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 (Phoenix-13 hooks).
CoalFace	Active Front	Beta	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	🔵 Blueprint	A memory-defragment engine (the 6th sibling, in design): cleans + compacts an agent's persistent memory — notes and governance — under a hard zero-fact-loss guarantee (a code-core scout → gate → atomic-apply pipeline, with a 2-agent outsider+insider judgment and human-gated deletes). Cross-agent. Spec in design; build deferred.
CoalLedger	Records	🔵 Blueprint	A docs-health canary suite (the 7th sibling, in design): the docs-side mirror of CoalMine's code canaries — grounding (docs match their source-of-truth), completeness, rot, consistency, structure (AST rendering-fidelity), quality (incl. language mechanics), + an optional leak check. Cross-agent + multilingual; the engine reuses CoalMine. Spec in design; build deferred.
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 5)
node colliery-install.mjs 3         # just CoalBoard
node colliery-install.mjs 1 2 3     # CoalMine + CoalTipple + CoalBoard
node colliery-install.mjs 4 5       # CoalHearth + CoalFace (CoalFace 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, and CoalFace run on any concurrent-subagent agent (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 — every knob a user might reasonably change lives in a .<tool>.json file (project overrides global); 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. 🔦