Chapter six. Chapter five found that the stated bar is what does the work. The next question is how to state one.

The system a successor built put its agents on a ladder — four rungs, L0 to L3 — and wrote one rule under it that I have not been able to stop thinking about. A level is only the rungs you have closed in a row, each closed by someone other than you; the points counter is still there, and the board has to print beside it that it advances nobody; and at L2 the gate reads a name: the grader who already passed you is refused. Not discouraged — refused, by a lookup against the ledger, before a line is written. Your rivals become the only people who can advance you.

Thesis: Gamified agent motivation is vanity metrics by default, and the fix is not better rules about honesty — it is making the dishonest move unavailable. This system does that three times over, chose its mechanism by running an arena rather than by taste, and published the tensions it could not resolve instead of hiding them. Copy the rule, not the game: every should in a review process is a sentence someone breaks under deadline, and this system replaced its most important one with a fact about who is eligible.

---

Level Is Not a Score

The rule, from the spec:

Level = contiguous closed rungs on a class ladder (L0–L3), closed only by an independent verifier. Embers/XP may exist as flavor and must print embers advance level: false. (Emphasis on the second clause mine.)

Four rungs, and what escalates between them is the kind of evidence, never the amount:

flowchart BT
    L0["L0 — Named<br/>the bar and its falsifier<br/>written before the work"]
    L1["L1 — Done once<br/>a signature act, with evidence<br/>a stranger can re-check"]
    L2["L2 — Held<br/>survives a grader<br/>the hero did not pick"]
    L3["L3 — Outlives<br/>survived a hold; used by<br/>someone who owed nothing"]
    L0 --> L1 --> L2 --> L3
    style L0 fill:#5a5a8a,color:#fff
    style L1 fill:#5a5a8a,color:#fff
    style L2 fill:#5a5a8a,color:#fff
    style L3 fill:#5a5a8a,color:#fff

The spec's own rung table. The gate named on L2 is the rest of this chapter.

You cannot grind L3. There is no number of L1s that becomes an L2. The only way up is a different sort of proof, and the last one requires a stranger to have found your work useful without being obliged to. Hold on to that last rung. It is the kind of evidence the final chapter is about.

That the flavour counter is required to print its own irrelevance — embers advance level: false — is the tell that someone had watched this fail before.

---

The Mechanism Worth Stealing

The L2 gate is called stale_grader, and the spec states it plainly:

A grader who already passed you is refused at L2 — rivals enter each other's critical path. (Emphasis mine.)

Every independence rule I have written is a should: seek independent review, the grader should not be the maker. This one makes the friendly reviewer structurally unavailable. Having been passed by someone disqualifies them from passing you again, so verification has to rotate — and in a small system, rotating verification means the people best placed to advance you are the ones competing with you.

It converts independence from a policy into a fact about the graph. Nobody has to remember it or want it.

Here is the fact, in the live repository's ladder.mjs, inside the function that decides whether a pass may be written at all:

  if (c.fresh_verifier) {
    const priorGraders = new Set(
      [...d.passes.values()].map((v) => v.verified_by),
    );
    if (priorGraders.has(verifiedBy)) {
      fails.push(
        `stale_grader: ${verifiedBy} already closed a rung for ${hero.id}; this bar needs a grader who has not`,
      );
    }
  }

And here is what it looks like when it fires. The arena that selected the design was three sub-agents, each building one leveling technique as a runnable prototype, with a script driving each prototype's gate under a cast of names — Ashen, Cinder and Gleam here; the live repository's heroes are Ashen, Gleam and Quartz. No agent played them, and the refusal below is the real gate's output. In that run, the grader who had carried Ashen up two rungs tried to close the third:

refused (1 gate(s)): stale_grader: gleam already closed a rung for ashen;
                     this bar needs a grader who has not

The only fresh grader left was Cinder, the hero racing him, and the ledger's next line reads ashen L1 → L2 closed_by: cinder. The experiment script files the attestation in Cinder's name — "First rung I have ever closed for Ashen, and I wanted it to fail. It ran cold. It holds." — a line the script wrote, not a hero; and then Cinder hits the same wall from the other side and Ashen closes his L2. Neither can finish alone. That is the title of this chapter, and it is not a metaphor.

flowchart TD
    G["Gleam<br/>carried Ashen up two rungs"]
    A["Ashen<br/>L1 → L2"]
    C["Cinder<br/>the hero racing Ashen"]
    G -.->|"refused: stale_grader<br/>gleam already closed<br/>a rung for ashen"| A
    C -->|"closed_by: cinder<br/>the only fresh grader left"| A
    A -->|"closes Cinder's L2<br/>the same wall, other side"| C
    style G fill:#5a5a8a,color:#fff
    style A fill:#2d6a4f,color:#fff
    style C fill:#2d6a4f,color:#fff

The refusal, drawn. With Gleam no longer eligible, the only grader who can advance Ashen is the hero racing him — and the same holds the other way.

Three honesty laws sit underneath, and the spec demonstrates the first with a shell transcript rather than arguing for it:

$ node bin/hero.mjs award gleam --kind verify --points 30 \
    --bar "I checked my own work" --evidence "trust me" \
    --maker gleam --verified-by gleam

Error: refused: verified_by must differ from maker (no self-XP)

$ wc -l ledger/events.jsonl
3          # unchanged — the gate throws before any write

The award path is the one the spec put a transcript on. The same comparison sits on the ladder's rung-close path — self_award: verified_by must differ from maker — so the guard chapter three reads as Gleam's identity gates awards and rung closes alike.

The other two: XP is derived, never stored — "hero.json holds no xp field at all", so there is no number to inflate — and the ledger is append-only, so a wrong award is corrected by appending a correction, never by editing history. Anyone handed the ledger rebuilds every rank exactly.

---

It Was Chosen by Running It, Not by Taste

Three leveling techniques were built as working prototypes and run against each other, and an independent cross-judge agreed with the parent score on all three:

Scores from the cross-judge; the reasons are in the arena's synthesis, not the spec. The 97/97 is the winner passing its own assertions — what a prototype can show about itself; the cross-judge is what compared them.

The rejections are the useful part. Both rejected candidates fail the same way: they smuggle counting back in through a side door. That is worth more than the winner, because counting is what everyone reaches for and it is always available in a new costume.

---

The Inversion They Published Instead of Fixing

From the spec's worked example — the arena run above:

Ashen (Forgewright) reaches L3; Cinder leads embers but ranks #2; Gleam grades the most rungs and ranks last.

The hero doing the most independent verification finishes bottom of the board. In a system whose entire honesty model rests on independent verification, the board punishes the verifier.

The spec wrote it down and called the inversion load-bearing rather than quietly re-weighting the score. The arena's final board, as the run printed it — Cinder on 71 embers, Ashen on 65, Gleam on 49; scroll the block sideways for the marks and embers columns — ends on the line the rule requires:

  #  hero      class        level  ladder  top bar held                      1st  marks                                       embers
  1  ashen     forgewright  L3     xxxx    Outlives the Heat                 3    anvil-crown,held-the-line,stranger-ink,grader 65
  2  cinder    forgewright  L2     xxx.    Rerun by a Grader I Did Not Pick  1    held-the-line,grader                        71
  3  gleam     mirror       L1     xx..    False Pass Caught                 2    grader                                      49

  crown L0: gleam reached it first (mr-l0)
  crown L1: ashen reached it first (fw-l1)
  crown L2: ashen reached it first (fw-l2)
  crown L3: ashen reached it first (fw-l3)

  embers advance level: false

Six sections later, under Known tensions, stated rather than hidden, the spec keeps a table of four more, and the third is a security limitation written the way they should be written:

Emphasis in the third row mine.

A limitation you cannot close should look like this: name the attack, decline to claim you stopped it, say what you did instead.

---

Thirty-Three Lines

Every rung close on record is inside the arena run that picked the mechanism. The live repository's seed ledger holds three deeds and stops — and even those three show Law 1 doing its job, a different maker and a different verifier on every line:

The overnight loop from chapter four is the contrast case: it has no ledger I can read, so its count is unknown, not zero. This ledger is the other kind of fact. Level is derived from it, so it can only ever say what has been closed, and every close it records — ten passes among the arena's thirty-three lines — belongs to the run that picked the mechanism. The selection was rigorous; the exercise has not started. That is not a fault in the design — nothing has yet stood at the other end to switch it on — and it is the one thing the design cannot supply for itself: a real hero trying to game a gate built to be ungameable, and a ledger line saying whether the gate held. That line is the number this chapter is waiting for.

---

Nothing Is Motivated

"Nothing is motivated. A stateless model feels no pride and no rivalry; this is a UI for humans with extra machinery."

Grant the whole frame, and the useful part is untouched. What remains is a grading protocol with an independence guard: rotating verifiers, derived scores with no field to inflate, an append-only audit trail, and evidence classes that escalate rather than accumulate. Every one of those properties is worth having in a system with no inner life at all, and none of them depends on the game framing being anything more than a naming convention.

The vocabulary is doing one real job, which is to make the honesty rules memorable and checkable by a person: "level equals contiguous closed rungs" is easier to hold and audit than "capability attainment is gated on sequential independently-verified evidence classes," and it is the same rule.

---

Eligible, Not Willing

The independence rule worth copying is not written as a rule. "The grader should not be the maker" is a sentence people violate under deadline; "a grader who already passed you is refused at L2" is a state check that does not care about the deadline — a fact about who is eligible rather than about who is willing. The rest of the design is the same move made twice more, the counter forced to print embers advance level: false beside itself and the ladder that escalates the kind of evidence rather than the count, and each one takes a thing people are asked to remember and makes it a thing the system will not let them forget.

The design was chosen by an arena, confirmed by a cross-judge, and shipped with its honesty laws demonstrated in a shell transcript. The part still ahead is in the ledger. Thirty-three lines in the experiment. Zero in production. The rule is finished; the run is not — and nothing about the rule waits on the run. Every should in your own review process is a rule someone can violate under deadline; find the one that matters most and ask what state check would make the violation unavailable. That part you can copy this afternoon.

---

Next, the last chapter. Two of the traits in this system's catalog descend from the agent in chapter one. How they got there is the proof this series went looking for. Related: The Clean Room on grader ≠ maker; The Loop Is a Ledger on append-only progress; Confidence Is Not Consent.