# The Ratchet Loop

**A build loop where the champion only moves on a blind win.**

Version 4.5 · Method spec · Free to copy

**4.5 makes every rule a run reads executable on the CLIs of October 2026, and changes no
promotion arithmetic.** It came from six independent reviewers reading 4.4 as a run would, with
live probes of grok 1.0.50 (Claude Code 2.1.241 was checked offline only). One waiting rule:
collect one child per call in a loop, each wait bounded by the sooner of ten minutes or that child's
deadline, a `workbench.md` line after every return, and no turn ended while a child is open (§5.4)
— the shape the only completed 4.0 run used without a hang, and the one Relay's stop gate allows.
No hand-back on an unread spend or a missing wake-up (§11, §12). One sealed targeting rule,
`SEAL_ROOT` and `SEAL_URL` on the invocation, applied once the candidate's SHA resolves in the
main repository (§6). The calibration control has a source: a candidate round 0 discarded, pinned
under `refs/gauntlet/controls/` (§7.1). A judge's id is its calibration spawn's id, with
`liveSessionId` for a resumed child that comes back under a new id, and family means vendor:
where a harness offers three or more vendors, neither judge vendor is the builder's (§7.2). A
derived criterion list survives a death in round 0 (§12.2), and the ending list is one list (§12).
A round cap no longer selects a tier. The run reads `PROMPT.md`; this document is the manual, and
the adjudicator's schema ships as `run-kit/panel.example.json`. Cost multiples are estimates from
what a round spawns, not measurements (§14.1). Start a fresh lineage; finish 4.4 lineages under
their own kit (on grok 1.0.50, with `PATCH-4.4-GROK.md` applied). A second, fresh read added a round of repairs to the same release: run files gitignored and one
scratch directory; Claude's not-in-turn wait with its own `CronCreate` alarm (a foreground sleep is
refused there); a kit-absent check in the window check; who writes a sentence's harness; one A/B
labelling convention; a `two-model` panel; `HEAD` per piece; and the objective's completion
including the run's own integrity-fault or SETUP stop. None of this is evidence that
the method builds better artifacts than the Gauntlet.

**4.4 changes promotion evidence, not the standard of a running loop. Start a fresh lineage;
finish older lineages under their original kit.** Both upper tiers now require strict challenger
support in both presentation orders, with an explicitly authorized missing seat for a three-judge
quorum. The kit's pure `adjudicate.mjs` validates supplied records and computes the verdict;
it neither authenticates evidence nor moves champions. Calibration uses independent task-matched
examples containing neither live candidate. Normalisation preserves evaluated properties, every
criterion keeps its observation points, and evidence may be a trace or measurement rather than a
screenshot. Coherence follows a completed scheduling sweep, including losses. These are safety and
evidence repairs, not comparative proof of better artifacts on Grok Build or Claude Code.

*4.3 is what four independent verifiers, run on a different model from the one that wrote 4.2, found
when they read it as a run would. The largest: **the phase order appended the ledger line before the
coherence pass could write on it** — promote is the phase that appends, so coherence now runs after
the critique and before promote, and `wall_ms` follows (§5.3, §5.5, §13). The Duel — the default
tier, and the one that had received the fewest of 4.2's repairs — gains the ON STARTUP rule and the
RESUME block its own hand-off lines already told a resumed run to read, a round 0, the builder's
four-item spawn text and run-and-capture contract, the two-judge no-pack selection rule, and a ledger
example whose fields agree with its prose. Gate 1's "before any judge" is scoped to round 1 on,
because round 0's suite reads a `run.json` that does not exist until round 0 has picked something
(§6). A reopened parked gap starts its count again (§12). `bar_pick` is a string when blind and an
object when not (§5.3a). The Claude kit gains a spend reading — a statusLine command writing the
session's cost to `gauntlet/cost.json` — because the ledger's `cost` field had no source on that
harness (§13, §14.1). And two things the kit told a run to do that nothing in the kit supported are
now supported: `SEAL_URL` is read by every sealed body (§8.1), and the round-0 markers the sealed
README promised are emitted.*

*4.2 is what four reads of the shipped 4.1 turned up: an adversarial read of the composed prompt as
a run would read it, the first 4.0 run's own transcript, a desk-run of the Claude kit on the machine
these runs happen on, and a fidelity check of the Gauntlet tier against Shumer's three published
texts. **The builder was the only agent that changed the artifact and the only one that never saw
the standard** — §5.0 now writes the gap, the criteria that bear on it verbatim, the failing
measurement and the bar's own files into every builder's spawn text, and a builder returns on a
capture it drove and compared rather than on a commit. Gate 1 moved to the only place its own
sentence was ever true: **every material candidate, immediately after the build, before any judge
sees any of them** (§6). The critique moved to the end of the round and onto the **champion** (§5.3),
so the phase order became build, gate1, selection, gate2, critique, promote, coherence, and
`wall_ms` followed it (4.3 moved coherence before promote; see above). The critic goes **all the way through** the artifact before it names anything,
its two slates have to be the same kind of thing or the blinding is decoration, and `bar_pick` —
written every round and read by nothing — steers (§5.3a). Gap attempts are counted on the ledger
rather than in a context that ends at the next compaction (§12), and the budget lever is rounds
rather than judges (§14.1). §2 is corrected in both directions where this method had been claiming
one of his rules as its own and one of its own as his.*

*4.0 is the survival release, and it comes from reading the fleet rather than the method. Seven
real multi-day runs of this tool — one brief, three tiers, two models, and every one of them, as it
turned out, inside the same CLI — ended in two shapes. Three died the same way: the orchestrator
spawned its judges or critics, waited on all of them at once, one never came back, and the run sat
for most of a day burning tokens at the healthy rate while doing nothing. The two that survived had
each invented the same rule on their own — **if a judge hangs, proceed with the seated ones; that is
not a stop** — and nothing in this document had told them to. §5.4 is that rule, with a deadline the
run can compute and a fallback for every role, so that no death of a child is ever a question. §7.2
gains the quorum that makes a three-seat panel honest. Tier had no explanatory power over which runs
lived; harness survival was upstream of everything else this document measures.*

*Three more things the Gauntlet had and this method had lost, taken back: the coherence pass runs
between waves as well as at the end (§5.5), the progress page the owner watches ships in every tier
(§12.4), and the instrument is held to the same standard as the judge — a capture that did not show
the thing decides nothing (§5.3). Two Gauntlet properties are deliberately not claimed: this method
runs one piece-round at a time, because one HEAD, one `run.json` and one child cap make parallel
pieces a race (§5), and it has no word for finishing, because the runs that had one used it (§12).
These observations motivate the survival and evidence rules; they do not establish superiority.
The one controlled artifact comparison was lost (§14.3), and no comparable result on both Grok
Build and Claude Code establishes a better outcome.*

*And a reconciliation. An audit read the composed prompt against the kit it ships with and found
fourteen instructions a run could not follow — a `.gitignore` line for a path nobody named, a
`run.json` key that does not exist, a delete the shipped hook denies for every caller — and eleven
places two documents a run holds at once gave different rules. All are fixed; §10 and §11 now defer
to the kit's own context file for the hook's rules rather than paraphrasing them, because the
paraphrase was wrong in four places. The harvest (old §8.0) is cut, on cost. Every harness fact the
prompt asserts was re-verified against the shipped documentation of both CLIs, and the ones that
were wrong — the multi-id wait, the concurrency cap, the model parameter, the base-ref values, the
model precedence — are corrected in the harness sections of the prompt and recorded in the
project's verification file.*

> **3.0 is a breaking change, and a run started under 2.x must finish under 2.x.** A kit is
> self-contained: handing a running lineage a smaller prompt creates two documents with different
> rules claiming one run, and the ledger cannot say which of them a round was adjudicated against.
> Version-gate it. Finish under the spec you started under, and start a new lineage under 3.0.

*3.0 deletes about four fifths of this method, on measurements this document has been publishing
against itself since 1.9. **The regression suite is gone.** §14 said "spend on the duel before you
spend on the ratchet — the regression suite has yet to catch anything" from version 1.9 onward, and
the document then grew roughly a hundred thousand characters, nearly all of it into the half that
sentence says not to buy. The suite was given every chance to pay: six challengers and ten
mutation-validated checks in the one head-to-head anyone has run, then eight independently
re-measured round-to-round transitions across two lineages, one of them six rounds on a deliberately
coupled artifact with no regression protection at all. **Eight independently re-measured transitions plus six challenger gradings, zero observed
regressions, while the duel decided every promotion.** With Gate 1 goes everything downstream of it: mutation
admission and its five legs, narrowing, retirement, quarantine, burning, the redesign corridor,
scatter, the witness two-anchor rule, the GATE/HOLDOUT split, the criterion extension, the
`cut_defect` route and the WARDEN, which was the role that ran it.*

*Three more cuts, each for its own measured reason. **The derived sealed bar** — five repairs across
four revisions, four of its six measurements wrong, two of them actively harmful, and it never ran
in a paid round. **The decomposition test**, 8,300 characters written two days before the audit and
never exercised; what survives is the sentence that would have decided every case it decided — *if
it is unclear, one piece.* And **the terminal-state vocabulary**: CONVERGED, JAMMED, DEGRADING and
STALLED are deleted outright, because three wrong stops came out of them and none came from anywhere
else. §12 replaces them with one ending the run may declare — the human's cap — and the reason that
is safe rather than reckless: the champion is frozen by SHA with a ledger line every round, so **the
deliverable is complete at every round boundary**. A run killed mid-round-eleven ships what a run
that declared itself converged at eleven would ship.*

*And one addition, which the audit called the highest-expected-value edit available anywhere in the
product. Word counts across the three composed prompts found that **the most expensive tier did not
contain the Gauntlet Loop's most load-bearing instruction**: `harsh` appeared once in the cheapest
tier and zero times in the other two, and `inspect` did the same. Nothing told the critic to run the
artifact, and nothing set its severity. §5.3 now puts both into every tier, in the critic's spawn
text and in its contract, carrying the human's own goal verbatim so the bar the critic is harsh
about is theirs rather than a generic one.*

*What 3.0 keeps is what has a citation behind it: the blind calibrated duel (§7), which decided
every promotion in the head-to-head and drove one criterion from 1.65:1 to 8.53:1 where the plain
loop shipped 3.25:1; the champion, the append-only ledger and delivery by SHA (§13), which is the
one thing the plain Gauntlet structurally cannot do; coverage (§5.2), the only mechanism with a
cited artifact catch to its name; the human's own sealed scenario (§8.1), which held to four decimal
places every round of a real run; fan-out and materiality (§5.0); the harvest **trigger** (§8.0);
turn-ending (§12.3); and the RESUME block (§12.2).*

<details>
<summary>Version history before 3.0</summary>

*2.4 made the endings endings: seven of eight hand-backs became the loop finishing rather than
asking, the criterion list gained an extension route, two trust escalations were designed out and
one became a repair, and the handover became a RESUME block rewritten at every round boundary. 3.0
keeps the RESUME block and the turn-ending rule and deletes the rest — the extension mechanism was
never exercised by a run, and the escalations it repaired belonged to machinery that is now gone.*

*2.3 added the coupledness test; 3.0 keeps its one-sentence bias and drops the test. 2.2 added
turn-ending and the three admission passes. 2.1 defined what a round does when it cannot do the
normal thing — the no-gap route survives, shortened from five steps to three. 2.0 made the standard
unmovable: the criterion list is create-once and enforced by the boundary hook, which 3.0 keeps
unchanged. 1.9 split the method into tiers — Duel and Ratchet — on the finding that the duel did the
work and the suite did not; 3.0 is that finding carried to its conclusion. 1.8 recorded the
head-to-head this method lost, which is still in §14. 1.7 added the fan-out, the shared rubric, the
nine-item calibration pack and the escalation duel, all of which survive.*

</details>

---

## 1. What this is

The Ratchet Loop is the [Gauntlet Loop](https://somethingbig.ai/gauntlet-loop) with a memory.

The Gauntlet Loop — Matt Shumer's method — is: give an agent a goal and a *real bar it can inspect*,
let it split the work itself, and for every piece run a builder and a separate **harsh** critic with
fresh context that **inspects the real artifact** against the bar and names the single biggest
remaining gap. Loop until it wins or you stop it. That method is correct and this one keeps all of
it, including the two words in it that do the most work.

**The critic is deliberately fresh**, and the original method specifies no immutable champion
selection protocol. That is different from proving it always delivers the last or worst build.

> **The champion moves only on an eligible blind panel's win, with strict challenger support in
> both presentation orders. What you ship is the selected champion, by round id and commit SHA,
> not an unaccepted working tree. A majority is not proof that no criterion regressed.**

Versions 1.0 through 2.4 froze passed properties into re-runnable regression checks. **Eight
independently re-measured transitions and six separate challenger gradings found no regressions**;
the six gradings were not independent transition replays. The suite was removed on that limited
record, not on proof that long or coupled work cannot regress. §14 preserves the negative result.

**When to consider this rather than plain Gauntlet:** when explicit checkpoint selection and
resumable records matter enough to pay for them. Whether that produces better artifacts at equal
spend remains a comparative experiment, separately on Grok Build and Claude Code.

---

## 2. Honest prior art

The composition is not new either. Pretending otherwise would be the kind of unearned confidence
this method exists to prevent.

| Part | Where it comes from |
|---|---|
| Goal + inspectable bar, builder/harsh-critic split, blind A/B, no fixed round count | Matt Shumer, the Gauntlet Loop |
| The fan-out of sub-agents, the optional smoothing pass between waves, a live progress page, and keeping coupled things under one owner (§5.1) | Matt Shumer as well — the first three from the article and the prompt that built Claude of Duty, the fourth from that repo's README |
| Named / Fetchable / Comparable bar test | robonuggets' `gauntlet-loop` skill |
| Bar-discovery pass, held-out checks, non-negotiable criteria, smoothing | trilwu's `gauntlet-loop-skills` |
| Human gates that outrank the loop, fresh critic per retry | NicholasSpisak's `gauntlet-loop` |
| No helper scripts, capture harnesses, scoreboards or state files | duolahypercho's `gauntlet-loop` |
| Champion/challenger promotion, "ship the best checkpoint not the last" | standard eval & deployment practice |
| Commit-first (de-anchored) judging | reference-free judge reward-hacking work |
| Order-swapped presentation | LLM-judge position-bias literature |
| Sample many candidates, filter, keep one (§5.0) | repeated-sampling work: coverage rises log-linearly with samples, and the filter is the binding constraint |
| Panel diversity has to be in the models, not the presentation (§7.2) | the panel-of-judges literature: judges built alike share errors, so a same-family panel is worth fewer independent votes than its headcount (a specific figure this row used to quote had no source and is gone — §7.2) |
| Excluding the builder's own model from the panel (§7.2) | preference-leakage work: judges favour related models through style, invisibly to blinding |
| One shared rubric, grounded in real candidates (§7) | rubric-generation work: prompt-only rubrics scored *below* no rubric; response-grounded ones scored well above |
| Escalate a split rather than repeat the duel (§7.2) | position-bias work motivates avoiding repeated sampling of the same panel; no repetition rate is assumed here |
| A multi-item calibration pack (§7.1) | judge-reliability stress-testing: stability and sensitivity controls; the seating threshold is not an accuracy bound |

**Four rows of that table were wrong in one direction or the other until 4.2, and a fidelity check
against his three texts — the article, the prompt that built Claude of Duty, and that repo's README,
all fetched and archived on 2026-09-02 — settled each of them.** *His, and it had been labelled
ours:* **keeping coupled things under one owner** (§5.1), which comes from the README's process note
and carries his own numbers — three rounds of six parallel agents, one per directory, moved the
score +0.46 and left frame-ruining defects *higher* than they started (60 → 47 → 66), against +1.00
and 66 → 26 for one sequential pass with a single owner per coupled concern. *Ours, and it had been
reading as
his:* **"a pick, never a score"** (§7), which neither the article nor the prompt says and his own run
did not follow — he picked *and* scored, 3.59 → 4.14 → 4.05 → 5.05 out of ten; **the ban on
scaffolding**, which is duolahypercho's and ours rather than his, since his repo *is* a harness;
**the progress page's specification** (§12.4), where his text says not to over-specify it; and
**delivering the best artifact rather than the last** (§13), which no text of his addresses. And one
sentence of ours had inverted his: the smoothing pass is **optional** in the article, so the tier
named after his method calls it optional too. This method still runs it every wave (§5.5) — that is
a choice of ours over his text and it is labelled as one, which is the whole of the difference. The
tier-by-tier record is
`docs/GAUNTLET-FIDELITY.md` in the project, mechanism by mechanism, with his text quoted beside
ours.

**What used to be new here was mutation-based admission of auto-generated regression checks.** It is
gone. It was this method's one genuinely novel idea and it never caught a defect in an artifact;
losing it costs the paper, not the artifact. That trade is stated rather than hidden because the
same honesty is what §14 is for.

**The tension you should know about.** The Gauntlet Loop community — duolahypercho most explicitly —
warns against scaffolding: "do not invent helper scripts, capture harnesses, blind-compare tools,
scoreboards, state files." The Ratchet Loop is still scaffolding, just far less of it. It is worth
it when you want a champion rather than a last round. Below that, run the plain Gauntlet Loop.

---

## 3. Roles

**Five**, each with a different context and a different job. No agent both proposes and ratifies.

- **ORCHESTRATOR** — owns the goal, the criterion list and the ledger. Decides the decomposition,
  routes verdicts, spawns everything, writes every file under `gauntlet/`. **Never builds the
  artifact. Never judges it.** May never modify the criterion list (§4.1).
- **BUILDER** — one piece, clean context, a real artifact, in its own worktree. May never declare
  PASS, may never modify the bar, may never see `gauntlet/`. **Three per round**, each taking a
  different direction at the same gap and none of them seeing the others (§5.0).
- **CRITIC** — fresh context every round, so it is never defending its own last verdict. **Harsh, and
  it inspects the rendered artifact rather than the builder's summary** (§5.3). Returns the single
  biggest remaining gap, a per-criterion PASS / FAIL / NOT-JUDGEABLE verdict with citations, and
  **the states it entered**, by id, with the evidence it got there (§5.2).
- **PREPARER** — builds both candidates from clean checkouts by SHA at identical settings, produces
  every capture, normalises presentation, strips provenance, hands out shuffled unlabelled slates.
  It builds; it never judges.
- **JUDGE** — fresh context, has built nothing and seen no checkout. **Four per duel**, two per
  presentation order, with resolved model provenance and any capability limitation explicit (§7.2).
  Reports entered states and evidence with its verdict, exactly as the critic does.

> **Why the duel needs two roles.** An agent that builds both candidates knows which is which — it
> just checked them out by SHA. Separating the hands that build from the eyes that judge is what
> makes "blind" true rather than nominal.

> **Calibration remains a measurement risk.** The preparer fixes and validates the independent
> examples and answer labels before judges see them (§7.1). Record that provenance; neither model
> diversity nor a recorded pass proves the examples discriminate at the live duel's difficulty.

*The WARDEN was the sixth role. It existed to run the loop's own regression suite and to hold the
check bodies away from every other context. With the suite gone there is nothing for it to run, and
a role with no job is a role a run will invent work for.*

---

## 4. The bar

Unchanged from the Gauntlet Loop, and still the load-bearing part. A bar must be **named** (a
specific thing, not a category), **fetchable** (you can open, run, read, screenshot or measure it)
and **comparable** (two artifacts can sit side by side and a judge can pick one). Name the measurable
half alongside it — a number, a benchmark, a budget, a pass rate. Taste plus a number beats taste
alone, and a bar you cannot obtain is one you will hallucinate.

### 4.1 The criterion list is frozen

The list is **given, not derived**. Copy it verbatim to `gauntlet/criteria.md` and hash it into the
first round record, R0000 (never SETUP's probe line). It is **created once and never modified**, and the boundary hook enforces exactly
that: every route may create the file, and every route — including the orchestrator's own — is denied
from the moment it exists. Write the whole list in one call; a second call to finish it off is
denied, and that denial is the rule working.

Create it by **writing or copying, never by moving**. The no-rename rule under `gauntlet/` is checked
before the does-it-exist rule, so `mv` and `Move-Item` are denied even while the file is absent,
while `cp` to the same path is allowed. Measured against the shipped hook, both spellings, exit 2.

**If the brief carries no enumerated list, writing one is round zero's first task.** Record
`"derived": true` on the R0000 record, put the reasoning in `workbench.md`, and treat it as
frozen from that moment. Waiting for a human who has been told to walk away is how a run delivers
nothing. Prose is context, not criteria; 8–15 criteria is the working range.

**A criterion you believe is wrong is a note, not a stop and not a question.** Write what is wrong
with it on the ledger and keep running against the list as written.

*2.4 allowed a run to APPEND one criterion on five legs of evidence. No paid run ever exercised it,
four of the five legs cited machinery that no longer exists, and it was auditable only after the
fact. It is gone; the note is what remains.*

---

## 5. The round

**One piece per loop.** Each piece gets its own champion lineage and its own ledger over the one
shared criterion list, filtered to what that piece affects. Pieces never share a round, so a lost
duel has exactly one owner. Assembly needs a smoothing build plus a final duel against the previous
assembled whole, within the human's cap. **Per-piece champions are not proof of an integrated
whole.** If no assembled whole was evaluated, deliver the piece SHAs and the integration limitation,
not a claim of complete integrated delivery. Prefer one lineage for coupled work; 4.4 adds no
integration engine or permission to move a champion without its required evidence.

Everything a *round* writes takes the `<piece>` segment: `ledger.jsonl`, `PENDING`,
`champion/R<nnnn>/`, `inbox/`, `rubric/v<n>.md`, `coverage.md`. Shared: `criteria.md`, `states.md`,
`sealed/`, `evidence/`.

**One piece-round at a time, and that is a trade the method makes knowingly.** Original Gauntlet
lets the agent choose which pieces run concurrently. It can exploit parallel work where this
method deliberately serialises rounds; a wall-clock advantage must be measured, not assumed. This method cannot, for three reasons that are harness facts rather than choices: builders
branch from one `HEAD`, and neither CLI can pin a worktree's base to a SHA; every sealed check
rewrites the one `run.json` at the root; and a four-judge gate needs its four child slots at once
against one concurrency cap. Running two pieces' rounds concurrently would race all three, and a
race in Gate 1 reports green about the wrong artifact. **With pieces, `HEAD` is the champion of the
piece whose round it is** — each piece's lineage is its own, and a resume takes the piece the
scheduling rule picks, off its own ledger. Landing restores the last assembled whole a final duel
accepted; where none exists it restores the base the pieces branched from (R0000) and delivers every
piece's champion SHA beside it, saying no assembled whole was evaluated. The serial round buys the memory — the
champion by SHA, the ledger, the map of what nobody looked at — and the trade is written down so
that nobody re-derives it into a race. Where the pieces are many and the clock matters more than the
memory, the Gauntlet is the right loop, and §14 says so.

**Which piece the next round you start belongs to is a decision, and the ledgers make it**: the
piece with the fewest lines on its ledger, ties to the largest `rounds_since_promotion`. The critic
names the gap *within* a piece; it does not choose the piece. Left unsaid — as it was until 3.2 —
one piece with a talkative critic takes every round and the rest ship at whatever round 0 gave them,
which is not a decision anyone made and which looks identical to progress in the ledger being read.

Two details are load-bearing. **"The next round you start"**, because one harness is told to fan out
a sub-agent per piece and keep them all working: with several pieces in flight, "the next round"
names nothing. And **the tie-break has to be a field that exists** — there is no timestamp anywhere
in the ledger schema, so "oldest champion" was not computable and `rounds_since_promotion` is.

### 5.1 Keep coupled things under one owner

**If it is unclear, one piece.** The two mistakes do not cost the same.

A piece that could have been three is **slower**, and the ledger shows you that. Three that should
have been one produces the regressions §15 admits nothing here catches: **every piece green on its
own criteria**, and what broke is **the interaction no piece owns** — learned from a duel, late, or
never. Prefer the mistake that is visible.

Write the cut on the R0000 record as `decomposition` and carry it forward unchanged: a context
that resumes this run did not make the call and cannot re-derive it.

**This bound is his, and it is measured rather than argued** — §2. The Claude of Duty README reports
three rounds of six parallel agents, one per directory, moving the score +0.46 while frame-ruining
defects ended *higher* than they started (60 → 47 → 66), against +1.00 and 66 → 26 for one
sequential pass with a single owner per coupled concern. Until 4.2 this method's prompts labelled
the rule as ours.

*2.3 shipped a coupledness test — ownable versus whole-artifact criteria, asked in both directions,
with two evidence lists and a precedence rule between them. It was written two days before the audit
that removed it and was never exercised by a run. The sentence above is what it would have decided.*

### 5.0 Three challengers per round, not one

One gap, one assignment, **three builders in three separate worktrees**, each told to take a
different direction at it and to say in one line which direction it took. They never see each other's
work.

A loop that samples once per round is a search with a population of one: the best artifact it can
reach is whatever the first attempt happened to be. Not thirty, because the filter here is a blind
panel rather than a machine, and every extra sample costs judges.

**Every builder's spawn text carries four things, and the orchestrator writes them out**: the gap as
the critic named it, the criteria that bear on it **copied verbatim**, the measurement that is
failing, and **the bar** — the reference files from `run-kit/refs/INDEX.md`, as absolute paths.
`gauntlet/` and `run-kit/refs/` are gitignored so that a builder's worktree cannot contain them
(§10), which also means a builder cannot open what good looks like unless the paths are handed to
it. **The builder is the only agent in this method that changes the artifact and, until 4.2, the
only one that never saw the standard** — it was being asked to close a gap against a bar it had
never been shown, by a run whose every other agent had. **Where the harness confines a builder's
shell to its worktree** — Claude Code's does (§10) — an absolute path outside it may not open, so
round 0's first builder proves it by reading one reference file by that path and saying so; if it
cannot, the harness copies them in when it makes each worktree — on Claude Code a committed
`.worktreeinclude` at the repo root listing `run-kit/refs/` copies those gitignored files into every
new worktree — and the run writes down which of the two this machine does. (4.5 — the 4.3 text had
the orchestrator copy files into a worktree that does not exist until the spawn.) (4.3 — an independent read of 4.2 asked how a confined shell would open the paths 4.2
had just started handing it.)

**A builder does not return on a commit.** It runs the artifact in the gap's state or behavior,
records suitable evidence and compares it with the bar. Traces, replay, audio/video, outputs and
independent measurements may replace screenshots. If the gap remains, try again up to three times
and then return the SHA, direction and final evidence path. A builder that never
ran what it built has produced a diff, not a challenger. The first 4.0 run's builders returned in
about fifteen minutes each with one file apiece, and every gate downstream then spent the rest of
the round choosing between things nobody had run.

**Rule each candidate MATERIAL or NO-OP first**, from `git diff` against the champion. One that
touches no file the assignment names — or whose diff is confined to comments and whitespace — is a
NO-OP, and **a NO-OP is not a challenger.** Without this the round can never fail: a near-no-op
inherits the champion's behaviour, ties every criterion, and the cheapest promotion in the method
becomes a change that improves nothing measurable. Record `material` beside `directions`. If all
three are NO-OP, re-issue the same assignment *once* and say so; a second set of three no-ops parks
the gap. (Until 4.0 this paragraph also exempted "any file the run declared non-material in
`run.json`". No such key exists in `run.json`, in the kit or in the seal harness — the clause was an
instruction a run could not follow.)

**If more than one is material, run a selection duel among them first** — blind and champion-free,
ruled against the frozen criterion list and nothing else, with **two judges, one per presentation
order, and no calibration pack**. This picks which candidate to spend the real panel on, and a
candidate the run may freely discard does not need four. Single elimination, lowest index first, so
three survivors are two selection duels and a tie goes to the lowest index. The winner, and only the
winner, goes on to Gate 2, and **a selection win is not a promotion**. (Until 4.1 this said "the same
machinery as Gate 2". The first 4.0 run spent about a third of every round on two four-judge
calibrated selection panels that tied five times in eight and advanced the lowest index anyway — the
duel tier had said two judges all along, and the ratchet now agrees with it.)

**Its slates obey the same rule as Gate 2's** (§7): the preparer drives every candidate into the
state the gap names and captures there, the same interaction on each, before it captures anything
else — and the builders' own captures are where it starts, since each of them has already been in
that state. Two attempts at one gap differ in exactly one place, and a slate that does not show that
place is two identical-looking pictures and a coin toss. Until 4.2 the slate rule was written for
the champion duel only, which is the panel it was measured on and not the only one that ties.

**Round 0's selection duel uses two judges, one per order, and no calibration pack.** The ten-item
pack belongs to Gate 2 from round 1 on and uses independent task-matched examples containing neither
live candidate (§7.1). Earlier versions built it from the champion; 4.4 removes that exposure
because the calibrated judge retains its transcript when it resumes.

**Selection judges are not Gate 2's judges and may not be.** A judge that ruled here has seen the
challenger and can name it on sight in an unlabelled slate.

If a builder returns nothing, the round continues on the survivors; if all three return nothing,
the gap is parked rather than re-issued into the call that just lost three children. **Remove the
worktrees you did not keep and every clean checkout the round built**, by path — `rm` or
`Remove-Item`, never `git clean`, which the hook refuses inside any checkout — SHA and branch first,
**before the round closes** — not at a pause, which may never come. Build them outside `gauntlet/`,
which the boundary hook refuses to delete from. A harness that isolates a subagent by copying the run
directory copies whatever you left into every child of every later round, so the price of a kept
checkout is not the disk it sits on: it is that disk times every child of every round after.

### 5.4 Waiting on children — never without a deadline

This is the rule three of the seven real runs died for lack of, and both survivors invented. It is
stated once and filled into both upper tiers at the point the round has spawned its builders.

**Never wait on a child without a deadline, and never wait on a list.** The orchestrator collects
*one child per call*, with a timeout, in a loop, using the single-id wait its harness documents. The
list form — a wait handed several ids and one timeout — is the exact call shape that returned
`Pending` and never resolved in every run that died; the harness section of the prompt names the
right call for each CLI.

**The deadline is computed, not felt.** Every ledger line carries `wall_ms` per phase (§13). A
child's deadline is *three times the median of that phase's `wall_ms` over the last three lines*,
and ninety minutes until three lines exist. It is written beside the child's id in `workbench.md`
when the child is spawned, and every wait is bounded by the sooner of ten minutes or that child's
deadline, with a `workbench.md` line after every return: that loop is the heartbeat, because the
owner kills silent runs. No turn ends while a child is open, except Claude's not-in-turn branch
below — a headless grok 1.0.50 turn ended with a task live was never woken again (observed). There is no extension on liveness grounds: the runs that died were burning tokens at the
healthy rate, with live processes and a browser profile still writing, so none of that is evidence
a child is working.

**A child past its deadline is dead, not late.** Record it, stop it by id with the tool the harness
section names, respawn it once with a fresh context, and if the respawn dies take the role's
fallback. Never wait on it again. A respawned judge is a new judge: it takes the alternate calibration
pack (§7.1) and is seated on it before it sees a slate, and it counts against the respawn cap in §7.1.

**The fallback is named per role, so no death is a question.** Builder: the round runs on the
survivors. Critic: the no-gap route (§5.2a) picks the assignment. Preparer: `duel: null` on the
line, no promotion, next round. Judge: the quorum rule in §7.2. Coherence critic (§5.5): the wave is
recorded unreviewed and the next one runs it.

**A third dead child ends the round** — spawns and respawns counted together, whatever the roles.
Two deaths are survivable and the fallbacks above are how: one judge and its dead respawn *is* the
quorum case, not a void round. (The first draft of this rule said two, which voided the round in the
exact state the quorum exists for; an audit caught it, the tests had not.) At the third the round is
void, the gap is parked and the next round takes the next gap, because a round that keeps spawning
into a call shape that keeps killing children is the hang wearing a loop.

**On Claude Code** there is no deadline parameter on the spawn; the deadline is bookkeeping the run
keeps and enforces with `TaskStop` on the agent id. There is no agent wait tool (TaskOutput was
removed in 2.1.277) and no foreground sleep: 2.1.241 refuses a Bash or PowerShell call that starts
with a sleep of 25 seconds or more ("Blocked: standalone sleep"), read from the installed binary.
So **the not-in-turn branch is the wait, and it carries its own alarm**: with a child open and no
independent work left, the run creates one one-shot `CronCreate` for the sooner of the nearest
deadline and ten minutes from now (at least two minutes out, never at :00 or :30), writes its id and
fire time with every open child's id and deadline into the RESUME block, and ends the turn. Every wake
— a completion notification, which arrives as a new turn, or the alarm — checks every deadline first,
stops a late child by id, and writes one `workbench.md` line; on every wake the pending alarm is
deleted and, if a child is still open, the next one is armed; at any ending or pause `CronList` is
empty. Setup proves both kinds of wake start a turn; if either never does, that is setup's second
stop. This is the one place in this method where §12.3's rule has an exception. (4.5 round 2 — the
first 4.5 text prescribed a foreground sleep this build refuses, and its not-in-turn branch had no
alarm, so a hung last child left nothing to start a turn.) **On Grok Build**
inspect the live schema: this release uses
`get_command_or_subagent_output({task_ids:[id], timeout_ms:bounded_ms})`, one child per call.
Each call is bounded by the sooner of 600000 ms and the child's remaining deadline; the documented
maximum, 3600000 ms, is a ceiling, never a target. A non-blocking `timeout_ms: 0` snapshot of the
other open ids is allowed between slices. Never sleep in a shell loop. A dead child is cancelled through
`kill_command_or_subagent({task_id:id})`. Historical scalar argument names do not override the
installed tool schema.

### 5.5 The coherence pass — the seams no piece owns

Nothing in a piece's round can see the join between two pieces that each did the right thing, and
field reports of the plain loop agree: environments improved while the characters stayed bad, or
three good parts met at three bad seams. The Gauntlet's answer is a fresh agent that experiences the
whole thing between waves; Shumer's article calls it optional, and this method makes it a critic.

**At the end of every completed scheduling sweep** — when every piece has closed a round since
the last pass, including losses and no-promotion rounds — the orchestrator spawns a fresh critic
on the assembled champions. A piece that never promotes must not starve seam review. The preparer materialises every
piece's champion by SHA into one clean checkout; where two champions touch one file, that conflict
*is* a seam, recorded as one and never resolved by judgement. The critic experiences the whole thing
end to end the way the owner would — never a diff, never a summary — and names **the single biggest
seam**: the transition, the tone shift, the place two pieces meet and one of them is wrong. That seam
becomes the owning piece's next assignment, cited.

It moves no champion and runs no duel: it steers. It is the CRITIC role with a different brief, so
the hook resolves it, and it costs one agent call per wave. The preparer cannot read the ledgers, so
the orchestrator hands it every piece champion's SHA in the spawn text. **Round ids are one sequence
across pieces** — `R0007` on any ledger came after `R0006` on any other — so the per-piece ledgers
read as one history; the run writes `coherence: true` on the ledger of the piece whose round it was
in when it ran the pass, with the pieces covered in that line's `gap` field, and the wave boundary
is computable from disk. **With one piece there are no seams between pieces and no separate pass**:
the ordinary critic already goes through the whole artifact end to end (§5.3), which is what this
pass is for.

### 5.2 Coverage — the states nobody entered

This is the one mechanism here this project's records credit with a catch — a live defect found in
a state nobody had entered, in a run those records do not name — and it targets the class neither a
duel nor a regression suite reaches. Why it exists, measured twice, neither time a judgement failure:

- A control left focused after a click, so a later `Space` re-fired it and discarded a live game.
  Present at round 0, unnamed by six fresh critics, still there when the run ended.
- `Enter` not scoped to focus, so `Enter` on a Close button ran the selected command. Shipped by two
  loops built independently against one bar.

A critic told to find the biggest gap looks where it expects one.

**The state map**, `gauntlet/states.md`, written at round 0 and shared by every piece. For each
criterion, the states it speaks about — and then, because both misses above were *crossings* rather
than single states, the standard axes crossed against each other:

| Axis | Values |
|---|---|
| ENTRY PATH | keyboard, pointer, programmatic, restored-from-storage |
| DATA STATE | empty, typical, at the limit, over the limit, invalid |
| SEQUENCE | fresh, after an action, after an undo or reset, after an error |

Name each state and give it an id, taking the crossings the criteria actually touch. It is
**append-only, not frozen**: criteria are frozen because they are the standard, and this is a map of
the territory, which grows. Never remove one — a state deleted is a state that stops being uncovered.

**The coverage ledger**, `gauntlet/<piece>/coverage.md`: state id → the rounds it was entered in. Per
piece; at delivery a state is unentered only when no piece ever entered it.

**Every critic and every judge reports the states it entered**, by id, artifact SHA and evidence.
A visit on a losing candidate or an older SHA does not verify the delivered champion. Report only
what was entered, not states merely considered. **But they report them to the ORCHESTRATOR, which writes the
file** — the shipped hook gives a judge nothing at all under `gauntlet/`, so an instruction to go and
read `coverage.md` is a round that stops on a denial. So the list travels **in the spawn text**: each
round, read `coverage.md` and put the three least-visited states into the critic's prompt, ids *and*
descriptions, requiring it to enter them and report what it found on top of whatever it would have
looked at anyway. It costs no extra agents.

**Coverage is not quality and must never be scored.** It says somebody looked, not that the artifact
is good there; made a number to maximise, a builder will enter states cheaply to raise it.

### 5.2a When the critic reports no checkable gap

A critic that finds nothing is one agent, in one context, failing to name a hole in the place it
looked. The round after it may not be empty: no gap means nothing built, nothing built means no duel,
and a round that runs no duel tests nothing and costs money anyway. Work this list in order, stop at
the first step that yields an assignment, and record which step it was.

1. **A state nobody has entered**, off `coverage.md` — ids and descriptions in the spawn text,
   entered and reported with evidence. If the run never wrote a state map, write one now.
2. **The three least-visited states**, once every state has been entered at least once.
   Least-visited, not most interesting.
3. **The oldest parked gap.** It was parked because it was blocked against the champion of that
   round, and the champion has moved since. Reopening the oldest beats stopping.

*2.1's route had five steps. Two of them — re-reading the harvest trigger over the last three
promoted rounds, and a third attempt at an open blind spot — both ended in a full admission cycle,
and there is no admission left to run. There is also no sixth step that stops, because §12 leaves the
run no ending to declare.*

### 5.3 The critic is harsh and it inspects the artifact

Both halves, in the spawn text and in the contract, in **every tier**. This is a restoration rather
than an addition: the Gauntlet Loop says *"a really harsh critic … inspect the actual rendered game,
never the builder's summary"*, and an audit of the three composed prompts found that the word `harsh`
appeared once in the cheapest tier and **zero times** in the two expensive ones. `inspect` did the
same. Machinery had displaced the mechanism.

The spawn text carries **the human's own goal, verbatim**, so the standard the critic is harsh about
is theirs and not a generic one. A critic reporting on a description has reported on nothing, and a
gentle one costs the round it was paid for.

**The critique lands on the champion, once the duel has settled** — the challenger if it promoted,
the incumbent if it did not, and never a candidate the round discarded. A critique of something that
no longer exists names the next round's gap against a version nobody has, and files the states it
entered into the coverage map of an artifact that was deleted minutes later. Until 4.2 this said
"critique the one that reached Gate 2", which is a candidate chosen *before* the verdict: three
rounds in five of the first 4.0 run promoted nothing, so in each of them the critique and its
coverage line were about the loser. **The critique is the round's last agent call on this piece** —
only a due coherence pass, the promotion writes and the ledger line come after it — and its gap is
what the next round builds.

**So the round's phases, in the order the round runs them, are: build, gate1, selection, gate2,
critique, coherence, promote** — and `wall_ms` on the ledger line (§13) carries them in that order,
because the deadline rule (§5.4) reads a phase's own history and a key that means a different thing
on older lines is worse than a missing one. The preparer's time is part of the gate it prepares for.
**Coherence sits before promote because promote is what appends the ledger line** (§8): 4.2 had it
after, and a pass that runs after the append has no line left to write `coherence:true` on — a
defect an independent read caught and no run had reached, since no 4.2 run completed a wave.

**Inspect the complete user journey the assignment concerns, not only the first screen.** For
finite artifacts reach the relevant end; for open-ended games, services or libraries execute a
bounded representative scenario and report what remained uninspected. Record the state reached,
artifact SHA and evidence. Inability to complete a required journey is a gap, not permission to
claim coverage. Evidence can be captures, interaction traces, replay, audio/video, outputs or
independent measurements; use the instrument that can actually observe the criterion.

### 5.3a The critic is handed the bar, unlabelled — the one verdict from outside the run

**Added in 3.2, and it is a restoration too.** Nearly every verdict in the duel and the ratchet
compares the run to itself: Gate 2 is champion against challenger, the rubric is derived from the
run's own round-0 candidates, and where a brief carries no enumerated criterion list the run writes
that as well. Instrument and verdict both belong to the run, so the loop can only climb away from
wherever it started — it cannot find out that it started in the wrong place. The plain Gauntlet
Loop never had this problem, because its critic is handed the artifact **and the bar**, is not told
which is which, and picks between them.

**The two slates must be the same kind of thing or the blinding is decoration.** Whatever form the
bar is in — captures, a served page, a document — the preparer renders **ours** into that same form,
at the same viewport, in the same state, before the critic sees either. A running app beside a folder
of stills is labelled by its format, and a critic that can tell which is which is not blind however
carefully the labels were stripped. If the bar cannot be matched in form, hand the critic both
anyway and write `bar_pick` as an object, `{"pick":"theirs","blind":false}`, where the plain string
`"theirs"` or `"ours"` means a blind pick: a pick you know was not blind is worth less than one you
thought was, the ledger is where that difference has to live, and the steering rule below reads the
pick in either shape.

So the critic in both upper tiers gets the same slate: the artifact and the bar, unlabelled,
returning **a pick** — which of the two is better, not an aggregate score — and the biggest
remaining gap either way, named as a state or behavior with evidence that would show it fixed. "The
sidebar has no unit portraits and the bar's does" is a gap; "the look" is an adjective. The first
4.0 run's critic named "the Dune 2000 look" as the gap three rounds running; each round three
builders guessed a different part of it — terrain, sidebar, buildings; infantry, bugs, effects — and
the duel could not see which, because nothing in "the look" told the preparer what to capture. The
gap the critic names determines what the next round's preparer must observe (§7). Name a state or
behavior with evidence that would show the fix: a trace or measurement can establish what a still
image cannot. An adjective without an observable discriminator is not an assignment. It costs no extra agent call: the
critic already runs once a round. The bar is an external reference, but the pick remains the
critic's judgment. Likewise, a sealed human sentence still relies on a loop-written scenario
harness unless the human supplied the executable (§8.1). Neither provenance alone proves quality.

**The blinding is scoped to the pick, and then lifted.** This critic owes two things the Gauntlet's
does not: per-criterion rulings on the champion lineage, and the states it entered, which feed
coverage. Neither is answerable by an agent that never learns which slate was ours — it would file
states entered in somebody else's product into our coverage map, corrupting the one mechanism with
a cited catch. So: the pick is blind, and once it has answered, the critic is told which was ours.

**And the pick steers, or it is decoration.** If the **last three ledger lines all pick
`"theirs"`**, the critic has lost to the reference three rounds running on three different
gaps, and that is a **distance problem, not a gap-finding problem**: take the criterion the critic
cited against us most often across those three lines and make **that** the next assignment, whatever
else it named. Until 4.2 `bar_pick` was written every round and read by nothing — the one verdict
from outside the run had no route into what the run did next, which is the same defect as a rule
with no defined move (a field with no reader is a measurement nobody is allowed to act on).

**What is deliberately not ported is the wow.** In the Gauntlet, whether the critic is *utterly
wowed* is a stop condition. These tiers have exactly one ending and it is the owner's cap, and the
most expensive thing this method has learned is that a word for finishing becomes a word for
excusing. Winning the pick means the next gap is a smaller one. It means nothing else.

---

## 6. Gate 1 — the human's sealed check, and that is all it is

Gate 1 runs against **every material candidate**, each from its own clean checkout, **immediately
after the build and, from round 1 on, before any judge sees any of them**. Round 0 is the one
exception, and it is not a choice: the suite reads `run.json`, and `run.json` does not exist until
round 0 has picked something to describe (§4.2, step 6). A binding entry failing **takes that
candidate out of the round**; if it takes all of them, the gap is parked. It is machine-checkable and
it is the human's, so it is not a matter of taste and it does not go to a duel. If the brief carried
no sealed entries, **Gate 1 is empty and that is the deal the run took** — it says so in the ledger
rather than inventing a suite.

**Bind each invocation to the candidate, not merely its URL:** `SEAL_ROOT` is its absolute clean
checkout, `SEAL_URL` its attributed HTTP address when needed, and `--evidence-dir` is unique per
round/candidate/attempt. Set those variables on the actual invocation from the main repo (§8.1).
A champion fallback must retain separate target identity and evidence. No sealed bodies or specs
change to perform this routing.

**That order is the only one in which its own sentence was ever true.** Until 4.2 the gate ran on the
one candidate the selection duel had already chosen, so "before any judge sees it" was false as
written: two selection judges had seen and ranked all three, and a candidate that fails the owner's
own machine check had reached a panel. Running first costs **up to two more clean checkouts on a
three-candidate round** and buys the property the sentence claims — a candidate that fails the
human's check never reaches a judge at all — which is the cheapest thing in a round that spends its
money on judges (§14.1).

**Which entries are binding is written in their own `.criterion.md`** — an `Enforcement:` line on
the generated floors, the plain sentence *"Failing it fails the round"* on the human's own entry —
**and `sealed/INDEX.md`'s table agrees with it.** Not guessed from the name, not assigned by the
run, and not read off a Role line, because none is written. An
advisory entry failing fails nothing: record it, report it, carry on. Until 3.2 this tier used the
word *binding* three times and defined it zero, because the taxonomy lives in the duel's longer
sealed section and the ratchet's returns before it. **A gate whose trigger word is undefined in the
tier being run cannot be judged on how often it fires**, which is worth remembering before anyone
cites its block rate as evidence about the mechanism.

**This loop writes no regression suite of its own.** See §14.4: eight independently re-measured
transitions and six separate challenger gradings found no regressions. Those are different
measurements, not fourteen independent transitions. A human sentence still needs a scenario
harness; its implementation is loop-written and must not be described as an independent oracle.

---

## 7. Gate 2 — the duel

Split the hands that build from the eyes that judge. This decides every promotion; whether it
improves final artifacts over Gauntlet at equal spend is not established.

**Prepare both sides identically**, from clean checkouts by SHA, in separate directories, with the
same commands. A judge handed one side built and the other described is not comparing artifacts.

**And the slate shows the state the gap names, on both sides, identically.** The round's assignment
said what changed; the preparer drives both artifacts *into* that state — a unit selected, a fight
under way, the menu open — and captures there, with the same interaction on both, before it captures
anything else. A load screenshot cannot show combat. The first 4.0 run tied four-nil on two
consecutive rounds because its slates were stills of the opening screen while the rounds had built
infantry and gunfire: twenty-four judge verdicts on frames that could not contain the difference. A
duel whose slate cannot show the change measures nothing and costs the same, and the run's own
RESUME block diagnosed it — *"next slates must include a unit-select and a combat frame"* — one
round too late. 4.1 makes it the rule.

**Normalise provenance and presentation conditions, never evaluated properties.** Match viewport,
inputs, capture timing and evidence format; remove author labels and wrapper commentary. Preserve
native layout, typography, tone, length, animation and other properties whenever a criterion judges
them. Do not restyle a UI or paraphrase writing to make the sides look alike. Record every transform
and any remaining presentation mismatch. A trace, replay, audio/video segment or independent
measurement is evidence too; a screenshot is not required when it cannot show the property.

**One rubric, frozen, shared by all four judges.** Derive observation points from the frozen
criterion list and real round-0 candidates, without adding, removing or softening criteria. Keep
observation points for **every criterion**, including properties all initial candidates satisfy.
A later regression can occur in something initially tied. Merge redundant wording only when no
criterion or observation point is lost.

**Still commit first.** Before opening any candidate the judge reads the rubric and writes down, per
criterion, what it expects a winner to show *here*. Conditioned on a candidate first, a judge scores
plausibility instead of correctness — and pre-commitment without grounding underperforms no rubric at
all. Both halves matter.

**Randomise criterion order** on every call. Rule A / B / TIE per criterion with a **citation** — slate labels are the record's A and B in both
orders, and the order changes only which is shown first — the
exact output, measurement, quoted span or capture that decides it. No citable evidence is not a pass.

**And a citation is only evidence if the instrument saw the thing.** A capture that does not show the
element the criterion names, a number read off a page that had navigated away, a benchmark taken
with the camera parked — each of those decided a real round wrongly, in this project and in
published reports of the Gauntlet: a Chrome screenshot that omitted a panel invalidated a round; a
static-camera frame-rate benchmark read three times the real figure. Neither of Shumer's texts
addresses it, and it is the failure with the most independent sightings of anything in this
document. A ruling on such a citation is **void**: re-capture, re-rule, and say so. This is 4.0 and
it applies to the critic (§5.3) as much as to the judges.

**No scores out of anything, ever.** A pick between two things stays honest as the artifact
improves; a number does not. (This document used to say scores "drift upward every round". The
direction is well supported — pairwise judging is more stable than pointwise, and pointwise scores
carry a large non-quality component — but the round-over-round drift claim has no measurement
behind it, so 4.0 states the reason rather than the figure.)

### 7.1 Calibration — independent examples, then the same judge

Calibrate first in a separate call, then resume **the same judge session** for the live comparison.
The pack uses **independent task-matched examples containing neither live candidate**, including
neither a champion twin nor a recognizable transformation of either side. A separate call retains
memory; it does not undo exposure to the champion. **The control is a candidate round 0 discarded** — a sibling of R0000, never a derivative of a live
side — made to resolve in the main repository and pinned with
`git update-ref refs/gauntlet/controls/<piece>-R0000-<cand> <sha>` before its worktree is removed.
Where round 0 left none, the bar rendered into the slate's form is the control. The preparer builds
the ten items from it once per rubric version, plus one alternate pack for a respawned seat, fixes
and validates answer labels before judging and withholds them from the judges.

Ten items: one identical-example TWIN for plumbing, three DEGRADE examples on distinct criteria,
five independently validated equivalent examples, and one REPEAT. The TWIN must tie but does not
count toward the other nine. **Seat on 8 of 9**, retaining all responses and failed attempts. This
is a protocol threshold, **not a measured accuracy rate or confidence bound**: items are correlated,
REPEAT is not an independent trial, and retries select judges. FORMAT, VERBOSITY or PARAPHRASE may
supply equivalents only when they preserve every evaluated property; otherwise use different
validated equivalents. Never transform actual UI style or writing tone when those are criteria.

Cap respawns at two per duel; a respawned seat takes the alternate pack, never the one its
predecessor saw. A failed or
unverifiable calibration cannot become a live vote or be silently dropped to manufacture a quorum.
After ten eligible duels, fewer than nine full panels triggers one rubric-instrument review using
the recorded failures; it does not establish that the criteria are wrong. Preserve every criterion
and its observation points, record the new rubric version, and park an unseatable gap rather than
changing the standard.

### 7.2 The verdict

**Declare four judge ids and their orders before opening live slates: two AB, two BA.** Each is
the id its calibration spawn returned; where resuming returns a new id (grok 1.0.50 does, measured),
record that as the judge's `liveSessionId` and verify the live model on it. **Family means vendor**,
read off the resolved id. Cross two judge vendors across the orders; where the harness offers three
or more vendors, neither judge vendor is the builder's, and otherwise exclude the builder's resolved
model and record that a judge shares its vendor. On Claude Code, two other model tiers in one vendor
are a disclosed `same-family` limitation.
An account with exactly two models puts all four judges on the one that is not the builder's and
records `two-model`, quoting the harness's model listing (`grok models` on Grok Build) as its reason; a single-model account may use `single-model` only with the
limitation and its reason recorded. (4.5 — before it, a two-model account could seat no valid panel
while a sole-model one could.)
Record resolved model ids, families and harness provenance; a judge's self-description is not
verification. No selected model or family diversity implies statistical independence.

**A judge prefers the side winning more criteria; equal counts mean TIE.** Each frozen criterion
requires exactly one cited A / B / TIE ruling, never pooled across judges. An uncited, malformed,
ineligible or NOT-JUDGEABLE ruling makes the panel **INVALID**, not a smaller panel. Obtain the
missing evidence without changing the artifacts, or close the round with no promotion. A binding
sealed failure still excludes the candidate before this gate.

| Verdict | Four eligible, calibrated judges | Effect |
|---|---|---|
| **WIN** | ≥3 of 4 prefer challenger or tie, **with at least one strict challenger preference in each presentation order** | eligible for promotion |
| **LOSS** | ≥3 of 4 prefer incumbent | discard |
| **TIE** | any other valid profile, including four ties | no promotion |
| **INVALID** | evidence or eligibility does not satisfy the panel contract | no promotion; record the reason |

**One challenger preference plus three ties is not a win.** Two strict preferences across orders,
one tie and one incumbent preference do satisfy the four-seat rule. That is an explicit acceptance
trade, **not proof of no regressions or of a globally best artifact**.

**Three-seat quorum is authorized only after a judge and its one respawn miss their deadlines
(§5.4).** Keep the four-seat roster; name the missing seat and the failure record. With exactly
three eligible calibrated judges, WIN requires **no incumbent dissent and a strict challenger
preference in both orders**. Unanimous incumbent preference is LOSS; other valid profiles are TIE.
Do not convert failed calibration, malformed votes or unverified provenance into an absent seat.
Fewer than three is INVALID. Record `seated` as the count; exclude an authorized death-shortened
panel from the nine-of-ten full-panel window because a timeout is not a rubric measurement.

**Use the kit's deterministic adjudicator for both upper tiers.** Call
`node run-kit/adjudicate.mjs <panel.json>`; it prints one result. Exit 0 means a valid ruling,
not permission to promote: only `verdict:"WIN"` permits promotion after Gate 1. INVALID exits 2.
The module also exports pure `adjudicate(record)`. It validates supplied fields and computes only:
no spawning, writes, retries, evidence collection or champion changes. It does not authenticate
citations, model claims or blindness. The preparer and orchestrator remain responsible for those.

The private input contract (`schemaVersion:1`) is:

- `panelId`; `artifacts:{A,B}` as distinct lowercase commit/content SHAs; `challenger:"A"|"B"`;
  `criteria:[id,...]` from the frozen list; `builder:{id,family,source}` from harness evidence.
- `capability:{mode,reason?}`: `cross-family`, `same-family`, `two-model` or `single-model`; a limitation needs
  its reason. `roster:[{id,order,model,family},...]` retains four unique judge sessions, two per
  order. In cross-family mode each order has both families; same-family mode crosses two models; two-model mode seats all four on the one non-builder model.
- `judges:[{id,liveSessionId?,panelId,artifacts:{A,B},order,model:{id,family,source},eligibility:{blind:true,built:false,selection:false,
  source},calibration:{passed:true,judgeId,packId,source,independent:true,artifactIds:[sha,...]},
  votes:[{criterion,pick,citations:[reference,...]},...]},...]`. Calibration ids exclude both live
  artifacts. `liveSessionId`, when given, names one distinct resumed session per judge (on Claude
  `SendMessage` resumes the same id). A judge family that matches the builder's is returned as a
  limitation. `run-kit/panel.example.json` is a record the adjudicator accepts. `source` and citation references name retained evidence, not assertions invented to
  satisfy this shape. The judge receives only its anonymous slate, never this private record.
- Only for three judges: `quorum:{authorized:true,missingSeatId,
  reason:"deadline-and-respawn-failed",source}`. Invalid supplied judges are not removed.

Save the input and output under the round's `inbox/`, with paths in the ledger's `adjudication`
field. Preserve original sheets beside them. Output carries method/schema version, panel id,
`verdict`, `promote`, per-judge margins/preferences, `limitations` and `errors`. Neither a string
reference nor a matching hash is cryptographic proof that its cited observation is true.

**A selection panel is never "seated", because it has no pack to be seated on.** Its ledger entry is
`{"kind":"selection","judges":2,"answered":2}`, and **a selection duel where fewer than two judges
answered did not run**: the lowest-index material candidate goes forward and the line says
`by:"default"`. Until 4.2 this read "a selection duel with one judge seated did not run", which
carried the word `seated` and the field `calibrated` into the one panel that is deliberately
uncalibrated (§5.0) — a rule stated in a vocabulary its own subject does not have.

**Record the margin** per judge — criteria won and lost. Not a score on the artifact: a record of how
close the call was. A 4-0 panel with wide margins and a 4-0 panel where every judge was one criterion
from the opposite verdict are the same ledger line without it.

**On a valid TIE containing both challenger and incumbent preferences, escalate once — do not
re-run the same panel.** All ties, insufficient evidence and one-order-only support with no dissent
are not escalation triggers. Repetition may preserve a panel's bias rather than resolve it. Run one escalation
duel on a panel drawn as differently as the harness allows, freshly calibrated, both orders, same
rubric. **Its verdict stands**; if it splits too, the round is a TIE. Log both verdicts with each
panel's composition, or an escalation is indistinguishable from re-running until you like the answer.
**Never escalate a loss** — that is the p-hacking this bound exists to prevent.

*Scatter went with the redesign corridor it fed. A second split is now a TIE, which parks the gap.*

---

## 8. Promotion

**Two-phase, and the order is the point.**

1. Write `gauntlet/<piece>/PENDING` with the intended manifest hash.
2. Perform all the writes, freezing the challenger as `gauntlet/<piece>/champion/R<nnnn>/` with its
   SHA and a fresh `SNAPSHOT.sha256`.
3. **Append the ledger line.**
4. **Then** delete `PENDING`.

Delete-then-append leaves a window where `PENDING` is gone and the manifest disagrees with the last
ledger line — exactly the state this rule exists to stop being read as tampering.

`SNAPSHOT.sha256` **excludes itself**: sorted relative paths, itself omitted, one `sha256  path` line
each, then the sha256 of that listing.

**An orphan is not a fault.** A `champion/R<nnnn>/` directory with no ledger line naming it — a
promotion that died between step 2 and step 3 — cannot be deleted, because nothing under `gauntlet/`
can. It is recorded in the RESUME block as a known artefact and never read as the champion: the
ledger names the champion, and only the ledger. The integrity fault in §9 is a *ledgered* champion
whose snapshot no longer matches, and only that. (Until 4.0 this document said "roll back", which
named a delete the hook denies, and "a champion that no longer matches its snapshot", unquantified,
which a run enumerating the directory would read as ending itself on the orphan.)

### 8.0 The harvest — cut in 4.0, on cost

Until 4.0 every promotion evaluated a trigger: a judge cited a measurement violating a criterion's
own threshold on an artifact the sealed check for that criterion called green, and the hole was
recorded as an open blind spot carried on every later ledger line. It had one cited catch — a
contrast criterion at 4.5:1, a champion measured at 1.65:1 through a scrim, a check that said green
— and, after 3.0 narrowed its trigger to that conjunction, no recorded firing. The count of
non-firings names no ledger and is not quoted here; the cut is made on cost. What the run keeps is
the sentence in §8.1: *if you think one of these is wrong, say so in your report and keep running
it.* What the owner loses is the structured, carried-forward channel for the same thing, and this
paragraph says so rather than pretending the mechanism never paid.

### 8.1 The sealed suite — the checks the loop did not write

The run **runs** the sealed checks every round, **edits them never** and **reads them never**.
Distinguish human-uploaded executables, human sentences with loop-written scenario harnesses, and
generator-authored floors. **The orchestrator writes a sentence's harness** at
`gauntlet/harness/<id>.mjs` in round 0, before the rehearsal — the hook lets no child write under
`gauntlet/` — or copies there one a builder wrote outside it. A fixed sentence does not independently validate its implementation;
`harness.mjs` records the implementation hash but cannot prove that its `satisfied` result is true.

**Half of that is enforced and half is trust, and the run should know which.** The hook denies writes
to the specs and the bodies from every caller. It does not deny reads — running a check means reading
it, and caller identity may be absent in a supported harness configuration. So
not reading them is a rule the run keeps, not a control that holds it: a standard you have read is a
standard you start optimising against. **If a run reads one anyway, it says so** in the ledger and in
its final report. That disclosure is the whole of the control on this half.

The suite lives at `gauntlet/sealed/`, where START-HERE.md put it; the run verifies that before
round 0 and does not move it. If it is not there, the command in `sealed/INDEX.md` places it and
refuses to nest one suite inside another — a plain `mv` onto an existing directory puts the new
suite one level down, silently, and every round then grades against the old one, which was measured.
Each entry has a
`.criterion.md` the run **does** read and a `.spec.json` it **does not**, and each criterion names the
body that runs it on its `Run it with:` line. From the repo root:

```
node gauntlet/sealed/<body>.mjs --spec gauntlet/sealed/<id>.spec.json --json --evidence-dir gauntlet/evidence/<round>/<candidate>/<attempt>
```

One line of JSON comes back — verdict, measured, expected, detail, evidence path — with exit 0 PASS,
1 FAIL, 2 UNRUNNABLE or NOT-APPLICABLE.

**Two prerequisites with no fallback:** Playwright with Chromium, and an `http://127.0.0.1:<port>/`
address the artifact is served at, because `file://` is refused. Without either, every entry answers
UNRUNNABLE — a suite that gates on nothing and reports success.

**Only once the candidate's SHA resolves in the main repository** — on a harness that builds in a
standalone copy (grok 1.0.50), `git fetch <worktree_path> <sha>` first, and `git cat-file -t <sha>`
must print `commit`. **Point every invocation at the candidate root and URL, explicitly.** Set `SEAL_ROOT` to the
absolute clean checkout of the candidate SHA and `SEAL_URL` to its attributed HTTP address for
URL checks, in the **same shell invocation** as the command above. `SEAL_URL` alone does not
redirect filesystem checks or deterministic commands. Bodies and specs remain resolved from the
main repo; the candidate's `run.json` and relative artifact commands are resolved from `SEAL_ROOT`.
The URL override suppresses the candidate config's start command, not an explicit target frozen
in a spec. Never edit a sealed spec, a body or `run.json` to redirect it.

Retain candidate SHA, root, URL, owned server PID and returned evidence path with every result.
Use a fresh `--evidence-dir` under round/candidate/attempt for each invocation; a champion fallback
gets its own root, URL and evidence directory so neither result overwrites the other. Both sealed
bodies also make evidence filenames unique, but that does not replace target attribution. Restore
previous environment values afterwards **by assignment in the same call** — never with
`Remove-Item Env:`, which the hook reads as a delete under `gauntlet/` in a command that names it —
and stop only the server this pass launched, by its recorded PID. An export from an earlier shell call is not an environment contract.

A loop-written scenario harness is **not an independent oracle**. Even an uploaded script can
hardcode another path or ignore the URL. Preserve actual target evidence and report that limitation
rather than treating a green result or a hash as proof that the intended artifact was measured.

**Do not run one once to see if it works.** An entry that carries no number measures on its **first**
execution and freezes that reading permanently, so a smoke test against a placeholder makes the
placeholder the standard for the rest of the run and the hook denies every correction.

**UNRUNNABLE is not a pass, and whose fault it is decides the round** — told apart mechanically and
never by judgement: **re-run the same entry against the champion.** Unrunnable on the challenger
alone is the artifact — no target, no surface, a `run.json` that does not describe the thing — and
it **fails the round**, because otherwise a green is one broken address away. Unrunnable on both is
the environment — no browser, a mistyped spec, a checkout neither side can build — so record it,
report the hole every round until it is filled, and fail nothing. **An advisory entry never fails a
round either way.** NOT-APPLICABLE is recorded with a reason in `run.json` that the human gets to
disagree with.

The split is 3.2 in this tier; the duel and `sealed/README.md` shipping in every kit have carried it
throughout, and the ratchet's shorter Gate 1 section had been left out of it. Without the mechanical
test, the one Gate 1 environment failure this project has recorded — a checkout that would not
build, §1 — reads as the artifact's fault and fails every round of the run.

**One scenario the human wrote is worth more than every derived threshold together**, because it is
the only part of the method that samples their judgement rather than the loop's reading of their
prose. A real run held a physics invariant to four decimal places — 7.3431 s against a sealed
7.34 s ± 2% — every round.

*2.0 added a **derived** sealed entry, measured from a reference the human named. It took five
repairs across four revisions, four of its six candidate measurements were wrong and two were
actively harmful, and it never ran in a paid round. 1.7 added a **GATE/HOLDOUT** split so half the
suite stayed an honest estimate; its only measured event was a bug that silently moved two binding
floors into the half that cannot fail a round. Both are gone. The floors still ship in every kit and
still run; what went is the protocol around them.*

---

## 9. Crash consistency and accident detection

A ledger line is appended at the **end** of a round, so a session that died inside one left no line
for it. What it left is one of these, and they are what a resuming context checks:

- **`PENDING` present and consistent** → roll forward, log it, start the next round.
- **`PENDING` present and not consistent** → the promotion did not happen: check out the champion
  the last ledger line names, delete `PENDING`, record the half-written champion directory as an
  orphan in the RESUME block (§8 — it cannot be removed and it is not the champion), start the next
  round.
- **`PENDING` absent but the champion the last ledger line names no longer matches its own
  `SNAPSHOT.sha256`, or the manifest disagrees with the last ledger line** → **integrity fault**:
  deliver the last ledgered champion whose snapshot still matches, write exactly what changed, stop.
  Never repair one silently. An orphan directory is not this.
- **A leftover worktree, a dead branch or a dirty `run.json`** is none of those. Remove the worktree
  by path, restore `run.json` from the champion commit, record both, carry on: the round that made
  them never wrote a line, so nothing on disk claims them.

This is crash consistency and accident detection, **not tamper-proofing**.

---

## 10. The boundary is a hook and a worktree, not a sentence

An instruction is not a control.

**Primary: the worktree.** Spawn every builder into a worktree with no `gauntlet/` in it. A path that
is not there cannot be read, and it needs no hook. **`gauntlet/` and `run-kit/refs/` are in
`.gitignore` before round 0** — the kit's START-HERE writes both lines and the run confirms them — a
worktree leaves out *gitignored* files (on grok 1.0.50 it also copies untracked files and uncommitted
edits, so builders spawn only from a clean champion checkout), so those lines are what keep the sealed checks and the
reference captures out of a builder's checkout, and no spawn parameter can do it instead. Without the
first, the first `git add -A` at the repo root with three builders live commits three checkouts into
the artifact about to be frozen. (Until 4.0 this sentence also said "and the worktree root"; no
document ever named that path, so no run could gitignore it.) **The run's own files stay out of every checkout too**:
START-HERE also gitignores `workbench.md`, `progress.html` and `.rl-scratch/` — the one directory
for every clean checkout, served build, capture and server log made outside `gauntlet/` (and
`.claude/worktrees/` on Claude Code) — so `git status --porcelain` prints nothing before builders
are spawned (before R0000 a leftover may also be committed; after it nothing is committed, because a
commit moves `HEAD` off the champion: an untracked file moves under `.rl-scratch/`, and a changed
tracked file is restored with `git checkout HEAD -- <file>`; `.git/info/exclude` clears `git status`,
but on Grok Build the file still reaches every builder's copy), judges open only the slate paths their
spawn text names under `.rl-scratch/slates/<panel>/`, and builders commit only the paths they changed, by name, never `git add -A`. (4.5
round 2 — without those lines a builder's copy carried the live RESUME block and a candidate that
committed it could not be promoted cleanly.)

**Backstop: the kit's hook**, placed by START-HERE, whose exact rules are written in section 2 of the
context file the kit puts beside it (`CLAUDE.md` or `AGENTS.md`). That file is the authority on what
is denied and for whom; this document and the prompt no longer paraphrase it, because the paraphrase
was wrong in four places when 4.0 audited it. In one breath: the sealed suite and the criterion list
are never edited once written, nothing under `gauntlet/` is deleted or renamed except the `PENDING`
lock, the ledger is append-only for everyone, and on Claude Code — where the payload carries the
caller — builders and judges touch nothing under `gauntlet/` at all. `workbench.md` lives at the repo
root and is outside all of it.

**Probe it behaviourally, the way the context file says**, because the two CLIs prove it differently:
on Claude Code a throwaway builder's write under `gauntlet/` is denied by role; on Grok Build the
current hook uses `subagentType` when supplied and falls back to universal write protections
when it is absent. Prove from the orchestrator's own shell that a throwaway builder's worktree holds no `gauntlet/` —
never ask the builder, whom the hook denies any call naming it — and test
role denial through the actual dispatcher where identity exists. Keep synthetic script probes
separate from installation proof. A hook matching nothing loads perfectly and denies nothing.

**What is measured, and what is open.** A trailing dot walked through every rule on Windows and
deleted a whole tree — closed. A junction defeated command-text matching — closed. `node -e`,
`python -c`, `[IO.File]::WriteAllText` and the PowerShell aliases `del`, `ri`, `sc` bypassed the deny
— closed. **Still open, and documented as open:** a command that assembles the path from pieces, a
wildcard, a `cd` first, or a compiled helper. The mitigation is that tampering is loud in the ledger,
not that it is impossible.

**Clean checkouts, in three steps and never as a pipe:**

```
mkdir <dir>
git archive --format=tar -o <dir>.tar <sha>
tar -xf <dir>.tar -C <dir>/
```

`git archive <sha> | tar -x` is the obvious form and it **corrupts the archive under PowerShell**,
whose pipeline carries objects rather than bytes — and PowerShell is the shell on Windows without Git
Bash. **The `mkdir` is not tidiness:** `tar -xf … -C <dir>/` against a directory that does not exist
exits 1 with *"could not chdir"*, measured on this machine, and a round that reads that as a failed
checkout re-runs the whole preparation. Confirm the extraction is non-empty before building: an
empty checkout that "builds" passes every entry vacuously.

---

## 11. Harness mapping

The generated prompt carries a per-harness table with the exact primitives, and it is the authority
because it is re-checked against primary documentation on every release. Six facts each silently void
a gate if they are wrong, so they are stated there rather than here: how a subagent is spawned, how a
completed one is resumed so calibration binds to the judge that rules, how a model is pinned, the
nesting and concurrency limits, where hooks live and what a deny payload looks like, and how an
isolated build behaves.

Four things are proved at **setup**, before round 0 spends anything. **Which window this is**: the
brief and kit were generated for one CLI, and a kit opened in the other has a hook that window never
reads and role files it never loads — every run in the fleet that died had been generated for one
CLI and run in the other. That mismatch is written as the first line of `workbench.md` with its fix,
and the run stops before round 0; the same check stops a run handed the prompt with no kit on disk.
It is one of setup's two stops, and neither costs work. Then one throwaway
subagent that returns a word it was handed, in the background, collected by id; one shell command
whose output can be read back; and how this harness tells the orchestrator a child has finished,
which decides how the deadline in §5.4 is kept. All four are written down, or this run cannot happen,
and the first minute is the cheapest possible moment to know it. A throwaway child that would not
spawn, a read-back that failed, or a wake that never came, is the second refusal to start; a tool listed under another name
is neither.

**The role files.** The kit ships one agent definition per role for the CLI it was generated for —
builder, critic, preparer, judge-a and judge-b — with the role word in each name because the hook
resolves a child's permissions from it, judges held to reading, the critic given the full tool set,
and a model slot in each judge file so two families can be pinned and crossed against the two
presentation orders. Models are pinned there and never through the environment or the spawn: a spawn-time model
outranks the file on both CLIs, and on Claude the precedence between an environment variable and
the file has reversed across releases.

**Seven rows moved in 4.2, from a desk-run of the kit rather than from a document.** They are in the
prompt's harness tables, where a run reads them, and listed here so the manual and the prompt do not
disagree about what the harness does:

- **`builder.md` requests `isolation: worktree`.** Inspect the installed Agent tool schema
  rather than assuming an old list of accepted arguments. Verify the returned directory and
  initial SHA before judging any work.
- **Use fresh named roles and verify their context boundary.** Installed fork/isolation options
  can differ. A role file or a model's self-report is not proof of blindness; retain harness
  provenance and canary checks. Any judge exposed to candidate identity is ineligible.
- **Claude's not-in-turn waiting branch has a floor.** Where a completion notification is what starts
  the next turn (§5.4), the run writes the wall-clock time of the **latest open deadline** in
  `workbench.md` before it ends the turn, and says there that silence past it means the turn never
  resumed. On any turn that does start, the first act — before reading any result — is to compare
  every open child against its deadline and stop the ones past it.
- **Round 0 step 7 commits the artifact and `run.json` only.** The owner's harness lives under
  `gauntlet/`, which is gitignored, and `git add` of that path is **refused** (measured): forcing it
  in copies a check body into every builder's worktree, and the suite runs from the repo root anyway.
- **`mkdir` before the `git archive` two-step**, or `tar` exits 1 (§10, measured).
- **On Grok Build, `cost` is tokens from `grok usage $GROK_SESSION_ID` at each round boundary, as a
  *difference* from the previous boundary** — or the round's completed children summed with
  `grok usage <subagent_id>` while the session reports no usage — with the running total kept in
  `workbench.md`. A missing reading is not a reason to land or to ask. Where the session reports no
  number at all the field is **`null`, never `0`** — `0` reads as a cheap round and brakes the landing
  rule with a figure nobody measured.
- **A pinned model is confirmed per judge before its first slate**, from the harness's resolved
  model metadata or an attributed launch/result record. Record the source with the id and family;
  do not promote a judge's self-description into provenance. If the harness cannot confirm it,
  the panel is INVALID. Same-family tiers or a sole-model account are disclosed limitations under
  §7.2, never an invented cross-family panel.

---

## 12. Stopping

**There is one ending the run may declare, and it is the human's cap.**

Where the caps section names a number, that number halts the run — and it says to stop **before** the
round that would cross it rather than during one, because a round that runs out halfway leaves no
verdict and nothing promoted. **Where it says none was set, none was meant.**

*Two refusals to start sit outside this list and are named in the prompt's stop conditions for that
reason: the window check at setup (§11) — a kit whose hook this CLI never reads, or no kit on disk at all, is a run with no
boundary — and a setup probe that failed: a throwaway child that would not spawn, a shell read-back
that failed or a wake (completion or alarm) that never started a turn, never a tool's name. Both cost no work because nothing has been built when they fire.
An unread spend and a missing wake-up are on no list: the run records them and carries on (§5.4,
§11).*

**Everything else is keep going.** No gap → §5.2a, in order. A sealed check failed, a duel lost, a
round where nothing was material, a panel that could not be seated, a state nobody could enter →
**park it and take the next gap the critic named.** A parked gap is not a solved gap and the ledger
says so.

**And the attempts are counted on the ledger, because a context's memory of them ends at the next
compaction.** `gap_attempts` is **1** on the round a gap is first assigned and **one more on every
later round that assigns the same gap, whatever the verdict**. **At three, the gap is parked** after that round's verdict — three attempts, never a fourth —
whether or not anyone called it blocked. Two rounds that could not move a gap are difficulty; a
third is the loop paying to guess at the same thing again. (Until 4.2 this list ended "a gap still
blocked after two attempts", which defined neither *blocked* nor *attempt* and had no field on the
line to count in — a rule whose state lived only in the orchestrator's head, which is the one place
§13 says no rule may live.) **A reopened parked gap starts its count again**: `gap_attempts` is 1 on
the round §5.2a step 3 reopens it, because the count that parked it was against a champion that no
longer exists; the line says it was reopened, and `parked_total` does not go down. Without that
sentence a reopened gap arrived at three and parked itself on the spot — 4.3, from an independent
read.

**There is no word in the prompt for "I have finished", and that absence is deliberate.**

*This is the largest behavioural change in 3.0 and the one with the most evidence behind it. Every
early stop anyone has measured came out of a vocabulary this method supplied. A run wrote CONVERGED
over three rounds that built nothing and ran no duel — a state whose own definition requires three
decisive duel verdicts. A run stopped at a self-chosen round 8 while its author had left the cap
blank, having taken the number out of this document's own cautionary example. A run reported it had
"run out of time" when nothing in a run measures time. A run stopped to ask permission for an action
it had just proved correct. CONVERGED, JAMMED, DEGRADING and STALLED are deleted outright.*

**An interruption preserves the last accepted checkpoint, not the interrupted round's spend.**
The ledgered champion remains deliverable at a boundary. A multi-piece run still has the assembly
limitation in §5: intact piece champions do not prove an integrated whole. A killed session leaves
resumable state, not a completed objective or permission to invent a finish line.

**Low context is not a reason to end the run.** A compaction is something that happens to
the run, after which it reads the RESUME block and starts the next round. The first 4.0 run stopped
at a round boundary "on context" with a context that had just compacted to about two-thirds of its size
— because the Grok `/goal` hand-off said the objective was complete when the run "has stopped — on
the cap I set, on the harness, or on the context", and this paragraph listed the context beside the
cap. Both read as permission. 4.1 removes the word from both: the objective completes only when a
cap fires or the human stops the run, and a session that dies leaves a resumable state, not a
completed goal.

*Corrected 2026-09-02: 4.1 repaired the Grok hand-off and this paragraph, and left both Claude
hand-offs as they were, while this section claimed the repair had landed in "both". 4.2 carries the
same rule in all four hand-off lines the upper tiers ship — **finished only when a cap the human set
has fired or the human has stopped the run** (4.5 adds the run's own integrity-fault or SETUP stop,
written in `workbench.md`, which a `/goal` review could otherwise never certify), low context named as not a reason to stop, and a
session death named as a resumable state rather than a completed objective — and
the claim above is true as of that release rather than the one that made it. A repair recorded in the
document as done on a document that did not have it is defect class 2.2, and it is the second time
this project has shipped one against a hand-off line.*

**Every round boundary writes three things and they are not optional:** the ledger line, the champion
round id and SHA on it, and the RESUME block rewritten in `workbench.md`. Those three are what make
the paragraph above true.

### 12.1 When nobody is there: park, never ask

A run that asks a question has failed, however good its reasoning was. A run that pauses because a
context ended has not.

**The one exception that ends a run is an integrity fault** (§9): the record disagrees with itself, so
nothing written after it can be checked by anybody, and there is nothing a human could answer. Write
what changed, deliver the last champion whose snapshot still matches, stop.

Everything else is difficulty, and difficulty does not end a run. A judgement call about the
*artifact* is the human's; a judgement call about *how to keep working* is the run's.

Ending a thirty-round run at round eleven because one gap was blocked forfeits nineteen rounds a
plain Gauntlet run would have spent improving something else. That, and not any gate, is how this
method loses to the loop it improves on.

### 12.2 PAUSED, and the RESUME block

Running low on context is not an ending. Carry on — landing early because a compaction *might* happen
spends the whole remaining run to avoid a cost nobody measured. If the run truly cannot, write
`"state":"PAUSED"` on the ledger line, **at a round boundary and never mid-round**, with the RESUME
block written and true. A pause ends the session, not the run, and it is addressed to the next session
rather than to the human.

**The RESUME block is written at every round boundary, not only when the run pauses**, because
sessions that end mostly do not get to choose: a context fills, a harness kills a process, a machine
reboots. A handover that exists only when someone decided to write one is exactly the handover that is
missing when it matters. **Rewritten, never appended**, between the markers `[RESUME]` and
`[/RESUME]` at the top of `workbench.md`: it states what is true now and never grows.

**Measured, which is why it is worth the two minutes.** Real sessions of this method ran 8h41m, 8h00m
and 8h42m; the resumes after them ran 2h00m and 24m32s, each shorter than the last because a fresh
context spends its first hour re-reading before it can work. **Nothing written here makes a context
bigger.** What the block does is make that re-read a page instead of a run.

**Seven lines, in order:**

1. `RESUME R00NN` — the round to **start**, already computed. Not "R0008 finished".
2. the champion round id and commit SHA, and that HEAD is that SHA.
3. per piece: the ledger path, its line count, whether a `PENDING` is there.
4. the standard in force: `criteria_sha`, the rubric version and its sha, and the calibration
   control refs under `refs/gauntlet/controls/`.
5. **the open gap and what has already been tried on it** — one line per dead direction and how it
   died. This stops a fresh context buying a direction this run already paid for, and it is the one
   line that is expensive to reconstruct from the ledger alone.
6. coverage: the never-entered ids, the three least-visited assigned this round, parked gaps oldest
   first.
7. anything still running or still on disk to clean up, then the next steps in order — **and this
   line is rewritten the moment anything removable is created**: each worktree path, each clean
   checkout, each server's port and PID, **as they are made**, not when the round ends. A round that
   dies in the middle is the only case this line exists for, and it is the one case a
   round-boundary rewrite cannot cover. (4.2. Until then the whole block was written at boundaries
   only, so the line that lists what to clean up was guaranteed to be empty in exactly the state
   that needs it — a rule stated only inside a branch the run may never take.)

**On startup, read that block and the last ledger line and nothing else historical.** Where the two
disagree, **the ledger wins**: the block is stale, re-derive from the file, and say so on the line
being written.

A ledger with a complete round record means **setup is done and round 0 is over; do neither again.**
A probe line or malformed tail is not a completed round. If criteria already exists without a round
record, never recreate or repair it silently: where the brief carries an enumerated list, verify the
file against it; where it does not, the file is the run's own derived list — confirm `workbench.md`
records deriving it, write `derived:true` on the first line, and continue setup after that write.
Only a file that contradicts an enumerated brief is an integrity fault. The one line a
human pastes says "starting at round 0", and a resumed run that starts there dies on §4.1's first
sentence — `criteria.md` is create-once, it exists, and the hook denies the second write. That denial
is the rule working.

### 12.3 Ending a turn is ending the run

A turn ends when the agent stops calling tools, so a run that writes a tidy status paragraph and
falls silent **has stopped**, whatever it believes about coming back. Three real runs ended that way
with their own next action named in their own last line, no PAUSED line, an open assignment, and a
human who could not tell any of them from a crashed process.

**While an assignment is open, the next thing produced is the next unit of work, not a report about
the last one.** A report *at* a boundary is correct and `workbench.md` is where it goes; a report
*instead of* the next act is the defect, and the two look identical until you notice nothing was
spawned after it.

- After a build → rule the candidates material or no-op and run the sealed check.
- After a duel settles → the next duel, or the decision it feeds.
- After a round ends → append the line, rewrite the RESUME block, **start the next round**.

**And never a request that the human approve a next action the run has already worked out.** If it
has named the action, it is the one that runs it. If what it is about to hand back ends in a question
mark, it has not finished.

**If the turn does end, the line is written first** — disk before prose, always, because a human
coming back tells *paused deliberately* from *stopped talking* by reading the last ledger line, and a
summary in a chat window is not a state.

**Write `workbench.md` as you go, not at the end of a round.** From outside, a working run and a stuck
one look identical. One line when each phase starts and ends, with the wall-clock time, the round,
the phase and the child's id, so a dead child has a name. The phases are the round's own, in the
order it runs them — **build, gate1, selection, gate2, critique, coherence, promote** (§5.3) — and
three builders get three build lines, so a fan-out that quietly became one build is visible. If that file goes quiet for more than ten
minutes, a watching human cannot tell the run from a hung process and will kill one that was working
— so while the run waits on children it is still writing to it (§5.4).

### 12.4 The progress page, and the machine

**A live progress page ships in every tier.** One file, `progress.html`, at the repo root beside
`workbench.md`, rewritten every time the workbench is appended to, self-refreshing, self-contained —
no server, no build step, no dependency — so the owner opens it with a double click on a laptop with
nothing installed. In the upper tiers it shows, per piece: the champion round and SHA, the round in
progress, the last pick against the bar and the last gap named, the last duel's verdict and margins,
the assignment currently running with its deadline, and the time of the last update at the top —
and the owner's two stopping signals: spend so far against the cap (or SPEND UNREAD), the median
round cost and the rounds it still affords; and the trend, the last ten bar picks in order,
promotions out of rounds run and rounds since the last promotion. They are the owner's, never the
run's: not targets, and never an ending. It is a window, not a target: nothing on it is a score, nothing on it is something to improve, and if
writing it ever competes with the build it is written more roughly rather than less often. It does
not carry the Gauntlet's "was the critic wowed" line, which in these tiers would be a word for
finishing (§12).

**The machine is part of the run.** Free disk is checked at every round boundary; if the next round's
checkouts will not fit, the run cleans what it owns by path, and if they still will not, it ends at
that boundary as PAUSED with the reason written — a session ending, not a stop and not an open-ended
wait. (4.5 — 4.4 *held* the run on a floor it chose itself, with nothing to wake it.) A build into a full disk is a dead child with extra steps, and
disk exhaustion killed more agents in the fleet than any rule in this document. Every server the run
starts is written in `workbench.md` with its port and PID, killed by that PID at the round's end, and
never trusted on its port alone: the run checks the socket's owning PID before it reads anything off
it, because another run's champion once answered on a neighbour's port and was nearly graded as this
run's challenger.

---

## 13. What you deliver

**The champion, by round id and commit SHA.** Not the working tree. Not the last thing built.

**And restore it to the working tree as part of landing.** If the last round lost, the tree holds the
loser while the champion sits in `gauntlet/<piece>/champion/` where nobody thinks to look. A run that
ends with the wrong version checked out has handed back the one outcome this method exists to
prevent, and it looks like success until someone diffs it.

Report the champion round and SHA, the sealed verdicts, coverage as entered and never entered, the
duel record, the calibration pass rate, the dead children, and the ledger.

### Ledger line — one per round, append only

Appended to `gauntlet/<piece>/ledger.jsonl`, never rewritten. The hook enforces exactly that: `>>`
and `Add-Content` are allowed; a `Write`, an overwrite and a rewrite are denied.

```json
{"round":"R0008","piece":"<piece>","sha":"<commit>",
 "criteria_sha":"<sha256 of criteria.md>","derived":false,
 "rubric_sha":"<sha256>","rubric_version":1,
 "decomposition":{"pieces":["sim","hud"],"fixed":"R0000",
                  "evidence":"hud reads the published frame snapshot only"},
 "gap":"<gap targeted>","gap_attempts":1,"approach":"<direction taken>",
 "fanout":{"built":3,"chosen":"c2","by":"selection-duel",
           "directions":["volumetric fog","per-tile cache","shader-only"],
           "material":[true,true,false],
           "dead":[{"id":"c1","sha":"<commit>","branch":"dead/R0008-c1"}]},
 "sealed":{"n":7,"green":6,"na":1,"unrunnable":0,"failed":0},
 "bar_pick":"ours","coherence":false,
 "adjudication":{"input":"inbox/R0008-panel.json","output":"inbox/R0008-verdict.json"},
 "duel":{"orders":["B","B","A","B"],"models":["<slug>","<slug>","<slug>","<slug>"],
         "builder_model":"<slug>","calibrated":4,"respawns":0,
         "margins":[[6,2],[5,3],[4,4],[6,2]],"normaliser_residual":"len +3%, shape ok",
         "escalated":false,"first":null,"result":"WIN"},
 "panels":[{"kind":"selection","judges":2,"answered":2},
           {"kind":"gate2","calibrated":4,"seated":4}],
 "children":{"spawned":11,"dead":0,"respawned":0},
 "wall_ms":{"build":540000,"gate1":90000,"selection":600000,"gate2":900000,
            "critique":300000,"coherence":0,"promote":60000},
 "cost":<what this round spent, or null>,
 "coverage":{"states":24,"entered_this_round":["s07","s18","s21"],
             "never_entered":["s19","s23"],"least_visited_assigned":["s19","s21","s23"]},
 "no_gap":null,
 "promoted":true,"rounds_since_promotion":0,"parked":[],"parked_total":0,
 "state":"RUNNING","manifest":"<sha256>"}
```

**Every rule that spans rounds has a slot here**, deliberately: a context is not durable, so a rule
whose state lives only in the orchestrator's head ends at the next compaction. Derive every count
from the ledger, never from memory.

- `duel` is **null** on a round that ran none, written as a value rather than left out and never as
  an empty object.
- `panels` is **every** duel the round held, in run order. A **Gate 2** panel carries `calibrated`
  and `seated` — `seated` as the **count** that sat, and a panel short because a child died is left
  out of the 9-of-10 seating window entirely. A **selection** panel has no pack, so it carries
  `judges` and `answered` instead and is never described as seated (§7.2).
- `gap_attempts` is **1** when a gap is first assigned and one more on every later round that
  assigns the same gap, whatever the verdict; at **three** the gap is parked (§12). It is on the line
  rather than in the orchestrator's head because it is the only place a count survives a compaction.
- `wall_ms` is the measured clock per phase, **in the order the round runs them** (§5.3), and is what
  the deadline rule in §5.4 reads — a phase is
  `0` on a round that did not run it, and a phase with no reading on the last three lines takes the
  ninety-minute deadline; `cost` is
  what the round spent in the unit the caps name, and is what the landing rule reads, `null` where
  the harness reports no number and never `0` (§11) — on Grok Build it is the token difference from
  `grok usage $GROK_SESSION_ID` between boundaries (or the round's completed children, which
  undercount the orchestrator's own turn), on Claude Code the difference in `gauntlet/cost.json`, which
  the kit's statusLine command writes from the harness's own cost payload (§14.1). `duel.first` is
  the verdict an escalation overrode when `escalated` is true, and `null` otherwise. `children`
  is the two-dead-children bound made visible, and it counts: three builders, a preparer, two
  selection judges, four judges and a critic is the eleven in the example above, with `respawns`
  agreeing with `respawned`. `bar_pick` is the critic's verdict against the bar;
  `coherence` marks the round that ran the pass in §5.5; `derived` marks a criterion list the run
  wrote itself.
- `coverage` and `decomposition` are **carried on every line**, never only when they change. `pieces`
  that change on any line is an integrity fault — the natural failure after a compaction is to
  re-emit the empty example above.
- `parked` lists the gaps closed to work this round; `parked_total` is the running count, which cannot
  be read off one line otherwise.

*4.0 removed `open_blind_spots` with the harvest (§8.0) and added the seven fields the survival rules
read. A slot for a rule that no longer exists is a slot a resuming context will try to fill.*

*4.2 added `gap_attempts`, reordered `wall_ms` to the phase order, and replaced the selection panel's
`calibrated`/`seated` pair with `judges`/`answered`. It also repaired the example itself: it had
carried `respawns:1` beside `respawned:0` and nine spawned children for a round that spawns eleven,
and an example a resuming context copies is a schema whatever the prose around it says.*

*4.3 moved `coherence` before `promote` in `wall_ms`, to match the corrected phase order; replaced
the example's `"cost":0` with a placeholder, because the rule beside it says `0` is a reading and
an example a compaction re-emits is a schema; defined `duel.first`; and gave the Duel tier's own
ledger example the `sealed`, `parked`, `derived` and `selection` slots its prose already required.*

*2.4's line carried thirty-one fields. Twelve of them recorded machinery this release deleted —
`admission`, `harvest`'s outcome half, `corridor`, `extension`, `extends`, `cut_defect`, `gate1`,
`rubric_repair`, `regressions`, `cost_regressions`, `new_passes` and the GATE/HOLDOUT halves of
`sealed`. A slot for a rule that no longer exists is a slot a resuming context will try to fill.*

---

## 14. Cost, and the record of why the machinery went

**This section is the evidence that authorised 3.0, and it is kept in full.** The measurements that
justify deleting a mechanism are more valuable than the mechanism was; deleting them alongside it
would leave the next revision free to rebuild the whole thing from first principles.

### 14.1 What a round costs now

Multiples are against one plain Gauntlet round (1×, itself unmeasured), **estimated from what a
round spawns, not measured**: the Duel runs ~2.5–3× and the Ratchet ~3–3.5×.

| Round type | What it spends | Multiple |
|---|---|---|
| **No promotion** | 3 builds, a clean checkout per material candidate for Gate 1, up to 2 selection duels on 2 uncalibrated judges each, 2 cold clean builds for the champion duel, 4 judges and 4 ten-item calibration packs | **~3×** |
| **Promoting** | the same, plus freezing the champion and re-preparing | **~3.5×** |
| **Split → escalation** | one more panel, drawn differently, freshly calibrated | **+~1.5×** |
| **Nothing material** | no duel spent, the same assignment re-issued | **~1.5×** |

**Gate 1 costs a clean checkout per material candidate now, not one on the winner** — up to two more
on a three-candidate round (§6). The multiples are unchanged, because a checkout is not an agent call
and the agents are the bill; if that ever stops being true on some harness, this is the row where it
will show.

**Judges are the whole bill, and the lever is the number of *rounds* bought rather than the number of
judges inside one.** **Do not drop to two judges on the champion duel:** two is not a cheaper gate,
it is the quorum rule's own definition of a panel that did not seat (§7.2), and a round that does not
seat a panel has no verdict row — it spends two judges and buys nothing. Do not economise by skipping
calibration either: an uncalibrated panel is not a cheaper gate, it is no gate. **If cost is the
binding constraint, run fewer rounds, or run the plain Gauntlet Loop rather than running this one
badly.** (Until 4.2 this paragraph offered the two-judge duel as a saving, in a document whose own
quorum rule voids it — a rule contradicted by the section that prices it. The Duel tier's own cost
section kept offering it until 4.3.)

**Where the number the brake reads comes from.** Grok Build reports tokens through `grok usage`, and the
run writes the difference between boundaries into `cost`; while the session reports no usage, the
completed children's sum undercounts the orchestrator's own turn, so the landing estimate adds its share. Claude's interactive kit uses a
status-line hook (`cost-line.mjs`) that atomically writes session-identified estimated USD to
`gauntlet/cost.json`. A same-session nondecreasing counter yields a delta; for a new session add
its current reading to the previously recorded run spend rather than subtracting another
session's counter or resetting the allowance. Missing session identity, a stale reading, an
unexpected reset, or unknown pricing means `cost:null`, not free work. Persist the accounted
session IDs and totals in `workbench.md`; the file itself is a latest reading, not a run ledger.
Claude print mode has `--max-budget-usd`, which this interactive kit does not enable. Estimates
are not bills and boundary predictions can overshoot; keep provider-side spending limits.

### 14.2 What it used to cost

These are the rows 2.4 published, kept so the size of the change is legible rather than asserted.

| Round type | What it spent | Multiple |
|---|---|---|
| **Non-promoting** (died at Gate 1) | 3 builds and 3 clean checkouts + N witness judges; plus a full re-admission per burned entry | **~3.5× (up to ~7× on a burn)** |
| **Promoting, no new entries** | 3 builds + a selection duel + 2 cold builds + 4 judges and 4 calibration packs | **~8×** |
| **Promoting, k new entries** | + per candidate: 6–7 mutant builds, 5 stability runs, 1 re-derivation agent and its runs, and a second stability pass on the re-derived check | **~10–16×** |
| **Corridor** | up to 3 rounds with no Gate 1, then the full suite once and a duel; a discarded corridor bought nothing at all | **~3× for up to 3 rounds** |

**Admission dominated a promoting round.** That was the price of a regression suite you could trust —
and §14.3 is the measurement of what that trust was worth.

### 14.3 The head-to-head this method lost

Both loops were run on one brief, one piece, three rounds, the same ten-criterion bar, cost
disregarded. The ratchet took **5.7× the wall clock and 8.7× the agent calls**, and a blind panel of
four judges across two model families **preferred the plain Gauntlet's artifact or tied it,
unanimously — none preferred the ratchet's**. Its regression suite caught **nothing**: six
challengers, ten mutation-validated checks, zero regressions detected, both promotions decided by the
duel.

What the same run also showed, and the reason a champion is still worth keeping: **each loop shipped a
real defect the other caught.** The duel found page text illegible behind the palette's own scrim and
drove it from 1.65:1 to 8.53:1 across two rounds; the plain Gauntlet shipped that same defect at
3.25:1 (the three contrast ratios are that session's own readings and the repo holds no harness
output for them — unreproduced, recorded as reported). The plain Gauntlet's critic found focus
stranding on a backdrop click; the ratchet shipped that one. **The duel and the critic see different things** — which is why 3.0 keeps both and drops
what sat between them.

### 14.4 The hardest number anyone has on this method

Two lineages were re-measured afterwards by a harness neither loop wrote: the ratchet's three
champions, and **six rounds of a plain build/critique loop on a deliberately coupled artifact** —
movement, collision, an inventory, a carry limit, a derived score, save/load and a HUD, all depending
on each other, built with **no regression protection whatsoever**.

**Eight round-to-round transitions. Zero regressions.** Not one probe that passed at round N failed at
round N+1. Together with the head-to-head's six challenger gradings — which are not round-to-round
transitions and were not independently re-measured — that is **fourteen checks and zero events**;
where this document says "fourteen" bare, this is the arithmetic it means, and eight is the number
that was re-measured by a harness neither loop wrote. A ratchet is insurance against silent
backslide, and the insured event did not occur in any measurement anyone has taken.

**The failure that *did* show up is a different one, and no ratchet addresses it**: a defect present
in round 0 that no critic named until round 5, after which the loop stopped. Clicking a control left
it focused, so a later `Space` re-fired it and discarded a live game. It was there from the first
build and survived every round. Freezing what you already have does nothing about that — what finds it
is **more eyes on more states**, which is the fan-out (§5.0) and coverage (§5.2).

### 14.5 The counter-argument, which is not weak

**Every measurement against the regression suite was taken where this document already said it does
not pay** — one piece, three rounds, six-round lineages. The conditions it was designed for — thirty
rounds, five parallel pieces, sessions that get compacted — have never been measured, and §14 said so
in every release that carried the suite. A reasonable person can say the ratchet has not failed its
test; it has not been given one.

That argument is recorded rather than accepted, for three reasons. The suite was carried for eleven
revisions and grew to about half the prompt while waiting for its conditions. **Prompt size is the
direct input to the only stop that killed three runs** — a mandated startup read of somewhere between
a quarter of a million and 350,000 characters against a 200k-token window (two contemporaneous
readings of that startup read disagree, 248,000 and 347,000, and neither kept its recipe; the
project's ground-truth record says so rather than picking one). *(4.5: the later fleet deaths were a multi-id wait, not size, and contexts past 400k tokens have
since been observed; what size still costs is re-read time and room for contradictions, which is
why 4.5 stops mandating a read of this document.)* And a mechanism that has never been exercised is not
protection; it is an untested claim that a future run would discover the hard way.

**The honest experiment is a coupled probe at 20+ rounds and 3+ pieces, not another rule.** If anyone
runs one and it shows backslide, this section is where the case for rebuilding the suite starts.

**And the honest scoreboard, as of 4.0, is that the plain Gauntlet has won the only controlled
comparison this method has been given**, at a length where this section says the method does not
pay. Seven multi-day runs since then produced a fleet of survival data and no second head-to-head:
three tiers, two models, one brief, one machine, and the tiers never finished together. Nobody can
yet say the Ratchet builds a better artifact than the Gauntlet; what can be said is that it did not
die more often once the waiting rule existed (§5.4), that its runs resume where the Gauntlet's
cannot (§12.2), and that it found the class of defect six fresh critics could not (§5.2). The
protocol that would settle the rest — same brief, same bar, same cap, both methods, both CLIs, one
blind panel over every delivered artifact served from a clean checkout by SHA — ships with the
project as `tools/experiment/PROTOCOL.md`, with a tool that reads the ledgers into its columns. Until
someone runs it, "better than the Gauntlet" is a claim about survival and memory, not about the
artifact, and this document says so rather than implying otherwise.

### 14.6 What was cut, and what each cut was measured against

The character counts in this table are the readings taken when each cut was made, from the prompt
source of that day; the project's ground-truth record holds other readings of some of the same
sections from other days that do not agree with these, and no recipe was kept for any of them. Read
them as the order of magnitude each cut was, not as figures anyone can re-run.

| Cut | Evidence sought, and not found |
|---|---|
| **Gate 1, the frozen regression suite** (3,791 chars) | zero regressions across 6 challengers and 8 independently re-measured transitions in two lineages |
| **Mutation admission**, five legs (18,750 + ~8,300 downstream) | one catch, and it was about the suite rather than the artifact; it also generated the "may I run a second pass?" question that failed the owner's zero-input standard |
| **The derived sealed bar** (~12,000) | five repairs, four of six measurements wrong, two actively harmful, never ran in a paid round |
| **GATE / HOLDOUT** (~2,500) | its only measured event was a bug that moved two binding floors into the half that cannot fail a round |
| **The two cost floors as round-enders** (~1,500) | their only measured effect was telling a healthy run that had won 4-of-4 twice that it was degrading |
| **The redesign corridor, retirement, quarantine, burning, re-anchoring** | all downstream of Gate 1; none was ever cited catching anything |
| **The decomposition test** (8,298) | written two days before the audit, never exercised. Only the bias sentence survives (§5.1) |
| **Terminal-state vocabulary** (12,171 → ~1,200) | three wrong stops came out of it and none came from anywhere else (§12) |
| **The criterion extension** | never exercised; four of its five evidence legs cited machinery now deleted |
| **Ledger schema prose** (13,618 → ~2,000) | twelve of thirty-one fields recorded machinery that no longer exists |
| **The harvest and `open_blind_spots`** (4.0) | one cited catch; after 3.0 narrowed the trigger, no recorded firing. Cut on cost, not on the count — the count names no ledger (§8.0) |

**Set a hard budget before you start.** `--budget` on Grok Build; on Claude Code, name a ceiling in
the brief and let the run hold itself to `gauntlet/cost.json` (§14.1) while you watch `/cost` too.
Runs of this shape still reach hundreds of dollars. **You are the brake.**

---

## 15. What this does not fix

- **Coupled systems.** If lighting, tonemapping and materials are one system, fanning them out to
  three parallel builders produces regressions no ratchet can prevent — and 3.0 does not even detect
  them, because the suite that claimed to is gone and never did. Give coupled work a single owner.
  §5.1 is the whole of the answer: **if it is unclear, one piece.**
- **Silent backslide on a long run.** This is what 3.0 gives up, stated plainly. Protection against a
  round-thirty regression on a five-piece brief is real in principle, was never once exercised by any
  measurement, and cost about four fifths of the prompt. §14.5 is the case for putting it back and
  what would have to be measured first.
- **A session that is shorter than the run.** The one hand-back no wording removes. Measured sessions
  of 8h41m, 8h00m and 8h42m, then resumes of 2h00m and 24m32s, each shorter because a fresh context
  re-reads before it can work. §12.2's RESUME block makes that re-read a page — which shortens the tax
  and does not remove it. **Closing this needs external automation**: a supervisor that starts a fresh
  session per round and hands it the block. No wording in this document lengthens a context window,
  and a version of this section that implied otherwise would be the same defect as a comment
  describing code nobody wrote.
- **A vague bar.** Still the number one failure. Every gate here makes a bad bar *expensive* as well
  as useless.
- **Local optima.** A champion that only moves on a blind win is monotone on a non-monotone quality
  surface. 2.4 mitigated this with a corridor that could descend for up to three rounds; the corridor
  was downstream of Gate 1 and went with it. Reaching an artifact that needs a transient regression is
  now a human decision.
- **A criterion list that is not what you actually wanted.** §8.1's sealed suite is the counter, and it
  is only as good as what you put in it. **One scenario you wrote yourself is worth more than every
  derived threshold together.**
- **A malicious orchestrator.** §9 detects accidents, not adversaries.
- **Novel work with no existing benchmark.** The critic will invent a standard. Front-load a planning
  pass that produces a pass/fail answer key first, and use *that* as the bar.

---

*The Ratchet Loop builds on the Gauntlet Loop by Matt Shumer. Prior art credited in §2.*