Third door

The HTTP API

The method ships three ways, and they are the same method. The Evaluation edition runs it offline from a zip. The MCP server runs it inside the chatbot you already use. This runs it over ordinary HTTP JSON — for a CI job, a backend, a script, anything with no agent in the loop.

Nothing here is a second product. The endpoint calls the identical 17 tool handlers the MCP server advertises: the same procedure, the same conformance rules, the same hands-off boundaries, the same key and meter. The reasoning is still yours — this server never calls a model. Read the method itself in the user's manual — the single source of truth for all four doors. In TypeScript, reach for the published client rather than writing these calls yourself: same tools, with the types, the tiers and the run's bookkeeping already in the package.

The contract

Endpoints: GET https://shpbl.com/api/public/v1 for the descriptor (name, version, instructions, tools), GET https://shpbl.com/api/public/v1/tools for the list, POST https://shpbl.com/api/public/v1/tools/{tool} to run one.
Auth: None for the free lane. A Practitioner key travels as `Authorization: Bearer shpbl_mcp_…`, or as `key` in the body — the same key, the same meter, the same register as the MCP doors.
Response: `{ tool, ok, content, structuredContent? }`. `content` is the tool's own text, verbatim. A refusal returns 422 with the tool's wording and its `Next step:` line; bad arguments return 400 with the failing field.
Pacing: 120 calls a minute per address on the transport, plus each tool's own metering underneath. A throttled call is refused before any work starts and charges nothing.
Recorded: Every call lands in the same register the MCP doors write to, so an API run is metered and recorded exactly like an agent run.

Four calls, in order

1 · Read the tool list

curl https://shpbl.com/api/public/v1/tools

2 · Audit, free, no key

curl -X POST https://shpbl.com/api/public/v1/tools/evaluate_repo \
  -H 'content-type: application/json' \
  -d '{ "repo": "owner/name" }'

3 · Search the library, keyed

curl -X POST https://shpbl.com/api/public/v1/tools/library_search \
  -H 'content-type: application/json' \
  -H 'Authorization: Bearer shpbl_mcp_YOUR_KEY' \
  -d '{ "scope": "catalog", "query": "idempotent webhook receiver" }'

4 · Walk a run from code

const call = async (tool, args) => {
  const res = await fetch("https://shpbl.com/api/public/v1/tools/" + tool, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      // Omit for the free lane. Same key as the MCP endpoints.
      Authorization: "Bearer " + process.env.SHPBL_KEY,
    },
    body: JSON.stringify(args),
  });
  return res.json(); // { tool, ok, content, structuredContent? }
};

// The conductor walks one step per call, exactly as it does over MCP.
const card = await call("run_gauntlet", { repo: "owner/name" });
const step1 = await call("run_gauntlet", { repo: "owner/name", step: 1 });

One step per call, in the order the tool returns them — the procedure is enforced on the server, not suggested. `run_gauntlet` still refuses step 2 and beyond without the `ledger_digest` from the step before it, and still pauses for a human acknowledgement on its checkpoints. An API caller is held to the same discipline as an agent.

The 17 tools

POST /tools/…	Lane	What it returns
welcome	free	This orientation: the tool menu, the example commands, and where the manual lives.
list_repos	free	Real repository names — yours, an owner's public ones, or everything a token can see — and whether a pull request may be opened there.
method_protocol	free	The whole discipline in words: how an audit, a repair and a harvest are conducted. Fetched once, cached, so later calls carry source instead of instructions.
run_contract	free	The canonical twelve steps as machine-readable authority: what each step must produce, the precedence, the two ways a run may land — and, given a run's files, the same pass/fail verdict the offline gate returns. Read it instead of inferring a step.
pin_source	free	Step one, pinned: one source digest over a GitHub tree, a directory or a repository ZIP, computed the same way every time, so a connected run and a fully offline run agree on exactly which bytes were audited.
evaluate_repo	free	The audit: a repeatable survey, every capability found with its file and line, a benchmark against the audited corpus, and the library rows that already cover what the repo does.
fix_repo	free	Verbatim source of the files you name, plus the ordered remediation protocol, so your agent writes real diffs against real lines.
harvest_repo	free	The shortcut to the capabilities in a repository you are licensed to reuse: it reads what that repository already does, ranks named proposals against the owned capability library, stops for your decision on each one, then hands back the seed modules for the ones you approved. It never writes to the target. A free call reports the reading and how much is offerable, then stops at the composition boundary.
compose_capability	$39/mo	The harvest lane, and the point of the instrument: what your software already does, fused with owned SHPBL primitive capabilities — DREAM, EVOLUTION, MEMORY, DEFENSE, BRAIN and the rest of the canonical forty — returned as Capability Grants with the bound bodies, their class and ports, a seed module, the wiring, the verification and the limits. Your agent writes the repository-specific code.
build_intent	free	The gate between finding something and building it: register what the harvest proposes and the server returns the licence verdict, the invariants it passed, and — where you are entitled — the order to write the software and its tests.
run_gauntlet	$39/mo	The full conductor: audit, repair, harvest, library comparison, composition, verification and write-back from one tool, one step per turn. Requires Practitioner.
library_index	free	What SHPBL publishes: editions and prices, the seven strategy volumes, the public downloads, the case studies of real runs.
selfcheck_mcp	free	SHPBL's own audit, run against this live server, one pass or fail per verification axis. We hold ourselves to the method we sell.
subscription_status	free	The lanes, the prices, which tools meter, and — if you hold a key — this month's usage.
library_search	$39/mo	The capability library as cited rows: the engineered catalog and the capability units, searched in plain words before you write anything new.
library_document	$39/mo	One long document read paged: a strategy volume in full, the catalog outline, the report template, the standing order.
write_to_repo	$39/mo	The result kept: repairs, ledgers and reports landed on a branch as a pull request for a human to merge. Never a push to the default branch.

The free lane provides the repository evaluation and stops at the composition boundary: no library search, no candidates, nothing kept, and no full gauntlet. A Practitioner key at $39 a month runs the full sequence — both libraries searched, new capability composed and verified, and the result written back into your own repository — take a key. Questions, ideas or a story about what it found: dev@KESJr.com.

What every API run has to clear

01
Verdict
The evaluation is on paper before anything is written.
02
Your approval
Per proposal — approved, declined or deferred. Silence is never approval.
03
Build intent
Signed, single-use and expiring. Without it the foundry refuses.
04
Verification
The composed result is proven in the architecture it entered.
05
The gate
Cleared work arrives as a branch and a pull request you read first.

Six facets, one crystal

Every colour on this site is one of the six lit facets of the mark, and each facet owns one concern of the run. Nothing is tinted for variety.

01 · harvestReading what is already thereIt reads what is already in your repository and lifts out the parts that solved something real, with provenance. Everything else is left exactly where it sits.
02 · evaluateVerdict before repairEvery finding is tagged and located — defect, missing dependency, performance risk — and nothing is written until the verdict is on paper.
03 · composeParts into wholesVerified parts are composed into higher-order capability instead of being rewritten from scratch, and composites are counted separately from candidates.
04 · libraryOn the shelf, not in a chat logEach kept capability lands on a shelf with a name, a citation and a licence, readable by the next agent that opens the repository. Chat logs are not a library.
05 · repairThe right part in the right placeApproved repairs fit verified components into the broken structure, then prove the result before anything is allowed to move.
06 · shipNothing moves unauthorisedWrite-back is authorised, single-use and expiring: a signed build intent or nothing moves, and what clears the gate arrives as a pull request you can read.

Keep reading

Where to go next

Agent access — the MCP server
The same tools inside Claude, ChatGPT, Cursor or Codex, plus where keys come from.
The user's manual
The method itself: what each tool does, what to say, and how a run is conducted.
The Evaluation edition
Run the identical method offline, from a downloadable zip.
Audited runs
Six real repository runs, with the verdict each one produced.
SHPBL — own software again
The whole picture in one page: what the Master Library Set is, what $499 buys, and why one purchase ships software twice.