BFM-decomp/phase-ends/logs/Phase25.md

CURRENT_PHASE — Phase 25: The structural-family endgame (idiom curriculum)

Status: In progress — plan approved 2026-07-08 (gate 1 passed). · Generation: Gen2 (17th phase of the arc; Phase 14 public-flip deferred to Gen3+). · Effort: Max (planning/synthesis/deep debugging); prompt + wait for the toggle (R27) → Ultracode for breadth waves (T5, T7 harvests), Fable5Max for new-class discovery + the T6 curriculum authoring. Claude cannot set effort itself. Plan of record: /home/musashi/.claude/plans/plan-mode-enabled-max-generic-galaxy.md (approved, verbatim). This file is the P3 crash-recovery execution log.

Scope clarification (Drew, 2026-07-08, at gate 1)

The phase's atomic unit of work is "solve ONE exemplar per structural family" — swept across the whole family set (~2,764 h_norm families), curriculum-ordered, cheap-tier-first with Opus/Fable5/permuter escalation. One solved exemplar → the family propagates ×134 (reloc-only families, free via --tier h_norm) or yields the idiom to template the variants (immediate families). The AIM is one exemplar per family for every family the tiers can crack; genuine gcc-intrinsic-wall families (S3 / RC-6 / cse mega-flush / L6 exemplars) stay INCLUDE_ASM with logged evidence (G4/P9). This unifies plan T5 (cheap exemplar sweep) + T7 (curriculum-ordered escalation) into one exemplar-per-family endgame.

Strategy (approved)

Cheap/free tiers exhaustively FIRST → complete measured frontier map + pre-softened seeds → Fable5Max authors the idiom curriculum → sweep one exemplar per family (curriculum-ordered), each cracked exemplar propagated ×134 via dedup_propagate --tier h_norm, byte-gated. The whole-binary byte-gate (harvest_verify) is the sole arbiter (G3/P9) — no wrong match can bank; 136/136 byte-identical every batch (R22).

Tasks

• T0 — Refresh + housekeeping
• T1 — Integration-recovery pass (split-aware recover_integration fix; caller-arity cohort exhausted 0/16 — residuals backlogged)
• T2 — Exemplar target manifest (tools/family_manifest.py: 2,764 multi-member families → 127 draftable / 156 matched-free / 2481 absent)
• T3 — Swing-question PROOF: free --tier h_norm REFUTED (0/133); mechanical symbol-remap lever PROVEN (tools/family_remap.py) ← endgame reshaped, see log
• T4 — v4 retrain + A/B gate — FAILED/negative, keep v3 (see log)
• [~] T5 — Cheap-tier soften + measure wave → frontier map (Step A) + pre-advanced seeds. PILOT + BATCH-1 COMPLETE (Opus xHigh). Pilot 10 + batch-1 cheap tier 83/83 drafted (first 54 + the 29-continuation, which needed a resume after a session-cap hit — 20 cached + 9 re-run). Cheap-tier totals: 24 clean exemplar-banks + ~2,793 siblings via family_sweep (~0 agent tokens). Fleet 71.36 → 72.18% (+2,820 fns this session), R22 136/136 every batch, dedup 1813/0. Frontier map = 93 exemplars measured (.run/t5_frontier.jsonl; 75 match_one-MATCH). Clean-bank rate ~35% (rest = def-side-wall → backlog, the #1 T7 lever). REMAINING: the ~34 giants (batch-2, awaiting Drew) + 5 _o0 (batch-3) + T5c/T5d. (Max orch + xHigh workers)
• T6 — Step B: Fable5Max curriculum authoring ✅ (2026-07-09) — docs/phase25-t6-curriculum.md + .run/t6_worklist.json; R14 re-verify flipped the map (62/95 iso-MATCH genuine); canon_sig_reconcile v3.1 (5 defects fixed) → 44/62 probe-BANKABLE (4,254 ins, 13 giants, incl. all 3 _o0); ×134 sweep law PROVEN (per-sibling re-reconcile, 6/6); gate-validated on func_8013DD68; cookbook §41a + decision-log
• [~] T7 — Sweep one exemplar per family, curriculum-ordered. MECHANICAL/free sub-scope DONE (matched-free +16,512 · T7.2 type-lift +1,729 · T7.3 h_exact +~200). T7 CURRICULUM MECHANICAL TIERS DONE 2026-07-10 (see the T7 log): M1 37 exemplars + M2 4,389 members + M3 2+266 = ~4,694 fleet fns, fleet 72.29→73.66%. REMAINING (the real substance): the F-band frontier (31 near-misses: permuter/§31-Opus/Fable5) + the deferred mechanical tail (M4 8, F-jumptable 4, M-linkwall 3, M3-residue 4, F-perturb 4, draft 2).
• Close — clean-fleet verify · PhaseEnd synthesis · plain-English recap (R25) · Phase-26 backlog (NOT yet — phase open)

FRESH SESSION — RESUME HERE (fleet: instr-weighted 58.2% / distinct-code 30.3%; phase OPEN, do NOT close. NEXT: the FAMILY-ENDGAME MEGAPLAN → docs/family-endgame-megaplan.md. Drew runs a plan-mode + Fable5 session to build the "finish the decomp this weekend" plan from it. ALL other tasks (Fable5 batch #2, F-band) are DEFERRED into that megaplan, most-value-first.)

⇒ MEGAPLAN PIVOT (2026-07-11, end of session) — the "unique tail" is mostly TEMPLATABLE FAMILIES

THE FINDING (byte-verified; full detail + data + Fable5-examine list in docs/family-endgame-megaplan.md): the "36k unique / 87% distinct-code tail" was a STRICT-h_norm artifact. Re-clustered by h_seq (mnemonic skeleton), 90% collapses into ~754 families; 986 substantial (nins≥80) families / 1.88M ins, top-20 = 52%, all per-location-shaped (same fn at 1 addr × ~120 overlays). Templatability CONFIRMED — identical nbytes/ncalls/call-sequence across members (e.g. 0x80178d40 890ins×121, 0x8015ae2c 562×121, 0x8017ca80 952×100 cross-address). → the endgame is crack ~986 exemplars → template ×~120, NOT 36k hand-decomps. Drew's insight; it makes "finish this weekend" credible. (Reproduce: h_seq in .run/sig.*.jsonl; survey in the megaplan §1.) NEXT SESSION = plan-mode + Fable5 analyze the megaplan → build the finish-plan (Step A cheap map+triage → Step B Fable5 hard family CORES → Step C mechanical ×120 harvest → Step D unique residue). Do Step A's cheap h_seq map + templatability validation + exemplar triage FIRST (the measured foundation); Fable5 drafts on that data, not predictions. DEFERRED into the megaplan (most-value-first): (1) Fable5 hard family CORES (890/952/562-ins exemplars, ×~120 each — the real "monsters worth Fable5"); (2) the 2 permanent walls func_801412A8 (198×134 S11) / func_80178004 (165×134 pin-free); (3) the 3 walled reach-134 giants (recon-done pin-free seeds + gdb specs: func_8014D820/func_8016CBC0/func_801670E4 — see megaplan §6); (4) F-band residuals; (5) the 5.9MB matched-free propagation (mechanical, no Fable5). NOT the 5 unique ≥1000-ins behemoths — ×1, worst ROI, Step D/never. PERMUTER BATCH this session (Drew-directed, DONE): func_801670E4 + func_8012E364 + func_801549F8 through the directed ILS → ALL WALLED (masked 22/31/2), 0 banks — the free permuter tier is exhausted on these intrinsic ties (→ Fable5 or the fuzzy-family tail). func_801549F8 is masked-2 (jump-table; a .text-0 still needs the rodata jtbl §8-verified). COMMITTED this session: flagship func_80133CD4 ×134 (commit:0515, R22 136/136) + cookbook §45. This checkpoint commit = the megaplan + this pivot note.

SESSION 2026-07-11 — GIANT ESCALATION ROUND (Max orch; TASK A giant #2 flagship + flywheel) — [src banked; commit pending R22]

Permuter round (both pin-free seeds) WALLED: func_8014D820 masked-38 (RC-6), func_80133CD4 masked-172 (allocno tie). Both → Fable5 per the recipe. 🎯 FLAGSHIP func_80133CD4 (399 ins) CRACKED ×134 (Fable5, gdb-on-cc1 §34). Whole-binary byte-gate BYTE-IDENTICAL (d19c9580); family_sweep 133/133 siblings, 0 failed; PIN-FREE (×134-clean). Fleet instr-weighted 57.7→58.2%, distinct-code 29.3→30.3% (+1.0% distinct from ONE giant). Lever → cookbook §45 (merged-accumulator-variables permutation-breaker + the 1-death-local-alloc in-out-asm + offset-0 /s + goto-shared-return). Draft .run/giants/func_80133CD4.fable.c; report .fable.md; dumps/oracle .run/giants/fable_cd4/. The ~22-phase "unsteerable" verdict RETIRED. FLYWHEEL (3 cheap-Opus agents applying §45 + the map) — all WALLED → Fable5, each now a PIN-FREE ×134-safe seed + a gdb-oracle escalation spec (recon done):

• func_8014D820 (304×134): LCS 226 pin-free (RC-6 sched1 delay-slot; sched.c:3199 param-pin + a ratan2-delay-slot tie-break). .run/giants/func_8014D820.opus.{c,md}.
• func_8016CBC0 (209×134): close=153 pin-free (beat the 155-pinned ×1 seed; qty-birth/allocno-priority lock). .opus.{c,md}.
• func_801670E4 (279×134): close=23 pin-free (beat the 48-pinned ×1; residual = block0 fence-lock 6 + block2 S3-priority 17) — may fall to the directed permuter. .opus.{c,md}. Flywheel reusable findings (fold into §45 when these crack via Fable5): (a) the merge-lever has a MIRROR split law for scalars (func_801670E4 d-split, func_8016CBC0 counter-split); (b) a new input-only-anchor load-early+tie dial; (c) §44-Lever-5 "i=0/p-hoist co-location" DOWNGRADED — cracked 42→0 (was tagged intrinsic; R14). Detail in the .opus.md files. FABLE5 QUEUE (2-day window; strategic read, Drew 2026-07-11): Fable5's deliverable is PERMANENT IDIOMS, not matched fns → burn it on distinct HARD CLASSES (reach-134 giants + the 2 walls + new-class exemplars), NOT unique-shape behemoths (×1, worst ROI, non-transferable, LAST). Run parallel-isolated agents (NOT one batched agent — context-accumulation makes batching ~N× costlier; the §31 map already amortizes the compiler-source read), distill after each, let cheap-Opus mop up transfers. Queue: (1) the 3 walled giants [recon done]; (2) the 2 permanent walls func_801412A8 (198×134, S11 LUID×alloc) + func_80178004 (165×134, matched-with-pins → needs pin-free); (3) func_80166690 (193×134), func_8017C294 (246×15); (4) new-class small walls func_801778A8 (iv-combine). The cheap flywheel (≤180-ins draftable) + the 5.9 MB matched-free propagation run ALONGSIDE (no Fable5), anytime.

📊 THREE metrics (progress.py --weighted; regen every make report): fn-count 74.58% (×134-inflated), instr-weighted 57.7% (the decomp.dev-DISPLAY number, shipped .text), distinct-code 29.3% (each unique fn once, the distinct-RE truth; ~74k unique-monster tail is the long grind). Executable code only (resident+134 overlays; main EXE excluded). ✅ TASK A — GIANT CAMPAIGN batch 1 DONE (2026-07-11, Max orch; 3 giants banked ×134, R22 136/136 GREEN, instr-weighted 56.8→57.7%, distinct 27.3→29.3%): 6 cheap-Opus crackers (+1 Fable5 for giant #1) over the 6 frontier giants (209–399 ins, all remap-clean 133/133). BANKED ×134 (3): func_80166994 (369, §43 K&R s16-param, Fable5, COMMITTED commit:0513) · func_80135480 (258, block-scoped-pointer-split §44#3) · func_80163EC8 (234, cross-jump-duplicated-tail §44#4, 1 benign $v0 pin). 6 reusable levers → cookbook §43 + §44 (§43 K&R + §43-extension callee-stash + pointer-var-decl + block-scoped-split + cross-jump-tail + the intrinsic-wall taxonomy). R14: giant #1's prior "MATCH" note was STALE/FALSE; §43 does NOT universally transfer — only 1 of 6 was K&R-s16; each giant is its own class. 🔁 THE 4 GIANT SEEDS → ESCALATION ROUND (permuter-first, then Fable5). Seeds in .run/giants/func_*.c + .run/giants_seeds.txt; §44#5 = the intrinsic-wall taxonomy. Bodies are pin-free/×134-clean once cracked:

• func_80133CD4 (399, FLAGSHIP) — close≈30 true (pin-free), §37 allocno-tie (caller-vs-callee s0v→$v0-vs-$s0); §43-double-copy already in the body. NO //@EDIT/ec_edit. → Fable5 §34 gdb-on-cc1 find_reg/post_mark_life (the clearest Fable5 target).
• func_8014D820 (304) — close=67, PIN-FREE (RC-6/S3 pressure-lock). ec_edit: engine_core.h DEFINE_func_8014D790 extern void func_8014D820(s32,void*,void*) → extern s32 (byte-neutral, caller discards). → permuter-first NOW (pin-free).
• func_801670E4 (279) — close=48, light pins (t=$2,zr=$0 blessed biv + 1 coloring); two scheduling-position tie-breaks. NO //@EDIT/ec_edit. → Fable5 consume-as-is; permuter needs pins stripped (pycparser rejects register __asm__, §42).
• func_8016CBC0 (209) — close=43, 6 pins (dB seed; RC-6 coalescing). NO //@EDIT/ec_edit. → Fable5 crack PIN-FREE for ×134 (else ×1); permuter needs pins stripped. RECIPE: (1) permuter round — Phase-24 overhaul (tools/masked_scorer.py + permuter_weights.py §31-class + permuter_ils.py) on func_8014D820 + func_80133CD4 (both pin-free); strip pins on the other two first. (2) Fable5 (Agent(model: fable), ~375k tok/giant) with tools/reference/gcc-2.7.2/ + the §34 method on the walls the permuter can't close — flagship func_80133CD4 first; each cracked lever → §31/§44 (flywheel). Per-crack GATE: exemplar substitute (+ any ec_edit) → make build BINARY=ov_SC01_077 == d19c9580… → build a family_sweep --edit-remap manifest {addr, edits:[], ec_edits:[…]} → sweep ×134 → R22 clean-fleet 136/136 → commit (Drew pushes). Combined-batch the clean banks into one sweep+R22 (as batch 1 did). ✅ TASK B DONE — family_sweep --edit-remap BUILT + swept (2026-07-11, Max, COMMITTED, R22 clean-fleet 136/136 GREEN, fleet 74.40% → 74.48%, +266 fns, dedup 1813/0, 0 NON_MATCHING): Built family_sweep --edit-remap MANIFEST (JSON: per family, edits=split-scope //@EDIT old||new in exemplar symbols, symbol-remapped per sibling via family_remap.symbol_map; ec_edits=once-global engine_core.h flips, byte-neutral). Manifest .run/edit_remap_manifest.json. Per sibling: apply remapped edits to split + stage family_remap body + gate via harvest_verify (sole arbiter). BANKED 266/266 (0 failed): func_80136824 + func_80136334 (array-decay ptr-flip) × 133 siblings each — full ×134. ⚠️ R14 FINDING — B yields ~266, NOT ~800: 4 of the 6 byte-drift families are cc1-CRASH-WALLED (backlogged). The register-pin-heavy cracks — func_80133AB0 (register int zr __asm__("$0") zero-reg pin, crash 3/3 sibs), func_8016DF5C / func_8013D9B0 (GTE 20-pin bodies), func_80156044 (inline-asm trampoline; its engine_core.h int→void flip IS byte-neutral but the body crashes the _after TU) — SIGABRT cc1-2.7.2 (make Error 134) compiling the SIBLING TU, though the identical body compiles fine in ov077. The hand pins are ov077-TU-context- specific (cc1's 1996 regalloc aborts on the pin pattern in a different overlay's function set). NOT mechanically ×134-recoverable → exemplar-only (×1); route to per-sibling permuter/Fable5 or accept ×1. rtu_match/match_one are BOTH useless (neutralized/isolation compiles ALSO crash — a harness artifact); only make build exit-134 is truth. cookbook §42e addendum written. NEXT = A (7 giants, all remap-clean 133/133 → honest ×134 leverage ~938 fns high-byte-weight; needs the Fable5 prompt R27; caveat: pin-heavy Fable5 cracks would hit the same ×134 cc1-crash wall).

B (ORIGINAL BRIEF, now DONE-partial) — the family_sweep --edit-remap enhancement (cookbook §42e). Recover the 6 byte-drift families whose fix lives OUTSIDE the remapped body: func_8016DF5C, func_80136334, func_8013D9B0, func_80156044 (wave-4) + func_80136824, func_80133AB0 (wave-3). Approach: {per-sibling — remap the exemplar's //@EDIT old||new symbols via family_remap.symbol_map and apply to the sibling split before the gate} + {once — apply any shared-header (engine_core.h) flip globally}. Outcome: 2/6 (array-decay) recovered ×133; 4/6 cc1-crash-walled (above). A (SECOND) — the 7 GIANTS 200+ ins → Fable5 surgical probe (.run/frontier_crack_targets.json, nins≥200: 0x80133cd4/80166994/8014d820/801670e4/80135480/80163ec8/8016cbc0). Prompt Drew for the Fable5 model switch (R27; 7/12 access). Check family_remap remap-ability of each giant up front (a crack only ×134-propagates if remap-clean or --edit-remap-able — §42e forward rule) so the leverage estimate is honest. C (THIRD) — F-band backlog: M-linkwall func_8016D1D8/80165240 (compile-fixed, rtu-blind link-fail — manual undefined-syms), sig-reconcile func_80164E40, -O0 func_801457A4 (needs -O0 split handling), permuter func_8012E364 c=4 / func_801549F8 c=3. PROPAGATION-RECOVERY (2026-07-10c, Max) — COMMITTED, R22 136/136 GREEN, fleet 74.36% → 74.40% (+133 fns): Investigated task (b). R14 CORRECTION: the "family_remap limitation" I first concluded was a MISDIAGNOSIS — the "remap-fail" was a mislabeled canon_sig_reconcile def-finder bug (its regex required a leading \n, so a //@EDIT-stripped raw draft with the fn def on line 1 → "no definition found"; family_sweep miscounts that as remap-fail). FIXED \n→(?:^|\n). Recovered func_8014FE60 fully (133/133 siblings) + its engine_core.h void→s32 global flip. Residual (the genuine, now-SMALL --edit-remap): 4 families reconcile but byte-drift per sibling — their fixes live OUTSIDE the remapped body (pointer //@EDIT, no-proto, return-flip). A --edit-remap {per-sibling remap the //@EDIT + apply any shared-header flip once} recovers them. cookbook §42e, decision-log corrected. LESSON (R14): trace a tool's real exception, not its summary label.

WAVE 4 (2026-07-10c, Max orch + Ultracode fan-out over the FRONTIER MAP) — COMMITTED, R22 clean-fleet 136/136 GREEN, fleet 73.97% → 74.36% (+1350 fns): Built the systematic frontier map (docs/phase25-frontier-map.md, committed commit:0506): endgame = 42 draftable (crack) + 235 matched-free (propagate) + 2481 absent; rtu_match-measured all 42 → 37 crack targets. Crack fan-out wf_b54b5d98-380 (26 tractable-band exemplars, ~2.36 M tok): 24/26 MATCH. Gated → 20 banked byte-identical (incl. the 22×1996 func_8014FBC0 inline-asm trampoline + the 27×539 func_80132144; func_8016CF04 via the real engine_core.h void→short flip). Swept ×134: 1330 siblings / 931 failed (the //@EDIT/trampoline/engine_core families → the --edit-remap backlog (b)). Batch = 20 exemplars + 1330 = 1350 fns. CAUTION LOGGED (recovered): a stray git checkout ov_SC01_077_after.c mid-gate reverted the wave-4 _after exemplars (masked because reverted fns build byte-identical as stubs) — re-applied cleanly via .run/crack3/apply_wave4_final.py. When surgically removing ONE fn from a big uncommitted batch, never git checkout the whole split; re-stub just that fn. 5 durable levers → cookbook §42d (return-type flip BOTH ways void↔s32/short; address-recompute-vs-CACHE unifying read-global rule; the full-inline-asm TRAMPOLINE idiom + family_remap-inside-asm note; memcpy→struct-assign at scale; phantom-frame). 6 deferred (backlog, map tiers): func_8016D1D8/80165240 (M-linkwall — compile-fixed but rtu-blind link-fail), func_80164E40 (sig-reconcile), func_801457A4 (-O0 split), func_8012E364 c=4 / func_801549F8 c=3 (permuter). SESSION TOTAL (this session): wave 3 (407) + map + wave 4 (1350) = ~1,757 fns; fleet 73.85% → 74.36% (+0.51%). The rtu_match engine is proven (wave-3 7/9 + wave-4 24/26 = 31/35 MATCH).

WAVE 3 PART 2 (2026-07-10c, Max orch + CORRECTED Ultracode fan-out) — COMMITTED, R22 clean-fleet 136/136 GREEN, fleet 73.89% → 73.97% (+273 fns): Built tools/rtu_match.py — real-TU-faithful, PARALLEL-SAFE per-fn match check (neutralizes INCLUDE_ASM → compiles the whole split TU in a per-fn temp dir, no asm/, no shared overlay build). Closes match_one's isolation blind spot so a MATCH HOLDS at the whole-binary gate (cookbook §42c). Corrected fan-out wf_80762f2c-822 (9 xHigh workers, ~1.27 M tok): 7/9 MATCH → all 7 banked byte-identical, ZERO drift (vs wave-2's ~50% attrition). Swept ×134: 266 siblings banked / 266 failed (the 2 //@EDIT families func_80133AB0/80136824 can't per-sibling-reconcile via family_sweep — BACKLOG (b)). Batch = 7 exemplars + 266 = 273 fns. Banked exemplars: func_8012FCC4 (an arity-bug — the "irreducible" delay-slot that wasn't), func_80133AB0, func_80134A74, func_80136824 (pointer-vs-array), func_8014DD8C (engine_core.h void→s32 flip, R22-neutral fleet-wide), func_80168828 (register-a0v capture), func_8016C188. 7 durable levers → cookbook §42c (callee-arity delay-slot · pointer-global *(T**)& · array-decay CSE · §17 zero-reg copy · void→s32 · register-arg capture · free-floating load hoist). rtu_match → SETUP §6. 2 DIFF → permuter (seeds .run/crack3/wave3/): func_801670E4 (70→48), func_80185BA4 (177/177 struct, c=65). NEXT (ranked): (a) permuter-ILS the 2 DIFFs; (b) a family_sweep --edit-remap enhancement (carry the exemplar's //@EDIT edits per sibling, symbol-remapped) → recovers ~266 dropped + any exemplar-only families; (c) apply the rtu_match fan-out engine (reconcile-first + rtu_match-gated + §42c levers) to the phase tail (tasks #2–4).

WAVE 3 (2026-07-10c, Opus-Max — surgical single-fn crack, NOT a fan-out) — COMMITTED, R22 clean-fleet 136/136 GREEN, fleet 73.85% → 73.89%: func_80164930 (81) CRACKED + swept ×134 = 134 fns (133/0 siblings). The crack = the read-global fix below. TWO DURABLE FINDINGS (cookbook §42b): (1) THE STALE-OBJECT GATE TRAP — a piped make build >/dev/null that FAILS leaves a stale .o; asm-differ -o then reports a phantom score 0. This INVALIDATED wave-2's "iso-drift" labels: a rigorous re-check (rm the split .o + build exit-code + real whole-binary SHA) shows ALL 4 remaining iso-drift drafts NOCOMPILE (unreconciled callee externs conflicting with the TU canonical-sig layer). Every gate MUST rm the .o + check the build exit code — never trust a piped make build + asm-differ alone (compounds §42a --out). (2) canon_sig_reconcile *(T*)&D_sym READ-global drift — &sym forces the address into a HELD register (lui;addiu;lhu 0(reg) — kills the target's direct lui;lhu %lo → schedule drift); write-only globals are unaffected (direct lui at;sh %lo(at)). FIX (byte-proven on func_80164930): flip the file-scope decl to the exact type (extern s16 D_8018971C;→u16, byte-neutral to store-only callers) + reference the global DIRECTLY (no cast). A block-scoped extern u16 vs ambient s16 is a hard cc1 conflicting types ERROR (exit 33, NOT a warning), so the fix must be at file scope. Rigorous crack harness at .run/crack3/ (gitignored). THE WAVE-3 FRONTIER IS HEAVIER THAN THE HANDOFF (each remaining fn needs real-TU reconcile-crack, NOT gating the broken wave-2 drafts; EACH cracks → ~134 fns since all are ×134 families → ~9 fns ≈ ~1,200 fleet potential):

• 4 iso-drift (NOCOMPILE, need decl-reconcile): func_80136824 (156, _a, pointer-vs-array type-model drift), func_8014DD8C / func_8016C188 / func_80168828 (_after; func_80168828 self-doc c=8 schedule near).
• 5 nears (residual closure, worker drafts in .run/uc_crack2/): func_80134A74 (107), func_80133AB0 (137, first 37 ins exact ~c91), func_8012FCC4 (57, c=3 "irreducible" reorg thread-steal → G4 candidate), func_80185BA4 (177, c=79 structurally matched), func_801670E4 (279, 94→70). NEXT (Drew's call, R27): (A) corrected FAN-OUT [prompt /effort ultracode] — workers use the .run/crack3 rigorous gate (rm .o + exit + SHA) + real-TU reconcile-first; RELIABLE now the stale-object trap is fixed; scales to the phase tail — RECOMMENDED. (B) continued Max serial (me) — highest per-fn quality, doesn't scale. IN-FLIGHT (2026-07-10b, Opus-Max→Ultracode) — T7 F-band ≤28 crack wave RUNNING (nothing banked/committed yet): Re-triaged the ≤28 band (R14, all vs bytes): it's regalloc-order-DOMINATED (§17 register __asm__ pin territory) — the permuter PLATEAUS on it (func_80134C20 regalloc stuck@3 even with regalloc-directed weights; func_8017EF50 schedule stuck@4; func_80168828 schedule 8→5). cookbook §17 confirms "permuter can't help — pycparser rejects register __asm__". Free permuter left softened seeds: func_8017EF50 c=4, func_80168828 c=5 (in .run/permuter/<fn>/output-*). Better drafts found than the T6 table: func_8017B614 is c=6 (not 22). Iso-MATCH-but-real-TU-drift class: func_8017B490 (gate_stage failed=1 compile-wall → per-fn TU work). Length-drift seeds: func_8012E364 (+1), func_801345F8 (−2). jtbl+schedule: func_801549F8 (c=3, jtbl_801D89A4 %hi/%lo). Ultracode wave wf_0329d3c2-75c = 9 regalloc fns (func_80134C20/8017B614/80180F10/80141A60/801365B8/80164930/80136824/8012E364/801345F8), 1 xHigh worker each, §17 pins → MATCH-in-isolation → .run/uc_crack/<fn>.c. GATE RECIPE per MATCH: canon_sig_reconcile --fn X --draft .run/uc_crack/X.c --out .run/uc_gate/X.c --tu src/ov_SC01_077/<split>.c → harvest_verify --binary ov_SC01_077 --src src/ov_SC01_077/<split>.c --asm-subdir asm/ov_SC01_077/nonmatchings/<split-subdir> --drafts .run/uc_gate --good-sha d19c9580a02dc63ba1f0e7e0c770f3b10de35635 --chunk 1 → on bank: family_sweep --only 0xADDR --reconcile .run/uc_crack → R22 clean-fleet 136/136. Isolation-MATCH ≠ real-TU bank (def-side wall / codegen drift) — the whole-binary gate is the sole arbiter (G3/P9). Task board #1 (re-triage ≤28 done) / #2 (crack wave in_progress). WAVE RESULT (2026-07-10b): crack wave wf_0329d3c2-75c = 7/9 iso-MATCH (R14 re-verified via independent match_one) + 2 near (func_801365B8 c=2 irreducible cse-repr conflict, both fixes contain __asm__ so permuter-blind; func_8012E364 c=6). GATE → 4 BANKED byte-identical into ov_SC01_077: func_80134C20 (230), func_801345F8 (106), func_80141A60 (76), func_80180F10 (75). 3 iso-MATCH-but-real-TU-DRIFT (compile OK, byte-differs → back to F-band): func_80136824 (156), func_8017B614 (101 — the T1 memcpy-builtin-vs-call class: TU declares memcpy → worker's inlined block-move lowers to a CALL → drift; re-crack with field-by-field copy), func_80164930 (81). SWEEP ×134 DONE: func_80134C20 ✓133 + func_801345F8 ✓133 = 266 siblings banked; func_80141A60 133 siblings ALL byte-DRIFT (frame-pad lever is ov077-specific, doesn't remap per-sibling → frame-pad families are EXEMPLAR-ONLY, not ×134-sweepable — backlog); func_80180F10 = standalone (no h_norm siblings). BATCH = 4 exemplars + 266 siblings = 270 new matched fns. family_sweep --commit AUTO-COMMITTED (commit:0500, src/ov_/.c only, no ROM — R6/H1 OK; Drew pushes) — note it committed BEFORE R22 (running bfpt9lgm0); revert commit:0500 if R22 ≠ 136/136. Banked-but-not-swept-cleanly func_80141A60 stands as exemplar (+1). F-band ≤28 residual after this wave: 3 real-TU-drift (func_80136824/8017B614/80164930) + 2 near (func_801365B8 c=2 / func_8012E364 c=6) + 4 schedule/jtbl/iso-drift (func_8017EF50 c=4-perm-softened / func_80168828 c=5 / func_8012FCC4 / func_801549F8 jtbl / func_8017B490 real-TU). func_80141A60's 133 frame-pad siblings. ✅ R22 CLEAN-FLEET 136/136 GREEN (corrected recipe: make clean nukes asm/, so re-extract ALL 136 via for b in $BINS; do make extract BINARY=$b; done THEN check-all — cookbook §42c). Fleet 73.66% → 73.73%, dedup 1813, NON_MATCHING 7 (0 in default build). Commit commit:0500 (src banks) VERIFIED. Cookbook §42 written (density-lever catalog + 3 tooling gotchas). Doc checkpoint commit next. F-band ≤28 wave = DONE (4/9 banked, residuals backlogged above); NEXT F-band sub-tiers = 29–100 §31-Opus band + the residual re-cracks (memcpy-class func_8017B614, jtbl func_801549F8) + func_80141A60's frame-pad siblings (per-sibling frame analysis). WAVE 2 (wf_dbadb86a-6b7, 14 workers, 2026-07-10b): 9/14 iso-MATCH (R14) → GATE 4 BANKED (func_80133784 203-ins 29-100 win · func_8017B614 memcpy-fix HELD · func_8017EF50 · func_80145CEC) + 5 iso-drift (func_80136824/ 80164930/8014DD8C/8016C188/80168828 — cracked isolation-only → drift) + 5 near (func_80134A74 71→16, func_80133AB0 →28aligned, func_8012FCC4 c=3 beqz/jal delay-swap, func_80185BA4 c=65, func_801670E4 c=70 "irreducible"→G4-candidate). Sweeping the 4 ×134 (buserg6v8). META-LESSON (→ wave 3 prompt + cookbook §42 addendum): iso-MATCH ≠ real-TU bank (5/9 drifted); the ONLY iso-drift fn that banked (func_8017B614) did so because its worker VERIFIED against the reconciled real TU (embed def into a scratch copy of the split .c, compile whole TU, objdump-compare) — wave 3 workers MUST do this, not isolation-only. DURABLE LEVER (cookbook): memcpy-builtin→CALL fix = replace memcpy(x,y,8) with typedef struct{u8 b[8];}Blk8; *(Blk8*)x=*(Blk8*)y; (routes emit_block_move lwl/lwr/swl/swr, references NO memcpy symbol → immune to the TU-wide builtin-disable; mirrors sibling func_8017B368's SV4 struct-assign idiom). ✅ WAVE 2 R22 CLEAN-FLEET 136/136 GREEN. Fleet 73.73% → 73.85%. Sweep 399/0 (commit:0502); cookbook §42a written (real-TU-verify rule + memcpy fix + 5 levers). SESSION TOTAL: fleet 73.66% → 73.85% (+0.19%, ~673 fns): wave 1 4 exemplars + 266 siblings (commit:0500/commit:0501), wave 2 4 exemplars + 399 siblings (commit:0502). dedup 1813, NON_MATCHING 7 (0 in default build). NEXT (fresh session recommended, phase OPEN): WAVE 3 with the real-TU-verify rule (§42a) baked into the worker prompt over: the 5 wave-2 iso-drift fns (func_80136824/80164930/8014DD8C/8016C188/

80168828. • the 5 nears (func_80134A74 c=16, func_80133AB0 c=28, func_8012FCC4 c=3, func_80185BA4 c=65, func_801670E4 c=70)

• the >100 band (task #4, re-triage naive-inflated first) + the deferred tiers (jtbl func_801549F8, -O0 func_801457A4, func_80141A60 frame-pad siblings). Gate recipe: reconcile → harvest_verify --out build/ov_SC01_077/ov_SC01_077 → family_sweep --reconcile --commit → R22 (clean+extract-ALL-136+check-all). TOOLING GOTCHA (fix in cookbook/SETUP): harvest_verify for a NON-resident binary MUST pass --out build/<bin>/<bin> — its build() removes+sha1s --out (defaults to build/resident/resident), so without it every overlay draft spuriously reports "final SHA None"/fail even when byte-identical. func_80180F10 needed the RAW draft (canon_sig_reconcile choked on its fn-ptr cast ((s32(*)(...))func)) — raw compiled + banked directly (sig already canonical). WORKER LEVERS worth cookbook §17/§31 (from the wave journal): §31 density lever (zero-byte __asm__("":: "r"(v)) dead-read to boost a pseudo's ref-count and win a razor-thin $sN density race); opaque asm-copy __asm__("addu %0,%1,$zero") to force a param live-range split; frame-pad induction (s32 pad[2]; (void)&pad; reserves unused var_size, zero code); array-initializer LUID shift (s32 a[2]={x,y}; vs two stmts → reorders const-materialization in sched2 prologue-weave); u16* zero-extend for a high-bit (0x8000+) halfword store constant (ori opcode 0x34 vs s16* addiu/sign-extend 0x24). DIRECT register __asm__("$21") pins OFTEN BACKFIRE on giants (wreck prologue save-birthing) — density levers beat them. T7 MECHANICAL DONE (2026-07-10, Opus-Max): the curriculum's mechanical tiers are banked + swept ×134, fleet 72.29% → 73.66% (+1.37%, ~4,694 fleet fns), R22 clean-fleet 136/136 at every checkpoint, dedup 1813/0, 0 NON_MATCHING. Commits: M1 commit:0495, M2 commit:0496, M3 commit:0497. Tools: tools/t7_bank.py (M1 driver), canon_sig_reconcile v3.2 (5 defects + type-uniquify fixed), family_sweep --reconcile (the ×134 per-sibling re-reconcile). See the T7 log below + cookbook §41a/b/c. M4 RESOLVED 2026-07-10 — NOT mechanical (0/8 via reconcile_decls, R14 correction, cookbook §41b-addendum): the 8 M4 fns are byte-correct in ISOLATION but drift 8–69 in the real TU (codegen scheduling/volatile-loss, not data-type casts; 4 have no data conflict at all) → they JOIN F-band. Same probe-over-count pattern as jumptable/linkwall. The truly-mechanical curriculum tier is exhausted (M1 37 + M3-clean 2 = 39 exemplars, swept ×134). NEXT (deferred, ranked): (1) F-near = 31 near-misses + the 8 ex-M4 = ~39 fns — the genuine frontier: permuter-ILS on the ≤28-band [prompt Ultracode], §31-Opus mid-band, Fable5 only on new-idiom evidence [prompt R27]; (2) F-jumptable 4 fns / ~536 — jump-table-in-rodata workflow (cookbook §8); (3) M-linkwall 3 fns / ~402 — manual undefined-syms for dropped scratch symbols; (4) M3-residue 4 / ~407 (func_80131B14/ 8016F0AC arity, func_8013D9B0 TU-conflict, func_80182988 loose-typing) + F-perturb 4 / ~405 + draft 2 / ~268. Worklist: .run/t6_worklist.json (F_jumptable/F_near/F_perturb/M4 tiers) + .run/t7_rawdrafts/ (39 raw drafts, byte-correct-in-isolation) + docs/phase25-t6-curriculum.md. T7 discipline: good-sha from config/check.*.sha (never hand-typed); R22 clean-fleet every batch; the object-probe is NOT the gate — it's blind to rodata, link, AND in-TU codegen (cookbook §41b + addendum); size any "mechanical" tier from the whole-binary gate. T6 DONE (2026-07-09, Fable5): the crack curriculum is authored and byte-grounded — docs/phase25-t6-curriculum.md (tiers + per-fn worklists + commands) with .run/t6_worklist.json (machine-readable) and .run/t6_recon6/ (44 staged reconciled drafts). Headline: the def-side wall was ~71% TOOL-shaped — canon_sig_reconcile.py v3.1 (committed) fixes five measured defects; 44 exemplars probe-BANKABLE now (M1), the ×134 sweep works via per-sibling re-reconcile (M2, 6/6 proven — extend family_sweep with the one-line reconcile step per the curriculum §3), 6 fns need the engine_core.h no-proto rewrite (M3, fix_arity_callers class, R22-gate the neutrality FIRST), 8 need §33 TU retypes (M4). Mechanical total ≈ +2.2% fleet (~74.5%) for ~0 agent tokens. True frontier = 33 fns (curriculum §6 bands: permuter ≤28-band first, then §31-Opus, Fable5 only on new-idiom evidence — R27 prompt) + 2 tiny _o0 drafts. T7 discipline: re-reconcile at bank time (TU mutates); good-sha from config/check.*.sha (NEVER hand-typed); R22 clean-fleet after first-5 banks and every batch; probe≠gate (jal-symbol-blind) — harvest_verify is the sole arbiter. T6 HAND-OFF (2026-07-09): Step A (measure wave) DONE — 125/127 exemplars measured, batches 1–3 complete, def-side wall cracked (canon_sig_reconcile.py, cookbook §41), fleet 72.29% committed commit:0492. The mechanical reconcile-sweep is NOT the clean 51-target ×134 win first hoped (R14-corrected: the frontier "match" status carried un-verified agent claims; a 5-sample spot-check = 3/5 genuine, and even genuine MATCHes hit VARIED walls — callee-sig conflicts, non-identical types Vec3/SVEC, macro-local data). ~19/51 have clean engine_core.h canonicals = the reliable mechanical tier; the rest need per-fn work → this is genuinely the Fable5/T6 residual. So NEXT = T6: Fable5Max authors the crack curriculum from the measured frontier + the diagnosed wall-classes → the full input package is docs/phase25-t6-fable-brief.md (self-contained; read it first). Then T7 executes the curriculum (back at Opus-Max + surgical tiers). Drew: start the fresh session AS Fable5 (session model), confirm the system-reminder (R27). BATCH-3 DONE (measured, banking deferred to T7) — PAUSED 2026-07-09 at Drew's request. The 3 _o0 giants (func_8013C414/329, func_8013BD74/198, func_8013C0F8/154, all inst=134) drafted (Workflow wf_f22bdea4-50d, drafts .run/drafts-t5-batch3/): 3/3 isolation-MATCH at -O0 (R14-verified via new match_one.py --o0). But 0 banked — all 3 hit an -O0 in-context byte-diff (compile OK, SHA differs; NOT the def-side sig wall — canon_sig_reconcile's void→s32 return change is NOT byte-neutral at -O0, and gate_stage's call-site transforms don't fix it either → 3 near). Cause = callee canonical sigs changing -O0 call codegen; needs an -O0-specific reconcile (T7). Frontier updated: 125/127 draftable measured (2 tiny _o0 stragglers left: 0x8013bc7c/24, 0x8013bcdc/22). func_801457A4 = whale-region -O0 tail, deferred. Uncommitted (safe on ext4): tools/match_one.py (--o0 flag), docs/backlog.md (gate re-render), this file. No src/ banks (tree = committed commit:0492 state). BATCH-2 DONE — DEF-SIDE WALL CRACKED MECHANICALLY (2026-07-09); R22 verifying, then COMMIT. 29 non-_o0 un-measured giants drafted (Workflow wf_9ce827ee-933, drafts .run/drafts-t5-batch2/); 16 R14-isolation-MATCH (.run/t5_batch2_verify.json) but 0 auto-banked — ALL blocked by the def-side canonical-sig wall (drafts use Ghidra-typed sigs conflicting with the engine_core.h canonical, which lives inside DEFINE_func_* macros so sig_unify can't reach it). CRACKED → new tool tools/canon_sig_reconcile.py (strip ambient-dup typedefs/externs → rewrite def to canonical sig → cast changed params AT USE, never intermediate locals [locals shift regalloc → byte-diff, measured 70ff4748≠d19c9580]). Cookbook §41 + decision-log R31 entry written (R30/R31). BANKED 5 giants mechanically: func_8013B274 func_80130D48 func_80167DBC (swept ×134) + func_8016DC20 func_8018514C (exemplar-only — reconciled body carries ov-specific decls, siblings failed remap). ~404 new fn-defs. Frontier map appended (29 giants → .run/t5_frontier.jsonl: 13 near, 11 wall, 5 banked). 11 walls backlogged (per-fn T7): non-identical ambient types (func_80167AE0 SVEC, func_8016A290 ApplyMatrixSV), macro-local data symbols (func_80162438 D_80078EB0, func_80161E08 D_801D9670, +others reconcile_decls/§33 territory), u8 primitive redef (func_8016CF04), byte-diff (func_801824D0). 13 nears = permuter-ILS/Fable5 fuel (func_80134C20 c=3, func_801365B8 c=11, func_80136824 c=28 closest). RESUME: (a) R22 (.run/t5b2_r22.log, run ba10w4gum) — MUST be 136/136 before commit (R22 caught a buggy R22-harness earlier: $(OVERLAY_BINARIES) unexpanded → use BINS="main resident $(ls -d src/ov_*/|xargs -n1 basename)"). (b) If green: commit batch-2 (5 banks + 3×134 sweep + canon_sig_reconcile.py + cookbook §41 + decision-log + backlog + CURRENT_PHASE) — Drew pushes (R6). (c) Recompute fleet %. If R22 shows a real break: diagnose/revert (source spot-checks passed: ov_SC01_000/02_000/06_015/07_009 all BYTE-IDENTICAL clean). T5b batch-1 (cheap tier, 83) COMPLETE 2026-07-08, fleet → 72.18%. How to resume: reuse the proven pipeline — wave_targets/the giant list from .run/t5_targets.json (bucket=GIANT, 34) → generate a §12-robust wave (copy the .run/t5_scaleup_cont.js pattern: worker_wave head + waves-of-10 + retry, targets embedded — sandbox can't read files) → Opus-xHigh Workflow → independent match_one (R14) → split-file gate_stage --no-propagate → family_sweep --only <banked> → R22 clean-fleet 136/136 → commit. Frontier map accumulates in .run/t5_frontier.jsonl (93 exemplars so far). Giants: crack tractable directly (pilot cracked the 369-ins func_80166994), backlog intrinsic walls for Fable5/permuter; the -O0 ones (batch-3 + func_801457A4) need an -O0 match_one. Effort: Max orchestrator + xHigh workers (NOT global Ultracode) — confirmed by Drew. Phase is OPEN. Order: T7-mechanical (done) → T4 (done, FAILED) → T5 (pilot + batch-1 DONE 2026-07-08, fleet→72.18%; batch-2 giants NEXT, awaiting Drew) → T6 → T7-cracking → Close. T5 mechanics validated end-to-end (worker_wave Opus-xHigh → independent match_one → gate_stage per split-file → family_sweep ×N → R22). Effort = Max orchestrator + xHigh workers (Drew chose Opus-xHigh for ALL 127, not global Ultracode; usage not a constraint). Scale-up staged: .run/t5_waves.json (12 waves ≤10, ROI-ordered) + 5 _o0 deferred (need -O0 match_one). Frontier map accumulates in .run/t5_frontier.jsonl + the backlog (def-side-wall

• near-misses). Def-side-wall recovery (caller-decl reconcile, fleet-wide) + hard giants = T7 (curriculum-directed). The phase's CORE prize is still ahead: the 127 draftable family exemplars / 6.7 MB, cracked by the frontier tier and propagated ×134 by deterministic tooling. Do NOT write a PhaseEnd until T5/T6/T7-cracking are done and top-family ROI drops (open-ended milestone, per the plan-of-record). (A prior session misread "→ Close" in a handoff header and nearly closed early — see docs/decision-log.md; reconcile against the plan-of-record.)

T5 — the cheap-tier soften + measure wave (Step A). Over the T2 exemplars + reach-1 + reach-134-tractable: cheap drafters (v3 — NOT v4, which failed T4 — + cheap-Opus applying §31) → match_one closeness + klass per fn; permuter-ILS softens regalloc/schedule seeds. Output = the complete class/closeness frontier map + pre-advanced seeds. Bank free wins via gate_stage as they land. This is BREADTH → at session start, PROMPT Drew for /effort ultracode and WAIT for the toggle (R27); Claude cannot set effort. Tools: wave_targets.py / gen_harvest_targets.py, tools/workflows/worker_wave.js + distill.js, permuter_ils.py, bulk_harvest.py.

Done + committed: T0–T3 + T7-part-1 (matched-free sweep, commit:0476) + T7.2 decl-reconcile (commit:0479) + T7.3 h_exact stragglers (commit:0481) + T4 (v4 retrain — FAILED, keep v3) — fleet 66.02% → 70.82% → 71.32% → 71.36%. T7.2 banked 1,729 (base 532 + _after 1,197) via type-lift + mechanical remap; T7.3 banked ~200 via dedup_propagate; R22 clean-fleet 136/136 every batch, dedup-check 1813/0.

The mechanical family method (the phase's engine — T3): h_norm families are TEMPLATES, not free dedup. Per family: crack ONE exemplar → family_remap builds each member's C by positionally substituting the per-overlay symbols (read from each member's image) → plain harvest_verify byte-gate (NOT gate_stage's transforms — they perturb a correct remap). ~0 agent tokens/member. func_ names are UPPERCASE-hex.

T7.2 findings (durable — cookbook §40 refinement): (1) family_sweep --no-preclassify — the match_one pre-classify compiles in ISOLATION (-Iinclude only) so it CANNOT see src/shared/engine_types.h (pulled by the real overlay TUs via ../shared/engine_core.h); it false-negatives every type-lifted family. The flag routes remappable exemplars straight to the real-TU harvest_verify byte-gate (the sole arbiter). (2) The overlay SPLIT files (_a/_after/_o0) are SEPARATE TUs with conflicting/​shadowing local types → a blind "lift all splits" is UNSAFE: Buf has a DIFFERENT layout in _a vs _after (fleet-wide lift → conflicting types in the other TU), and _a defines MATRIX/VECTOR = PsyQ SDK names (fleet-wide lift SHADOWS the real types). Safe mechanical ceiling = base types + _after minus Buf. New tool knobs: build_engine_types --file <split.c> + --exclude <names>.

NEXT — resume the planned order (T7-mechanical was pulled ahead):

1. ✅ T7.1 surveys · ✅ T7.2 decl-reconcile (1,729; commit:0479) · ✅ T7.3 h_exact stragglers (~200; commit:0481).
2. T4 — v4 retrain + A/B gate (xHigh pipeline; Max to judge A/B). Retrain v4 on the Phase-23/24 banked-idiom corpus; A/B vs v3 (ab_match.js/ab_score.py). Keep v4 in the wave only where it beats v3. $0 to run. (models/bfm-match-7b-v3 is the current; doc docs/gen2-mips-matching-model.md.)
3. T5 — cheap-tier soften + measure wave → the complete class/closeness frontier map (Step A) + pre-advanced seeds. Prompt /effort ultracode (R27) — this is the breadth wave.
4. T6 — Fable5Max curriculum authoring from the measured map. Prompt for Fable5Max (R27).
5. T7-cracking — execute the top structural families curriculum-ordered: crack each exemplar (127 draftable / 6.7 MB), template/propagate ×134, byte-gate. Validate top ~3-5 first, then scale (Phase-15/16 lesson).
6. Close — only when top-family ROI drops (open-ended, per plan §Milestone). NOT before.

Residual backlog (revisit after the curriculum; genuine Phase-26 candidates):

• T7.2 residual: 16 split-TU-type families / ~2,128 members — need per-type reconciliation (namespaced/per-TU header, rename the cross-TU Buf, or verify _a's PsyQ MATRIX/VECTOR are layout-compatible + use real SDK headers) — NOT mechanical. .run/sweep_deferred.preT72.txt = the 29 addrs.
• h_exact engine-core straggler class — more DEFINE_func macros likely stub in siblings (dedup_propagate --auto MISSES them — it only converts INLINE defs). Sweep by --addr. Plus inline→macro hygiene of T7.2's h_exact-identical inline banks (10 fns; byte-neutral). A small family_remap.extract_unit fix to handle macro bodies would unblock the 2 h_norm-macro remap-fails (8012A568/80138C30).
• 683 whole-binary-diff simple failures (~4%: match_one-MATCH but TU-context diff, like the memcpy idiom).
• 0x8013c360 (-O0 cluster); the 2 permanent giant walls func_801412A8/func_80178004 (G4, INCLUDE_ASM).

Blockers

None.

Per-task log

T0 — Refresh + housekeeping ✅ (2026-07-08)

• Housekeeping: gccdump.lreg (repo root) = gcc's DEFAULT RTL dump (dump-base "gccdump", .lreg = local-reg pass; toplev.c:1973/2077), left by a one-off cc1 -da RTL-inspection run with CWD=root — not any committed tool (grep hits only the gcc source under tools/reference/). Deleted; root clean; no other stray dumps. Practice: RTL-inspection runs use a .run/ CWD or -dumpbase .run/gccdump (R12).
• Regenerated 134 overlay sigs (make sig-overlays, exit 0); rebuilt fuel_manifest + worklist --refresh (stale Jun-26 ranking killed → docs/worklist.md: 130 live stubs, top = the wall func_801412A8).
• Fixed tools/sig_image.py docstring (h_norm is the live norm_stream, not a "T5 placeholder" — R21/R30).
• CURRENT FRONTIER (R14 ground truth): fleet 66.02%.
  • h_exact: 82,744 unmatched classes / 111,815 instances / 27.33 MB. Reach-134 tier = 130 classes / 4.11 MB (7 tiny + 55 small + 50 med + 16 large + 2 giant-walls). x1-unique = 74,742 classes / 19.99 MB.
  • h_norm: 44,101 families; 2,764 multi-member families / 11.1 MB (the hidden lever). Top: same-address- ×134 (func_80133CD4/166994/8013C414 … 126-127 h_exact-cls / 134 inst / 199-399 ins) → match 1 → ×134; high-count-small (func_80150480: 1,997 inst × 22 ins → 1 idiom → ~2000 fns); low-variant (func_8014E284/80150170: 2 h_exact-cls / 268 inst → match 2 → ×268).
  • Solo-monster reframe CONFIRMED: 3,989 / 8,670 large (≥150-ins) h_exact-reach-1 fns have h_norm siblings (46% templatable); 4,681 truly-unique-shape (worst ROI → LAST).
  • Cheap first wins queued: T1 leaf-matches func_80155800 (#3) + func_8014F4C0 (#4) ≈ 38k gain_ins near-free; 2 permanent walls func_801412A8/func_80178004 stay INCLUDE_ASM (G4).

T1 — Integration-recovery pass ✅ (2026-07-08) — cheap cohort exhausted; deliverable = the split-aware fix

• Deliverable (committed commit:0470): recover_integration made split-aware (§39 gap). It was silently skipping the 263-stub ov_SC01_077_after cohort (drift-check hardcoded the main asm subdir; gate_stage never got src/asm/src_file). Now stub_map() reads each stub's asm subdir from its INCLUDE_ASM line and reconcile_and_gate gates per split-file group (run_gate self-filters; propagate idempotent). Reusable T5/T7.
• Finding (R14/P9): the closeness-0 caller-arity cohort is EXHAUSTED — --auto --limit 20 banked 0/16 (Phase 24 already banked the cheap decl-plumbing ones). Residuals (incl. both flagships) are per-function TU-context matching, not decl-plumbing.
• The blocker class (matching idiom → cookbook when it recurs, R16): an 8-byte mem-copy written as a struct-assign *(T*)x = *(T*)y (func_8014F4C0's Vec4u) is match_one-MATCH in isolation but lowers to a memcpy CALL in a TU that declares memcpy (sibling extern void *memcpy(...) disables the builtin) → byte mismatch (9d043345≠d19c9580). Banked sibling convention = explicit memcpy(x,y,8) or field-by-field lhu/sh (the target uses lhu/sh). T5/T7 drafters: avoid struct-assign for small mem-copies in these overlays.
• Decision (Drew): conclude T1; closeness-0 residuals stay in the ranked backlog (available later); the 2 flagship ×134 leaf-matches NOT hand-banked (per-function ROI < the family lever).

T2 — Exemplar-scoped target manifest ✅ (2026-07-08)

• Deliverable: tools/family_manifest.py (committed, reusable) → docs/family-manifest.md + gitignored .run/family_manifest.json. Regroups the unmatched frontier by h_norm; per family: the ov_SC01_077 drafting exemplar (where present), instances (the ×N leverage — NOT h_exact-reach, ~1-3 for byte-shattered families), size, byte-weight. 44,101 families; 2,764 multi-member / 11.1 MB.
• The endgame's 3 levers (× ov_SC01_077 membership):
  • draftable 127 / 6.7 MB — unmatched ov077 member → draft the exemplar (primary T5/T7; most byte-weight).
  • matched-free 156 / 2.3 MB — matched ov077 member + unmatched siblings → FREE --tier h_norm propagation (draft-free; the T3 proof + a free win).
  • absent 2481 / 2.1 MB — no ov077 member → small fns in other overlays, draft elsewhere (low priority).
• Insight: h_norm families are reloc-only by construction, so the matched-free bucket is likely bankable NOW by re-propagating already-matched ov077 fns via --tier h_norm (byte-gated). T3 tests decisively.
• T3 candidates (mid-size draftable): 0x8012c890(149)/0x8016d1d8(148)/0x8013d9b0(141) — all inst=134, ~127 hexcls.

T3 — Swing-question PROOF ✅ (2026-07-08) — free lever refuted; mechanical remap PROVEN (the phase's pivot)

• Free --tier h_norm dedup REFUTED (R14): propagating ov_SC01_077's matched 0x80141100 across its 133 h_norm-siblings banked 0/133 (all byte-diverge). h_norm families are byte-shattered because each member references per-overlay symbols (D_80187xxx in ov077 vs D_8017Fxxx in ov000) — one C body can't name 134 overlays' symbols. This also kills the plan's draft-then-propagate fallback (same mechanism).
• Mechanical symbol-remap lever PROVEN → tools/family_remap.py: two h_norm-identical members have identical instruction streams except in the masked reloc fields, so disassemble both overlay images at ADDR, positionally pair the resolved reloc targets, substitute the exemplar C's per-overlay symbol NAMES with the sibling's. Verified: reloc decoder 22/22 vs .s; 0x80141100→ov_SC01_000 whole-binary BYTE-IDENTICAL + harvest_verify banked (9052dc0e); 12/12 siblings SC01-SC07 match_one; 7/9 families × 3 siblings = 21/27 match_one.
• The 2 failures = decl/type plumbing (custom MatEntry type + conflicting shared ApplyMatrixSV decl — a COMPILE error, NOT a byte mismatch): the remapped draft must reconcile decls with the target's ambient engine_core.h/engine_types.h (strip ambient externs). A known-solved T7 refinement, not a remap failure.
• Gate path for remapped drafts = plain harvest_verify (gate_stage's canon/cast/sig_unify transforms PERTURB an already-correct remap → 0-bank; skip them for remaps).
• Endgame reshaped: the 11.1 MB h_norm families are cheaply, MECHANICALLY recoverable — crack ONE exemplar per family → remap+gate members (~0 agent tokens/member). Members no longer need drafting; only exemplars do.

T7 (part 1) — MECHANICAL family sweep: matched-free harvest ✅ (2026-07-08, commit:0476)

• Built tools/family_sweep.py (two-phase: stage all remaps per overlay, gate each (overlay,split) group ONCE via plain harvest_verify; a match_one pre-classify defers compile-failing type-using families to avoid bisection blowup). Driver validated on func_80141100 (133/133 banked, committed commit:0475).
• BANKED 16,512 member-matches (131 simple exemplars × ~133 siblings) + the 133 validation; 0 remap-fail. R22 clean-fleet verify: 136/136 byte-identical from a fully clean tree (make clean + extract-all + check-all). Fleet 66.02% → 70.82% (+4.8% in ONE deterministic, ~0-agent-token pass). dedup-check 1813/0.
• Deferred (.run/sweep_deferred.txt): 29 type/decl (type-lift recoverable), 4 diff, 4 remap-fail.
• 683 / 17,195 simple drafts failed the whole-binary gate (match_one-MATCH but TU-context diff, ~4%; auto-reverted).
• Reproduce: family_sweep.py --limit 0 (after make sig-overlays). The remap is family_remap.py.

T7.2 — decl-reconcile the 29 type/decl families ✅ (2026-07-08, commit:0479) — 1,729 banked; split-TU wall found

• T7.1 refresh: make sig-overlays (134 re-signed) + family_manifest.py — levers unchanged (2,764 families; 127 draftable / 156 matched-free) because they key on ov077 membership, which the 16.5k sibling-banks didn't change.
• Base type-lift: build_engine_types --source ov_SC01_077 --strip lifted 4 base-local types (MatEntry, P_TAG, OtBlk, packed_word/word_bytes) → engine_types.h; byte-neutral (ov077 d19c9580). Banked 532.
• The pre-classify false-negative (R14): after the lift, all 29 STILL pre-classified as type/decl (0 simple). Root cause: match_one isolation compiles with -Iinclude + a prepended common.h — it does NOT see src/shared/engine_types.h (the real overlay TU pulls it via ../shared/engine_core.h). PROVEN false-negative: single real-TU gate func_80142A80→ov_SC01_000 = 9052dc0e BYTE-IDENTICAL. FIX: family_sweep --no-preclassify.
• The split-TU wall: the 25 remaining families need types from the overlay SPLIT files, which are SEPARATE .o TUs with conflicting/​shadowing local types. Blind "lift all splits" FAILED: typedef Buf has a DIFFERENT layout in _a.c vs _after.c (conflicting types for Buf when shared); _a.c defines MATRIX/VECTOR (PsyQ SDK names → fleet-wide SHADOW). Safe ceiling = base + _after minus Buf (build_engine_types --file … --exclude Buf): byte-neutral, banked +1,197 (9 of 10 _after families/overlay; the 1 miss is the Buf-user).
• T7.2 TOTAL 1,729 (532 + 1,197). R22 clean-fleet 136/136 from clean tree; dedup-check 1813/0; fleet 71.32%.
• Deferred → Phase 26: 16 families / ~2,128 members (see backlog above). Old deferred snapshot preserved at .run/sweep_deferred.preT72.txt (the 29 addrs).
• Reproduce: build_engine_types --source ov_SC01_077 --strip ; build_engine_types --file src/ov_SC01_077/ov_SC01_077_after.c --exclude Buf --strip ; family_sweep --only <29 addrs> --no-preclassify.

T7.3 — edge-case triage: 2 h_exact stragglers banked ✅ (2026-07-08, commit:0481) — +~200 members

• Triaged the 8 T7-part-1 edge cases (4 diff + 4 remap-fail). Finding: the 4 remap-fails are matched in ov077 via the DEFINE_func_<ADDR>() engine-core MACRO (§11 h_exact source-share), NOT an inline def — so family_remap's extract_unit (keys on a func_<ADDR>( DEFINITION) can't extract them. 2 of them (func_80128EA8, func_80132EC4) are h_exact-identical fleet-wide but were stub in 100 overlays → banked via the EXISTING dedup_propagate --addr --tier h_exact (118 overlays byte-identical each). R22 clean-fleet 136/136; dedup-check 1813/0; fleet 71.32% → 71.36%. (byte-% moves little: asm stubs were already byte-identical; the win is 200 fns now C, not asm.)
• Deferred → Phase 26: the 2 h_norm-macro remap-fails (8012A568/80138C30 — h_norm AND macro-defined, neither h_exact-propagatable nor family_remap-extractable); 8013C360 (-O0 cluster); the 4 "diff" cases mostly already banked (stub-in-0 now).

SESSION PROGRESS (2026-07-08) — T7-mechanical pulled ahead; phase OPEN (T4→T5→T6→T7-cracking remain)

This session (T7.1–T7.3, all committed, R6 = Drew pushes): fleet 70.82% → 71.36%; +1,929 member-matches (T7.2 1,729 via type-lift+remap commit:0479/commit:0480; T7.3 ~200 via h_exact propagation commit:0481/commit:0482). Every batch R22 clean-fleet 136/136, dedup-check 1813/0. Tools added: family_sweep --no-preclassify; build_engine_types --file/--exclude. Cookbook §40a written (R30). NEXT = T4 (see the RESUME section above); NOT closing — the curriculum + 127-draftable exemplar-cracking is the phase's core, still ahead.

T4 — v4 LoRA retrain + A/B gate ❌ FAILED / NEGATIVE (2026-07-08) — v4 discarded, KEEP v3

• Retrained v4 (same recipe as v3, corpus 2,891→3,574) — converged (loss ~0.082). Gate-true A/B vs v3 on identical held-out functions, 3 bands: easy 6-14 both 5/5; medium 18-40 v3 closer near-misses + fewer compile-fails (v3 better on 9/12); hard 45-85 both 0/10. v4 = marginally WORSE. Verdict: discard v4, keep v3 (frozen ceiling). "Corpus quality > size" confirmed; the 7B is capacity-bound (0/5 even on trained fns, NOT truncation).
• v3 remains the drafter (models/bfm-match-7b-v3). v4 adapter kept at models/bfm-match-7b-v4 (gitignored) for reference only. Full write-ups: docs/decision-log.md (strategic — 7B off the endgame critical path) + docs/gen2-mips-matching-model.md (technical — the A/B + the maxlen-2048 truncation flaw for any future retrain).
• Strategic conclusion (Drew-aligned): the local-7B tier is a $0 mop-up for the ≤~15-ins tail, NOT load-bearing. The endgame engine is frontier-crack → deterministic-propagate → byte-gate + permuter-soften. No more 7B retrains.

T5 — cheap-tier soften + measure wave (Step A) — PILOT ✅ (2026-07-08); scale-up in progress

• Pipeline validated end-to-end (the T5 engine): tools/family_manifest→ .run/t5_targets.json (127 draftable exemplars, live-stub-verified: 34 GIANT/18 large/43 med/32 small) → worker_wave.js (Opus xHigh, 1 drafter/target, returns {status,closeness,klass}) → independent match_one re-verify (R14) → gate_stage --src-file <split> (per split; the whole-binary byte-gate is the arbiter) → family_sweep --only <addr> (h_norm mechanical remap ×N) → R22 clean-fleet 136/136.
• Pilot (10 diverse targets): 7/10 match_one-MATCH incl. a 369-ins giant (func_80166994) cracked by the wave. Whole-binary gate banked 3/7 clean (func_801596F0, func_8014D3E0, func_801320D8); family_sweep → +399 siblings, 0 failed across 133 overlays (~0 agent tokens). Fleet 71.36% → 71.47% (+402 fns), dedup 1813/0.
• Key findings (frontier data → T6): (1) byte-weight ≠ tractability — func_8014D3E0 (22 ins × 1997) looked like the mega-ROI freebie but is a $sp stack-switcher, matched only by porting an already-matched sibling (func_8014D04C); the 369-giant fell to the wave while a 304-giant (func_8014D820) is close=253 (Fable5). (2) The dominant gate-failure is the def-side loose-typing wall (4/7): a byte-correct draft whose CALLERS carry guessed sigs (void func_X(s32,s32…)) that conflict fleet-wide with the true def; gate_stage runs sig_unify (which regresses these) but not a caller-decl reconcile. func_80166994 is genuinely loose-typing-entangled (5 callers, mixed s16/s32 args → truncation risk) = T7. (3) family_sweep is SAME-ADDRESS only → func_8014D3E0's cross-address h_norm instances (~1863 of 1997) are a T5c/T7 cross-address-remap follow-up.
• Class dist (pilot): schedule 5, other 2, iv-combine/struct/plumbing 1 each. Near-miss permuter/Fable5 fuel: func_8017B490 (3), func_8014DD8C (88), func_8014D820 (253).
• Reproduce: target pool .run/t5_targets.json; frontier .run/t5_frontier.jsonl; waves .run/t5_waves.json. Scale-up (117) + permuter-ILS soften (T5c) + frontier synthesis (T5d) NEXT; def-side-wall recovery tool → T7.

T5b — measure-wave batch 1 (the ≤149-ins cheap tier) — PARTIAL ✅ (2026-07-08); MORE BATCHES LATER (Drew)

• Generated a §12-robust scale-up wave (tools/workflows/t5_scaleup.js: worker_wave's drafter prompt + sequential waves-of-10 + retry×2, targets embedded — sandbox can't read files). Launched over the 83 ≤149-ins targets.
• Drew stopped it at ~50 (HTTP 529 Overloaded under API load — the §12 throttle; retry+gap-fill was recovering it, no work lost). 54 drafts landed, 0 truncated. Processed as T5b per Drew's instruction (don't restart; bank what's done; checkpoint + pause; more T5b later).
• Results: independent match_one (R14) = 46/54 MATCH (85%; cheap tier). gate_stage per split (main/​_a/​_after) banked 16 clean (main 1 · _a 10 · _after 5) → family_sweep +1,861 siblings / 1 fail across 133 overlays (14 exemplars swept, ~0 agent tokens). Fleet 71.47 → 72.02%, R22 clean-fleet 136/136, dedup 1813/0.
• The def-side loose-typing wall is confirmed dominant at scale: ~30 of the 46 match_one-MATCH drafts were byte-correct standalone but gate-rejected (caller carries a guessed sig) → all backlogged. This is the #1 lever for T7 — a fleet-wide-gated caller-decl reconcile would convert most of them. Clean-bank rate ~16/46 = 35% (matches the pilot's 3/7).
• Frontier map: 64 exemplars measured (.run/t5_frontier.jsonl; classes: struct 15, plumbing 13, schedule 11, regalloc-order 11, remat 5, …). Near-miss permuter fuel: func_8012FCC4/func_801549F8 (3), func_8017EF50 (4).
• BATCH-1 CONTINUATION DONE (the 29 undrafted cheap, 74-149 ins): a resume (resumeFromRunId) recovered the 9 session-cap failures (20 cached-replay + 9 re-run, 0 errors). 22/29 -O2 match_one-MATCH → 8 clean banks + 533 siblings (fleet 72.02 → 72.18%, R22 136/136). Notables logged to backlog: func_801457A4 (MATCH but -O0-only → batch-3), func_80135004/func_8013AD38 (MATCH but need the T7 caller-decl reconcile), func_80168828 (close=8, permuter fuel). Batch-1 cheap tier now 100% drafted. Gen3 recomp/PsyQ→Vulkan architecture idea captured to docs/gen3-parking-lot.md (Drew spitball).
• REMAINING: the ~34 giants (batch-2, AWAITING Drew) + 5 _o0 (batch-3, -O0 match_one) + permuter-ILS soften (T5c) + frontier synthesis (T5d) + the def-side-wall reconcile tool (T7 lever #1). Scale-up wave generator reusable.

RULES ADDED THIS PHASE (transcribe to the PhaseEnd Rules table at close)

• R31 — CONFIRMED by Drew 2026-07-08 (binding now). Capture the WHY behind strategic pivots in docs/decision-log.md, while fresh. At each major direction change / dead-end / reversal, log (during the producing session): context+belief → what was tried that failed → the pivot → the byte/measurement-grounded why → a hindsight "better path" note. Extends R30 (which covers TECHNICAL artifacts — cookbook idioms, byte-verified findings, distillations) to STRATEGIC / decision rationale — the perishable judgment the terse PhaseEnd Deviations table can't hold and a fresh session reconstructing from compressed summaries would lose. Forward-only (no backfill from summaries). It is the substrate for the eventual project retrospective + the public "how to AI-decomp a new project" wiki (Drew, 2026-07-08). Doc created + seeded with this session's two fresh pivots (the handoff-misread; the split-TU mechanical ceiling).

T6 — Fable5Max curriculum authoring ✅ (2026-07-09, the Fable5 session)

• Deliverables: docs/phase25-t6-curriculum.md (the tiered crack curriculum, all numbers probe-derived) + .run/t6_worklist.json (machine-readable tiers) + .run/t6_recon6/ (44 staged reconciled drafts) + tools/canon_sig_reconcile.py v3.1 + cookbook §41a + a decision-log entry (R31).
• Method: R14 re-verified all 95 stubs (.run/t6_verify.json: 62 iso-MATCH / 31 near / 2 no-draft) → 6-iteration probe program (reconcile → splice into the real TU → full pipeline → masked in-TU byte-compare; .run/t6_reconcile_probe*.json) → v1's reconcile itself was the wall for most (5 defects fixed) → BANKABLE 10→20→37→44. Swing answers: Q1 = 44 mechanical (not ~19); Q2 = resident-callee extension moot (real class = self/arity conflicts → M3 no-proto); Q3 = -O0 reconcile REFUTED (all 3 _o0 giants bank under v3.1); Q4 = type collisions are a RENAME, never layout (SVEC/ApplyMatrixSV giants bank); Q5 = ×134 sweep = remap + per-sibling re-reconcile, 6/6 proven (§41 fragility dissolved).
• Validation: func_8013DD68 (187-ins "wall" giant) banked BYTE-IDENTICAL through the real make build gate (then restored — no T7 execution in T6; tree stays at the committed state + these deliverables).
• Cost: ~0 agent tokens (local deterministic compute only; no Workflow/Agent fan-out).

T7 — EXECUTE the crack curriculum: mechanical tiers M1/M2/M3 (2026-07-10, Opus-Max orchestrator, ~0 agent tokens)

Fleet 72.29% → 73.66% (+1.37%, ~4,694 fleet fns); R22 clean-fleet 136/136 at every checkpoint; dedup 1813/0; 0 NON_MATCHING (G4).

• M1 (commit commit:0495) — 37 exemplars banked ×1. tools/t7_bank.py (reconcile-at-bank-time + harvest_verify whole-binary gate; chunk-bet + per-round re-reconcile for cross-fn ambient mutation; giants first). Two canon_sig_reconcile fixes surfaced during execution: (a) v3.2 uniquify ALL draft-defined type names + struct tags to <name>_<addr> (the redefinition of struct Fr inter-draft-collision class when many exemplars bank into one TU) — banked the 284-ins func_8016A290; (b) the earlier v3.1 5-defect set. R14 CORRECTION (cookbook §41b): the T6 object-only probe OVER-counted BANKABLE by 7 — it's blind to rodata + link: 4 jump-table fns (3 _o0 giants + func_8012ACE0) have byte-perfect .text but a switch jump table in rodata diverges (REFUTES the T6 "Q3 -O0 REFUTED" claim → F-jumptable); 3 last-referencer link-walls (func_8016D688/D1D8/165240) C-ify the only asm referencer of a scratch data symbol → ld undefined reference → M-linkwall.
• M2 (commit commit:0496) — 4,389 members swept ×134. family_sweep --reconcile: per (exemplar, sibling), symbol-remap the RAW draft then RE-RUN canon_sig_reconcile against THAT sibling's TU (the Q5 law — plain remap of the ov077-reconciled body banks 0; per-sibling reconcile banks 94%). 4,389/4,655 (266 per-sibling loose-typing-wall misses → backlog). cookbook §41c.
• M3 (commit commit:0497) — 2 no-proto exemplars + 266 swept. Rewrote 4 clean fns' engine_core.h macro-internal externs to no-proto (10 byte-neutral decl edits); banked func_8012D664+func_8015D01C, swept 266/266 (100%). The fleet-wide EC change R22-verified neutral (136/136). 4 residue deferred.

Deferred backlog (ranked, .run/t6_worklist.json tiers + .run/t7_rawdrafts/): F-near 31 / ~3,775 ×134 (the genuine permuter/§31-Opus/Fable5 frontier — bands in curriculum §6) · M4 8 / ~1,206 (§33 reconcile_decls TU-retype, mechanical-untried) · F-jumptable 4 / ~536 (jump-table-in-rodata, cookbook §8) · M3-residue 4 / ~407 (func_80131B14/8016F0AC arity, func_8013D9B0 TU-conflict, func_80182988 loose-typing) · F-perturb 4 / ~405 · M-linkwall 3 / ~402 (manual undefined-syms) · draft-needed 2 / ~268 (tiny _o0). ~56 exemplars / ~7,000 fleet-inst potential remain.