SHPBL: Repository Audit & Repair MCP Server

Read one long SHPBL document, paged for a context window: `volume` (the complete text of a volume of The Strategic Master Library), `catalog_outline` (the Collective catalog's parts, component classes, agent-kit steps and verification axes), `report_template` (the branded audit report HTML to fill in), or `standing_order` (the prompt that governs a run). Requires a Practitioner key.

Everything published on shpbl.com in one read: the editions and their prices and licences, the seven volumes of The Strategic Master Library with their seals and read links, the public downloads with byte sizes, and the case studies of real audit runs with each verdict, and `pools` — the canonical reconciliation of every count this server quotes, so two totals are never mistaken for a contradiction and never added together. Scope it with `sections`, or pass `volume` (slug or 1-7) or `case_study` (slug) for one record in full. Free — no key, no allowance.

Search the Collective Master Library for a capability in plain words, before writing new code. `scope: "catalog"` (Practitioner) searches the engineered components — class, what each does, API surface, line counts, verification marks. `scope: "composites"` searches capabilities earlier runs invented for one host by fusing library parts, each citing its sealed report. Pass `ids` for whole rows by component ID, with siblings and declared twins. Multi-word queries match term by term and rank; with no exact hit you get the closest rows, labelled as such.

The gate between discovery and creation, and the human checkpoint in front of it. Register one Build Intent — what you found in the host, what SHPBL already possesses, what new software becomes possible, why neither parent does it alone, and the tests that would prove it — and this returns the mechanical verdict: the invariants it passed, whether it rests on SHPBL's licensed reusable capability, whether this caller may execute the foundry, the terminal state to report, and where an authorised artifact may come to rest. THE CHECKPOINT BLOCKS: without `human_decision` carrying an attributed decision from the person, this returns the proposal in the words to say to them and nothing else — no verdict, no read, no record — and you end your turn and wait. No answer yet is NOT_YET_ASKED, never DECLINED. A decision attributed to you, to a model, to a policy or to a default is refused where the server can recognise it as such; any other name is recorded and attributed, not verified, and the authorization says which — `account` when the name matches the key's account holder, `attested` otherwise. DECLINED and NEEDS_EXPLANATION are successful outcomes: record them, build the approved siblings, and do not report a declined proposal as a failed step. Free to call at every level. Every COMPOSE, SPECIALIZE and CREATE must pass through this before any source is written; never assume authority and never write a refused artifact yourself.

The harvest lane: read what a repository can already do, then offer codeless capability nominations that fuse those affordances with owned SHPBL primitive capabilities — DREAM, EVOLUTION, MEMORY, DEFENSE, BRAIN and the rest of the canonical forty, plus the S-Tier artifacts. Each nomination names host evidence, proposed capability bodies, Capability Contract slots, a test plan, and honest limits. It contains no implementation; approved materialization belongs to `harvest_repo`. Free calls return host affordances, then stop before library correlation; nominations require a Practitioner key (7-day free trial).

Read the canonical twelve-step run contract, or check a run bundle against it. Call it with no `files` to get the contract itself: every step's id, the artifacts it must produce, the exact condition that closes it, the terminal word to report when it does not, the instruction-precedence order, the retention rule and the two legal ends of step 12. Call it with `files` — a map of run-folder paths to their text — to get the machine verdict: which step blocked, which predicate refused and why. This is the identical implementation the offline `tools/run-gate.mjs` in every edition is bundled from, so the two cannot disagree about whether a bundle satisfies the contract. What they do not share is evidence: the offline gate checks the bundle you hand it, while a connected run can also confirm against the real repository tree that the files cited exist and say what the bundle claims. Same rules, one with a witness. Free, unmetered, read-only, stateless. Never infer a step, reorder one, or declare a run finished on your own reading — run the gate and report its word.

Audit any GitHub repository and get back one complete result: a report (inventory, languages, spine files, risk signals), the capabilities found in it (name, signature, file and line, stated contract, dependencies), and how it stands against SHPBL's anonymous corpus of audited repositories. Works with no key: every caller gets the whole diagnosis of their own repository. A free run stops at the composition boundary — neither library is searched, so no library rows, candidates, parents or proposed architecture are returned — and nothing is retained (no pull request, no export, no recorded run). A Practitioner key (7-day free trial) continues past that boundary: both libraries searched, candidates identified and composed, and the result written back to your own repository. Whatever a run finds is yours. Follow with `fix_repo` for verbatim source and diffs, `harvest_repo` for the whole tree.

The repair: verbatim source of the files you name — or the repository's spine when you name none — paginated for your context window, with the remediation protocol your model writes the diffs against. Free to run with no key: every file you name, paginated, plus the ordered remediation protocol — repair of what is already there. A free repair stops before either library is searched, so it proposes no composed capability, no candidates and no reuse. A Practitioner key (7-day free trial) crosses that boundary and makes the repair persist — `write_to_repo` opens the branch and the pull request.

One runner for an entire SHPBL repository audit and repair: survey, opening library comparison, evaluation, repair, the batched harvest, closing library comparison, the branded HTML report, and the write-back path. STRICT SEQUENCE: call it once with no `step` for the run card, then `step: 1`, `step: 2`, one step per turn, in order. Do the returned step, report one line to the person, then call the next. Never call two steps in one turn, never attempt the whole run at once, and never infer a finding you were not handed. From `step: 2` on you must pass `ledger_digest`; every 3 steps (adjustable with `checkpoint_interval`, max 10, only when the person asks for fewer pauses) the run pauses and you must ask the person before continuing, then pass `continue_ack: "continue"`. The final step hands over the report template and the write-back path. Your own model does all reading and writing. This full conductor requires a Practitioner key (7-day free trial). The free lane provides repository evaluation, not a partial or full gauntlet.

The harvest shortcut: point it at a repository you hold a licence to reuse — one you do not own and will never open a pull request against — and it goes straight to the capabilities. It reads what that repository can already do, fuses those affordances with the owned SHPBL capability library, ranks and names the results as proposals a person can read, stops for your decision on each one, and then emits the seed modules for exactly the ones you approved into your own `.shpbl/` library. That is the gauntlet's steps 8, 9 and 10 without the audit, the repair plan or the pull request. It never writes to the target repository. Pass `approve` with `approved_by` and `host_license` to collect the approved grants; pass `mode: "walk"` for the older batched ledger walk of the whole tree (`estimate`, `part`, `ledger_digest`, `budget` belong to that mode). Free calls report what the repository can do and what is offerable against it, then stop at the composition boundary; grants need a Practitioner key (7-day free trial).

Return the SHPBL disciplines verbatim — evaluation, remediation and harvest — plus the component classes' verification axes and the reporting style. Free and unmetered. Fetch it once, then call `fix_repo` or `harvest_repo` with `brief: true` so their payload is source rather than repeated instructions.

Build `HOST-SOURCE-MANIFEST.json` for canonical step 1 from a GitHub repository, online, with no clone and no download: every file's Git blob identity, the byte length, the head commit, and the `SHPBL-SOURCE-DIGEST/1` digest over the pinned tree. Write the returned JSON to your run folder as `HOST-SOURCE-MANIFEST.json` and step 1 passes the gate. Free and unmetered. If the run is offline instead, do not call this — run `node tools/source-manifest.mjs <repo-dir|repo.zip>` from the edition, which produces the same manifest from a directory or straight out of the repository ZIP. Never invent the digest or the commit.

Land finished work in a repository as a pull request: pass the files you wrote (full new contents, not diffs) and this opens a branch and a PR for the human to review and merge. Nothing is ever pushed to the default branch. Requires a SHPBL Practitioner key and the SHPBL GitHub App installed on that repository (or a one-off `github_token`). The caller chooses the repository — ask which one, or call `list_repos` first; never assume. Where things go: Harvest output belongs under `.shpbl/` in **the caller's own repository** — the person who asked for the run — and never in the repository that was harvested. Those are frequently not the same repository: a run may read a public open-source project, or a repository the caller merely has access to, and writing a harvest back into a source repository would be putting our output into somebody else's software. Sources a run may read: public repositories that carry a proper open-source license, the caller's own repositories, or private repositories the caller has access to. The server never reads a repository the caller has no right to read, and it never absorbs customer harvests back into the public library. - `.shpbl/README.md` — the index of their capability library (this tool scaffolds it when it is absent). - `.shpbl/<run-seal>/LEDGER.md` — the folded ledger for one run. - `.shpbl/<run-seal>/REPORT.html` — the branded report, if one was produced. - `.shpbl/<capability-name>/` — a capability kept as source, one folder each. - `.shpbl/COMPOSITES.md` — your own composites: capabilities this run invented for your repository by fusing parts that did nothing alone. Record each as `- <name> — <what it fuses> — <why neither part sufficed>`. These are yours and stay private; SHPBL's global composites ledger is fed only by Governor-keyed published runs, so never send yours anywhere and never expect them to appear there. If the harvested repository is not the caller's own, the harvest still lands in the caller's `.shpbl/` and the source is named in provenance. Ask the person which of their repositories is the home for their library if it is not obvious, and stop for that answer rather than guessing. Give each kept capability a one-line contract in `.shpbl/README.md`, in the form `- <name> — <path> — <contract>`. That index is what makes the library reusable: on the next run, read it and pass those entries as `own_library` to `evaluate_repo`, `fix_repo` or `run_gauntlet`, and the run will tell you which concerns you already solved before citing anything new. Those entries stay yours — they are held for the call and never stored by SHPBL. Repairs are the exception: write the repaired file at its own path, never under `.shpbl/`.

Lists real repository names so a run never starts on a guessed one, and answers whether a repository can be written to. Pass `github_token` to see everything that token can see, or `owner` to list a public account's repositories; with neither, it lists the repositories the SHPBL GitHub App is installed on for this key — the same ones a pull request can be opened on. Pass `repo: "owner/name"` to ask about one target instead of reading the whole list. Free — costs no allowance.

Runs SHPBL's own audit against the running server and returns one pass/fail/unavailable line per verification axis: the registered tool surface against the priced tier table, version agreement across the published files, subscription-register reachability, catalog reachability, repository-write authority, and billing wiring. Free, unmetered, read-only — nothing is written and no model is called. Use it to prove the server is live and consistent before starting a run, or when a tool answered in a way that looks wrong.

Report the tiers of this MCP server and — from the `key` argument or the same `Authorization` header the gated tools read — that key's tier, status and month-to-date usage. This is the authoritative answer to "am I connected, and what do I have".

Call this first, once, when a person connects. Returns the welcome, the full tool menu with one line per tool, the exact sentences a person can say to start a run, the support address, and the link to the user's manual. Free, unmetered, no key. Read it to the person in your own words — warmly and briefly — then ask what they would like to point it at.