Pressure Testing — the sections replaced on 2026-11-13
The two sections Order and iteration and What “grounded” means of Pressure Testing, moved here whole on 2026-11-13, when the section What DONE means replaced them. They are record: the rule the council runs is that section’s.
Order and iteration
Phase 1 — Foundation: runs 1 → 2 → 3, once each. Pass 1 is mechanical and produces a list of structural gaps. Pass 2 looks at the in-pattern resolutions and asks whether they belong elsewhere. Pass 3 attacks what survives. All three must run before any refinement begins; the foundation is not optional and cannot be skipped.
Phase 2 — Refinement: re-run 1 → 2 → 3 as many times as needed. Each round of fixes changes the document and can surface new findings in any of the three passes. Pass 2’s extractions can re-introduce Pass 1 gaps. Pass 3 fixes can expose gaps that Pass 1 should have caught. The refinement loop has no fixed count — it runs until a complete pass across all three surfaces no new findings. This is expected: a complex atom with a novel structure may require two or three refinement rounds; a simpler atom closely following a prior pattern may need none. Both outcomes are normal.
Multi-file refinement order. When running refinement rounds across a library — all atoms and compositions in a single sweep — process in dependency order: atoms before any composition that names them. Compositions depend on their constituents’ APIs (rejection reasons, invariant counts, action signatures); refining a composition before its constituent forces guesses about the constituent’s details, and guesses introduce errors.
The corollary follows immediately: when a constituent’s refinement round changes its API — adds a rejection reason, corrects a reason name, adds an invariant — every composition naming that constituent needs a follow-up pass to absorb the change. This propagation is structural, not optional. An invariant count that was accurate at authoring time becomes stale the moment its constituent gains an invariant.
The motivating evidence is from the library’s own first refinement sweep. Shared Todo and Undo History were refined before Personal Todo; both used invalid-request for Personal Todo’s description-validation rejection, which turned out to be invalid-description. The error was only discoverable when Personal Todo was refined last and the correct name was confirmed. Strict dependency order — Personal Todo before any composition naming it — would have surfaced the discrepancy in-round rather than requiring retroactive correction. The same sweep also produced stale invariant counts in Shared Todo (referencing “nine Assignment invariants” after Assignment gained a tenth during its own refinement round), again a consequence of refining the composition before its constituent had fully settled.
The practical rule: before beginning a library-wide refinement sweep, topologically sort the files (order them so that each atom comes before any composition that depends on it). If a composition’s refinement reveals that a constituent’s details are needed but not yet confirmed, pause the composition and refine the constituent first. This is not a performance optimization — it is a correctness requirement for the cross-reference surface the library accumulates.
Reference-first for cross-cutting changes — gate the reference before the sweep. The dependency-order rule above governs independent refinements. A different and more expensive failure appears when one design decision is applied across many patterns at once — a corpus-wide refactor, not N unrelated touches. Here the rule is: apply the change to a single reference pattern, run the closing fresh-reader round (Phase 3) on that reference, and only sweep the rest once the reference clears. Principle: a cross-cutting decision is gated once, on the reference, before it is replicated. Likely objection: “the reference is obviously right; the sweep is mechanical.” Mechanism: the fresh-reader round exists precisely because author confidence is not the bar — running it on one pattern is cheap; running it on the reference after replication is not. Result: the blast radius of a wrong cross-cutting call is one pattern, not the corpus. Worked instance (2026-06-23): the derive expiry at read time initiative threaded the injected clock into action signatures across eight atoms before the reference was gated; the closing round rejected the signature form and the change was reverted across all eight — a cost the reference-first rule bounds to the single reference. This is the multi-file order rule lifted one level: settle-and-gate the decision before replicating it, exactly as you settle the constituent before the composition that names it.
Phase 3 — Final AI adversarial round: mandatory before grounded. After human refinement rounds have settled, one complete round of all three passes is conducted by a high-functioning AI reviewer before the pattern can declare grounded. This is not a repeat of Phase 2 — it is a structurally different kind of scrutiny. A human author who has written and revised a spec has emotional investment in the choices, accumulated blind spots from having reasoned through each decision, and a mental model that paper over gaps the written text does not actually close. An AI reviewer has none of these: it reads only what is written, applies the same pass questions without fatigue or sympathy, and has no stake in the outcome.
The AI round runs all three passes, not Pass 3 alone. Pass 1 and Pass 2 benefit from the same fresh-reader quality: the AI checks GRID completeness against what the spec actually says, not what the author knows it means; and it applies the EOS extraction test without the author’s sense of “we already talked about this.” Pass 3 is where the AI’s adversarial posture is most distinctive — it will surface muddled identity, sloppy invariants, and happy-path-only examples that a sympathetic human reviewer may rationalize past.
What counts as a high-functioning AI reviewer. The bar is not model-specific — it is prompt discipline and structured question coverage. The AI must be given the full pass question sets from this document, the pattern under review in full, and no additional context about the author’s intent beyond what the spec itself states. The reviewer’s job is to surface findings, not to guess what the author meant. A review that paraphrases the spec back is not a pass — it is a read. A pass produces findings, named as findings, or a clean result with explicit confirmation that each question was applied and no gap was found.
Recording the AI round. AI-conducted rounds are recorded in the commit message in the same format as human rounds, but distinguished: the entry notes “AI-conducted round” and names the model used. This is not for model attribution — it is for reproducibility. A future reader who wants to re-run the round knows what prompt discipline and reviewer type produced the original findings. Findings closed in the AI round are recorded the same way as findings closed in human rounds: what was found, how it was resolved.
Fresh-reader discipline, defined operationally. Fresh-reader is the structural property that makes Phase 3 different from refinement Pass 3, not the human/AI distinction. A reviewer satisfies fresh-reader discipline when, for the round in question, the reviewer receives: (a) the full pass question sets from this document; (b) the pattern under review in full; and (c) nothing else — no author intent, no rationale, no prior-round findings from this pattern, no summary of what the author thinks the spec says. A reviewer who reads prior-round findings before applying Pass 3 is conducting refinement Pass 3, which is also valuable but is not Phase 3. The discipline forecloses two specific failure modes: the reviewer rationalizing past a gap because a prior round noted and resolved an adjacent one (“the author addressed this nearby issue, so this nearby gap is probably intentional”), and the reviewer pattern-matching to prior findings instead of attacking the text on its own terms. Refinement rounds can use findings context to drive convergence; the closing Phase 3 round cannot.
A lapsed pass does not count (2026-10-06). A pass in which the reader saw anything its brief forbids — a Ledger line, a Decisions entry, a model, an earlier round’s report — is a lapsed pass, whether the page it came from is the one under review or one the reader opened to check a citation. Its findings stand and are triaged like any other. Its zero does not: a lapsed pass counts toward no clean round, and the pass is run again on the same text by a reader who has read none of it. A reader reports its own lapse, and a brief bounds every read and every search to the lines the reader may see — both lapses recorded on 2026-10-05 were a search that printed past a Status line. Disclosure records a compromised sample; it does not repair one.
Automated councils satisfying Phase 3. Phase 3 may be conducted by a single AI reviewer in one session or by an automated council that decomposes the three passes across agents (typically one agent per pass plus a consolidate step). The Phase 3 discipline applies uniformly to Pass 3: Pass 3 always runs in fresh-reader mode, in every round, regardless of whether the round is refinement or final. Pass 1 and Pass 2 findings drive document changes between rounds (applied by a human, an apply-agent, or whatever the council provides); Pass 3 then reads the resulting document with no findings context. Every Pass 3 invocation is structurally a Phase 3 candidate; the invocation that surfaces no findings — i.e., a clean Pass 3 in a round where Passes 1 and 2 were also clean — grants grounded eligibility. There is no mode switch, no “final round” detection, no escalation logic. The rule chooses simplicity and discipline over convergence speed: redundant findings during refinement (Pass 3 surfacing the same gap across rounds before the document fully absorbs the fix) is a small cost; priming Pass 3 with prior findings is the exact failure the fresh-reader discipline exists to foreclose. Pass 1 and Pass 2 may flow findings forward within a round (Pass 2 may read Pass 1’s findings; Pass 1 has no prior to read) — those passes are structural and conceptual rather than adversarial, and findings context does not undermine their job. The commit message records the council pattern used (which model per agent, which formula) and confirm that Pass 3 ran in fresh-reader mode throughout.
Phase 4 — Readiness check: Opus at Happy Torvalds X2. (Opus is Anthropic’s most capable AI model; “Happy Torvalds X2” means applying Opus’s full intelligence to confirm the spec is generation-ready — not to achieve perfection, but to clear the bar for shipping.) After the nine-pass minimum has been satisfied and Phase 3 returns clean, one additional mandatory pass runs before the pattern may declare grounded. This pass is conducted by Opus — the most capable available model — at twice the analytical depth of standard Pass 3 (Linus mode). It is not a fourth round in the same sense as Phases 1–3; it is a single-pass readiness check whose job is to confirm the spec is good enough to generate from. Code can be regenerated at any time as the spec improves; the goal here is to ship fast and good, then iterate.
Why a separate check, and why Opus at X2. A pattern that has survived nine passes has been iterated and defended. Standard Phase 3 uses “a high-functioning AI reviewer” with structured question coverage and fresh-reader discipline; that bar is correct for the closing AI round of a refinement sequence. Phase 4 applies Opus’s full intelligence to answer one question: is this spec ready to generate reliable code from? Opus at X2 depth catches anything that would produce bad generated output — gaps in the identity model, invariants that break under real conditions, concept boundaries that would cause generation to go wrong — while staying focused on generation-readiness rather than theoretical perfection. The safety net is regeneration: because code is derived from the spec, any future improvement to the spec is immediately realizable. A grounded spec is the starting point for that cycle.
What X2 depth means operationally. The reviewer receives the full pass question sets, the pattern in full, and nothing else — fresh-reader discipline still applies. Pass 1 and Pass 2 run at standard intensity. Pass 3 runs at X2: the reviewer brings full intelligence to bear on whether the spec is generation-ready. Every concept boundary is tested — is it real, or would it cause generated code to absorb the wrong responsibility? Every invariant is tested for conditionality gaps — does it hold under real conditions, not just the happy path? Every example is tested for coverage — would a regulator or a real user find a scenario the spec doesn’t handle? The posture is not “achieve perfection” but “confirm this is good enough to ship from, knowing iteration will follow.”
Recording the clearance gate. The commit message notes “Opus clearance gate — Happy Torvalds X2” and the model version used. Each finding is classified at the time it is recorded — foundational (missing methodology-required content; blocks grounding until closed), refining (sharpens content the spec already has; closed in-pattern but does not block), or rhetorical (prose-only attack on sound content; recorded with classification but does not block). A routed finding’s Ledger line is id · class · where · defect → fix. If foundational findings remain after the round’s fixes land, the gate runs again; the pattern remains partially resolved until the gate returns with zero foundational findings (the 92%-good threshold — see the section titled What “grounded” means). A gate result that meets the threshold is the Ledger’s last gate: line when grounded is declared.
The minimum standard stated plainly. Three rounds × three passes = nine passes minimum, plus one Opus clearance gate (Phase 4), plus the formal-layer vote (and, where the vote is yes, a verifying derived formal model before unqualified grounded). Round 1 is the foundation (Pass 1 → 2 → 3, once each). Rounds 2 through N−1 are human or council refinement, running until a complete round surfaces no new findings. Round N is the final AI adversarial round (Phase 3), running all three passes with fresh-reader discipline — single-reviewer or automated-council, the discipline is what counts. After Round N returns clean, the Opus clearance gate (Phase 4) runs as the tenth and final step. A pattern that has not cleared the Phase 4 gate has not met the minimum standard and should not declare grounded, regardless of how many refinement rounds it has survived.
Round structure and naming — the canonical grounding marker. The phases above describe what runs; this paragraph canonicalizes how rounds are counted and named, because two numbering schemes circulated before it was written down. The 3×3 baseline is three rounds of the three passes — Round 1 runs Pass 1 / Pass 2 / Pass 3; Round 2 runs Pass 1 / Pass 2 / Pass 3; Round 3 runs Pass 1 / Pass 2 / Pass 3. Pass numbering resets per round, so “Pass 3” always means the Linus adversarial pass, never the third pass-of-nine. After the baseline, Final Critique runs as the AI-conducted closing round starting at Round 4 — in current practice the Phase 3 final adversarial round and the Phase 4 Opus clearance gate run together as this single Opus round (fresh-reader discipline throughout, X2 depth on Pass 3, findings classified foundational / refining / rhetorical). If Final Critique 4 closes clean, the pattern is grounded on Final Critique 4; if it surfaces findings, a refinement round absorbs them and the pattern grounds on Final Critique 5, then 6, and so on until the threshold clears — foundational findings at zero; refining and rhetorical findings may remain (the 92%-good threshold, the section titled What “grounded” means). grounded on Final Critique N is the canonical grounding marker recorded in the pattern’s Status line and Ledger. Older patterns that used cumulative Pass 1–9 numbering (Defensible Retention is the worked example) carry a retro-mapping note explaining the relabel; the unified convention is per-round Pass 1/2/3 + Final Critique.
Skipping is not an option. Each pass catches a different class of gap. A pattern that has only survived Pass 1 is structurally complete but probably absorbs responsibilities it shouldn’t and contains hidden decisions. A pattern that has only survived Pass 3 is precise but may be missing entire GRID nodes. Either is incomplete. Refinement passes do not substitute for the foundation — they extend it. The AI round does not substitute for human refinement — it concludes it.
What “grounded” means
A pattern reaches the grounded status — the state declared in its Status section — when:
- All nine GRID nodes are resolved (Pass 1 clean).
- Every responsibility belongs to the pattern it’s in; no over-absorptions remain (Pass 2 clean).
- No muddled identity, sloppy invariants, happy-path-only examples, or hidden load-bearing decisions remain (Pass 3 clean).
- All three conditions above have been confirmed by a final AI-conducted round (Phase 3), with findings recorded in the Ledger (open) or the commit (closed).
- The Opus readiness check (Phase 4 — Happy Torvalds X2) has returned at-or-above the 92%-good threshold (see below), with the gate result recorded on the Ledger’s
last gate:line. - The formal-layer vote has been cast and recorded on the Ledger’s
formal:line (see Formal models — The formal-layer vote). If the vote is yes, the derived formal model exists and verifies; until it does, the pattern isgrounded (English) — formal layer pending, notgrounded.
Grounded is against a commit (2026-11-02). An atom or a composition is grounded against a named foundation commit: the grace-commons commit its grounding round froze, which its Status token records as at <sha> (the entry Status line format). The claim stays true for that commit for good. A later foundation commit does not falsify it: a change to the Execution Contract, to GRACE-lang, or to a constituent owes the atom or composition a migration, a round that reads what the change touched, and leaves it grounded meanwhile. The bar is unchanged: zero foundational findings on a round of three fresh passes. Two numbers are reported, never one: grounded, the atoms and compositions that carry a grounded token, and current, those whose pin is an ancestor of grace-commons HEAD with no change since to the atom or composition or to a constituent. The gap between them is the migration debt, and it is counted, not hidden. The maintainer ruled it (“Once grounded they should stay grounded else this will never work”, 2026-11-02), after one sweep took the count from 17 of 55 to 7 of 57 because the record of what each atom or composition was verified against did not exist, so the only safe act was to unmark it.
A clean round grounds, delta or full (2026-11-03). A round with zero foundational findings after both triages grounds its atom or composition whether the round’s kind is delta or full. An atom’s or composition’s first round is a full read of the whole text, and every round after it reads the diff and the surfaces the diff touches, so a clean delta round means the whole text was read once at its first round and every change since has been read in its diff. The bar is unchanged: zero foundational findings after both triages. A clean delta round grounds on a reading of the reach (the entry A cure is re-read by its diff), which walks a changed Term’s definition chain to its end, so no rule the change affects is left unread. The reach is built by one walk, tools/grace/cites.py --reach, and delta-covers.py runs that walk again as a receipt: its exit 1 is a defect in the tooling, fixed in the settle, and never a round to hold or a full round to owe. The maintainer ruled it (“what I am saying is ground on clean, no rescan”, 2026-11-03); it replaces the rule that only a full round may ground, which made the count oscillate: an atom or composition was cured, took a delta round, came back clean, and waited for a fresh full read that any cure in it sent back to delta.
grounded is a launch point, not a finish line. The spec is ready to generate from; further refinement rounds will continue to improve it; and because code is derived from the spec, every improvement is immediately realizable by regenerating.
The 92%-good grounding threshold. A pattern grounds when the Phase 4 readiness check’s foundational findings reach zero, even if refining and rhetorical findings remain. “92%-good” is the colloquial label: foundationally complete, generation-ready, no methodology-required content missing. The threshold is intentionally not 100% for two reasons. First, X2 depth has no convergence ceiling — a sufficiently thorough reviewer can always find prose to sharpen regardless of whether the underlying content is sound, and demanding zero refining or rhetorical findings would mean a spec never ships. Second, perfection isn’t required: code is a derived artifact that regenerates from the spec. Any improvement to the spec after grounding is immediately realizable. The goal is to ship a spec that generates reliable code today and keep improving it — not to spend indefinite refinement rounds chasing a spec that will never run.
Each gate finding is classified into one of three classes, recorded with the finding in Lineage notes:
Foundational — a conforming implementation could behave differently, or an invariant could break, because of what the page says or omits. At least one of these holds:
- A state-machine gap: two traces the prose permits (or forbids) that a natural reading of the rules would treat differently.
- An unstated invariant: a reachable state that violates a property the pattern claims to guarantee, with no rule forbidding the transition that produces it.
- A rule resting on an undeclared capability: the rule cannot be discharged by any implementation that follows only what the page names.
- A deployment obligation named nowhere: the pattern’s guarantees silently depend on something the deployment is never told it must supply.
The reviewer who rates a finding foundational must name either the two implementations that would diverge, or the concrete reachable state that breaks the invariant — and show how the page’s text, or its silence, produces the difference. A finding that changes only what a reader understands — a gloss, a forthcoming marker, a pointer, a count, an example, a claim’s phrasing, or anything the linter checks mechanically — is refining or rhetorical and never blocks. Foundational findings block grounding — they must be closed in-pattern before the gate counts as clean.
A foundational finding is resolved by cure, by dated record, or by named non-goal (2026-10-02). The definition above is unchanged; this says only what closing one means. A cure is a rule change on the page; a dated record is a Decisions entry or a capability requirement that states the behavior and who owns it; a named non-goal states what the page will not do and names the owner of the gap. Each leaves nothing silent, which is what grounded requires.
Refining — the spec contains the required content but a section overstates a claim, two sections disagree, a fix from a prior round didn’t propagate everywhere it should, a primitive policy is too thin to defend, a deployment obligation is named in one place but missing from the obligations list. The fix sharpens content the spec already has. Refining findings do not block grounding — they are routed to the Ledger as open lines, or closed in-pattern where the fix adds no rule; the load-bearing surface was already present. A cure is load-bearing text the next gate reads, so curing every refining finding inside the grounding loop grows the surface faster than the gates close it: five consecutive gates on Credential cured theirs in the pass that found them, the page grew by half, from 68 to 101 kilobytes, and four of the five foundational findings after the first were the previous cure’s own text (council read 272).
Rhetorical — the spec’s content is sound and the methodology’s pass questions are answered, but the reviewer at X2 intensity has attacked the phrasing the spec uses to defend a claim. The fix is a prose rewrite that says the same thing in different words. Rhetorical findings do not block grounding — they are recorded with classification visible and either closed (rewritten) or accepted (recorded as-is with rationale) per the author’s call.
The threshold operationally. A clearance gate counts as clean for grounding purposes when its foundational finding count is zero — regardless of how many refining or rhetorical findings the same gate surfaced. If foundational findings remain after the round’s fixes land, the pattern remains partially resolved and another round runs. The grounding bar is foundational completeness, not absence-of-all-reviewer-findings.
A clean round is a sample (2026-10-06). The threshold above is unchanged; this says what one clean round proves. Defensible Retention returned zero foundational on three passes of one text on 2026-10-04. The rounds run on it the next day, because a sibling’s gate had found an assumption the two pages shared, returned nineteen foundational findings, fifteen of them in text those three passes had read. So a clean round is one draw from the readers and not a proof, and a page says how many it rests on. A page is confirmed when two consecutive rounds, each three passes by readers who have read no earlier round of the page, return zero foundational on one text; a load-bearing touch between them starts the count again. A page grounded on one clean round is on one sample: grounded stands. No second round is owed and no rescan is scheduled for it: the maintainer ruled it (“ground on clean, no rescan”, 2026-11-03), so a later reader does not reinstate a debt by inference, and the patterns now reading grounded on one sample keep their status and owe nothing. The result of a last gate: line written from this date on ends with one of three: one sample, confirmed, accepted on one sample; a line that names none reads one sample. A second round that returns a foundational finding is a rescan that surfaced findings (the entry Scheduled rescan).
Three passes over moving text is a search, not a round (2026-10-07). A round is three passes over one text. A cure made after one pass and before the next is text no pass has read, so a sequence in which each pass is cured before the next runs can find defects and can seal nothing: its findings stand and are cured, and it counts toward no clean round, whatever its last pass returned. A round names the text it holds still — the hash of the body, and of any constituent its readers read whole — runs all three passes on it, and triages and cures only after the third has reported. Immutable Ledger, bound that week to Recoverable Invocation, is the worked case: three passes cured in sequence returned 3, 5 and 6 foundational, two of the last six in rules the first two passes’ cures had written that day; three passes over the text then held still returned 5, 3 and 2, with conceptual independence at zero. The two sets of counts are comparable, and the comparison is not the argument: the frozen round found no fewer. What it bought is closure. Its nine findings are about one text, so curing them can end a round; the search’s fourteen could close nothing, because the text moved under them.
The builder’s reading runs beside Pass 2 (2026-10-07). Pass 2 asks whether each concept is one thing with one owner. It does not ask whether the page can be built, and a page can pass the first and fail the second. So the reader of Pass 2 runs a second reading in the same pass and reports the two apart: as an engineer who must implement each action from the page, walking it step by step, and reporting every input on which two rules oblige different things, every point where two competent teams would build differently and each could defend its build from the text, every value, bound or ordering the page does not give, and every name a rule uses that is not declared where the rule says. Its findings are classified like any other. On the frozen pair of 2026-10-07 conceptual independence returned zero foundational, and the builder’s reading, in the same pass over the same text, returned three — one of them an action obliged to release or to hold by a condition none of its inputs carried. Every Pass 2 runs both.
The “~92%, not 100%” framing recognizes that complex patterns produce refining and rhetorical surface area as a side effect of their defenses; demanding zero of either at X2 is demanding the prose and cross-section consistency be unattackable, which is a different bar than demanding the content be correct. Round 1 of any pattern is typically 100% foundational by classification (foundation gaps). Round 2 typically surfaces a mix as the foundational surface fills in. Subsequent rounds shift the mix toward refining and rhetorical with diminishing returns. The pattern grounds when foundational density reaches zero — empirically the second-or-third round for richly-surfaced atoms, the first round for simpler primitives.
The classification is the reviewer’s call, made under the test above: a finding rated foundational that names neither diverging implementations nor a breaking state is refining. A report that a specification does not restate a rule the Execution Contract or GRACE-lang states once is refuted at triage by citing that rule, and is placed neither foundational nor refining: the rule binds the specification without a restatement of its own, so a lone flash reader’s restatement finding costs no round (the maintainer, 2026-11-03 17:15Z). The Ledger’s per-finding format is: id · class · where · defect → fix, one line, the class one of the three above.* Future readers can audit the classification by inspection.
Triage fields for a gate round (2026-10-02). Beside the class above, each finding recorded in a round’s triage carries two more fields, so the round’s cost can be read without re-reading the findings. Kind: A defect (a reachable state or divergence the page permits and should not), B hardening (the page is correct and a stronger form is available), C ownership (the page is correct and the obligation belongs to a deployment, atom or other page that has not accepted it), D preference (a reader’s alternative with no divergence). Blame: fresh if the rule the finding sits in was added or changed within the last two rounds, older otherwise. Only a kind-A finding is cured in the pass that finds it; B, C and D are closed by dated record or named non-goal first, and cured later only if the record says so. A round declares its finding budget before it runs, and its report carries four numbers: findings by class and kind, the fresh-to-older blame ratio, the share of findings rejected on triage, and the net count of rules added minus rules removed.
A rule the page’s lawful states break is first checked for a rule to delete it in favour of (2026-10-08). When a finding shows a rule broken by a state the page itself calls lawful, the first cure looked for is not a qualifier on that rule but an existing rule that already holds those states; where one exists, the broken rule is tombstoned to it. A qualifier written from the states that broke the rule restates each of them as new text a later pass must read, and a tombstone restates none. The worked case is Immutable Ledger’s third round on frozen text: a wiring decision claiming exactly one live outcome event per disclosure had been qualified once already, for the open invocation, and was then broken by an escalation and a purge, each lawful on the page; Invariant 1.3 already said what was true of the binding, and the wiring decision was tombstoned to it rather than qualified again.
A count that decides something is triaged twice, the second time blind to the threshold (2026-10-09). When a round’s count decides an outcome — a pre-registered stopping rule, a clean round, a grounding — every finding the count could include is adjudicated a second time by a reader given the findings, the method’s test and the rule for placing each one, but not the threshold or the outcome it would decide. Where the two triages part, each disagreement is settled against the text and recorded beside the count. The worked case is Immutable Ledger’s confirming round of 2026-10-09: the author’s triage made the older count three, the stopping rule’s threshold; the blind adjudication rejected one of the three on the constituent’s own text and placed it in a rule round four had changed, the author checked the text and agreed, and the count stood at two.
Status line format — the canonical grammar (pinned 2026-06-11). Every pattern carries a ## Status section (the container is required by spec-format.md; a top-of-file **Status:** line is a shape deviation, not an alternative placement). The section’s first line is the status line: exactly one backticked status token, optionally followed by prose. All explanatory content — round history, model references, gate results, glosses — lives in the prose, never inside the backticks: a Tier-1 gloss inside the token is unparseable by the mechanical checks that mirror it. Before this grammar was pinned, the corpus carried at least six surface shapes for the same statuses, which made the roadmap’s status mirror un-lintable by hand or machine — that is the failure this grammar exists to close. The tokens:
`draft`— freshly authored; the foundation round has not run.`unresolved`/`partially resolved`— per the taxonomy above.`grounded on Final Critique N — YYYY-MM-DD at <sha>`— the canonical grounded form. N is the grounding critique (the entry Round structure and naming); the date is the most recent complete three-pass round, updated by every touch-triggered re-pass and scheduled rescan.<sha>is the grace-commons commit the grounding round froze (its freeze file’sFrozen commit:line), written as seven to forty lowercase hexadecimal digits; where the round’s record is gone, it is the grounding settle’s own commit, and the settle’s entry says so. A token written before 2026-11-02 may carry noat <sha>, and the grammar accepts it; every grounding written from that date carries one. The Ledger’sstatus:line repeats the token, pin included. The two qualified forms below take the sameat <sha>after the date.`grounded (English) on Final Critique N — YYYY-MM-DD — formal layer pending`— vote-yes, derived model not yet verifying (the section titled The formal-layer vote). This state is referred to throughout this document by its short prose name,grounded (English) — formal layer pending; an actual Status line carries the full token with its Final Critique number and date.`grounded on Final Critique N — YYYY-MM-DD — <named item> pending`— the bounded-qualifier form for a routed finding blocking one named surface (the worked precedent:formal coverage of Invariant 4 pendingon Forensic Recovery and Chain of Custody, 2026-06-10 → closed 2026-06-11); the prose names the finding id.<named item>never names the formal layer — the formal-pending state is the previous form’s exclusively, so the two forms cannot collide on the same line.
The status token is the surface the roadmap’s status cells mirror — the pattern file is the source of truth, and a roadmap cell that disagrees with the pattern’s token is a finding (the status-mirror lint check). A pattern whose rescan date is significantly older than the current date — particularly one that predates atoms it now composes with — is a candidate for the next scheduled sweep.
Patterns that have survived only one or two passes should not declare grounded. Patterns that have completed human refinement but not the AI round should declare partially resolved. A pattern whose formal-layer vote is yes but whose verifying model does not yet exist declares grounded (English) — formal layer pending — the prose review is complete and clean, but the temporal claims await discharge on the formal surface. Honest partial completion is more useful than false confidence.
Touch triggers re-pass — for load-bearing touches. A load-bearing edit to a grounded pattern — a change to an invariant, a state, an action signature, a rejection reason, a decision rule, or any content the pass questions verify — requires a full three-pass round (the AI round included) before the pattern may retain its grounded status; a pattern so touched is downgraded to partially resolved until the round completes. This is not punitive; it is what keeps grounded meaningful as the library grows.
A clean round grounds with its own cures (2026-10-30). A round with zero foundational findings after both triages grounds its page even when the settle’s own refining cures are load-bearing, provided each cure was verified against the frozen text. No second round is owed to read them (the entry A clean round is a sample). Without this, a page whose readers always find something refining owes a re-pass of every clean round’s cures and never grounds: Consent had four clean rounds in eight and had not. Ruled under the maintainer’s anything near grounded is grounded.
A reopened grounded page takes a delta round (2026-10-30). When a load-bearing touch reopens a grounded page, by its own settle’s cure or by a change to a constituent, its next round is a delta round: one fresh reader, on a reading set of the reach (the entry A cure is re-read by its diff) and the method pages, triaged twice as any round is. The page keeps its status while the delta round is owed. Zero foundational keeps it grounded; any foundational finding makes it partially resolved until a clean round, delta or full, grounds it: the delta round that reads the cure (the entry A cure is re-read by its diff) comes first, and its clean result grounds it (the entry A clean round grounds, delta or full). The maintainer ruled it with the v1 baseline of GRACE-lang and the Execution Contract, since each change to the foundation had reopened grounded pages and the full rounds that followed held the schedule back.
A cure is re-read by its diff (2026-11-01). After a settle that cures, the page’s next round is a delta round, grounded or not. A delta round’s reader reads the reach: every rule python3 tools/grace/cites.py --reach <spec path> --changed <base> names for the diff since the last settled round’s freeze, each under its label as the frozen text writes it, with the closure-table rows that name any of them. The reach is the spec’s own changed rules and terms, the rules of it that rest on them (a changed Term’s definition chain walked to its end), and the rules of it that cite a changed rule or Term of another specification. It scopes the atom or composition under review and its reopen only: the method documents stay whole in every reading set (the maintainer, 2026-11-03 03:20Z: “Full scoping is the expensive path; only take it when a round actually needs it”). A clean delta round grounds the page on the condition the entry A clean round grounds, delta or full states; a page that is already grounded stays so, as the entry above says. Nothing about the bar changes. The maintainer ruled it (“as recommended”, 2026-11-01 21:45Z) from Audit Trail’s last eleven cures, which each changed 17 to 57 of about 2,250 lines (1 to 2.5%) while every round still put three readers through the whole page and its twelve-file set; about half the standing findings were breakage a cure made, which a read of the diff catches. The maintainer ruled that a change reopens what it reaches, never the whole (2026-11-03 16:40Z: “A change reopens what it reaches, not the page”): a delta round reads the reach, and a constituent’s change that reaches no rule of a composition reopens nothing of it.
A grounded constituent is read by its declared surfaces (2026-11-01). In every round’s reading set, a grounded constituent enters by its declared surfaces only: its actions, its reads and the terms they name, which is all a composer may use of it (the Execution Contract, Substrate composition invocation: declared surfaces only). The constituent’s page itself stays out of the set. An ungrounded constituent is read whole. The maintainer ruled it with the entry above.
Editorial touches do not trigger a re-pass. A purely editorial edit — a prose rewrite that changes no load-bearing content, a typo or comment fix, a Decisions entry, or a cross-reference whose target moved while its meaning did not — is recorded in its commit but does not downgrade the pattern or require a fresh round. The test is the constituent-cascade test (breaking vs additive) applied to the pattern itself: does the edit change what a conforming implementation must do, or what a reviewer’s pass questions would check? If not, it is editorial. The earlier formulation — which counted any edit, including a corrected cross-reference, as a re-pass trigger — made the cheapest upkeep as costly as a semantic change and so discouraged the very maintenance that keeps the corpus consistent; calibrating the trigger to load-bearing content removes that disincentive without lowering the bar for changes that actually alter meaning. (Doc-structure consequence: re-pointing cross-references after a file move is editorial, which softens one argument in the section titled The methodology applied to itself against splitting this document — the split’s other costs stand on their own.)
Batch a cross-cutting change through one re-gate. When the reference-first rule (the entry Multi-file refinement order) has gated a cross-cutting decision and the change is then swept across a batch of patterns, the batch earns one closing round over the touched set — not an independent full cycle per pattern. The assurance lives in the gate, and one fresh-reader gate over the consistent batch is the unit; re-passing each pattern separately multiplies reviewer cost without adding assurance. Reground the batch together once the round is clean. The distinction is load-bearing for cost: the scheduled cadence is calibrated for confirming stable patterns (cheap clean rescans that ratchet confidence), while propagating a cross-cutting design change is this other workflow — reference-first, then swept, then one batched gate. Conflating the two is what makes a single improvement feel like it re-passes the whole corpus.
Constituent-change cascade. A breaking change to a grounded atom — an invariant removed, an action signature incompatibly altered, a state machine transition removed — triggers a touch-triggered re-pass on every grounded composition that names that atom in its Composes section. Each affected composition is downgraded to partially resolved until its re-pass completes. An additive change (new invariant, new edge case, new example, editorial correction) does not trigger a cascade downgrade; the “all invariants from [Atom]” cross-reference form means the composition’s claim is already forward-compatible with constituent growth. Additive atom changes should note “Compositions affected: [list]” in the commit message so the next scheduled sweep can prioritize them.
Scheduled rescan. Grounded patterns are also re-passed on a regular schedule — a weekly or weekend batch is the working default — regardless of whether anything has touched them. A scheduled rescan is the same complete three-pass round as a touch-triggered re-pass; it is not a lighter check. Its purpose is not to find regressions (the spec hasn’t changed, so the spec itself can’t have regressed) but to ratchet confidence in the pattern as the library’s surrounding context evolves. Each clean rescan is independent corroborating evidence that the pattern still holds against the current state of the library’s vocabulary, the current state of the constituent atoms it composes with, and (for AI rounds) the current state of reviewer models. A pattern that has survived five scheduled rescans without findings is materially more reliable than one that has survived one — the number of clean rescans is part of what grounded means in practice, even though the status word is the same.
The default executor is the automated council. A scheduled rescan is council-run by default: the entry Automated councils satisfying Phase 3 machinery conducts the round — typically one agent per pass plus a consolidate step — with Pass 3 in strict fresh-reader mode throughout (the pass question sets and the pattern under review, nothing else). Pass 1 and Pass 2 agents may verify cross-references against the constituent specs the pattern names; that is structural checking, not findings context. For a vote-yes pattern, the same round carries the formal-layer portion below, riding tools/harness/ mechanically. Human attention goes to triage of council findings — classifying, folding fixes, routing extractions — never to conducting rounds. This is not a weakening of the discipline; it is what keeps the cadence executable. A rescan discipline that exceeds the review attention actually available does not degrade gracefully — it silently stops running, and the Status lines’ rescan dates become quiet fiction, which is precisely the false-confidence failure this methodology exists to prevent. A human-conducted rescan remains valid (it is the same three-pass round), but it is the exception, not the load-bearing default. The Ledger’s last gate: line names the executor: a clean council-run rescan records “Scheduled rescan: YYYY-MM-DD — clean (council-run).”
The cost model — parameterized, never snapshotted. The rescan economics are stated as parameters, not arithmetic: per the no-snapshot rule, this section carries no corpus-size math — the corpus and the costs both move; the parameters, not their current values, are canonical. Two parameters govern the cadence:
- The weekly rescan budget — a deployment-set number of full council rounds funded per week. It is set explicitly and revisited as measured costs or the corpus change; the measured per-pattern cost of each rescan is recorded on the rescan’s own evidence trail (the commit message, or the deployment’s usage log), so the budget rests on observed cost rather than guessed cost.
- Risk-weighted ordering when the budget is short. When the budget covers fewer patterns than the grounded corpus, rescans run oldest-rescan-date-first — staleness is the dominant risk signal, because the longest-unreviewed pattern has accumulated the most unexamined drift in the library context around it — tie-broken by composition fan-in: the count of grounded compositions naming the pattern in their Composes sections. Fan-in breaks ties toward the patterns whose staleness propagates furthest; a stale atom named by six compositions is a bigger liability than an equally stale leaf. Patterns carrying open routed findings are not rescan candidates — their next round is the touch-shaped round that folds the fix, and it rides its own trigger, not the rescan queue.
A scheduled rescan can surface findings for reasons the prior round could not have caught. Three of the common cases:
- A constituent atom has been refined since the last rescan, gaining a new invariant or renaming a rejection reason; the composition’s cross-references are now stale. This is the multi-file refinement order rule operating at the timescale of weeks rather than within a single sweep.
- Methodology conventions added since the last rescan apply retroactively. The two regulated-pattern conventions (Regulated adversarial scenarios; Generation acceptance) and the Audit-Trail-traversal-clearable / externally-clearable split from Multi-Party Approval’s Round 3 are examples; both were applied retroactively to earlier patterns once codified.
- The reviewer (human or AI) has improved. An adversarial pass conducted today by a sharper reviewer than the prior round can surface a finding the prior round missed without the spec having changed.
When the weekly passes stop (the maintainer, 2026-11-03). A grounded pattern’s weekly passes stop once two weekly passes in a row find nothing, foundational or refining. A pass that finds anything, of either class, restarts the count at zero; a touch-triggered re-pass counts as neither. The stop is the pattern’s, not the corpus’s: a later load-bearing change to the pattern, or to a constituent rule that reaches it, returns it to the weekly passes. The pass that makes the second clean one writes it in the last gate: line as “Scheduled rescan: YYYY-MM-DD — clean (council-run); weekly passes stop”.
A scheduled rescan that closes with no findings updates the rescan date in the Status token and the Ledger’s last gate: line, naming the executor: “Scheduled rescan: YYYY-MM-DD — clean (council-run)” for the default, “— clean” for a human-conducted round. A scheduled rescan that surfaces findings is treated identically to a touch-triggered re-pass — open lines in the Ledger for what is routed, the fixes and their reasoning in the commit, status preserved at grounded only if the round closes clean across all three passes. Findings from a scheduled rescan are not a failure of the prior round; they are the rescan doing its job.
For a pattern carrying a vote-yes formal model, the rescan’s formal-layer portion is three cheap mechanical steps, all of which ride this same cadence: (1) re-run the model and its buggy twin through tools/harness/ (the twin must still be rejected); (2) run the coverage cross-check (see the section titled The coverage cross-check) — emit the coverage matrix, route any GAP row as a finding; (3) take the one bound-saturation bump. None of these requires new tooling or heavier search; the coverage cross-check in particular is the highest-yield-per-minute step for closing the property-fidelity residual, which is why it belongs in every formal-layer rescan rather than in an occasional special pass.
The cadence is deployment-shaped. The working default is weekly with weekends as the batch window, but a library churning slowly may rescan less often, and a library under active multi-author refinement may rescan more often. The discipline is that the cadence is fixed and externally driven, not “when somebody remembers.” The whole point is to ratchet confidence on a rhythm independent of any particular author’s attention — and the council-as-default-executor is what makes that independence real: the schedule fires the council and the budget bounds the batch, so the cadence holds whether or not any human had review hours that week. Human hours are spent where they are irreplaceable — triage.
The August essays, moved 2026-11-13
Eleven of the frozen rules Pressure Testing argued from 2026-08-27 to 2026-08-30, moved here whole on 2026-11-13: each is now a rule of the pattern or of the Execution Contract that the page’s section What August taught names beside it. The five whose owner is pending stay on the page.
Durability boundaries — an atomic set may not contain a write the host cannot take back
FROZEN — 2026-08-29. Stated 2026-08-27 after the transactional atomicity over an append-only substrate class closed (three instances, three rounds, one protocol repair), and held open while methodology debt #19’s two remaining classes ran, in case either returned a case it did not cover. Neither did; both closed the same day. It is frozen with the other two #19 rules and the six rules stated 2026-08-29 from the second fresh-reader gates, under the section titled Authentication precedence’s discipline: a round that finds it inconvenient applies it as written or records a finding against the pattern, and reopening requires a case none of its arms covers, recorded first.
The rule. Never place an independently durable write inside a host transaction’s atomic set. A write is independently durable when the store that accepts it declares it cannot be withdrawn and offers no synchronous rollback — an append-only audit log is the canonical case, and in this corpus every AuditTrail.record_action is one. A host transaction cannot enlist such a write, so it cannot roll it back, so a set containing it does not commit together or not at all. Where the append cannot participate, specify three things instead and specify them explicitly: the ordering across the durability boundary, the reachable partial states that ordering admits, and the recovery for each.
This is the fourth use surface of the section titled Capability provenance, stated at full strength. “These writes commit together or not at all” claims a withdrawal capability over every member of the set. Where a member is an append the substrate declares un-withdrawable, the claim is an undeclared dependency — and unlike most undeclared dependencies it is not merely unproven. It is false, and the composition’s own text usually contains the refutation.
Why this is not “state the guarantee more carefully”
An all-or-nothing claim over a durability boundary fails in one of two ways, and they need different treatments. The distinction is the campaign’s main result, because the two look identical on the page.
| The claim | The wiring | The treatment | |
|---|---|---|---|
| Manifestation A | impossible to prove | the execution order already preserves safety; the reachable partial is the recoverable one | restatement — safety plus liveness, plus the mechanism that makes liveness dischargeable |
| Manifestation B | false | rollback makes a forbidden state reachable, and it is a state nothing can repair | protocol repair — move the durable write out of the atomic set, then restate |
The discriminator: does anything durable end up asserting a fact the canonical state denies? A missing record is recoverable — append the seal, write the propagation event, retry. A false one is not: the append cannot be withdrawn, and manufacturing the missing canonical record afterwards fabricates the very evidence the record exists to protect. A composition cannot honestly restate its way out of a reachable state it has no way to leave. Where the reachable partial is a missing record, restate. Where it is a false one, rewire first.
Practically the question reduces to write order: if the durable append is last, the partial is a missing record; if the append can land while an earlier write is still revocable — including inside a transaction that may yet abort — the partial is a false record. That is why manifestation B is the one that hides: the wiring looks stronger, because it wrapped more in the transaction.
The three tells
1. An argument that reasons about the wrong member of the set. The most convincing instance in the corpus did not assert its atomicity, it argued for it: it observed correctly that one member was a recoverable store write the transaction could undo, and concluded the whole set was atomic. Sound about that member, silent about the append. Showing its work made it more persuasive, not less. When a spec defends an atomicity claim, check that the defence covers every member, especially the one it does not mention.
2. An escape hatch dressed as a caveat. “Where the stores cannot co-transact…”, “in the conforming case…”, “where the host cannot provide that atomicity…” — each reads as a deployment-specific edge and each names the universal case, because an append-only substrate never co-transacts. Qualifying a false claim makes it read as defended. In one instance a gate finding had actively pushed a spec deeper in, adding a conforming-case qualifier for symmetry with a sibling invariant, hardening a claim that was wrong on both sides.
3. The refutation already present elsewhere in the spec. In all three instances the pattern stated the fact that falsifies its own claim — in an edge case, a constituent’s contract, or the treatment of its intent record — a section or two away from where the claim was made. The principle is rarely missing; it is applied to one durable write and dropped for another. Before concluding a composition lacks the insight, search it for the sentence that already has it.
What the restatement costs, and the two ways to pay
Stating liveness raises the question the atomic claim suppressed: compensate with what. The material the failed write carried — a disposition set, a scope enumeration, a disclosure descriptor — commonly exists nowhere else, since it lived in the write that did not land and in the process that died. A restatement that stops at the sentence produces a liveness claim no deployment can discharge and no auditor can test, which is a worse artifact than the overstatement it replaces: the overstatement was at least falsifiable.
Carry the material if it is a computed verdict; carry the boundary if it is derivable from an append-only log. A verdict — a per-record disposition, a determination — is not in any log, so the intent record must carry it (or its digest with the universe cardinality). A set that is derivable — an enumeration over recorded events — needs only a fixed point to be derived at, and a durable write that already exists can serve as that point. The boundary form is strictly better where available: it costs no new field and no second copy, and a boundary cannot drift out of agreement with the thing it bounds.
Either way the liveness arm needs a declared window. “Eventually” is not an auditable guarantee, and a retry with no terminus is indistinguishable, from the records, from an orphan nobody is working on. A compensation_window configuration entry is what makes at quiescence checkable and gives the retry somewhere to escalate to; a reconciliation_cadence bounds detection, and a cadence longer than the window makes the window unmeetable by construction. Both are capability-provenance obligations of the composition’s own — the declaring source for what its liveness arm spends.
And the partial must be findable. The failure that returns surfaces itself; the failure that cannot return — a crash between the two writes — surfaces nothing, and that is the case the no unsurfaced partial arm is actually about. It requires a reconciliation scan that is mandated rather than implied, with a restart trigger and a declared cadence, and a join key it can run on. Check that the key exists before claiming the scan: in one instance the disclosure record carried no identifier tying it to its request, so the invariant named a scan that could not run.
What this does to the formal layer
A model that encodes the claim cannot falsify the claim. In all three instances the model committed every sub-write in one action, so the state that made the wiring unsafe was not merely unverified — it was unrepresentable. That is how the sharpest of the three passed a formal-layer vote, an author gate, a fresh-reader council and a clearance gate without anyone seeing it. When a model’s central action sets several variables at once, ask what interleaving that action forbids and whether the deployment can actually forbid it.
Two consequences for twins. A twin should be the composition’s own previous wiring where one exists — a repair whose necessity cannot be demonstrated is indistinguishable from a preference, and such a twin is also a permanent regression guard against the wiring being folded back. And a twin must be a plausible mis-implementation of this composition: where a safety arm is earned by a constituent’s guarantee (an earlier write that is terminal by the atom’s own invariant) no wiring of this composition can violate it, so it is a frame property here and correctly has no twin. The same claim is a frame property in one pattern and a reachable defect in another, and which it is depends entirely on whether the earlier write can be taken back — the discriminator again, arriving from the formal layer instead of the prose.
The mechanical slice
tools/linter/lint.py check P-atomic-audit: an all-or-nothing sentence whose member set names an audit write, with no acknowledgement in the enclosing block that an appended event cannot be withdrawn. The phrase alone is not the signal — nine patterns use it benignly over constituent-store writes only. It landed advisory, measured the class, and was promoted to gating on 2026-08-27 when the last instance closed and it fired zero times corpus-wide: a check becomes gating at the moment it stops measuring a backlog and starts defending a property.
Its regression guard is worth copying. The check’s first draft treated a hedge word as an acknowledgement marker, which silenced it on the two sites that motivated it — both their pattern’s declared formal-model subject, because a hedge word clusters around a pattern’s most careful claims, so a hedge-word suppressor is biased toward silencing the findings that matter most. That regression was pinned to those corpus sites, and the pins had to be retired as the sites were repaired — a corpus-derived pin is perishable by construction, dying exactly when the finding is fixed, and it creates a bad incentive besides, since the cheapest way to make it pass is to delete it. It is now pinned to synthetic fixtures instead: a decoy block that must fire and an honestly-restated block that must stay silent, neither tied to any corpus file, verified by reintroducing the original bug. Where a check’s regression can be stated without a victim, state it without a victim.
Which pass owns it
Detection is Pass 3 (adversarial) in practice — the question “what is the sequence in which this fails?” is what surfaces it — but the classification is Pass 2 (EOS): whether the reachable partial is a missing record or a false one is a question about where a capability lives, and the answer decides whether the round edits a sentence or moves a boundary. The mechanical form is the linter check above.
Worked origins (all 2026-08-27). Resolve a Person’s Data Rights Invariant 1 — manifestation A; order already correct; restated, with the disposition set carried in both intent records because a verdict is in no log. Capability-Backed Sharing Invariants 2 and 3 — manifestation B; the append sat inside the transaction, so an abort after it left a sealed disclosure event for a disclosure that never committed; rewired to durable intent → transactional domain mutation → durable outcome. Propagate Consent Revocation Downstream Invariant 3 — manifestation A, and the purest instance: both members irreversible, so there was never a transaction to enlist anything in; restated, with the propagation set’s boundary moved onto the existing intent event at no new field. Per-round detail lives in each pattern’s commit history and the class record in roadmap.md methodology debt #19.
A reconciliation is bounded at both ends — an age bound below, the audit horizon above
FROZEN — 2026-08-29. Stated when the second fresh-reader gates — gates run after a pattern’s open foundational findings had all been closed — returned the same defect shape in three of the first eight patterns sampled, each gated independently and each carrying a reconciliation the previous round had accepted. It is frozen on the day it is stated rather than left open, because the evidence it rests on is not one pattern’s archaeology but recurrence across independently gated patterns, and because a rule stated open is a rule the next round edits instead of applying. Unfreezing follows the same discipline as the section titled Authentication precedence: a case none of its arms covers, recorded first.
The rule. Every reconciliation leg — a sweep, a scan, a comparison of one record class against another — declares the interval it runs over, and the interval has two edges the leg must name: an age bound below, excluding invocations that may still be in flight, and the audit horizon above, past which the record class it is looking for has been lawfully destroyed. A leg with neither edge does two wrong things at once, in opposite directions: it reads work that has not finished yet as an orphan and corrects it, and it reads history whose events have aged out as a crash and re-runs it.
The two edges have different sources and are declared differently. The age bound is a deployment obligation of the composition’s own — a Configuration entry naming the longest an invocation of the action may take between its first committed write and its last, read against the seam clock the invocation began under — and a leg examines nothing younger than it. The horizon is inherited: it is the retention policy of the audit instance the leg reads, and above it the leg’s missing half is not missing, it is purged, so the survivors on the other side are the truth-bearing class the section titled A derived index splits at the horizon governs, not candidates for repair.
The tells
1. A correction fired from a comparison. “For every issuance with no completion, revoke.” “For every chain with no initiation event, treat as a crashed initiation and quarantine.” A leg that does something to the records it finds is the leg whose window matters, because a wrong window is not a wrong report, it is a wrong act — and the act is usually irreversible by the constituent’s own invariant. Read the comparison and ask what happens to an invocation that committed its first write one second ago.
2. “At quiescence” doing the work of a window. The phrase is correct and it is not a bound: an auditor cannot tell quiescence from a slow invocation without a declared duration. Where an invariant’s liveness arm says at quiescence and no Configuration entry says how long quiescence takes to reach, the arm is asserted, not checkable — the same defect the section titled Durability boundaries names for compensation_window, arriving at the reconciliation instead of the compensation.
3. A check quantified over “all” of a purgeable class. “For every X event, confirm a Y event exists” is false on a schedule the composition does not control, because X and Y are purged on the same policy and not necessarily on the same day. The check needs the horizon in its own text, and a stated answer for the pair whose members straddle it.
What it costs
One Configuration entry per bounded action (a completion bound), a stated relation between the leg and the audit instance’s retention policy, and each leg restated in three arms: below the bound, examine nothing; between the bound and the horizon, the leg as written; above the horizon, the survivors are truth-bearing and the leg reports rather than repairs. A check that reads the leg widens its window by whatever read latency the deployment discloses — a subscriber read that lags the dispatch by a bounded interval is not a coverage failure, and the check that says so needs the interval on the page.
Which pass owns it
Detection is Pass 3 (adversarial) — what does this sweep do to an invocation that has not finished, and to one whose events have aged out? — and the mechanical form is a Pass 1 reference-graph check: every leg’s lower edge resolves to a Configuration entry and its upper edge to the retention policy it reads under. No linter check; the leg’s shape is prose.
Worked origins. Login (second gate, 2026-08-28) — the issuance-reconciliation sweep revoked in-flight logins, because nothing told it how long a login takes; fixed with a declared login_completion_bound below which the sweep examines nothing. Multi-Party Approval (second gate, 2026-08-29) — the initiation leg had no horizon, so every lawfully purged chain read as a crashed initiation and was quarantined; fixed by bounding the leg and the additive rebuild’s quarantine to chains whose initiated_at lies inside the horizon. Notification Fanout (second gate, 2026-08-28) — fired_at was claimed as the instant the subscriber set was fixed, which nothing takes or observes; restated as a lower bound, with check 1’s window widened by a disclosed max_read_latency on the subscriber read.
Intents pair with outcomes by an invocation identity the seam injects
FROZEN — 2026-08-29. Same evidence, same freeze discipline as the section above: four of the eight second-gate patterns returned a pairing defect, in four different disguises.
The rule. Where a composition writes an intent record and later an outcome, both carry one invocation_id — minted nowhere inside the composition, injected at the same seam as now (the Logic Confinement Principle), fresh per state-changing invocation — and every sweep join, every acceptance check, and every audit question that pairs an intent with its outcome pairs on that field. Where the pairing is nonetheless undecidable from the records — older records written before the field existed, a marker the deployment lost — the sweep names the candidate set rather than choosing a member, and closes the others as abandoned.
This is the generalization of a rule the section titled Authentication precedence already states for bindings: whenever a check is claimed to verify an ordering or a binding, name the field on the record that makes it recomputable. What the second gates showed is that naming a field per check is not enough, because the field named is usually the wrong one — a per-case key on an action that is repeatable against the case, a per-subject serialization on a scan that can see a concurrent sibling’s records, an intent event id carried on some outcome kinds and not others. One key, injected, on everything, is what makes the join the same question everywhere.
The tells
1. The definite article. “The intent record” in a sweep, where the action can run twice against one subject. One stale intent then satisfies the check for an unbounded number of later acts.
2. A key that is narrower than the act. A join on case_id, record_ref, subject_ref, or (subject, initiator, scope) where two invocations can share it. The tell is a serialization argument — serialized per chain_id — offered as the reason the join is exact, when the scan the join feeds runs under a different key than the serialization does.
3. A recovery emission that matches on the subject. A sweep that re-emits an outcome with recovery = true because a record for that subject is missing pairs an intent with whatever outcome it finds, and under retry or concurrency it emits records that are false as written.
4. An outcome kind without the key. Where an action has several outcome payloads — the success, the refusal, the void — and the acceptance check’s join names a field, read every payload and confirm each carries it. One origin pattern had the field on its main path and on none of three branch payloads its own check joined over.
What it costs
One field on every intent and outcome payload, injected at the seam, and a join clause in each check that names it. No Configuration entry. Where the composition’s serialization is keyed by something the scan can distinguish — a chain’s own id carried as the constituent call’s reason — the same key serves both.
Which pass owns it
Detection is Pass 1 (GRID) in its mechanical form — a check that says pair, match, join, or for the corresponding names the field, and every outcome payload the action can write carries it — and Pass 3 (adversarial) for the two-identical-acts question: given two invocations of this action against one subject, which record answers for which? No linter check yet; the mechanical form is a payload-field presence test the linter could carry once payloads are written in one shape.
Worked origins. Defensible Retention (second gate, 2026-08-28) — intent/outcome pairing undefined, so the sweep re-emitted false recovery = true records under retry and under concurrency; fixed with a seam-injected invocation_id on every audit record and a sweep that lists attributed_to candidates where the pairing is undecidable. Customer Onboarding (second gate, 2026-08-29) — check 6’s join key intent_event_id was absent from three of the outcome payloads it joined over. Multi-Party Approval (second gate, 2026-08-29) — the sibling-safe scan withdrew a concurrently initiating sibling’s step, because the scan’s key and the serialization’s key differed; fixed by carrying the invocation’s chain_id as the submit’s reason. Capability-Backed Sharing (second gate, 2026-08-29) — the intent carried no disclosure_id and the disclosure record no token, so an unmatched intent could not be joined to its disclosure at all; the honest answer there was not a key but a downgrade — escalated, never sealed.
Recovery commits under a declared service identity behind its own intent record, and what cannot be re-derived is re-run
FROZEN — 2026-08-29. Stated from the second gates and from two first-round findings the same week that reached the same shape from the other side. The rule is the conjunction of three things the corpus already says separately — the section titled Authentication precedence’s binding half, the section titled Durability boundaries’ carry-the-material rule, and the Execution Contract’s classification of derived state — applied to the one action every regulated composition has and few had written down: the one that runs when the original invocation is dead.
The rule. Any constituent commit made outside the original invocation — a retry after restart, a sweep’s compensation, a cascade’s recall, a re-invocation on an already-* arm — runs under the composition’s declared service identity (a registered application_actor_ref and application_credential in the substrate’s Actor Identity registry), is preceded by its own recovery-intended record naming the invocation it repairs (the key of the section above) and what it is about to do, and writes only what it can re-derive from the constituent stores or the sealed trail. What it cannot re-derive it does not re-emit: the act is re-run through the action’s own idempotent re-entry arm, or escalated.
The three clauses each close a hole the others leave. Without the identity, the recovery record is attested under a human who was not present (the binding defect). Without the recovery-intended record, the composition’s own trail cannot show that the recovery was occasioned by a repair rather than by a direct call (the provenance defect). Without the re-derivability test, the recovery remembers — from process memory, from a presumed value, from the intent alone — and what it writes is evidence of an act whose content nobody can check (the fabrication defect, which the sealed record then protects forever).
The tells
1. “Re-emit the owed record” with no source named. Ask where the payload comes from. If the answer is the intent record, ask whether the outcome owns a datum the intent must not carry (the section titled Authentication precedence, when the intent record should carry its plan) — a minted id, a verdict computed after the intent. If it does, the recovery cannot write the outcome; it can only re-run the act or say the act was abandoned.
2. Recovery attributed to the human. A sweep step that calls record_action(actor_ref = <the requester>, …) on a path where the requester’s credential is not in hand. The substrate will refuse it or, worse, a cached credential will let it through.
3. A re-invocation that dies on already-* before it reaches the step that failed. The action’s step list commits at step 5 and fails at step 6; the retry re-enters at step 1, hits already-closed at step 5, and stops. Every action whose later steps can fail after an earlier irreversible commit needs a re-entry arm that recognizes its own prior commit and continues.
4. A guard that rests on a transient. A provisioning step gated on an in-memory Approved that no rebuild reproduces means the recovery either cannot fire the step or fires it twice. The guard must be readable from a store the recovery can reach.
What it costs
Two Configuration entries (the service identity), one action_ref per composition for the recovery-intended record, an idempotent re-entry arm on every action with a post-commit failure step, and — the expensive part — an honest sentence per recovery leg saying whether its record is derived or re-run. Where a re-run is impossible and the record is not re-derivable, the leg emits an abandoned record under the service identity and the pattern’s liveness arm degrades to surfaced, which is what the records can actually support.
What this does to the formal layer
The recovery is its own action in the model, with its own actor, or the model cannot distinguish a recovery that repairs from a recovery that fabricates. A model in which the sweep sets the outcome variable directly encodes the fabrication as correct behavior.
Which pass owns it
Detection is Pass 3 (adversarial) — who writes this record, under what identity, from what source, and what if the source is gone? — and classification is Pass 2 (EOS): which of the recovery’s records are derived (re-derivable, rebuild-on-miss) and which are not is a question about where the fact lives, and the not-derivable ones are the ones that must be re-run.
Worked origins. Customer Onboarding (second gate, 2026-08-29) — the post-closure floor had no compliant recovery when the retention placement failed after the party was closed: cross-invocation constituent commits were the thing the action’s own text forbade, and re-invocation died at already-closed; fixed with the declared service identity, a customer-onboarding.recovery-intended record, and a re-entry arm. Login (second gate, 2026-08-28) — the recovery claimed to re-derive every owed record and could not re-derive the cascade’s own; fixed by writing the cascade’s join key into the Session record it revokes and, where a cascade died before completing, emitting credential_revocation_cascade_abandoned and re-running rather than re-emitting. Resolve a Person’s Data Rights (second gate, 2026-08-29) — the scan compensated intents that had no disclosure behind them, writing a sealed event for a disclosure that did not exist; fixed by conditioning the compensation on the disclosure’s existence. Execute Gated Workflow (2026-08-27) reached the same rule from a first-round finding: committed-but-unrecorded work is re-derived from the constituent stores, never remembered by the process.
A transcribed rejection arm keeps its payload and its reachability
FROZEN — 2026-08-29. Stated from four second-gate findings in three patterns, and from refining lines two other patterns already carried for the bare token (every substrate-arm transcription, five rejection sites). The refining lines were right and were being closed one at a time; the second gates showed the defect is foundational when the dropped payload decides whether a retry is safe.
The rule. When a composition maps a constituent’s rejection into its own, the mapping carries the arm’s declared payload — recording-failure(step), cascade-failure(step), mechanism-failure(reason) — and lands every arm the constituent’s contract can reach, including the ones the composition believes it has made unreachable. A bare recording-failure is not an abbreviation; it discards the one fact the caller needs to decide what is on disk.
The substrate makes the point concrete, and it is the substrate every regulated composition here writes to. Audit Trail’s record_action fails at step 2 (attestation) with nothing committed, at step 3 (append) with an orphan attestation, and at step 4 (retention placement) with the event already appended — so recording-failure(step-4) means your record exists; read its id back and clear whatever pending marker you hold, and a retry re-appends. Only the step-2 and step-3 arms are retry-safe. A composition that maps all three to one bare token has written a retry loop that duplicates outcome events under the failure it was written for. The same step is why invalid-request is never unreachable from record_action: step 4’s invalid-policy and policy-not-found arrive as invalid-request, and they come from the substrate’s own retention Configuration, not from the caller’s payload — a deployment fault, reached with the event appended. A composition that argues invalid-request cannot occur here because the payload is composition-built has reasoned about step 1 and step 3 and forgotten step 4.
The tells
1. A bare token on the left of a mapping arrow. `recording-failure` → `rejected(recording-failure)` transcribes the substrate’s arm and drops its payload in the same stroke. The linter finds this one.
2. “Unreachable here because …”. Every such sentence names the steps it reasoned about. Check the ones it did not.
3. A retry that does not ask which step failed. “On recording-failure, retry until the write lands” — correct for two of the three steps and a duplicate-event generator for the third.
4. A code in the prose and not in the signature. The signature block is the surface a caller switches on (the section titled Authentication precedence, the signature block is where attention does not land). A landing described in an edge case for an arm the signature does not declare is a landing the implementer never sees.
5. Validation after the intent. An intent record written before the composition’s own commit-free checks means every rejection path the spec describes as leaving no trace leaves an open marker. Checks that need no commit run first; the intent record is the first write, not the first step.
What it costs
(step) on every transcription; one landing per arm, usually two sentences — step-4: the event is appended; read the id back through the declared read and continue; alert on the retention configuration — and the code added to the signature. The limit-shaped arms need one more thing: where the substrate caps a field (reference_length_cap on actor_ref and action_ref), the composition validates every reference it will pass — including ones it reads from its own store, such as an approver’s — before the intent, or one over-long reference makes every decision on the chain refuse.
The mechanical slice
tools/linter/lint.py check S-recording-step: in a composition that composes Audit Trail, a bare `recording-failure` on the left of a mapping arrow (→), on a line that also names record_action, above the Status section. A bare token in that position is a transcription of the substrate’s arm with its payload dropped; the same token elsewhere — in a signature block naming the composition’s own code, in an example, in prose — is not flagged, because a composition may lawfully declare a recording-failure of its own over a non-substrate write (Reserve from Pool’s recording-failure(post-commit) is one). The same-line condition was added on 2026-08-29 when the check’s first draft, which assumed only Audit Trail emits the token, fired on Privileged Access Provisioning’s transcription of Multi-Party Approval’s arm: compositions re-export recording-failure bare at their own caller boundary, so a composer transcribing a peer’s arm is transcribing it correctly, and the rule reaches the peer’s own transcription of the substrate one level down. It landed advisory on 2026-08-29 measuring twenty-three sites across six patterns (twenty-two across five after the same-line correction), and was promoted to gating the same day, when the sweep under this rule closed the last of them and it fired zero times corpus-wide — the same promotion discipline P-atomic-audit followed. Its regression guard is synthetic: a mapping that drops the step must fire; the same mapping carrying (step) must stay silent; a bare token in a signature block must stay silent.
Which pass owns it
Pass 1 (GRID) — the reference graph: every mapped arm resolves to the constituent’s declared shape, and every code the prose lands appears in the signature — with the reachability argument left to Pass 3 (adversarial): for each arm, which step failed, and what is on disk when it did?
Worked origins. Capability-Backed Sharing (second gate, 2026-08-29) — dropping (step) made the retry duplicate outcome events, and invalid-credential / invalid-request were unlanded at two redemption steps; fixed with a uniform (step) rule, a step-4 read-back, and both codes in the signature. Login (second gate, 2026-08-28) — invalid-request declared unreachable at four steps that the substrate reaches by deployment fault. Multi-Party Approval (second gate, 2026-08-29) — reference_length_cap on an approver’s reference made every decision on the chain refuse; fixed by validating each reference before the intent. Defensible Retention (second gate, 2026-08-28) — the intent record preceded the commit-free checks, so rejection paths said to leave no trace left an open marker.
A seal presentation is keyed by log position over the covering range
FROZEN — 2026-08-29. Stated from two first-round findings of 2026-08-27 that closed the same way in two patterns, and from a third pattern the linter check below finds still carrying the shape. It is the narrowest rule on this page and the one with the cleanest mechanical form.
The rule. The payload set presented to AuditTrail.verify_record is the covering range read_record names for the event — every payload in the seal’s coverage, in ascending sequence_number order — and a composition that passes the caller’s presentation through keeps it as a map keyed by sequence_number, never by its own identifier. The record set a seal commits to is a sequence range (Audit Trail Invariant 7), and under any cadence but per-event that range spans events the composition did not write and has no id for. A map keyed by event_id, entry_id, or disclosure_id can hold at most one payload per event, so under the interval cadence the substrate recommends every verification returns a seal-record-set mismatch — and an acceptance check built on it reports tampering on an intact log.
Two corollaries the same rounds produced. An entry whose covering range is not wholly present in the map is reported unverifiable(payload-not-supplied(missing)), naming the absent sequence numbers, rather than failed — partial verification of the entries whose ranges are supplied is still worth having. And a replay that must be ordered is ordered by the log position of the record that fixes the order — the intent event’s sequence_number, where the intent precedes the act — not by the outcome’s, and not by a per-record list whose order is the order of writes that landed.
The tells
1. original_event_payloads[event_id]. The subscript says what the author thinks a seal covers.
2. The singular. “The payload”, “its original payload”, one verify_record(event_id, payload) per event in a walkthrough. The substrate’s own parameter name is singular and its Invariant 7 is not; the composition inherits the invariant.
3. A per-event cadence assumed where the Configuration recommends interval. The walkthrough’s arithmetic — one seal, one event, one payload — is the healthy special case, and the rule is the range.
The mechanical slice
tools/linter/lint.py check T-seal-key: an original_event_payloads map subscripted or described as keyed by an identifier ([event_id], [entry_id], “keyed by disclosure_id”) in a composition body. It landed advisory on 2026-08-29 at one site and was promoted to gating the same day, when the sweep under this rule closed that site and it fired zero times corpus-wide. Bare-payload verify_record calls are not flagged — the substrate’s own contract uses the singular name, so a match on it would fire on the exemplar — and that recall gap is recorded here rather than closed by loosening.
Which pass owns it
Pass 1 (GRID) — mechanical, above — with the cadence question left to Pass 3 (adversarial): which seal cadence does this example assume, and what does the verification return under the other one?
Worked origins. Chain of Custody (2026-08-27) — original_event_payloads re-keyed by sequence_number, [Verify Custody] assembling each entry’s presentation from the range read_record names, and unverifiable(payload-not-supplied(missing)) for an entry whose range is incomplete. Forensic Recovery (2026-08-27) — the same re-keying, and the replay ordered by the intent event’s position, carried in the index as intent_position. Immutable Ledger — still keyed by event_id at [Verify Ledger] when this rule was stated; the check above found it, and the sweep under the frozen rules closed it the same day.
A compensator is exclusive — one writer per act, and the invocation yields at its bound
FROZEN — 2026-08-30. Stated from the third fresh-reader gates — the eight patterns the 2026-08-29 freeze had not yet gated, plus one re-grounding — which returned forty-seven foundational findings, forty-five of them confirmed by a second reader given the full record. Three patterns returned this shape, each gated independently, each carrying a reconciliation the sweep under the section titled A reconciliation is bounded at both ends had just extended. Frozen on the day it is stated, under the same discipline as that section: recurrence across independently gated patterns is the evidence, and a rule stated open is a rule the next round edits instead of applying.
The rule. For every act a composition can compensate, exactly one writer may land the outcome — the invocation or a reconciliation leg, never both — and the invocation’s own retry has a terminus: at the completion bound it yields, and everything after the bound belongs to the leg. Two legs that can see the same act serialize on the act’s key, and the look-then-write pre-check every compensator runs is re-read under that serialization, not before it. An age bound alone guards one side: it keeps the leg off work younger than the bound. It does nothing about an invocation that is still retrying past the bound, and nothing about two legs — restart and cadence, two nodes — that run the same comparison at once. Each of those is a second writer, and a second writer lands a second outcome for one act, which the sealed trail then protects.
The frozen the section titled A reconciliation is bounded at both ends presumes an invocation stops at its bound; nothing in the corpus said so, and the three origin patterns each said the opposite — retry until it lands with no terminus, beside a leg that starts at the bound.
The tells
1. “Retry until it lands” with no terminus. The phrase names a loop whose exit is success; it does not name the bound. Ask what the loop does at bound + 1, when the leg has already read the act as an orphan.
2. A pre-check that looks, then appends. “Traverse the log for an existing outcome carrying this key; if none, append.” Two compensators run it at once and both find none. The pre-check is correct only under a serialization that the spec names.
3. Two legs and no lock. A scan “at restart and on reconciliation_cadence” with no per-act mutual exclusion is two legs; on two nodes it is four. The frozen substrate closes its own version of this with a closed-state marker on the act (compensated_attestations); a composition’s leg needs the same or an equivalent.
4. A stalled invocation resuming after the leg. A step that is a bare append — no pre-check of its own, no lease — will land its outcome beside the leg’s when the process it belongs to wakes. Per-key locking that prevents interleaving does not prevent sequencing.
What it costs
One sentence per action with a post-commit failure step: the invocation attempts the outcome write until <x>_completion_bound, then yields; a later success is the leg’s. One serialization statement per leg naming the act’s key (the same invocation_id the section titled Intents pair with outcomes carries), under which the pre-check is re-read. Where the invocation cannot be made to yield — it holds no clock past its first read — the outcome step itself runs the pre-check under the act’s key and adopts an existing outcome as its own (proceed as landed). And a check that reads the pair widens from at most one outcome per intent to exactly one writer per outcome, named: the outcome carries recovery = true or it does not, and the pair is exact.
What this does to the formal layer
The model needs the invocation and the leg as two processes over one act, with the bound as the point at which one of them stops being able to write. A model in which the invocation is a single atomic step cannot exhibit the second writer, and passes.
Which pass owns it
Pass 3 (adversarial) — what does this invocation do at bound + 1, and what do two runs of this leg do at once? — with the mechanical form in Pass 1 (GRID): every retry loop names its terminus, and every leg names its serialization key. No linter check; the loop’s shape is prose.
Worked origins. Chain of Custody (third gate, 2026-08-30) — Invariant 4’s liveness arm retried the outcome write with no terminus while the scan started at the bound; both ran the same look-then-append pre-check with nothing between them. Forensic Recovery (third gate) — the restart scan and the cadence scan, and an invocation past its bound, could each compensate the same intent; the scan’s place in the replay was fixed, its multiplicity was not. Immutable Ledger (third gate) — [Disclose Subset] step 4 was a bare append, so a stalled invocation resuming after the scan had compensated it landed a second ledger.disclosed; the Configuration entry admitted the direction and named no remedy.
An outcome is sized before the intent — the cap is checked against the largest record the act can write
FROZEN — 2026-08-30. Stated from two third-gate findings and one refining line of the same round, in three patterns that each argued the substrate’s
invalid-requestwas foreclosed by construction at the outcome position because the payload was composition-built. The argument was about the intent; the outcome is a superset of it, and a compensation record is larger still.
The rule. A composition that writes an intent record before an irreversible commit sizes, at its commit-free validation step, the largest record the act can write — the outcome payload, and the compensation payload a reconciliation would write for it — against the substrate’s payload_cap, and refuses invalid-request before the intent when either would exceed it. Every set-valued field an outcome carries — the entries disclosed, the scopes affected, the credentials revoked — has a declared cardinality cap, in Configuration or in the field’s own policy, or the argument that the cap is unreachable is false. Foreclosed by construction means the construction is bounded; an unbounded set is not a construction, it is an input.
The consequence of getting this wrong is the one the section titled Durability boundaries names: the constituent’s record exists, the outcome that would bind it cannot be written, and the binding is un-writable for as long as the payload stays over the cap — which, for a set that only grows, is forever.
The tells
1. “Foreclosed by construction” / “the payload is composition-built”. Ask which payload. If the sentence was written about the intent, read the outcome’s field list and find the one the intent does not carry.
2. A set-valued field with no cap. disclosed_entry_ids — non-empty; affected_scopes — the complete set; revoked_credentials — every effective-Active credential. Non-empty is a lower bound. The cap is the upper one, and the caller can reach it.
3. A compensation larger than the outcome. A recovery record that carries the outcome’s fields plus intent_event_candidates, recovery = true, and the acting human. If the outcome fits the cap by one byte, the compensation does not.
What it costs
One sizing step at validation — construct the maximal envelope, or bound it arithmetically from the declared caps — and one cardinality cap per set-valued field. Where the set is genuinely unbounded (a long-lived consent’s registrations), the composition declares a chunked shape with every consumer of the field restated against it, or bounds the set by policy; a digest in place of the set is not a shape, because nothing that reads the set can read a digest.
Which pass owns it
Pass 3 (adversarial) under the Arms question — which step failed, and what is on disk? — with the mechanical form in Pass 1 (GRID): every set-valued outcome field resolves to a cap.
Worked origins. Immutable Ledger (third gate, 2026-08-30) — disclosed_entry_ids had no cardinality cap; the intent passed, the Selective Disclosure record committed, and the outcome could be refused by the cap with no exit. Forensic Recovery (third gate) — the uniform arm rule admitted an outcome-stage invalid-request orphan it then declared unclearable, against Invariant 4’s claim that every orphan is bound. Propagate Consent Revocation Downstream (third gate) — affected_scopes grows without bound, and the escape offered was a digest no processor can act on.
Liveness is arithmetic — bound plus cadence plus latency, strictly less than the window
FROZEN — 2026-08-30. Stated from one third-gate foundational finding and three refining lines in the same round that each corrected the same inequality. The corpus had been writing cadence no longer than the window since the section titled Durability boundaries introduced
compensation_window; the sweep under the section titled A reconciliation is bounded at both ends added a lower edge to every leg and did not re-derive the inequality the edge changes.
The rule. Where a liveness arm promises closure within a window, the Configuration states the inequality that makes the promise true — the completion bound the leg waits out, plus the cadence between runs, plus the write latency of the closure, strictly less than the window — and the check that confirms the deployment meets its window confirms that inequality, not a fragment of it. An orphan created at t is invisible to the leg until t + bound; the next run is at most cadence later; the closure lands latency after that. cadence ≤ window is satisfied by a deployment that breaches the window on every orphan.
The tells
1. “Cadence no longer than the window.” Two of the three terms are missing.
2. Equality admitted. No longer than is ≤. At equality the closure lands exactly at the window’s edge, after the latency the inequality did not count.
3. A check that reads Configuration for one knob. Confirm reconciliation_cadence ≤ compensation_window. The check is true and the promise is not.
What it costs
One inequality per liveness arm, written out in Configuration with its three terms, and the sentence checked at instance start — a deployment whose knobs do not satisfy it refuses to start rather than starting to breach. The check that confirms the window reads all three.
Which pass owns it
Pass 1 (GRID) — mechanical: the inequality is on the page and its terms resolve to Configuration entries — with Pass 3 (adversarial) doing the arithmetic on a concrete triple.
Worked origins. Actor Suspension (third gate, 2026-08-30) — check 6 confirmed cadence ≤ completion_window while the sweep skipped entries younger than suspension_completion_bound; a fifteen-minute bound, a ten-minute cadence and a ten-minute window breach on every suspension with the check passing. Propagate Consent Revocation Downstream, Forensic Recovery, Chain of Custody (third gate, refining) — the same fragment.
A stamp from another seam never decides a write alone
FROZEN — 2026-08-30. Stated from two third-gate foundational findings and two refining lines, in patterns that had each stated the Logic Confinement Principle correctly for their own seam and then compared their own reading against a constituent’s.
The rule. A timestamp the composition wrote from its seam and a timestamp a constituent wrote from its own are two readings of two clocks. They may be compared only under a declared offset allowance — a Configuration entry — and the comparison may narrow a decision, never make one: no pairing, bypass verdict, enrollment, compensation, or refusal rests on it alone. Where the composition needs equality, it passes its own reading through to the constituent (disclosed_at = now, revoked_at = now), so that the stamp on the constituent’s record is the composition’s and equality is by construction. A constituent that calls its own range read best-effort under skew has told the composition the read is advisory; a composition that gates a write on it has overruled the constituent’s own contract.
The tells
1. “Inside the bound before the record’s granted_at.” The bound was declared against the composition’s seam; granted_at was stamped by the constituent. The inequality has a sign that skew can flip.
2. A constituent’s advisory read used as a gate. Party Identity: “an [Enrolled At] range … under clock skew its result set is best-effort.” A resume arm that decides enroll again on that read’s emptiness has made the constituent’s caveat load-bearing.
3. A pass-through on one side and not the other. The withdrawal side passes revoked_at = now and pairs exactly; the grant side does not pass granted_at and pairs on before. The asymmetry is the finding.
What it costs
One Configuration entry (clock_offset_allowance), symmetric windows widened by it wherever two seams meet, the pass-through wherever the constituent’s contract accepts the stamp, and — where it does not — the decision downgraded from a verdict to candidates or an escalation. The Generation acceptance standing rule most patterns already carry for checks is the same allowance; this rule carries it to the writes.
Which pass owns it
Pass 3 (adversarial) — the Time question: whose clock stamped each side of this comparison? — with the mechanical form in Pass 1 (GRID): every cross-seam comparison names the allowance it runs under.
Worked origins. Propagate Consent Revocation Downstream (third gate, 2026-08-30) — the grant-side scan paired an intent to a Consent record by intended_at before granted_at and landed bypass, write nothing on the result; a three-second skew made a real orphan un-withdrawable forever. External Onboarding (third gate) — the resume arm’s duplicate-freedom rested on Party Identity’s enrolled_at range read, which Party Identity declares best-effort, with no margin. Forensic Recovery, Propagate Consent Revocation Downstream (third gate, refining) — the composition’s now handed to a constituent whose own future-bound guard runs on its own clock, an invalid-request reachable after the intent.
A composition’s own rejection arm carries the retry bit
FROZEN — 2026-08-30. Stated from two third-gate foundational findings that the section titled A transcribed rejection arm keeps its payload does not cover and was written not to: that rule governs the transcription of a constituent’s arm, and its linter check’s own note records that a composition lawfully re-exports
recording-failurebare at its own boundary. Two patterns showed the re-export is not lawful when the bare token covers two dispositions — the case that rule’s arms do not name, recorded here first as its unfreezing discipline requires, and closed by a rule of its own rather than an amendment.
The rule. A rejection code a composition exports at its own signature carries whatever the caller needs to decide whether a retry is safe. Where one token would land at a position before the act’s irreversible commit and at a position after it, the token carries the position — recording-failure(intent | outcome), or two codes — and the signature block declares the payload. The composition boundary is a transcription too: of the composition’s own steps, to a caller who cannot see them. A caller who receives a bare token after an outcome-position failure and retries has been told, by the signature, that nothing was committed.
The tells
1. One token at two steps, one on each side of the commit. The linter finds this one.
2. “The collapse happens only at the caller boundary.” Written as reassurance; it is the defect. The caller is the one who retries.
3. A retry rule the signature does not carry. “Retry only on the intent-position arm” in an edge case, with recording-failure bare in the signature.
The mechanical slice
tools/linter/lint.py check U-retry-bit: within one action’s step list in a composition that composes Audit Trail, a bare `rejected(recording-failure)` landed at a numbered step before the action’s first qualified constituent commit call and at a numbered step after it. Read calls (read, read_record, check, verify_*, history_for, active_for, and the like) do not count as the commit; AuditTrail.record_action does not count as the commit, because the intent record precedes the act by design and its own arm is retry-safe. It landed advisory on 2026-08-30 measuring ten actions across five patterns, two of them patterns the second gates had already closed, and was promoted to gating the same day, when the sweep under this rule closed all ten and it fired zero times corpus-wide — the third check to follow P-atomic-audit’s promotion discipline. Its regression guard is synthetic: two bare landings straddling a commit must fire; the same two with (intent) and (outcome) must stay silent; two bare landings both before the commit must stay silent.
Which pass owns it
Pass 1 (GRID) — every code the prose lands appears in the signature with the payload the prose distinguishes — with Pass 3 (adversarial) asking, for each exported code, what does the caller do next, and is it safe at every step that lands the code?
Worked origins. Immutable Ledger (third gate, 2026-08-30) — the spec stated the collapse in its own words: two dispositions, retry the whole action and do not retry, a disclosure record exists, shared one token at the caller boundary. Forensic Recovery (third gate) — three lifecycle actions exported the same bare code from a step that had committed nothing and from a step that had committed the transition and owed the audit record; the hard alert and compliance finding Invariant 4 said the outcome carried appeared in no signature.
The stories of the formal-model authoring pitfalls, moved 2026-11-13
The thirty-six dated entries of the section Formal-model authoring pitfalls in Pressure Testing, moved here whole on 2026-11-13; the page keeps each entry’s instruction.
-
An action that fuses a guard with its effect cannot find a check-then-act defect (2026-08-30). If the model evaluates
remaining >= write_boundand performs the write in one atomic step, no time can pass between them, and “a write issued inside the lease lands inside it” stops being a fact the model derives and becomes one it defines. The first Recoverable Invocation model did exactly that, held over 38,394 states, rejected three twins — and a fresh reader then found that the gate it had validated is check-then-act, which the spec itself says of relative timeouts two sections away. Split every lease, deadline, freshness and liveness gate into two actions, with time free to pass between them, and budget the pause rather than forbidding it. The corrected model reproduces the defect on its own and, with the remedy as a constant, says which mechanism actually carries the invariant: the fence does, and the gate — the thing the page had leaned on for two rounds — carries none of it. -
Where the model is more disciplined than the spec, it is validating a better spec than the one anybody will implement (2026-08-30). This is the general form of the trap above and of debt #19’s the model proved what it was told: not a model told too little, but a model that quietly supplies the care a careful implementer would supply. The first Recoverable Invocation model held its critical section until its closing write had landed; the page releases it when
record_actionreturns. It gave the sweep the act’scompletion_boundas a lease; the page gives itmax(completion_bound, closure_latency). Neither divergence is visible as an error — each reads as a sensible modelling choice — and each hid a real defect. Audit a model against the spec’s stated discipline, clause by clause, asking of every guard and every ordering: does the page say this, or am I supplying it? Where the model must be more generous than the page to stay tractable, say so and say why the gap cannot matter. -
A property that is really liveness, checked as time-indexed safety, needs the stall budgeted (2026-08-30). A window (“closed within
compensation_window”) stated as a safety property over an explicit clock is checkable — but in a model without fairness, “pause for ever” is always an available behaviour, and it starves the act at every window. Read naively that looks like an unmeetable bound; it is a statement about fairness. Give the pause an explicit budget, so exceptional pauses stay reachable (the safety counterexamples need them) while the arithmetic becomes measurable. Then derive the bound by controlled variation — hold everything fixed, move one term, measure the smallest window that holds — rather than reading it off the prose. -
STANDING ROUND DISCIPLINE: the diff-derived obligation sweep (2026-09-10). This is a procedure every repair round runs, not a lesson to remember. Before a round is delivered, take the round’s own diff and list every obligation it introduced or removed — each new
must, each inequality, each new key or argument, each new exemption, each deleted source, each renamed token, each newly declared piece of state. For each one, write down the sites that now have to honour it and check them: the worked examples that must satisfy a new inequality; the acceptance checks that must carry a new key; the modes the page already declares which need an exemption from it; the totality claims (“these four are the whole of it”, “six clocks meet here”) a new element falsifies; the signatures still exporting a code whose last producing source the round deleted; the sibling surfaces a rule was stated at one of. The list is short — a round introduces perhaps ten obligations — and it is derived from the diff rather than from the corpus, which is what makes it tractable and what makes it find things. A numeric subset is mechanical and worth automating first: every worked example’s bound values satisfy every inequality the page declares. Run this sweep in addition to the token sweep, never instead of it, and expect it to find more. -
Sweep obligations, not tokens (2026-09-10). A repair round should end with a sweep, and this campaign has been sweeping the wrong thing carefully. The token sweep — is this identifier spelled two ways, is this code declared and never landed, does this registry entry have a marker — runs clean and is worth keeping, and it is blind to the defect that actually recurs. The recurring defect is an obligation introduced in one place and not carried to the places that must honour it. Supersession made transitive at one action and left pairwise at the three surfaces the same paragraph names. A duplicate key added without exempting the mode the page itself says produces duplicates by design. A configuration floor added, and the worked example eight lines below it breaching the floor. An acceptance check re-keyed onto a record only one of its two branches has a producer for. Sixteen of one gate’s nineteen self-inflicted findings were that one shape, and every one of them survived a token sweep that reported nothing. So the sweep to run is derived from the round’s own diff, not from the corpus: for each normative statement the round introduced — every must, every inequality, every new key, every deleted source — enumerate the sites that have to honour it and check each. It is a checklist, it is short because a round introduces few obligations, and it is the only sweep that looks where the defects are. A numeric subset is even mechanical: every worked example’s bound values satisfy every inequality the page declares is pure parsing and would have caught the floor breach outright.
-
The sweep finds neighbours, not only the diff’s own sites (2026-09-10). The discipline says the list of obligations is derived from the round’s diff, which is what makes it short enough to run. That is still right, and it undersells what the run produces. Enumerating an obligation forces you to name the sites that must honour it, and naming a site means reading it — at which point defects that have been sitting there for rounds become visible, because you are for once reading that passage with a specific question rather than for general sense. One round’s sweep, checking whether a new count reached the Summary, found the Summary and the Ledger both saying the formal model has five components and both then listing six, an operator having been added two gates earlier without the count moving. Nothing in that round touched either sentence. So do not narrow the sweep to a diff-versus-site test. The diff decides which passages to open; what you find once they are open is the sweep’s second yield, and on this evidence it is not small.
-
A delegated obligation needs a discharge record, or it is not delegated — it is dropped (2026-09-10). This corpus is scrupulous about admitting what it will not decide. An atom that will not settle a question says so and hands it to the composing layer; a composition that will not settle it says so and hands it to the deployment. Both halves are honest and both are load-bearing — and nothing tracks whether the last party in the chain ever decided. The instance: a permissions atom stated that duplicate active grants on one
(subject, scope)pair are permitted and that “composing systems that intend to issue a single authoritative grant should guard against concurrent issuance”; the composition wiring it acknowledged that and re-delegated, naming the failure mode exactly — “accidental (a UI double-click before the first request returned)”; the deployment never picked it up, and a user reported an actor holding the same permission eleven times. No spec was wrong and the generated code was conformant the whole way down. That is a fourth class of finding, distinct from the three the frame metric carries — not an uncaptured requirement, not a transcription failure, not silent completion, but correctly captured, correctly delegated, never discharged. Its mirror is the render-local notes file whose findings about other renders never travel upward; together they say the return path is broken in both directions, and neither direction has a mechanism. The remedy is an artifact, not a check, and the third triage question is why: the decidable form — every delegated obligation is acknowledged by every composition that composes it — passes on the instance that motivated it, because acknowledging and re-delegating is acknowledgement. The hop that fails is composition → deployment, and the deployment is not in the corpus. So generate the transitive set of delegated clauses for a wiring as a deployment obligation sheet and make answering it part of shipping. The population is already there and nearly formulaic: 159 clauses across 40 files corpus-wide, 51 for one demo’s wiring. -
A check is only as reliable as the surface it parses, and this corpus has measured that (2026-09-10). Eleven checks have been through the promotion pipeline. Sorted by what surface they read rather than by what they check, the outcome is unanimous: six of six promoted checks parse a place where the language was already controlled — the Ledger block, the Status line, the Terms registry, the signature fence, numbered steps, a bolded count claim — and five of five rejected checks were reading ordinary English. Each rejection was argued on its own terms at the time, and one sentence predicts all five. So the triage questions this page already carries — can a finding be dismissed without reading a claim, does the shape recur, does the decidable form cover the defect — have a cheaper predecessor: is the thing being read already written in a controlled form? If not, the honest options are to reject the check or to control the surface first, and the second is usually the better trade, because a controlled surface pays every future check as well as this one.
The corollary is a design instruction, not just a triage one. Where an obligation matters enough to check, make its sentence shape fixed before writing the checker. The corpus’s most reliable check is the one reading its most rigid container, and its most embarrassing near-misses were checkers built to infer intent from paragraphs. Control the surface, then check it — in that order, because the reverse produces a check that runs, passes, and lies.
-
Introducing a form is riskier than discovering one, so introduce it at one site (2026-09-10). The rule for a controlled vocabulary is that forms are discovered: a construction appears in prose, survives pressure testing, acquires a stable meaning, gets recognizable tells, becomes mechanically checkable, and only then becomes canonical. That rule has an exception and it is worth naming so it is not taken silently. Sometimes the concept is thoroughly earned — proven by findings across several rounds — while the phrasing never stabilized, because each round said it differently. Authoritative ownership of an obligation is the case here: three consecutive gates were about it, a frozen rule depends on it, and the corpus says it in those words eleven times in seven files out of fifty-seven. The words have to be introduced rather than found. When that happens, introduce the form at exactly one site — one spec, 2026-09-10 — and let it be used before it is propagated, because nothing has pressure-tested the phrasing and a form spread to forty sites before its first real use is forty sites to re-edit. A discovered form arrives already tested by the prose that produced it; an introduced one has to earn the same standing the slow way.
-
Where a claim lives in both a controlled form and a prose form, the prose is the half that rots (2026-09-10). This campaign now has two clean instances from a single round, and they point the same way. A page declared a configuration floor in prose as
run_bound ≥ 2 × closure_latency + journal_write_bound, while the schedule enumerator that had refuted two earlier forms of the same inequality was filtering onmax(completion_bound, closure_latency + journal_write_bound) + closure_latency— the correct form, since the holder a run waits out may be an invocation and not a sweep. The two disagreed for two rounds. Re-run under each, the prose floor admits 324 of 432 tuples and the window inequality breaches on 15 of them; the enumerator’s admits 288 and breaches on none. In the same round a fresh reader found that a duplicate-detection key had no exemption for the mode the page itself instructs to produce duplicates — while the formal model’s corresponding invariant had been writtenServiceIdentity => ~secondOpenedsince the gate that added it, with the branch in it all along. In both cases the machine-readable artifact was right and the sentence was wrong, and in both cases the sentence was the newer of the two. The instruction is cheap: when a claim exists in a model, a checker, an enumerator or a fixture as well as in prose, diff them deliberately at the end of every round — not to see whether the code implements the page, which is the usual direction, but to see whether the page still says what the code checks. And the deeper reading is the one the controlled-language work is built on: the prose did not rot because anyone was careless with it. It rotted because nothing was reading it. -
Measure the form, not the word — and say which you measured (2026-09-10). A count reported seven candidate controlled forms as earned, 45–57 of 57 files each, and a grammar proposal was drafted on it. The count measured English words two ways at once: it ignored case, so
must,beforeandaftercounted, and it matched fragments and synonyms, soderived from(48 of 57 files) stood in forIS DERIVED FROM(7) and never forMUST NOT. Re-measured over the 56 files ofatoms/andcompositions/(the first count’s 57 also included the Recoverable Invocation draft), for the uppercase token in its controlled role,MUSTis in 3 files,MUST NOTin 1, and every other candidate in none — while the same words in any case run from 6 to 55. The concepts are pervasive; the forms are absent. Both are true and they are claims about different things, and only one of them is evidence that a form has been discovered rather than invented. So a vocabulary measurement states its match pattern, its case rule and its file set, or it is not a measurement of a form — a rule about case alone would not have caught the fragment match. The deeper consequence is that earned cannot mean the token already appears in its controlled role — that is circular, since a controlled form exists to replace the free-prose expression of an idea and its token appears only once someone admits it. It has to mean the concept recurs and its free-prose expression has drifted or produced findings; recurrence alone is not a case, because the commonest words in this corpus are the ones carrying the least obligation. The failure here was mine and it was the campaign’s own signature shape at one remove: a number was produced, believed, and propagated into a roadmap entry and a language proposal without anyone asking what it had counted. -
Extend an earned form’s field set before inventing a new one (2026-09-10). A round that needs to state four parallel facts about each of three things reaches naturally for a table. Before doing that, look at what the page already has: this corpus’s term entrys are aligned key-value blocks, a controlled surface that has been through the promotion pipeline and carries a passing check. Re-using that shape with a different field set —
Instant / Minted by / Judged by / Value / Bound atbeside the existingKind / Member of / Role / Projection— costs a reader nothing to learn, keeps the parse surface the checker already understands, and does not spend the risk budget that the entry Introducing a form is riskier than discovering one is about. A new field set inside an established shape is a discovery; a new shape is an introduction. Reserve introductions for the cases where no earned shape fits. -
Ownership has levels: extracting a rule leaves its bindings behind (2026-09-10). An extraction moves the rule to one owner and, by design, leaves the composing pattern its bindings — which key, which holder, how long, which arm maps to which code. That is correct and it is the whole reason the extraction shrinks so little. But a binding is an obligation too, and it can be owned in as many places as the rule was. One page bound a fence three times: one passage minted the instant with the allowance, a second said the fence carried the bare instant “which is where the first puts it” — an assertion about a passage that says the opposite — and a third cited the second. The atom was faithful, the rule was unambiguous, and a generator reading any one of the three built something different. So run the ownership count twice: once on the rule, once on each binding of it, and consolidate the bindings on the composing page even after the rule has left it. A rule with one owner and a binding with three is a defect wearing the composing pattern’s clothes.
-
Consolidating is a change like any other, and needs the obligation sweep run on it (2026-09-10). Creating a single owner for a scattered rule feels like the end of a repair, and it is the beginning of one. Three of one gate’s six foundational findings were the residue of two consolidations done the round before: an exemption that one of the old owners carried and the new owner did not, so the page went on mandating a state three surfaces report as a failure; a classification every sibling element carries that the new element was not given; and a binding never consolidated at all. The sweep’s question at a consolidation is not the usual one. What must change because of this is the question for a new obligation. For a new owner it is: what did the old owners say that the new one must now say? Walk each site the consolidation emptied and check that every clause it carried — the exemptions, the classifications, the degradations, the pointers — arrived at the new owner or was deliberately dropped. A clause that was in one of four owners and none of the citations is the most likely thing to be lost, because the three that lacked it look like agreement.
-
DRY on responsibility, not on nouns — and extraction is not the only cure (2026-09-10). The rule that decides what to pull out of a document is not this word appears a lot. It is: one authoritative owner per obligation. A repeated use of a concept is composition and is exactly what a library is for; a repeated ownership of an obligation is duplication, and it is the thing that propagates badly, because a rule stated in four places is a rule that four rounds of repair must each find four times. The test is concrete: when this obligation changes, how many passages have to change with it? One is healthy at any frequency. Four is the defect whatever the word count.
That test has two cures and this library had been reaching for only one. Where the obligation is owned by several patterns, extract it to an atom they cite — which is what happened with lease semantics, and the small size of the resulting shrink is the correct outcome, not a disappointment: most of the page’s remaining lease references are bindings and uses, and those are supposed to stay. Where the obligation is owned by several sites inside one pattern — a rule stated at an action, restated at a read, restated at an invariant, restated at an acceptance check — the cure is a single normative statement the other sites cite, and it needs no new file. One review round found a rule made transitive at one of its four owners and left pairwise at the other three; no atom would have prevented that, and one owner with three citations would have.
So triage an extraction candidate by counting owners first and files second: owners in more than one pattern → an atom; owners in more than one place in one pattern → consolidate and cite. Both are the same rule applied at different scales, and confusing them either leaves the defect in place or mints an atom nobody else needs.
-
Choose an extraction by where the obligations are now, not where they have been (2026-09-10). An extraction removes future propagation, so the evidence for it has to be forward-looking, and the cumulative record is a backward-looking measure that quietly recommends the wrong candidate. A concept was extracted from one composition on exactly the right kind of evidence — recurrence, four rounds of it, the largest single source of obligations across the page’s whole review history. Classifying every foundational finding by the obligation behind it showed the share was real and declining: two of three at the first gate, three of seven at the second, and by the sixth gate one of nine, because the rounds in between had argued that concept out. The concepts that had taken its place — a findings surface with a state machine no atom names, and the duplicate-detection machinery — were each producing two or three findings a gate and had no extraction planned. The cumulative record measures what has already been fixed; the current round measures what is still costing. So rank extraction candidates by the obligation sources in the last one or two rounds, and treat a candidate whose share is falling as one the review has already handled by hand.
-
Say a measurement is underpowered before you run it, not after (2026-09-10). An extraction removed 1.9% of a document’s body. At the document’s measured defect density — one foundational finding per nineteen kilobytes — that predicts removing 0.19 findings, which is noise. The next review could not possibly detect the change, and a result at the old level would have been read, by someone hoping, as evidence that extraction does not work. The arithmetic that says so takes one line and is available before the review runs, which is the only time it is worth anything: afterwards it reads as an excuse. When a change is too small for the metric you were going to judge it by, either make the change bigger before measuring, or change the measure to something the change can move — here, findings classified by which obligation source they come from, which is directly attributable and needs no volume at all. A metric that cannot see your intervention is not a neutral metric; it is a metric that will report failure.
-
A flat defect density means the repairs are growing the denominator (2026-09-10). Four consecutive gates on one page returned 6, 7, 8 and 9 foundational findings while the body grew from 119 KB to 164 KB. Divide and the picture changes completely: 19.8, 19.7, 19.1, 18.2 KB per foundational finding — flat. The page has a stable defect density and each round of repair adds surface, so the absolute count rises with the size and the effort is invisible in the number. That is worth checking on any long-running review, because the raw count reads as getting worse and the density reads as treading water, and they call for different responses. The one that follows from a flat density is that a page gets better only by getting smaller. Every finding’s fix is an obligation, every obligation has a propagation cost across the whole document, and past some size that cost exceeds what a round can pay — at which point the right move is not another repair round but an extraction: move the machinery the obligations are about into atoms the page cites, so that each round propagates across a smaller surface. Measure the density before deciding that a rising count means a worsening page.
-
Before building a check, ask whether its decidable form would have caught the instances that motivated it (2026-09-10). This is the third triage question and it belongs after the other two, because a shape can pass both and still be worthless. Two shapes had recurred often enough that the recurrence rule said build them, and both were built far enough to measure and then rejected — one of them by the sharpest result this pipeline has produced. A declared partition must add up had cost three hand-fixes and escalated to foundational, so the recurrence was undeniable. Its decidable form — every name in an
a + b + c = dexpression is a field of that action’s declared return — runs clean on the one instance that motivated it. The defect was never that a name was undeclared; it was that a path fell into no bucket, which is not visible to any parser. The check would have been built, would have passed, and would have prevented nothing, while carrying the authority of a gating check. The second shape, a retired token surviving at a call site, was decidable as a token and a token extending it across an underscore both live on one page: 178 instances across fifty-six files, of which one is the defect — the rest are the corpus’s ordinary naming convention (event_idandintent_event_id,actor_refandacting_actor_ref), and telling those from a stale name is a question about what the names mean. So the full triage is three questions, and the order matters: can a finding be dismissed without reading what a sentence claims; does the shape recur often enough to be worth checking; and does the mechanical shadow of the shape actually cover the defects that made you want it? The third is the one that catches a check which would run, pass, and lie. Measuring it costs what the first two cost — one script, run against the instances already in hand — and it is the only one that can be answered before the check exists and not after. -
A plausible remediation from a fresh reader is still only a hypothesis until the model distinguishes it from its siblings (2026-09-09). Four consecutive gates have now identified a real defect and prescribed the wrong repair, and the failure mode is consistent rather than careless: a reader who has found a genuine hole reasons from the sentence in front of them to the mechanism that would close it, and the mechanism they reach is the plausible one, not necessarily the load-bearing one. A window inequality was short by one term and the prescribed second term still breached on 396 of 432 parameter tuples. A read failure wanted its own code at one action and the prescription put it at four. A late-landing intent write looked like a missing lease gate, and the model shows the gate-off configuration holds under a fence while the gated configuration violates without one — the fence is the mechanism and the gate is neither necessary nor sufficient. So a prescribed fix is a hypothesis with a shape: it names a mechanism, and a named mechanism has siblings. Build the configuration where the prescribed mechanism is off and everything else is unchanged, and the configuration where its sibling is off, and let the checker say which one the property depends on. If the prescribed one holds with it removed, the prescription was aimed elsewhere. This costs two runs and it has changed the repair in four rounds out of four, which is the strongest argument this campaign has produced for the formal layer owning protocol mechanics outright: the model is no longer only verifying the specification, it is verifying the fixes the verification process proposes.
-
Splitting an action redefines every phase label it touches (2026-09-09). Raising a model’s fidelity is usually safe and this is the exception. An action that was atomic carried phase labels whose meaning came from the atomicity — “opened” meant the intent is in the journal, because issuing and landing were one step. Split that action into issue and land and the label silently keeps its old name and loses half its meaning: “opened” now means the intent was issued, and every guard that read it as landed is quietly wrong. In this campaign that produced an invariant failure attributed to the protocol for a full round of analysis before it was recognised as the model’s own. The earlier version could not have made the error, which is what makes it easy to miss: the regression is introduced by the improvement. So when an action is split, re-derive every guard that mentions its phases before running anything, and prefer renaming the old label to keeping it — a label that survives a split unchanged is a claim that nothing about it changed, and that claim is usually false. Increasing fidelity can introduce an abstraction bug, and the bug will look like a finding.
-
A model’s claim is bounded by its horizon, and the twin suite is what measures whether that bound is enough (2026-09-09). “All invariants hold” is never a statement about the protocol; it is a statement about the protocol within N ticks at these constants. That is usually harmless and becomes dangerous the moment the horizon moves — and it moves whenever fidelity rises, because more phases cost states. When a model that ran at seven ticks will only finish at five, the honest report is holds within five, and the temptation is to say holds and move on. There is a cheap empirical substitute for the monotonicity argument nobody wants to write: a twin that still fails at a horizon proves the horizon covers that property’s witness, because the twin exhibits the violation and the chain producing it therefore fits. So re-run the whole twin suite at every horizon change and treat the results as the vacuity evidence they are; a property attacked by no twin is checked at the horizon and claimed at the horizon, and should be written that way. Where a property’s witness demonstrably does not fit — one here needs a take, a read, a write landing past the lease, an expiry and a second take — give it its own configuration with a horizon that covers it, rather than stretching the main one until nothing finishes.
-
Count a shape’s population in recurrences, not in instances (2026-09-09). The population rule below stopped two checks by measuring how many times a construct appears in the corpus, and the measurement was right both times. The conclusion drawn from it was wrong for one of them, and the correction is worth more than the original rule. A declared partition — these five counts sum to that one — appeared once in fifty-six files, so it was triaged out as a hand-fix wearing a tool’s clothes. It has since been hand-fixed in three consecutive rounds and escalated from refining to foundational, because each round added a path to the thing being counted and the identity is only correct with respect to the paths that existed the day it was written. A retired token surviving at a call site went the same way: triaged out on one instance, then recurred, and the second time the round’s own sweep printed the offending line and the reader looked past it. So a shape that appears once in a static corpus but is rewritten every round on the page under active development has a population of one file and a population of four events, and it is the second number that decides whether a check pays. The test costs one extra question and no extra tooling: how many instances are there, and how many times has this shape been repaired before? A shape with two prior repairs needs no further argument. The deeper point is that the corpus is the wrong denominator for a document still being written — most of a check’s value accrues while a page is changing, and by the time the page is stable the check has little left to catch.
-
Write the probe for the second occurrence, not just the first (2026-09-09). Reachability probes stop a model from passing because nothing happened. They have a blind spot of their own, and it showed up one gate after they were introduced. Three probes asked whether a newly modelled writer ever holds the critical section, ever writes, and ever writes over an existing record; all three were rejected, so the component was reachable and its invariants were not vacuous. The next gate then found a defect the model could express and the configuration had switched off — a budget of one call, where the defect needs two, because it is a chain: a record superseded by a record superseded by a record. Neither the model nor the probes were wrong; the question was. Does it ever happen and does it ever happen twice are different questions, and in a concurrency model the interesting failures are almost never the first occurrence — they are the second one interleaving with the first, or the correction of a correction. So budget constants deserve the same treatment as remedy constants: raise the budget by one and probe for the second occurrence, or write down why one is enough. And when a probe holds, the question is not “did the configured limit change” but “WHAT IS ACTUALLY PREVENTING THE BEHAVIOUR?” — and the answer is rarely the knob named in the configuration. A probe for a supersession chain held twice: the first time because the configuration had pushed the sweeps out and removed the only thing that triggers the operator, the second because the operator’s phase machine was terminal — it never returned to idle — so the budget constant the round had carefully raised was never the binding constraint at all. Both times the report would have read “raised the budget, still holds”, and both times that sentence would have been false about the reason. This also names a third way a formal result can mislead — beside the behaviour never happened and the violation came from something other than the twin’s constant, there is the behaviour is expressible and a configuration constant excluded it, which reads as a clean pass and is the hardest of the three to see.
-
A new component earns its invariants only after a deliberate falsehood about it fails (2026-09-08). A model that adds a process, a writer or a path can pass on the first run for the worst reason: the new thing is unreachable in the configuration, so every invariant mentioning it is vacuously true and the run says only that nothing happened. This campaign was already caught this way once — a window invariant whose antecedent needed a horizon several times the one configured — and caught it by arithmetic rather than by method. The method is cheap: alongside the twins, write reachability probes, each a deliberate falsehood about the new component (it never holds the critical section; it never writes; it never writes over an existing record), and require the checker to REJECT each one before reading the main run as evidence. Three probes cost three configurations and one line of definition each. Pair it with the twin’s own guard: a twin whose constant is flipped inside an unusual configuration needs a PASSING SIBLING in that same configuration, differing by exactly that constant, or its violation is attributable to the configuration rather than to the constant. Between them the two rules answer the only two ways a formal result lies — the behaviour never happened, or the violation was caused by something other than what the twin claims.
-
When a model will not terminate, ask whether the excess behaviour is behaviour the spec actually admits (2026-09-08). The first instinct on a state explosion is to buy the space back: shorten the horizon, cut a budget, drop a process. Sometimes that is right. But an explosion is also evidence, and it is worth one question first: is the model letting this component act in situations the specification does not? Bringing an operator into a protocol model made it non-terminating, and the cause was that the operator could race the sweep to any open past-the-edge act — which the page admits in exactly one deployment, the report-only one where the sweep writes nothing. Making that deployment a modelled dimension both shrank the space and corrected the model, and the two were the same edit. A budget shrinks the space and leaves the model wrong; a fidelity correction shrinks it and makes the model right. The tell is whether the narrowing can be stated as a sentence from the specification. If it can, it is fidelity. If the only justification is “otherwise it does not finish”, it is a budget, and it belongs in the configuration with a comment saying what it costs.
-
An outside-the-frame finding names the instrument you are missing, not the model you should grow (2026-09-08). The frame metric sorts a formal-layer campaign’s findings into outside the model’s frame, inside and the model was wrong, and inside and the transcription was wrong. The second and third buckets have obvious responses. The first looked, for two rounds, like a standing argument for a bigger model — and it is not. A gate found that the closure window’s inequality under-charged a sweep death by a whole run; the finding was outside the frame because the model carries leases, fences and a window but has no backlog, and therefore has no term for a run’s own elapsed pass. Extending it to carry one would have multiplied the state space to re-derive a bound that is pure arithmetic over a schedule. What settled it instead was forty lines of Python that enumerate the schedules the page’s own timeline admits and report the worst landing instant. It took an hour, it rejected the correction the gate had prescribed (still wrong on 396 of 432 parameter tuples), and it produced a configuration obligation nobody had asked for: the corrected inequality breaches on exactly the tuples where the disclosed run bound is smaller than one lease plus one closure, so that obligation is load-bearing rather than hygiene — a fact discovered by the instrument, not decorated on afterwards. So read the outside-frame bucket as a shopping list of small instruments. A model is one instrument, not the instrument; a bound over a schedule wants an enumerator, an arithmetic claim wants a checker, and reaching for the biggest tool because it is the one already built is how a campaign spends a week to learn what an afternoon would have told it.
-
Fixing an instance of a shape is not the same as knowing the shape (2026-09-08). A gate found that one of this page’s actions returned a code the page’s own rule reserved for a different diagnosis — two unrelated meanings on one token, with opposite caller actions. The repair gave the second meaning its own code. The new code collided with a constituent’s code named two paragraphs away in the same document, and it took a hand sweep rather than a check to notice. The round had just written a paragraph explaining why two meanings on one token is a defect. A repair that closes an instance while re-committing the error a sentence later is the ordinary case, not an embarrassment, because the reviewer’s attention is on the finding’s site and the shape lives everywhere else. Two things follow. Sweep the shape across the whole document after every repair, not the site — one
grepper token introduced. And treat the shapes a repair round re-commits as the strongest candidates the promotion pipeline will ever see, since they come with a demonstration that a careful reader misses them while actively thinking about them. (Both new candidates from this round were nonetheless rejected — one on population, zero instances in fifty-six files, one on the CONTAINS/CLAIMS boundary — which is the population rule doing its job against a shape that felt urgent.) -
A check needs a population, not just a rule (2026-08-30). Decidability is necessary and not sufficient. Two more shapes from the same gate were triaged before any effort went into them, and both were rejected on frequency rather than on decidability. A declared partition adding up is decidable in a narrow form — every name in an
a + b + c = dexpression must be a field of that action’s return — but the expression occurs exactly once across fifty-six files, in the draft that produced the finding; a gating check for a construct with one instance is a hand-fix wearing a tool’s clothes. A retired abbreviation surviving at a call site is worse placed: the retirement is declared in prose (“written(kind, act_key)here and abbreviatedact_keynowhere”), so reading it as a declaration is a question about what a sentence claims, and the check is blocked on a convention the corpus does not have rather than on parser cleverness. So triage a candidate on two questions before building it: can the rule be stated without the word claims, and does the shape occur often enough that a check beats fixing the instances? Measuring the second costs onegrepand has now stopped two checks; it is the cheapest step in the pipeline and the one most likely to be skipped, because by the time a shape has been named it already feels like a rule. -
The boundary’s real test is the dismissal, not the rule (2026-09-08). The CONTAINS/CLAIMS rule below is right and was stated one level too shallow. A later candidate passed every test it names — a code an action’s signature declares that the action’s own prose never lands — and it is as mechanical as a check gets: a delimited code fence against a delimited section, five self-test cases holding in both directions against a deliberately broken variant, and the largest corpus population any candidate in this campaign has had, twenty-seven findings across ten files. It was still rejected. Every one of the twenty-seven had the token elsewhere on the page, and every dismissal therefore required deciding whether a sentence written somewhere else covers this action: one composition lands a credential rejection for four actions in a single shared wiring paragraph that names all four; another lands a code in its term entry and nowhere near the action. Those are legitimate conventions, and no parser can tell them from the real defect the same check correctly found. So ask of a candidate not “can the rule be stated without the word claims” but “can a FINDING be dismissed without reading what a sentence claims”. A rule can be perfectly mechanical and still be a claims question in disguise, and the population measurement will not catch it — this candidate had the best population of any so far and the worst dismissal cost, which are not independent: a shape common enough to be worth checking is usually common enough that the corpus has grown conventions around it.
-
The linter can ask what a document CONTAINS; only a reader can ask what a sentence CLAIMS (2026-08-30). Three checks were prototyped against gate 8’s mechanically-decidable findings, and the line between the one that promoted and the two that did not turned out to be sharp and reusable.
V-signature-alternationasks is there a separator between these two items — a question about the document’s contents, decidable with no notion of assertion, promoted the day it landed.W-step-referenceasks does that action have a step 5 — the same kind of question, promoted (preventive; it has never fired). The two that failed both need to know what a sentence is asserting:E-code-not-in-signaturecannot tell a code this action exports from a constituent’s code it is transcribing before mapping, and the mechanism check — does step 2 carry the thing the page says step 2 carries — cannot tell a sentence that claims step 2 does X from one that mentions step 2 and separately mentions X. On this page’s draft the second found the real defect it was built for, buried in a dozen false positives, which is exactly the trap: a heuristic that finds a true thing is still a heuristic. So the promotion test is not “did it find something real” but “can the rule be stated without the word claims”. Anything needing that word stays with the fresh reader, and that is the boundary’s real definition — not the topic of the finding, but whether deciding it requires reading a sentence as an assertion. -
A checker’s finding being true does not make its rule correct (2026-08-30). The
E-code-not-in-signatureprototype reported thatcustomer-onboarding’sinitiate_onboardinglandsinvalid-credentialwithout declaring it. The finding pointed at a real defect and the stated rule was wrong: the code is in the signature, and what is actually broken is that the block is missing a|, soinvalid-requestandinvalid-credentialsit on consecutive lines and the alternation reads as one malformed code. Correct result, invalid proof path — which is the same failure the formal layer had just spent a campaign fixing, in a new place. So a check earns promotion on its rule being right, never on a finding happening to be real; and where the two diverge, the right response is to split the check into the rule that actually holds (here, a pure-syntax alternation check, which promoted the same day) and the one that does not yet (own-export versus transcribed-constituent-code, which needs a semantic distinction the parser cannot yet draw). -
A fixture pins nothing until you have watched the check fail with it (2026-08-30). Writing
V-signature-alternation’s fixtures took three attempts to pin one guard. The first nested fixture passed under both the correct check and a deliberately broken one, because its groups each sat on a single line and were separated anyway; the second passed under both because the guard before the one under test already excluded it. Only the third — a nested group spanning lines whose continuation follows a line ending in neither(nor|— made the broken check fail. Break the check on purpose and confirm the suite goes red, naming the fixture, before believing a green suite means the logic is held. A synthetic fixture that cannot fail is the vacuity trap wearing a test’s clothes. -
Three layers, and a promotion pipeline between them (2026-08-30). The Recoverable Invocation campaign ran eight fresh-reader gates and two model rewrites, and what it converged on is a division of labour rather than a better prose discipline. The formal model owns concurrency, timing, crash and recovery, leases, fences and bounds — everything whose interleaving space is unbounded. The linter owns mechanically decidable internal consistency: whether a code an action lands appears in its signature, whether a mechanism a page names exists where it says, whether a declared partition adds up, whether an abbreviation an entry retires survives at a call site, whether two sections state the same rule. The fresh reader owns semantics: authority, meaning, trust assumptions, whether a binding really represents the adopter’s domain. Using a reader as a type checker is the most expensive way to run one, and for three gates that is largely what this campaign was doing.
The measurement that forced the third layer out: after each repair round, count the findings the previous round’s fixes caused — text the repair wrote, or text the repair made wrong. Across gates 7 and 8 that rate ran 35% and then 67%. A repair pass generating two findings for every three it closes is not converging; it is exploring a state space by hand. But the character of the caused findings had inverted by gate 8 — protocol defects in the first round, bookkeeping in the second, with ten of twelve mechanically decidable. A rising caused-rate on judgement-free defects is a tooling gap, not a discipline gap, and a rule the author already half-follows is evidence that it should stop being a rule.
So a finding is promoted rather than merely fixed, on the same path a language takes from convention to compiler error: fresh-reader finding → recurring mechanically decidable shape → linter check → corpus sweep → zero → gating. The sweep is the load-bearing step and the one that is skipped: a check that is not run across the whole corpus and driven to zero is a check nobody can turn on. Two cautions earned immediately. First, verify the instrument against a case whose answer you already know before its output is evidence — the first
E-code-not-in-signatureprototype reported thirteen findings of which ten were an artifact of a lazy regex, and noise gets waved through where a hard failure would not. Second, a check that fires for the wrong reason is still worth reading: the same prototype’s two surviving corpus findings were both false as described, and one of them was concealing a real defect — a signature block with a missing|, so an alternation silently read as one item. -
A model’s NOT MODELED list is a prediction surface, not a disclaimer (2026-08-30). What a model excludes is exactly where the prose is still carrying protocol risk alone, and that is where the next fresh reader’s foundational findings will be. Measured: the gate after the Recoverable Invocation model was corrected returned seven foundational findings, and five sat verbatim on the model’s own exclusion list — skew, the lost-reply retry, retention purge, the bindings table’s lifecycle. So the list is maintained as a live artifact, written to be read as a forecast: each round, what the model newly excludes is what the next round is expected to find. Two consequences follow. Widen the frame selectively, at the exclusions the last gate actually hit, rather than trying to model everything. And record, per gate, where each foundational finding sat relative to the frame — three buckets, not two: outside the frame (widen it), inside and the model was wrong (the correspondence is failing — the serious one), and inside and the transcription was wrong (the model proved it and the prose failed to carry it, which needs discipline in the transcription rather than a better model). A gate returning more findings than the last is not a regression if they have moved from the middle bucket to the first; that is the boundary doing its work.
-
A remedy introduced into a page must be specified to the standard of its nearest established analogue (2026-08-30). A new mechanism added to fix a finding is itself unreviewed, and the page usually already contains a fully worked instance of the same concept. Recoverable Invocation gained a
journal_fencein one paragraph whilecommit_fencesat three sections away with a declared conveyance, a named clock, and an edge widened by one allowance; the new fence had none of the three and produced three of the next gate’s seven foundational findings by itself — including a contradiction with a sentence in its own paragraph. Find the analogue first and write the remedy against it clause for clause, and then ask what the analogue did not need: here, the margin had to be minted into every instant the fence produces rather than only the lease’s, which the checker established only after the first correction still let the defect through.
The formal-layer vote, moved 2026-11-14
The section The formal-layer vote of Pressure Testing, moved here whole on 2026-11-14, when the minimum-formalism principle and the three-tier formal verification stack came to that page’s section Formal models from the manifesto: every page carries both models, and there is no vote on it (Scott, 2026-11-08, the formal layer is not optional). The sentence on the vote that The Method carried went with it. They are record: the rule the library runs is the stack’s.
The formal-layer vote
Before any pattern may declare grounded, it casts an explicit formal-layer vote, recorded on the Ledger’s formal: line and argued in the commit: does this pattern carry load-bearing temporal, ordering, concurrency, or safety claims that a formal model would verify — yes or no, with a one-line rationale? The vote is mandatory; the model is not. The vote enforces explicit-over-implicit on the methodology itself — the same information-management discipline the library applies to specs — so that no pattern grounds without the formal layer having been considered, even when the considered answer is no.
- Vote = no. The pattern grounds English-only. The recorded vote is the evidence the formal layer was weighed and judged unwarranted (the minimum-formalism principle — do not put Alloy on Personal Todo). The English remains the sole SSOT and carries the full proof burden in prose, which is why an English-only pattern’s prose must be correspondingly rigorous and verbose: nothing downstream is checking it.
- Vote = yes. A derived formal model becomes a grounding prerequisite for that pattern. Until it exists and verifies, the pattern is
grounded (English) — formal layer pending: the three-pass baseline and Final Critique may be clean, but the load-bearing temporal claims have not yet been discharged on the surface best suited to them. The model’s findings are written back into the English per the conflict protocol; only then does the pattern reach unqualifiedgrounded.
What “the model exists and verifies” means — the “model present” bar. A model file existing is not the formal layer being discharged. The phrase “model present” on a formal: line or in a vote means all of the following, on the record:
- It runs green in the reproducible harness. The model passes
tools/harness/mechanically — not “ran once in the Alloy GUI,” not “a sibling Python checker agrees.” The committed artifact verifies on command. (A model that does not typecheck, or that a TLA+ checker reportsNoInitialStatesfor, has not run — treat a typecheck/parse error or empty initial-state set as a hard failure, never a skip.) - It ships a buggy twin the checker rejects. Every model carries a deliberately-wrong sibling (
<name>-buggy.tla/-buggy.als) that re-introduces a real hazard the spec defends against; the harness must reject it (TLA+: an invariant violation; Alloy: at least onecheckfinds a counterexample). The twin is the vacuity guard — without it, a model that passes proves nothing, because a check can pass simply because its antecedent is never satisfiable. The twin proving the checker can fail is what makes the correct model’s green meaningful. - Its checks are non-vacuous. Every Alloy
checkis accompanied by a satisfiablerunthat exercises the same predicate (so the guarantee is quantified over a non-empty set, not vacuously true); every TLA+ model explores a state space that saturates at the chosen bound (raise the bound until the state count stops growing, then keep headroom — a passing run at an arbitrary low bound is not coverage). The tell to refuse: acheckthat holds while its pairedrunis vacuous — that guarantee is unenforced.
These three are the bar that the capability.als typecheck error, its vacuous transition layer, and privileged-access-provisioning.tla’s unrunnable request_to_chain all slipped past historically — each was recorded as “model present” while the artifact was not actually verifying anything. The bar exists to close that loophole: until a vote-yes pattern clears all three, it stays grounded (English) — formal layer pending, never grounded.
This vote replaces the prior rule that formal models were simply “not prerequisites for grounded.” That rule predated the shift toward the formal layer as the load-bearing verification surface; it left the decision implicit, which allowed a pattern with heavy temporal claims to ground without anyone deciding whether prose review was the right gate for it. The vote closes that gap without over-correcting into a blanket formal-for-everything mandate.
The Method’s sentence on the vote
The sentence The Method carried below its diagram, in its section Grace closes loops, until 2026-11-14:
The AI vote on Alloy or TLA+ is a triage gate, not a loop: it decides what gets built, and everything below it loops.