docs(phase-31): S61 interim checkpoint + cookbook §293 (the sibling law decomposed: the baseline, not the siblings) + decision-log entries + accelerator #12

R30/R31 capture while hot: the resolver pivot (63 zero-token banks of 245 staged of 424 judged of
1,352 nominated), the RED-fleet finding (15/214 baseline-RED refusing 174/182 doubly-verified
drafts), the three byte-proven repairs so far, and rule candidates R56–R58.

docs/accelerators.md

@@ -261,3 +261,11 @@ accelerator: for ANY lane that mass-produces candidates from a template, build t
 FIRST (cheapest oracle to most expensive, every verdict consumed, every drop named), and treat "an
 oracle exists but the lane doesn't consume it" as a defect with a per-pass machine cost, not a
 nice-to-have (`docs/tool-designs/aprop-lane-s59.md`, cookbook §270–§273).
+
+## #12 — Byte-locate the residual before blaming the draft (P31 S61)
+`cmp -l built retail | map through <bin>.map` names the first misplaced symbol, its delta, section
+and OBJECT in ~2 minutes; name-encoded symbols (D_/func_/jtbl_<addr>) mean the retail address is
+already in the name. One derivation replaced days of "CAUSE NOT DETERMINED" backlog rows and
+turned 15 mystery walls into three named config repairs. Corollary: gate verdicts need a green
+baseline — audit `make build BINARY=<b>` per binary BEFORE trusting any per-draft verdict
+(gate_stage now refuses red-listed binaries' drafts as BASELINE-RED).

docs/decision-log.md

@@ -2489,3 +2489,83 @@ three-quarters-hopeless numerator. The real denominator is 973 open members; the
 reachable slice is ~120/pass banking at ~50–60%; the remaining ~850 are named residuals (169
 STRUCT cracks, 121 type-inference, ~73 IMM tier-2, wrong-family cards) — work for different
 tools, not this lane. Saying so beats reporting a flattering fraction of the wrong denominator.
+
+## 2026-08-25 (P31 S61) — the wall is an integration wall: stop re-drafting solved functions, re-judge them
+
+**Context and belief.** Through S58–S60 the campaign optimised the wide wave: band, mix, card
+count, sibling-inclusive draws, straggler handling, gate parallelism. Each lever moved yield by
+single digits while first-gate conversion slid from 51% (dd) to 1–6% (en/eo/ex/ey/ez), and the
+going explanation was population exhaustion of a *codegen* frontier — the gen6+ "wall".
+
+**What the measurement said instead** (`docs/tool-designs/frontier-analysis-s60.md`, a read-only
+Fable audit at session end): of the 292 functions refused six or more times, 178 had ALREADY
+produced a closeness-0 draft — byte-equal at the object level, refused by the whole-binary gate —
+and across the open pool ~571 functions had finished drafting. The fleet kept re-drafting them
+(10,049 reject rows over 574 distinct functions), and the gate spent ~3 whole-binary builds per
+failing draft confirming failures that were never about the draft's text.
+
+**The pivot.** Build the deterministic lane the analysis asked for instead of touching the wave
+again: `tools/integration_resolver.py` treats the ledgers as an INDEX (not a promise — a July
+closeness-0 draft can CC1-fail today because the fleet's declarations moved), re-judges every
+candidate at the REAL split TU with `rtu_match`, requires `reloc_identity` to agree on symbols
+(rtu masks relocation fields, so a wrong symbol name still reads MATCH — R34's disagreeing
+oracle), rebases with `aprop_symfix` where only names are wrong, stages, gates on the whole-binary
+SHA, commits at once (R42). Refuses main by name, `//@EDIT` drafts, dirty trees, collapsed
+registries; a negative control over recently-banked functions must pass N/N before a verdict is
+read (its first form picked carve moves as banks and failed 9/12 — fixed before any stock verdict
+existed, R35).
+
+**Why, in numbers (denominators, R41).** First pass, 2026-08-25 23:38–23:48: 1,352 nominated
+(binary, fn) pairs → 901 already banked, 27 main → **424 judged in 41 s → 245 staged (57.8%) →
+63 banked** (net INCLUDE_ASM delta; the commit subject's "72" counted 9 carve moves), zero model
+tokens, ~10 minutes wall. The wave lane's best recent gate banked 13 of 222 in a ~30-minute gate.
+The falsifier (<5% survive intake) was not close.
+
+**What the refusals then taught, byte by byte.** 182 doubly-verified drafts were still refused.
+Probe 1 (`md_SC03_076/func_801EFBB4`, 407 ins): the spliced binary builds and 66 bytes differ at
+file offsets 324–2440 — the `.rodata` jump tables the stub's `.s` carried (`jtbl_801EF5AC`,
+`jtbl_801EF5E4`) move by one word when the compiler emits them itself: the §8e/§260 table-placement
+class, not codegen. Only 43 of the 182 carry rodata at all; 139 (in 16 binaries) were refused with
+no rodata coupling — that residual is the next thing to characterise (cookbook §293 records what the
+probes find).
+
+**Hindsight — the better path.** The ledgers held the evidence for weeks: `closeness: 0` rows with
+"whole-binary gate rejected — CAUSE NOT DETERMINED" as their verdict. A verdict that names no cause
+is a measurement nobody can act on; the cheap move — re-judge the stored body at the real TU and
+diff the BYTES of the built image against the good one — costs ~90 s per function and should have
+been the gate's own failure report from the day the ladder was built. Generalisable: when a
+correctness oracle says "no" without saying where, build the second instrument that says where
+before tuning anything upstream of it.
+
+## 2026-08-26 (P31 S61, small hours) — the RED fleet: the wave collapse had a third cause nobody was billing
+
+**Context.** After the resolver banked 63 zero-token functions, 182 of its doubly-verified drafts
+(rtu-MATCH at the real TU, reloc-AGREE on symbols) were still refused by the whole-binary gate, and
+the per-binary refusal counts were all-or-nothing: 23/23, 23/23, 18/18, 13/13 in single binaries.
+
+**What the probes said.** All-or-nothing per binary is not a property of drafts. A clean-tree build
+of the fully-refusing binaries: 15 of 214 fleet binaries were baseline-RED at HEAD — seven not even
+building (stale JTBL_PADS after S60's evening banks/reverts), the rest byte-shifted (a missing
+interleave entry; a wave-committed half carve). They had been red for 4–12 hours because the fleet
+R22 sweep was guard-skipped whenever any gate was in flight — i.e., always. Every wave gate and
+every resolver gate against them since was a measurement of the BINARY billed to the DRAFTS —
+part of the "1–6% conversion" story S58–S60 attributed to population exhaustion.
+
+**The pivot.** Stop diagnosing drafts; audit and repair baselines: per-binary clean audit → the
+byte-proven repairs (jtbl_pads_fix for pad drift — itself first un-broken three ways, R40;
+insertions-only interleave regeneration from the splat yaml for layout shifts) → a gate-side
+BASELINE-RED refusal so a red binary's drafts are never judged (negative-controlled both ways) →
+re-open the mislabeled refusals in the resolver ledger for automatic re-judging.
+
+**Casualties of the night, recorded because they are the pattern.** The repair tool's own writer
+poisoned the registry into a make parse error that failed every build of every binary for ~9
+minutes, voided one wave's re-gate and its own candidate search, and was adopted by a blanket
+pre-gate commit (R52 instance #2). Two gater-restart helpers killed themselves via unanchored
+pgrep self-match (the S60 hazard, from the other side). Every one of these is the same lesson:
+the instrument — including its write path, its restart path, and the baseline it measures against
+— is part of the experiment.
+
+**Hindsight.** The S60 close declared "tree clean, all lanes stopped" and was true, while 15
+binaries were silently red — "clean" and "green" are different invariants, and only one of them
+was checked. A session-close ritual (and any wave post-mortem) should quote the fleet's GREEN
+count next to the tree's cleanliness; tonight that number was 197/214 pretending to be 214/214.

docs/matching-cookbook.md

@@ -29017,3 +29017,53 @@ the per-candidate verdicts above:
 
 ## §292 — DECLARING A SYMBOL UPSTREAM OF AN ALREADY-BANKED SIBLING THAT RELIES ON THAT SYMBOL'S IMPLICIT (K&R) DECLARATION CAN SILENTLY REPROTOTYPE THE SIBLING'S OWN CALL SITE (P31 S60; waves #, byte-proven)
 #
+
+## §293 — THE "WHOLE-OBJECT GATE NEEDS EVERY SIBLING" LAW, WRITTEN PROPERLY: IT IS THREE LAWS, AND THE LOAD-BEARING ONE IS "THE BASELINE, NOT THE SIBLINGS" (P31 S61; byte-proven on 15 binaries in one night)
+
+Eight cards across four waves independently re-derived "the whole-object gate needs every sibling
+matched" (§283 flagged it as the strongest missing-section signal). Taken literally it is FALSE —
+`--chunk 1` gates one draft per build and a correct draft banks with every sibling still a stub —
+but the agents were observing something real. It decomposes into three separable laws:
+
+**(1) The batch-revert policy artifact (historical, already ended).** §12/§14-L1144/§20: a chunked
+gate or an all-or-nothing slate reverts every co-spliced draft when ONE fails, so a byte-perfect
+body reads as refused. `--chunk 1` + stage-0-first ended the mechanism; the folklore survives in
+cards because the SYMPTOM (my perfect draft won't bank) persists via (2) and (3).
+
+**(2) The structural coupling that is real: a bank moves rodata.** A stub's `.s` carries the
+function's jump tables and migrated rodata islands at their RETAIL positions; banking the function
+makes the COMPILER emit them into the TU object's `.rodata` instead. Retail layout then survives
+only if the carve chain is complete and current: the splat yaml `.rodata` subsegment (§8), the
+object's entry at the right position in `<bin>_JTBL_INTERLEAVE` (§8b), and a correct per-object
+`JTBL_PADS` spec (§8e). ONE missing or stale piece shifts every later rodata/data/text reference —
+byte-witnessed tonight: a single absent `ov_MAIN_012_jr_8016AB6C.o` interleave entry displaced
+1,671 symbols by +0x20; a stale 2-entry pad spec (its `switch` function had been reverted, taking
+a table with it — the R51 stored-derived-property class) held ov_SC01_006 RED; ov_SC04_000's wave-
+committed carve left the order list one object short (+0x2944 from `tail19` on). None of this is
+about siblings — it is about the OBJECT's rodata bookkeeping.
+
+**(3) The load-bearing law: A GATE VERDICT IS A MEASUREMENT OF THE DRAFT ONLY WHILE THE BINARY'S
+BASELINE IS GREEN.** When (2) breaks, the BINARY fails its locked SHA with no draft spliced at all
+— and then every draft gated against it is refused regardless of quality, which reads exactly like
+"my sibling is blocking me." Measured tonight (S61 fleet audit, 214 binaries): **15 binaries were
+baseline-RED at HEAD**, and they accounted for **174 of the 182 refusals of the resolver's
+doubly-verified drafts** (245 staged; rtu-MATCH at the real TU AND reloc-AGREE on symbols). They
+went red DURING S60's evening incremental banking — §61c's "incrementally valid, clean-invalid" —
+and the fleet sweep that would have caught them had been guard-skipped since 12:54 (R54). The gate
+now refuses a red-listed binary's drafts as class BASELINE-RED before any build (gate_stage,
+`.run/baseline_red.txt` ∪ `.run/fleet_red.txt`), so a broken baseline can never again be billed to
+the drafts. Corollary, one night, same class: an INSTRUMENT'S OWN WRITE PATH IS PART OF THE
+INSTRUMENT — `jtbl_pads_fix.write_pads` split its target line on ':' (but `:=` contains one),
+poisoned the registry into a make parse error ("target pattern contains no '%'"), which failed
+EVERY build of EVERY binary, voided its own candidate search (0 winners: its writer broke the
+build it was measuring), and was adopted by a blanket pre-gate commit (R52's second instance).
+`mk_write` now refuses parse-poisoned lines.
+
+**Recipe when a "wall" function won't bank and the body is proven:** (a) `make build BINARY=<bin>`
+on a CLEAN tree first — if the baseline is red, stop blaming drafts; (b) locate the shift, don't
+guess: `cmp -l` the built image against the retail bytes and map offsets through the linker map —
+name-encoded symbols (`D_/func_/jtbl_<addr>`) make "first misplaced symbol, delta, section, object"
+a two-minute derivation; (c) the object it names tells you which carve piece is missing/stale
+(yaml subsegment / interleave entry / pad spec); repair THAT, byte-prove, commit; (d) only then
+re-judge the drafts — tonight the resolver's ledger re-opened them automatically (BASELINE-RED is
+not a final verdict).

phase-ends/CURRENT_PHASE.md

@@ -1991,3 +1991,60 @@ Every serious stall traced to **an instrument trusted without a control**, never
 
 ## (superseded) previous checkpoint (end of build arc)
 **T0–T9 ALL COMPLETE AND COMMITTED** (through `commit:2181`). Phase totals: **17 banked, 0 agent tokens**; stubs 12,059 → 12,042; R22 213/213 verified twice (post-T1, post-T6). The machine: the Atlas (5,139 groups, `make atlas`), the widened lanes (symfix STALE-DELTA, recover_integration isolation + macro-externs/tu-scope, family_align + len_tells + lenmiss routing), the armed queues (grinder: 59 warmstart records; cards: 954 weak + 192 len + 704 adapt; permuter-49). NEXT = **T10+ the campaign loop**: L3 grinder running in background (launched at checkpoint time); **card/crack WAVES need Drew's `/effort ultracode` toggle first (R27)** — prompt and WAIT. Campaign cadence + close criterion: the plan file §Leg-C. If resuming fresh: read the approved plan + this log; check `.run/auto/grinder_heartbeat.json`; run `make atlas` to refresh; continue the loop.
+
+---
+
+## 🛑 SESSION CHECKPOINT — S61 INTERIM (2026-08-26 00:5x). Phase 31 T10+ CONTINUES. Lanes: gater + maintenance + resolver_lane UP (drafter deliberately DOWN).
+
+**The session so far, in one paragraph.** Read `frontier-analysis-s60.md` and executed its sequence:
+built the INTEGRATION-RESOLVER (tools/integration_resolver.py + lanes/resolver_lane.sh) — first pass
+1,352 nominated → 424 judged in 41 s → 245 staged (57.8%) → **63 banked, zero tokens, ~10 min**
+(commit:2991; subject says 72 = gross incl. 9 carve moves). Probing why 182 doubly-verified drafts
+still refused exposed the night's real story: **15 of 214 binaries were baseline-RED at HEAD**
+(stale JTBL_PADS / missing interleave entries / half-committed carves from S60's evening), refusing
+174 of those 182 regardless of draft quality; the fleet R22 sweep had been guard-skipped since
+12:54. Repairs so far (each byte-proven, committed): ov_SC01_006 (pad spec 0,0→0), ov_MAIN_012 +
+ov_SC02_037 (missing jr_8016AB6C.o interleave entry; +0x20, 1,671/2,176 misplaced symbols). A
+background batch (`.run/resolver/probe/repair3.sh`) is running jtbl_pads_fix over 9 more +
+insertions-only interleave regeneration for 3. Casualties fixed en route: jtbl_pads_fix was broken
+three ways (stale OBJ_ERR bracket regex; only one drift phrasing; write_pads' colon-split poisoning
+the registry into a make parse error that failed EVERY build for ~9 min and was adopted by a blanket
+commit — R52 #2); mk_write now REFUSES parse-poisoned lines; gate_stage now refuses red-listed
+binaries' drafts as BASELINE-RED pre-build (negative-controlled both ways).
+
+**Measurement/tooling shipped:** campaign_status derives banked-today from the INCLUDE_ASM
+invariant (+ anchored pgrep alive()); gater ledger carries gate_min beside wall_min; maintenance
+fleet sweep is draw.lock-aware (it actually runs now); rtu_shadow.py (prospective ledgers for
+fa–fd EXIST at .run/rtu_shadow/<w>.jsonl; join handles 0-bank waves + excludes REDs);
+build_wave_atlas holds resolver-owned (binary,fn) from draws; resolver ledger re-opened 146
+refusals on RED binaries as BASELINE-RED (auto re-judged next pass). Cookbook §293 (the sibling
+law decomposed — the load-bearing part is THE BASELINE, NOT THE SIBLINGS), two decision-log
+entries, accelerators #12.
+
+**In flight right now:** gater re-gating fb honestly (third attempt — attempts 1–2 were voided by
+a NameError guard then the poisoned registry), queue fc/fd/fe/ff behind it; repair3 batch;
+a Fable agent building tools/decl_from_use.py (negative-control-first; its scratch may appear as
+src/*/.cdecl_*.c dotfiles — untracked noise, sweep after it reports). Resolver lane wakes every
+45 min and will re-judge the re-opened items against repaired binaries.
+
+**Next after the notifications:** (1) repair3 results → update .run/baseline_red.txt → commit →
+trigger a resolver pass early; (2) fb..ff gates → `tools/rtu_shadow.py --join fb --join fc ...` →
+the INVERSION decision (§3: false-negative <~2% flips the gate to rtu-first); (3) decl_from_use
+slate → resolver intake; (4) then S61-5 re-aim (gen0/main/3–8 band) + the 8k-vs-16k A/B on the
+first relaunched wave; (5) escalation tier only after the resolver stock drains.
+
+**Hazards for whoever resumes:** kill lane PYTHONS by PID and verify with `ps -o lstart` (pgrep -f
+self-matches your own wrapper — it killed two restart helpers AND the gater tonight); never let a
+script's own text contain the pattern it pkills; the gater blanket-commits src/ config/ at gate
+entry — probes that splice into src/ must hold the per-binary lock AND finish before gate entry, or
+ride into a chore commit (the ov_MAIN_012 repair did — commit commit:2998 — harmless but
+mis-attributed). Stop sentinels are CLEAR; `.run/baseline_red.txt` is live gate input — keep it
+current as repairs land.
+
+**Rule candidates added tonight (P10):** R56 — A GATE VERDICT IS A MEASUREMENT OF THE DRAFT ONLY
+WHILE THE BINARY'S BASELINE IS GREEN; check the baseline before billing the subject (extends
+R35/R40 to the subject's environment; enforcement shipped as the BASELINE-RED skip + the fleet
+audit). R57 — AN INSTRUMENT'S OWN WRITE PATH IS PART OF THE INSTRUMENT: a repair tool whose writer
+corrupts what it measures voids its own search and reports the corruption as the subject's failure
+(write_pads; extends R40/R43). R58 — A SESSION-CLOSE "CLEAN" MUST QUOTE THE FLEET'S GREEN COUNT:
+tree-clean and fleet-green are different invariants (S60 closed "clean" with 15 binaries red).