Quality tooling for AI coding agents — mined, sorted, and shipped.

A colliery is the complete coal mining operation: the mine, the tipple, and the workspace that turns a raw underground seam into clean, burning fuel.

TheColliery is a series of small, sharp, offline-first tools designed to keep AI coding agents honest, secure, and blazing fast. We build the infrastructure that helps agents execute safely, coordinate concurrently, and optimize their token budgets without sacrificing quality.

The Colliery structures its tools by the processing stages of raw digital coal:

Project	Stage	Status	Concept
CoalMine	Extraction	Live	Nine quality-canary skills (code-health, grounding, supply-chain, resilience, observability, testability, scaling, drift, completeness) plus the auto-cadence hooks that run them unprompted at session start and session end, equipping agents for raw, safe code extraction.
CoalTipple	Sorting	Live	A model/effort router: delegation (down, to save tokens) and escalation (up, for quality), a qualityBar staircase, and a fail-safe model-ranking Lock. Claude Code only — routing actuates only where an agent can pick a spawned worker's model + effort (built and validated across the 2.1.x line).
CoalBoard	Governance	Live	A consensus & debate board: on an error-not-allowed task — or any hard problem worth several lenses — with consent, diverse epistemic lenses (empirical/source-grounded · formal · a show-me skeptic) debate in parallel — either verifying new work before it ships (Generate) or reporting on existing work (Audit/Review) — a judge synthesizes on VERIFIED inputs, an independent solver breaks ties, and the human signs off. Bounded cost + zero-breakage. Cross-agent — validated on Claude Code + Antigravity; other concurrent-subagent platforms design-supported.
CoalHearth	Session Storage	Live	A session warm-resume engine: a hook journals session state every step, so an interrupted session resumes from a recovery block instead of a manual rebuild. Reduces the work lost to a session limit (it does not prevent one). Claude Code (validated) + 6 wired ports (Antigravity, Gemini CLI, Copilot CLI, Devin CLI, Kiro, Augment) — Phoenix-13 hooks.
CoalFace	Active Front	Live	The fan-out discipline: a mandatory scout sizes the swarm, workers return anchor-edit orders as text, one writer applies behind a snapshot + QC + domain gate, and the whole run is bounded by the estimated solo $-cost, never a token bound (raw tokens run higher; bandwidth dial with TCP-style backoff). Disciplines the fan-outs an agent would already do — it does not make models smarter.
CoalWash	Washing	RC	A memory washer/defragmenter with two lanes and two different contracts. Class-B — the context you load every session (memory + governance files): cleans the FAT, never the MEAT, under a code-enforced fidelity gate proving zero structured-token loss by diff, with plan-sourced deletes made safe by UNDO (verified snapshot + WAL + whole-run rollback, not pre-approval; pinned files untouchable), and a session-start gauge whose FULL band force-runs the free mechanical pass on a deterministic break-even proof with the numbers shown. Class-A — the at-rest estate on disk (transcripts and tool results): never semantic-edited at all — they are vendor-owned and machine-parsed, so the guarantee is byte-identity, copy-verify-then-delete with a round-trip restore. The estate lane runs only when you choose it in the wizard — never on a band, never ambient, because disk is not context. Cross-agent design (Claude Code validated).
CoalLedger	Records	Beta	A docs-health canary suite — CoalMine for documentation: 6+1 canaries (wrong · incomplete · stale · contradictory · broken · unreadable · + config-gated leaked), with doc-structure detecting through a vendored zero-dep CommonMark+GFM AST engine (things that render fine are never flagged). Severity judged by context, never a fixed map; fixes choice-gated, never auto-applied; correctness escalates to CoalBoard. Plus a quiet docs memory-drift reminder — not a canary — when docs change but MEMORY.md does not. Cross-agent + multilingual.
CoalPortal	Gateway	⚫ Reserve	A remote web-to-CLI gateway (an idea held on the shelf): drive a local session from a phone. Superseded by first-party Claude Code Remote Control (/rc) and cut before build — kept as a reserve concept for a narrow air-gapped / zero-trust niche /rc may not serve. Whether it revives is undecided — a plan on record, not an active build.

Each tool installs on its own, or grab them together — like choosing DLC on a store page: take the whole pack, or just the pieces you want.

One-step selector (needs node + git on PATH; the claude CLI for the plugins):

curl -fsSL https://raw.githubusercontent.com/TheColliery/.github/main/install.mjs -o colliery-install.mjs
node colliery-install.mjs all       # the whole suite (all 7)
node colliery-install.mjs 3         # just CoalBoard
node colliery-install.mjs 1 2 3     # CoalMine + CoalTipple + CoalBoard
node colliery-install.mjs 6 7      # CoalWash + CoalLedger (beta)
node colliery-install.mjs coalmine  # by name, too

Or install each tool directly — each repo's README has the authoritative, always-current steps:

Headline results — small, dated samples curated here, each stamped with the date + tested version it was measured on; the full tables, method, and caveats live in each tool's benchmark record (the single source of truth):

See the benchmark records.

Every tool inside TheColliery is governed by our core constitution — the full doctrine spells out every Phoenix-13 and Quantum-11 point. The lines below are one-line digests:

1. 🌐 Works in Every Mine (Cross-Agent): Vendor-agnostic by design, and each tool says exactly how far it has been taken — no blanket claim covers them all.

   Tool	Beyond Claude Code (all are validated on Claude Code)
   CoalMine	Validated on Antigravity — canaries validated, auto-cadence hooks wired. Reads + analyzes anywhere.
   CoalBoard	Validated on Antigravity (2026-06-22). Needs a concurrent-subagent platform.
   CoalHearth	Wired on Antigravity, Gemini CLI, Copilot CLI, Devin CLI, Kiro and Augment — built + hermetically tested, live-validation pending. Runs wherever a lifecycle-hook engine exists.
   CoalWash	Manual on every non-Claude-Code platform — the documented file-copy install, designed-degrade-safe, not yet run there.
   CoalLedger	Manual, same shape. Reads + analyzes anywhere, except doc-structure, which runs its bundled zero-dep engine (Node only — no install, no network).
   CoalFace	Design-supported — needs a concurrent-subagent platform; re-verify subagent support on yours.
   CoalTipple	Claude Code only, by capability — model/effort routing actuates only where an agent can pick a spawned worker's model + effort, so there is nothing to degrade to elsewhere.

   Wired = built and hermetically tested, not yet run live. Manual = a documented install path that works, not merely a design intent. Neither is a validated claim, and neither is a promise.

2. 🦅 Phoenix 13 Compliance: Immortal hooks, all 13 commandments — fail-silent · zero-dependency · zero-latency · zero-garbage · zero-side-effects · stateless · offline · deterministic · portable · sandboxed · future-proof · self-healing · zero-noise.

3. 🔬 Quantum 11 Performance: All 11 principles — maximum output · zero visible errors · single brand · minimum power + consent · essential accessories · error correction · determinism · isolation · measurement · trust · entanglement.

4. 🛡️ Antivirus/ESET Heuristics: Heuristic detection plus definition-freshness stamps (revalidate dates) and consent-gated updates — never a silent one.

5. 🔌 Single Power Button: Absolute minimal setup — a single command installs and runs the conductor.

🔑 Least-power, in one place: the Permission Matrix lists the minimum capability each tool requests — and the rights it deliberately never asks for, proven absent rather than merely unused.

Beyond the doctrine, each tool is built like a proper program — it ships the same five standard systems, so any tool feels familiar the moment you open it (the full doctrine has the detail):

1. ⚙️ Config — two levels: a global ~/.claude/.<tool>.json plus a per-project .<tool>.json override (project wins). Install a tool globally, then re-tune — or shut it off entirely — per project: a skill you don't need in a given project stops loading (and burning tokens) there. Schema-validated, range-clamped; nothing load-bearing is hard-coded out of reach.
2. 🌍 Language — output auto-detects the conversation's language (English is the always-safe fallback — zero setup) and can be locked via config. Prose is translated; technical terms — commands, paths, identifiers, config keys, model/tier/severity names — are kept verbatim (a translated command is a broken command).
3. 🔄 Self-Update — a tool checks for and applies its own updates (consent-gated, offline-graceful), and every version transition leaves no old-version leftover — stale caches and renamed files are swept, never abandoned.
4. 🐛 Problem-Report — one command offers to file an issue upstream, with any memory content scrubbed first; nothing is ever submitted without your say-so.
5. 📊 Measurement — a /stats command shows what the tool actually did and what it was worth — tokens saved, issues caught, or fidelity preserved; a quality tool should prove its own impact.

More tools and skills are still deep underground. 🔦