mirror of https://github.com/Druthulu/BFM-decomp synced 2026-09-27 05:56:00 -04:00

Files

T

Drew T 7e9394f691 fix(phase-30 S45 p4): R14 correction — the MAIN/7/SC03-trio 'loader fn' leads were scanner phantoms

- the quick hi/lo sweep paired lui/lo16 WITHOUT tracking base registers -> phantom refs
  (0x800AE868 read where the true target was 0x8018E868); register-tracked rescan: the ONLY
  literal loc-table ref fleet-wide is SC02/9's (solved)
- standing truth: MAIN/7, MAIN/9, SC03/53/54/56 all load via table-INDEXED paths; homework
  respecified (descriptor-data hunt + ResourceGetCdLoc/StreamLoad index math)
- fn 0x80161E08's real gate: currentLocationId vs {0x3012,0x3054,0x3079,0x3096} — the
  'variable 0x800C3054' never existed; cookbook §155 (track the register)

2026-08-07 15:13:50 -06:00

265 KiB

Raw Blame History

CURRENT PHASE — Phase 30: The Recovery & Concentration Campaign (overlays to their ceiling)

Opened: 2026-07-30 · Effort: Max (Fable 5; saved defaults) · Generation: Gen2 (22nd phase of the arc) · Baseline: PhaseEnd_Phase29 (v1.28.0) · Roadmap: docs/roadmap-to-100.md v2 §3 P30 Plan approved (P3 gate 1): 2026-07-30, in-session (Drew's explicit waiver of the fresh-session step at 28% context). Full plan mirror: ~/.claude/plans/continue-dazzling-newt.md (out-of-repo; this file is the in-repo authority + crash-recovery log).

Fleet at open: 87.5% instr-weighted / 78.0% distinct-code / 92.00% fn-count · 140/140 byte-identical · 0 NON_MATCHING · dedup 1886/0 · tools-health RC=0.

Drew's Phase-Start decisions (2026-07-30):

In-session start (fresh-session step waived at 28% context).
The Ghidra-C prefetch batch pulled forward from P31 → T0.5 (tail + main's 1,034 stubs; headless, background).
T2's primary path = the two-file atomic o0b substitution driver (the log's costed no-splat route); Arm-A splat research is the fallback only.
ROI floor for T3: two consecutive sessions each < +0.3pp instr with all lanes exercised (Drew-adjustable).

⚠️ PRECONDITION (R6): Drew makes the milestone-close commit + push (PhaseEnd_Phase29.md + phase-ends/logs/Phase29.md, both in the tree) before P30's first commit lands. P30 work proceeds; the first P30 commit waits on it.

The numbers this phase must pin FIRST (T0 — do not consume until re-derived, R35/R14)

family_hseq 29,961 vs progress.py 28,296 remaining instances — an unexplained R32 gap.
The -O0 population: "10 families / ~1,287 raw distinct" (checkpoints) vs "123 families / 121,264 ins / 3,100 distinct" (the log's R14 correction) vs "129 distinct on the table" (the costed o0b route) — three numbers, one T0 job.
The zero-crack family list (map said 61 on 07-29) and the concentration table (top-20/top-100 shares).

Standing invariants (every task)

Whole-binary byte-gate is the sole arbiter (G3/P9); match_one/closeness/masked = candidates (§52b).
R22 clean-fleet per banked batch: make clean && make extract-all && make check-all → 140/140.
make tools-health green + fail-closed before matching (corpus · cdecl · audit-binaries(R36) · report/lint/dedup).
Blast-radius typing on every integration write (T0 draft-only / T1 binary-local / T2 fleet-shared ⇒ R22 mandatory).
Probe before costing (R37-candidate discipline): probe one member before pricing a job; derive attribution from corpus.stubs before/after; diff the artifact to prove an edit ran (§120).
Flywheel: idioms → cookbook + tooling in-session (R16/R30); pivots → decision-log (R31).
Effort/model transitions prompted, never assumed (R26/R27) — STOP + WAIT for the toggle.
One commit per task/sub-repair after this file's update; Drew pushes (R6/R20). R23 no-op on db.*.gbf churn.

Task checklist (current-task pointer = ▶)

T0 — Frontier regen + instrument repair [Max] ✅ (all six letters; see per-task log; frontier report = docs/frontier-p30.md, report point #1): (a) gate_stage.py snapshot/restore (the ladder destroys good drafts) · (b) rtu_match.py surface the real cc1 error in the verdict · (c) reconcile the family_hseq↔progress instance gap (R32) · (d) purge since-banked rows from the backlog ledger + still-a-stub filter from corpus.stubs (R33) · (e) refresh .run/autopsy/residuals.jsonl + fix the 21-file absolute-include defect · (f) regenerate the frontier (report / family_hseq / worklist / fuel manifest) + pin the three contested populations → the one-page frontier report (report point #1). Verify: tools-health green; digests committed; velocity derives from digest git history (R33).
T0.5 — Fleet Ghidra-C prefetch batch [background] ✅ (SESSION-27: 124/124 programs, 7,716 files, 335 min unattended; 95.2% of crack-needing families seeded, main 2,001/2,002, resident 14/14. Was left unticked through S27 — corrected S28.) — ImportOverlay.java (~130 missing programs) + DecompileFunctions.java over every remaining distinct stub (overlay tail + main's 1,034; skip LINKED) → .run/ghidra_c/. R23 lock discipline (stop the hook-launched MCP server first or route through it). Verify via build_fuel_manifest.py counters + 5 spot-reads.
T1 — Integration-recovery sweep ✅ DELIVERED as T1a (report point #2), then CLOSED both ways. 108 fresh autopsy-MATCH strandeds / 50 binaries through the tiered driver → +18 banked (derived: fn-count +18 / distinct +12; the commit-message sum of 19 was a gate-report double-list — the metric wins), R22 140/140. The measured verdict: the S16 "39%" prior did NOT generalize (it was measured on FRESH same-wave drafts); on this stored-backlog population — the class decision-log A10 had already byte-proved non-bankable by plain re-gate (0/958) — the driver's reconcile/de-macroize lifted 18 of ~111 ≈ 16%, a real but bounded delta. The ~90 that did not bank stay match_one-MATCH but are integration-DECAYED: they route to T3's REDRAFT lanes, not another recovery pass. No Ultracode was needed (the lever was deterministic).
T2 — The -O0 cluster [Max, deep] ✅ ROUTE PROVEN, TOOLED, AND SWEPT FLEET-WIDE (S28). Report point #3 = this entry. DEVIATION from the phase-start plan, byte-justified — BOTH named routes were refuted: the PRIMARY "two-file atomic o0b substitution driver" mis-places by construction unless the target abuts the o0b object's END (the ×1 probe), and the FALLBACK premise was also wrong — the Arm-A splat %lo +0x20 does not bite (a pure -O2 sub-split of a jr object is byte-neutral, probe 1). The real constraint is §126: an address range is not an optimization region — it contains already-matched -O2 bodies, so the bound is (range MINUS matched) and K islands ⇒ K+1 regions (probes 3–4). Shipped: tools/o0_subsplit.py · Makefile -O0 glob _o0b→_o0? · cookbook §126/§126a. Swept: 135/135 overlays, 0 refusals; 140 new -O0 region files; o0_sources() 137→277; 0 invisible to the oracle; 2,200 open stubs now in a genuinely -O0 TU. 6 fns banked (ov_SC03_014/015). R22 140/140; tools-health OK. Population correction (R14): my "275 stubs / 18 overlays" was an 8× under-count from a bare except swallowing R32 during a rebuild; truth 2,184 / 138, which vindicates the T0(f) "2,192" pin I had wrongly called stale (§126a). Handoff → T3: drafting the 2,200 is crack-wave work; seeds cached; match_one --o0.
T3 — The standing crack-wave loop ✅ RAN across S26–S29, all four lanes exercised, with a measured per-lane verdict (the ROI floor is a LANE property, not a phase property): · Lane B (top-mass fresh families) PAYS and is not exhausted — S27 waves 1–4 (8/14 · 15/19 · 48/48 · 69/70) + 7 confirmed behemoths at 700–970 ins; S28 the jtbl OVER-SPAN fix + the 710-ins func_80191C50; S29 the jr-pair = frontier families #3 and #4 by templatable weight, banked ×138 each for ~0 agent tokens after the instrument repair. · Lane C (tail mass, ×2-reach cached band) is AT the floor — S28 measured 1.33M tokens → 12 banks → +0.00pp headline. That, not the phase, is what the ROI floor names. · Lane A (zero-crack propagation) + Lane D (PINS/W4/permuter) exercised; 29 zero-crack families remain as propagation-only fuel behind matched exemplars. (Original text:) — lanes interleaved, propagate behind every crack same-session: A zero-crack (~61, propagation-only) · B top-mass fresh families (no size cap; jr via jtbl_family_bank; gate_stage call-site-casts, never bulk header edits) · C tail mass on prefetched seeds (local v3 ≤15 → GLM/Haiku ≤~50 → cheap-Opus mid) · D PINS (19) + W4 bounded diagnoses + permuter backlog via the T4-fixed grinder. Per-session checkpoint + velocity + 3 metrics. ROI floor: 2 consecutive sessions < +0.3pp instr each with all lanes exercised.
T4 — Carried-tool resolution [xHigh] ✅ (S28, commit:1279). The 2 "Phase-22 grinder bugs" were struck as STALE in S27 (already fixed). This session: --fix-def-sig posture audited clean (defaults False, one consumer, no caller passes it) — and the audit found the live hazard the earlier pass missed: docs/decision-log.md still recommended making it default-on, which T84/§119 byte-refuted; struck in place with a superseding note (R31). Grinder ILS warm-restart WIRED — permuter_ils.py had sat unused beside grinder.py since Phase 24, so every grind was a COLD search; now --cycles (default 4) warm-restarts from the best byte-waypoint, --cycles 1 = old behaviour. Justified by measurement before building (the lane looked dead: 0 banks since Phase 21) — 665 open near-misses in the permuter-tractable band, 157 at close 1–4, incl. func_8016BA68 close=1 reach=134. ⚠️ Yield UNPROVEN on this backlog — wiring only; the ILS evidence is one Phase-24 fn.
T6 — The measured-frontier continuation [approved by Drew 2026-08-01, in-phase re-plan (P5d)] — P30 stays OPEN. Order derived from the S29 frontier regen, ranked by the family map's TEMPLATABLE weight (see the pricing finding below), NOT by worklist.md: S1 zero-crack propagation sweep — 29 families / 67,470 ins, ~0 agent tokens (head 0x8014032C 183×137 = 25,071 jr · 0x8017BEBC 12,376 · ~8 ×4-straggler families) · S2 the LAST two reach-138 fresh cracks — func_80176734 (371×138 = 51,198, no jr, cached) + func_8016EC0C (88×138 = 12,144) · S3 the close=0 stored drafts as a diagnostic pass (§132 ladder per draft), not a blind re-sweep (T1a's ladder measured 16%; S29 resolved 2 of 2 "gate refuses" to tooling) · S4 PINS bounded wave (14 fns / 44,279 ins; the pin-crash wall dissolved in P27) · S5 the ×10-133 mid-multiplicity families (142,527 ins). Deliberately excluded: the 2 GIANT walls (close=110/91 — P32's track), the ×2-9 mass (339,742 ins, worst multiplier), the singleton/non-substantial residue (635,805 ins, ×1). ⚠ THE PRICING FINDING (R14/R35): worklist.md ranks by h_exact reach, so a per-location PURE family is priced ×1 — it under-prices the frontier head by up to 138×. Byte-proof: S29's pair was priced 272 and 198 ins and delivered 37,536 + 27,324. func_80176734 sits at rank ~50 in worklist.md and is the single largest item on the board. Rank by .run/family_hseq.json templatable weight for family work; the worklist is correct only for genuinely h_exact-reach functions. ⚠ THE STRUCTURAL SIGNAL: after S2 the ×138 era ENDS — those are the last two crackable fleet-wide families; everything after is ≤133 members and mostly ≤9. That rise in cost-per-point, not a session count, is P30's honest ROI floor and the trigger for T5.
T7 — THE FABLE-5 FRONTIER PLAN [approved by Drew 2026-08-04, in-phase re-plan (P5d)] 📄 FULL REPORT: .run/fable_frontier/ANALYSIS.md (verbatim; the agent's harness blocked it from writing to disk, so the orchestrator transcribed it — future sessions read it THERE, not here). Its computed pools are .run/fable_frontier/pool_ovres.json. Its two headline refutations were independently re-verified; its POOL NUMBERS were not — verify before scaling a wave onto them (R14). Why this supersedes T6's wave order: the base rate across every sweep run is ~24k PLUMBING vs 4,917 DIFF (5:1). Sweep failure here has always been mostly plumbing, so fixing the plumbing moves work from the 490-tok/ins column to ~0 — and S1 restores the propagation multiplier that makes every later wave ~3× cheaper. DO S1 BEFORE ANY WAVE. · S1 fix the 2 plumbing classes (typedef/macro gather in family_remap; wire the extern-conflict reconcile into --hseq) → re-sweep the 148 matched-exemplar families (1,585 members / 75,383 ins gross, 71,178 PURE+IMM). 35-60k ins @ ~10-25 tok/ins. Mechanism already PROVEN this session: 0x801833f0 went 0/6 → 6/6 after lifting 3 types (R22 140/140). Kill-test: after the typedef fix --only 0x801833f0 must stay 6/6, and after the extern fix --only 0x80128c98 must move off 0/138. · S2 jr matched-exemplar families via jtbl_family_bank (§53) — 11 fams / 52 members. 10-18k ins @ ~0 tok. · S3 the SC07 carve/pin fix (T2 Arm-A %lo +0x20) → the whale ×4 (3,080 ins of BYTE-IDENTICAL code) + 61 SC07 -O0 members. 5-15k ins @ ~0 tok. · S4 draft-recovery on 39 draft-exemplar families (382 members) + the 2 resident stubs that already have match_one-MATCH drafts gate-rejected for TU plumbing. 10-25k ins @ ~10-50. · S5 re-aim waves at the open-only h_norm clusters — 1,689 clusters / 5,956 fns / 326,261 ins = 46% of all open overlay code, at a 2.7× propagation multiplier. Nobody has ever aimed a wave here. Needs S1 first or the propagation never realizes. · S6 the 2 GIANT exemplar walls — 50,094 ins riding on 2 cracks (close=91/110; their 138 members each classify PURE). Time-boxed siege, hard budget stop. · S7 the singleton tail + main (regen main's Ghidra sig FIRST — it is 7 weeks stale and missing 757 of 2,002 stubs; main is structurally barren, zero h_exact overlap, so it is the genuine ~490-tok/ins agent tail). 🚨 STANDING PRE-PROBE RULE: check h_norm identity across a family's members from the sig files BEFORE probing. If members are h_norm-identical, a 0% is a compile-error certainty, not evidence about codegen. And read .run/hseq_failed.*.classified.txt before theorising about any sweep failure — 23,211 of them exist and both of S38's zeros were already in there.
T5 — Phase close [Max] — burn-down from digest history; P7 milestone walk; Roadmap delta (including the v2 gap this analysis exposed: bucket W3's remainder has NO owner phase after P30 — P31 is T/M/R, P32 is walls/behemoths); gate 2; PhaseEnd_Phase30.

Milestone: overlays at their measured ceiling — ≥95% instr fleet, or every remaining overlay stub on a named wall/behemoth/queue ledger — 140/140 byte-identical throughout.

Blockers

(none) — the precondition (Drew's milestone-close commit) landed at commit:1213.

🛑 SESSION S45 CHECKPOINT part 3 (2026-08-07 evening) — SC02/9 FELL; parked = 5 — FRESH SESSION SAFE HERE

Tree CLEAN but for R23 db.*.gbf churn (never stage). Nothing running. Effort xHigh. NO phase close — T5 unopened, needs Drew's gate-2.

✅ FINAL S45p3 STATE — R22 CLEAN-FLEET 213 passed / 0 failed of 213 · tools-health OK

make audit-disc: UNCLAIMED 5, residue 0. SC02/9 = the Steam Knight (1ST-BOSS) event module, captured live at 0x801E4C60 via the DECODED gate (matched C → loc 0x300E → scene arithmetic → one targeted load) AND retro-verified by Phase-3's ram_castle.bin (same address, 2026-06-14 — R10 two independent datapoints). Onboarded as md_SC02_009, byte-identical first build. Loc-id map appended to docs/debug-menu-list.txt; memory-map §S45 part 3 has the decoded leads for the last 5.

⚠️ p4 CORRECTION (R14/R35 — read BEFORE the homework below): the per-file "loader fn"

leads in p3 were PHANTOMS from a register-blind hi/lo scanner (memory-map §S45 part 4 + cookbook §155). Register-tracked truth: all five remaining files load via table-INDEXED paths; zero literal loc-table refs exist fleet-wide (only SC02/9's, solved). The real homework: hunt descriptor DATA rows carrying global indices {7, 9, 231, 232, 234} + decode ResourceGetCdLoc / StreamLoadStateMachine / D_80068B60 index math + per-overlay IDXTAB/DESTPTR. Items 1-2 below are struck; item 3 (MAIN/9 indexed) was right all along and now covers all 5.

▶ THE LAST 5 = STATIC-RE HOMEWORK (not emulator work — Drew's framing, adopted)

MAIN/7: loader fn @0x80161E08 in ov_SC03_126/ov_SC04_021/ov_SC05_019; gates on global 0x800C3054 ∈ {0x3012,0x3079,0x3096} (ids sit in unlisted menu-gap scenes). TRACE the writer of 0x800C3054 (not written by the EXE — resident/overlay side), identify the 3 host overlays' real locations, decode the extra condition (li 0x1a / 0x8, jal 0x800291DC flag-check family). Then derive dest + onboard (first-build byte-gate arbitrates).
SC03/53/54/56: loader @0x80161FBC in ov_SC03_104 — same §pattern; decode its gate.
MAIN/9: NO literal table ref anywhere — a table-INDEXED loader (id 0x2D = alt build of md_MAIN_015-class actor; Minku spawn showed slot-A hot-loading live). Hunt indexed loads of cdFileLocTable (the resourceIdMap path) + scan descriptor tables for idx 9.
Then: II.5 frontier (~931 module + big-3 novel + script-module stubs) — waves need Drew's Ultracode toggle (R26/R27).

📋 CO-OP PROTOCOL (binding, from today's friction — memory `live-coop-answer-before-grinding`)

Turn-ending replies to Drew BEFORE starting grinds; one plain line per step; long runs announced with duration; "your part is done" said explicitly.

🛑 (superseded by part 3) SESSION S45 CHECKPOINT part 2 (2026-08-07) — THE L3 TOUR

Tree CLEAN but for R23 db.*.gbf churn (never stage). Nothing running. Effort xHigh. NO phase close — T5 unopened, needs Drew's gate-2.

✅ FINAL S45p2 STATE — R22 CLEAN-FLEET 212 passed / 0 failed of 212

FLEET: 93.8% instr (12,683,086 / 13,522,748) · 95.68% fn-count · 87.2% distinct (78,596 / 90,888 uniq) · tools-health OK · audit-digest OK · make audit-disc: UNCLAIMED 6, residue 0. (Drop from part-1's 94.0% = the 29 new modules' text joining the denominator — honest direction.)

WHAT S45 part 2 DID (the live emulator session with Drew + same-day banking)

The L3 debug-menu tour (mode-7 hammer over the Redux web API; full mechanics + slots in docs/memory-map.md §S45; Drew's menu transcription = docs/debug-menu-list.txt): all 28 script modules captured live (four byte-verified per-chapter slots; interior↔module routing law) + MAIN/3 DISCOVERED (the main-menu module both audit oracles had mis-bucketed as data; live byte-proven @0x800CEDF8) + md_MAIN_011/DISELECT byte-proven 24,236/24,240 + slot A/B/boot live R34-verification.
29 onboardings, byte-identical on first build (md_MAIN_003 + the 28 script md_*) → fleet 212. Dedup measure: modules are ~94% novel (probe-first, R37).
R22 earned its keep ×3 on md_MAIN_003: (a) the A4 resident-symbol leak again (DsMix phantom); (b) an extract-order-sensitive splat boundary at 0x800D3200 — the bytes resolved it: a one-word data sentinel in .text + the real fn at +4, now PINNED in config/symbols.md_MAIN_003.txt; (c) corpus.stubs taught that a D_/jtbl_ INCLUDE_ASM is a blob include, not a function stub (mirrors progress.py). All negative-controlled; 212/212.
The module-id census (disc-wide, offline): 77 id-law code payloads, 72 claimed + 5 parked, zero further misses; SC03/55 = confirmed DATA (companion table of 0x40–0x43). The census pattern belongs in disc_audit as the third oracle — small P31 task.
Parked-for-L3 is now 6 payloads with byte-checked negative evidence (MAIN/7, MAIN/9, SC02/9, SC03/53/54/56 — see disc-completeness S45 addendum). Next tier: the CD-read tracer (log cdFileLocTable index per read during play), not scene-guessing. MAIN/9 = alt build of actor 0x2D. The 104 local ram_*.bin dumps in .run/s45/ are LOCAL-ONLY (regenerable).

▶ RESUME HERE (fresh session)

II.5 / the standing frontier — now ~931 module stubs + big-3 novel + ~1,000 script-module stubs (all novel actor/scenario code). Breadth waves ⇒ prompt Drew for Ultracode (R26/R27).
P31 candidates raised this session: the CD-read tracer for the parked 6 · fold the id-word census into disc_audit (R34 third oracle) · main's second oracle (carried).
The S43 serial-crack queue + cheap fuel lists: unchanged, below.

🛑 (superseded by part 2 above) SESSION S45 CHECKPOINT (2026-08-06) — FRESH SESSION SAFE HERE

Tree CLEAN but for R23 db.*.gbf churn (never stage). Nothing running. Effort xHigh. The S44 plan's Part II is DELIVERED through II.3 (II.4 = L3 emulator tour is P31 bucket T by Drew's sequencing; II.5 = the novel-fn frontier is the standing crack-wave slot). NO phase close — T5 unopened, needs Drew's gate-2.

✅ FINAL S45 STATE — R22 CLEAN-FLEET 183 passed / 0 failed of 183

FLEET (honest, grown denominator): 94.0% instr-weighted (12,682,962 / 13,487,439) · 95.96% fn-count · 87.6% distinct-code (78,596 / 90,143 uniq) · 0 NON_MATCHING (G4) · tools-health OK · audit-digest OK · make audit-disc: UNCLAIMED 34, residue 0 — the 34 ARE the parked-for-L3 ledger (roadmap §1.1's explicit exclusion list). The drop from S44's 94.4% is the 40 modules' +52k ins joining the denominator (honest direction).

▶ RESUME HERE (fresh session)

II.5 — the novel-function frontier is the standing crack-wave slot: ~931 module stubs (novel actor code, GTE-heavy, at slots A/B/boot/SC07) + the big-3 novel tier. Regenerated family map + worklist carry them (citizenship). Breadth waves ⇒ prompt Drew for /effort ultracode first (R26/R27); the §150–§153 idioms + match_one --o0 where the prologue says so (§116).
The 169 sweep-fails + 77 STRUCT refusals from the S45 module sweep are classified in .run/hseq_failed.*.classified.txt — read them BEFORE theorising (S44 checkpoint rule).
L3 emulator tour (P31 bucket T): resolves the 34 parked bases + R34-verifies the §S44 static addresses. Needs Windows-native PCSX-Redux (R11) + Drew.
Serial crack queue + cheap fuel lists: see the S43 checkpoint below (unchanged).

S45 per-task log

II.1a ✅ — all 38 MAIN modules onboarded BYTE-IDENTICAL on first build at the §S44 static addresses: slot A 29/29 (md_MAIN_013…041 @ 0x800CAE08) · slot B 6/6 (md_MAIN_042…047 @ 0x800CCB1C) · boot trio 3/3 (md_MAIN_001 [≡MAIN/0, twin], md_MAIN_008, md_MAIN_011 @ 0x800CEDF8). TLO roster derived from the §154 id-word/prologue law (.run/s45/derive_tlo.py): 0x4 everywhere except 011=0x7C, 025=0xC, 034=0x80, 039=0xC. Two findings fixed in new_binary.sh + configs: (1) a module header can hold a function's JUMP TABLE → the hdr carve is now a dot-typed .rodata PAIRED with the c segment (same object; the EXE [0x63238,.rodata,800] precedent) — standalone rodata,hdr emits .L locals that don't link (md_MAIN_034), and bin links in the data block (wrong placement); (2) A4 law applied to the boot trio — symbols.resident.txt removed from their stacks (their windows are sub-ranges of the resident region; DsMix @0x800D1BD8 had already minted a phantom function boundary inside md_MAIN_011; re-extracted clean, all 3 byte-identical, phantom gone).
II.1b ✅ — SC07 pair onboarded BYTE-IDENTICAL at 0x801A00D8 (md_SC07_003 text-lo 0xFC, 100 fns; md_SC07_004 text-lo 0x158, 315 fns — the derived TLOs matched the plan's documented values exactly via the independent first-prologue scan). Symbol stacks window-checked clean.
II.1c ✅ — the module batch signed, dedup-banked, and fully verified. · Dedup measure (R37 probe first): 69/1,113 module fns h_exact-match matched corpus code (~6% — LOW, as the plan predicted; modules are novel frontier). dedup_extend plans 0 (its group model is same-vram; modules live at their own slots) → routed through family_sweep --hseq --band all --only <57 exemplars> instead: 408 member-matches banked (182 into modules 1,113→931 stubs; 226 into the big 3 — families Part I's scoping missed, caught by the regen), 169 failed + 77 STRUCT-refused = genuine frontier. · R22 clean-fleet: 183 passed / 0 failed of 183. · make audit-disc: UNCLAIMED 75 → 34, residue 0. 34 = the 31 parked-for-L3 + 3 rows Discovery-3 never tiered: SC03/53, SC03/54, SC03/56 (SC-disc type-1s, per-disc runtime routing like SC02/9 — parked for L3 with the rest; recorded in II.2/II.3 docs). · Three instrument fixes, each negative-control-proven: (1) family_sweep --hseq stub map now derives ov_+md_+resident (was sig.ov_* glob → every module member silently "not-stub", the R32 class; 0→32 staged on the control family); (2) sig-modules seeds from the built ELF's func_* symbols (bootstrap's linear partition GLUES adjacent fns around jtbl dispatch — 24 false TRUNCATED; perturbed-sig control still flags real disagreement); (3) corpus.audit counts CODE lines only (a module .s legitimately carries its header jtbl as .word lines — the paired-.rodata migration), and progress.py buckets INCLUDE_RODATA symbols as blobs (the §154 id word emitted per-symbol was an unbucketed R32 hole). · tools-health OK · audit-digest OK. NEW HONEST BASELINE (183 binaries): 94.0% instr (12,682,962/13,487,439) · 95.96% fn-count · 87.6% distinct (78,596/90,143 uniq). The drop from S44's 94.4% is the denominator growing +52k module ins (honest direction, P27/S39/S44 precedent).
II.2 ✅ — retirements (R33) + SETUP module recipe. Deleted: disc_code_sweep.py (superseded by disc_audit.py/make audit-disc), reconcile_decls.py (superseded by reconcile_tu; its incumbent row removed from cdecl's differential — the audit's purpose was to enable exactly this deletion), the 3 one-shot rollout drivers (rollout_801457a4_o0 / rollout_whale_o0 / rollout_o0_cluster — rollout_o0.py is the live generic), ImportOverlay.java + VerifyOverlay.java (ghidra_import_raw.sh is the live path). Reference check first: the plan's "zero build refs" was wrong for 3 of them (comments + one live cdecl import — handled, gate re-proven green). SETUP §6.7 gained the module-class recipe (TEXT_LO derivation law, paired-.rodata header carve, A4 symbol-window law, ELF-seeded sig-modules) + inventory rows (R21); disc-completeness Reproduce marked retired; Makefile comments annotated.
II.3 ✅ — metrics re-baseline + roadmap delta + decision-log. Roadmap §1.1 contract corrected: 183 onboarded binaries; the 100% claim's explicit exclusion list = the 34-row parked-for-L3 ledger (28 script + SC02/9 + MAIN/7/9 + SC03/53/54/56), superseding the "39 type-1 backlog" framing. disc-completeness.md gained the S45 section (what landed + the full parked list + the L3 resolution path). Decision-log R31 entry written (the five instrument findings + the hindsight). Digests already re-baselined in II.1c (audit-digest green: 94.0% instr / 95.96% fn / 87.6% distinct over 183).
Next: II.4 (L3 emulator tour) is P31 bucket T — not this session. II.5 (the novel-fn frontier: ~931 module stubs + big-3 novel) is standard crack-wave work.

🛑 SESSION S44 CHECKPOINT (2026-08-06) — FRESH SESSION SAFE HERE

Tree CLEAN but for R23 db.*.gbf churn (never stage). Nothing running. Fable5Max session; plan approved + executed through Part I: ~/.claude/plans/optimized-squishing-engelbart.md — a fresh session continues at Part II of that file (II.1 small-module batch first). NO phase close — T5 needs Drew's gate-2.

✅ FINAL S44 STATE — R22 CLEAN-FLEET 143 passed / 0 failed of 143

FLEET (the HONEST, GROWN denominator): 96.13% fn-count · 94.4% instr-weighted (12,676,581 / 13,435,348) · 88.3% distinct-code (78,334 / 89,140 uniq). Pre-expansion line for continuity: 95.00% instr on 13,160,961 (140 binaries). The drop is the denominator growing by the 3 new overlays' text (+274,387 ins) while the numerator grew +174,062 — the honest direction (P27/S39 precedent). audit-binaries OK over 143 (R36). make audit-disc: UNCLAIMED 78 → 75 payloads / 3,564,021 → 2,038,104 B, residue 0 — the three claims flipped automatically via config/check.<bin>.sha (zero wiring, as designed).

WHAT S44 DID (Part I of the plan, complete)

I.0 knowledge capture — memory-map §S44 (the complete STATIC loader routing table; the emulator doctrine refuted), tooling-audit §S44 (every tool classified), decision-log R31 entry, cookbook §154, disc-completeness corrections.
I.1 five blocking tool fixes, each with a negative control — family_remap vram_of(alias) (0xECC regression byte-identical); Makefile modules.mk + sig-modules (no-op absent the file; main re-verified 143dbb89); audit_binaries de-ov_'d (planted fake module FAILS); the glob widenings (family map now carries resident, 139→142 binaries); tools/new_binary.sh (new_overlay.sh now a 30-line wrapper).
I.2 the big 3 onboarded + dedup-banked — ov_MAIN_012 (d6b3e8b9) · ov_SC02_037 (b0c5394a) · ov_SC03_107 (87d02b57), each BYTE-IDENTICAL on the FIRST build at the statically derived 0x80128158 (byte-proving the §S44 loader table). Then 4,836 h_exact members (dedup_extend, 1,612/binary) + 290 template members (family_sweep --hseq scoped by --only to the 637 relevant families) = 5,126 member-functions banked, every one whole-binary byte-gated. Remaining stubs 624+717+710 = 2,051 = the ~802 novel fns × instances + the failed tier — the new frontier, already visible to every tool (citizenship): worklist/family-hseq/progress carry it, so no separate backlog rows were written (deviation from the plan's I.2e, judged redundant).
Process errors (mine, both caught before reporting): ran the in-place extender on an uncommitted tree (it refused, H4 — I misread the refusal as a result) · a single-file grep -c display artifact briefly read as "0 stubs left".

▶ RESUME HERE (fresh session = Part II of the plan file)

II.1 the 35 small MAIN modules (slots A/B per memory-map §S44; new_binary.sh md_MAIN_<nnn> <payload> <slot> <text_lo> — prologue offsets in the disc-ledger roster; MAIN/0≡1 once) + the SC07 pair at 0x801A00D8 (text_lo 0xFC / 0x158). Then sig-modules, hseq regen, dedup pass (expect LOW dedup — actor modules are novel), audit-binaries, R22, audit-disc.
II.2 retirements (disc_code_sweep, reconcile_decls, rollout_* one-shots, ImportOverlay/VerifyOverlay.java) + SETUP §6.7 module recipe + inventory (R21).
II.3 metrics re-baseline + roadmap delta (completion contract: binaries = 143 + modules; the parked-for-L3 ledger is the 100%-claim's explicit exclusion list).
II.4 L3 emulator (the 28 script modules + MAIN/7/9 + SC02/9 + R34 address verification).
II.5 the ~802 novel functions = normal crack-wave frontier (standard slot; §150-§153 apply).

Tree CLEAN but for R23 db.*.gbf churn (never stage). Nothing running. Effort Max. NO phase close — T5 unopened, needs Drew's gate-2. No src/ or config/ change this session ⇒ the fleet cannot have moved: metrics below are S42's, carried forward unchanged, and no R22 run was owed (nothing was banked).

✅ FINAL S43 STATE — R22 CLEAN-FLEET 140/140, ALL 18 BANKS CONFIRMED

FLEET: 96.63% fn-count · 94.99% instr-weighted (12,501,204 / 13,160,961) · 89.4% distinct-code (78,096 / 87,459 uniq) · 0 NON_MATCHING (G4) · dedup 1919 groups. Session: 12,484,373 → 12,501,204 = +16,831 instructions, 18 functions banked. P30's 95% instr milestone bar is 1,708 instructions away (was 18,539 at session open — the report line rounds to "95.0%"; the precise figure is 94.99%, and the bar is NOT yet met).

The 18: func_8017C6F4 ×4 (Fable5, §150) · func_8017EF68 ×1 (Fable5, §151) · the 0xECC family ×12 (one body, 5 names, 6 addresses — §152) · func_8018D98C ×1 (§153). Near-misses banked to the ledger, not forced (P9): func_8017C6F4's pre-crack seeds; the 246-ins body at 2/246 across 4 instances (func_8017CE58 + func_8017C294).

WHAT S43 WAS: FOUR INSTRUMENT DEFECTS, AND THE TWO QUESTIONS THEY HID

The session opened on the serial crack queue's named next move ("demacroize func_8017C6F4 so the permuter can be aimed") and found that neither the blocker nor the two work items behind it were what the checkpoint said. Nothing was banked; four tools now tell the truth, one floor moved, and one phantom item left the board. Full detail in the S43-1..4 per-task log entries below.

#	recorded as	actually	consequence
1	"the GTE `#define` block defeats `make_base_c` — demacroize first" (§148)	`cpp_expand_macros` ran BEFORE `#include` was stripped → cpp rc=1 → silent fallback returned the unexpanded draft	the permuter was silently dead on 63 stored drafts, incl. the behemoth renderer drafts
2	"an artifact-less backlog rumour outranks the real 63"	the row is real and reproduces (14/15) — but on a different body: `0x8017C6F4` is 15 ins in SC03_010/011/013, 948 in SC03_126/003, SC04_021, SC05_019	`load_best` keyed on ADDRESS → 7%-correct masked 93%-correct; and `binary:null` → absent scored as banked
3	"the classifier writes `CC1-FAIL: make: *** Error 33`"	`errs[-1]` and make prints its summary LAST, always	~3,000 of ~4,000 CC1-FAIL labels were content-free
4	"26 unpropagated members — cheapest fuel, levers exist, ~0 tokens"	0 of 31 templatable from any matched source	phantom item; they are per-member drafting work

THE ONE NUMBER THAT MOVED

func_8017C6F4 (947 ins): hand floor 63 → permuter 41. Both basins then plateau flat (pin-free masked 44 / 8 cycles; pin-t5 masked 43 / 5 cycles). Best draft .run/s43/func_8017C6F4.ils43-pin.c (closeness 41), logged + allowlisted. The ~40 hand probes that "proved" 63 unmovable were all run while the permuter was silently broken.

▶ S43-10 — the wave's 5th agent: §147 REFUTED, and a parked family un-parked

func_8017CE58 is two bodies at one address (246 ins in ov_SC02_000/003; 734 in ov_SC03_092). The 246 body is byte-identical to func_8017C294 — the function §147 was written from — so one draft covers 4 instances. It went from the recorded 12 with a "stop searching" verdict → 2. Three §147 verdicts fell (correction written into §147 in place):

§147-A "stratum 3, unreachable from C" — REFUTED. There is no stratum 3. The frame is declared locals then reload spill slots in pseudo-regno order; the mystery 0x108 slot is an ordinary spill belonging to a loop.c-created pseudo — reachable by writing the loop as an index loop (a pointer walk puts it at the bottom). Every prior draft faked it with volatile pEnd + dead[7].
§147-B — the unreferenced block is combine-orphaned sign-extension intermediates (combine.c:10839), not ?:-on-memory cost.
§147-E — the qty_compare tie is breakable via §148-C's zero-emission ref slider. Consequence: func_8017C294's 15 siblings were parked "until stratum 3 is explained" — that hold is VOID. The last 2 are a cse1 elision-count fact (target 16 orphan slots, draft 12), permuter-confirmed from both basins. The 734-ins body is a singleton (§152 size-key: the only other 0xB74 differs in 766 normalized lines) — queue it as its own behemoth crack seeded from .run/s43/fable/8017C6F4/v2_rtu.c. Process lesson recorded in §147: a confident NEGATIVE verdict is a claim like any other — date it, name its evidence, and re-measure before letting it park work.

▶ RESUME HERE (S43)

func_8017C6F4 — do NOT re-run the ILS on these two seeds (measured flat, 14 restarts). Remaining levers: §148-C the zero-byte allocno-priority slider (__asm__ ("" :: "r"(a),"r"(b)) inside the loop — the documented lever for exactly this two-callee-saved-register swap) by hand; then Fable5 on a fresh seed. Then the rest of the serial queue (func_8017C59C 947 reach 6, func_8017CE58 733×3, func_8017EF68 969, …) — every brief opens with the all-drafts scan + the §147-A frame test, and any ×N claim needs the §148-E draft test.
func_8017C294 NEAR(12) still parked on §147-A stratum 3; its 15 siblings stay parked with it.
Re-check the 63 GTE drafts the silent fallback disabled — the behemoth renderer drafts are the high-byte-weight ones and have never actually had a permuter run.
Then L1+L2 disc audit (task #10), then L3 + type-1 onboarding (task #11) — Drew's agreed plan, unchanged, below.
Cheap fuel: the 61 SC07 -O0 members · func_80183BAC's R22 revert (capture WHICH binary) · 2 resident stubs with gate-rejected match_one-MATCH drafts · the 263×5 cluster (0x80182fd4, parse error before 'unsigned', undiagnosed — the fixed classifier will now name it). ⚠️ "26 unpropagated members" is REFUTED — struck from this list (S43-4).

🧰 HAZARD INTRODUCED-AND-DOCUMENTED THIS SESSION

tools/harvest_verify.py has no if __name__ == '__main__' guard: import harvest_verify runs a full build, splices drafts, and overwrites .run/harvest_*.txt. I tripped it unit-testing classify_fail (no damage — resident stayed 8e17e02f, 0 banked, tree clean). Nothing imports it, so it is flagged in the file header rather than fixed by a risky 500-line refactor of our most load-bearing gate. To test a helper in it, exec that function's source — never import the module.

🧰 MY PROCESS ERRORS THIS SESSION

Queried the wrong field name (draft vs best_draft) and briefly read all 838 rows as artifact-less — the §133 default-filter shape, self-inflicted. Caught by sanity-checking a number that was too round.
Inherited a checkpoint claim without probing it ("no draft survives on disk"); the draft was there, and one ls would have shown it. The whole S43-4 refutation exists because I probed the second such claim instead of the first.
Imported a module that runs a build (above).
Wrote a "negative control" that never exercised the changed branch — the PLUMBING path returned first, so old and new agreed and the test proved nothing. Rebuilt it to hit the branch under test.

🛑 (superseded) SESSION S39–S42 CHECKPOINT (2026-08-05)

Tree CLEAN but for R23 db.*.gbf churn (never stage). MCP was stopped by me for the main sig regen — the SessionStart hook restarts it; run /mcp before any Ghidra work (R29). ONE AGENT MAY STILL BE RUNNING: a serial crack on func_8017C6F4 writing to .run/s42/ov_SC03_126/. If its result never arrived, re-run it (brief pattern below). NO phase close — T5 is unopened and needs Drew's gate-2.

FLEET — R22 140 passed / 0 failed of 140 (run ~25× this session, green every time)

96.62% fn-count (341,775/353,717) · 94.9% instr-weighted (12,484,373/13,160,961) · 89.2% distinct-code (5,043,472/5,654,184; 78,081 uniq) · 0 NON_MATCHING · audit-digest OK. Session: 12,405,402 → 12,484,373 = +78,971 instructions, +129 unique fns, 46 commits. ⚠️ The denominator CHANGED mid-session (13,141,652 → 13,160,961) when main's sig was regenerated. Compare percentages only within one denominator. No numerator ever fell.

REMAINING (measured at close)

676,588 ins across 12,902 open stubs — main 79,074 / 2,001 stubs (12% of remaining, and the least tractable: structurally barren, zero h_exact overlap, no free dedup, checked twice) · overlays + resident 597,514 / 10,901. Distinct remaining 610,684 ins across 11,330 unique fns — only 1.1× compression. The ×138 propagation era is over: what is left is largely genuinely distinct code, so the fleet number and the work are now nearly the same thing.

🎯 THE AGREED NEW PLAN (Drew, 2026-08-05) — DO NOT LOSE THIS

Drew: "im getting tired of learning there was more code all along, we really need a full audit that definitively lists ALL code that we need to decomp." Agreed and approved. Full rationale in docs/decision-log.md (2026-08-05 entry); tasks #10 and #11.

THE INVARIANT: every byte on the disc belongs to exactly ONE bucket — onboarded-code / classified-data / audio-video / filesystem-metadata / unused — the buckets sum to the disc, and residue is a DEFECT (R32). A partition with an asserted residue of zero is a completeness proof; a longer list is only a longer list. Same move as audit-digest (S1e) and audit-binaries (R36) applied to the DENOMINATOR.

Why three surprises happened: every tool was correct about the subset it examined and silent about the rest — a 0.4.dec glob (missed 4 SC07 overlays whose code is at PAC entry 1), a decode layer (disc_code_sweep was blind to COMPRESSED code), a 4,096-word window. Measured: 782 of 1,328 PAC payloads are only PARTIALLY classified (~55.5M words never examined). Probably data — but nothing has checked, which is the exact shape of all three findings.

L1 (task #10, cheap, deterministic, no RE): walk from the DISC IMAGE not our configs — every ISO file → .CD sub-file → PAC entry → both raw AND decompressed layers; classify whole payloads, no window; emit docs/disc-ledger.md with per-payload claimed-by <binary> | UNCLAIMED; assert sum(buckets) == disc bytes; ship as make audit-disc. L2 (task #10, R34): a SECOND, DISAGREEING oracle. Today's code test is a heuristic (valid ≥ 0.90 AND jr $ra ≥ 0.01) — a small code payload can fall below 1% jr density. Cross-check with sig_image boundary carving; disagreements are the review queue. L3 (task #11, the proof — AND the type-1 onboarding, SAME RUN): instrument PCSX-Redux (R11: Windows-native, WSL via 172.17.208.1:8081) over a scripted tour of every location; log every load (payload → RAM addr → len) and every executed PC range. Delivers (a) the load addresses the 39 un-onboarded type-1 modules need — they are NOT location overlays, each loads at its own address like the resident at 0x800CEDF8, so they cannot be onboarded mechanically and a build binary needs its address to byte-verify (P9); (b) completeness proof — anything executed but absent from the L1 ledger is a hole; (c) honest exclusion — never-loaded payloads marked out-of-scope WITH EVIDENCE. Do L3 and the onboarding together or you pay for the tour twice. EXPECT THE HEADLINE TO FALL when the 39 land (denominator grows) — the honest direction, as with today's main regen (94.5→94.4) and P27's overlays (68.9→67.0). "100%" is not claimable until the 39 are onboarded-and-matched or explicitly excluded with a stated reason.

SEQUENCE (Drew's): finish the serial crack queue → L1+L2 (they sharpen L3's target list) → L3 + type-1 onboarding. Fold into P31, which already owns roadmap bucket T.

🏆 WHAT S39–S42 DID

S6 — BOTH "PERMANENT" GIANT WALLS CRACKED ×138 (+50,094 ins)

wall	recorded verdict	what it took
`func_80178004` 165×138 = 22,770	P26: Fable5, ~477k tokens, "intrinsic 3-integer regalloc wall"	a stored draft, gated as-is, no new work
`func_801412A8` 198×138 = 27,324	close=29/110 since P24	1 of 31 stored drafts + the §37/§124 alias
Why #2 looked intrinsic: TU declares `extern int f(int×6)` and callers USE the return, but the
byte-true def returns a pointer and takes two `u16`s — so **the byte difference is in the CALLERS,
which `match_one` never compiles. Propagation then returned 0/137 twice**, both times a missing
TYPE (`_carry_macros` carries `#define`s but not typedefs, and is not transitive). → cookbook §146.

The `cast_call_sites` BUG — it DELETED `return` STATEMENTS

return func_X(…); — return is a valid identifier where DECL_LINE_RE expects a type, so the "rewrite decl to canonical" path replaced the STATEMENT with a declaration. C89 → parse error before 'extern', which reads as the DRAFT's fault. Fix = statement-keyword guard. Sweep 0/39 → 18/39. ⚠️ Routing it through cdecl (the obvious R33 move) is a SILENT NON-FIX — cdecl.parse() calls return func_X(…) a declaration of func_X and if (f(a)); a declaration of if. Checked before shipping. In gate_stage's DEFAULT pipeline since Phase 20; 318 of 44,833 stored drafts carry a line it mis-reads. → §143.

S1e — the "distinct-code regression" NEVER HAPPENED

A stale committed digest (commit:1426 generated from a tree holding work reverted before the commit landed; overstated +7,879 ins / +130 uniq). True delta: everything rose. Fixes: progress.py stub_addrs no longer swallows corpus.stubs (it had reported 100.00%/100.00% in a tree with no asm/); the same swallow fixed in cast_call_sites.tu_for + reconcile_tu.tu_for (they silently reconciled against the WRONG TU); NEW make audit-digest. → §140.

S5 — two waves, 24 exemplars, 24/24 banked, ZERO codegen walls

Pool verified first (R14): 1,677 clusters / 5,795 fns / 319,755 ins at 3.68× (Fable claimed 2.7× — accurate here, though its whale claim was 3/4 wrong: verify each claim separately). Wave 1 8/8 match_one → 5/8 gate → 8/8 after recovery; wave 2 16/16 → 14/16 → 16/16. All six first-pass failures were TU-integration plumbing with documented levers. ⇒ THE GATE NUMBER MEASURES INTEGRATION, NOT MATCHING — run the recovery ladder BEFORE recording a wave's yield. Then 61/87 members propagated. 3.73M subagent tokens, 0 errors.

S4 (REDONE — the first pass was wrong) · S7 · §134

S4: the first pass re-gated only the NEWEST draft per head (8 banked). S6 proved that is sampling — its giant's match was the 9th of 31. Rescanned ALL drafts over 38 targets: 14 matched on disk, 7 banked, incl. func_8018057C (897 ins) that was on the "needs an agent" list. S7: main's sig regenerated (1,729→2,205 sigs; stub coverage 1,525→2,001 of 2,002) — main is now the single largest open target at 79,074 ins / 10.7% of all open code, and only became visible at that size today. §134 CLOSED: the last two line-shape scanners route through cdecl._mask.

NEW COOKBOOK THIS SESSION — §140 §141 §142 §143 §144 §145 §146 §147

§147 (from the serial run, most transferable): the three-stratum frame law — stratum 3 is a trailing block ?: chains allocate and never reference, unreachable from C; the 30-second test is delete the min/max tail, re-read .frame … # vars=; the drop IS stratum 3. Plus: a ?: on MEMORY operands costs ~16 bytes of frame and on REGISTER operands zero; inner-block declaration does NOT delay slot allocation (byte-refuted); a lone $t8/$t9 is RELOAD SCRATCH (reproduce the spill, don't pin — the pin CREATED a diff); a qty_compare tie is not spelling-reachable (72 statement permutations × 4 decl orders × 7 retypings × pins × permuter, floor never moved). §142 the free h_exact pool (propagate the MATCHED body, don't gate a draft) · §144 the literal's SPELLING picks the immediate encoding (cnt + 0xff vs cnt - 1) · §145 combine_givs anchor rule / p = r; combine barrier / chained assignment stores right-to-left.

▶ RESUME HERE

Serial crack queue (Drew's explicit choice: SERIAL, one agent per fn, so a transferable idiom makes the rest cheaper). Order + status: func_8017C294 NEAR(12) — draft .run/s42/ov_SC01_077/, blocked on §147-A stratum 3; DO NOT spend its 15 siblings until that is explained (all hit the same 12; family_remap takes all 16 in one pass when it closes). func_8017C6F4 (947×3) — NEAR(63) pin-free (.run/s42/ov_SC03_126/func_8017C6F4.c); a register … __asm__("$13") variant reaches 47 (.pin-t5.c). Frame 0x120 + vars=232 EXACT; all opcodes/immediates/stack-offsets/branch-targets correct; residual is ONE register rotation (mnc→$a0 mine vs $t0 target, cascading xmx1→$t1, cell→$t3, prim→$t5). Did not move under ~40 probes (decl order, inner-block scoping, split X/Y, statement order, aliasing, direct-field reads, 6 pin combos). NEXT MOVE: demacroize so the permuter can be aimed — run_masked currently fails "Function not found in base.c" because the gte_* #define block defeats make_base_c. Idioms → §148. ⚠️ The agent claimed all sixteen 947-ins instances are ONE body (→ 15,152 ins on one crack). I CHECKED AND IT DOES NOT HOLD: its draft scores 63 on ov_SC03_126 but 340 on both func_8017C59C and func_8017CF90, with an IDENTICAL first diff on each — so those two match each other, not the cracked one. Consistent with the h_norm clustering (947×3, 947×2, singletons): several groups, not one of 16. Test a ×N claim by sed-renaming the draft and running match_one against the sibling's asm — a normalized diff says "same shape", only that says "same body" (§148-E). Then: func_8017C59C (947, reach 6) · func_8017CE58 (733×3) · func_8017EF68 (969) · func_8017D538 · func_8017C974 (close=47, re-measure first) · func_8017DF98 · func_8017CF90 · func_8018D98C. (func_8018057C already banked free.) Every brief MUST open with the all-drafts scan and the §147-A frame test.
Then L1+L2 disc audit (task #10), then L3 + type-1 onboarding (task #11).
Cheap fuel any time: the 26 unpropagated members (20 CC1-FAIL + 5 callee conflicts: func_8017EFA0 ×3, func_8012B23C ×2) — levers exist. FIRST FIX THE CLASSIFIER: it writes CC1-FAIL: make: *** Error 33 without the cc1 message, so each costs a manual splice-and- rebuild to diagnose (done 3× today). harvest_verify already captures cc1 stderr — copy that.
Also open: the 263×5 cluster (0x80182fd4) sweeps 0/5, parse error before 'unsigned', undiagnosed — do not assume codegen · 7 S4 drafts still near/failed in .run/s41/rec/ · the 61 SC07 -O0 members · func_80183BAC's R22 revert (capture WHICH binary this time) · 2 resident stubs with gate-rejected match_one-MATCH drafts.

💾 THE SERIAL DRAFTS ARE NOW COMMITTED — AND ONE LEDGER ROW IS A RUMOUR

The two NEAR drafts (~680k subagent tokens) were gitignored, one git clean from gone. A curated /.run/s42/ allowlist now tracks them; both are logged to the backlog with measured closeness, class, reach and draft path: .run/s42/ov_SC01_077/func_8017C294.c NEAR 12 / 246 .run/s42/ov_SC03_126/func_8017C6F4.c NEAR 63 / 947 (frame 0x120 + vars=232 EXACT) .run/s42/ov_SC03_126/func_8017C6F4.pin-t5.c NEAR 47, register … __asm__("$13") variant

⚠️ func_8017C6F4 carries a PRE-EXISTING backlog row closeness=14 (2026-07-01, ov_SC03_010, source=bulk-harvest) with draft: None, klass: None, nins: None, reach: None. No artifact behind it, and no draft of it survives on disk (the S42 agent scanned every stored draft: two, both junk). load_best takes the LOWEST closeness, so this unverifiable row OUT-RANKS today's real 63 in every future target selection. Same defect class as Phase 28's func_80178004 close=0 myth (truth 91). Treat the 14 as UNVERIFIED; start from the committed 63/47 drafts; purge the row if it cannot be reproduced. General rule worth adopting: a backlog row with no draft artifact is a rumour, not a result — backlog.py log should require a draft path or mark the row unverifiable.

🧰 MY PROCESS ERRORS THIS SESSION (all caught; each is a rule now)

Sampled instead of scanning — head -8 of 31 drafts, reported "closeness 40" for a function whose MATCH was in the 9th. Cost: nearly skipped a 27,324-ins crack.
Substring false positive — grep -c "Prim_1412A8" matches inside addPrim_1412A8; I briefly concluded a type-carry worked when it hadn't.
Lift without strip — lifted typedefs to engine_types.h without removing the originals → duplicate typedef → R22 139/140. build_engine_types --strip does both.
Nearly ran make clean (deletes asm/) while 8 agents were reading it.
Asserted two mechanisms before deriving either (S1e) — three greps settled it; I ran them third.
A worktree probe that silently measured the wrong tree (symlinked tools/ → ROOT resolved back to the main repo). A control that cannot fail is not a control.
Wrong match_one flags in the wave-1 prompt (--binary/--src; real: --c/--asm-subdir).

🛑 SESSION-39 CHECKPOINT (2026-08-04) — FRESH SESSION SAFE HERE

NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN but for the R23 db.*.gbf churn — never stage. Effort xHigh. R22 run FOUR times: 140/140 every time. No failures, nothing reverted. NO phase close — keep grinding. Plan = T7; full report .run/fable_frontier/ANALYSIS.md. VERIFY: git log --oneline -4 at/near HEAD + docs/progress.fleet.md agrees with FLEET below.

FLEET — R22 140 passed / 0 failed of 140 (run ~14× this session, 140/140 every time)

96.51% fn-count (341,365/353,717) · 94.4% instr-weighted (12,419,169/13,160,961) · 89.0% distinct-code (5,029,454/5,654,184; 77,973 uniq) · 0 NON_MATCHING · audit-digest OK. Session opened 341,186 / 12,405,402 / 77,952 ⇒ +13,767 instructions, +21 unique fns, +179 fn-count, ~0 agent tokens — NO WAVE WAS RUN. Every gain came from re-gating stored work, mechanical propagation, and fixing instruments. ⚠️ THE DENOMINATOR MOVED +19,309 ins (main's sig regen, S7). instr 94.5%→94.4% and distinct 89.3%→89.0% are a DENOMINATOR CORRECTION, NOT a regression — both numerators are unchanged across that edit. main's sig covered only 1,525 of its 2,002 stubs (dated 2026-06-14); now 2,001/2,002 (the 1 is func_80049600, a LINKED PsyQ region the Ghidra sig excludes by design). Phase-27 precedent: an honest denominator moves the headline DOWN.

🔑 THE SESSION'S HEADLINE — S38's "distinct-code REGRESSION" NEVER HAPPENED

The v4 checkpoint gated the phase's best lever on it ("do NOT scale the alias lever"). It was a STALE COMMITTED DIGEST. commit:1426's digest was generated from a working tree still holding work reverted before the commit landed (+7,879 ins / +130 uniq overstated) and never regenerated, so the next HONEST digest read as a fall.

	instr	distinct	uniq
`commit:1426` true	12,394,533	5,022,306	77,895
`commit:1426` as committed	12,402,412	5,029,324	78,025
its successor, true = committed	12,405,402	5,025,082	77,952

True delta over that span: instr +10,869 · distinct +2,776 / +57 uniq — EVERYTHING ROSE. ⇒ THE ALIAS LEVER IS UNGATED. Both recorded leads were wrong (R14): progress.py:423's SIG feeds fn-count only (neither weighted metric sees a C identifier — both derive matched = sig − corpus.stubs), and "reverted to INCLUDE_ASM" died on one grep (483 removed, 0 added).

THE 3-GREP PROOF, before forming any hypothesis about a metric move: identical sigs (both denominators unchanged) + unchanged tools/ + git diff A B -- src/ | grep -c '^+.*INCLUDE_ASM(' = 0 ⇒ HEAD's stub set is a strict SUBSET ⇒ both numerators are mathematically forbidden to fall.

🧰 FOUR INSTRUMENT DEFECTS FIXED — all ONE class: a bare `except` around a fail-CLOSED oracle

progress.py stub_addrs swallowed corpus.stubs' refusal → empty stub set → matched = sig − stubs credited EVERY function. Byte-witnessed reporting instr 100.00% / distinct 100.00% in a tree with no asm/. Now propagates. 2–3. cast_call_sites.tu_for + reconcile_tu.tu_for — identical swallow, falling back to the default <ov>.c instead of the _jr_/-O0 split TU: the exact bug cast_call_sites' own docstring says it exists to fix. A wrong-TU reconcile fails the gate, and the phase's base rate is ~24k PLUMBING vs 4,917 DIFF ⇒ it presents as a codegen wall. Both propagate; ValueError fallback for curated names kept; derived path re-verified on a _jr_ stub.
NEW make audit-digest (tools/audit_digest.py, in tools-health after report) — recomputes the three headline metrics from the tree and fails if the committed digest disagrees. Compares INTEGERS, not percentages (the staleness printed "94.4%" on both sides). Negative-control-proven against the stale digest. R34: the byte-gate is a null oracle for DOCUMENTS.

✅ BANKED THIS SESSION (+4,727 ins, every step R22 140/140)

what	ins	note
the whale ×1 → 138/138 (`ov_SC07_010`)	+770	`o0_subsplit --lo 0x80144B9C --hi 0x801457A4`; 0 already-matched in range ⇒ no §126 island; split byte-neutral FIRST, then banked. S38's stated cause (reused `_o0c`) did not recur — `free_letters` derives an unused suffix.
4 wave-6 drafts (SC06_032 710 · SC03_001 557 · SC04_018 513 · SC02_027 125)	+1,905	banked UNCHANGED — see the finding below
`func_801878E8` family 4/4 siblings	+2,052	`jtbl_family_bank.py`, ~0 agent tokens
4 re-gated stored drafts (the 2 REVERTED overlays)	+146	`ov_SC06_030` ×2 · `ov_SC07_010` ×2; incl. a fleet-wide `engine_core.h` no-proto arity edit proven byte-neutral
8/35 draft-exemplar heads re-gated	+474	4 gate cycles, 0 agent tokens; 23% vs 8% for the general pool
5 families propagated ×N (10 siblings)	+718	`jtbl_family_bank`; 1 family auto-REVERTED on R22 (§61), 1 found nothing
`func_801758FC` ×137	+7,535	the largest free h_exact class — see the third finding
8 small free h_exact classes	+175	the rest of that pool `--addr` could reach

🔑 THE SECOND FINDING — RE-GATE STORED DRAFTS AFTER ANY TOOL REPAIR

All 4 wave-6 drafts banked with no change to the drafts. S38 recorded them blocked on a class needing a crack ("cracking this one class frees 6 drafts at once"); they had already been freed by S38's own tool repairs (the jr_isolate_all/overlay_src_split alias-DEFINITION-deletion blindness

harvest_verify._reload_corpus). The drafts were correct; the instruments were failing them. A stored verdict is only as current as the instrument that produced it (R35, applied to the backlog rather than to metrics). This is the 5th "wall" this phase to resolve to our own tooling.

🔑 THE THIRD FINDING — MEASURE THE FREE POOL, DON'T TRUST THE REPORT

.run/fable_frontier/ANALYSIS.md claimed the whale was "open only in SC07_006/007/010/011" — 3 of those 4 were already banked; only 010 was open (closed this session). Its pool numbers are not reliable (the checkpoint's own R14 caveat, now demonstrated). Re-measured from the bytes instead: 215 open instances / 8,763 ins are h_exact-identical to an already-matched function, and ONE class was 86% of it — func_801758FC, 55 ins, same address in all 138 overlays, matched in ov_SC01_000, open in 137. dedup_propagate --addr banked all 137 byte-identical (+7,535 ins). It had been in the stored-draft backlog and re-gated "no" earlier the same night — because gating a DRAFT is the wrong move for an h_exact class; propagating the MATCHED body is the free one. Same function, two routes, only one is free. Remaining free pool: 66 instances / 1,061 ins across 25 classes, all macro-backed (so --addr refuses — they need a dedup_extend-style route).

🏆 S6 (2026-08-05) — BOTH GIANT WALLS CRACKED ×138, +50,094 ins — FLEET 96.62% fn / 94.8% instr / 89.2% distinct, 140/140

The two functions the roadmap carried as PERMANENT WALLS since Phase 24 are matched in all 138 overlays. Neither needed a siege — both matched from drafts ALREADY ON DISK.

wall	recorded verdict	what it took
`func_80178004` 165×138 = 22,770	Phase 26: Fable5, ~477k tokens, "intrinsic 3-integer regalloc wall"	a stored draft, gated as-is, no new work
`func_801412A8` 198×138 = 27,324	close=29/110 since Phase 24	1 of 31 stored drafts + the §37/§124 alias

Why the second looked intrinsic: its TU declares extern int func_801412A8(int×6) and callers USE the return, while the byte-true def is Prim_1412A8 *(Prim_1412A8*, int,int,int, u16,u16). Narrow params can't agree with an int prototype and the no-proto escape is illegal once a param promotes — so the byte difference lives in the CALLERS, which match_one never compiles. The measuring instrument was blind to where the difference was. Propagation then returned 0/137 TWICE, both times a missing TYPE: _carry_macros carries #defines but not typedefs, and is not transitive. Lifted Env_1412A8/PTag_1412A8/ Prim_1412A8 + OT/getaddr/setaddr → 137/137. MY ERROR, caught by the gate: lifted without STRIPPING the originals from ov_SC01_077.c → duplicate typedef → R22 139/140 [FAIL] ov_SC01_077. Stripped → 140/140. A proper lift strips the source (build_engine_types --strip). Also: my first draft scan used head -8 of 31 and missed the match in the 9th. SCAN, don't sample. cookbook §146.

🚨 ROADMAP DELTA — the "2 permanent giant walls" line is RETIRED

Every roadmap/backlog reference to func_801412A8 + func_80178004 as permanent INCLUDE_ASM walls is now false. P32's behemoth/wall track loses its two headline items. More importantly the class of claim is suspect: when a tool is repaired, every verdict it produced becomes a HYPOTHESIS again. The backlog's closeness values and residual classes were produced by tooling that has changed materially this session (§143 alone). Re-measure before respecting any of them.

🚀 S40 (2026-08-05, ULTRACODE) — FLEET 96.54% fn / 94.5% instr / 89.2% distinct, 140/140

Session arc: 12,405,402 → 12,432,941 instr (+27,539), +120 unique fns, R22 green at every step. ⚠️ The denominator is now 13,160,961 (was 13,141,652) — main's sig regen made it honest. Compare percentages only across the same denominator; the numerator never fell.

THE `cast_call_sites` BUG (the session's most consequential find)

It read a RETURN STATEMENT as a prototype and deleted it. return func_X(…); — return is a valid identifier where DECL_LINE_RE expects a type — so the "rewrite this decl to canonical" path replaced the STATEMENT with extern … func_X(…);. C89 then says parse error before 'extern', which reads as the DRAFT's fault. Fix = a statement-keyword guard. family_sweep over 5 families went 0/39 → 18/39; the same machinery later propagated 24/24 and 61/87. ⚠️ THE TRAP INSIDE THE FIX: routing it through cdecl (the obvious R33 move) is a SILENT NON-FIX — cdecl.parse() calls return func_X(…); a declaration of func_X and if (f(a)); a declaration of if. It parses declarator GRAMMAR; statement-vs-declaration is not a question it answers. Checked before shipping. Blast radius: in gate_stage's DEFAULT pipeline since Phase 20; 318 of 44,833 stored drafts carry a line it mis-reads, across 67 callees. cookbook §143.

THE WAVES — 24 exemplars, 24/24 banked, ZERO codegen walls

Pool VERIFIED first (R14): 1,677 clusters / 5,795 fns / 319,755 ins at 3.68× vs Fable's claimed 1,689 / 5,956 / 326,261 at 2.7× — accurate here, and the multiplier is BETTER. (The SAME document's whale claim was 3/4 wrong. Verify each claim; never accept or reject a source wholesale.)

wave	targets	match_one	gate 1st pass	after recovery
1	8	8/8	5/8	8/8
2	16 (lessons folded into the prompt)	16/16	14/16	16/16

ALL SIX first-pass failures were TU-integration plumbing with documented levers — §77 probe-layer strip · recover_giant block-scoping · §37/§124 def-side asm-label alias · §17a-1 no-proto + call-site cast. ⇒ THE GATE NUMBER MEASURES INTEGRATION, NOT MATCHING. Run the recovery ladder BEFORE recording a wave's yield, or the metrics under-report the drafters and send the next wave hunting walls that are not there (docs/wave-metrics.md S40-1). Cost 3.73M subagent tokens / 24 agents / 0 errors. Then 61/87 members propagated (+7,087 ins).

NEW IDIOMS (all byte-derived by the drafters, distilled in-session)

§144 the LITERAL'S SPELLING picks the immediate encoding (cnt + 0xff vs cnt - 1 — mod-256 identical, both one addiu, but gcc emits 0x00FF vs 0xFFFF from the source text; looks exactly like an intrinsic wall and is free) · §145a combine_givs anchors the address-giv group on the LAST address-giv in SOURCE order · §145b a bare p = r; is a COMBINE BARRIER that preserves a pointer-bump addiu · §145c chained assignment emits stores RIGHT-TO-LEFT.

▶ CHEAPEST FUEL NEXT SESSION (all named, all deterministic)

The 26 unpropagated members (20 CC1-FAIL + 5 callee conflicting types: func_8017EFA0 ×3, func_8012B23C ×2) — the recovery ladder already has every lever.
FIX THE CLASSIFIER FIRST: it writes CC1-FAIL: make: *** Error 33 without the cc1 message, so 20 of those 26 carry no actionable reason and each costs a manual splice-and-rebuild to diagnose (done twice this session). harvest_verify already captures cc1 stderr — do the same here.
Scale the wave — the verified pool still holds ~450 tractable clusters; both waves closed 100%.
Carried: the 61 SC07 -O0 members · func_80183BAC's R22 revert (my loop logged THAT check-all failed, not WHICH binary — capture the failing binary on the retry) · S6's 2 giant walls (50,094 ins on 2 cracks, untouched) · main's 79,074-ins tail (agent work, structurally barren).

🌙 OVERNIGHT (S39 cont., 2026-08-05 ~00:40–)

tools/grinder.py -j 14 --cycles 4 --permute-secs 240 --max-closeness 20 --max-nins 400 — the token-FREE permuter daemon, running the P30-T4 ILS warm-restart whose yield was never proven. Targeting ON: 1,286 classified, only bucket=permuter admitted (skipped 805: 447 redraft, 272 structural, 53 integration). First evidence the ILS wiring does something: func_80182C9C hit "best 5, warm-restarting" (a cold search would have restarted from scratch). It commits its own verified banks (gate_stage --no-propagate, §55b). ⚠️ MORNING: its banks are per-binary gated but NOT fleet-verified — run a full R22 before treating them as a fleet claim (§61), then make report + propagate anything it landed. Log .run/s39/grinder.log; 6h box from 00:42.

Also delivered overnight (all zero-agent, all committed)

§134 CLOSED (task #7) — the last two line-shape scanners (progress.py.strip_comments, lint_symbol_refs.strip_comments_strings) now route through cdecl._mask. The progress one was not string-aware, so a } inside a string literal walked the body-depth to −1 and would mis-bucket a function in fn-count; metrics identical before/after (a latent defect). cookbook §141.
main's sig regenerated (task #6/S7) — 1,729→2,205 sigs, stub coverage 1,525→2,001 of 2,002. Denominator +19,309 ⇒ the honest re-baseline above. MCP IS DOWN (I stopped it for the lock); SessionStart restarts it — run /mcp before any Ghidra work (R29).
make audit-frontier (task #9, Drew's MASTER_REMAINING in its DERIVED form) — reconciles every "what's left" view against corpus.stubs; on first run caught family_hseq publishing 11,456 unmatched instances when only 11,297 are still open (delta +159, the map predates tonight's banks). Deliberately NOT in tools-health — additive until Drew has seen it; --strict exits 1. Assessment in docs/decision-log.md: adopt the goal, reject the maintained list (R33).
docs/frontier-s39.md — measured frontier + the T5 burn-down, with the −0.14pp last row annotated as a denominator correction, not a regression (T5 must not report it as one). main is now the single largest open target: 79,074 ins / 2,001 stubs = 10.7% of all open code.
cookbook §142 — the free-h_exact lever and the trap that hid it.

▶ RESUME HERE

S4 continues (task #3): the 39 draft-exemplar families (382 members) + the 2 resident stubs that already have match_one-MATCH drafts gate-rejected for TU plumbing. ⚠️ Do NOT blanket-re-gate the stored backlog — MEASURED this session (docs/calibration.md): fresh wave-6 drafts 4/6, unbiased stored sample 1/12, the two REVERTED overlays 3/17. A10's 0/958 broadly STANDS; 1,155 whole-binary builds are not justified by ~8%. The rule is narrower: re-gate the drafts a repair plausibly touched, targeted by its blast radius.
S5 the wave (task #4) — 1,689 h_norm clusters / 326,261 ins at a claimed 2.7×. VERIFY Fable's pool numbers first (R14 — its two headline refutations were re-verified, its POOL NUMBERS were NOT), then ONE 8-target calibration wave, measure REALIZED propagation. Prompt for the toggle (R27).
S6/S7 — the 2 giant exemplar walls (50,094 ins on 2 cracks); then main (regen its 7-week-stale sig FIRST — missing 757 of 2,002 stubs).
NEW (Drew, 2026-08-04, task #9 — do NOT start without his go): the frontier reconciliation gate + denominator completeness (his MASTER_REMAINING idea in its derived form). Full assessment in docs/decision-log.md: adopt the goal, reject the maintained list (R33). Fits P31's opener.
Carried, not lost: the 61 SC07 -O0 members (S3's untouched half) · the §134→cdecl._mask consolidation (task #7; the class has now appeared in SIX tools) · progress.py's SIG alias blindness (fn-count only — resolve defs through overlay_src_split.asm_label_aliases, R33).

🚧 LEFT ON THE BACKLOG AS GENUINE (not forced, P9)

func_8017C974 (ov_SC01_077, 947 ins, close=47, REGALLOC-PERM, 12 permuter variants inert) · func_80188C68 (ov_SC03_124, 551 ins, close=370, the only target with no twin anywhere).

📌 A METRIC SHAPE WORTH KNOWING (R30)

A body banked by #include-ing a shared header is invisible to fn-count's NUMERATOR (the definition is not in the .c) while its stub leaves the denominator — the whale bank moved fn-count 341186/353718 → 341186/353717. The weighted metrics counted it correctly (+770) because they derive from corpus.stubs, not re-parsed C. Trust the weighted pair. Same root as the SIG lead.

🧰 MY PROCESS ERRORS

Asserted two mechanisms before deriving either — the recorded SIG lead (feeds fn-count only) and "the harvest reverted functions to INCLUDE_ASM" (483 removed, 0 added). Three greps settle it; I ran them third instead of first. R14/R37 — derive, then assert.
Built a worktree probe that silently measured the wrong tree — symlinking tools/ made ROOT resolve back to the main repo, so the "843 tree" reported HEAD's numbers. Caught because the numbers were identical, which was too good. A control that cannot fail is not a control.
Chased the conflicting-decl bank one build at a time (2 iterations) before enumerating all collisions with cdecl in one pass — which found exactly 3 re-declarations, 2 conflicting.

🛑 (superseded) SESSION-38 CHECKPOINT — v4, POST-S1d (2026-08-04)

NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN but for the R23 db.*.gbf churn — never stage. Effort xHigh. R22 run THIRTEEN times: 140/140 on eleven, TWO REAL FAILURES (both caught, both reverted, both recorded below). NO phase close — keep grinding. Plan = T7; full report .run/fable_frontier/ANALYSIS.md; task list has 11 items. VERIFY: git log --oneline -3 at/near HEAD + docs/progress.fleet.md agrees with FLEET below.

FLEET — R22 140 passed / 0 failed of 140

96.46% fn-count · 94.4% instr-weighted · 89.2% distinct-code (77,952 uniq) · 0 NON_MATCHING. Session opened 96.28 / 94.1 / 88.7 ⇒ +37,166 instructions, ~0 agent tokens after the opening wave. ✅ RESOLVED S39 (S1e) — the "distinct-code FELL 89.3 → 89.2" alarm was a STALE COMMITTED DIGEST, not a regression. True delta over that span: instr +10,869 · distinct +2,776 ins / +57 uniq — everything ROSE. THE ALIAS LEVER IS UNGATED. Guard added: make audit-digest (in tools-health). See §140.

🔑 THE SESSION'S BIGGEST FIND — the def-side asm-label alias is a CLASS lever

The dominant sweep blocker was conflicting types for func_80146A6C (208 of ~398 conflicts). Diagnosed by READING THE DRAFT after eliminating three levers by measurement: draft def : void func_80146A6C(s16 a0, s32 a1, s16 a2, s16 a3, u16 a4, s32 a5, s32 a6) TU decl : extern s32 func_80146A6C(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6); The NARROW PARAMS are the wall: C default argument promotion means s16/u16 cannot agree with an s32 prototype, and the () no-prototype escape is ILLEGAL precisely when a param promotes — so NEITHER declaration side can move.

lever	result	why wrong
`cast_call_sites` (already default-on)	no effect	fixes CALLEE decls, not the def's own
`--normalize-self-decls`	0 banks + non-neutral reverts	fixes the target's decl in CALLERS
`--fix-def-sig`	0/138, error unchanged	cannot reconcile a promoting param at all
§37/§124 def-side asm-label alias	138/138	removes the DECLARATION from the equation
void aF80146A6C() asm("func_80146A6C");
void aF80146A6C() { ... }
Zero blast radius; byte-neutral by construction. `.run/alias_defs.py` applies it to a staged set.
S33 proved this once on `func_80147364` (×137 first try, 1,725 in-tree precedents) — **it was never
generalised.** Generalised run: 971 drafts → 192 files → R22 140/140 (after 1 revert).

⚠️ TWO R22 FAILURES — "per-binary BANKED" IS NOT A FLEET CLAIM (§61)

Both passed their per-binary/per-draft gate and FAILED the clean-tree rebuild:

ov_SC07_010 (S3) — its -O0 split reused an EXISTING _o0c instead of a fresh _o0d, creating region _jr_801457A4 whose asm dir splat never generated. Reverted; still open.
ov_SC06_030 (S1d) — D_800AF648' undeclared in func_8017E120: a draft that gated fine broke once the REST of the harvest landed in the same TU (its decl displaced by another banked draft's preamble). Reverted. In a WIDE harvest, per-draft acceptance is not even a per-TU claim. The narrow 138/138 run was clean BECAUSE it was narrow ⇒ prefer smaller batches.

✅ T7 PROGRESS

task	result
S1a lift local types	DONE — 895 types / 1,259 files
S1c re-sweep families	DONE — 97 members
S1b "wire the reconcile"	PREMISE REFUTED — already wired; NSD re-tested post-fix = 0
S2 jr families	DONE — 10 members; 7 families now CLASSIFIED
S3 the whale	✅ COMPLETE — 138/138 (S39). `ov_SC07_010` closed: `o0_subsplit --lo 0x80144B9C --hi 0x801457A4` (1 stub, 0 already-matched in range ⇒ no §126 island; 3 regions, `_o0c` free) → split byte-neutral → banked via `../shared/func_80144B9C.h` → R22 140/140 clean-tree, fleet instr +770 (12,405,402 → 12,406,172). The S38 cause ("reused an existing `_o0c`") did not recur — `o0_subsplit.free_letters` picks an unused suffix. Two decl conflicts hit on the way, enumerated with `cdecl` in ONE pass (R33) instead of one build at a time: of the header's 94 symbols the §8b carried layer re-declared 3, and 2 conflicted (`D_801274D0` `s32()(s32)`, `D_801274CC` `void` vs header `s32`) — dropped, matching all 137 precedents (0 of them carry either), byte-neutral per §8c. The 61 SC07 `-O0` members remain NOT attempted.
S1d the alias class	138/138 on family 1; generalised harvest committed w/ the accounting caveat
S1e (#11)	✅ RESOLVED — THE REGRESSION NEVER HAPPENED (S39). The `commit:1426` digest was committed STALE (generated from a tree still holding work reverted before the commit landed; overstated +7,879 ins / +130 uniq, never regenerated), so the next honest digest read as a fall. True delta 843→HEAD: instr +10,869 · distinct +2,776 ins / +57 uniq — everything ROSE. HEAD's digest reproduces EXACTLY. ⇒ THE ALIAS LEVER IS UNGATED — scale it (§61 small batches). Both recorded leads were wrong (R14): `progress.py:423`'s `SIG` feeds fn-count only, and "reverted to INCLUDE_ASM" died on one grep (483 removed, 0 added). Fixes: `stub_addrs` no longer swallows `corpus.stubs` (the bare `except` byte-witnessed reporting 100.00%/100.00% in a tree with no `asm/`); NEW `make audit-digest` in `tools-health` (integers, not percentages — the staleness printed as "94.4%" both sides), negative-control-proven vs the stale digest; the SAME swallow fixed in `cast_call_sites.tu_for` + `reconcile_tu.tu_for`, where it reconciled against the wrong TU (the bug that file's own docstring exists to fix). cookbook §140 · decision-log 2026-08-04.
S4 draft-recovery	🔄 IN PROGRESS (S39) — the 6 open wave-6 drafts triaged; 4 BANKED (+1,905 ins), R22 140/140. `func_801919A0` (ov_SC06_032, 710) · `func_80189030` (ov_SC03_001, 557) · `func_801878E8` (ov_SC04_018, 513) · `func_8018A564` (ov_SC02_027, 125). ⚠️ THE FINDING: all four banked UNCHANGED — no new work on the drafts. S38 recorded them blocked on a class needing a fix ("cracking this one class frees 6 drafts at once"); they were already freed by S38's own tool repairs (the `jr_isolate_all`/`overlay_src_split` alias-DELETION blindness + `harvest_verify._reload_corpus`). The drafts were correct; the instruments were failing them. ⇒ RE-GATE STORED DRAFTS AFTER ANY TOOL REPAIR before treating a stored verdict as a fact about the code — this is the 5th "wall" this phase to resolve to our own tooling. Note each bank also did a jtbl carve ⇒ config touched ⇒ fleet blast radius (R22 mandatory, run). Left on the backlog as GENUINE codegen residuals (not forced, P9): `func_8017C974` (ov_SC01_077, 947, close=47 REGALLOC-PERM, 12 permuter variants inert) · `func_80188C68` (ov_SC03_124, 551, close=370, no twin anywhere). Family propagation DONE: `func_801878E8` 4/4 siblings BANKED (+2,052 ins, ~0 agent tokens) via `jtbl_family_bank.py` — `family_sweep --hseq` had correctly REFUSED it (§53 interlock: `has_mid_jr` ⇒ jtbl carve route, "a 0% from this path would be a TOOL artifact, not a wall"), and the tool requires a CLEAN tree (it reverts from HEAD per sibling), so the ×1 banks had to commit first. R22 140/140. Stored-draft re-gate MEASURED (S39, `docs/calibration.md`): A10's "0/958" was re-tested after S38's tool repairs — fresh wave-6 drafts 4/6 · unbiased stored sample 1/12 · the two REVERTED overlays 3/17 (+146 ins banked: `ov_SC06_030` func_80161208/func_80162CCC, `ov_SC07_010` func_801506A4/func_8016F0AC; R22 140/140, incl. a fleet-wide `engine_core.h` no-proto arity edit proven byte-neutral). A10 broadly STANDS — ~8% on the general pool is not a harvest and a 1,155-wide sweep (1,155 whole-binary builds) is NOT justified. The real rule: re-gate the drafts a repair plausibly touched, targeted by its blast radius — not the whole ledger. Still to do in S4: the 39 draft-exemplar families (382 members) + the 2 resident stubs with gate-rejected match_one-MATCH drafts.
S5 · S6 · S7	pending

▶ RESUME HERE

~~S1e (task #11) FIRST~~ ✅ DONE (S39) — no regression existed; the alias lever is ungated and is the cheapest large lever on the board. Both recorded leads were wrong (R14): the progress.py:423 SIG lead feeds fn-count only (neither weighted metric sees a C identifier — they derive from matched = sig − corpus.stubs), and the "reverted to INCLUDE_ASM" theory died on one grep (483 removed, 0 added). Still worth doing opportunistically: the SIG alias blindness is REAL for fn-count — resolve a def through its __asm__ label via overlay_src_split.asm_label_aliases (R33, reuse it) rather than a new regex.
~~ov_SC06_030 + ov_SC07_010~~ ✅ DONE (S39). ov_SC07_010 whale banked → 138/138, R22 140/140, +770 ins. ov_SC06_030/func_8017E120 needed nothing — it is already banked (defined at ov_SC06_030_jr_8017C8D0.c:3491); what S38 reverted was the surrounding batch, not that function. Metric note (R30, same class as S1e): a body banked by #include-ing a shared header is invisible to fn-count's numerator (the definition is not in the .c) while removing its stub from the denominator — the whale bank moved fn-count 341186/353718 → 341186/353717. The weighted metrics counted it correctly (+770) because they derive from corpus.stubs, not from re-parsed C. Same root as S1e: classify() re-parses C and inherits blindness; trust the weighted pair. Still open here: the 61 SC07 -O0 members (S3's untouched half).
S4 (task #6) + wave 6's 3 still-failing alias drafts (the three LARGEST — size-correlated).
S5 the wave (task #7) — 1,689 h_norm clusters / 326,261 ins at 2.7×. VERIFY Fable's pool numbers first (R14), ONE 8-target calibration wave, measure REALIZED propagation. Prompt for the toggle (R27).
S6/S7 — the 2 giant exemplar walls (50,094 ins on 2 cracks); then main (regen its 7-week-stale sig FIRST — missing 757 of 2,002 stubs).

🧰 ELEVEN TOOL DEFECTS FIXED — nine of the ten "walls" were our own instruments

harvest_verify._reload_corpus (deleted the stub it had just followed through a carve → 10 of wave 6's 16 drafts vanished with no verdict) · .run/s6f_gate.py (booked a crash as silence; now asserts 1:1 accounting + exits 1) · classify_fail (truncated the symbol away) · jr_isolate_all/ overlay_src_split (silently DELETED def-side alias functions — FIFTH tool with that blindness, fixed in family_remap and never propagated) · partition/_partition (now REFUSE to rewrite when an address won't resolve, R32) · the type-scope class (895 types lifted) · jtbl_family_bank (gate-fail with no reason) · family_hseq stdout (overlays-only called "fleet") · my own alias scanner (the §134 defect I documented that morning — caught by the R32 guard I added that morning) · the S3 ambient filter's endswith(';') (§134 again). §134 has appeared in SIX tools. The fix is routing every line-shape decision through cdecl._mask (R33), not a seventh patch.

🧰 MY PROCESS ERRORS

Claimed family_sweep hides per-member errors — FALSE; 23,211 .classified.txt files exist and both of the day's zeros were already diagnosed in them. Two probes wasted. READ THE PAYLOAD FIRST.
Called 4 families "chance collisions" while my own printout showed them PURE/IMM.
Reverted config/ and re-extracted ONE overlay of sixteen — a gate cycle read 3 real banks as failures against stale asm (the Phase-20 R22 corollary).
A backticked `make extract` in a -m message EXECUTED — use quoted heredocs.
… | tail swallowed a non-zero exit, and later tail -5 destroyed a gate summary I then could not report. A pipeline's status is the LAST command's; don't pipe away evidence.
Looked a just-banked head up in members — it moves to exemplar.kind='matched'.
Reported "138/138" for the whale before R22 spoke — it was 137/138. No bad bytes from any of them — the byte-gate and R22 caught everything.

🛑 (superseded) SESSION-38 CHECKPOINT v3 — POST-S1/S2/S3

NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN but for the R23 db.*.gbf churn — never stage. Effort xHigh. R22 clean-fleet run TEN times; 140/140 on nine, ONE REAL FAILURE (see S3). NO phase close — keep grinding. Plan = T7; full report .run/fable_frontier/ANALYSIS.md. VERIFY BEFORE TRUSTING: git log --oneline -3 at/near HEAD + docs/progress.fleet.md agrees.

FLEET — R22 140 passed / 0 failed of 140

96.32% fn-count · 94.4% instr-weighted · 89.3% distinct-code (78,025 uniq) · 0 NON_MATCHING. Session opened 96.28 / 94.1 / 88.7 ⇒ +34,176 instructions (12,368,236 → 12,402,412), the great majority for ~0 agent tokens — instrument repair, not drafting.

✅ T7 PROGRESS

task	result
S1a lift local types	DONE — 895 types / 1,259 files; killed the type-scope class
S1c re-sweep matched-exemplar families	DONE — 97 members (were 0)
S1b "wire the reconcile"	PREMISE REFUTED — already wired; `--normalize-self-decls` re-tested post-fix = 0 banks
S2 jr families via `jtbl_family_bank`	DONE — 10 members; 7 families now CLASSIFIED
S3 the whale	DONE-PARTIAL — 137/138 (3 of 4 SC07s); `ov_SC07_010` reverted, still open
S1d · S4 · S5 · S6 · S7	pending — see the task list

⚠️ THE ONE R22 FAILURE — READ THIS BEFORE TRUSTING ANY PER-BINARY "BANKED"

ov_SC07_010 passed its per-binary build and FAILED the clean-tree R22 (139/140). Its -O0 split landed in an EXISTING _o0c file instead of a fresh _o0d, creating region _jr_801457A4 whose asm dir splat never generated. Reverted; the overlay is still open. A per-binary pass is NOT a fleet byte claim (§61) — committing on that "BANKED" would have shipped a broken overlay and reported 138/138. This is the whole reason R22 exists.

🔑 S3'S REAL MECHANISM — the plan's framing was WRONG, do not repeat it

Recorded as "the T2 Arm-A %lo +0x20 carve defect". The carve was never broken — o0_subsplit reported split byte-neutral ✓ on the FIRST attempt in all four. The blocker: carving the whale out of a jr file makes jr_isolate_all hoist the parent's file-scope decls into the new region as its ambient set, so the fleet's loose-typed spellings share a TU with the shared header's for the first time (extern void *D_801274CC vs the header's extern s32 D_801274CC). In the 134 working overlays the whale sits in a CLEAN -O0 file (common.h + the header, nothing else) and they never meet. Fix: drop the ambient duplicates in that one file — the header is the byte-proven side. Three iterations, each a DECLARATION: data syms → function syms → the alias form ending in a trailing COMMENT (§134 comment-blindness, the THIRD time today).

🧰 TEN TOOL DEFECTS FIXED — every "wall" today was our own instrument

harvest_verify._reload_corpus re-applied --src after a carve → deleted the stub it had just followed → uncaught KeyError → _jtbl_restore never ran → stranded carve; 10 of wave 6's 16 drafts vanished with no verdict.
.run/s6f_gate.py never checked the child rc — a crash read as silence. Now asserts banked+failed+no-verdict == drafts, prints rc + tail, exits 1.
classify_fail truncated diagnostics from the LEFT, severing the symbol.
jr_isolate_all/overlay_src_split silently DELETED definition-side __asm__-alias functions (addr_of resolves by C name; an alias def is spelled aF…). Fifth tool with that blindness — family_remap fixed it and never propagated it.
partition/_partition now REFUSE to rewrite a file when an address won't resolve (R32).
The type-scope class — 895 types lifted, class gone.
jtbl_family_bank reported gate-fail with no reason (only stage-construction errors were captured, never the build's).
family_hseq stdout called an OVERLAYS-ONLY number "fleet".
My own alias scanner had the §134 defect I documented that morning — greedy [^;{}]* over unmasked source matched from inside a comment and swallowed the real decl. Caught by the R32 guard from #5, on its first real encounter. Fixed via cdecl._mask (scan the MASK, read the symbol from the SOURCE — rejecting after the fact does not work, finditer resumes past the swallowed decl).
The S3 ambient-decl filter's endswith(';') skipped comment-terminated lines (§134 again).

THE STANDING LESSON: every wall today was a tool keyed on the wrong thing — verdicts by grep not accounting · stub location by --src not the tree · a banked head by members not exemplar · a definition by C name not emitted symbol · a type by where it sat in a file · a line-shape by a test a comment invalidates. §134 has now appeared in SIX tools; the real fix is routing every line-shape decision through cdecl._mask (R33), not another per-tool patch.

▶ RESUME HERE

S1d (task #10) — the two dominant conflict symbols, ~383 member failures. func_80146A6C: fleet decls UNIFORM ⇒ the DRAFT is wrong (bug hunt; work out why cast_call_sites, which runs at family_sweep.py:632, is not already resolving it). func_80161208: FOUR incompatible fleet shapes ⇒ the genuine Phase-16 loose-typing wall; candidate = the §37/§124 definition-side alias.
ov_SC07_010 — force a FRESH _o0 region instead of reusing _o0c, then re-run .run/s3_sc07_whale.py (it self-skips the 3 already banked). Also: the 61 SC07 -O0 members in S3's original scope were never attempted.
S2 residue — .run/jrprop/*.log: 2 families isolate-fail, 1 carve-fail (tool refusals, likely routable); only 2 members are genuine DIFF.
S4 (task #6) + wave 6's 3 still-failing alias drafts (the three LARGEST — size-correlated).
S5 the wave (task #7): 1,689 h_norm clusters / 326,261 ins at 2.7×. VERIFY the pool numbers first (Fable's, unverified — R14), ONE 8-target calibration wave, measure REALIZED propagation before scaling. Prompt Drew for the toggle (R27).

🧰 MY PROCESS ERRORS

Claimed family_sweep hides per-member errors — FALSE, 23,211 .classified.txt files exist and both of the day's zeros were already diagnosed in them. Two probes wasted.
Called 4 families "chance collisions" while my own printout showed them PURE/IMM.
Reverted config/ and re-extracted ONE overlay of sixteen — a gate cycle read 3 real banks as failures against stale asm.
A backticked `make extract` in a -m message EXECUTED — use quoted heredocs.
… | tail swallowed a non-zero exit — a pipeline's status is the LAST command's.
Looked a just-banked head up in members — it moves to exemplar.kind='matched'.
Reported "138/138" before R22 — it was 137/138. See the R22 failure above. No bad bytes from any of them — the byte-gate and R22 caught everything.

🛑 (superseded) SESSION-38 CHECKPOINT v2 — POST-S1/S2

NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN but for the R23 db.*.gbf churn — never stage. Effort: xHigh (Drew set it for the eventual S5 wave; the S1/S2 work was deterministic). R22 clean-fleet run SEVEN times this session, 140/140 every time. Drew's standing decision: NO phase close — keep grinding. Plan = T7 (the Fable-5 plan); full report at .run/fable_frontier/ANALYSIS.md, pools at pool_ovres.json. VERIFY BEFORE TRUSTING: git log --oneline -3 should show this at/near HEAD and grep -E 'FLEET (fn-count|instr|distinct)' docs/progress.fleet.md must agree below. Digest wins.

FLEET — R22 140 passed / 0 failed of 140

96.32% fn-count · 94.3% instr-weighted · 89.1% distinct-code (77,884 uniq) · 0 NON_MATCHING (G4). Session opened 96.28 / 94.1 / 88.7 ⇒ +19,300 instructions, the great majority for ~0 agent tokens (instrument repair, not drafting).

WHAT S38 ACTUALLY WAS: EIGHT TOOL DEFECTS, NOT A COMPILER PROBLEM

Every "wall" hit today was our own tooling keyed on the wrong thing. In order:

harvest_verify._reload_corpus re-applied --src after a carve → deleted the stub it had just followed → uncaught KeyError → _jtbl_restore never ran → stranded carve → later gate groups built against a mutated tree. 10 of wave 6's 16 drafts vanished with no verdict.
.run/s6f_gate.py never checked the child's rc — booked a crash as silence. Now asserts banked+failed+no-verdict == drafts, prints rc + output tail, exits 1.
classify_fail truncated diagnostics from the LEFT, severing the symbol name.
jr_isolate_all / overlay_src_split SILENTLY DELETED definition-side __asm__-alias functions during a repartition (addr_of resolves by C name; an alias def is spelled aF…). → 3 wave-6 drafts recovered instantly. Fifth tool with this same blindness — family_remap fixed it and the fix was never propagated.
partition/_partition now REFUSE to rewrite a file when a construct's address won't resolve (R32) instead of dropping it.
The type-scope class — a remapped body names the exemplar's TU-local types → parse error, never reaches codegen. 895 types lifted fleet-wide → the class is gone.
jtbl_family_bank reported gate-fail with NO reason (only stage-construction errors were captured, never the build's). Fixed → S2's failures are now classified.
family_hseq's stdout called an OVERLAYS-ONLY number "fleet".

✅ T7 PROGRESS

task	result
S1a lift local types	DONE — 895 types / 1,259 files
S1c re-sweep matched-exemplar families	DONE — 97 members banked (were 0)
S1b "wire the reconcile"	PREMISE REFUTED — nothing to wire (see below)
S2 jr families via `jtbl_family_bank`	DONE — 10 members banked, 7 families classified
S1d, S3–S7	pending — see the task list + T7

S1b is closed by measurement: cast_call_sites is ALREADY called in hseq_sweep (family_sweep.py:632, default-on), as are tu-scope §103 and scope_data_fix. And --normalize-self-decls — whose only negative (0/1,622) its own author proved was a tool artifact — got a fair post-fix re-test: 0 banks + repeated "self-decl edit NON-NEUTRAL → reverted TU". It also targets the wrong axis (the target's OWN decl; the residue conflicts are on callees/data).

🎯 THE REAL RESIDUE — TWO SYMBOLS, 383 of ~398 CONFLICTS (→ task S1d)

func_80146A6C (208) — the fleet is UNIFORM (4,262 decls of extern s32 func_80146A6C(s32,void*,s32,s32,s32,s32,s32) + 297 unnamed-param copies of the same types), so the TU is right and the templated draft carries the bad decl. A draft-side bug hunt, NOT a new lever — and work out why cast_call_sites is not already resolving it.
func_80161208 (175) — the fleet genuinely disagrees: s32 f() ×3730 · int f() ×1775 · s32 f(void) ×1517 · s32 f(void*) ×138. That is the Phase-16 loose-typing wall, not plumbing. Candidate: the §37/§124 DEFINITION-side asm-label alias (zero blast radius). Probe one member.

▶ RESUME HERE (cheap deterministic lanes still pay; the wave costs ~20M tokens)

S3 — the SC07 carve (task #5): the whale 0x80144b9c is matched in 134/138 overlays and open ONLY in the 4 SC07s = 3,080 ins of BYTE-IDENTICAL code blocked by the T2 Arm-A %lo +0x20 defect. ~0 tokens.
S1d (task #10) — the two symbols above, worth ~383 member failures.
S2 residue — .run/jrprop/*.log: 2 families isolate-fail, 1 carve-fail (tool refusals, likely routable); only 2 members are genuine DIFF.
S4 (task #6) — 39 draft-exemplar families + the 2 resident stubs with match_one-MATCH drafts already gate-rejected for TU plumbing; plus wave 6's 3 still-failing alias-class drafts (func_80189030 / 801878E8 / 801919A0 — the three LARGEST, so the residual cause is size-correlated).
S5 — the wave (task #7): 1,689 open-only h_norm clusters / 326,261 ins at a 2.7× multiplier. VERIFY the pool numbers first (Fable's, unverified — R14), then ONE 8-target calibration wave measuring REALIZED propagation before scaling. Prompt Drew for the toggle (R27).

🧰 MY PROCESS ERRORS THIS SESSION

I claimed family_sweep hides the per-member error. FALSE — 23,211 .run/hseq_failed.*.classified.txt files exist and both of the day's zeros were already diagnosed in them. I asserted a tool limitation without looking, then spent two probes and a manual --stage-only round rediscovering one. Read the payload first.
I called 4 families "chance collisions" while my own printout showed them PURE/IMM — and PURE means every differing word is at a RELOC position, the opposite of chance. Refuted by Fable.
I reverted config/ and re-extracted ONE overlay of sixteen (the Phase-20 R22 corollary), so a whole gate cycle measured against stale asm and read 3 real banks as failures.
A backticked `make extract` in a -m commit message EXECUTED — corrupted the message and ran a real extract. Use quoted heredocs. (No damage; re-committed.)
family_sweep … | tail swallowed a non-zero exit — a pipeline's status is the LAST command's.
I looked a just-banked head up in its family's members list — a banked head LEAVES members and becomes exemplar.kind='matched'. No bad bytes from any of them — the byte-gate and R22 caught everything.

🛑 (superseded) SESSION-38 CHECKPOINT v1 — wave 6 banked + the gate defect fixed

NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN but for the R23 db.*.gbf churn — never stage. Effort: high (Drew lowered from ultracode as an experiment; he will enable xHigh for wave 7). R22 clean-fleet run TWICE this session, 140/140 both times. Drew's standing decision: NO phase close — keep grinding. Next: wave 7 at ~50k templ ins (Drew's explicit direction: "chase that 50k like you tried"; he toggles xHigh when it is staged). VERIFY THIS BLOCK IS CURRENT BEFORE TRUSTING IT: git log --oneline -3 should show this checkpoint at/near HEAD, and grep -E 'FLEET (fn-count|instr|distinct)' docs/progress.fleet.md must agree with the FLEET line below. If they disagree, the digest wins (R35). Nothing is owed. All 16 wave-6 drafts are gated; the 9 unbanked are diagnosed and preserved.

FLEET — R22 140 passed / 0 failed of 140

96.29% fn-count · 94.2% instr-weighted · 88.9% distinct-code (77,796 uniq) · dedup 1910/0 · 0 NON_MATCHING (G4). Session opened 96.28 / 94.1 / 88.7 ⇒ +10,616 instructions banked (12,368,236 → 12,378,852 — the digest delta matches the hand-derivation EXACTLY). Phase opened 92.00 / 87.5 / 78.0 ⇒ +4.29pp fn, +6.7pp instr, +10.9pp distinct.

WHAT THIS SESSION DID

lane	result
wave 6 (16 tgt / 50,596 templ ins)	7 heads banked, 9 refused-and-diagnosed
propagation (5 jr-families, carve path)	25 of 38 sibling slots (15+3+3+2+2)
instrument repair	4 defects fixed — see below

⚠️ THE HEADLINE IS NOT THE BANK COUNT — THE GATE WAS BOOKING CRASHES AS SILENCE

Wave 6's first gate printed BANKED 5 / FAILED 1 over 16 drafts. Ten produced no verdict at all, nine of them claiming MATCH, and the tally looked clean. Chain (cookbook §139):

harvest_verify._reload_corpus re-applied the --src filter AFTER a jtbl carve — deleting the very stub it had just followed to its new TU, which is that function's whole documented purpose. → KeyError in render() → UNCAUGHT → _jtbl_restore(snap) never ran → carve STRANDED in config/+src/ → every LATER group in the same gate then built against a mutated tree.
.run/s6f_gate.py never checked the child's returncode — it grepped stdout for two line-prefixes and booked "neither" as nothing (the §136a defect, in the gate itself). Both fixed. The gate now asserts banked+failed+no-verdict == drafts, prints the child's rc + output tail, and exits 1 (a crashed child may have stranded a carve). Proof it was not cosmetic: func_8017EA84 (579 ins) banks BYTE-IDENTICAL under the fixed path — reported as NOTHING before. Also fixed: classify_fail truncated diagnostics from the LEFT, severing the symbol name that is the label's entire routing value (undefined reference to \func_801` ← cut at four hex digits). Now keeps both ends.

📌 THE 9 UNBANKED WAVE-6 DRAFTS — ALL DIAGNOSED, DRAFTS COMMITTED IN `.run/w6/`

6 are ONE class (the highest-value thing to fix next): undefined reference to a sibling that IS defined in the overlay but only through a definition-side __asm__ alias (void aF<X>(...) __asm__("func_<Y>"); — §37/§124). The carve repartitions the object and separates the call site from the alias definition. Worked example: func_801884D8 (ov_SC02_028) → func_80183AF8, whose definition is the alias aF8018A860 at _jr_8017D898.c:4753. Cracking this one class frees 6 drafts at once, and it will recur in every carve-heavy wave.

fn	overlay	class
func_801884D8	ov_SC02_028	undefined ref `func_80183AF8` (alias)
func_80189030	ov_SC03_001	undefined ref `func_80186F88`
func_801878E8	ov_SC04_018	undefined ref `func_801848DC`
func_80180B04	ov_SC06_020	undefined ref `func_80184F18`
func_801919A0	ov_SC06_032	undefined ref `func_8018B878`
func_801380E0	ov_SC07_006	undefined ref `func_80137614`
func_8018A564	ov_SC02_027	CC1-FAIL (Error 33) — different, needs its own read
func_8017C974	ov_SC01_077	genuine DIFF close=47, REGALLOC-PERM (947 ins, Opus, 12 variants inert)
func_80188C68	ov_SC03_124	genuine DIFF close=370 (551 ins, the only target with NO twin anywhere)

📊 `docs/wave-metrics.md` — Findings 5 and 6 added

Rank waves by INSTRUCTIONS, not heads. Wave 6 banked ~45% more instructions than wave 5 while banking less than half as many heads (10,616 exact vs ~7,200 est.), because a bigger head carries more instructions AND its family propagates at the same cost per sibling — func_8017FEE0, ONE 299-ins head, became 4,485 ins across 15 siblings for ~0 agent tokens. The metric to beat is POOL REALISATION (21%), not bank rate; wave 6's bank rate is not comparable to waves 3–5 because the difficulty knob moved deliberately (median target 438 ins vs 143, mostly has_mid_jr).

🔬 THE FAMILY FRONTIER — MY S38 READING WAS WRONG; CORRECTED HERE (Fable5 + byte-checked)

Superseded claims (do NOT act on them): "the ×138 era is over", "4 of the 8 big families collide by chance", "0x80175820 / 0x80132018 are not templatable", "the free-sweep zeros are undiagnosed", "family_sweep reports failures without the per-member error". Every one is refuted.

What is TRUE: the open-member DISTRIBUTION does skew small (5,792 families / ~702k open ins; 8 families at 100+, 1,534 at 2-4, 3,807 singletons). What is FALSE is the conclusion I drew from it. The map's own classify_member (family_remap.py:213) is a per-word diff with reloc tracking — PURE means every differing word sits at a RELOC position, i.e. the exact opposite of a chance collision. All four families I called "chance" classify PURE or IMM ×138. 0x80161418 has 552 already-matched siblings — that family has swept successfully before. The two "ledgered not-templatable" entries are contradicted too (0x80175820 IMM×137 / 7,535 ins; 0x80132018 PURE×132 / 6,072 ins). Only the 2 GIANT walls survive, and those are exemplar walls (close=91/110) whose 138 members each classify PURE — 50,094 ins ride on 2 cracks.

THE BASE RATE, which settles it: across ALL sweep runs' classified files, blockers are ~24k PLUMBING vs 4,917 DIFF — 5:1. Sweep failure in this project has ALWAYS been mostly plumbing. My "families don't template" reading had the base rate exactly backwards.

✅ BOTH S38 ZEROS DIAGNOSED — BOTH PLUMBING, BOTH ALREADY ON DISK

0x801833f0 0/6 → 6/6 (FIXED, banked, R22 140/140). Cause: the remapped body carries the EXEMPLAR's TU-local types (PTag_/Ft4_/Drm_801833F0); undeclared type ⇒ gcc-2.7.2 parses the declarator as an expression ⇒ parse error before 'vtx'. Never reached codegen. Fix = lift the types (lift_types --apply). This is §20's propagation cap on the h_seq sweep path.
0x80128c98 0/138: PLUMBING: conflicting types for 'cdFileLocTable' — the §103/§20 extern-conflict class. Also never reached codegen.
.run/hseq_failed.<ov>.<n>.classified.txt — 23,211 files — carried both diagnoses all along. My claim that the sweep hides the per-member error was FALSE and is struck (R37).

🎯 THE UNTARGETED POOL (Fable5, computed from sig+corpus — verify before scaling)

Open-only h_norm clusters: 1,689 clusters / 5,956 fns / 326,261 ins = 46% of ALL open overlay instructions, with a 2.7× propagation multiplier (exemplar 88,649 ins → propagated 237,612). Nobody has aimed a wave here.
h_exact pool: 250 open fns / 12,981 ins byte-identical to already-matched code — incl. the whale 0x80144b9c matched in 134/138 overlays, open only in the 4 SC07s (3,080 ins), blocked solely by the SC07 carve defect (T2 Arm-A +0x20).
main is structurally barren (zero h_exact overlap; different compiler era) — genuine agent tail. Its Ghidra sig is 7 weeks stale and missing 757 of 2,002 stubs — regen before pricing it.
2 of the resident's 14 stubs already have match_one-MATCH drafts in backlog.jsonl, gate-rejected for TU plumbing — same class.

📋 THE RANKED PLAN (tokens/instruction vs a 490 t/ins wave baseline)

#	strategy	reachable ins	tok/ins
S1	fix the 2 plumbing classes (typedef/macro gather + extern-conflict reconcile) → re-sweep the 148 matched-exemplar families	35-60k	~10-25
S2	jr matched-exemplar families via `jtbl_family_bank` (§53) — 11 fams / 52 members	10-18k	~0
S3	SC07 carve fix → whale ×4 + 61 SC07 o0 members	5-15k	~0
S4	draft-recovery on 39 draft-exemplar families + the 2 resident MATCHes	10-25k	~10-50
S5	re-aim waves at open-only h_norm cluster exemplars, sweep after every bank	up to 326k	~130-150
S6	the 2 GIANT exemplar walls (50,094 ins on 2 cracks)	50k	~50-200
S7	singleton tail + main (regen main's sig FIRST)	remainder	~490+
S1-S4 ≈ 80-115k ins moved from the 490-t/ins column to ~0, and S1 restores the propagation
multiplier that makes every later wave ~3× cheaper. DO S1 BEFORE ANY WAVE.

🚨 STANDING PRE-PROBE RULE (this session's cheapest lesson)

Before probing a family, check h_norm identity across its members from the sig files. If members are h_norm-identical, a 0% is a compile-error CERTAINTY, not evidence about codegen — it would have predicted both of today's zeros without spending a probe. And read .run/hseq_failed.*.classified.txt before theorising about any sweep failure.

▶ RESUME HERE — wave 7, ~50k templ ins (Drew's direction)

.venv/bin/python .run/w6_pool.py 16 .run/w7_wave.json — the pool derivation is a SCRIPT now (ranks by OPEN templatable weight from corpus.stubs, carries the walls/ledgered exclusions, drops previously-attempted-and-still-open addrs, one target per (overlay,TU)). Pool at this checkpoint: 2,928 fresh families / 476,611 open templ ins — nowhere near exhausted. Add wave 6's 9 unbanked addrs to its exclusion list (or fix the alias class first and re-gate them — that is 6 drafts already written and paid for).
Build the script from .run/w6.js (it is .run/s37w.js's pipeline block + the S37/W6 prose). Prompt Drew for /effort xhigh and WAIT for the toggle (R27) before launching.
Land: gate (.run/s6f_gate.py '.run/w7/*/func_*.c') → diagnose failures (.run/w6_diag.py, which runs the REAL gate path; s36_capture.py splices WITHOUT the carve and is wrong for jr targets) → propagate (family_sweep --hseq REFUSES has_mid_jr families by design — route those to .run/w6_jtbl_prop.py / jtbl_family_bank, and note it needs a CLEAN TREE between families) → R22 → commit → append a wave-metrics row.

🧰 MY PROCESS ERRORS — one mechanism: a tool answered a NARROWER question than I asked

I reverted config/ and re-extracted ONE overlay of sixteen. The Phase-20 R22 corollary (a reverted config needs make extract) — which I know. Three genuinely-banked functions then read as failures against stale asm. A gate result measured against stale asm is not a measurement.
family_sweep ... | tail swallowed a non-zero exit (--only wants comma-separated). A pipeline's status is the LAST command's — use pipefail/PIPESTATUS.
A backticked `make extract` inside a double-quoted -m commit message EXECUTED, corrupting the message and running a real extract. Re-committed with quoted heredocs (what I used everywhere else and lapsed on once). No damage — src/config verified clean vs HEAD.
I looked a just-banked head up in its family's members list and got "NO FAMILY" for all 5 heads family_sweep had just enumerated — a banked head LEAVES members and becomes exemplar.kind='matched'. (Distinct from §138 rule 4, which governs target SELECTION.)
jtbl_family_bank logs gate-fail per sibling without the underlying error — same "outcome without the payload that routes it" class as the classify_fail truncation. The 13 sibling failures are therefore unrouted. Worth fixing before a carve-heavy wave 7. No bad bytes from any of them — the byte-gate and R22 caught everything.

🛑 SESSION-33..37 CHECKPOINT (2026-08-04, wave 5 BANKED) — FRESH SESSION SAFE HERE

NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN but for the R23 db.*.gbf churn — never stage. Effort: ultracode. R22 clean-fleet run TWENTY times this session, 140/140 every time. Last CODE commit commit:1393 (wave-5 bank); this checkpoint commits on top of it. Drew's standing decision: NO phase close — keep grinding. VERIFY THIS BLOCK IS CURRENT BEFORE TRUSTING IT (it goes stale, and stale is worse than absent): git log --oneline -3 should show this checkpoint at or near HEAD, and grep -E 'FLEET (fn-count|instr|distinct)' docs/progress.fleet.md must agree with the FLEET line below. If they disagree, the digest wins — re-derive before scoping anything (R35). Nothing is owed. The 16 wave-5 drafts flagged in the previous checkpoint are BANKED.

FLEET — R22 140 passed / 0 failed of 140

96.28% fn-count · 94.1% instr-weighted · 88.7% distinct-code (77,765 uniq) · dedup 1910/0 · C1 241216/241216 · 0 NON_MATCHING (G4). Session opened 96.01 / 93.6 / 88.0 ⇒ +0.27 / +0.5 / +0.7pp. Phase opened 92.00 / 87.5 / 78.0 ⇒ +4.28pp fn, +6.6pp instr, +10.7pp distinct.

WHAT THIS SESSION DID

lane	result
SC07 EXTEND	0/36 → 31/36
PROPAGATE head	0 → 18,545/18,545 ins (5/5 classes)
wave 1 (17 tgt)	15 banked + 65 members
wave 2 (13 tgt)	10 banked + 18 members
wave 3 (13 tgt)	13/13 + 21 members
wave 4 (14 tgt)	14/14 + 26 members
wave 5 (16 tgt)	16/16, ZERO reconcile + 26 members
reconcile lane	21/22 lifetime

📊 NEW: `docs/wave-metrics.md` — the wave performance log (Drew asked for this)

Wave-by-wave targets / tokens / wall-clock / parallelism / bank rate, with the derivation commands so future rows are COMPUTED not transcribed (R33). Append a row after every wave. Four findings, each with its caveat recorded rather than as a bare number:

The prompt is the lever, and the agents write it — 76→77→100→100→100% with models and gate held constant. The jump was STEP 0 (magic-literal grep of src/, ahead of engine_core.h), which came from a wave-2 agent's index_gap report. Caveat: waves 3–5 targets also trended easier; the mechanism is the durable claim, not the exact %.
pipeline() beats batched parallel() — 136 min/14 tgt → 82 min/16 tgt, 2.5×→3.8×. The two-batch design was a hard barrier (37–50 min dead gaps); the harness already caps at 16. Copy .run/s37w.js's execution block for every future wave. Floor: the slowest agent is still ~50 min of real match_one iteration ⇒ the lever is target SELECTION, not concurrency.
Economics — ~170–300k tokens/banked head, but the unit of value is head + propagated members, and sweep yield is bimodal not average (21/21 vs 18/165) because it is a property of the FAMILY.
A perfect gate means the prompt rules landed — waves 1–4 each needed 1–2 post-gate reconciles; wave 5 needed none. The reconcile lane is the fallback, not the plan.

📌 THE DISTILLED RULES (cookbook §138 + index; memory `wave-prompt-seed-step0-and-gaps`)

Bucket a gate refusal by the (macro-shape, TU-shape) PAIR, not the SYMBOL.
Reconcile direction depends on WHERE the TU's decl is — ABOVE the splice ⇒ DELETE your duplicate (§100); BELOW ⇒ KEEP a decl in the TU's EXACT shape and cast at the use (§17a-1 D2). A wave can manufacture this for itself: two targets in one TU means the first to bank puts its type tags in the second's way.
STEP 0: grep -rn "<MAGIC>" src/ with a distinctive literal from the .s, ahead of engine_core.h — the only step that reaches a banked twin in ANOTHER overlay's TU.
Never rank off the family map's exemplar field — derive open sites from corpus.stubs (measured 16,696 ins → 41,023 on the same map).
Three carry variants hide in one "CARRY-FIXABLE" bucket — multi-line comment (fix the tool) · draft-local struct Tag (use the shared type) · file-scope static inline helper (hand-author + EXCLUDE the source overlay).

🔬 SETTLED — do not re-litigate

func_801758FC / func_80132018 / func_8018A808's families are NOT templatable. Probed (.run/s6_diag.py, 2 builds): remapped member is BUILD OK + byte diff ⇒ genuine per-member codegen. The h_seq refusal ceiling, confirmed.
_alias_decl_for was ONE function, not a class (91 alias decls fleet-wide, 90 already matched).
"normalized distance 0" is NOT an h_exact guarantee — relocs are masked.

▶ RESUME HERE — wave 6, nothing blocked

Regenerate the map, then derive the pool the corpus.stubs way (rule 4). Pool at the last regen: 852 families / 225,217 ins. Exclude the 3 walls (0x801412a8, 0x80178004, whale 0x80144b9c) and the ledgered residuals (0x8017c294 close=12, 0x8017f7b4, 0x801898e4, 0x80186e24 close=187, 0x801758fc, 0x80132018, 0x8018a808).
Build the script from .run/s37w.js (pipeline block + the accumulated extra prose), 16 targets. Launch → gate (.run/s6f_gate.py '.run/<w>/*/func_*.c') → capture any failure (.run/s36_capture.py <ov>:<fn>) → reconcile per rule 2 → make sig-overlays + family_hseq.py + family_sweep --hseq --band all --only <addrs> → R22 → commit → append a row to docs/wave-metrics.md.
EXTEND's last 5: func_80144B9C ×4 needs the §38 -O0 shared-header route (and dedup_extend should refuse-and-name that class per R32); func_80149954 ×1 sits behind func_80147364's u16 params.

🧰 MY PROCESS ERRORS — one mechanism: the signal sampled was not the thing measured

nohup CMD & inside a backgrounded call ⇒ the harness signalled the WRAPPER; the fleet check stood at 63/140 and I nearly read it as a pass.
pgrep -x make is right for ONE make, WRONG for a campaign of sequential makes; pgrep -f SELF-MATCHES so that waiter never exits. Use the campaign's real argv or treelock.sh --status.
A corpus.stubs probe mid-rebuild returned garbage; R32's assertion refused to answer.
I predicted a fix without reading the macro in front of me (relaxed 42 (void) decls; that macro declares (u8*) — banked 0/1 in all 134) → the PAIR rule.
I violated §136a in my own capture tool — a narrow keyword filter reported "NO COMPILE ERROR" on a build failing with redefinition of struct PW8017C290. No bad bytes from any of them — the byte-gate and R22 caught everything.

🛑 (superseded) SESSION-33..37 CHECKPOINT (2026-08-04) — pre-wave-5-bank

NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN but for the R23 db.*.gbf churn — never stage. Effort: ultracode. R22 clean-fleet run NINETEEN times this session, 140/140 every time. Drew paused here to restart Windows. Drew's standing decision: NO phase close — keep grinding.

⚠️ THE ONE THING THAT IS OWED: 16 UNGATED WAVE-5 DRAFTS

.run/s37/*/func_*.c — 16 drafts, all claiming MATCH, NONE gated, NONE banked. They are force-added to git (.run/ is otherwise gitignored) because they cost ~2.7M agent tokens and the Workflow resumeFromRunId cache is SAME-SESSION-ONLY, so it does not survive the restart. Resume by gating them — do not re-run the wave:

tools/treelock.sh g .venv/bin/python .run/s6f_gate.py '.run/s37/*/func_*.c'

then: capture any failure (.venv/bin/python .run/s36_capture.py <ov>:<fn> — it ranks HARD errors above warnings) → reconcile per the §138 direction rule → make sig-overlays + tools/family_hseq.py + family_sweep --hseq --band all --only <banked addrs> → R22 → commit. Manifest: .run/s37_wave.json (16 targets / 16,884 templatable ins). Script: .run/s37w.js.

FLEET (at the last commit, before the ungated drafts)

96.27% fn-count · 94.1% instr-weighted · 88.6% distinct-code (77,723 uniq) · dedup 1910/0 · C1 241216/241216 · 0 NON_MATCHING (G4). HEAD commit:1391 + this checkpoint. Session opened 96.01 / 93.6 / 88.0. Phase opened 92.00 / 87.5 / 78.0 ⇒ +4.27 / +6.6 / +10.6pp.

WHAT THIS SESSION DID

lane	result
SC07 EXTEND	0/36 → 31/36
PROPAGATE head	0 → 18,545/18,545 ins (5/5 classes)
wave 1 (17 tgt)	13 heads + 65 members + 2 reconciled
wave 2 (13 tgt)	9 heads + 1 reconciled + 18 members
wave 3 (13 tgt)	13/13 + 21 members
wave 4 (14 tgt)	14/14 + 26 members
wave 5 (16 tgt)	16/16 claimed — UNGATED, see above
reconcile lane	21/22 lifetime

🔑 THE RESULT WORTH KEEPING: the wave prompt is the lever, and agents write it

Bank rate, same models and same gate — the prompt was the only variable: 76% → 77% → 100% → 100% (wave 5 pending its gate). The jump came from STEP 0: grep -rn "<MAGIC>" src/ with a distinctive literal from the target .s, placed AHEAD of engine_core.h in §136c's search order. §136c's first two steps are same-TU/shared-header scoped and structurally CANNOT reach a banked twin in another overlay's TU — where the big template classes live. That step came from a wave-2 agent's index_gap report. By wave 4 most agents cited it by name and reported index_gap: none. → memory wave-prompt-seed-step0-and-gaps; cookbook §138.

⚡ THE `pipeline()` FIX — measured, not assumed (Drew asked why waves were slow)

The two-batch parallel() design was a hard barrier: batch 2 could not start until batch 1's slowest agent finished.

	wave 4 `parallel()`	wave 5 `pipeline()`
targets	14	16
wall-clock	136 min	82 min
parallelism	2.5×	3.8×
median agent	14 min	9 min
40% faster on 14% more targets. `.run/s37w.js` is the pipeline version — copy its execution
block for every future wave. (Slowest single agent is still ~50 min; that is real `match_one`
iteration, 200-300 turns, and is the irreducible floor now.)

📌 THE DISTILLED RULES (cookbook §138 + index; all measured this session)

Bucket a gate refusal by the (macro-shape, TU-shape) PAIR, not the SYMBOL — the same symbol conflicts in BOTH directions across the fleet.
Reconcile direction depends on WHERE the TU's decl is. ABOVE the splice ⇒ DELETE your duplicate (§100); BELOW ⇒ KEEP a decl in the TU's EXACT shape and cast at the use (§17a-1 D2). Picking wrong CREATES the next error. A wave can manufacture this for itself: two targets in one TU means the first to bank puts its type tags in the second's way (wave 4's only failure).
STEP 0 magic-literal grep (above).
Never rank off the family map's exemplar field — it is IN-FAMILY and can name an ALREADY-BANKED instance. Derive open sites from corpus.stubs: 16,696 ins → 41,023 on the same map.
Three carry variants hide in one "CARRY-FIXABLE" bucket — multi-line comment (fix the tool) · draft-local struct Tag (use the shared type) · file-scope static inline helper (hand-author + EXCLUDE the source overlay; gcc-2.7.2 accepts implicit decls so it passes compiles_standalone and only fails 137 gates later).

🔬 SETTLED — do not re-litigate

func_801758FC / func_80132018 are NOT templatable. Probed with .run/s6_diag.py (2 builds): the remapped member is BUILD OK + byte diff ⇒ genuine per-member codegen. The h_seq refusal ceiling, confirmed. Same for func_8018A808's family (0/14).
_alias_decl_for was ONE function, not a class (91 alias decls fleet-wide, 90 already matched).
"normalized distance 0" is NOT an h_exact guarantee — relocs are masked.

▶ RESUME ORDER

Gate .run/s37/*/func_*.c (above) → reconcile → propagate → R22 → commit.
Wave 6: derive the corpus.stubs way (rule 4) from a REGENERATED map. Pool at pause: 852 families / 225,217 ins. Exclude the 3 walls (0x801412a8, 0x80178004, whale 0x80144b9c) and the ledgered residuals (0x8017c294 close=12, 0x8017f7b4, 0x801898e4, 0x80186e24 close=187, 0x801758fc, 0x80132018, 0x8018a808). Use .run/s37w.js's pipeline block.
EXTEND's last 5: func_80144B9C ×4 needs the §38 -O0 shared-header route (and dedup_extend should refuse-and-name that class per R32); func_80149954 ×1 sits behind func_80147364's u16 params.

🧰 MY PROCESS ERRORS — one mechanism: the signal sampled was not the thing measured

nohup CMD & inside a backgrounded call ⇒ the harness signalled the WRAPPER; the fleet check stood at 63/140 and I nearly read it as a pass.
pgrep -x make is right for ONE make, WRONG for a campaign of sequential makes (fires in a gap); pgrep -f <pat> SELF-MATCHES so that waiter never exits. Use the campaign's real argv or treelock.sh --status.
A corpus.stubs probe mid-rebuild returned garbage; R32's assertion refused to answer.
I predicted a fix without reading the macro in front of me — relaxed 42 (void) decls and asserted it unblocked the lane; it banked 0/1 in all 134 because that macro declares (u8*). → the PAIR rule.
I violated §136a in my own capture tool — a narrow keyword filter reported "NO COMPILE ERROR" on a build failing with redefinition of struct PW8017C290. No bad bytes from any of them — the byte-gate and R22 caught everything.

🛑 (superseded) SESSION-33/34/35 CHECKPOINT (2026-08-04)

Tree CLEAN but for the R23 db.*.gbf churn — never stage. Effort: ultracode. R22 clean-fleet run FIFTEEN times, 140/140 every time. HEAD commit:1388. Drew's standing decision: NO phase close — keep grinding, run waves all night. ⚠️ A wave (.run/s35w.js, 13 targets / 17,644 ins) may still be IN FLIGHT — check /workflows and .run/s35/*/*.c before assuming the tree is idle. Agents write .run/ ONLY.

FLEET — R22 140 passed / 0 failed of 140

96.24% fn-count · 94.0% instr-weighted · 88.4% distinct-code (77,655 uniq) · dedup 1910/0 · C1 241216/241216 · 0 NON_MATCHING (G4). Session opened 96.01 / 93.6 / 88.0 ⇒ +0.23pp fn, +0.4pp instr, +0.4pp distinct. Phase opened 92.00 / 87.5 / 78.0 ⇒ +4.24pp fn, +6.5pp instr, +10.4pp distinct.

WHAT THIS SESSION DID — the deterministic lane first, then two agent waves

lane	result
SC07 EXTEND	0/36 → 31/36
PROPAGATE head	0 → 18,545/18,545 ins (5/5 classes)
wave 1 (17 targets, 26,227 ins)	13 heads + 65 members + 2 reconciled = 80 instances
wave 2 (13 targets, 37,943 ins)	9 heads + 1 reconciled + 18 members
reconcile lane	19/20 lifetime

🔑 THE THROUGH-LINE: every blocker was TOOLING or a DECLARATION — not one was gcc

Five tool defects, four of them the SAME §134 multi-line-blindness class in THREE tools: dedup_propagate.find_site (was discarding a 3,288-ins fn) · overlay_src_split._split_macro_body (38 live instances in engine_core.h) · family_remap._alias_decl_for (the wrapped alias) · dedup_propagate blind to the asm-label alias form entirely. All now decide on cdecl._mask or reuse _alias_decl_for — one oracle (R33), never a second hand-rolled line test.

📌 THE DISTILLED RULES (all in cookbook §138 + index)

Bucket a gate refusal by the (macro-shape, TU-shape) PAIR, not by the SYMBOL. The same symbol conflicts in BOTH directions across the fleet; func_80146C3C cost this twice in one session.
Reconcile direction depends on WHERE the TU's decl is. ABOVE the splice ⇒ DELETE your duplicate (§100); BELOW ⇒ KEEP a decl in the TU's EXACT shape and cast at the use (§17a-1 D2). Picking wrong CREATES the next error. Grep the TU and compare line numbers with the stub FIRST.
STEP 0 of sibling-first: grep -rn "<MAGIC>" src/ with a distinctive literal from the .s. §136c's first two steps are same-TU/shared-header scoped and CANNOT reach a banked twin in another overlay's TU — where the big template classes live. Found func_80188C04 (328 ins) byte-identical to a banked twin in a different overlay, reused verbatim.
Never rank off the family map's exemplar field. It is an IN-FAMILY pointer and can name an ALREADY-BANKED instance, hiding the family. Derive open sites from corpus.stubs over the member list: measured 16,696 ins → 41,023 on the same map.
Three carry variants hide in one "CARRY-FIXABLE" bucket — multi-line comment (fix the tool) · draft-local struct Tag (switch to the shared type) · file-scope static inline helper (hand-author + EXCLUDE the source overlay). gcc-2.7.2 accepts implicit decls, so the third PASSES compiles_standalone and only surfaces as a byte DIFF 137 gates later.

🔬 MEASURED THIS SESSION, so nobody re-litigates it

func_801758FC / func_80132018 are NOT templatable. They banked as heads but the sweep managed 18/165 members. Probed with .run/s6_diag.py (2 builds): 0x80132018's remapped member BUILD OK (byte diff) — it compiles clean and the bytes still differ ⇒ genuine per-member codegen, not plumbing. That is the known h_seq refusal ceiling, confirmed, not a new wall. (0x801758fc reported "(no family)" — the diag keys on exemplar.addr; find its real map key.)
_alias_decl_for is ONE function, not a class: 91 distinct alias decls fleet-wide, the old per-line matcher resolved 90. The S6b note implied a class; it is not one.
"normalized distance 0" is NOT an h_exact guarantee — relocs are masked. An agent's distance-0 claim is why dedup_propagate correctly answered reach<2.

▶ RESUME HERE

Gate .run/s35/*/*.c when the wave lands: tools/treelock.sh g .venv/bin/python .run/s6f_gate.py '.run/s35/*/*.c' → capture blockers for any claimed-MATCH failure (.run/s34_capture.py <ov>:<fn>, which now ranks HARD errors above warnings) → reconcile per rule 2 → make sig-overlays + family_hseq.py + family_sweep --hseq --band all --only <addrs> → R22 → commit.
Derive wave 4 the corpus.stubs way (rule 4). Pool at this checkpoint: 864 families / 250,799 ins. Exclude the 3 walls (0x801412a8, 0x80178004, the whale 0x80144b9c) and the ledgered residuals (0x8017c294 close=12, 0x8017f7b4, 0x801898e4, 0x80186e24 close=187).
EXTEND's last 5 (unchanged): func_80144B9C ×4 needs the §38 -O0 shared-header route, and dedup_extend should refuse-and-name that class per R32; func_80149954 ×1 sits behind func_80147364's u16 params.

🧰 MY PROCESS ERRORS — all ONE mechanism: the signal sampled was not the thing measured

nohup CMD & inside a backgrounded call ⇒ the harness signalled the WRAPPER; the fleet check stood at 63/140 and I nearly read it as a pass.
CORRECTION to the S10 rule: pgrep -x make is right for ONE make, wrong for a campaign of sequential makes (it fires in a gap). And pgrep -f <pat> SELF-MATCHES, so that waiter can never exit. Wait on the campaign's real argv or treelock.sh --status.
A corpus.stubs probe mid-rebuild returned garbage; R32's assertion refused rather than answer.
I predicted a fix without reading the macro in front of me — relaxed 42 (void) decls and asserted it unblocked the lane; it banked 0/1 in all 134 because that macro declares (u8*). The PAIR rule (#1 above) is the distillation.
I violated §136a in my own capture tool — filtered the build log for error|conflicting|undefined reference, so it reported "NO COMPILE ERROR" on a build failing with redefinition of struct PW8017C290. A narrow keyword filter is how a real error goes unseen. No bad bytes from any of them — the byte-gate and R22 caught everything.

🛑 (superseded) SESSION-33 CHECKPOINT (2026-08-04)

Nothing is running. Tree lock FREE. Tree CLEAN but for the R23 db.*.gbf churn — never stage. Effort: ultracode. R22 clean-fleet run FOUR times this session, 140/140 every time. HEAD commit:1380. Drew's standing decision: NO phase close — keep grinding.

FLEET — R22 140 passed / 0 failed of 140

96.10% fn-count · 93.7% instr-weighted · 88.0% distinct-code · dedup 1908/0 · C1 240807/240807 · 0 NON_MATCHING (G4). Phase opened 92.00 / 87.5 / 78.0 ⇒ +4.10pp fn, +6.2pp instr, +10.0pp distinct.

WHAT S33 DID — lane 2 of the S10 checkpoint (the propagation lag), taken FIRST on the

standing "probe the cheap lever before funding the expensive one" doctrine. ~0 agent tokens.

SC07 EXTEND: 0/36 → 31/36. Commits commit:1377 · commit:1378.
PROPAGATE head: 7,398 of 18,545 ins banked — func_80147364 ×137 (4,110) + func_8012A598 ×138 (3,288). Commits commit:1379 · commit:1380.
Distilled to cookbook §138 (+ index regenerated) — the full triage is there, not here.

🔑 THE FINDING: a gate refusal in these lanes is a DECLARATION, not codegen

Not one of the 36 EXTEND blockers was compiler codegen. Nine failures per binary reduced to 4 distinct symbols repeated across all four. Two masqueraded as walls:

The 4 "undiagnosed DIFF"s in dedup_extend's own header are a volatile. Its correctness argument says an h_exact match makes a DIFF impossible — and the contract HELD (original bytes sha1-identical across the failing and working overlay, af1aceb2…, checked in one command with no build). The host TU declared extern volatile s32 D_80127090/94/98 at FILE scope, which no working overlay's copy does ⇒ the macro's three stores became a scheduling barrier ⇒ addu could not sink into the jal delay slot ⇒ built body emitted it early plus a nop, one instruction longer. Tell: a positional shift with a nop at a delay slot is an ORDERING constraint, not a wrong body. Fixed by the §37/§124 DATA asm-label alias. 16/16 on retry.
func_80147364: definition (u16,u16) vs 4,046 fleet decls (u16,s32). u16 promotes, so the () escape is ILLEGAL. The DEFINITION-side asm-label alias is the only zero-radius escape (1,725 in-tree precedents). Banked ×137 first try. Before relaxing a decl to (), grep the fleet's decl shapes for that symbol — () is illegal only against a default-promotion param. 4,020 decls of func_80146C3C were all (void)/()/(u8*) ⇒ safe ⇒ 8 of 36 for ONE token.

🧰 TOOL FIX — §134 multi-line blindness, now in a SECOND tool

dedup_propagate.find_site's preamble backscan had the SESSION-18 fix for blank////single-line comments and still halted on a multi-line block comment. Same class S6b fixed 3× in family_remap. Now decides on cdecl._mask (one oracle, R33) with an R32 length-preservation assertion. Monotone + byte-gate-fed ⇒ can fail to bank, never falsely bank. Paired with switching the func_8012A598 exemplar off its draft-local struct BigCopy164 to the shared struct BigCopy (engine_types.h L312, already used identically at engine_core.h:16158). Either fix alone leaves the function written off.

🔬 S33b — the PROPAGATE remainder DIAGNOSED: it is `func_80146C3C` again

Ran the one probe the checkpoint asked for, in the order §138 prescribes:

Originals byte-identical across ov_SC07_006 / ov_SC06_025 / ov_SC01_000 / ov_SC01_077 / ov_SC03_001 for BOTH 0x8016BA68 and 0x8012F274 (one command, no build) ⇒ the registry is sound, the cause is TU context.
One build in an excluded overlay named it: conflicting types for func_80146C3C — the SAME symbol as the EXTEND lane, the same (void)-vs-(u8*) shape, the same one-token lever. ⇒ Relaxed all 42 remaining extern void func_80146C3C(void); in engine_core.h to (). Measured safe before editing: every fleet decl of that symbol is (void)/()/(u8*)/(u8 *a0) (no default-promotion param anywhere, so gcc-2.7.2's () rule cannot bite), and every use in the header is either a no-arg call or already cast ⇒ codegen-neutral. dedup_propagate cannot finish this one — the 4 SC07 members are now macro sites, so find_site never returns a def and the auto-source scan errors. dedup_extend is the tool for an already-macro-ized group. Probe: exactly 1 extendable group per ordinary overlay (so the fleet has no hidden wiring backlog beyond this) ⇒ run it across the 134 non-SC07 overlays.

✅ S33b RESULT — the PROPAGATE head is 15,257 of 18,545 ins banked (82%)

class	ins	outcome
`func_80147364`	4,110	×137 — definition-side asm-label alias
`func_8016BA68`	3,886	×134 via `dedup_extend` (not dedup_propagate — see the tool boundary)
`func_8012F274`	3,973	×136 — hand-authored macro, source overlay excluded
`func_8012A598`	3,288	×138 — the `cdecl._mask` backscan fix + the shared-type switch
`func_801466F0`	3,288	OPEN — the wrapped-alias regex, measured as exactly ONE function

THREE DISTINCT CARRY VARIANTS, each needing a different response (they were all filed as one "CARRY-FIXABLE" bucket before):

variant	what `extract_unit` cannot carry	response
a MULTI-LINE comment halts the backscan	the externs above it	fix the tool (`cdecl._mask`)
a draft-local `struct Tag {…}` in the preamble	the type	switch the exemplar to the shared type
a file-scope `static inline` helper	the helper	hand-author the macro and exclude the source overlay
The third is the sneakiest: gcc-2.7.2 accepts implicit function declarations, so the extracted
body PASSED `compiles_standalone` with the helper undeclared and the miss surfaced only as a
whole-binary byte DIFF, 137 gates later. And instantiating that macro in the SOURCE overlay is a
duplicate definition (its file-scope helper is still there) — `--source-overlay X --binaries
`is the shape;`--binaries` alone removes the source from the scan pool and errors.

_alias_decl_for measured, NOT assumed (R37): 91 asm-label alias decls exist fleet-wide, the current single-line regex matches 90, and the one miss is func_801466F0. The S6b note implied a class; it is one function worth 3,288 ins. Fix the regex (join-and-map, the §134 shape) or hand-author.

⚠️ MY WRONG PREDICTION, CORRECTED BY THE BYTES (R14/R37) — and it refines §138

Commit commit:1382 relaxed 42 extern void func_80146C3C(void); decls and its message implies that unblocked the PROPAGATE remainder. It did not. The re-run banked 0/1 in every one of the 134 overlays, with the same error — because DEFINE_func_8016BA68 declares that symbol (u8*), not (void), and the TU declares it (void). That is the MIRROR of the EXTEND-lane pair, and my relax only touched one direction.

Root cause (the R37 shape, again): I bucketed by SYMBOL and stopped there. §138 says "bucket by which symbol is named" — that is not sufficient. The lever is determined by the (macro-shape, TU-shape) PAIR, and the same symbol conflicts in BOTH directions across the fleet: · EXTEND lane: macro (void) vs TU (u8*) → relax the MACRO decl. · PROPAGATE lane: macro (u8*) vs TU (void) → relax the MACRO decl of the other form. One awk over the specific macro's own body — which I ran for the EXTEND macros and NOT for this one — would have shown it before the 134-build run. Read the decl of the macro you are actually fixing, not of its sibling.

The 42-decl relax is still byte-neutral and still useful (it removes a real conflict class and R22 proved it 140/140) — it simply did not do the thing I predicted. Relaxing the remaining 2 (u8*) decls is the actual fix for this lane. §138 to be amended with the PAIR rule.

🧹 THE §134 SCANNER SWEEP — sized, one clear target

Hand-rolled comment tests still outside the cdecl._mask oracle: · tools/overlay_src_split.py:345 (_split_macro_body) — the IDENTICAL single-line-only form I just fixed in dedup_propagate (not s or s.startswith("//") or (s.startswith("/*") and s.endswith("*/"))); it decides where a macro body's file-scope externs END, so a multi-line comment there silently truncates the extern set. Same defect, same consequence. Highest value. · tools/overlay_src_split.py 239/242/520/523 — same file, other scanners (these DO track a block-comment state; lower risk). · tools/split_src_region.py:71-73 and family_remap.py:829 already handle the multi-line form. Already on the oracle: conform_decls · normalize_self_decls · reconcile_tu · scope_tu_externs · dedup_propagate · family_remap.

▶ RESUME HERE — three named items, none diagnosed against a build yet

The PROPAGATE head remainder — 11,147 ins. func_8012f274 (3,973, dropped), func_8016ba68 (3,886, 4 of 138), func_801466f0 (3,288, no source found — the S6b D4 gap: its def at ov_SC01_077_after.c:495 carries a wrapped __asm__ alias decl that _alias_decl_for's single-line rx.match cannot see, with a file-scope typedef struct Rec801466F0 behind it, §100). --recover is NOT a retry — it banked 4 of 138 here, and the reconcile lane that is 16/16 lifetime on drafts does not transfer to propagation. Probe ONE excluded overlay's build output (§136a) before re-running any lever.
The 41-class PROPAGATE tail — 2,316 ins total. Low value; batch it or ledger it.
EXTEND's last 5: func_80144B9C ×4 — the whale's registry func field is a bare name, not a DEFINE_ macro, so write_drafts emits a CALL (hence "undefined reference" in ov_SC07_010); it needs the §38 -O0 shared-header route, and dedup_extend should refuse-and-name the class per R32 rather than feed the gate a draft that cannot pass. Plus func_80149954 ×1, blocked behind func_80147364's u16 params. Then: lane 1 (S10's 17 unbanked targets, 26,227 templ ins, Sonnet at ~12-16 concurrency — the manifest .run/s10.json / script .run/s10.js are still valid) and lane 3 (the ×2-9 grind).

🧰 MY PROCESS ERRORS THIS SESSION — all ONE mechanism, all now in §138

The signal I sampled was not the thing I was waiting for, three times:

nohup CMD & inside a backgrounded call ⇒ the harness signalled the wrapper's exit; the fleet check stood at 63/140 and I nearly read it as a pass.
CORRECTION to the S10 checkpoint's own rule. It says use pgrep -x make. Right for ONE make, wrong for a campaign of sequential makes — it fired in a gap and called a live campaign done. And pgrep -f <pattern> SELF-MATCHES, so that waiter can never exit (two spinning shells, killed). Wait on the campaign's real argv or on treelock.sh --status.
A corpus.stubs probe run mid-rebuild returned garbage — R32's coverage assertion refused to answer rather than hand me a wrong stub set. A measurement taken during a rebuild is not a measurement (S27's law, re-earned). No bad bytes from any of them — the byte-gate and R22 caught everything.

🛑 (superseded) SESSION-31/32 CHECKPOINT (2026-08-03)

Nothing is running. Tree lock FREE. Tree CLEAN but for the R23 db.*.gbf churn — never stage. Effort: ultracode. R22 clean-fleet run TWELVE times, 140/140 every time. HEAD commit:1375. Drew's standing decision: NO phase close — keep grinding (task #15).

FLEET — R22 140 passed / 0 failed of 140

96.01% fn-count · 93.6% instr-weighted · 88.0% distinct-code (77,550 / 87,459 uniq) · dedup 1905/0 · 0 NON_MATCHING (G4). Phase opened 92.00 / 87.5 / 78.0 ⇒ +4.01pp fn, +6.1pp instr, +10.0pp distinct.

SESSION TOTAL — ~2,320 function-instances; 167/167 drafted targets banked earlier (100%)

Campaigns: wave 4a (33) · wave 4b b1/b2/b3 (111) · S8-3 x10-99 (23) · S6c jr (12 members) · x2-9 calibration (22 heads + 67 members) · S10 Sonnet wave (13 heads + 57 members). Lane records: reconcile 16/16 lifetime · redraft 15/15 · §136b closed 15/15. A first-pass gate failure is a ROUTING DECISION, not a wall (capture -> reconcile/redraft).

🔬 THE SONNET FINDING (Drew's call — override my routing; he was right)

	Opus (S8-3, 121-328 ins)	Sonnet (S10, 125-793 ins)
first-pass bank rate	10/13 = 77%	13/16 = 81%
30-wide concurrency	fine	SERVER-throttled, 14 of 30 never ran
The §136i ~120-ins Opus threshold is TOO LOW — it was my extrapolation, never measured. Sonnet
is at least as capable to ~800 ins. The limiter is CAPACITY, not capability: run Sonnet waves at
~12-16 concurrency, not 30. Not naming a new cliff number — 16 samples under a throttle confound
can't. Task #12 (controlled A/B) is how that gets fixed properly.

▶ RESUME HERE — three lanes, all measured, none blocked

S10's 17 unbanked targets = 26,227 templ ins (14 server-throttled + 3 gate-failed). Re-run in TWO batches of ~9 at ~12 concurrency. Manifest .run/s10.json, script .run/s10.js (already all sonnet), banked list .run/s10_banked.txt. Heads: func_8017D174(793x5) func_80186E24(611x5) func_8017E2EC(296x7) func_8017C8FC(210x7) func_8017F2E8(207x7) func_80181EE0(198x7) func_8017CDF0(693x2) func_8017E9F4(221x6) func_8017D318(184x7) func_801829BC(150x8) func_8018F060(397x3) func_8017F624(170x7) func_80190144(128x9) func_801813D0(163x7) func_80187DD0(174x6) func_8018457C(160x6) func_8018A390(136x7).
The propagation lag — 26,006 ins, ~0 agent tokens, PARTLY BLOCKED (task #14):
- EXTEND shape (14 classes / 48 stubs / 5,169 ins): dedup_extend --binaries ov_SC07_006,ov_SC07_007,ov_SC07_010,ov_SC07_011 planned 36 groups and banked 0/36 — 6 PLUMBING / 4 DIFF, and the PLUMBING conflicts repeat the SAME ~5 symbols across all four binaries: func_80146C3C (the same one that blocked func_8017C120), func_80144B9C, func_8014F4C0 (both self-axis => §37 asm-label alias), func_8012E5CC, D_80126CC4. ~5 declaration fixes unlock most of the 36. Reconcile-lane shaped (16/16 lifetime). The 4 DIFFs are ODD — dedup_extend's contract says h_exact identity guarantees byte-identity including relocs, so a DIFF should be impossible. Probe one (overlays-share-VAs trap?).
- PROPAGATE shape (45 classes / 780 stubs / 20,837 ins): NEVER PROBED. Needs dedup_propagate --addr from the single matched source. Probe ONE before costing (§136h).
The x2-9 grind (task #15): 411 of 1,872 families cover the 212,594-ins gap to 95% instr. Measured ~22,937 templ ins/wave at the head; mean ins/family decays 1,844(top-25) -> 525(top-400) -> 193(band-wide). Est 19-30 waves. Work highest-templatable-weight-first.

⚠️ P32's BEHEMOTH LEDGER IS STALE — REBUILD BEFORE PLANNING IT

roadmap-v2 claims 0x80183814 = 5,122 ins in ov_SC07_006, "largest fn in the game". Measured: it is ~108 ins in ov_SC02_000/003. The largest unmatched function fleet-wide is 969 ins (0x8017ef68, ov_SC06_000); NOTHING >=1,000 ins remains unmatched. Of 45 distinct live stubs

=400 ins: 21 are already cracked elsewhere (propagation lag, 24,354 instruction-instances) and 24 are genuinely never-cracked (22,065). ~Half of "P32 wall tonnage" is not wall at all.

✅ MAIN IS NOT FREE DEDUP — checked two ways, both negative

main's 1,525 stubs vs 39,917 banked overlay classes: 0 h_exact hits AND 0 h_norm hits (h_exact alone would be meaningless — different vram base, so relocs differ by construction). Resident 14 stubs: also 0. Consistent with Phase-11's EXE-vs-resident finding, now extended to overlays. Main's stubs are all genuinely fresh work — P31 scope, not a dedup opportunity. (Caveat: main's sig is Ghidra-derived from June 14 — valid since the binary is unchanged, but the relocation-masked xsig tool is the instrument built for cross-base comparison if you want proof.)

🧰 MY PROCESS ERRORS TODAY — the corrected patterns (all ONE root cause)

Trusting a proxy instead of the thing itself, three times:

§136h — priced a 141-family sweep off byte_weight_templatable; it banked 1 of 1,781. That column counts what COULD template if bodies reproduced — the very question. Probe one member per family. (Also: I pointed family_sweep --hseq — which REMAPS — at an h_exact- identical population, where the correct tool is dedup_extend/dedup_propagate and no remap is needed at all. Wrong tool, not a wall.)
§136a — classified blocker captures on EXIT STATUS, then on error PROSE. make build runs check, so a clean-compiling byte-DIFF also exits non-zero; and too many arguments matched no regex. Derive from the invariant: did the compile produce an object?
The waiter — until [ -s <output> ] fires at the FIRST LINE, not completion. It fired mid-propagation and I ran make clean on a live family_sweep. Use pgrep -x make (exact process name; pgrep -f <pattern> also SELF-MATCHES and leaked 4 spinning shells earlier). No bad bytes from any of them — the byte-gate and R22 caught everything.

🔑 THE FOUR FINDINGS THIS SESSION PRODUCED (cookbook §136 · §136a · §136b · §136c · §136d)

§136 — the LOCAL-VARIABLE lever. In the 60–120-ins band most "regalloc residuals" are decided by how many C locals you declare and at what scope, not by register pins (local-alloc.c:472 promotes any pseudo with REG_N_DEATHS > 1 to a global allocno, which loses the low register). One case explicitly REFUTES the pin as the lever for a redundant copy.
§136b — a "genuine byte-DIFF" verdict is a fact about ONE DRAFT, closed at 8/8. Every DIFF-ledgered function banked on redraft: wave 3's four, the three I classified myself, and one from batch 1. Never retire a target on a DIFF verdict; route it to REDRAFT. And re-GATING an unchanged draft is not a retry (that is why wave 4a's 3 DIFFs survived one gate).
§136a CORRECTED, by an agent, against the bytes. I wrote "70% of gate refusals are paperwork, not codegen." Wrong — a declaration conflict ABORTS the compile, so a PLUMBING verdict says NOTHING about the body. 2 of 3 second-round PLUMBING drafts had a real codegen residual behind the conflict. Also: classify on the build's OUTPUT, never its exit status (make build runs check, so a clean-compiling byte-DIFF also exits non-zero).
§136c — SIBLING-FIRST is a DERIVATION shortcut, not just a conflict fix. Search order: engine_core.h DEFINE_* near-twin → same-TU banked sibling → the .s → the Ghidra seed LAST (byte-proven an entirely different body twice this session). Produced first-draft matches. §136d adds four new levers, each with its refuted axis recorded.

▶ RESUME HERE

Gate batch 3 if it was in flight (see the header) → propagate → R22 → commit.
The 4 remaining stubs of 107: func_8017C120(SC02_026 — classified UNKNOWN, neither a compiler error nor a SHA mismatch; owes a direct look at its build output, not a guess) · func_8017CD9C(SC04_003) · func_801848DC + func_80185904(SC04_018). Capture then route — and per §136b none of these is a wall on one attempt.
The wave-4b remainder: batch 3 was the last of the 111-family volume lane. After it, the B-shape lanes are spent — re-derive the queue from a freshly regenerated family_hseq before scoping anything new (the ×138 era already ended; the next tiers are ×10-99 and the zero-crack non-jr residue at 120 families / 65,946 ins).
T5 close — only after re-deriving; the checklist's ROI-floor trigger is REFUTED and must not be used to close the phase.

🛑 (superseded) SESSION-30 CHECKPOINT (2026-08-01, S6 complete through wave 3)

Nothing is running. Tree lock FREE. Tree CLEAN (0 non-ghidra entries; the db.*.gbf churn is R23 restart-noise — never stage). HEAD commit:1352. Effort: xHigh → ultracode (Drew enabled mid-session for the waves). make tools-health green at session open; frontier REGENERATED at HEAD after the last bank, so every number below is current (not carried forward).

FLEET — R22 clean-fleet 140 passed / 0 failed (run 9× this session, 140/140 every time)

95.42% fn-count · 92.4% instr-weighted · 85.5% distinct-code (75,926 unique fns) · dedup 1905/0 · 0 NON_MATCHING. Phase opened 92.00 / 87.5 / 78.0 ⇒ +3.42pp fn, +4.9pp instr, +7.5pp distinct.

WHAT S6 DID — ~3,500 member-matches in 11 commits

commit:1343 S6a 842 · commit:1344 S6b +740 · commit:1345 S6e fix · commit:1346 B +268 · commit:1347 S6f calib +65 · commit:1348 S6f wave-1 +544 · commit:1349 S6g wave-2 +342 · commit:1351 S6h wave-3 +673 · commit:1352 cookbook §135 (+ 2 checkpoint/doc commits).

Two distinct engines ran, and BOTH paid:

Tooling repair (deterministic, ~0 agent tokens). The pre-fix tools scored the zero-crack population at 842 members; with three scanner fixes the SAME population scored 1,582. Six defects found, five fixed — all one root cause: a multi-line C construct read one line at a time, or a guard firing on a condition it never verified. → cookbook §134.
Agent waves (two-lane: cheap drafts + Opus reconciles). Bank rate 83% → 93% → 89%; the reconcile lane is 12/12. → cookbook §135 (6 codegen idioms + 4 integration rules).

⚠️ TWO THINGS A FRESH SESSION MUST NOT INHERIT UNCHECKED

The T6 ROI-floor trigger is REFUTED. Do not close P30 on it. The checklist says T5 fires when "the ×138 era ENDS after S2". That was wrong twice today: two ≥126-member families were open (33 ins of C → 266 members), and a 36-family / 28,829-ins pool of the same shape sat unexamined behind them. Three §133-class misses now share one mechanism — a conclusion drawn from a view that silently excluded the thing being looked for. Re-derive from a freshly regenerated family_hseq before any close.
Token economics, measured today (re-check before scaling wave 4): deterministic sweeps ≈ 0 tokens for +0.5pp instr; wave-1 ≈ 2.0M for +0.1pp; wave-3 ≈ 4.1M for +0.3pp. The agent lane is still paying, but the tooling lane paid better — the same finding Phase 15 recorded. Probe the cheap lever before funding the expensive one.

📊 THE LIVE QUEUE — re-derived at HEAD after the final bank

lever	families	templ ins	note
B-shape ≥20 memb, ≤60 ins	0	0	EXHAUSTED (was 36 / 28,829)
B-shape ≥10 memb, 61-120 ins	33	34,895	best per-target value; Opus ≥90 ins
B-shape 10-19 memb, ≤60 ins	111	33,554	volume lane, Haiku
zero-crack non-jr residue	116	61,230	S6-diagnosed; bimodal residue
zero-crack `has_mid_jr` (S6c, untouched)	9	9,364	needs `jtbl_family_bank`, 26 slots, ~0 tokens
fresh ×2-9	1,877	363,873	worst multiplier — deprioritised
fresh ×1 singletons	3,642	207,945	×1 — deprioritised
Unmatched fleet-wide: 15,161 instances / 935,927 ins.

🔁 THE WAVE RECIPE (cookbook §135 has the full version)

Manifest derived from corpus.stubs + family_hseq, paths verified on disk, pasted from the file — never typed (a hand-transcribed list cost wave 1 three agents' time). Draft lane: Haiku ≤89 ins (≡ Opus at ≤~50, ~4.8× cheaper), Opus direct ≥90, Opus escalation between. Then: gate whole-binary via .run/s6f_gate.py '<glob>' (derives every TU/split; agents' match_one MATCH is NOT a bank) → capture each failure's compiler error → Opus reconcile lane → gate → family_sweep --hseq --band all --only <addrs> → R22 → commit. If N reconcile targets share ONE TU, forbid agent builds.

▶ RESUME HERE

Wave 4 over the two B-shape slices (144 families / 68,449 ins) — recipe above, §135 in prompt.
S6c — the 9 jr zero-crack families (9,364 ins, ~0 agent tokens) via jtbl_family_bank, probing ONE sibling first (the S29 discipline: 1 build, not 137).
The 4 carried failures: func_80184A94 (reconciled to match_one MATCH, still gate-refused)
- 3 genuine byte-DIFFs func_801845B0, func_8017BEBC@ov_SC02_026, func_8018480C.
T5 close — only after re-deriving; see the refuted trigger above.

🛑 (superseded) SESSION-29 CHECKPOINT (2026-08-01, refreshed ~11:2x)

Supersedes the earlier S29 block below (which said "AT GATE 2"; Drew then directed P30 stays OPEN and approved the T6 continuation). Nothing is running. Tree lock FREE. Tree clean but for the R23 db.*.gbf churn (never stage). HEAD commit:1335. Effort: Max → xHigh (Drew).

FLEET — R22 clean-fleet 140 passed / 0 failed (run 7× this session, 140/140 every time)

94.43% fn-count · 91.4% instr-weighted · 84.0% distinct-code (73,787 unique fns) · dedup 1905/0 · 0 NON_MATCHING. Phase opened 92.00 / 87.5 / 78.0 ⇒ +2.43pp fn, +3.9pp instr, +6.0pp distinct. Session start (S28 close) was 93.25 / 89.2 / 80.5 ⇒ +1.18 / +2.2 / +3.5pp today.

THE UC WAVES (Drew opted in mid-session) — 33 heads banked, ~3,560 members propagated

Wave 1 (14 agents, 2 lanes): 14/14 match_one MATCH → 8 heads banked by three mechanisms (plain gate · a NEW targeted decl reconcile that edits ONLY the line the compiler names · the gate_stage ladder) → 1,370 members propagated, 0 failed.
Wave 2 + 3 (19 + 11 agents): 19/19 heads banked — the best conversion of the phase → 2,192 members / 411 stage-but-DIFF residue.
THE RECONCILE LANE IS THE RESULT WORTH KEEPING. 17 of 19 wave-2 heads needed a declaration fix and not one needed a header edit. Two escapes did all of it: the §37/§124 asm-label alias (<ret> aF<ADDR>(...) __asm__("func_<ADDR>")) when the conflict is on the function ITSELF (return-type or arity), and conform-the-decl + cast-at-use when it is on a DIFFERENT symbol the draft declares (func_80142A80, RotTransSV, func_80146C3C, D_8011D030, D_800AF634). This is the direct answer to the morning's failure: the documented fix for that class was a fleet-wide decl widen, which touched 2,046 files and still did not build. The alias sidesteps the collision at ZERO blast radius.
Agents cannot run the gate, so a blocker-capture pass (splice→build→revert) had to precede each reconcile fan-out and embed the exact compiler error per agent. Without it they are blind on the one axis that matters. (R14 on my own capture: the note: lines I passed through were pre-existing SHB macro-redefinition NOISE — four agents independently called it and worked the real error.)

WHAT S29 DID

JR-PAIR-IN-ONE-O0-OBJECT RETIRED — two instrument defects (§132), not a compiler wall: jtbl_carve blind to a merged-double span + no .DELETE_ON_ERROR (a truncated .o outlived its own loud compile error and the NEXT build linked it). Pair banked ×138 = 276 instances.
S1 zero-crack tier — 186 members (head func_8014032C 137/137 = 25,071 ins via the new --span-rel, §132b; func_8017BEBC 13/13; + jr tier). My routing error recorded: 13 of 28 families are not jr and carve-failed by construction (§123's own law).
S2 — both remaining reach-138 heads cracked. func_8016EC0C (void-return delay-slot idiom) ×138; func_80176734 (371 ins — the largest single item in the frontier) banked first try and propagated. TWO agents reached byte-identical solutions independently via different lever sets.
S3 measured, not scaled — 77% of stored drafts have DECAYED (7/30 still verify); the survivors are def-side-walled. A fleet sed over decls touched 2,046 files and failed ⇒ reverted (§29 law).
UC wave 1 (14 agents): 14/14 match_one MATCH → 8 banked heads by three different mechanisms (plain gate · a NEW targeted decl reconcile that edits only the line the compiler names · the gate_stage ladder). 1,370 member instances propagated, 0 failed.
Cookbook §132 · §132a · §133 (the DEFAULT-FILTER class — three times in one session a tool silently answered a narrower question than the one asked).

📊 THE POST-WAVE FRONTIER (re-derived at HEAD after the 2,192-member propagation — R35)

Overlays: 94.7% fn / 91.8% instr / 85.0% distinct; unmatched 18,635 instances / 1,069,466 ins / 13,658 distinct classes → 2,378 families + 3,767 singletons.

lever	scale	cost	verdict
Zero-crack propagation (source-agnostic)	190 families / 129,997 ins	~0 agent tokens	DO FIRST (S6)
×10-99 fresh-crack band	243 families / 239,058 ins	agent waves	next (S5)
STRUCT class (ov077 surface)	29 fns / 39,892 ins	agent waves	after S5
GIANT	4 fns / 100,188 ins	2 are the known walls (close=110/91)	P32's track
×2-9 fresh-crack	1,941 families / 410,671 ins	biggest mass, worst multiplier	deprioritised
×1 singletons	3,767 / 230,367 ins	×1	deprioritised
~~S4 PINS~~	101 ins (not 44,279)	—	RETIRED, see below

TWO PRICING CORRECTIONS (both §133, in OPPOSITE directions — this is why the table is re-derived):

S4 PINS is retired on measurement. The plan priced it at 44,279 ins from worklist.md, which prices by h_exact reach (×138/fn). Re-priced against the family map after the waves, the PINS functions' families are almost all already matched/propagated: 24 fns / 101 templatable ins. Running the planned wave would have bought ~0.001pp. The same mis-pricing that once under-valued the frontier head by 138× over-valued this by ~440×.
106 of the 190 zero-crack families have exemplars OUTSIDE ov_SC01_077 (ov_SC03_014 17, ov_SC06_018 10, ov_SC01_084 9, ov_SC02_027 7, ov_SC02_011 7, …). Every sweep this project has run passed --source ov_SC01_077, so those families were structurally unreachable — not hard, not walled, just never addressed. Probe-confirmed: func_8012B77C is DEFINED in ov_SC07_006 and still an INCLUDE_ASM stub in ov_SC01_000.

▶ RESUME HERE (T6: S1–S3 done, both UC waves done; nothing blocked, nothing running)

The ×138 redraft band is now CONSUMED. All 33 fresh-crack ≥100-member families are banked except the 2 GIANT walls (func_801412A8 close=110, func_80178004 close=91 — P32's track).
S6 (NEW, highest ROI): source-agnostic zero-crack propagation — 190 families / 129,997 ins, ~0 agent tokens. Drive each family from ITS OWN exemplar overlay, not always ov_SC01_077; route by tier (§123) and pass --band all (the S1 trap). Probe one sibling per family first.
S5: the ×10-99 band — 243 families / 239,058 ins, the proven 3-lane workflow. Expect the ROI floor here: the multiplier is 10-99, not 138.
~~S4 PINS~~ RETIRED on measurement (101 ins, not 44,279 — see the pricing corrections above).
The 411 stage-but-DIFF propagation residue — per-overlay variants whose remapped bodies do not reproduce; individually gate-rejected, ledger material not a lever.
Reusable machinery from today (all committed): the 3-lane workflow scripts under .claude/…/workflows/scripts/p30-uc-wave{1,2,3}-*.js · .run/uc_capture.py (blocker capture, the precondition for any reconcile fan-out) · .run/uc_reconcile.py (compiler-named decl edits only) · tools/jtbl_family_bank.py --span-rel (§132b) and its like_arg guard (§132a).
T5 close fires on the measured ROI floor. The ×138 lever is spent; S4/S5 are the remaining in-phase levers, and their multiplier is materially lower — that is the honest floor signal.

🛑 (superseded) SESSION-29 CHECKPOINT (2026-08-01 ~00:40) — AT GATE 2

Supersedes SESSION-28 below. Nothing is running. Tree lock FREE. Tree clean but for the R23 db.*.gbf churn (never stage). HEAD commit:1303. Effort: Max all session. make tools-health RC=0 at close; R22 clean-fleet run TWICE this session, 140/140 both times.

FLEET — R22 clean-fleet 140 passed / 0 failed

93.33% fn-count · 89.6% instr-weighted · 81.6% distinct-code (72,416 unique fns) · dedup 1905/0 · C1 240496/240496 · 0 NON_MATCHING. Overlays-only: 93.6% fn / 90.1% instr / 82.5% distinct. Phase opened 92.00 / 87.5 / 78.0 ⇒ +1.33pp fn-count, +2.1pp instr, +3.6pp distinct this phase.

WHAT S29 DID (all committed, all R22-verified)

JR-PAIR-IN-ONE-O0-OBJECT RETIRED — the S28 class and its §81-isolate escape are BOTH refuted. Two instrument defects: jtbl_carve's merged-double blindness + no .DELETE_ON_ERROR (a truncated .o outliving its own loud compile error). Both fixed; cookbook §132.
The jr pair banked ×138 each — 276 function-instances. Frontier families #3 and #4 by templatable weight (37,536 + 27,324 ins). The -O0 cluster is now COMPLETE fleet-wide.
§132a — the --like role-name over-transfer (ov_SC07_010), guard shipped.
§100 type-locality — a file-scope typedef in a draft is an exemplar-only bank: it passes the gate and silently cannot travel. Caught by probing ONE sibling before 137 builds (R37).
T1/T3 closed with measured per-lane verdicts (see the checklist), tools-health + fresh frontier.

▶ RESUME HERE — P30 STAYS OPEN; T6 approved (Drew, 2026-08-01)

Gate 2 was reached and deliberately not taken: the ≥95% branch is out of reach (89.6%) and the ledger branch IS met, but closing now would strand roadmap-v2 bucket W3 (the overlay family mass) with no owner phase — P31 is scope-complete/main/resident, P32 is walls/behemoths. So P30 continues on the T6 order in the checklist above (S1 → S2 → S3 → S4 → S5), and T5 fires on the measured ROI floor (the end of the ×138 era after S2), not on a session count.

Start here: S1's head — 0x8014032C (183 ins ×137, jr, per-location, exemplar matched in ov_SC01_077) via jtbl_family_bank, probing ONE sibling first (the S29 discipline: 1 build instead of 137). Then 0x8017BEBC, then the ×4-straggler families. Frontier data: .run/family_hseq.json (regenerated at HEAD commit:1303, same-tree as the digests).

🛑 (superseded) SESSION-28 CHECKPOINT (2026-07-31 08:1x)

Supersedes SESSION-27 below. Nothing is running. Tree lock FREE. Tree clean but for the R23 db.*.gbf churn (never stage). HEAD commit:1293 (+ this doc commit). Effort: opened xHigh → Max for the jr re-measurement and the T2 probe ladder → back to xHigh for the driver + sweep. make tools-health RC=0 at session open. R22 clean-fleet run THIRTEEN times this session, 140/140 every time (one 139/140 and one 137-file false-pass, both MINE, both caught and reverted — see the honesty ledger).

FLEET — R22 clean-fleet 140 passed / 0 failed (verified THIRTEEN times this session)

93.25% fn-count · 89.2% instr-weighted · 80.5% distinct-code (72,154 / 87,459 unique fns) · dedup 1905/0 · C1 240496/240496 · 0 NON_MATCHING. Phase opened 92.00 / 87.5 / 78.0 ⇒ +1.25pp fn-count, +1.7pp instr, +2.5pp distinct this phase.

🎯 THE THREE REACH-138 TARGETS + THE SWEEP RESIDUE — 270 members banked, 1 wall

✅ func_8013C08C 0/137 → 137/137 (commit:1286) — §94 type-carry; E_13C08C was a MULTI-LINE typedef at FILE scope and extract_unit's backscan cannot carry one (it presents its CLOSING line first). Fix = §100 draft-local. Byte-neutral. ✅ 0x8013BC7C 133/133 (commit:1291) — the sweep residue. My hypothesis (split tracks the -O0 file) was REFUTED (SC07_006/007/011 were sub-split today and banked anyway), so I staged one member and READ the error: (1) a typedef textually identical to engine_types.h's, which C89 still rejects — already handled by harvest_verify's cdecl.strip_provided_typedefs; (2) §57 self-decl divergence ⇒ --normalize-self-decls. One flag, 133/133. ⛔ func_8013B83C + func_8013BD74 — NOT BANKED, class JR-PAIR-IN-ONE-O0-OBJECT. Both bodies byte-correct (--o0 MATCH, 272/198 ins). Two jr fns sharing one -O0 object: carving both gives a valid span (pads [0,4,4]) and an INCREMENTAL build says BYTE-IDENTICAL, but the CLEAN build cannot link — undefined reference to $L105 (local label from the C-emitted jtbl) + undefined reference to func_8013C938 (a previously-MATCHED fn). Untested escape: §81 step 1 — isolate one into its own code subseg so each object owns exactly one table. Drafts preserved at .run/s28w/.

▶ RESUME HERE — FRESH SESSION SAFE. Nothing running, tree clean, lock FREE.

Drew's directive at the S28 close: items 1–3 done; item 6 wants Max (prompted, not started); items 4–5 are for a FRESH SESSION (this checkpoint is that handoff).

[T1, Ultracode] Integration-recovery sweep — the ~90 stored drafts that are match_one-MATCH but integration-decayed, + the 10 named SESSION-16 blockers. Prior measured recovery 39%. Report point #2. Prompt for /effort ultracode and WAIT (R26/R27).
[T3, Ultracode] More crack waves — 3,873 fresh cached cores across 119 binaries (.run/p30w4_pool.json). ⚠️ S28 ROI evidence: a 15-target wave cost 1.33M tokens for 12 banks and +0.00pp headline. Only worth resuming against HIGH-REACH targets; ×2-reach drafting is not where the leverage is. Deal ACROSS binaries so the gate fans out.
~~[Max] #9 — jtbl_carve diverges on ov_SC06_018~~ ✅ SOLVED + BANKED (S28, commit:1293). Root cause: a jtbl OVER-SPAN. sltiu 0xC names 12 entries, the object emits 12 words, the carve reserved 13 — the 13th being ordinary NON-ZERO data spimdisasm ran into the dlabel, which the zero-word trim cannot see. The piece under-filled ⇒ every later symbol slid −4 ⇒ 812 %lo immediates changed. Fixed with an sltiu-authorized clamp (refuses loudly if a surplus word looks like a real entry). func_80191C50 (710 ins) BANKED, R22 140/140. Cookbook §131. ⇒ the JTBL-CARVE-BREAKS-BYTES class is RETIRED — it was a real bug, now fixed.
[Max, xHigh-able] JR-PAIR-IN-ONE-O0-OBJECT — try §81 step 1 ✅ SOLVED + BANKED (S29). The class is RETIRED and the §81-isolate escape was never needed: it was TWO instrument defects (a merged-double span jtbl_carve could not see + no .DELETE_ON_ERROR, so a truncated .o survived its own loud compile error and the NEXT build linked it). Both fns banked, R22 140/140. Cookbook §132. Sibling sweep (2 × 137) unblocked — see the S29 log entry.
[T5, Max] Phase close. ⚠️ Milestone reality: 89.2% instr vs a ≥95% bar. The remaining overlay volume is small; the bulk is main's 1,034 stubs + the 39 type-1 modules, both P31 scope. P30 realistically closes on the milestone's ledger branch ("every remaining overlay stub on a named wall/behemoth/queue ledger"), which is an explicit either/or in the approved milestone — Drew's call, to be made deliberately at T5, not discovered.

⚠️ S28 HONESTY LEDGER (read before trusting any S28 conclusion)

Five wrong calls, every one caught by an oracle, none committed:

Two of three jr "wall" verdicts RETRACTED — a grep-of-the-build-log gate in a driver with no revert-on-abort contaminated its own measurements (§125).
An 8× population under-count (275 vs 2,184) — a bare except: continue swallowed R32's coverage assertion during a rebuild; it also made me wrongly call a good T0 pin "stale" (§126a).
"15 contiguous -O0 fns" — an under-count from scanning asm/**/*.s, which cannot see matched functions (§126).
Broke the fleet gate to 139/140 — a negative control that corrupted the REAL tracked file and restored it with tangled escaping (§128a). A negative control must mutate a scratch copy.
Reported "BOTH BANKED — BYTE-IDENTICAL" from an INCREMENTAL build that the clean build cannot even LINK (§130). The sharpest lesson of the session: an incremental byte-gate result can be actively FALSE, in the most convincing direction. Standing consequence: only make clean && make extract-all && make check-all counts, and a tool's exit status is never the oracle — read the output.

📌 THE 4th `-O0` REGION — verified, sized, and correctly BLOCKED (do not re-litigate)

My own byte scan (not the agent's claim — R14/R37) over all 156 fns of ov_SC03_014_jr_8017EB7C: the -O0 frame-pointer prologue covers exactly the contiguous run 0x80183CF0..0x80184868 (15 fns), with -O2 neighbours 0x80183A54 below and 0x80184920 above — a clean cut. Prize: 30 fn-instances / 1,504 ins — the region is h_exact-identical in ov_SC03_014 + ov_SC03_015 ONLY; the 3 other overlays holding a func_801846E4 (SC03_090, SC04_005, SC05_018) are DIFFERENT code at the same VA (overlays share VAs — the §-index warning, live). Blocked structurally: all 15 live in an -O2 split (corpus.o0_sources confirms), and the append-to-_o0b route fails BY CONSTRUCTION (the existing _o0b covers the whale at file 0x1CA44..0x1D64C; this region is far above it, so appended bytes land at the wrong VA — the same reasoning that killed the T2 ×1 append probe). ⇒ needs the re-carve; it IS T2.

⚠️ TWO CORRECTIONS TO THE SESSION-27 CHECKPOINT (mine, R14)

The 137 were SKIPS, not failures. S27 folded them into the 401 gate-failures; 137+22+10 = 169 ≠ 401. They are a separate skipped{} bucket.
The cause was NOT "the exemplar banked in a different binary." It is banked in ov_SC01_077 under the §37/§73 asm-label alias (int aF8016191C(...) __asm__("func_8016191C")), and extract_unit only matched a head literally named func_<ADDR>. One exemplar × 137 same-address members — a tool lookup miss, the 4th consecutive "structural" residual to resolve to our own tooling (R35). Fixed T0-only; the alternative (widen engine_core.h, drop the alias) was REJECTED — it fixes only §73's RETURN axis while the decl/body also disagree on PARAMS, and it is a T2 fleet-shared edit. §124.

🧪 A METHOD NOTE WORTH KEEPING (cost me one probe this session)

I ran a corpus.stubs probe while make extract-all was mid-flight and got 4 binaries' worth of garbage. corpus.py's R32 coverage assertion caught it and refused to answer instead of returning a wrong stub set — the assertion earning its keep. A measurement taken during a rebuild is not a measurement (SESSION-27's law, re-earned). Re-derive after the campaign exits.

🛑 (superseded) SESSION-27 CHECKPOINT (2026-07-31 01:25)

Supersedes SESSION-26 below. Nothing is running. Tree lock FREE. Tree clean but for the R23 db.*.gbf churn (never stage). HEAD commit:1258.

FLEET — R22 clean-fleet 140 passed / 0 failed (verified at HEAD)

92.67% fn-count · 88.3% instr-weighted · 78.7% distinct-code (70,590 / 87,459 unique fns). Phase opened at 87.5 / 78.0 / 92.00 → +0.8pp instr, +0.7pp distinct, +0.67pp fn-count so far.

WHAT LANDED THIS SESSION (all committed, all R22-verified)

T0 instrument repair (a–f), 6 commits — incl. gate_stage stage-0 (§122) and the fix_arity_callers per-edit journal undo.
T0.5 fleet Ghidra-C prefetch COMPLETE — 124/124 programs, 7,716 files, 335 min unattended. 95.2% of the 6,070 crack-needing families are seeded; main 2,001/2,002; resident 14/14.
T3 waves 1–4 + behemoths: wave1 8/14 · wave2 15/19 · wave3 48/48 · wave4 69/70 banked (70/70 drafted) · 7 behemoths CONFIRMED at 700–970 ins (4 banked; 3 jr deferred).
Propagation: 548 + 911 members via family_sweep --hseq; h_exact leg 14 propagated / 42 benign skips / 0 failures.
New instruments: tools/treelock.sh · tools/prefetch_fleet.py · tools/cookbook_index.py
- docs/cookbook-index.md (324 sections, symptom-keyed, in tools-health).
Cookbook §122, §123.

▶ RESUME HERE (nothing blocked, nothing in flight)

func_801846E4 (ov_SC03_014) — the 1 of 10 resumed drafts that did NOT bank (agent reported MATCH; gate refused). Draft at .run/drafts-p30w4/ov_SC03_014/func_801846E4.c. Its agent flagged it as the -O0 class (SIZE-MISMATCH/short + frame-pointer prologue) — likely needs --o0.
The 137 "no matched unit for func" sweep-routing gap — family_sweep looks for the exemplar's banked unit in the wrong binary. Cheap, worth ~137 members.
3 jr behemoths (func_80191C50, func_8018057C, func_80181CDC; staged in .run/beh-gate/<binary>/) + group B's carve (13-member IMM/jr @952, 103 already matched → jtbl_family_bank.py). Both run make extract — run ALONE under tools/treelock.sh.
T2 -O0 carve-within-a-carve (13 families / 1,746 members). Newly cheaper: wave-4 agents documented the match_one --o0 flag AND found a 4th -O0 region beyond the 3 known ones.
Next wave: 3,873 fresh cached cores across 119 binaries remain (.run/p30w4_pool.json); deal them ACROSS binaries so the gate fans out.

🔁 THE LOOP THAT WORKS (proven 4 waves running)

draft (agents, .run/ only) → --no-propagate gate, per-binary IN PARALLEL → sig+map regen → propagate per-function, routed by tier (§123) → one R22 → commit. Wrap every tree-writing campaign in tools/treelock.sh.

⚠️ THE THREE LAWS THIS SESSION COST US (all mine, all now mechanised)

Guard the CAMPAIGN, not the process — a pgrep poll cannot see a campaign made of sequential processes; mine started in a gap → 63/140 broke. → treelock.sh.
A killed process performs no undo — a fixed 3600s propagation timeout killed the driver mid-fleet-write. → timeout scales with bank count AND is caught.
A measurement taken during corruption is not a measurement — I reported a "per-binary bank-rate cliff" and theorised a cause; re-gated clean it was 6/6 everywhere. Both incidents cost build cycles and ZERO work, because agents only ever write .run/.

📊 THE MEASURED FINDING WORTH KEEPING

Bank rate by wave: 57% (no index) → 79% → 100% → 99% (index-first). Same models, same gate. The bottleneck was discoverability of our own knowledge, not the compiler. Agents also self-report index_hit/index_gap, and their gap reports are now curated symptom lines — the flywheel is closing on itself.

🛑 (superseded) SESSION-26 CHECKPOINT (2026-07-30 23:05)

Supersedes the in-flight block below. Paused for the 5h usage limit; a one-shot cron is set for 00:47 (2026-07-31) to resume — but cron is SESSION-ONLY and dies with this session, so if the session ended, just follow "RESUME HERE" manually.

HEAD commit:1254. Fleet at last verified point: 92.59% fn-count · 88.2% instr · 78.7% distinct · R22 140/140 (commit commit:1252).

⏳ RUNNING AT PAUSE (check these FIRST)

w4-gate under tools/treelock.sh (pid at pause 1313761): gating wave-4's 68 drafts across 14 binaries in parallel, then sig+map regen, then R22. Log: .run/w4gate_run.log + .run/w4gate/<binary>.log. If it did not finish: tools/treelock.sh w4-gate bash .run/p30w4_gate.sh. Nothing from it is committed yet — commit only after R22 shows 140/140.
Tree carries Lane A's 15 banks (sweep finished: 15 banked / 712 failed / 910 already-not-stub — the population was largely consumed by the earlier sweep, so Lane A is now nearly spent).

▶ RESUME HERE (in order)

Finish/verify the w4-gate → R22 140/140 → commit.
RESUME THE 12 UNFINISHED AGENTS (.run/p30w4_remaining.json) — Drew's explicit instruction, cron 799f00d8 set for 00:49 on 2026-07-31. Wave 4 launched 70, 58 returned (ALL 58 match_one MATCH), 12 were killed mid-run: func_8017EA1C(SC02_041) · func_8018A150(SC02_027) · func_80185680(SC02_017) · func_8017D900,func_801846E4(SC03_014) · func_80187940,func_80185B5C,func_801885C0(SC04_011) · func_801832D4,func_80183CBC,func_80183258,func_8017D7A4(SC02_035). Workflow scriptPath /tmp/claude-1000/-home-musashi-bfm-decomp/f1a9b030-5924-4b17-b102-3de2ca684a6f/scratchpad/p30w4.js, args = the 12 targets as an ARRAY (a JSON string breaks pipeline()). ⚠️ 10 of the 12 have a PARTIAL draft on disk from the killed run — a starting point, NOT a verified result; re-verify with match_one before any MATCH claim. (Counting note, R14: my first count said "2 remaining" because I measured draft-FILE existence. An agent writes its draft early and then iterates, so a file proves nothing about completion — the journal's result records are the truth. Drew's "12" was right and my measure was wrong.)
The h_exact propagation leg that halted at 0x801466F0 (rc=1, stopped by design).
The 137 "no matched unit for func" sweep-routing gap — the exemplar banked in a DIFFERENT binary than family_sweep looks in. Likely cheap and worth ~137 members.
3 jr behemoths (func_80191C50, func_8018057C, func_80181CDC, staged in .run/beh-gate/<binary>/) + group B's carve (13-member IMM/jr family @952, 103 already matched → jtbl_family_bank). Both run make extract — run them ALONE under the lock.
T2's -O0 carve-within-a-carve (13 families / 1,746 members walled) — the deep arc.

⚠️ THE TWO LAWS THIS SESSION COST US (both self-inflicted, both now mechanised)

Guard the CAMPAIGN, not the process (tools/treelock.sh). A pgrep poll cannot see a campaign made of sequential processes; mine started in a gap and 63/140 binaries broke.
Gate with --no-propagate, then propagate PER FUNCTION, routed by tier (§123). A fixed 3600s propagation timeout killed the driver mid-fleet-write; a killed process performs no undo.
Corollary proven twice: agents must only ever write .run/ — that is why both incidents cost build cycles and zero work.

📓 NEW THIS SESSION

Cookbook §122 (gate raw before transforming; undo belongs to the writer as a per-edit journal), §123 (propagate a family with the tool its TIER needs + routing table), docs/cookbook-index.md (226→324 sections, symptom-keyed, in tools-health), tools/treelock.sh, tools/prefetch_fleet.py, tools/cookbook_index.py.

🛑 (superseded) SESSION CHECKPOINT (2026-07-30, in-flight)

Written while two background campaigns run; REFRESH before any pause (the stale-checkpoint trap).

Running in background: (1) T0.5 full prefetch batch (prefetch_fleet.py, 126 programs — imports ~3 min each + define+decompile; cache was 3,680 at launch; task baw61zyz6; resumable — re-run the same command if interrupted). (2) T1a recovery sweep (.run/recover/t1a_runner.py → .run/recover/t1a.log; 108 autopsy-MATCH fns / 50 binaries; driver commits banks per binary via gate_stage's scoped add; OWED AFTER IT LANDS: a config sweep-up commit — jr-bank preps edit config/overlays.mk + splat yamls which gate_stage --commit does NOT stage — then R22 clean-fleet

report point #2).

HEAD at checkpoint: commit:1223. Fleet: 87.5 / 78.0 / 92.00 (pre-T1a-banks). Tree: T1a's in-flight src/config edits (theirs); .run/ artifacts.

**T0 ✅ (6 commits) · T0.5 ▶ (batch running; main+3 overlays done: +2,241 cached) · T1a ▶ · T2 ▶ (two probes done, arc re-scoped — see log; NEXT session opener: sub-split carve + shift-diff

symbol-pin probe on ov_SC07_007) · T3/T4/T5 pending.**

If resuming fresh: read docs/frontier-p30.md (report point #1, with the T2 R14 correction) + the T2 log entries; check both background tasks' outcomes first (git log for t6-recover commits; ls .run/ghidra_c | wc -l); the Ultracode prompt for T3's first wave is still OWED to Drew (R26/R27) — T1b agent-residue wave folds into it.

Per-task log

▶ S43-1 — the §148 "GTE macro wall" was a SILENT CPP FALLBACK; the permuter lane was dead on 63 drafts (2026-08-05)

First task of the serial-crack continuation. §148's tooling note recorded "the gte_* #define block defeats make_base_c — demacroize first." That diagnosis was wrong (R14/R35), and the fix is in our tooling, not the drafts.

Root cause (reproduced, not inferred): make_base_c called cpp_expand_macros before drop_preproc_and_scalar_typedefs removed #include lines, so mipsel-linux-gnu-cpp -P -nostdinc - died on #include "common.h" (rc=1, empty stdout) and the return c fallback handed back the unexpanded draft. hide_asm — which is built for __asm__ statements, not multi-line macro definitions — then chewed through the gte_* block and swallowed the function with it. pycparser reported "Function … not found in base.c" and decomp-permuter no-opped in 0 s, which at the call site is indistinguishable from "searched and found nothing". cpp_expand_macros exists precisely to prevent this; its detector fired correctly; the silent fallback undid it.

Shipped (tools/p16_permute.py):

cpp_expand_macros strips #include before the cpp call (byte-neutral — they are dropped downstream regardless) and RAISES on cpp failure instead of returning its input (R32/R35: no silent fallback).
NEW defines_fn(base_c, fn) + an assertion in setup(): base.c must still contain a definition of the target. This guards the output, so it catches every swallow cause (this cpp path, the §G unterminated-comment class, future macro shapes), not just the one diagnosed today.
main() catches the RuntimeError per function so one bad draft is loud + counted but cannot abort a batch.

Verification: target func_8017C6F4 → defines_fn True, 0 gte_ macros left, 35 asm statements correctly hidden as b64 pragma carriers; proxy validated over 388 stored drafts with a plain definition → 0 false alarms, 0 cpp raises (macro-free drafts byte-untouched); end-to-end the permuter now loads the draft at base score 65 and iterates (was a 0 s no-op).

Blast radius (measured, 14,899 stored drafts scanned): 63 drafts carry both a #define … __asm__ and an #include — including drafts-behemoth2/3 — so the permuter lane has been silently dead on the GTE-heavy renderer/behemoth drafts, the highest-byte-weight targets on the board.

⚠️ Consequence for §147/§148's floors: the ~40 hand probes on func_8017C6F4 (and func_8017C294's sweep) were run with the permuter unavailable. "The permuter also plateaus" was never measured on these functions — do not treat those floors as permuter-tested. → cookbook §148 tooling note corrected in place.

▶ S43-2 — the permuter took the "unmovable" 63 to 42; and the ledger row was NOT a rumour (2026-08-05)

The floor moved. With base.c fixed (S43-1), permuter_ils on the S42 hand draft: masked base 65 → 44 in cycle 1, then flat across 5 warm restarts. Re-measured in match_one terms (the metrics are NOT interchangeable — always re-measure before comparing): 63 → 42 mismatched, same 947/947 ins, residual still the register-rotation class but with fewer instances. The first movement on this function after ~40 hand probes — and it came from repairing an instrument, not from new C. Draft preserved + allowlisted: .run/s43/func_8017C6F4.ils44.c (+ ils_8017C6F4.log), logged to the backlog at closeness 42.

Final permuter verdict for this function (14 warm restarts across two basins): pin-free seed masked 44 / match_one 42 (flat over 8 cycles); the pin-t5 seed masked 43 / match_one 41 (flat over 5). Best known draft = .run/s43/func_8017C6F4.ils43-pin.c at closeness 41, logged. So the permuter is worth 63 → 41 here and is now itself exhausted on both basins — the residual register rotation survives it. Next lever is §148-C (the zero-byte allocno-priority slider) by hand, or Fable5 on a genuinely fresh seed; do not re-run the ILS on these two seeds, it is measured flat.

The S42 "rumour row" claim was WRONG (R14) — and the truth is a worse defect. The 2026-07-01 row does have an artifact, it is on disk (.run/backlog_drafts/func_8017C6F4.c, one of 3,335 there), and it reproduces exactly: match_one vs ov_SC03_010 → 14 mismatched of 15 target ins, SIZE-MISMATCH/redraft. It is not a rumour; it is a near-worthless draft on a different function. 0x8017C6F4 hosts TWO bodies: 15 ins in ov_SC03_010/011/013, 948 ins in ov_SC03_126/003, ov_SC04_021, ov_SC05_019 (§148-E, ledger side).

Three defects, all in tools/backlog.py, all fixed:

load_best keyed on address alone, so the two bodies merged and the LOWER absolute closeness won — a 14-of-15-wrong draft (7% correct) masked a hand-won 63-of-947 (93% correct). Now sub-keyed by known nins; unknown-nins rows keep the old behaviour and fold into the sole known body when unambiguous (so legacy name-vs-addr dedup is preserved).
binary: null defaulted to ov_SC01_077, where func_8017C6F4 does not exist at all — and "not an open stub there" was read as "banked", so today's real result was invisible to render, the grinder, and target selection. Absent ≠ done (R32/R34). Now: derive the binary from the draft path, and only drop when the fn is closed in every binary that has it (_open_anywhere).
backlog.py log had no --binary flag at all — the root cause of every null. Added, plus append_record derives it from the draft path (the S20 addr_of lesson, applied to binary).

Measured impact, derived not asserted (R37): replaying the exact pre-fix selection → 836 → 837 rows, 1 appeared, 0 vanished, and the one that appeared is func_8017C6F4 nins=947. The live blast radius is one row today — s42-serial is the only logger that omitted binary — but the mechanism would silently eat every future serial/agent result logged the same way. Note on ranking (documented, NOT fixed): closeness is an ABSOLUTE mismatch count, so it is not comparable across sizes — 14/15 outranks 63/947. A relative-closeness rank was probed and not built: only 24 of 836 live rows carry both closeness and nins, and on those the two orderings agree 14/15 (most are closeness=0 integration-stranded). Revisit if nins coverage ever rises.

▶ S43-3 — the CC1-FAIL label named MAKE, not the compiler: ~3,000 content-free labels (2026-08-05)

The checkpoint's cheap-fuel note ("the classifier writes CC1-FAIL: make: *** Error 33 without the cc1 message, so each costs a manual splice-and-rebuild") is exactly right, and the cause is one line. classify_fail picked errs[-1] — the LAST error line — and make prints its own summary (make: *** [Makefile:N: build/src/<ov>/<tu>.o] Error N) last, always. So make's wrapper won every time, and the label carried nothing but the TU name the record already stores.

Measured over the committed .classified.txt corpus (R37, derived not asserted): ~3,000 of ~4,000 CC1-FAIL labels are that wrapper, plus 1,019 bare CC1-FAIL with no message at all.

Fix: _MAKE_WRAP guard — make's summary lines are excluded from the label, and the FIRST real diagnostic wins (cc1 cascades: error #1 is the root cause, error #N its aftershock). When nothing but a wrapper exists the label is now CC1-FAIL(no-diagnostic): — honest about the gap rather than disguising it (R32). This is the same family as the §58 warning red-herring guard immediately above it in the source: a label identical for every input carries no information. Verified on the exact branch: CC1-FAIL: make: *** [...] Error 33 → CC1-FAIL: src/…/tu.c:2240: error: too few arguments to function `gte_ldv3'.

⚠️ HAZARD FOUND (mine, and now documented in the file's header): harvest_verify.py has no if __name__ == '__main__' guard — the entire gate runs at module level. Unit-testing classify_fail by importing the module ran a full 13-draft resident gate and overwrote the unsuffixed .run/harvest_{verified,failed}*.txt scratch. No damage (resident stayed 8e17e02f, 0 banked, tree clean, per-binary outputs untouched) and nothing imports it today (checked), so it is a documented hazard rather than a risky 500-line refactor of the most load-bearing gate we own. To test a helper in it, exec that function's source (ast.get_source_segment) — never import the module.

▶ S43-4 — the "26 unpropagated members = cheapest fuel on the board" is REFUTED: 0 of 31 templatable (2026-08-05)

The S40 close and the S42 checkpoint both list this as item #1/#3 cheap fuel — "20 CC1-FAIL + 5 callee conflicts; the recovery ladder already has every lever." Measured today: it does not.

Re-derived from the tree, not inherited (R35): the S40 propagation commit commit:1465 banked 59 function families; 22 of them still have open members — 31 instances, not 26 (the stale count was taken before later sessions moved the board).

The probe (SCAN, don't sample — S4's lesson): for each of the 31, try a mechanical family_remap from every binary where the same function is already matched (up to 4 sources each). RESULT: 0 templatable / 31 not. Every attempt fails reloc-count mismatch … (not an h_norm-clean pair) — and the mismatches are gross, not marginal: 2!=15, 12!=2, 11!=20, 2!=0. Script + JSON preserved: .run/s43/probe_leftovers.py, .run/s43/leftover_probe.json.

What they actually are: structurally DISTINCT bodies that merely share an address and a name across overlays — the same collision as func_8017C6F4 (15 ins vs 948, S43-2), one level down. The family_hseq manifest agrees independently (R34): these members cluster into families with matched=0, several with n_members=1. There is no matched sibling to template from, so there is nothing for the recovery ladder to recover — the failures were never plumbing.

Scope of the claim (stated precisely, P9): what is refuted is mechanical remap from a matched sibling (0/31, strong). What remains formally untested is whether an h_seq-staged draft plus the recovery ladder could bank some — but that is the path that produced the original CC1-FAILs, its labels were content-free until S43-3, and --hseq --only now stages 0 families for these addrs because none has a matched exemplar. Treat them as per-member drafting work (agent-class), not deterministic fuel — and cost the next wave accordingly.

Board correction: strike "26 unpropagated members" from the cheap-fuel list. It was three sessions old, never probed, and would have been priced at ~0 tokens (R37: probe before costing — this is the rule's own failure mode, caught by applying it).

▶ S43-5 — the serial queue: `func_8017EF68` is at 2 of 969 and was measured against the WRONG BODY for months (2026-08-05)

Ran the queue's mandatory all-drafts scan before drafting anything (S4's law). It paid immediately, and in a way that indicts the queue's own annotations.

The queue list's sizes are wrong — func_8017EF68 is listed as "969" but is 12 ins in ov_SC03_007; func_8017CE58 is listed "733×3" but is 246 in ov_SC02_000. Cause: the third instance of today's address-collision pattern. Both addresses host two unrelated bodies: 0x8017EF68 = 12 ins (ov_SC03_007) and 970 ins (ov_SC06_000); 0x8017CE58 = 246 (ov_SC02_000/003) and 734 (ov_SC03_092).

Consequence: the stored draft .run/drafts-p30beh/func_8017EF68.c is a 969-instruction draft. Measured against the 12-ins body — which is what every scan keyed on name+home did — it scores 969 mismatched and reads as garbage. Measured against its OWN body (ov_SC06_000): DIFF 969/969 ins, 2 mismatched, SCHEDULE-REORDER/2, profile=schedule.

It is a two-instruction adjacent transposition — lw $v0,0($s3) ↔ srl $a2,$a1,16 at idx 75/76, registers, frame, spill map and every other instruction already byte-exact. The draft's header documents five byte-measured levers that took it 827 → 2, a "DO NOT RE-BUY" list of ~20 spent hand variants, a §49 root-cause analysis (a sched2 INSN_LUID tie: both candidates measure priority 3, so the backward scheduler picks the larger LUID, and sched1 sinks the srl to just before its consumer which gives it that larger LUID — the target needs the opposite sign), and it ends: "NEXT STEP: this is the permuter's exact profile."

And the permuter could not run on it. .run/drafts-p30beh/ is one of the 63 GTE-draft directories S43-1 unblocked — so this function has been sitting one working permuter run from a bank, with a note on disk naming the permuter as the next step, for as long as the silent fallback existed.

Status: ILS (schedule profile, 6 cycles × 240 s) reached the same 2 and held it flat — the tie survives the repaired permuter's directed search. A longer free run (12 × 600 s) is queued. Logged to the backlog at closeness 2 with the correct binary. Escalation from here is Fable5 (§45's gdb-on-cc1 read of the scheduler is exactly this class) — that needs Drew's go (R27).

Queue note: func_8017C974 (22 drafts on disk) best-of-22 is 812/947 — genuinely far, not a near-miss; func_8017CE58's only draft is Ghidra-C and CC1-FAILs. Re-derive every queue entry's size and home from the bytes before briefing an agent on it — the list's annotations are unreliable.

▶ S43-6 — `func_8017C6F4` CRACKED by Fable5, pin-free, and banked ×4 (~3,788 ins) (2026-08-05)

Drew approved the Fable5 escalation (R27). Two isolated agents, one per function, never batched.

RESULT: byte-exact, pin-free, 947 ins — and my diagnosis was wrong. I had this filed as §147-E, a qty_compare tie unreachable from source. It was variable-identity evidence all along:

the X-pass and Y-pass min/max intermediates are different variables (8, not 4 reused);
mnc/mxc do not exist — the cell clamps reuse the PRIM-LOOP mn/mx (X) and mny/my (Y). Ablations prove the conjunction is required: split-only 63, reuse-only 624, both = MATCH. That also explains why S42's "separate X vs Y variables" probe was recorded as a failure — it was half the fix. And why every allocator lever was inert (pins, §148-C sliders, declaration order, 14 permuter restarts): the draft had the wrong NUMBER OF PSEUDOS, which no allocator steering reaches.

Verified independently before believing it (R14): match_one MATCH (947 ins) re-run by me, then the whole-binary gate.

BANKED ×4 — every 948-ins sibling of this body:

binary	SHA (byte-identical)
ov_SC03_126	`c48a8bb894974dd3746a5833a20ee6da2feb831f`
ov_SC03_003	`898bf52a903dcb74ce11d2a8389c483ecc24e49e`
ov_SC04_021	`336142349b39ea4f5139b035fdb1ca8d8e7961c8`
ov_SC05_019	`3f5b4f132ed3ca63522d75c4021033b9d32b7a39`
`family_remap` produced all three siblings cleanly (SC03_003 remapped 4 per-overlay symbols; the other
two needed none). ≈3,788 instructions. ⚠️ These are INCREMENTAL-build gates — R22 clean-fleet is
owed before the commit is trustworthy (§130: an incremental build can pass what a clean build cannot
even link). Deferred only because the second Fable5 agent is reading `asm/` and `make clean` would
destroy its inputs mid-run.

The propagation gotcha (§146, seen again): all three siblings first failed the gate with PLUMBING: parse error before 'MTX_C6F4' — family_remap's _carry_macros carries #defines but not typedefs. Prepending the 9 typedef lines to each remapped draft fixed all three. Worth noting: that label is legible only because of this session's classifier fix — before it, this would have read CC1-FAIL: make: *** Error N and cost three manual splice-and-rebuild diagnoses.

Idiom distilled → cookbook §150 (a register rotation across symmetric blocks is variable-identity evidence; decode ownership from the MATCHING diff regions first; per-instance register asymmetry ⇒ per-instance variables; a deleted self-move in one of two symmetric blocks is the tell; and the global.c:719-vs-:729 death-before-store exemption that produces it). §147-E corrected: it named the wrong allocator — these are global.c allocnos, not local qty_compare quantities.

▶ S43-7 — `func_8017EF68` CRACKED (the 2-of-969 wedge); R22 CONFIRMS ALL FIVE BANKS 140/140 (2026-08-05)

The second Fable5 agent matched the function whose draft had been sitting one working permuter run from a bank — MATCH 969/969, re-verified by me, then gated: ov_SC06_000 byte-identical at da4a26ffffe8759929aa078aac7285738089a1f2.

The mechanism is a machine-model constraint, not a tie (read from cc1's own -dR trace): the r3000 description gives the memory unit load-ready-cost 2 and store 1, so blockage(load,store) = 2 — a load can never be picked in the tick immediately after a store pick. sched2 therefore ALWAYS wedges one ready ALU insn between the lw and the sh, and the target's zero-wedge order is unreachable by any statement order. That is why ~20 documented hand variants AND the repaired permuter both floored at exactly 2. The draft's own §49 "sched1 LUID/sink" story was incomplete — real but secondary.

The lever (→ cookbook §151, "the ghost wedge"): a zero-emission tied in/out asm __asm__("" : "=r"(v) : "0"(v), "r"(rival)); — same-reg, empty template, 0 bytes, but a schedulable insn that absorbs the blocked tick; it also sets reg_n_sets(v)=2, killing sched1's birthing boost, so one instrument acts on both passes. Two measured fallouts closed it: read the rival in the same asm (density flip, 22→12), then a second re-tie on a high-ref host to restore allocno live-length parity (each in-loop insn is +1 live length for every loop-spanning allocno, and a trio of invariant addresses sat exactly on allocno_compare's integer-floor boundary). Host choice is empirical: pkt ⇒ MATCH, ot ⇒ 705 off, doubling the first host ⇒ 10 off.

✅ R22 CLEAN-FLEET — 140 passed, 0 failed of 140

make clean && make extract-all && make check-all from a genuinely clean tree. This discharges the [R22 PENDING] caveat on commit commit:1484 — all five of today's banks are confirmed, not incremental-build artifacts (§130).

FLEET AFTER S43

96.63% fn-count · 94.9% instr-weighted (12,489,130 / 13,160,961) · 89.2% distinct-code (78,084 / 87,459 uniq) · 0 NON_MATCHING in any default build (G4) · dedup 1919 groups. Session delta: +4,757 instructions banked (12,484,373 → 12,489,130), all from 2 cracks ×5 binaries. Distance to P30's 95% instr milestone bar: 13,782 instructions (was 18,539 at session start).

▶ S43-8 — the 0xECC family: ONE crack = 12 overlays / 11,364 ins; and SIZE is the family key (2026-08-05)

Three isolated cheap-Opus agents, briefed with §150/§151 and told to open with the all-drafts scan, converged independently on the same discovery: func_8017C6F4 is not one function. The same 947-ins body (0xECC) appears in 12 overlays under 5 DIFFERENT NAMES at 6 DIFFERENT ADDRESSES, each differing by exactly two per-overlay symbols (a screen-rect helper + the 64×64 cell table).

overlay	fn	overlay	fn
ov_SC01_077	func_8017C974	ov_SC03_007	func_8017C59C
ov_SC01_080	func_8017C59C	ov_SC03_012	func_8017C59C
ov_SC02_000	func_8017D538	ov_SC03_023	func_8017C59C
ov_SC02_003	func_8017D538	ov_SC03_028	func_8017DF98
ov_SC02_004	func_8017C59C	ov_SC03_030	func_8017C974
ov_SC02_005	func_8017CF90	ov_SC07_010	func_8017C59C

GATED 12/12 whole-binary, 0 failed — and each built image independently re-checked against its own config/check.<bin>.sha (12/12), stubs confirmed replaced by real definitions. 11,364 instructions from this morning's single crack. (A cosmetic artifact: my gate log printed one final SHA for both SC02_000 and SC02_003, whose locked SHAs differ; the independent per-binary check shows each matching its own target. R22 is the arbiter.)

⚠️ WHY IT HID FOR 30 PHASES — and the new family key (→ cookbook §152): name-keyed grouping scattered these across five names, and h_seq grouping scattered them too. The key that finds them in one command is BYTE SIZE: grep -rl 'nonmatching .*, 0xECC' asm/*/nonmatchings/*/ returns exactly the 12 with no false positives. Size is an allocator-independent, cache-independent family key that reads the asm rather than a manifest. This refines the Phase-26 "h_seq is spent" finding: h_seq is still worth exactly ONE size-keyed sweep behind each FRESH core crack — here it paid 11:1.

Two agent-supplied cautions, both verified and both worth keeping:

A masked tool cannot validate a remap. match_one and rtu_match both mask jal targets and %hi/%lo immediates — precisely the fields a remap edits — so a WRONG symbol map still reports MATCH. One agent re-checked all 12 against the raw unmasked call-site pattern before claiming them. Remaps are gated by the whole-binary SHA, never by a per-function tool.
A stale residual is not evidence that two functions differ. I briefed one agent that func_8017C59C was a different body because an old draft scored 340 against it. Refuted: that 340 came from a PRE-§150-fix draft, and a wrong draft scores nonzero against every family member including its own target. Re-measure with the CURRENTLY BANKED draft before accepting a "different body" verdict.

Tool defect found (R32 class, not yet fixed): family_remap.py's raw output does not compile — its unit backscan accepts only blank/extern/comment/typedef lines, so it halts at the first #define and never chains back past it. Measured: 16/16 gte macros carried, 0/10 typedefs carried, silently. This is the same §146 gap seen from the other side, and it is why the sibling gates needed typedefs prepended by hand. Fix: let the backscan skip #define continuation blocks, or floor it at the macro-carry's own start line.

⚠️ S43-9 — MY ERROR, RETRACTED: I measured the STUB BASELINE and called it a bank

I reported the 263×5 cluster (0x80182fd4, 5 members, cross-address) as "all five byte-identical, 1,315 ins". FALSE — nothing was banked. family_sweep --stage-only staged the drafts, but they were reverted before my hand-built make build, so every SHA I compared was the INCLUDE_ASM stub baseline — which is byte-identical by construction, because INCLUDE_ASM pastes the original asm. This is R34's trap exactly (the byte-gate is a perfect CORRECTNESS oracle and a NULL COVERAGE oracle — green since Phase 5 at 0% decomp), self-inflicted by hand-building instead of using harvest_verify, which splices/builds/reverts atomically and reports verified-vs-failed. The lesson, now paid for twice in one session: never hand-build to test a draft; the gate's verified/failed count is the only reading that distinguishes "matched" from "the stub is still there". The cluster returns to UNRESOLVED. Its real finding stands and is separate: the staged draft compiles clean, so the 0/5 parse error before 'unsigned' came from a gate-pipeline transform, not the remap — worth pinning, since it may be silently killing other sweeps. (Also corrected: my "41 behemoth drafts" was a FILE count — 79 unblocked files resolve to 20 distinct functions, 36 of them fragments of one small function.)

▶ S43-11 — the 263×5 cluster BANKED 5/5: the sweep's own pipeline was corrupting byte-correct drafts (2026-08-05)

Redo of S43-9's retracted claim, done correctly through harvest_verify (splice → build → keep iff byte-identical → revert), not by hand-building. 5/5 banked, 1,315 instructions, each independently re-verified three ways: image SHA == locked SHA, stub gone, real definition present.

binary	fn	binary	fn
ov_SC03_101	func_801814F8	ov_SC04_005	func_80181054
ov_SC03_104	func_80184934	ov_SC04_007	func_8017FF08
ov_SC04_003	func_8017E4F4

THE DEFECT, PINNED — and my first hypothesis was WRONG (R14, corrected in place). I wrote that a gate-pipeline transform was eating a /* opener and turning comment prose into code, because the only unsigned in the draft sits inside a comment. Refuted by test: every ladder step — cast_call_sites, sig_unify, reconcile_tu, each run with the gate's real --src-file — preserves the comment intact.

The real cause is the family_remap TYPEDEF-CARRY GAP (§146/§152), full stop. The staged draft fails as `Vec8_80182FD4' undeclared (first use this function) — the type the body needs was never carried, because family_remap's unit backscan halts at the first #define. parse error before 'unsigned' was simply that failure surfacing at the next recognizable token, the following extern unsigned char … line. A misleading label, not a second defect.

Why direct gating banked all 5 anyway: the TARGET TUs already declare that type at file scope, so the splice compiles even though the draft fails in isolation. That is the rule worth keeping — the typedef gap is fatal only when the target TU does not already declare the type, which is exactly why this family looked like an intractable "parse error" wall in the sweep and banked instantly when gated directly. Fixing family_remap's backscan (let it skip #define continuation blocks) closes the whole class; until then, gate remapped drafts DIRECTLY rather than through family_sweep's ladder.

The workaround that banked them: carry the exemplar's typedefs onto each remapped draft by hand (the same family_remap _carry_macros gap as §146/§152) and gate directly, bypassing the sweep's recovery ladder entirely. Drafts + gate logs: .run/s43/cluster_gate/.

▶ S43-12 — L1+L2 SHIPPED: `make audit-disc`, the partition HOLDS at residue 0 (2026-08-05/06)

Drew's task #10, delivered. tools/disc_audit.py + make audit-disc, ledger at docs/disc-ledger.md, machine copy .run/disc_audit.json.

THE PARTITION HOLDS — residue 0 over all 416,021,760 disc bytes, 1,291 payloads examined:

bucket	bytes	share
onboarded-code	47,066,812	11.31%
unclaimed-code	3,564,021	0.86%
classified-data	134,265,572	32.27%
audio-video	184,338,000	44.31%
filesystem-metadata	46,787,355	11.25%

THE ANSWER TO THE QUESTION THAT MOTIVATED IT: 34 UNCLAIMED code payloads / 3.56 MB — code on the disc that no onboarded binary claims. Largest is MAIN.CD sub-file 12, entry 1, type 1, 383,783 B; the rest are small type-1 entries, overwhelmingly in MAIN.CD. These are the "there was more code all along" surprises, enumerated instead of stumbled into.

Design (the three past surprises, each designed out): walks the DISC IMAGE not our configs · whole payloads, no window · decodes both the raw and LZSS layers. claimed-by is DERIVED (R33) from config/check.<bin>.sha — that hash IS the build's own byte-identity gate, so it cannot drift.

L2, the SECOND DISAGREEING ORACLE (R34), earned its keep immediately — it found two L1 defects:

A claim outranks a heuristic. I let the statistical verdict override a SHA match, so claimed binaries were being filed as classified-data. Onboarded bucket was understated by 14.5 MB.
Whole-payload averaging DILUTES code. A real overlay is code + a large data tail, so its whole-payload valid-ratio lands ~0.87, under L1's 0.90 gate — while L2 carves real functions from its head. My "classify the whole payload" fix (for the old 4,096-word window) had simply traded a head-only bias for an averaging bias. 80 disagreements, all this shape. Resolution: a claim wins outright; otherwise take the UNION of the two oracles — over-reporting code puts a payload in a review queue, under-reporting it hides code, which is the exact failure mode that produced the three surprises. Unclaimed code went 1.70 MB → 3.56 MB once fixed.

My own first run FAILED the partition by −49,709,520 B and the fail-closed exit caught it: .DA entries' LBAs point past track 1 into the CD-DA tracks (double-counted against the whole-track audio total) and .STR/.XA are MODE2 FORM2 (2324 user bytes/sector, not 2048).

Known gap, stated not hidden: LIST.CD fails the TOC walk (it IS the TOC cache, not a container) and is booked as data. Not in tools-health — it needs disks/, which a fresh clone lacks (H1). Next (task #11 / L3): the emulator tour resolves whether these 34 are the 39 type-1 modules, gives their load addresses, and proves completeness against execution.

▶ S44-I.0 — the new-code campaign opens: knowledge captured (2026-08-06, Fable5Max plan approved)

Plan: ~/.claude/plans/optimized-squishing-engelbart.md (Part I this session, Part II fresh). Three exploration agents broke the 78-payload class open; everything captured while hot (R30/R31):

docs/memory-map.md §"Phase 30 S44" — the COMPLETE static loader routing table (loadDestPtrTable slots · boot k-set {1,3,8,10,11} · resident tables D_800D3764/D_800D384C → slots A/B 0x800CAE08/0x800CCB1C · MAIN/12 → 0x80128158 · SC07 pair → 0x801A00D8 · gbase arithmetic · slot-adjacency proof · module-id law · "type 1 = uncompressed overlay"). Supersedes P3-T5's "runtime-indexed, no static xref" and P27's "only knowable by runtime RE" (disc-completeness.md corrected in place, H5).
docs/tooling-audit.md §S44 — EVERY tool classified (a/b/c/d) with file:line: 8 code-changes, 7 registrations, 5 retirements, the rest auto-OK/N-A. The "every single tool" deliverable.
docs/decision-log.md — the R31 pivot entry (why L3 shrank; why the doctrine was missable: a confident negative doctrine is a claim like any other — the §146/§147 lesson at doctrine scale).
Cookbook §154 (+ index regen, 454 sections): module-id word / dual base-voting methods / type-1-is-an-overlay. Key numbers: big-3 base 0x80128158 at ~500:1; ~75-77% h_exact-known; 802 novel fns; 46/78 addresses static; 28+4 parked for L3.

▶ S11 — the propagation lag: EXTEND 0/36 -> 31/36, and every blocker was a DECLARATION (2026-08-03/04)

Lane 2 of the S10 checkpoint ("26,006 ins, ~0 agent tokens, PARTLY BLOCKED"), taken first on the standing doctrine that the cheap deterministic lever is probed before the expensive agent one.

EXTEND shape — 31 of 36 banked (was 0). Every failure was captured from the compiler's own output (§136a) rather than guessed, and the 9-per-binary failure set reduced to 4 distinct symbols repeated across all four SC07 binaries plus the 4 "DIFF"s:

func_80146C3C (8 of 36) — one token. Two macros declared it (void); the SC07 TUs declare (u8 *a0). Both macros already CAST at the call site, so the prototype is codegen-irrelevant -> relaxed to (). Measured BEFORE editing: all 4,020 fleet decls are (void)/()/(u8*)/(u8 *a0) — no default-promotion param anywhere, so gcc-2.7.2's () dead-end (which needs a promoting param) cannot bite. T2 but 2 lines.
func_8014F4C0 (self-axis, 4), D_80126CC4 (3), func_8012E5CC (1) — T1, binary-local. Conformed the SC07 decls to the fleet-canonical form. Each has zero uncast uses in its TU (verified per file), so they were splat boilerplate with no codegen effect.
One conflict hid another: fixing func_8012E5CC revealed func_80147364 behind it — the S29 law that a declaration conflict ABORTS the compile, so one error says nothing about the next.

The 4 "DIFF"s are a volatile declaration, not a codegen wall. dedup_extend's own header records them as UNDIAGNOSED while its correctness argument says an h_exact match makes a DIFF impossible. Both halves resolved against the bytes:

The contract HOLDS — func_80162FF4's original bytes are sha1-identical in ov_SC07_006 and ov_SC01_000 (af1aceb2…).
The cause is TU CONTEXT — the SC07 host TU (_jr_8015C32C.c:1177) declares extern volatile s32 D_80127090/94/98 at FILE scope; none of the 134 working overlays' copy of that TU does. Volatile makes the macro's three stores a scheduling barrier, so addu $a0,$s2,$zero cannot sink into the jal func_80146D30 delay slot — the built body emits it early plus a nop, one instruction longer. Measured word-for-word: built +0x090 addu / lui,sw x3 / jal / NOP vs ref +0x090 lui,sw x3 / jal / addu-in-delay-slot. All 4 macros touch exactly those 3 symbols, which is why all 4 fail in all 4 binaries and nowhere else. Fix: the §37/§124 DATA asm-label alias inside the 4 macros — a distinct C identifier is immune to any TU's declaration and byte-neutral in the other 134. 16/16 banked on the retry.

Still open in this lane (both NAMED, neither a wall): func_80144B9C x4 — the whale's registry func field is a bare name, not a DEFINE_ macro, so write_drafts emits a CALL (hence "undefined reference" in ov_SC07_010); it needs the §38 -O0 shared-header route, and dedup_extend should refuse-and-name the class per R32. And func_80149954 x1, blocked behind func_80147364's u16 params.

func_8012A598 banked x138 (3,288 ins) — and it took TWO fixes, either alone insufficient. The tool skipped it as missing file-scope extern (CARRY-FIXABLE): D_801151D4, D_80126DB8_a, D_80127504.

TOOL (R33): find_site's preamble backscan had the SESSION-18 fix for blank / // / SINGLE-LINE /* … */ lines, but a MULTI-LINE block comment still halted it — its middle lines start with * and its last line ends */ without starting /*. The §134 multi-line-blindness class, which S6b already fixed three times in family_remap. Replaced the line-syntax test with a decision on cdecl._mask (the project's ONE masking oracle) — it subsumes every comment form and cannot be fooled by a /* inside a string — plus an R32 assertion on the length-preservation invariant it rests on. Strictly monotone: it can only carry MORE preamble, and dedup_propagate is a byte-gate feeder (a bug here can fail to bank, never falsely bank).
EXEMPLAR: the body also declared a draft-local struct BigCopy164 tag, which the tool refuses by design (two macros defining one tag redefine it in a TU). The shared struct BigCopy (engine_types.h L312) is the identical layout and is already used this exact way at engine_core.h:16158, so switching the exemplar to it is byte-neutral. Probed on ONE member first: byte-identical 9052dc0e…; then 138 overlays byte-identical.

PROPAGATE shape — the head is 5 classes, not 45. .run/s8_lag.json re-split: EXTEND 13 classes / 45 stubs / 5,145 ins; PROPAGATE 46 / 783 / 20,861 — but 5 classes carry 18,545 ins (89%) and the other 41 carry 2,316. Ranked: func_80147364 30x137=4,110 · func_8012f274 29x137=3,973 · func_8016ba68 29x134=3,886 · func_8012a598 24x137=3,288 · func_801466f0 24x137=3,288.

func_80147364 banked x137 (4,110 ins) via the DEFINITION-SIDE asm-label alias. Its byte-true definition is (u16, u16) while the fleet declares it (u16, s32) in 4,046 places — u16 is a default-promotion type, so the () escape is ILLEGAL and a decl conform would change caller codegen. The alias gives the definition a distinct C identifier while emitting the real symbol: zero blast radius on every caller. Probed on ONE member first (1 build, not 137 — the S29 discipline): byte-identical 9052dc0e… first try, then the full run: 137 overlays byte-identical. In-tree precedent for the form: 1,725 files already use it.

Named + sized, not yet banked: 0x8012a598 skipped missing file-scope extern (CARRY-FIXABLE): D_801151D4, D_80126DB8_a, D_80127504. 0x801466F0 reports "no source overlay has it matched" — the S6b D4 case, still unfixed: its def in ov_SC01_077_after.c:495 carries a wrapped __asm__ alias decl and _alias_decl_for is a single-line rx.match (the §134 multi-line-blindness class), plus a file-scope typedef struct Rec801466F0 that a macro body cannot travel with (§100).

My process errors this block, recorded: (1) I wrapped the first R22 in nohup … & inside a backgrounded call, so the harness signalled completion of the WRAPPER while the fleet check stood at 63/140 — I nearly read that as a pass. Wait on pgrep -x make, never on a wrapper's exit. (2) I ran a corpus.stubs probe while make extract-all was mid-flight and got garbage; R32's coverage assertion refused to answer instead of returning a wrong stub set. A measurement taken during a rebuild is not a measurement — S27's law, re-earned. (3) CORRECTION to the S10 checkpoint's own waiter rule. It says "use pgrep -x make (exact process name)". That is right for a single make, and wrong for a CAMPAIGN: dedup_propagate runs a SEQUENCE of make build BINARY=<ov> calls, so between any two there is a window with no make process — my waiter fired in one and reported "done" on a live campaign whose log had one line. This is the identical structure tools/treelock.sh's own docstring warns about ("guard the CAMPAIGN, not the process"; a pgrep poll is a sampling test on a gappy signal). Wait on the campaign itself — pgrep -f dedup_propagate / family_sweep — or on tools/treelock.sh --status, which is a statement of intent that spans the gaps. Three waiter failures now share one mechanism: the signal being sampled is not the thing being waited for.

▶ S6a — the source-agnostic zero-crack sweep: 842 banked, and the residue is OUR TOOLING again (2026-08-01)

Setup, measured before running anything (R37 — probe before costing). The 190 zero-crack families (129,997 templatable ins) were decomposed with zero builds by remapping each family's exemplar onto one member and type-checking the resulting draft statically: · 117 families / 92,368 ins / 2,735 member-slots — draft self-contained ⇒ sweepable now. · 17 / 24,332 ins — the §94/§100 class: the body uses a file-scope MULTI-LINE typedef, which extract_unit cannot carry (it carries single-line ones only). Head prizes 0x8012b77c (ov_SC07_006, 139 members, Ang2_8012B77C) and 0x80128c98 (ov_SC01_077_a, 275 members, CdFileLoc) = 14,937 ins. · 9 / 9,364 ins — has_mid_jr ⇒ the §53 carve path, not this sweep. · 47 / 3,933 ins — remap_hseq REFUSES (mostly unresolved immediates). Genuine, small.

⚠ PREMISE CORRECTION (R14) — the checkpoint's stated mechanism was wrong. The post-wave frontier says these families were unreachable because "every sweep this project has run passed --source ov_SC01_077". It is not the mechanism: --source ov_SC01_077 is the default, and hseq_sweep's override block only fires when source != EX_OV, so the manifest's own non-ov077 exemplar was already being used. The real gate is --band substantial (the default): of the 181 non-jr zero-crack families only 13 are substantial — 114 mid, 54 tiny. --band all is the unlock, exactly as the S1 trap note warned. (The 106 non-ov077 exemplars are real and interesting; they were not what blocked the sweep.)

Result: family_sweep --hseq --band all -j12 --only <117 addrs> staged 2,735 drafts / 1,239 groups, 0 skips → BANKED 842 / 1,893 failed. R22 clean-fleet make clean + extract-all + check-all → 140 passed, 0 failed of 140. Fleet 94.43→94.67% fn-count · 91.4→91.6% instr · 84.0→84.5% distinct.

The residue is bimodal, and that is the finding: 57 families banked ALL members, 52 banked ZERO, 8 partial. A per-member compiler wall does not produce that shape; one per-family blocker does. Eight zero-banked families were probed with a new generic blocker-capture (.run/s6_diag.py — the any-overlay sibling of S29's ov077-only .run/uc_capture.py: remap → splice → build THAT overlay → read the compiler's own error → revert; one build per family, not 137). Seven of eight are declaration/carry plumbing; one is a genuine byte DIFF. Two are proven defects in tools/family_remap.py, both located at source:

D1 — the preamble backscan's {-guard does not exempt comment lines. The guard is a real T65 fix (extern void f(int); int g(){…} on one line), but it fires on any documentation line that merely mentions a brace, so the carry stops mid-comment and the sibling receives a dangling * … fragment → parse error before 'the' (0x80176144, 0x80146afc).
D2 — _def_head_at returns True on "param list continues past this line ⇒ ANSI definition". False for a wrapped multi-line DECLARATION (extern void func_801466F0(s32 a0, …,\n s32 sp8);), so extract_unit accepts line 457 of ov_SC01_077_after.c as a definition head and returns a 16-line fragment that contains no function body at all (DEFINE_func_801466B4() + #include "common.h" + a comment), terminated by a brace pair inside that comment. Verified directly: _def_head_at('extern void func_801466F0(s32 a0, s32 a1, s32 a2, s32 a3,', idx) -> True. This is the §110/R35 class again — a silent 0/137 wearing a compiler wall's clothes.

S6b — the fix belongs in the TOOL, not in 17 exemplars (R33). The plan was to hand-move each MISSING-TYPE exemplar's typedef into its function body (§100, byte-neutral, 17 edits + 17 verifications). Probing the class first showed it is the SAME root cause as D1/D2 — a multi-line construct read one line at a time — so it was fixed once, in family_remap, for every future family instead:

D5 — _typedef_block_start(): on a } T; closing line, walk up to the matching typedef (both the typedef struct { and brace-on-its-own-line forms) and carry the WHOLE block. Only blocks that literally begin with typedef are carried (a struct VARIABLE closes identically but would be a duplicate global in the sibling); safe because harvest_verify already strips a typedef the sibling TU provides. The old code comment claimed these functions "route through the engine_types.h lift" — measured, they routed nowhere: 17 families / 24,332 ins were simply dropped.
D4 — the wrapped asm-label alias (_alias_decl_for is a single-line rx.match) was MEASURED (1 exemplar, 0x801466f0, 137 members / 3,288 ins, with a second blocker behind it) and deliberately left unfixed. It now returns None, so the sweep reports skipped {'no matched unit for func'} instead of failing 137 times. A known gap that announces itself is not the same defect as a silent one (R32).
Also hardened: the forward body scan now counts braces in cdecl._masked text (R33 — one masking oracle), so a brace inside a comment or string can never close a function body.

Blast radius verified, not assumed (R14): extract_unit output diffed against the pre-S6 tool over all 181 zero-crack exemplars — 157 byte-IDENTICAL, 24 changed, every change in the intended direction (more preamble carried; one → None, the D4 case that previously produced garbage).

Measured payoff of the repairs, one sweep each: · D1+D2 → +323 members recovered from families that had banked zero. · D5 → +417 members, including func_8012B77C 139/139 (8,062 ins — the head prize) and func_80128C98 137/275; func_80146AFC 135/137, func_80176144 99/137. · S6 total: 1,582 member-matches. The pre-fix tool scored this same population at 842. R22 clean-fleet make clean + extract-all + check-all → 140 passed, 0 failed of 140. Fleet 94.43→94.88% fn-count · 91.4→91.9% instr · 84.0→84.6% distinct; phase arc from open (92.00 / 87.5 / 78.0) = +2.88pp fn · +4.4pp instr · +6.6pp distinct.

Family state now: 70 ALL-banked · 17 partial · 94 zero-banked; 64,050 templatable ins still open. Distilled to cookbook §134 (the MULTI-LINE BLINDNESS class + the bimodality tell: 57/52/8 is a tooling signature, not a codegen one — read ONE compiler error before believing the compiler).

✅ S6h — wave 3 (38 targets, size-routed) + an 8/8 reconcile lane (2026-08-01)

38 targets / 44,297 templatable ins — the 11 high-multiplier families at 61-120 ins plus the top 26 of the 10-19-member band, model-routed (Haiku ≤89 with Opus escalation, Opus direct ≥90). 52 agents, ~4.1M tokens, 30 min → gate banked 27/38 (71%). All 11 failures were captured and classified: 8 declaration/link plumbing · 3 genuine byte-DIFF. An 8-agent Opus reconcile wave then fixed 8/8 (7 banked; 1 re-failed) → wave-3 total 34/38 = 89%, propagation +639 members / 1 failed / 83 overlays. R22 clean-fleet 140/140. Fleet 95.23 → 95.42% fn · 92.1 → 92.4% instr · 85.0 → 85.5% distinct.

The reconcile lane is now 12/12 across two waves and is the most reliable stage in the pipeline. Design note (S27 law, applied BEFORE it bit): six of the eight reconcile targets share ONE TU, so this wave forbade agents any build — six concurrent splice-builds would have clobbered a tracked file. Wave 2's reconciles were allowed one build each because they were spread across TUs.

The agents out-diagnosed the blockers I handed them — three findings worth keeping: · func_801848B0: an agent REJECTED MY PREMISE. I told it the draft was byte-correct and only declaration-blocked; it ran match_one first, found a real 1-instruction DIFF, and fixed both. R14 coming back at me from a subagent, correctly. · func_8017C5F0: the "invented symbol" was an INTERIOR ADDRESS. D_801DA0F0 has no symbol because it is offset 0x6C into D_801DA084 (which spans 0x801DA084..0x801DA103, asm/ov_SC02_027/data/tail18.data.s). The lui/addiu pair builds an interior pointer — a class the drafters will hit again. · func_8018A860: the TU declares memcpy THREE times with incompatible signatures (L81, L1518 builtin-compatible, L1524), and a latent byte bug sat behind it. A TU that declares one symbol three ways is a defect waiting for the next draft that touches it.

Carried (4): func_80184A94 (reconciled to match_one MATCH, still gate-refused) + the 3 genuine byte-DIFFs func_801845B0, func_8017BEBC(ov_SC02_026), func_8018480C — real codegen residuals, ledger material.

✅ S6g — wave 2: 83% → 93% bank rate from ONE batch of learning (2026-08-01)

15 targets (11 fresh Haiku + 4 gate-failed reconciles on Opus), 15 agents, ~0.74M tokens. Gate banked 14/15 (93%) — up from wave 1's 20/24 (83%) — and all 4 reconciles banked. Propagation +328 members / 0 failed / 76 overlays. R22 clean-fleet 140/140. Fleet 95.13 → 95.23% fn · 92.0 → 92.1% instr · 84.9 → 85.0% distinct.

Three changes between the waves, each fixing a wave-1 failure — this is the S27 finding reproducing (57→79→100% there, 83→93% here):

Args pasted from the DERIVED manifest, not typed. All 30 paths verified present on disk before launch (asm 15/15, tu 15/15).
Blocker-capture before the reconcile fan-out (the S29 law: agents cannot run the gate, so a match_one-MATCH draft that dies on conflicting types for D_800A5E88 looks like a codegen problem to them). Each reconcile agent got the exact symbol + line, plus the two byte-neutral levers (conform-and-cast-at-use; the §37/§124 asm-label alias).
Wave-1's Opus DISCOVERIES became wave-2's Haiku INSTRUCTIONS (the ori-vs-addiu unsigned destination rule; the store-sinking scheduler rule). The flywheel closing on itself.

The reconciles produced better root causes than my captured blocker did — worth keeping: · func_80189B78: my capture named ONE conflicting symbol; the agent found the draft had invented prototypes for six the TU already declares, two of them AFTER the splice point where cc1 had not yet reached. Fixed by copying all six from the TU verbatim and pushing every type disagreement to a cast at the call site — zero bytes changed. · func_8018584C: lever (A) was blocked in both directions — the draft cannot use the TU's tag (it must also compile standalone for match_one) and cannot redefine it. Closed with the data form of the asm-label alias: extern struct B16_8018584C aD800A5E88 __asm__("D_800A5E88"); (in-tree precedent at ov_SC06_008_jr_80135D20.c:1434). · func_80180A4C: the draft declared extern s32 D_801A9DA0[], the TU says extern u8 D_801A9DA0[] eleven lines after the splice point — conform to u8, the use site already casts. One character class, byte-neutral.

✅ S6f — the B-shaped wave: Haiku drafts, Opus closes, the gate arbitrates (2026-08-01)

The pool. Derived from the regenerated map: 36 families / 28,829 templatable ins that are kind=modal (no member matched ANYWHERE, so no sweep could reach them), ≥20 members, ≤60 ins, non-jr, and not one exemplar in ov_SC01_077. Calibrated by hand first (Phase-15/18 discipline): 3/3 one-shot — func_8017CDD8 (17 ins ×142), func_8017CE7C (16 ins ×126), func_8017E934 (29 ins ×65) = 330 members from 62 instructions of C, ~0 agent tokens.

The wave (Drew enabled Ultracode; Haiku drafters + Opus escalation, 24 targets). Haiku was the right tier by the cheap-tier-ab-validated measurement (≡ Opus at ≤~50 ins, ~4.8× cheaper); this pool is 16-53 ins. 31 agents, 0 errors, ~2.0M tokens, 12.5 min. · agents claimed 24/24 MATCH · whole-binary gate banked 20/24 (83%) · propagation +524 members / 0 failed / 91 overlays. 17 of the 20 banks were Haiku, 3 Opus. R22 clean-fleet 140/140. Fleet 94.97 → 95.13% fn · 91.9 → 92.0% instr · 84.7 → 84.9% distinct.

What Opus actually bought (it earned its slot on exactly the cases the A/B predicted): · a sh of a constant whose stored-width top bit is set needs a u16 destination — through s16 gcc-2.7.2 folds it sign-extended and li emits addiu; through u16, force_fit_type keeps it positive and li emits ori (func_8018A0F4). · a schedule-reorder closed by STATEMENT ORDER, not the permuter: gcc's list scheduler preserves relative order of disambiguable stores, so two field-zero stores had to be written ABOVE a three-halfword copy to sink correctly — 9 mismatches → 0 (func_8017CAB4). · three separate loose-typing fn-ptr casts (((void(*)(s32))func_80178D18)(a0)) where the TU declares (void) but the asm passes $a0 — a cheap drafter had misread all three as delay-slot / permuter-class residuals (func_8017EAAC, func_8017CBD4, func_8017D5C4).

⚠ MY ERROR, recorded (R37/R14). I generated the wave manifest to .run/s6f_wave_targets.json and then hand-transcribed the args into the Workflow call instead of pasting the generated file, pattern-filling _jr_8017BEBC across overlays where no such split exists (ov_SC02_027, ov_SC04_018, ov_SC03_002 — corpus.stubs says _jr_8017AE2C). Three agents lost time rediscovering the real paths and reported SPEC ERRATA. Cost: tokens, not correctness. The gate driver written afterwards (.run/s6f_gate.py) derives every TU/split from corpus.stubs per draft and asserts nothing — which is what the manifest should have done. Assert nothing you can derive.

The 24→20 gap is the known match_one→gate gap, not new: match_one compiles standalone and cannot see a TU-level declaration conflict (Phase-19 measured 88-92% match_one → 60-71% banking). 4 carried: func_8018584C, func_80180A4C (ov_SC02_026), func_8017CC80 (ov_SC02_027), func_80189B78 (ov_SC03_014).

✅ A + B — the ×138 era was NOT over: two 16-ins cracks bought 266 members (2026-08-01)

A (frontier regen at HEAD, R35). Sigs + family_hseq regenerated after S6's banks — required before pricing anything, and doubly so because .run/hseq_verified.*.txt has accumulated 22,841 files across every sweep ever run, so any per-family analysis that globs them over-counts. The regenerated map derives state from sigs + corpus.stubs (R33), which is the authority. Overlay-only frontier at HEAD: 95.2% fn / 92.3% instr / 85.5% distinct; zero-crack residue 106 families / 58,657 ins (was 181 / 120,633 at S6 open).

B — and the finding that matters. The S29 checkpoint's structural signal said "after S2 the ×138 era ENDS — those are the last two crackable fleet-wide families", and made that the trigger for T5/phase close. It is wrong, and this is the THIRD §133-class miss in a row. Re-derived from the family map, two fresh-crack families with ≥126 members were open the whole time: · 0x8017cdd8 ov_SC02_039 — 17 ins × 142 members = 2,414 templatable ins, PURE · 0x8017ce7c ov_SC03_114 — 16 ins × 126 members = 2,016 templatable ins, IMM Both are kind=modal — no member matched anywhere, so no sweep could reach them, and neither exemplar is in ov_SC01_077. They are invisible to exactly the two habits this phase already corrected.

Both hand-drafted off the .s, match_one MATCH on the FIRST try, ~0 agent tokens. Then:

First gate attempt FAILED, class PLUMBING (not DIFF) — my draft declared extern void func_8017CFCC(s32 a0); while the TU defines void func_8017CFCC(void). The target passes $a0 anyway (the caller's incoming argument simply still sits in the register — loose typing, §16), so the byte-true C calls it with no argument and declares it exactly as the TU defines it. Re-verified MATCH, then gated byte-identical in both overlays.
Propagated: 266 member-matches / 0 failed across 118 overlays — from 33 instructions of C.
R14 on the seed: the cached Ghidra-C for func_8017CE7C decompiled an entirely DIFFERENT body (three calls that do not exist in the asm). Reading the .s is what made it one-shot; a drafter trusting the seed would have burned the target and possibly ledgered it as hard.

✅ S6e — `--normalize-self-decls` measured to ZERO, but only after fixing the guard that made the measurement impossible (2026-08-01)

The S6a blocker probe found conflicting types for func_X on the SELF axis, which is exactly what family_sweep --normalize-self-decls targets (drop the sibling's divergent decl of the function being defined, cast its in-scope calls). It is OFF by default, so it was the obvious next zero-token lever.

Run 1: 0 banked / 1,622 failed — and 909 of 909 groups reported ⚠ self-decl edit NON-NEUTRAL. A 100% rate is a statement about the mechanism, not about 1,622 different functions (the §134 tell, one day old). The three earlier sweeps over the SAME population reported 0 NON-NEUTRAL.

The defect (D6, family_sweep.hseq_sweep): the TU snapshot was taken unconditionally, one line before the if nfix: that decides whether to edit at all — so a TU that NSD merely INSPECTED still landed in tu_snapshots, and the phase-2 MISMATCH backstop then attributed ANY group failure to a "self-decl edit" that was never made, reverting the TU and reporting 0/N banked. Measured directly: NSD fires on ~25% of members (3 of 12 probed), so ~75% of those reverts were attributing a failure to an edit that did not exist. The §103 tu-scope path immediately below has always snapshotted inside its own if _rep["moved"]:; NSD was the odd one out. Fixed to match.

Run 2 (fixed): NON-NEUTRAL 909 → 303 (~33%, consistent with the measured fire rate) — the fix is confirmed — and still 0 banked. The 606 groups that now took the NORMAL path banked nothing, so the verdict is real: this residue is not self-decl-conflict-bound. Lever measured, closed, zero.

One open item, deliberately not chased (it is no longer decision-relevant). I byte-measured a firing case myself rather than trusting the backstop (R14): func_80162CCC in ov_SC01_000 builds to 9052dc0e… with and without the NSD edit — i.e. byte-NEUTRAL, so the surviving 303 verdicts are wrong too. Most likely the sweep applies NSD to several members of the SAME TU and the backstop attributes an accumulated-state mismatch to "the edit". Left as a named open item because the lever yields 0 either way; it would matter only if a future population makes NSD worth re-testing.

✅ S3 — the close=0 stored-draft DIAGNOSTIC pass: measured, classified, and correctly NOT scaled (2026-08-01)

Chartered as "classify, and only build a fix if ≥3 share a named class". Ran exactly that; the answer is that no cheap shared class exists, so nothing was scaled. The population is bigger than the plan thought and worth less than it looks:

30 ×138 family heads carry a stored draft = 182,850 templatable ins (the plan said ~12 drafts).
Only 7 of 30 still verify (match_one MATCH). 23 have DECAYED — mostly LENGTH-DRIFT, a few SIZE-MISMATCH/WIDTH/ADDRESSING. ⇒ a stored draft's recorded closeness is not a current fact: 77% of this backlog no longer matches. Re-verify before valuing a draft (extends A10/T1a).
Of the 7 survivors: 1 banked clean (func_801754A8, 37 ins ×138 = 5,106). The other 6 failed conflicting types — and gate_stage's ladder recovered 0/6.
Those 6 split into: 1 §30#2 return-widen (func_8014C4AC) and 5 PARAMETER-signature conflicts (the Phase-16 def-side loose-typing wall, unchanged).

The §30#2 attempt, and why it was reverted (R14 + the anti-bulk-header law). func_8014C4AC's draft documents its own fix (extern void→s32 in engine_core.h, measured byte-neutral there) — but the note's claim that no split .c carries its own decl is wrong: the gate named _jr_80154C24.c, then _jr_80182268.c. A sed over every matching decl touched 2,046 files and STILL did not go green. That is precisely the "bulk header edits BREAK builds" pattern (§29 doctrine: call-site casts are the integration spine). Reverted; exemplar re-verified d19c9580. A fleet-wide decl reconcile needs a gated TOOL, not a sed — logged, not attempted.

Ledger: 23 decayed drafts → redraft lanes (they are not "nearly done"); 5 param-conflict → the def-side wall; 1 widen → needs the gated decl-reconcile tool. S3 is CLOSED as a measurement.

✅ S29 — `JR-PAIR-IN-ONE-O0-OBJECT` RETIRED: two instrument defects, both fixed; the pair banked (2026-07-31)

The S28 ledger class and its recorded escape (§81 step 1, isolate one fn into its own code subseg) are both refuted. Neither function needed isolation; neither is on a compiler wall.

Root cause 1 — jtbl_carve could not see a 4th table. ov_SC01_077_o0's carve at 0xb01a4 predates the §8e tables= persistence and is a merged double (func_8013C0F8 $L75 + func_8013C414 $L105); the second owner is MATCHED, so make extract pruned the stub .s that named its table. The tool's "single-table predecessor" inference therefore derived 3 starts where the object emits 4 tables, wrote JTBL_PADS := 0,4,4, and jtbl_rodata_pads refused mid-stream — correctly, with the exact message. Root cause 2 — the refusal left a corpse. as reads a pipeline, so it had already written a TRUNCATED .o (12 of 16 T func_; undefined $L57/$L59/$L63/$L75/$L76). make reported Error 1 and left the object on disk, newer than its .c — no .DELETE_ON_ERROR. The next build linked the corpse: that IS S28's undefined reference to $L105 + func_8013C938, one build downstream of a loud, correct compile error.

Fixes (both byte-gated). (a) Makefile: .DELETE_ON_ERROR: — negative-control-proven (make: *** Deleting file …), scratch invocation, tracked files untouched. (b) tools/jtbl_carve.py spec_from_starts: a R32 coverage assertion + payload recovery at the single choke point — every zero word inside a span is an original .align 3 pad (the tool's own axiom), so the word after it starts a table; recovered starts are logged. No-op where the structure is already known (the 134 sibling _o0c spans DO carry tables=+0x0,+0x70), so committed-green spans are untouched. Honest limit: only pad-separated boundaries are recoverable; a tight boundary still fails LOUD (short spec → filter refusal), never silently.

Byte proof. 4 tables at 0x801D8254 / 0x801D828C / 0x801D82FC / 0x801D836C (13/27/27/27 entries, each preceded by a zero pad); span 0xb00fc..0xb0280 = 388 B = 52+4+108+4+108+4+108 — closes exactly; derived spec 0,4,4,4 tables=+0x0,+0x38,+0xa8,+0x118. func_8013B83C (272 ins) + func_8013BD74 (198 ins) banked, ov_SC01_077 d19c9580, R22 clean-fleet 140/140 (make clean + extract-all + check-all — the incremental result was NOT trusted, §130). Fleet 93.25% fn-count / 89.2% instr / 80.5% distinct; dedup 1905/0; 0 NON_MATCHING. Cookbook §132 (incl. the reusable ladder: compile the ONE TU standalone and let .section .rodata + the nearest preceding .ent name every table owner — it found the 4th owner and attributed $L105 in one command, before any build or carve).

Sweep prep — the §94/§100 type-carry class, caught by probing ONE sibling (R37). The first sibling gate-failed. The §132 ladder named it in one command: the sibling object emitted only func_8013C0F8 + func_8013C414 tables — BD74's body never compiled (E_13BD74' undeclared). Cause: BD74's draft declared E_13BD74/P_13BD74 at FILE scope, and extract_unit/remap_hseq carry only the BODY — the exact class that held func_8013C08C at 0/137 earlier this phase. Fix = §100 draft-local types (moved both typedefs inside the function body; byte-neutral, exemplar re-gated d19c9580). B83C's draft was already draft-local, hence unaffected. A file-scope type in a draft is an exemplar-only bank: it passes the gate and silently cannot travel.

THE SWEEP — 137/137 both, i.e. 2 × 138 = 276 function-instances banked. jtbl_family_bank, BD74 first then B83C (order is load-bearing: B83C's table sits BELOW BD74's, so carving it while BD74 is still raw leaves an unmatched table inside the span — NON-CONTIGUOUS, byte-observed on the exemplar). ~8.5 s/sibling, zero-token. Both sweeps failed on the SAME single overlay, ov_SC07_010 — which is a property of that sibling, not noise, so I probed it instead of ledgering it and it returned 2 banks plus a real tool defect (§132a): jtbl_carve --like matches donor→recipient by the subseg's ROLE NAME; ov_SC07_010's -O0 region is named _o0, the same role as the exemplar's and the ONLY other overlay so named (the other 136 are _o0c, whose role never matched — the only reason the sweep worked at all). The exemplar had just banked 2 more owners than the sibling has, so the transfer derived SIX starts for THREE emitted tables. Guard shipped (jtbl_family_bank.like_arg: a sibling's own committed tables= is authoritative; --like is for a span with NO record — inert for all 136 already-banked siblings, fixes exactly the broken one).

Fleet after the sweep (R22 clean-fleet 140/140, make clean + extract-all + check-all): 93.33% fn-count · 89.6% instr-weighted · 81.6% distinct-code (72,416 unique fns, +260); dedup 1905/0; 0 NON_MATCHING. Phase arc so far: 92.00→93.33 fn / 87.5→89.6 instr / 78.0→81.6 distinct. That -O0 cluster is now COMPLETE across the fleet — the two functions were the last open stubs in every overlay's _o0* region.

✅ T0.5 COMPLETE — the fleet Ghidra-C prefetch: 124/124 programs, 7,716 files, 335 min, unattended

Zero-token, headless, resumable; imported ~120 overlay programs on demand and ran the DefineFunctions completion pass per program (raw-blob auto-analysis only finds the reachable subset — the Phase-10 finding, now automated). Coverage measured, not assumed:

5,777 of 6,070 families needing a fresh crack (95.2%) have a cached seed
main 2,001/2,002 (100%) · resident 14/14 (100%) · 1 residue (one main addr with no fn)

What this changes: the drafting surface is now fully fueled with NO MCP dependency, so waves can run unattended against any part of the fleet — the precondition Drew asked about. It also un-blocks P31's main-EXE campaign early (its 1,034 game-code stubs are all cached), though that stays P31 scope. tools/prefetch_fleet.py is committed and re-runnable; the Ghidra programs are script-reproducible, so only the tool is tracked, not the DB bulk.

✅ REDO UNDER LOCK — 52 cores + 911 members banked; R22 140/140; the "cliff" was an artifact

Re-ran the whole banking sequence serially under treelock.sh: parallel 8-binary gate → non-jr behemoth gate → sig+map regen (a bank invalidates the map) → tier-routed propagation (§123) → one R22 over everything.

Wave 3: 48/48 banked through 8 PARALLEL per-binary gates (the throughput unlock, proven).
Wave 2: 15/19. Behemoths: 4 non-jr confirmed (incl. func_8017E120 884 ins ×14).
family_sweep --hseq: 911 members banked / 401 failed across 137 overlays, 49 families.
Fleet: 92.59% fn-count · 88.2% instr · 78.7% distinct (70,506 unique fns) · R22 140/140.

R14 CORRECTION, on my own earlier claim. I reported a "per-binary bank-rate cliff" (SC03_014 1/6, SC04_018 1/6, SC06_018 2/6) and theorised a cause — canonical-decl maturity per binary. It was an artifact: those gates ran against a tree that propagation was concurrently rewriting. Re-gated clean, every binary banked 6/6. A measurement taken during corruption is not a measurement, and I theorised before re-running. Same failure shape as the phantom 91.4% in the same incident.

Carried, honestly: the h_seq sweep's 401 failures split as 137 "no matched unit for func" (the exemplar banked in a DIFFERENT binary than the sweep expects — a routing gap, likely cheap), 22 unresolved-immediates, 10 STRUCT (refused by design). One dedup_propagate run stopped the h_exact leg early (0x801466F0 rc=1) — the loop halted as designed rather than risking a partial write; the h_exact leg is unfinished and owed.

⚠️ INCIDENT 2 (mine) — a POLL is not a MUTEX: concurrent tree writers broke 63/140; reverted clean

What I did. Wave-3 gated 8 binaries in parallel (correct — the byte-gate IS per-binary) while wave-2's propagation loop was still running, then I ran make clean (deleting asm/) on top of both. check-all → 77/140, and the corpus denominator itself moved (353,720 → 353,691), so the apparent "91.4% instr" was an artifact of a half-written tree, not a gain.

Root cause — the guard was structurally unsound, not merely unlucky. My gate waited on while pgrep -f dedup_propagate; do sleep; done. But a CAMPAIGN is a loop of short-lived processes — 15 sequential dedup_propagate invocations — so between every pair there is a window with no matching process. The poll sampled one of those gaps, read "clear", and started. Presence- of-a-process is a sampling test on a gappy signal; it cannot express "a campaign owns the tree."

Recovery (clean, nothing lost that mattered). Killed the writers; git checkout -- src/ config/ back to commit:1245 (the last R22-verified 140/140 commit); all 58 drafts survive untouched in .run/ because agents never write the tree — the discipline that made this cheap. Re-verifying baseline, then re-gating and re-propagating serially under the lock.

Fix shipped: tools/treelock.sh — an flock(1) mutex held for the WHOLE campaign, released by the kernel on exit or kill, with --status. Both drivers now refuse to run unlocked. The general law (worth a rule at close): guard the CAMPAIGN, not the process. Corollary, the second time this session a killed writer hurt: a killed process performs no undo, so a fleet-tier write needs a lock ABOVE it, not cleanup inside it.

T3 BEHEMOTH WAVE (10 agents, 3.23M tok) — 7/10 CONFIRMED byte-matches at 700–970 ins, 0 disputed

Drew asked for up to 10 agents on the behemoths; grouping analysis first showed the ≥700-ins band is structured, not 29 singletons: one 16-member family @947, one 14-member @884, a 5-member @793, a 3-member @710, a 2-member @728, 5 true singletons — plus two groups that are TOOL jobs, not agent jobs (the 13-member IMM/jr @952 with 103 already matched → jtbl_family_bank carve; two 134-matched families with 4 stragglers each → sweep). All 10 agents therefore went to genuinely uncracked families/singletons, and each MATCH claim was adversarially re-verified by a second agent.

CONFIRMED (7): func_8017E120 884×14 · func_80191C50 710×3 · func_8017FA5C 728×2 · func_8018057C 897 · func_80181CDC 769 · func_8017CAD4 755 · func_8017E35C 719. NEAR (3), all with byte-grounded residuals: func_8017EF68 969 ins at closeness 2 — two transposed instructions, sched2 rank_for_schedule LUID tie-break, everything else (frame 0x228, spill map, every register) byte-exact · func_8017D174 793 at 82 (allocno tie + pin damage, length EXACT) · func_8017C974 947×16 at 812 (a pure regalloc cascade from ONE extra reserved reload reg; 598/957 regions already exact, no shape errors) — the last is the biggest family left and now has a full structural map + the exact gcc mechanism written down.

MY ERROR (recorded): I hand-typed the asm paths into the workflow args instead of passing the ones I had already DERIVED from corpus.asm_path in the same session — so several task cards named a split that does not exist (_jr_8017AE2C where the truth was _jr_8017C8D0 / _jr_8017C294). The agents located the real paths themselves and reported the discrepancy. Deriving then discarding the derivation is worse than never deriving it: it looks authoritative. Pass the artifact, never a retyped copy of it.

Gating plan (the jr/non-jr split matters): 4 confirmed are non-jr → gate freely. 3 are jr → their jtbl carve runs make extract, which rewrites asm/ under the 48 running wave-3 agents, so they are DEFERRED until wave 3 lands. Staged per-binary in .run/beh-gate/<binary>/ for parallel gating (7 distinct binaries).

T4 (partial) ✅ — the two "Phase-22 grinder bugs" are STALE carry items; the real fixes were elsewhere

Verified against the code, not the list (R14 on our own defect ledger):

"split-file-blind lookup" — ALREADY FIXED. asm_subdir_for globs nonmatchings/*/ which matches every split; verified on a _jr_ fn, an _o0 fn, and an absent fn. Struck.
"churn-without-blacklist" — ALREADY FIXED. The blind tried.clear() was replaced by input-signature gating in the T5 targeting work (re-open only fns whose draft mtime/closeness changed), and the blacklist exists. Struck.
Real fix taken instead (R33): asm_subdir_for was a PARALLEL implementation of corpus.asm_path that silently took g[0] on multiple matches — now derived from the oracle.
--fix-def-sig posture: flag correctly defaults OFF, but its help still advertised "Byte-neutral; gate arbitrates" — the exact claim T84 refuted (it imposed a signedness-wrong header decl over a byte-correct draft, slti/sltiu, and held 137 members at 0 until DROPPED). Help now carries the §119 warning. The posture was right; the documentation was the defect. Lesson for the phase close: the carried-defect list had 2 of its entries already fixed. A defect ledger nobody re-verifies decays into busywork — verify before scheduling (R35's sequencing applied to the backlog of our own bugs).

T3 wave 1 (Ultracode, 14 agents, 1.20M tok) — 14/14 match_one MATCH → 8/14 BANKED; the gate's propagation TIMEOUT left the fleet half-written (caught, reverted, tool fixed)

The wave: 14 fresh reach-138 cores in ov_SC01_077 (117,162 gain-ins in play), one agent each, drafting against the §31 map + cookbook with match_one/rtu_match self-verification. All 14 returned closeness 0, most cross-verified in the real TU. Whole-binary gate (the arbiter, §52b): 8 banked — func_80175820 (×276!) · func_8012E014 · func_80133298 · func_8015FBE0 · func_8016E9EC · func_80151C54 · func_8012F49C · func_80151B98. Bank truth derived from source (INCLUDE_ASM presence), never the gate report (§55b trap 4). 57% conversion = the §52b law holding exactly; the 6 rejects are all declaration/integration work their agents had already named.

THE INCIDENT (recorded, not buried). gate_stage hardcoded timeout=3600 on dedup_propagate. Ample for one bank; with EIGHT (each rewriting ~138 overlays) it blew, and TimeoutExpired propagated out and killed the driver mid-write: 313 files modified (alphabetically ov_SC01_000..ov_SC03_013 — it died partway through the fleet), config/dedup.us.yaml never updated, engine_core.h half-edited. check-all 124/140. Caught by running the oracle before trusting the state; git checkout -- src/ reverted all of it (§61 — and note a KILLED process performs no undo at all, so the driver's own restore logic was never reached). Nothing was committed at any point; zero contamination. Fix shipped: timeout now SCALES with bank count (1800 + 1800×banks, capped 6h) AND is CAUGHT — on expiry the driver reports TREE DIRTY, REVERT REQUIRED and returns cleanly instead of dying with the fleet open. Recovery path (also the new standing practice for multi-bank waves): re-gate --no-propagate, then propagate PER FUNCTION via dedup_propagate --addr — bounded, resumable, verifiable between steps — rather than one monolithic fleet write.

Three byte-grounded idioms to distill (R16/R30, owed): (1) void→s32 return is NOT byte-neutral — an s32 return keeps $v0 live-out and stops dbr stealing an addiu into the loop-back delay slot; this CORRECTS cookbook §3a-1's neutrality claim (func_8016EC0C). (2) The asm-label alias extern s32 SYM_w __asm__("SYM") — reads a u8-declared shared global as a word WITHOUT *(s32*)&SYM, which force_regs the address and drags 3 extra la pseudos across calls; found independently by two agents; a general unblock for the u8-vs-s32 loose-typing collisions (func_8012E014, func_80133298). (3) Zero-byte __asm__("") as a delay-slot fence — reorg.c stop_search_p halts the eager filler on an asm insn (func_8015FBE0).

T1a ✅ — the deterministic recovery sweep: +18 banked; the stored-draft question CLOSED (report point #2)

Population: the 108 fresh autopsy-MATCH strandeds (+ the 012 abort re-run, 0/3) across 50 binaries, 47 min, 17 driver commits. Metric truth (R14, derived): fn-count +18 instances / distinct +12 unique fns (commit messages summed 19 — gate-report double-list; the metric wins). R22 clean-fleet 140/140 after the sweep + residue revert. Fleet: 87.5 / 78.0 / 92.00 (+384 w-ins). The honest read: the S16 "39%" prior did NOT generalize — it was measured on FRESH same-wave drafts; this stored-backlog population is the class decision-log A10 already byte-proved non-bankable by plain re-gate (0/958). The driver's reconcile/demacroize lifted 18 of ~111 (≈16%) over A10's 0% — a real but bounded delta. The stored-draft recovery question is now CLOSED both ways: cheap wins taken; the ~90 not-banked stay match_one-MATCH but their drafts are integration-decayed — they route to T3's REDRAFT lanes (A10's "fresh re-drafts only"), not another recovery pass. §61 residue class found + reverted (2 orphan carve .c + overlays.mk/yaml edits from FAILED jr attempts). Two live gaps for T3 pre-work: (1) gate_stage --commit add-scope cannot stage NEW carve files / overlays.mk / yaml — moot at 0 jr banks here, live the moment a T3 wave banks a jr fn through it; (2) my own checkpoint edit mid-sweep tripped the driver's blast-radius assert (012's abort) — tracked-file writes and a tree-writing campaign cannot share a repo; queue docs until the campaign exits.

T2 finding 2 — the Arm-A reproduction target has MOVED: the fleet is jr-carved now (2026-07-30)

rollout_o0_cluster.py ov_SC07_007 → SKIP ("cluster fns not in base .c"): since Arm A (07-16), the P29 jr campaign carved every overlay (007 now: 16 _jr_*.c splits) and the -O0 range (0x8013B568..) sits INSIDE <ov>_jr_80135D20.c (23 stubs there in 007). The Arm-A tool's single-file premise is stale fleet-wide — the rollout is now the predicted carve-within-a-carve: sub-split _jr_80135D20.c (pre / o0 / post) per overlay + the Makefile -O0 wildcard for the new class + the +0x20 shift-diff at the NEW seam. Next concrete steps (deep arc, next session's opener): (1) extend the carve tool to sub-split jr files; (2) probe on ov_SC07_007 (zero T1a collision; baseline %lo/%hi inventory saved: .run/t2_007_baseline_syms.txt, 951 operands); (3) on shift: diff the generated asm symbol inventory → pin the drifted D_ symbols at pre-carve addresses in the overlay symbol file → re-extract → per-binary sha (the config-only fix hypothesis); (4) the R31 whale-shape hypothesis (no INCLUDE_ASM in the -O0 split) as fallback. ov_SC07_010's carve is still in-tree + byte-neutral (the Arm-A keeper) — the 010-vs-007 asm diff is a free shift oracle.

T2 ▶ driver generalized; ×1 probe REFUTED the append route for the remaining cluster (2026-07-30)

tools/rollout_o0.py (generalizes T85's rollout_801457a4_o0.py): map-derived members (cross-address-safe), stub located in any non-_o0 split, jr+o0 composites routed out loudly, atomic two-file + per-binary SHA gate + restore-both. ×1 probe (0x8013b6a0@ov_SC01_000): gate-reject — and the diagnosis corrects the frontier report (R14 on my own doc): T85's family banked by APPEND because 0x801457A4 abuts the o0b object's END; the remaining 18 families (0x8013Bxxx–0x8013Cxxx, below the whale) mis-place on append by construction, and per-fn isolation IS the Arm-A re-carve. o0b-bearing ≠ o0b-adjacent — my "the wall never has to fall" inference was wrong; caught at 1 build instead of 2,131. T2's real substance = the Arm-A +0x20 defect. First probe: identify WHICH symbol shifts on a failing overlay's re-carve; hypothesis: splat re-GUESSES a data-symbol boundary the carve moves → pin it in config symbols and re-probe.

T0.5 ▶ launched + probed (2026-07-30)

tools/prefetch_fleet.py (committed commit:1220): 126 programs / 7,966 uncached representatives. Probe 1 (main): +1,525/2,002 cached in <1 min — the decompile leg is CHEAP; 477 main addrs have no defined function in the program (main's 06-14 auto-analysis gap) → follow-up: a DefineFunctions.java completion pass over main from splat entries (the Phase-10 mechanism), then re-run (resumable). Probe 2 (import leg): FAILED then FIXED — my missing-program matcher checked "not exist"/"NOT_FOUND"; Ghidra's actual phrase is "Requested project program file(s) not found" → the self-healing import never fired (+0/371, +0/315). One-line trigger broadening; re-probe running. T1a (deterministic recovery sweep, 108 fns / 50 binaries, driver-committed banks, no-propagate — reach≥2 winners ride T3 Lane A) launched concurrently; commit-scope interaction VERIFIED safe (driver delegates to gate_stage's scoped git add -u src/ — ghidra/ churn cannot leak into bank commits).

T0(e2)+(f) ✅ — autopsy refreshed; frontier regenerated + the three populations PINNED (2026-07-30)

Autopsy (collect -j12 + report): 1,349 rows — 1,178 near / 63 nobuild / 108 match_one-MATCH (T1's stranded-draft fuel, 3× the S16 sample), 0 classifier errors, second-oracle agree. docs/autopsy.md regenerated.
Worklist/manifest regen: 101 live stubs / 261,789 gain-ins (stale 160/583k gone); R14 checks inside the manifest: 28/28 giants verified reach-138.
THE -O0 PIN (headline): 18 families / 2,192 open members — 2,131 o0b-route-eligible / 61 SC07-no-o0b; 15/18 exemplar-matched. The "WALLED ~1,287" framing dissolves: the bulk never needs the Arm-A splat fix — T2 = generalize the proven rollout_801457a4_o0.py (130/130). Composites flagged: 0x8013c414/0x8013c0f8 are jr+o0 (carve inside the o0b TU — probe ×1 first).
Zero-crack roster: 114 families / 3,166 open members / ~204k weighted ins (28 substantial); its head IS the -O0 set (T2 and Lane A open together).
Concentration: top-20 = 24.0% / top-100 = 44.8% of open family weight (head consumed vs S13's 53% — expected post-campaign flattening).
Report point #1: docs/frontier-p30.md (all numbers same-tree at one HEAD, post-repair — R35).

T0(e) — part 1 ✅: the 21-file absolute-include defect fixed (2026-07-30)

All 21 carriers were jr-carve split files including engine_types.h by absolute path (/home/musashi/bfm-decomp/..., some twice); swapped to the house-relative #include "../shared/engine_types.h". grep -rln /home/musashi src/ include/ → 0. R22 clean-fleet from a genuinely clean tree: 140 passed, 0 failed of 140. Part 2 (autopsy refresh) next.

T0(d) ✅ — backlog ledger: already clean; the scanner deleted (R33) (2026-07-30)

Findings, byte-verified: (1) the still-a-stub filter already existed (load_best drop + prune, built 07-24) and the tracked jsonl was already compacted — the tree's pre-existing uncommitted .run/backlog.jsonl edit was late-S25's un-committed prune output; prune today: 1350 → 1350, dropped 0. (2) The stale rows I'd flagged (func_80151944 etc.) live in worklist.md (regen at T0(f)), not backlog. (3) _open_stubs (private regex) vs corpus.stubs (the oracle): 0 divergence across all 131 ledger binaries — after fixing MY probe, which compared names against int vram addrs (R35 pointed at my own instrument). Hardening: _open_stubs now derives from corpus.stubs (STUB_RE deleted — R33's "best outcome is a deleted scanner"); hex-case canonicalized on both sides of the membership test (a lower-hex record can't silently drop, R32); count parity proven post-change (load_best 1350 == 1350). §83's doctrinal caveat (backlog ≠ work queue; worklist is the queue) STANDS — that's classification quality, not staleness.

T0(c) ✅ — family_hseq↔progress gap: ZERO definitional gap; stamped against recurrence (2026-07-30)

Same-tree regeneration of BOTH digests: family_hseq (overlays) 27,248 instances == progress fleet stubs 28,296 − main 1,034 − resident 14 = 27,248 — EXACT. The carried "29,961 vs 28,296" was a cross-date, cross-scope misread: the 07-29 map snapshot was SESSION-25's open state, and 29,961 − 27,248 = 2,713 = exactly the session's banked total. The tools were never in disagreement — both already derive from corpus.stubs (the Phase 26-A conversion, family_hseq:42). Hardening: the family-hseq digest header now stamps scope ("138 OVERLAYS only") + generation HEAD + the shared-oracle note ("compare digests only at the same HEAD") — a stale or scope-mismatched comparison is now self-announcing. Roadmap v2 D-bucket corrected. Fresh frontier readings from the regen (full pinning still at T0(f)): 478 substantial families / 678,404 templatable ins · 28 zero-crack (was 61 on 07-29 — S25 consumed 33) · 3,626 PURE / 40 IMM / 6 STRUCT · overlays 27,248 instances / 17,629 distinct / 1,587,311 ins.

T0(b) ✅ — rtu_match surfaces the real cc1 error in the verdict (2026-07-30)

_diagnostics() filter (the SESSION-25 recipe, in-tool): drop warning:/In function/At top level/###/blank lines from the failing stage's stderr and print the FIRST 15 survivors — gcc-2.7.2 hard errors carry no error: prefix and the old [-2000:] tail was all warnings. Raw-tail fallback if the filter empties (ICE/signal formats) — never prints less than before. Applied to all four stages (CPP/CC1/MASPSX/AS). Verified on a real deliberate CC1 failure: the verdict now leads with t.c:3116: 'nonexistent_var' undeclared instead of a 2 KB warning tail. --stderr-out unchanged (full dump). Docstring updated.

T0(a) ✅ — gate_stage stage-0 + fix_arity_callers journal undo (2026-07-30)

The carried defect pair closed structurally, not by root-causing:

gate_stage.py: stage 0 gates the RAW drafts before any transform (GATE_NO_STAGE0 to disable) — the destroyed-good-draft mode (SESSION-22 reproduction: _o0 pair + func_80138C60, ladder-FAILED / bare-VERIFIED) is now impossible by construction; the canon/cast/rc ladder + arity pre-pass run only on stage-0 failures. Root-cause hypothesis recorded in-code (transforms are batch---src-file TU-blind where the gate is per-draft TU-aware) — open, now harmless.
fix_arity_callers.py: --journal (per-edit literal before/after) + --undo-journal [--keep <banked>] — the exact undo now lives in the WRITER, shared by ladder AND bare workflows (the 17-TU residue class). Replaces gate_stage's two-special-case file snapshot; undo moved to after stage 2 (closes the latent stage-2 parity gap: a stage-2 bank used to lose its arity edit before its own gate attempt). Stale-journal guard (_arity_rc is not None).
Verification: negative control apply→undo → byte-identical tree; --keep retains exactly the kept edit; in-process flow test .run/t0a_flowtest/driver.py 7/7 PASS (stage-0-first, s1in = failures-only, accumulation, undo-guard, src/ untouched). Real-tree at-scale proof lands with T1's first sweep (R22-bracketed there). Cookbook §122.

265 KiB Raw Blame History Unescape Escape

CURRENT PHASE — Phase 30: The Recovery & Concentration Campaign (overlays to their ceiling)

The numbers this phase must pin FIRST (T0 — do not consume until re-derived, R35/R14)

Standing invariants (every task)

Task checklist (current-task pointer = ▶)

Blockers

🛑 SESSION S45 CHECKPOINT part 3 (2026-08-07 evening) — SC02/9 FELL; parked = 5 — FRESH SESSION SAFE HERE

✅ FINAL S45p3 STATE — R22 CLEAN-FLEET 213 passed / 0 failed of 213 · tools-health OK

⚠️ p4 CORRECTION (R14/R35 — read BEFORE the homework below): the per-file "loader fn"

▶ THE LAST 5 = STATIC-RE HOMEWORK (not emulator work — Drew's framing, adopted)

📋 CO-OP PROTOCOL (binding, from today's friction — memory live-coop-answer-before-grinding)

🛑 (superseded by part 3) SESSION S45 CHECKPOINT part 2 (2026-08-07) — THE L3 TOUR

✅ FINAL S45p2 STATE — R22 CLEAN-FLEET 212 passed / 0 failed of 212

WHAT S45 part 2 DID (the live emulator session with Drew + same-day banking)

▶ RESUME HERE (fresh session)

🛑 (superseded by part 2 above) SESSION S45 CHECKPOINT (2026-08-06) — FRESH SESSION SAFE HERE

✅ FINAL S45 STATE — R22 CLEAN-FLEET 183 passed / 0 failed of 183

▶ RESUME HERE (fresh session)

S45 per-task log

🛑 SESSION S44 CHECKPOINT (2026-08-06) — FRESH SESSION SAFE HERE

✅ FINAL S44 STATE — R22 CLEAN-FLEET 143 passed / 0 failed of 143

WHAT S44 DID (Part I of the plan, complete)

▶ RESUME HERE (fresh session = Part II of the plan file)

✅ FINAL S43 STATE — R22 CLEAN-FLEET 140/140, ALL 18 BANKS CONFIRMED

WHAT S43 WAS: FOUR INSTRUMENT DEFECTS, AND THE TWO QUESTIONS THEY HID

THE ONE NUMBER THAT MOVED

▶ S43-10 — the wave's 5th agent: §147 REFUTED, and a parked family un-parked

▶ RESUME HERE (S43)

🧰 HAZARD INTRODUCED-AND-DOCUMENTED THIS SESSION

🧰 MY PROCESS ERRORS THIS SESSION

🛑 (superseded) SESSION S39–S42 CHECKPOINT (2026-08-05)

FLEET — R22 140 passed / 0 failed of 140 (run ~25× this session, green every time)

REMAINING (measured at close)

🎯 THE AGREED NEW PLAN (Drew, 2026-08-05) — DO NOT LOSE THIS

🏆 WHAT S39–S42 DID

S6 — BOTH "PERMANENT" GIANT WALLS CRACKED ×138 (+50,094 ins)

The cast_call_sites BUG — it DELETED return STATEMENTS

S1e — the "distinct-code regression" NEVER HAPPENED

S5 — two waves, 24 exemplars, 24/24 banked, ZERO codegen walls

S4 (REDONE — the first pass was wrong) · S7 · §134

NEW COOKBOOK THIS SESSION — §140 §141 §142 §143 §144 §145 §146 §147

▶ RESUME HERE

💾 THE SERIAL DRAFTS ARE NOW COMMITTED — AND ONE LEDGER ROW IS A RUMOUR

🧰 MY PROCESS ERRORS THIS SESSION (all caught; each is a rule now)

🛑 SESSION-39 CHECKPOINT (2026-08-04) — FRESH SESSION SAFE HERE

FLEET — R22 140 passed / 0 failed of 140 (run ~14× this session, 140/140 every time)

🔑 THE SESSION'S HEADLINE — S38's "distinct-code REGRESSION" NEVER HAPPENED

🧰 FOUR INSTRUMENT DEFECTS FIXED — all ONE class: a bare except around a fail-CLOSED oracle

✅ BANKED THIS SESSION (+4,727 ins, every step R22 140/140)

🔑 THE SECOND FINDING — RE-GATE STORED DRAFTS AFTER ANY TOOL REPAIR

🔑 THE THIRD FINDING — MEASURE THE FREE POOL, DON'T TRUST THE REPORT

🏆 S6 (2026-08-05) — BOTH GIANT WALLS CRACKED ×138, +50,094 ins — FLEET 96.62% fn / 94.8% instr / 89.2% distinct, 140/140

🚨 ROADMAP DELTA — the "2 permanent giant walls" line is RETIRED

🚀 S40 (2026-08-05, ULTRACODE) — FLEET 96.54% fn / 94.5% instr / 89.2% distinct, 140/140

THE cast_call_sites BUG (the session's most consequential find)

THE WAVES — 24 exemplars, 24/24 banked, ZERO codegen walls

NEW IDIOMS (all byte-derived by the drafters, distilled in-session)

▶ CHEAPEST FUEL NEXT SESSION (all named, all deterministic)

🌙 OVERNIGHT (S39 cont., 2026-08-05 ~00:40–)

Also delivered overnight (all zero-agent, all committed)

▶ RESUME HERE

🚧 LEFT ON THE BACKLOG AS GENUINE (not forced, P9)

📌 A METRIC SHAPE WORTH KNOWING (R30)

🧰 MY PROCESS ERRORS

🛑 (superseded) SESSION-38 CHECKPOINT — v4, POST-S1d (2026-08-04)

FLEET — R22 140 passed / 0 failed of 140

🔑 THE SESSION'S BIGGEST FIND — the def-side asm-label alias is a CLASS lever

⚠️ TWO R22 FAILURES — "per-binary BANKED" IS NOT A FLEET CLAIM (§61)

✅ T7 PROGRESS

▶ RESUME HERE

🧰 ELEVEN TOOL DEFECTS FIXED — nine of the ten "walls" were our own instruments

🧰 MY PROCESS ERRORS

🛑 (superseded) SESSION-38 CHECKPOINT v3 — POST-S1/S2/S3

FLEET — R22 140 passed / 0 failed of 140

✅ T7 PROGRESS

⚠️ THE ONE R22 FAILURE — READ THIS BEFORE TRUSTING ANY PER-BINARY "BANKED"

🔑 S3'S REAL MECHANISM — the plan's framing was WRONG, do not repeat it

🧰 TEN TOOL DEFECTS FIXED — every "wall" today was our own instrument

▶ RESUME HERE

🧰 MY PROCESS ERRORS

265 KiB

Raw Blame History

📋 CO-OP PROTOCOL (binding, from today's friction — memory `live-coop-answer-before-grinding`)

The `cast_call_sites` BUG — it DELETED `return` STATEMENTS

🧰 FOUR INSTRUMENT DEFECTS FIXED — all ONE class: a bare `except` around a fail-CLOSED oracle

THE `cast_call_sites` BUG (the session's most consequential find)

📌 THE 9 UNBANKED WAVE-6 DRAFTS — ALL DIAGNOSED, DRAFTS COMMITTED IN `.run/w6/`

📊 `docs/wave-metrics.md` — Findings 5 and 6 added

📊 NEW: `docs/wave-metrics.md` — the wave performance log (Drew asked for this)

📌 THE DISTILLED RULES (cookbook §138 + index; memory `wave-prompt-seed-step0-and-gaps`)

⚡ THE `pipeline()` FIX — measured, not assumed (Drew asked why waves were slow)

🔬 S33b — the PROPAGATE remainder DIAGNOSED: it is `func_80146C3C` again