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

# CURRENT_PHASE — Phase 24: Fix + evolve the permuter (§31-class-aware) · integration-recovery tool · scale the §31 wave

**Started:** 2026-07-02 · **Effort:** Max · **Gen2 phase 16 of the arc (8→…→23→24)** · Open-ended matching phase (checkpoint-close, like 15/20/21/22).
**Plan:** approved (Drew, sequencing = permuter-first, staged). Full plan: `/home/musashi/.claude/plans/plan-mode-enabled-max-tender-bengio.md`.
**Baseline at phase start:** fleet 64.86% byte-identical-from-source (~30% byte-weighted); 136/136 binaries byte-identical; 0 NON_MATCHING; dedup groups per Phase-23 close. main `143dbb89…`, resident `8e17e02f…`, ov_SC01_077 `d19c9580…`.

## Invariant (every task)
Whole-binary byte-gate (`tools/harvest_verify.py`) is the SOLE arbiter (G3/P9). Tools only reshape declarations/plumbing or PROPOSE candidates; nothing banks except a byte-identical SHA1 rebuild, verified CLEAN (R22): `make clean && (extract all 136) && make check-all` → 136/136; `tools/dedup_integrate.py --check` 0-failed; `tools/progress.py --fleet` monotonic up. No Ghidra DB change (R23 restart-noise — do NOT stage `db.*.gbf`).

## Task checklist
- [x] T1 — Re-log map-wave results + backlog hygiene *(xHigh)*
- [x] T2 — Permuter Stage-0: floor-free masked scorer (-drz) *(Max)*
- [x] T3 — Permuter setup fixes: pins · typedefs · -O0 *(xHigh)*
- [x] T4 — Probe the flagship func_80132784 (4/400) + count-exact seeds *(Max)*
- [x] T5 — Permuter evolve: §31-directed mutation + grinder fixes *(Max)*
- [x] T5b — Fable5 §31 map-extension spike: S11 CRACKED (func_8014E048 banked; S12/S13/RC-10 → §31) *(Max; Fable5)* — + found the Phase-21 breakage (overlay GetTPage + main-side 62 refs → both fixed in T5c)
- [x] T5c — Fix the Phase-21 main/library clean-rebuild breakage (62 dangling INCLUDE_ASM refs) *(Max)* — renamed to curated names; **true clean 136/136 restored**; added `tools/lint_symbol_refs.py` guard
- [x] **T6 — Integration-recovery tool + ×134 propagation-recovery** *(Max)* — flagship `func_80132784` ×134 (`commit:0443`) + `recover_integration.py` (`commit:0445`); **§A propagation-recovery COMPLETE (2026-07-03):** 15 more fns propagated ×134 — the 13 leaf-MATCHes (`commit:0447`) + func_8014E048 (T5b S11 crack) + func_80157580 (`commit:0448`). Fleet 64.90→**65.48%**, **clean fleet 136/136 (R22) after each batch**, dedup 1784→1799/0. Tool fixes: find_site indented-defs + trailing-comment externs, `dedup_propagate --recover` (Part B reconcile / Part A per-overlay exclude), build_engine_types comment-awareness. Broader capped tail (17 skips: 3 pin/asm/SHB stragglers + 14 local-type) → T8 sweep.
- [x] T7 — Region-a giants *(Max)* — **✅ GIANT ENDGAME COMPLETE (2026-07-08):** §G batch (6/8 cracked, 4 ×134) + whale ×134 + this session's `func_801770E0` + `func_801372B0` ×134 ⇒ every matched region-a giant is ×134; NO matched giant remains ×1. The 2 remaining reach-134 giants are permanent walls (`func_80178004` biv-init, `func_801412A8` alloc-knot — INCLUDE_ASM, G4). Small ×1 tail (3 stragglers + 17 local-type) → T8. Fleet 66.02%. — giant-crack pipeline PROVEN: `func_80129CF8` Fable5-cracked + §32 idiom + banked ×1 (`commit:0450`) → **NOW ×134** (via T7b/T1: the "×134 wall" was an **R14 MISDIAGNOSIS** — the already-reconciled ×1 bank propagates cleanly via existing `dedup_propagate --recover`; clean fleet 136/136, fleet **65.52%**). 6 sibling giants still stubs (need Fable5/Opus match → then the tool).
- [x] **T7b — Canonical-decl reconcile tool** *(Opus, Max — NOT Fable5)* — **COMPLETE** (plan `plan-…mossy-dawn.md`, T1–T6, commits `commit:0452`/`commit:0453`/`commit:0454`/`commit:0455`). **T1 (R14):** the "×134 wall" was a misdiagnosis — `func_80129CF8` banks ×134 FREE. **T2/T3:** `tools/reconcile_decls.py` (fleet-majority oracle + byte-neutral data-cast transform, wired into gate_stage), byte-proven. **T4** no-op (no per-member conflicts). **T5:** 2nd giant `func_80138ED0` MATCHED (Opus+§32→close=21→Fable5 MATCH) + banked ×134 — validates the tool + pipeline on a real un-reconciled sibling; **2 giants ×134 this task**, fleet 65.48→**65.56%**, clean 136/136. **T6:** cookbook §33/§34 (+ the 3-qty sort bug / zero-byte asm toolkit / giv-init fence), §31 map RC-11, SETUP, design-doc RESOLVED. Reframed value: the tool AUTOMATES the manual reconcile for freshly-matched giants + the wave tail (6 sibling giants remain).
- [ ] T8 — Scale the §31 wave *(breadth → prompt for /effort toggle, R27)* — §D
- [ ] T9 — Distill + PhaseEnd *(Max, Tier-1)* — §E

**Current task:** ✅ **T7 §G ×1→×134 GIANT ENDGAME COMPLETE (2026-07-08)** — both remaining ×1 giants (`func_801770E0` 152, `func_801372B0` 207) banked ×134 via the native `dedup_propagate` DEFINE-macro path (R14: the handoff's 3rd "×1 giant" `func_8014E048` was already ×134). Clean fleet **136/136 (R22)**, dedup **1813/0**, fleet **66.02%**; no matched giant remains ×1; cookbook **§39** distilled. **NEXT (Drew's call):** **T8 — scale the §31 wave** over the near-miss / small-tail residuals (breadth-shaped → prompt for `/effort ultracode`, R26/R27; the 3 now-propagatable stragglers + 17 local-type ×1s are cheap fodder), **OR close the phase** (T9 — PhaseEnd, Tier-1 Max). **Rules check ✓ (P6).** main `143dbb89`, resident `8e17e02f`, ov_SC01_077 `d19c9580`; all 134 overlays now carry `func_801770E0` + `func_801372B0` ×134.

**Fable5 policy (Drew, 2026-07-02):** Fable5 (`Agent(model:fable)`) is the reserved *discovery / wall-breaker* tier (reads the gcc-2.7.2 source; ~375k tok/giant), NOT the workhorse. Cheap-tier-first: permuter + Opus applying §31 → Fable5 only when they stall. Two uses this phase: (1) **on-demand escalation** on any giant the fixed permuter can't close (T4/T8 — no task); (2) **T5b** proactive spike to test whether S11/RC-6 are truly intrinsic. A Fable5-cracked lever goes into §31 (R16) so Opus applies it thereafter.

## §G — GIANT ENDGAME QUEUE (NEXT SESSION — Drew, 2026-07-04) — start AFTER this session's 3-giant Fable5 batch lands
> The remaining **~9 reach-134 giants (≥150 ins)** to harvest next session (12 reach-134 giants were stubbed post-T7; **this session's batch = func_801392FC/8013A530/8013AF20**, banked HERE first). **Strategy: closest-to-completion FIRST + fast-track the whale via a cheap triage** — NOT smallest→largest (closeness = the effort; size = the payoff; a 204-ins giant can be close=10 while a 152-ins one is close=52). **R14: RE-MEASURE closeness first** (`match_one` per giant — the backlog values below are Phase-23-era, likely stale). **Bank this session's Fable5 idioms into §31 BEFORE starting** (compounding). Banking recipe = cookbook **§35**; per-giant integration classes (caller-conflict / callee-proto / local-typedef) in §35.
>
> **The order:**
> 0. **Verify near-free:** `func_80178004` (165, backlog close=**0**, no saved draft) — `match_one` it FIRST; may bank almost free.
> 1. **Closeness ladder (drafted/close = fast certain wins):** `func_8014EA4C` (183, ~c6) → `func_801571C4` (198, ~c24) → `func_80176D94` (152, ~c52, drafted) → `func_801770E0` (152, ~c53) → `func_80148094` (213, ~c72, drafted) → `func_801412A8` (198, ~c110, drafted) → `func_801372B0` (207, ~c173).
> 2. **THE WHALE — triage EARLY, in parallel:** `func_80144B9C` (**770 ins**, untouched) — a cheap Opus pass (ranking-law triage: param/buffer-based → one-shot ≈ **+1.6% byte-weight free**; global-array-hoister → close-draft + Fable5). Its byte-weight ≈ the next ~8 giants COMBINED — the single biggest lever on the honest byte-weighted % (giants ≈ 35% of remaining byte-weight, Phase 19). Do NOT bury it at the end of the closeness queue.
>
> **Method per giant:** cheap Opus applying §32/§34/§35 (ranking-law triage) → bank via the §35 recipe if close; if stalled at a genuine global-hoist/regalloc wall → Fable5 (sequential, idiom-banking). ~90 total ≥150-ins stubs exist in ov_SC01_077 but only these ~12 are reach-134 (×134 payoff); the ~78 lower-reach large fns are a separate, lower-value tail.

## R14 corrections carried in (do NOT re-adopt the stale Phase-23 backlog framings)
- "split-file-blind glob" is refuted — the real defect is `compile.sh`/`match_one.py` are **-O2 only** (can't match `_o0`). → -O0 compile.sh variant (T3).
- "churn-without-blacklist" is refuted — the real churn is **floor-victim idle re-tries** (`grinder.py:120 tried.clear()`). → scorer (T2) + input-changed gating (T5).
- `func_80144090` ×1 is a **type-lift** case (`OtBlk` not in `engine_types.h`), NOT a straggler. → `build_engine_types.py` (T6).
- `backlog.jsonl` closeness is **stale/regressed** for the wave seeds (true values in `.run/wave/*.c` headers; `func_8014E048` logged `failed` → `wave_targets` skips it). → re-log first (T1).
- The "~95/80/31" class counts are aspirational; real canon `SCHEDULE=30/REGALLOC=84/REMAT=3`, steerable near-misses scattered in `OTHER`/`None`. → wave text-scans `where_stuck` (T8).
- `gcc-papermario` is gcc **2.8.1**, not 2.7.2; vanilla 2.7.2 at `tools/reference/gcc-2.7.2/` (cite it). `loop.md` on vanilla; sched/regalloc/cse map files still cite 2.8.1 lines.
- **No decomp-permuter submodule edit** for the overhaul (scorer rebind + `#pragma _permuter b64literal` pin carrier + `weight_overrides`, all in `tools/`). The pin-scope randomizer pass (only submodule edit) is deferred.

## Progress log
*(append one line per task on completion — the crash-recovery trail)*
- **✅ T7 §G ×1→×134 GIANT ENDGAME COMPLETE (2026-07-08) — `func_801372B0` (207) banked ×134; BOTH remaining ×1 giants now ×134.** Unique-renamed local `SVEC`/`GLINE` → `Svec_801372B0`/`Gline_801372B0` (a DIFFERENT same-named `SVEC` with u16 fields lives in `_after.c` → a bare-name lift would double-define fleet-wide) + lifted to `engine_types.h`; ov_SC01_077 byte-neutral (`d19c9580`); `dedup_propagate --addr 0x801372B0 --recover` → 134 byte-identical, group `E_func_801372B0`. CLEAN fleet **136/136 (R22)**, dedup **1812→1813/0**, fleet 65.99→**66.02%** (byte-weighted gain larger). **Completeness scan (R14): NO matched giant remains ×1** — the only reach-134 ×1 fns left are SMALL (3 now-propagatable stragglers `0x80174650`/`0x8012A018`/`0x80165CA0` + 17 local-type-blocked) = the **T8 tail** (Drew's focus directive: giants only, no small sweeps; my `overlay_files` fix incidentally unblocked the 3). Distilled → cookbook **§39** (native-DEFINE-path-for-O2-giants · the `overlay_files` post-whale-split gap · `find_site` extern-comment class · unique-rename typedef-lift · R14 handoff-staleness). **The giant endgame is fully banked ×134** (whale + 6 §G cracks + func_801770E0 + func_801372B0). Remaining reach-134 giants = the 2 permanent walls (`func_80178004` biv-init close=7, `func_801412A8` alloc-knot close=29 — INCLUDE_ASM, G4). Commit: (this).
- **T7 §G ×134 GIANT ENDGAME (2026-07-08, this session) — `func_801770E0` (152) banked ×134 via the NATIVE DEFINE-macro path; R14: `func_8014E048` was ALREADY ×134 (handoff line-49 stale).** Verified each named ×1 giant against the bytes (R14): `func_8014E048` is a 134-member group + `DEFINE_func_8014E048()` in every overlay (done in T6 §A) — NOT ×1. Only `func_801770E0` + `func_801372B0` actually remained. **Chose the native `dedup_propagate` DEFINE-macro path over the handoff's hand-rolled shared-header** — `func_8014E048` (pins+asm) is ×134 via a DEFINE macro, PROVING that path handles pin/asm -O2 giants (the whale needed a shared header only because it's -O0 → separate object). **Blocker found + fixed (reusable):** `dedup_propagate.overlay_files` scanned `_a`/`_o0` splits but NOT the whale-rollout-created `_o0b`/`_after` — so every post-whale-region fn (func_801770E0 @0x801770E0 lives in `_after.c`) was invisible for BOTH source-def-find and stub-replacement → added `_o0b`/`_after` to the suffix list. Also made func_801770E0's extern block contiguous (a `/* comment */` between externs made `find_site` drop the earlier 5 externs → compiles_standalone fail; byte-neutral relocation). Then `dedup_propagate --addr 0x801770E0 --recover` → **134 overlays byte-identical, 0 stragglers, group E_func_801770E0 registered**. CLEAN fleet (make clean+extract-all-136+check-all) = **136/136 (R22)**, dedup **1811→1812/0**, fleet 65.95→**65.99%** (byte-weighted gain larger — 152-ins giant). **NEXT: `func_801372B0`** (207; blocker = local `SVEC`/`GLINE` typedefs, also used differently in `_after.c` → unique-rename `Svec_801372B0`/`Gline_801372B0` → `engine_types.h`, byte-verify d19c9580, then `--recover`). Commit: (this).
- **🔜 NEXT SESSION (2026-07-07, whale done) — the 2-3 ×1-matched giants → ×134 (Drew: "finish the giants").** `func_801372B0` (207) + `func_801770E0` (152) + `func_8014E048` (143, T5b S11 crack) are MATCHED but banked ×1 in ov_SC01_077, STUBBED in the other 133 overlays — blocked from ×134 because `dedup_propagate.compiles_standalone` (tools/dedup_propagate.py:246) REJECTS register-asm-pin / anon-struct / local-typedef bodies (§A). Est. ~+0.4-0.6% byte-weight (already-matched; no new matching). **WHALE-DERIVED LEVER (a promising LEAD — verify, not proven):** the whale propagated ×134 WITHOUT dedup_propagate — via a **shared header** (`src/shared/func_80144B9C.h`) + a **hand-registered** h_exact dedup group (`.run/t7b/register_whale_dedup.py` → E_func_80144B9C, `source=`the header). This pattern **BYPASSES `compiles_standalone` entirely**. The ×1 giants may bank ×134 the same way: extract each matched body → `src/shared/<fn>.h`, then in ov_SC01_077 AND each of the 133 overlays replace the `INCLUDE_ASM(<fn>)` line with `#include "../shared/<fn>.h"` **AT THE STUB POSITION** (NOT the file top — the fns are position-locked in the -O2 main subseg, unlike the whale which had its own o0b subseg), and hand-register the group. Sidesteps the pin/asm gate. (Alternative: teach `compiles_standalone` to compile pin/asm bodies WITH the pins.) A `rollout_whale_o0.py`-style tool (but for a mid-file `#include`, no yaml carve since these are -O2) would script it. **Then the giant endgame is fully banked.** Whale commits **commit:0463 (×1) + commit:0464 (×134)** — ready for Drew to push.
- **🐋 T7 WHALE ×134 ROLLOUT COMPLETE — clean fleet 136/136 (2026-07-07):** all 134 overlays now carry func_80144B9C as -O0 compiled C (was ×1 in ov_SC01_077) — the single biggest byte-weight lever, banked ×134 (~+1.6% byte-weight). Mechanism (`tools/rollout_whale_o0.py`): per single-file overlay, LINE-split `<ov>.c` at the whale (splat emits in vram order → no item-parse hazard), carve the yaml code subseg into before/`_o0b`(-O0)/`_after`, thin `<ov>_o0b.c` #includes the shared `src/shared/func_80144B9C.h` (the whale C moved there — DRY, TU-local typedefs, NOT a fragile 200-line DEFINE_ macro). One Makefile `WHALE_O0B_OBJS` wildcard -O0-compiles all `_o0b.o`. Registered dedup group **E_func_80144B9C** (134 members, h_exact 74186b97, source=the header — `group_members` keys on binary+vram, so a header-share validates like a macro-share). **CLEAN fleet check-all 136/136 (R22)**; dedup-check 1810→**1811/0**; FLEET REAL 225816→225949, byte-identical 65.91→**65.95%** function-count (the big gain is byte-weighted). Validated on ov_SC01_000 + spot-checks SC02/SC03/SC07 before the full fleet. Distilled: **cookbook §38** (struct-assign -O0 idiom + the -O0 reach-134 rollout + the memcpy asm-label) + SETUP inventory. **🐋 WHALE DONE.** Commit: (this).
- **🐋 T7 WHALE func_80144B9C CRACKED + banked ×1 (-O0), clean fleet 136/136 (2026-07-07):** the 770-ins reach-134 whale — the single biggest byte-weight lever (≈ next ~8 giants combined). **CRACK (cheap Opus, NO Fable5/calls.c — both retired):** the close=2 residual was a STRUCT ASSIGN `D_80078E50 = *ent;` (sizeof(ENT)==0x24), NOT an explicit memcpy() — gcc-2.7.2 -O0 expands a >MOVE_RATIO struct copy via emit_block_move→emit_library_call(memcpy): args go through copy_to_mode_reg (pseudos) then `addu $a0,$v1 ; addu $a1,$v0` = the exact 2 missing moves. **BANK INFRA (byte-neutral, reusable for ×134):** (1) 2nd per-file -O0 split — the whale is a 2nd -O0 region (prologue 21F0A003) in the -O2 "after" segment, carved into its own -O0 object `o0b` (splat.ov_SC01_077.yaml 3-way + Makefile CC1FLAGS=-O0; the file is splat-emitted in vram order → a LINE-based split at the whale preserves all banked C, no item-parsing/DEFINE_ hazard — `.run/t7b/split_whale.py`). (2) `memcpy=0x8005C324` in symbols.resident.txt (overlays+resident ONLY — main defines memcpy via MEMCPY.o, so a shared-symbol add would multiple-def) + `__asm__("memcpy")` on the engine_core.h block-copy macro (keeps the non-builtin C name to avoid gcc's built-in-memcpy codegen, emits the same 0x8005C324 call; benign "conflicting types for built-in memcpy" warning). splat REJECTS two symbols at one addr (tried func_8005C324+memcpy → error) → the asm-label is the fix. ov_SC01_077 == d19c9580; **CLEAN fleet check-all 136/136 (R22)**, dedup 1810/0. **W9 NEXT: script the ×134 -O0 rollout** (per-overlay o0b split via split_whale-style tool + a DEFINE_func_80144B9C() macro w/ TU-local typedefs — no engine_types.h collision; 133 single-file overlays, whale stubbed at file 0x1CA44 in each) → ~+1.6% byte-weight. Commit: (this).
- **T7 §G BATCH CLOSE ✅ (2026-07-07, committed; TRUE clean fleet 136/136) — 6/8 reach-134 giants cracked, 4 propagated ×134, fleet 65.75→65.91%:** MATCHED: `func_801571C4` (permuter, after the p16_permute comment-fix), `func_8014EA4C`/`func_801372B0`/`func_801770E0`/`func_80176D94`/`func_80148094` (Fable5, sequential idiom-banking chain). 2 WALLS (stay INCLUDE_ASM, G4): `func_80178004` (biv-init emit-order, close=7), `func_801412A8` (allocation placement-knot, close=29). **Propagated ×134:** 571C4/EA4C/76D94/48094 (134 overlays byte-identical; dedup **1810 groups / 0 failed**; genuinely-clean `make clean`+extract-all-136+check-all = **136/136**). **×1 (×134 follow-up — §A `dedup_propagate.compiles_standalone` gaps):** `func_801372B0` (asm-label-alias bank; blocked by local SVEC/GLINE typedefs — need unique-renamed lift — + register-asm pins), `func_801770E0` (anon-struct'd; blocked by register-asm pins). **NEW TOOLS:** `tools/p16_permute.py` comment-fix (a silent bug that had no-op'd the permuter on EVERY commented draft → immediately cracked 571C4) + `tools/permuter_ils.py` (warm-restart iterated-local-search). **KNOWLEDGE (durable):** cookbook **§37** + `docs/gcc-2.7.2-map/t7g-giant-harvest.md` (sibling-isomorphism law · `/s`-dep-lattice load+store dual · allocno ref-boost · coalescable-copy insn_count bump · RC-6-exemplar downgrade · "RTL dumps NOT stripped" · asm-label-alias/anon-struct banking). **REMAINING:** the WHALE `func_80144B9C` (close=2, DISCOVERED -O0 — needs a 2nd per-file -O0 split + gcc-2.7.2 `calls.c` + Fable5) + the 2 ×1 giants' ×134 (a pin/asm self-containment shim). Commit: (this).
- **T7 §G IN PROGRESS — parallel-attack session (2026-07-07, uncommitted; NOT yet clean-verified):** worked the ~9 reach-134 §G giants via 8 parallel Opus draft-agents (draft-only) + directed permuter + Fable5 chain; banking serial in main loop. **R14 re-measure overturned §G's stale closeness** (func_8014EA4C "~c6"→really 128; func_80178004 "close=0"→91; the REAL closest was func_801571C4 @11). **FLYWHEEL FIX:** found+fixed a silent permuter bug — `make_base_c` didn't strip draft header comments → `cpp` "unterminated comment" → decomp-permuter no-op'd `(0s)` on EVERY commented giant draft (`tools/p16_permute.py` `strip_c_comments`). Immediately cracked **func_801571C4 (SCHEDULE, 11→0 in 40s) → banked ×1** (`.run/t7b/matched/`; needed the byte-neutral `extern void`→`u32` caller reconcile at ov_SC01_077.c:4721; propagate ×134 at batch close). Built **`tools/permuter_ils.py`** (warm-restart iterated-local-search; 48094 72→38 where cold plateaus). **7 giants driven count-exact to precise single-class cc1-internal walls → FABLE5 BATCH (Drew authorized full, closest-first sequential + idiom-banking):** EA4C(6,frame-0x60-knife-edge) · 372B0(8,sched1 live-range) · 78004(37,const-hoist⊗regalloc) · 770E0(47,RC-6) · 76D94(52,S3 mutual-excl) · 48094(72,local-vs-global $a0; ILS→38) · 412A8(80,S3; ILS→45). **EA4C Fable5 RUNNING (1st).** 🐋 **WHALE func_80144B9C CLOSE=2 (768/770) — DISCOVERED -O0, not -O2** (prologue `21F0A003`; -O2 reads only 458/770) — a 2nd -O0 region @0x80144B9C stranded in the -O2 segment; needs a **2nd per-file -O0 split** (config) + **gcc-2.7.2 `calls.c`** (not in tools/reference, only 2.8.1) + Fable5 for the memcpy(=func_8005C324) -O0 arg-precompute. All drafts in `.run/t7b/{matched,close}/`; all levers + the -O0 idiom set + banking recipe in **`.run/t7b/LEVERS_HARVEST.md`** (→ cookbook at close). Fleet still 65.75% (571C4 ×1 negligible until ×134). NEXT: bank each Fable5 MATCH ×1 → one `dedup_propagate --auto-from --recover` at close → R22 clean-verify 136/136. **GEN2 RELEASE CANDIDATES (Drew 2026-07-07 → put in PhaseEnd):** (1) upstream an ILS/warm-restart mode to decomp-permuter (it appears to lack one); (2) release our gcc-2.7.2 codegen map §31/§36 + the "shipped cc1 RTL dumps are NOT stripped (`-dr -dj -dc -dl -dg`)" method — high value to any gcc-2.7.x decomp project; (3) the ILS *idea* (not the harness-coupled wrapper). Sequence at the Gen2 public flip. **FOCUS DIRECTIVE (Drew 2026-07-07):** pursue the largest-%-gain giants ONLY — NO small-function backlog sweeps (declined a ~52-candidate sweep); crack ALL giants incl. the WHALE func_80144B9C (the single biggest lever, ≈ next ~8 giants combined in byte-weight), THEN decide what's next.
- **T7 Fable5 batch COMPLETE — 3 giants cracked + banked ×134 (2026-07-04, `commit:0460`; clean fleet 136/136):** the 3 residual monsters (close=2/10/15) all → **MATCH** via sequential Fable5 (idiom-banking between): `func_801392FC` (cross-BB combine law + volatile-frame-parity), `func_8013A530` (the RC-6 "reload knot" was the pins → the **$0-add opaque copy** `iVar7=fc+zr` + 3 zero-byte levers; regalloc.md RC-12/13), `func_8013AF20` (the "impossible" const-hoist order was libgpu addPrim's 24-bit **bitfield store** → `store_fixed_bit_field` emits 0x00ffffff first; P_TAG lifted to engine_types.h byte-neutral). Banked via the §35 recipe; cookbook **§36** + loop.md + regalloc.md fed; gcc-2.7.2 reference tree extended (expmed.c/mips.md/…). **SESSION TOTAL: 7 giants ×134** (func_80129CF8 R14-free + func_8012D098/EC04 Opus-solo + func_80138ED0/801392FC/8013A530/8013AF20 Opus→Fable5); **fleet 65.48→65.75%**, 136/136, 0 NON_MATCHING. **NEXT SESSION: the ~9 remaining reach-134 giants per §G** (closest-first + the 770-ins whale func_80144B9C fast-tracked). Bank this session's §36 idioms are already in §31 → next-session Opus starts richer.
- **T7 (resumed, Drew's choice) — sibling-giant harvest via parallel Opus-Max agents (2026-07-03, IN PROGRESS):** launched 5 Opus agents (one per remaining region-a giant), each applying §32/§34, escalating to Fable5 only on stall. **KEY FINDING (answers the flywheel Q):** the "3 hardest 8-$s-reg giants" were MIS-RANKED — the 8-$s pressure is param/local/buffer-derived, NOT global-array hoists (only global-array-hoisting giants like func_80129CF8 are genuinely hard), so they **one-shot with Opus alone, no Fable5**. Banked ×134 so far: **func_8012D098** (189, one-shot Opus) + **func_8012EC04** (178, one-shot Opus = sibling func_8012EA90 + GTE tail). Fleet 65.56→**65.64%** (uncommitted, clean-verify running). 3 still iterating: func_8013AF20 (~60), func_8013A530 (~45), func_801392FC. **BANKING RECIPE (established; per-giant integration is mechanical, §30a):** matched draft → `fix_arity_callers --apply --any-proto` (no-proto the engine_core.h/overlay caller extern that conflicts with the matched def-sig — the DEF-side wall) → `sig_unify` (callee no-proto→full-proto) → **strip draft-local typedefs already in engine_types.h + anonymize named local typedefs** (else `conflicting types` in the shared TU) → `harvest_verify --chunk 1` ×1 → `dedup_propagate --recover` ×134. **NOTE: skip `cast_call_sites`** — it mis-casts a no-proto `void f()` to `void(*)(void)` (T6/cookbook fix candidate). **Two-pass verdict (Drew's Q):** Opus-first is right (structure cheap + flywheel; Fable5 only for genuine global-hoist/regalloc walls); parallel Opus is fine, sequence any Fable5 escalations with idiom-banking. **HARVEST COMPLETE (5 giants processed):** **4 banked ×134** (func_80129CF8, func_80138ED0 earlier; **func_8012D098 + func_8012EC04 this batch**, `commit:0457`, clean 136/136, fleet **65.64%**). **3 deferred to a Fable5 batch** — all Opus-driven to a single-class compiler-internal wall: `func_801392FC` **close=2** (count-load pipelining / combine-fold-vs-sched2), `func_8013A530` **close=10** (RC-6 reload-pressure, register-only, contained), `func_8013AF20` **close=15** (loop-invariant constant-hoist order). Residuals in `docs/backlog.md` + cookbook **§35** + `.run/t7/<fn>.c` headers. **RANKING LAW (retires "8-$s=hardest"):** difficulty = global-array-hoisting, NOT $s count (param/buffer giants one-shot Opus even at all-8-$s; only global-hoisters need Fable5). **BANKING RECIPE** (§35): fix_arity_callers --any-proto → sig_unify → strip engine_types.h-dup + anonymize local typedefs → harvest_verify → dedup_propagate; NOT cast_call_sites (mis-casts no-proto). **NEXT DECISION (Drew):** Fable5-batch the 3 residuals now (~1.3M tok, ~4.5h, each ×134) vs a fresh focused session vs permuter-first on the contained func_8013A530.
- **T7b/T5 — 2nd giant `func_80138ED0` MATCHED + banked ×134; the real un-reconciled-sibling proof + major new §31 idioms (2026-07-03):** Opus applying §32 → **close=21** (159/159 ins; semantics/control-flow/constants exact; found the transferable **giv-init fence** lever) → stalled on pure regalloc/sched. **Fable5Max reading the vanilla gcc-2.7.2 source → MATCH** (every class C-reachable, no permuter). Headline finds (→ cookbook §34, byte-verified + gdb-on-cc1): **gcc-2.7.2's 3-qty local-alloc SORT BUG** (`local-alloc.c:1441` — ≤3 qtys allocate in creation not density order; fixed via a zero-instruction **decoy qty**) + the **zero-byte asm allocation toolkit** (input-only / multi-input / def+use dummies = ref-count / lifetime / sort-path dials that emit nothing, byte-gate-certified). **Banked via the standard pipeline** (validates it on a real giant): `cast_call_sites` reconciled `func_8013914C` `(u8*,u16*)`→canonical `(s32,s32)`+call-site cast; **`reconcile_decls` a NO-OP** (the 2 data bases are giant-local → no fleet conflict — confirms the tool's no-op correctness / no false-positive); `harvest_verify` ×1 (`d19c9580`) → `dedup_propagate --recover` **×134** (134 byte-identical; pins/asm body propagates fine; `func_800599B8`'s lone `(s32,s32)` decl is in `ov_SC01_077.c`, a separate TU from the `_a.c` bank → no per-member conflict). gcc-2.7.2 reference tree **completed** (18 .c). Distilled: cookbook **§34** + SETUP §5.6. **Clean fleet verify running.** T5 satisfied: tool proven on 2 real giants (func_80129CF8 reconcile-path byte-proof + func_80138ED0 no-op + full-pipeline + 2nd giant ×134). **NEXT: T6 finalize** (fold §34 into the §31 map files) **+ PhaseEnd.** Commit: (pending verify).
- **T7b/T2+T3 — `tools/reconcile_decls.py` built + BYTE-PROVEN (2026-07-03, `commit:0453` tool + docs commit):** the DATA-symbol analog of `cast_call_sites` (§20). **Oracle** (T2): fleet-majority canonical-type picker — `engine_core.h`-macro type authoritative, else plurality across all overlays+resident (deterministic); reuses `gen_harvest_targets.collect_data_decls`; **8/8 correct** on func_80129CF8's symbols (`--print-canon`). **Transform** (T3): byte-neutral access-cast taxonomy — array `(Ed*)D_x`, struct-base `(Ed*)&D_x`, scalar-signedness `*(Td*)&D_x`, ptr-in-scalar `(*(P**)&D_x)`; ONE single-pass `re.sub` per symbol (a first draft double-wrapped the ptr-store — fixed). Wired into `gate_stage` after `cast_call_sites` (idempotent / no-op without a data conflict → can't regress the wave; byte-gate stays sole arbiter). **BYTE-PROOF (no Fable5):** full *loose* func_80129CF8 (intended decls, un-cast) → `reconcile_decls` (5 reconciled) → swapped into the `DEFINE_` macro → `make build BINARY=ov_SC01_077` = **`d19c9580` BYTE-IDENTICAL**; idempotent (0) on the canonical committed draft. **T4 resolved NO-OP** (T1: zero per-member conflicts — the fleet is decl-consistent). Distilled (R30): cookbook **§33** + §32 R14-correction, SETUP inventory row, design-doc **✅ RESOLVED** banner. **NEXT (T5, on Drew's Fable5 go):** match a sibling giant — `func_80138ED0` (closest, 2 data bases D_80127548/D_80127C0C) — with Fable5Max → `reconcile_decls` its raw draft → bank ×1 → `dedup_propagate --recover` ×134 (the real end-to-end proof + a 2nd giant ×134). Then T6 finalize + PhaseEnd.
- **T7b/T1 — R14: the "×134 wall" was a MISDIAGNOSIS; `func_80129CF8` banks ×134 FREE (2026-07-03, this commit):** Diagnosed the prior "×134 BLOCKED / all overlays excluded" claim by RUNNING it (R14/P9). Byte-verified: (a) the giant's ×1 bank extern block is already fleet-canonical (every symbol matches the overlay-majority; the lone `D_801151D4` `s32`-vs-`ptr` conflict is in `resident.c`, NOT an overlay member); (b) `dedup_propagate --addr 0x80129CF8 --check-only` → plan-eligible, **134 members**, passes `compiles_standalone`; (c) a representative member (`ov_SC01_000`) declares NONE of the giant's symbols locally (the macro's externs are the sole declarers); (d) controlled `--no-gate` instantiate + `make build BINARY=ov_SC01_000` = **BYTE-IDENTICAL** `9052dc0e`. Then full `dedup_propagate --addr 0x80129CF8 --recover` → **134 overlays byte-identical, group registered** (exit 0); clean `make clean && extract-all && check-all` → **136/136, 0 failed**, fleet **64.90→65.52%**, dedup **1799→1800/0**. ⇒ the "loose-typing wall" was a **stale-asm / incremental-tree artifact** (the exact T5c/T6-§A trap — a prior run before the reconcile committed, or a dirty asm/). **Consequence:** the reconcile tool is NOT needed to unlock func_80129CF8 (or any *already-reconciled* giant); its real value = **mechanize the manual decl-reconcile** for *freshly-matched* giant drafts (m2c `M2C_UNK` / Fable5 output with loose callee/data types) → canonical decl + byte-neutral access casts → bankable ×1 + propagatable ×134, hands-free. Beneficiaries: the **6 sibling giants** (all still stubs) + the wave tail. **Drew's choice B:** finish the tool + match a sibling giant as the real T5 validation target (Fable5Max on request). Plan `plan-…mossy-dawn.md` (T1–T6); next = T2 oracle + T3 `reconcile_decls.py`. Commit: (this).
- **T7 — giant `func_80129CF8` CRACKED (Fable5) + §32 idiom + banked ×1; ×134 WALL found → Drew chose to build the canonical-decl tool (2026-07-03, `commit:0450`):** Fable5Max cracked the 191-ins region-a camera giant (match_one MATCH) — struct-base hoisting via **source-local pointers** (gcc-2.7.2 has no cross-bb CSE → a callee-saved base can only come from a local, **NO pins**), branch-polarity-off-the-opcode, S12 reused-temp fence, `expand_block_move` struct-assignment, dead-local-aggregate frame → **cookbook §32** (transferable to the 6 sibling giants — `.run/t7/GIANTS_SURVEY.md`). Banked **×1** in `ov_SC01_077_a.c` (`d19c9580`, clean fleet 136/136) after reconciling its loose-typed decls (`u8[]`/`s32[]`/`struct BigCopy`/`s8`-vs-`u8`; `func_80012F74` `s16`-vs-`s32`) → canonical + **byte-neutral access casts**; `RView` (GsRVIEW2-shaped) → `engine_types.h`. **FINDING (byte-proven):** ×134 propagation is **BLOCKED by the fleet-wide loose-typing wall** — the giant's shared callees/data are declared incompatibly across overlays, so the macro's externs conflict per-overlay, and `dedup_propagate --recover` only fixes the propagated fn's CALLER extern (not its callee/data). Loose-typed giants bank ×1, NOT ×134 (the flagship `func_80132784` propagated only because its symbols were fleet-compatible). **DREW'S DECISION (A — invest over immediate ROI):** build the fleet-wide **canonical-decl reconcile tool** = the ×134 giant unlock. **Spec + conflict taxonomy + the proven byte-neutral cast patterns → `docs/canonical-decl-reconcile-design.md`.** Build it **Opus, plan-mode, Max — NOT Fable5** (it's tooling; the byte-gate arbitrates; reserve Fable5 for stalled giant MATCHES). Fable5's giant-crack is a *match* tier; this is a *plumbing* tier.
- **T6 §A — ×134 propagation-recovery COMPLETE (2026-07-03, `commit:0447`+`commit:0448`):** 🎯 **15 fns propagated ×134** this session (fleet 64.90→**65.48%**; two clean-fleet-verified commits). Fixed FOUR blockers, all whole-binary-byte-gate-validated: **(1) find_site indented defs** — the def regex `^[A-Za-z_]` was column-0-only, silently dropping every recover_integration-banked (indented) def from propagation; unit-tested (indented DEFS match, indented CALL-exprs don't). **(2) find_site trailing-comment externs** — the extern-collection `^\s*extern\b.*;\s*$` stopped at `extern u8 D_x[]; /* comment */`, dropping the earlier externs → THIS (not "pin/asm", R14) was func_8014E048's real self-containment blocker. **(3) dedup_propagate --recover** — on a straggler byte-gate fail: Part B no-protos that overlay's conflicting caller extern + re-gates (byte-neutral, = fix_arity_callers --any-proto); Part A excludes only that overlay (×N-1) vs the historical all-or-nothing drop; wired into gate_stage. **(4) build_engine_types comment-awareness** (`blank_comments`) — its OWN generated "…typedef lift" header comment was captured as a bogus `typedef vec`, self-colliding and blocking every --strip; NOTE full --strip still conflicts with the `_a/_o0` splits, so func_8014F74C's PosT/MoveT were lifted TARGETED (byte-neutral). **Banked:** the 13 leaf-MATCHes + func_8014E048 (T5b S11 crack) + func_80157580. **R14/R22 lesson (cost me a detour):** a stale-`asm/` tree (13 missing `.s`) confounded the FIRST --recover test into a false "byte-diverge everywhere incl. the source overlay" — a re-extract fixed it; the incremental per-overlay byte-gate is only valid on a freshly-extracted tree, so clean-verify (make clean && extract-all && check-all) EVERY batch. **Deferred tail (17 not-self-contained):** the 3 pre-existing --auto-from stragglers (0x80174650/8012A018/80165CA0 — pin/asm + uncaptured local `#define SHB`; moving SHB to a shared header would unblock func_80165CA0) + 14 local-type cases → T8 sweep. **T9 cookbook fodder:** the integration-recovery family (§A) + the stale-asm R22 corollary + the find_site extern-comment/indent classes.
- **T6 (tool built + gate-recovery proven; ×134 propagation-recovery deferred) (2026-07-03):** built **`tools/recover_integration.py`** (batch integration-recovery: gather leaf-MATCH candidates → no-proto their conflicting caller decls → gate_stage → 2-pass snapshot/restore so non-banks aren't corrupted) + **extended `tools/fix_arity_callers.py`** with `--binary` (scan the overlay's OWN inline callers, not just engine_core.h — the gap that left the "declaration/TU plumbing" class unrecovered). **Banked 13 leaf-MATCH fns** (func_8014F74C/801542A4/8015BE94/8015F380/80160F00/801653B8/80166244/8016E778/801732C4/8017331C/80173374/80174554/801745AC), **clean-verified together** (ov_SC01_077 `d19c9580`). **R14 lesson (clean-verify caught it):** the first batch's `fix_arity_callers --revert` was LOSSY for `--any-proto` (`()`→`(void)`, not back to the original args) → corrupted non-banks ("too many arguments"); fixed with the 2-pass snapshot. **×134 propagation of the 13 is BLOCKED (3 diagnosed sub-blockers → remaining T6 work):** (1) `dedup_propagate` `find_site` misses **indented** inline defs (7/13 "not inline-def" — Phase-15 class); (2) 1/13 uses overlay-local types (type-lift); (3) the 5 plannable all drop on the **ov_SC01_000 straggler** (conflicting caller externs, same class as the flagship's ov_SC02_005 — needs the auto-reconcile Part B). So the 13 are banked **×1** pending those fixes. Flagship `func_80132784` (`commit:0443`) remains the one ×134 T6 win.
- **T6 (partial) ✓ (2026-07-03):** 🎯 **FLAGSHIP `func_80132784` PROPAGATED ×134** (`commit:0443`) — the 400-ins S11 giant (cracked T4, banked ×1) now byte-identical in ALL 134 overlays, **+1.6% byte-weighted** (the single biggest lever; function-count fleet 64.86→64.90%). **The T6 recovery pattern, proven end-to-end:** the T4-deferred ×1 cap was one straggler overlay (ov_SC02_005) declaring a CONFLICTING caller extern `void func_80132784(s32,s32,s32)` vs the def `(s32,s32,u32)` → `conflicting types` → dedup_propagate's all-or-nothing single-`--addr` plan dropped the whole fn. Fix: reconcile the straggler's caller extern to the def's canonical sig (s32→u32, byte-neutral — the call site casts anyway), then propagate → 134 overlays rebuilt byte-identical, group `E_func_80132784` registered, dedup-check 1784/0. **Clean R22 fleet check-all 136/136.** **REMAINING T6 (the tool):** automate this — detect a straggler's conflicting caller decl → reconcile to the def's canonical sig → re-gate → propagate full (vs. all-or-nothing drop); + the other ×1 classes (func_8014E048 pin/asm self-containment — a DIFFERENT blocker: dedup_propagate's `compiles_standalone` rejects pin/asm bodies; func_80144090 OtBlk type-lift; func_8014F4C0/func_80155800 TU-context leaf-MATCHes in `.run/wave/`).
- **T5c ✓ (2026-07-03):** 🟢 **TRUE clean fleet 136/136 RESTORED** (first genuinely-clean `make clean`+full-re-extract+check-all green since Phase 21). Fixed the pre-existing Phase-21 (`commit:0292`) rename-propagation breakage: renamed all **62** stale `INCLUDE_ASM(func_<ADDR>)` → curated names across 12 main/library `src/*.c` (800c.c/800c3.c×22/apicard1·2·4/boot.c/libcd1×8/libetc×6/libgpu×3/sgap.c/snd1×7/snd2.c) to match splat's canonical output (proven: splat's fresh stub-regen uses the curated names). **main clean-builds `143dbb89` ✓; fleet 136/136 ✓** (all overlays byte-identical, resident `8e17e02f`). Built **`tools/lint_symbol_refs.py`** (comment/string-aware, func_+D_) — flags any `func_/D_<ADDR>` ref whose addr was renamed (the R22-masked class); caught the T5b macro-call + this INCLUDE_ASM set; now 0 stale. SETUP inventory + CURRENT_PHASE finding updated. Commit: (checkpoint).
- **T5b ✓ (2026-07-03):** 🎯 **S11 CRACKED — the class verdict was map-incompleteness, not intrinsic codegen** (Fable5 main-loop spike, Drew switched the session to Fable5 Max). `func_8014E048` (143 ins, reach-134; "S11 LUID⊗alloc intrinsic / not source-steerable" since the map wave; **28-off even after T5's directed permuter**) → **MATCH (143/143) + whole-binary BANKED** (`harvest_verify` 1/0, ov_SC01_077 `d19c9580…`). Derived by reading gcc-2.7.2 source + `-dl -dg -dS` RTL dumps (12 experiments, `.run/gccmap/exp/e1a..e1k.c`): **S12 reused-s32-temp fence** (output/anti deps forbid load batching; **u16 temps DON'T work** — unpromoted HI vars spawn per-use zext temps that combine folds away), **S13 head-skip escape** (body-local param copies keep hard arg regs live into the temp windows → conflict-steer the scratch contest; zero-byte volatile-asm dead-read as a wedge-slot fence; multi-input dead-read to rebalance K2 densities), **cse-opaque asm-copy** (`addu %0,%1,$zero`) for must-materialize pointer copies, **RC-4b pinned store-temp**, **RC-10 preference-cascade mechanics** (set_preference one-level expression unwrap; expand_preferences dying-into-set merge; find_reg pass-0 used-so-far/someone-prefers + pref override). Integration needed 2 hand-reconciles (both T6 classes): engine_core.h:17569 caller-decl `s16*`→`u16*` (ptr param type codegen-neutral) + canonical data decls with `*(u16*)` access casts (D_801152A8 `u8[]` / D_801152AC `s16`). **×134 lift blocked by dedup_propagate self-containment (pins/asm) → T6 target** (joins func_80132784). Distilled (R30): sched.md **§6/S12/S13** + regalloc.md **§F/RC-10** + cookbook §31 triage-table **S11 downgrade**. Backlog re-logged (capped). R22 clean fleet check-all running at close. Commit: (checkpoint).
- **T5 ✓ (2026-07-03):** **§31-directed permuter mutation + grinder input-changed gating — built, validated, distilled.** NEW `tools/permuter_weights.py`: `classify(klass,where)` → `regalloc|schedule|cse|None` + `render_settings_toml` emitting the `[weight_overrides]` table decomp-permuter merges over the gcc defaults (`main.py:336` / `helpers.py:merge` — per-key REPLACE; **no submodule edit**, R3/R20). Biases pass-selection toward each class's §31 levers (`perm_reorder_decls` RC-1/3 · `perm_reorder_stmts` RC-2/S1 · `perm_temp_for_expr` S2 · `perm_commutative` cse) and pushes the value/type noise to ~0.1. Wired into `p16_permute.setup(…, klass=, where=)` (+`--klass`, backlog auto-lookup) and `grinder.py` (auto-threads `klass`/`where_stuck`; `klass=None` → gcc defaults = the pre-T5 undirected search, a safe superset). **Grinder fix (R14):** replaced the blind `tried.clear()` idle churn with **input-changed gating** (`draft_sig`=(best_draft mtime, closeness) — re-open a fn only when the worker improved it; the permuter is deterministic given base.c+target.o). **VALIDATED:** the regalloc profile drove `func_8014E048` base masked-36 → **29** (match_one `-drz` **35→28**) where the undirected search stalled — real directed progress; re-logged (closeness 28, improved draft promoted). The 4 flagship count-exact seeds are the project's WORST-CASE intrinsic S11/RC-6 walls ("C-space discontinuous" §31 RC-6) — directed mutation improves but doesn't gate them → T5b/backlog fuel (§31 "two probes, don't grind"). Distilled: cookbook **§3b** + SETUP inventory (R16/R30). **No build-input changed → 136/136 fleet invariant untouched (tools/docs only).** Commit: (checkpoint).
- **T4 ✓ (2026-07-02):** 🎯 **FLAGSHIP BANKED** — `func_80132784` (400 ins, "HARD-DEFER/irreducible" for 22 phases) matched whole-binary + committed (`commit:0438`); `make check BINARY=ov_SC01_077` BYTE-IDENTICAL, dedup-check 1783/0. The permuter overhaul (T2+T3) is validated end-to-end by a real bank. **Banked ×1** — the ×134 propagation is capped by per-overlay declaration plumbing (`ov_SC02_005` cross-overlay straggler + an `extern`/type mismatch), NOT codegen → **T6 target** (the +1.6% byte-weight lands when T6's integration-recovery reconciles it). Hand-fix that unblocked the ×1: dropped the draft's redundant `Blk16` typedef (already in engine_types.h:442) — T6 automates this. **Count-exact seeds** (func_8014E048 35 / func_80176D94 52 / func_80148094 72 / func_801412A8 110): permuter setup works (parse/compile/search clean, 0 internal failures), but random mutation didn't close them (func_80148094 only 77→74 in T2) — they're intrinsic residuals (RC-6/S11) → **T5 directed mutation + T5b Fable5**. Fleet 64.86% (×1 negligible). Commit: (checkpoint).
- **T3 ✓ (2026-07-02):** permuter setup fixes (all in `tools/`, no submodule edit): `p16_permute.hide_asm` — a b64-pragma carrier for register pins AND GTE `__asm__` blocks (pycparser parses the pragma; decomp-permuter's own `process_pragmas` decodes it back so cc1 sees the real asm); custom-typedef/`#define` preservation (drop only `#include`); `f32` typedef gap fixed; `compile_o0.sh` `-O0` variant auto-selected for `_o0` targets; `run_masked.py` pin-var fallback (`expr_type`→`int` on an unknown/hidden-pin id → 0 "internal permuter failures", was >0). ROOT CAUSE of the GTE fail: `compile.sh` now prepends `.include "macro.inc"` so `mvmva` assembles (the real build gets it via `include_asm.h`, which base.c omits + `-DPERMUTER` disables) — byte-neutral for non-GTE (count-exact scores unchanged). ALL 5 seeds parse+compile (base 4/110/36/52/77). 🎯 **The flagship func_80132784 (4/400) CLOSED** to a masked-0 that `match_one` independently confirms **MATCH (400 ins)** — winner preserved `.run/wave/func_80132784.win.c` for the T4 whole-binary gate → ×134 (≈ +1.6% byte-weight). No build-input changed. Commit: (checkpoint).
- **T2 ✓ (2026-07-02):** built the floor-free relocation-masked scorer, ENTIRELY in the `tools/` layer (no decomp-permuter submodule edit): `tools/masked_diff.py` (shared `objdump -drz` oracle + masking), refactored `tools/match_one.py` to use it (`-dr`→`-drz`), `tools/masked_scorer.py` (`MaskedScorer` drop-in), `tools/permuter/run_masked.py` (rebinds `src.main.Scorer`), wired `p16_permute.run_permuter`. VALIDATED: `masked_self=0`; `masked_cand≈match_one` (77~72/36~35/52=52); **STOCK floor 1750–2100 vs masked 36–77** (the wander cause, removed); live permuter base score = masked 77 (not stock 1930), descends to 74. `-drz` also fixed match_one's GTE under-count (regression-clean on count-exact seeds; func_80132784 now true 400 ins / 4-off). match_one output format unchanged → gate_stage/grinder compatible. No build-input changed. Commit: (checkpoint). T3 next handles the 2 compile FAILs surfaced (func_80132784 GTE `mvmva`/common.h; func_801412A8 custom-typedef drop).
- **T1 ✓ (2026-07-02):** re-logged 7 map-wave seeds with BYTE-VERIFIED closeness (dropped 19 stale/unreproducible records from `.run/backlog.jsonl`, `.bak` kept; best_draft → `.run/backlog_drafts/`). Ground truth (match_one `-dr`): func_8014E048=**35** (was mis-logged `failed`), func_80176D94=**52**, func_80148094=**72** (best draft = `vG2.c`, NOT the named file), func_801412A8=**110**; T6 leaf-MATCHes func_8014F4C0/func_80155800=**0**. func_80144090 excluded (banked ×1, not a stub → T6 `OtBlk` type-lift). Fixed gate_stage sig_unify/`--src-file` doc-drift. `wave_targets --class REGALLOC` + grinder now surface all 4 count-exact permuter seeds with true closeness; func_80132784 correctly kept out of blind selection. No build-input changed → 136/136 invariant untouched. Commit: (checkpoint).

---

# 🔜 CONTINUATION FOR THE FRESH SESSION (2026-07-03 checkpoint)

**State (updated 2026-07-03):** all work committed (`…`→`commit:0448`); tree clean (only `db.*.gbf` R23 noise). Fleet 136/136 byte-identical from a genuinely-clean tree, **65.48%** count / ~31.7% byte-weighted, 1799 dedup groups. **§A propagation-recovery is COMPLETE** (15 fns ×134 — see the progress-log T6 §A entry; §A below is kept as the resolved-blocker record). **RESUME AT T7** — region-a giants *(xHigh; Drew: PING to switch effort before starting)*, OR the T8 tail-sweep *(breadth → prompt for ultracode, R26)*. Effort stays **Opus Max** until the T7/T8 toggle.

## §A — T6 propagation-recovery ✅ RESOLVED (2026-07-03, `commit:0447`+`commit:0448`)
> DONE: all 3 blockers fixed + a 4th (trailing-comment externs). 15 fns propagated ×134 (the 13 + func_8014E048 + func_80157580); clean fleet 136/136; fleet 65.48%. The blocker-by-blocker plan below is kept as the record of how it was done. Remaining tail (17 not-self-contained) deferred to T8.

**Goal (achieved):** take the leaf-MATCH-but-×1 banks to ×134. The **tool** (`recover_integration.py`) already banks the "declaration/TU plumbing" class ×1; what's missing is getting those ×1 banks (and the flagship-class ×1s) propagated ×134.

**Reproduce the 13 gate-recovered ×1 banks (clean-verified this session):**
```
.venv/bin/python tools/recover_integration.py --funcs func_8014F74C,func_801542A4,func_8015BE94,func_8015F380,func_80160F00,func_801653B8,func_80166244,func_8016E778,func_801732C4,func_8017331C,func_80173374,func_80174554,func_801745AC --no-propagate
# -> banks all 13 ×1 in ov_SC01_077; CLEAN-verify: make clean && make extract BINARY=ov_SC01_077 && make build BINARY=ov_SC01_077 == d19c9580
```
(Reverted at checkpoint — they re-bank via the tool. Better to fix propagation FIRST, then bank+propagate so they land ×134 directly.)

**The 3 propagation blockers (each a concrete fix; the whole-binary byte-gate is the arbiter throughout):**
1. **`dedup_propagate.find_site` misses INDENTED inline defs** (blocked 7/13 → "not inline-def"). The banked defs are indented (`    void func_801542A4(s32 *a0, s32 a1) {` at ov_SC01_077.c:4601). `find_site` (tools/dedup_propagate.py ~line 440, `apply_plan`) + its `INLINE_DEF_RE` detect column-0 defs only. **Fix:** allow leading whitespace in the inline-def detection (same Phase-15 `find_site` brace-placement class — a green byte-gate masks under-propagation; verify via `make report` fleet %, not just the gate). Cross-check with `tools/gen_harvest_targets.py:INLINE_DEF_RE` (Phase-19 fixed a similar column-0 issue there).
2. **Overlay-local type lift** (blocked 1/13 → "not self-contained (local types)"). One fn's body uses a type not in `engine_types.h`. **Fix:** `tools/build_engine_types.py --strip` (§28b type-lift), then re-propagate.
3. **Straggler caller-extern reconcile** (blocked the 5 plannable + the flagship + others). A member overlay (e.g. `ov_SC01_000`) declares a CONFLICTING caller extern for the fn vs the def sig → `conflicting types` → `dedup_propagate`'s all-or-nothing drops it. **THE PROVEN FIX (flagship func_80132784 / ov_SC02_005, byte-neutral):** rewrite the straggler overlay's `extern <ret> func_X(...)` to the def's canonical sig (width-compatible: `s32↔u32`, `s16↔u16`, ptr types — the call site casts or passes wide args, so codegen is identical), then re-propagate → ×134. Example done by hand: `sed -i 's/extern void func_80132784(s32 a0, s32 a1, s32 a2);/…u32 a2);/' src/ov_SC02_005/ov_SC02_005.c`. **AUTOMATE as `dedup_propagate --recover`:** on a straggler drop, (Part B) reconcile its conflicting caller extern to the def sig → re-gate → keep in members (×N); (Part A fallback) if irreconcilable, EXCLUDE the straggler from the fn's members and propagate to the clean N-1 (×N-1, keep straggler ×1) rather than the current "single-fn plan → all-candidates-dropped → error" (dedup_propagate.py lines 478-511). **NEVER change the matched def; only the caller's extern.**

**Also `func_8014E048` ×134 (T5b bank, DIFFERENT blocker, lower priority — 1 fn):** `dedup_propagate.compiles_standalone` (tools/dedup_propagate.py:246) REJECTS pin/asm bodies (`register __asm__`/asm-carrier) → the fn never enters the plan. Needs a self-containment shim (compile with the pins) or an alternate propagation path for pin/asm defs. `func_8014E048` is banked ×1 in ov_SC01_077.c (S12/S13 levers, §31 sched.md §6).

**T6 done-criterion:** the 13 (+ flagship-class ×1s) propagate ×134, clean fleet 136/136, dedup-check 0-failed, fleet-% up. Then `dedup_propagate --recover` (or the recover_integration `--auto` path with propagation) can sweep the broader capped tail.

## §B — Tools + knowledge built this session (for T8/T9 reuse)
- **`tools/permuter_weights.py`** (T5): §31-directed decomp-permuter weights (`classify(klass,where)→regalloc|schedule|cse` → settings.toml `[weight_overrides]`). Auto-threaded by `p16_permute.setup`/`grinder`. No submodule edit.
- **`tools/lint_symbol_refs.py`** (T5c): flags stale `func_/D_<ADDR>` refs after a symbols rename (comment/string-aware). **Run after ANY symbols.us.txt rename**; T9 candidate to wire into `make report`.
- **`tools/recover_integration.py`** (T6): batch integration-recovery (`--auto`/`--funcs`/`--from-file`; 2-pass snapshot/restore). Banks the caller-decl-conflict class.
- **`tools/fix_arity_callers.py`** — EXTENDED with `--binary` (scans the overlay's own inline callers, not just engine_core.h — the T6 gap) + `--any-proto`. NOTE: `--revert` is LOSSY for `--any-proto` (→ use snapshot/restore, as recover_integration now does).
- **§31 map extension (T5b, byte-proven):** `docs/gcc-2.7.2-map/sched.md §6` (S12 reused-s32-temp fence, S13 head-skip escape + case-study ledger `.run/gccmap/exp/e1a..e1k.c`), `regalloc.md §F` (RC-10 preference cascade + RC-6/S11 verdict DOWNGRADE), cookbook §31 triage table updated. **S11 is now steerable** — audit pins + try S12/S13 before any "S11 intrinsic" verdict.
- **§31-directed permuter (T5):** `tools/p16_permute.py --funcs <fn> --from-drafts .run/backlog_drafts --secs N --j 14` (auto-directed by backlog class). The 4 flagship count-exact seeds (func_8014E048 28 / func_80176D94 52 / func_80148094 72 / func_801412A8 110) are RC-6/S11 walls — permuter improves but doesn't gate; T5b cracked func_8014E048 by hand instead.

## §C — T7: unblock the 8 compile-blocked region-a giants (xHigh; PING Drew first)
The 8 (all reach-134, "won't compile standalone (loose-typing / missing decl)"): **`func_80129CF8`(191) `func_8012D098`(189) `func_8012EC04`(178) `func_8013339C`(160) `func_80138ED0`(159) `func_801392FC`(182) `func_8013A530`(204) `func_8013AF20`(185)**. Per the Phase-23 finding they are **mechanically** unblocked (ghidra-type aliases + data externs — NOT struct-walled). A cheap pass (add the missing type aliases/data externs so they compile standalone) makes them draftable → then §31 + Opus + the T6 recovery + permuter. Their Ghidra-C is in `.run/ghidra_c/` (or regen via `DecompileFunctions.java`, R23/R29 `/mcp`).

## §D — T8: scale the §31 wave (breadth → prompt for /effort toggle, R27)
With the permuter (T5), integration-recovery (T6), and the §31 map (incl. S12/S13/RC-10), run §31-powered Opus-agent waves over the near-miss backlog. Real canon class counts: `SCHEDULE≈30 / REGALLOC≈84 / REMAT≈3`, steerable near-misses scattered in `OTHER`/`None` (text-scan `where_stuck`). Each match ×134. Batch ~8, triage-first (bail confirmed-intrinsic to permuter). **The ~26 remaining capped candidates** (leaf-MATCH-but-gate-rejected beyond the 13 T6-recovered) are `recover_integration --auto` fodder — the harder multi-arity-caller loose-typing walls need per-fn diagnosis. Breadth-shaped → prompt Drew for `/effort ultracode` (R26/R27).

## §E — T9: distill + PhaseEnd (Tier-1, Max)
Distill into the cookbook: the **T6 integration-recovery** (caller-decl no-proto reconcile + the straggler-reconcile + the 2-pass snapshot) + the **incremental-masking lesson** (R22/R14 caught 2 traps this session: the Phase-21 fleet bug AND the tool's lossy-revert — clean-verify EVERY batch) + `lint_symbol_refs.py` + the **Phase-21 rename-propagation post-mortem** (§Blockers). Verify every checkbox (P7), clean fleet 136/136, write `PhaseEnd_Phase24.md`, archive this file → `phase-ends/logs/Phase24.md` (R19).

## §F — discipline reminders (do NOT regress)
- **R22/R14 — clean-verify EVERY batch before committing** (`make clean && extract-all && check-all` → 136/136). Incremental masks (proven twice this session). The `harvest_verify`/`dedup_propagate` per-binary gate is incremental — a full clean fleet check-all is the real proof.
- **Straggler/caller reconcile is byte-neutral ONLY on the caller's extern** (width-compatible types; the call site casts/passes-wide). NEVER touch the matched def.
- **R23:** never stage `db.*.gbf`. **T6 commits:** never stage `symbols.us.txt` (unrelated).
- **Commit hygiene:** the tool commits keep source/tool/docs; `git checkout src/ docs/` to revert scratch banks (keeps `tools/`+`phase-ends/`).

---

## T6 targets (the specific ×1 banks awaiting §A propagation-recovery)
- **`func_80132784`** (flagship, 400 ins) — **ALREADY ×134** (`commit:0443`, via the ov_SC02_005 straggler reconcile — the template for §A.3).
- **The 13 T6 gate-recovered fns** (§A) — banked ×1, awaiting the 3-blocker fix.
- **`func_8014E048`** (T5b, S11 crack) — ×1, pin/asm self-containment blocker (§A).
- Carried from Phase-23 backlog: `func_8014F4C0` (fwd-decl reconcile + Vec4u lift), `func_80155800` (TU-context), `func_80144090` (OtBlk type-lift). Test cases in `.run/wave/`.

## Blockers / open findings
- **✅ RESOLVED (T5b+T5c, 2026-07-03) — Phase-21 latent breakage: a truly-clean rebuild had been broken since Phase-21 close (`commit:0292`), masked by incremental builds. FOUND during T5b's R22 fleet verify; fully fixed, true clean 136/136 restored, `lint_symbol_refs.py` guard added.** (Kept here as the post-mortem for T9's PhaseEnd + cookbook distillation.)
  - **Symptom:** `make clean` + full re-extract + `make check-all` → main FAILS to build (`can't open asm/nonmatchings/800c3/func_8005CE18.s` … dozens); overlays failed 134× on `undefined reference to func_80058B40`. Only `main`'s failure remains after the overlay fix (135/136).
  - **Root cause:** Phase-21 xdedup (`commit:0292`, "+62 PsyQ names") renamed 62 PsyQ library functions to their proper names (InitHeap, FlushCache, GetTPage, SysEnqIntRP, SpuWrite, _SpuInit, CdMix, __main …) in `symbols.us.txt`, but did NOT propagate the rename to the committed source that references them by the OLD `func_<ADDR>` name: **(a) 1 shared macro CALL** in `engine_core.h` (`func_80058B40`, overlay-side) and **(b) 62 `INCLUDE_ASM(func_<ADDR>)` stub lines across 12 main/library `src/*.c`** (800c.c, 800c3.c×22, apicard1/2/4, boot.c, libcd1.c×8, libetc.c×6, libgpu.c×3, sgap.c, snd1.c×7, snd2.c). Splat now names/handles those addresses by the curated name (linked-not-stubbed via psyq_integrate, or emitted as `<curated>.s`), so the stale `func_<ADDR>` refs dangle. **Incremental builds reused stale pre-rename `.s`/`.o` and masked it** → every "check-all 136/136 / main 143dbb89" in Phases 21/22/23 was incrementally-stale, NEVER a genuinely-clean tree (the exact R22 failure mode).
  - **FIXED so far (overlay-side, byte-neutral, verified):** the 1 shared-macro call `func_80058B40` → `GetTPage` in engine_core.h (same addr 0x80058b40 → identical `jal`); took the fleet **135→ (134 overlays now pass)**; `ov_SC07_009` byte-identical `2a6499b6`. Static scan of engine_core.h+engine_types.h (func_ AND D_): this was the ONLY shared-header collision.
  - **FIXED (main/library-side, 62 refs — T5c, Drew: rename to curated names):** the root mechanism, byte-proven: **splat's FRESH regeneration of a stub `.c` uses the CURATED names** (move `src/800c3.c` aside → splat writes `INCLUDE_ASM(InitHeap)` + emits `InitHeap.s`); the committed `src/*.c` were simply STALE (`func_<ADDR>`) — Phase-21 renamed the symbols but never regenerated/renamed the committed stub refs. Fix = rename the 62 `INCLUDE_ASM(func_<ADDR>)` → the curated name (InitHeap, FlushCache, GetTPage, SysEnqIntRP, SpuWrite, CdMix, __main …) across the 12 files (800c.c 1, 800c3.c 22, apicard1/2/4 4/6/2, boot.c 1, libcd1.c 8, libetc.c 6, libgpu.c 3, sgap.c 1, snd1.c 7, snd2.c 1). **main clean-builds `143dbb89` ✓**; full clean fleet check-all confirming 136/136. (NOT hex-case, NOT a proto-dup — only symbols.us.txt is stacked.)
  - **Lesson (→ cookbook, T9):** a `symbols.us.txt` rename MUST be propagated to (a) shared-macro bodies AND (b) `INCLUDE_ASM` stub refs, AND verified by a genuinely-clean (`make clean` + full re-extract) check-all, never incremental. Add a lint: every `func_<ADDR>` referenced in committed `src/` must have a matching emitted `.s` OR a defined symbol. Also: T5b's interim harvest_verify on func_8014E048 passed on a stale `_a.o` → re-verified clean (ov_SC01_077 was among the 135 that pass).
- **RESOLVED in T2 (R14 self-correction):** the T1 finding that "func_80132784 is 204-off / not 4/400" was itself the `-dr` artifact. Once `match_one` uses `-drz` (T2), func_80132784 reads its **true 400 ins and is 4/400 count-exact** — the Phase-23 "4 instructions away" premise is CONFIRMED. Backlog re-logged closeness 4 (source T2-drz). The residual is a **prologue save/init order swap (S7/S11) — a pure register/schedule swap, prime permuter/pin + T4 target.** The realistic count-exact near-permuter seeds are: **func_80132784 (4)**, func_8014E048 (35), func_80176D94 (52), func_80148094/vG2 (72), func_801412A8 (110). S11 blocks func_801412A8 + (partly) func_80132784 → T5b Fable5 spike still well-motivated. Lesson: the `-drz` fix (T2) is load-bearing for measurement honesty, not just the permuter's gradient.