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) that equip 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, 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 — plus an advisory near-limit budget nudge. Reduces the work lost to a session limit (it does not prevent one). Claude Code + Antigravity 2.0 (wired) — 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 (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 for agent class-B memory (memory + governance files) — cleans the FAT, never the MEAT: a code-enforced zero-fact-loss fidelity gate, 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. 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) over 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. 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. Full tables, tested versions, + caveats live in each tool's benchmark docs (the single source of truth, never duplicated):

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 — CoalMine, CoalBoard, CoalFace, CoalWash, and CoalLedger are cross-agent (CoalMine/CoalLedger read + analyze anywhere; CoalBoard/CoalFace need a concurrent-subagent platform — Claude Code, Antigravity, Cursor, Codex, Cline, …). Validated on Claude Code; CoalBoard is also validated on Antigravity (2026-06-22); every other platform is design-supported (re-verify subagent support on yours). (CoalTipple and CoalHearth are the deliberate exceptions, Claude Code only — CoalTipple's model/effort routing only actuates where an agent can pick a spawned worker's model; CoalHearth's warm-resume runs on Claude Code hooks.)
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: Adaptive freshness checks, signature validation, and secure credential handling.
5. 🔌 Single Power Button: Absolute minimal setup — a single command installs and runs the conductor.

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. 🔦