a guess that carries its own verdict

the takeaway in one paragraph

One function in the maxwell kernel, resolveVerdict, decides whether a board-focused ask can land in one pass. Thirty-five tests, thirty-five pass, none skipped.

resolveVerdict answers one question about a board-focused ask: can it land in one pass, or does something else have to happen first. The answer comes back as one of six named states: blocked, insufficient_evidence, state_unavailable, tie_admitted, stage, converges. Five of them carry a reason in plain text. converges carries none, because there is nothing to report.

The lab's canon asks for more than that of a training run, in a different place. A training hypothesis is recorded as a verdict and a degree together: the accept-or-reject bit, and how much the result moved, with a confidence interval and a sample width named alongside it. The kernel half records the verdict and a reason, and has no degree in it. The degree is the training half, and that half is a canon entry used once.

the everyday problem

Most systems log a decision as a single bit. A test passed or it failed. A pull request merged or it didn't. That bit is enough when the underlying question is binary.

A training run is not that kind of question. Two runs can both come back accepted and mean opposite things: one moved the metric by an amount no random seed would produce on its own, the other moved it by an amount well inside the noise floor. Collapse both down to one bit and the second run reads exactly like the first.

The lab's canon entry `laws/hypothesis-carries-its-verdict-and-degree` states the fix. The record that enters the graph states the hypothesis before the attempt, and whether each clause was valid, and by how much. It names the confidence interval, the sample width, and the instrument's discriminating power. The runtime is meant to optimize over the recorded degree, never over the accept-or-reject bit alone.

six named states, one order

resolveVerdict returns a verdict, a list of reasons, and a list of stages, every time. A board store that throws and a malformed tie block both come back as a verdict, not an exception.

• blocked — the board's coherence reading, H = 1 minus R, sits above the block line verdict.ts names. Nothing gets staged until that is fixed.
• insufficient_evidence — a board was named but the read found nothing usable.
• state_unavailable — the read itself couldn't happen at all: no store wired, or the store threw.
• tie_admitted — the caller names a real degeneracy, both arms live, comparable budgets, both arguments current. Recorded as a terminal answer.
• stage — the ask can't land in one pass but can be split.
• converges — the ask lands in one pass, or no board was named at all, in which case no evidence was ever requested.

The order between them is fixed: blocked first, then the evidence hold (insufficient_evidence or state_unavailable), then tie_admitted, then stage, then converges.

The board-evidence path degrades closed. A missing store, a missing board, a board read that throws: none of it throws out of resolveVerdict, and none of it reads as converges. The dossier path is not narrowed the same way. A missing or failed dossier read contributes no stage signal and falls through to converges, which is what verdict.ts calls the pre-A4 law, still in force there.

the number

One training attempt has gone through the verdict-and-degree recording shape. The hypothesis, canon entry `conditions/turn1-weighted-multiturn-grpo`, is recorded as written down before the attempt ran, by the record's own account. The result, canon entry `evidence/world-turn1-multiturn-v1-tape`, came back with its no-regression clause holding and its lift clause null: the run didn't make the model worse, and it didn't clear the bar for better either.

The same record names a second surface it could not use: the world tape it was built for cannot rank adapters at all, one oracle per family across every instance on that tape. The run was scored on the parent's own tape instead. The record names both halves, the bit and the reason it came back that way, on the one attempt on record.

what this doesn't cover, and the next gate

The kernel code is tested. resolveVerdict's six states and the order between them have thirty-five tests behind them. The fifteen other kernel test files run for this note came back green in the same pass. They are a selected set, not the whole kernel suite.

The training-hypothesis law is not tested that way. It's one of ten canon entries still marked draft and kind idea, meaning the canon holds it as a working record. Nothing has promoted it. It has been exercised on one attempt, and that attempt's verdict came back rejected: the no-regression clause held, the lift clause was null, and the surface it was built for could not rank adapters at all.

• The law says a tape whose oracles cannot separate lanes is refused at plan time. On the one attempt on record, the tape could not separate lanes and the attempt ran anyway. The record shows a verdict, not the refusal the law calls for.
• The blocked verdict reads its coherence number from boardCoherence and never recomputes it. These thirty-five tests assert the H string the verdict reports on the board that blocks, and that a coherent board does not block. boardCoherence's own arithmetic is checked elsewhere, not here.
• The dossier read path still degrades silently to converges when it fails. That branch is unchanged and out of scope for this pass.

The next gate: the shape is tested, and the training runs that used it are the evidence. Publish the failing rows alongside the passing ones as more runs land, or the shape stays untested where it matters.

• note 20 · the four-rung recovery ladder
• note 29 · the box that built itself
• note 30 · the box that learned to read itself
• note 36 · networks of algebras