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

# CURRENT_PHASE — Phase 21: The Automation Manager

**Generation:** Gen2 (13th phase) · **Status:** APPROVED plan, in progress · **Effort:** Max (whole phase)
**Plan file:** `/home/musashi/.claude/plans/max-effort-plan-mode-breezy-zebra.md`
**Started:** 2026-06-21 · **Fleet at start:** 58.82% byte-identical (136/136 binaries byte-identical, 0 NON_MATCHING)

> Phase Start gate PASSED (Drew approved the plan). This file is the per-task crash-recovery log (P3/CURRENT_PHASE).
> Open-ended phase; milestone = **build → validate → stage, then close** (Drew's choice — the multi-day run is a later go).

---

## ★★★ SESSION 2026-06-25 (cont. 8) — fresh session: reach-1 waves (+16 ×1) + distill idiom + 3-source SOTA parity research → GIANTS pivot

> Fresh session ran the cont.7e reach-1 idiom loop. All byte-gated (G3/P9); grinder token-free alongside (banked 0 — hard tail).

**Fleet 63.18%** (217,332/344,010, +0.01% this session — reach-1 is ×1, % negligible BY DESIGN; value = ov_SC01_077 completeness + idiom-mining) · 136/136 byte-identical · 0 NON_MATCHING.

**★ ARC:** reach-1 wave-1 (69-86 ins) **+10 ×1** (`commit:0289`) · distill **+1 idiom** (chained-store-fanout `*a=*b=*c=v;` from func_80143D28, `commit:0290`) · wave-2 (76-101) **+6 ×1** (`commit:0291`). Self-MATCH→bank gap stark (21→10, 21→6 — the whole-binary gate is the honest arbiter; the rest = loose-typing/regalloc walls). **Yield 42%→25%→falling as the band climbs** (EASY reach-1 fuel consumed; remaining reach-1 is medium-large).

**★ GIANTS PIVOT (Drew's gate-2 AskUserQuestion):** reach-1's cheap vein thinned → pivot waves to the reach-134 GIANTS as **backlog-fuel** (NOT for %): workers get them structurally close + log ranked near-misses for hand-finish (the Phase-21 backlog's purpose). 14 stubbed giants cached; **6 fresh tractable (167-254 ins) batched first** (func_80163C2C/801571C4/80148094/80156B74/8014EE14/8015126C); the 770-ins monster func_80144B9C deferred to a deep session. **CAVEAT (cont.7d, unfixed):** gate_stage's canon/cast/sig_unify can REGRESS giant near-miss closeness → log the WORKER's self-reported closeness (true source) + raw draft to the backlog, not the post-transform value.

**★ SOTA PARITY RESEARCH (3 independent project-blind passes — 2 fresh-Opus chats + a research subagent):** unanimous — **our architecture IS the 2025-26 SOTA** (proposer + exact-verifier loop = Mizuchi/magic-decomp; permuter = the "amazing" evolutionary brute force; we're AHEAD on whole-binary SHA gate, ×134 propagation, idiom flywheel). **No GPU/neural/diffusion shortcut to byte-matching a 1997 compiler exists** (matching = discrete search vs an exact CPU oracle; GPU only smartens proposals, can't run cc1; all neural decompilers target functional-equiv, not bytes). The wall (scheduler/regalloc + loose-typing) is **field-wide**; needs a human brain — validates the giants-as-hand-finish pivot.

**★ PARKED R&D (Drew: "log these") — none on the critical path:**
1. **objdiff-cli `report --format json`** → decomp.dev-comparable **byte-weighted** progress metric (honest ~30% vs our function-weighted 63%); closes the Phase-19 gap. Adopt at/near the public flip. Headless, PS1-supported.
2. **gcc-2.7.2 RTL / `-fsched-verbose` dumps fed to drafters** as context for the scheduler/regalloc wall — the ONLY lever aimed at the actual wall, but speculative (no off-the-shelf tool; the "instrumented PsyQ gcc" lead was a TODO on a 2.8.1 build). Bounded experiment someday (R17/X2).
3. **Neural surrogate of cc1-psx / RL-matcher (compiler-as-reward, GRPO)** — genuinely-novel research moonshot, NOT the path: cc1 is discrete/nonlinear, C isn't gradient-descendable, still can't beat the loose-typing wall; the agentic loop already captures most of the benefit untrained. A research PROJECT (Drew has CUDA/LightGBM), not a workflow.
4. **[FUTURE WORK — Drew, 2026-06-26] Open-source `xsig` (the cross-project shared-code finder).** Genericize the `.run/xdedup/` tool + release standalone (MIT) on Drew's GitHub — the one genuinely-novel standalone tool we built. Scope (a ~1 focused day): consume project ARTIFACTS (splat `.s` or compiled `.o`), NOT source+compiler; one CLI with `sign`/`cross`/`verify` verbs (replacing the 6 ad-hoc drivers); keep the general core (`mask_word`/`signature`/`parse_objdump_dr`) + the 4 self-tests; DROP the BFM-coupled `sign_bfm`/`cross` hardcoded paths, the per-sister `compile_sister_*.py`, and `analyze.py`; README must document the masked-field-idiom false-positive caveat (struct-copy/memcpy collide on a masked data-addr; surface `nins`/`n_loc` confidence + the `verify` re-check). v1 = MIPS-only. ROM-safe (operates on disasm/relocations). Suggested name `mips-xref` / `decomp-xsig`. Idea also bankable: contribute the cookbook idioms + the distillation-flywheel pattern to the gcc-2.7.2 community at the public flip.

**★ PROCESS LESSON (banked):** with the Bash tool's `run_in_background`, do NOT also `nohup … &` inside — it detaches from tracking and fires a PREMATURE completion notification (the real process keeps running, stdout block-buffered). Run the command directly under `run_in_background` (+ `dangerouslyDisableSandbox` for make/git).

**★ DOC FIX (R21):** the Xenogears scout surfaced a stale `docs/SETUP.md §5.3` marker — line 363 still flagged the `-G` flag "TBD — not yet read" despite the resolution on line 365 (✅ Phase 5: -G0, header gp_value=0, zero $gp/%gp_rel in the disasm; Makefile builds -G0, byte-confirmed). Corrected the inline marker → "RESOLVED Phase 5 … -G0" so a TBD-grep no longer reads it as an open gap. (Ledger #8 line 736 was already correct.) Related soft spot left as-is: §5.4 line 379 "swap to -G8 if §5.3 says so" is a now-dead conditional (§5.3 says -G0) — technically correct, optional to tighten.

**★ COLLABORATION SWEEP — CLOSED with clean verdicts (5 scouts/probes; the "can external resources shortcut our gcc-2.7.2 wall" question is COMPLETE — answer: NO external shortcut exists):**
- **Parity research:** our architecture (LLM proposer + whole-binary byte-gate + permuter + idiom flywheel + ×134 dedup) IS the 2025-26 SOTA, ahead of Mizuchi/magic-decomp. No neural/GPU/diffusion 1:1 matcher exists (matching = discrete search vs an exact CPU oracle; GPU only smartens *proposals*, can't run cc1). Neural-surrogate-of-cc1 = research moonshot, not a workflow.
- **decomp.dev survey (byte-verified locally):** 4 gcc-2.7.2-psx twins — Xenogears, **Vagrant Story (CC0)**, Tomba!, FF7. Our cc1 ≡ the psx lineage (byte-proven); cdk ≠ psx. Pool ranking: **VS (CC0, clean)** → Croc (symbols/SDK-naming) → Xenogears + **Tomba (owner gave bfm-decomp full permission 2026-06-25)** as secondaries.
- **Census:** NO Square PS1 game shipped debug symbols (clean-room; Square lost its source). Best symbol Rosetta = **Croc** (same ASPSX 2.56) but non-Square → SDK-naming only, byte-neutral.
- **VS corpus:** 76 byte-verified (C→asm) pairs in `.run/corpus/vagrant-story/` (gitignored, reproducible). Low-priority asset (NN-retrieval isn't our bottleneck). Lesson: VS uses `-funsigned-char -fno-builtin` (BFM doesn't) — same-cc1 twins each carry flag deltas (cc1-internal idioms transfer 1:1; flag-dependent ones don't).
- **★ DEDUP PROBE — the decisive result (CLEAN NEGATIVE across all 3 sisters VS/Xenogears/Tomba):** BFM shares byte-identical (relocation-masked) code with the sisters **ONLY in PsyQ library/BIOS** (already on BFM's `psyq_integrate` roadmap → ~0 net-new byte-%). **ZERO Square OR non-Square engine code is shared.** The **AKAO sound-driver hypothesis is REFUTED** (0 of Xenogears' 127-fn AKAO driver matches BFM; BFM's sound is its own codebase). Tool `.run/xdedup/xsig.py` (relocation-masked signatures, self-validated). **Method-refinement (cookbook-worthy):** functions distinguished ONLY by a masked field (jal target OR data address — struct-copy/unrolled-memcpy idioms) can cross-project FALSE-POSITIVE even at n_loc=1; confirm any non-library HIGH hit semantically. **DROP the cross-project-C-lifting thread as a %-mover.**
- **Durable byproduct applied:** **62 PsyQ library/BIOS names** → `config/symbols.us.txt` (xdedup vs VS/Xenogears), byte-safe (main still `143dbb89…`, R22-verified). Comprehension win; Ghidra mirror (G6) deferred to next MCP session.
- **Reverse direction (Drew's Q — what can BFM give the sisters?):** CODE = none (symmetric — only PsyQ, which they each own). KNOWLEDGE = significant (our cookbook §17–§27 is the most advanced *documented* gcc-2.7.2 idiom guide; their patterns-wikis are empty stubs) + TOOLING (our harness + the new `xsig` cross-project-dedup tool, ahead of the field) → a **public-flip contribution**, not a code transfer.
- **STRATEGIC CONCLUSION:** **no external shortcut to the gcc-2.7.2 scheduler/regalloc/loose-typing wall** — it's intrinsic to matching a 1997 compiler. Forward progress = the proven toolkit + hand-finishing (the giants backlog), the path we're already on. A valuable Phase-3.5-style NO-GO (stops future shortcut-chasing).

---

## ★★★ SESSION 2026-06-25 (cont. 7e) — Drew's REFINED idiom-loop model + the "analyze-all-remaining" gap (READ FIRST)

> Drew (2026-06-25), articulating the neverending loop's PURPOSE: "**the goal of the waves is to LEARN IDIOMS.
> Every time we run out of fuel, analyze ALL remaining functions, group them by decomp issue; each group teaches
> ≥1 idiom; cookbook it; using it, run waves on ALL functions it applies to; bank; repeat forever.** I'd rather not
> use plan mode. Is this what we already set up?"

**ANSWER (byte-checked): YES — this IS the `idiom_loop` flywheel; no plan-mode build needed.** The mapping:
| Drew's step | The built mechanism |
|---|---|
| out of fuel → analyze remaining, **group by decomp issue** | `idiom_loop.py --assess` clusters the backlog by gcc-quirk class (regalloc-order/schedule/struct/…) |
| each group → **1 idiom** | `--assess` names the top close>0 codegen class → crack 1 exemplar → distill to cookbook (R16/R30) |
| **cookbook it** | `tools/workflows/distill.js` + the cookbook (§17–§27); drafters read it live |
| **wave ALL functions it applies to** | `--gen-fuel <class>` → `worker_wave.js` (Workflow, per-agent xHigh) seeded with the idiom |
| **bank** | `gate_stage.py` (canon→cast→sig_unify→byte-gate→propagate ×134) — G3/P9 sole arbiter |
| **repeat forever** | re-`--assess`; this neverending loop |

**THE ONE REAL GAP (the refinement worth making): `--assess` clusters the BACKLOG (already-DRAFTED near-misses),
not ALL remaining stubs.** A function's "decomp issue" is only known AFTER a draft attempt (the residual = the
class). So "analyze ALL remaining" = a **TRIAGE wave**: point `worker_wave` at the UN-drafted pools → each draft
self-reports `// @class` → they enter the backlog → `--assess` now sees the full landscape → idiom-per-group. **No
new tool needed** — just feed the loop the un-drafted fuel. **Next fuel = the reach-1 pool** (281 small
overlay-unique fns, `wave_targets --pool reach1`; ×1, low fleet-ROI ~+0.06%/183 per cont.5, but tractable + teaches
fresh idioms — exactly the "learn idioms" goal even if the % is small). The reach-134 ×134 tail is byte-proven
walled (5 levers: cheap-recovery/permuter/giant-wave/hand-finish/deep-RE all hit the gcc-2.7.2 scheduler/regalloc
wall at 63.17%, §27).

**EFFORT (already the design — no toggle dance):** Max for orchestration + idiom-cracking + synthesis; the WAVES
self-set per-agent **xHigh** via the Workflow tool (`opts.effort`). No global Ultracode needed (R26/R27).

**FRESH PHASE vs FRESH SESSION (Drew's question):** you do NOT need a fresh phase + plan mode to *build* this —
it's built. But (a) this session is ENORMOUS (cont.7→7e, very bloated context) → a **fresh session** is strongly
advisable for the next cycle (context hygiene = the breadth lesson + the neverending-loop model: one idiom/session,
clean context). (b) **Optional clean milestone:** the reach-134 ×134 harvest IS byte-proven complete (a natural
boundary) → you MAY **close Phase 21 (T7 PhaseEnd)** banking the arc + open **Phase 22 = the idiom-loop at scale on
the reach-1 / full-remaining landscape** (same architecture, no plan mode — the "plan" is this model). OR keep
Phase 21 open (neverending). **Drew's call** (P8 milestone gate).

**DREW'S DECISION (2026-06-25): keep Phase 21 OPEN; hand off to a FRESH session** with the `/loop` prompt above.
No PhaseEnd. This session (cont.7→7e) was enormous; the next starts clean and runs the idiom-loop on the reach-1
fuel. **Process lesson for the fresh session (keeps the orchestrator lean → longer hands-off runs):** delegate ALL
heavy work (drafting, hand-matching, deep analysis) to Workflows/subagents (isolated context); the main loop holds
only compact gate summaries. cont.7's context bloat came from doing hand-matching + deep-RE INLINE in the
orchestrator (func_80176D94 / func_801775E0 / func_8014EA4C) instead of in a Workflow — bank that lesson.

**THE `/loop` PROMPT for the next (FRESH) session** (whether Phase 21-cont or Phase 22):
> `/loop` Idiom-learning cycle on the reach-1 tail. Read CURRENT_PHASE cont.7e + cookbook §17–§27. (1) TRIAGE wave:
> `wave_targets.py --pool reach1 --n 24` → `worker_wave.js` (xHigh agents, each drafts + self-reports `// @class`)
> → `gate_stage --commit` (banks the one-shots ×1; logs near-misses by class). (2) `idiom_loop.py --assess` over
> the now-richer backlog → the top reach-1 decomp-issue group → crack 1 exemplar → distill the idiom (cookbook,
> R16/R30). (3) `--gen-fuel <class>` → re-wave the group with the idiom → bank. (4) Repeat; when reach-1 thins,
> triage the next un-drafted pool. Grinder runs token-free alongside (`tools/auto_status.sh`); byte-gate is the
> sole arbiter (G3/P9/R14 — match_one MATCH ≠ banked). Effort: Max orchestration, waves self-set xHigh.

---

## ★★★ SESSION 2026-06-25 (cont. 7) — cheap recovery lever EXHAUSTED (byte-proven); `--assess` was doubly-inflated, now fixed

> Drew's `/loop` (the cont.6+ prompt) + `/effort Max`. Ran the probe-first cycle: assessed → ran the cheap `_a`
> close=0 recovery to completion → diagnosed + FIXED the assess inflation. No token-heavy wave fired (ROI-gated,
> §20/§26). All byte-gated (G3/P9); 0 NON_MATCHING; grinder ran token-free alongside (banked 0 — the hard tail).

**Fleet 63.17%** (217,316 / 344,010, **+0.00% this session** — no banks; the cheap fuel proved dry) · 136/136
byte-identical (baseline re-confirmed green: fleet unchanged, HEAD unchanged) · 0 NON_MATCHING · HEAD = the cont.7
commit below. Local, not pushed (R6).

**★ THE FINDING (byte-proven, R14/P9 — the cycle's real value): the cheap close=0 recovery lever is EXHAUSTED.**
- Re-gated the **20 still-stubbed `_a`/`o0` close=0 reach-134 fns** through the cont.6 fixed pipeline
  (`gate_stage --src-file`, canon-first two-stage; `sig_unify --src-file` fired on all 20). **banked 0/20.** Same
  §16/§20 **def-side multi-way loose-typing wall** as the MAIN region (cont.6: 0/40). cont.6's func_8012F568 was
  the lone simple-arity win; the rest need a C type that conflicts caller-decl-vs-def with no single fitting sig.
- So the close=0 "recovery lever" the assess kept naming "do FIRST each cycle, ×134 for ~0 tokens" is **dry.**

**★ TWO DURABLE TOOLING FIXES — `idiom_loop.py --assess` was DOUBLY inflated (R16 flywheel; cookbook §26):**
1. **`load_backlog` now drops banked-since-logged fns** (intersect the ledger with the live `INCLUDE_ASM` stub
   set — the same drop-now-matched P9 honesty `backlog.render` applies). Removed the bogus "unknown 14" class +
   ~10/class of stale-matched inflation (schedule 49→39 r134, regalloc 44→39, …).
2. **The DETERMINISTIC-RECOVERY line splits FRESH vs WALLED** — never-recovery-gated close=0 (genuine ~0-token
   fuel) vs already-recovery-FAILED close=0 (the def-side wall, "do NOT re-run"). **Post-fix: 0 FRESH, 46 WALLED.**
   The assess no longer misleads the next session into re-burning the dry lever. (Compounds: `reach` itself is the
   masked-`h_exact` OVER-count, §25 — a ceiling, not the real ×134.)

**★ THE SCHEDULE-WAVE VERDICT (probe-first, ROI-gated — NOT fired):** the cracked-exemplar ×134 fraction is ~50%
on n=2 (func_8012F568 ×134 / func_80128ED8 ×1), at median **15 ins off** = expensive per-fn pin work, over an
h_exact-inflated "39 reach-134." §20 "don't wave a wall" → the schedule wave is **not justified.** No tokens spent.

**★ SESSION BANKS:** none (the cheap fuel was byte-proven dry). The durable output is the **exhaustion proof + the
two assess-honesty fixes + cookbook §26** — they stop every future session re-burning the close=0 lever.

**★ UPDATE (cont.7b — 2nd auto-wake, same session): the resolved-reach probe is REFUTED + the close-1 tail is
permuter-class (two R14 self-corrections; cookbook §26):**
- **The cont.7 "resolved-reach probe" recommendation is WITHDRAWN.** `sig_image`'s `h_exact` is already
  `SHA1(raw image bytes)` — UNMASKED (sig_image.py:170-171) — so `reach` IS the accurate shipped-byte reach; a
  resolved-byte probe just reproduces it. The real gap is `reach` (shipped identical) ≥ realizable-×134 (shared-C
  reproduces all N), measurable ONLY by `dedup_propagate`'s byte-gate on an ALREADY-MATCHED fn. **No cheap static
  probe exists. Don't build it.** (Caught by scoping before building — saved the wasted tool.)
- **Attempted a source crack on func_801775E0** (regalloc, backlog close=1, Drew's "try pins before concluding a
  wall"): the saved draft compiles **31-off from source** (prologue save-SCHEDULING + branch-sense + block-order —
  the §20 wall); its close=1 was **permuter-achieved**, not source-close. So the close-1..4 codegen tail is
  **permuter-class** (the grinder's token-free territory), not cheap pin targets. **RULE (§26): `match_one` a
  backlog draft for its SOURCE closeness before assuming a pin crack.**
- **The honest inflection (P9):** the cached reach-134 **automated harvest is COMPLETE** — every cheap/token-free
  lever is exhausted or walled (close=0 def-walls; close-1..4 permuter-class; the grinder banks ~0 on the hard
  tail). Forward %-progress now needs a **token-heavy** investment: the **8 giants** (deep per-fn, byte-weight) or
  per-fn pin-cracking — both warrant Drew's ROI greenlight (R26/R27, §20). **→ surfaced to Drew as a fork below.**

**★ UPDATE (cont.7c): Drew chose GIANT SESSION. Validated the giant approach end-to-end + distilled the recipe
(cookbook §27):**
- The giant pool is **~18 still-stubbed tractable giants** (152–284 ins) + 2 monsters (func_80132784=400,
  func_80144B9C=770) — bigger than the assess's "8" (that was only the backlog-recorded ones).
- **Hand-matched func_80176D94 (152 ins) to STRUCTURALLY-MATCHED:** all calls/constants/GPU-packet-build
  byte-correct via the §27 recipe (cached Ghidra-C + **call-matching callee decls** for the arg-arity blocker —
  func_80177784 is called 3-arg though canonical 4-arg — + **§17 register pins** for the regalloc-shift + the
  **sibling func_80176FF4** coord-strength-reduce/GPU-pointer idioms). **Residual = pure regalloc-coalescing** (2
  extra callee regs: $s5 temp + $s6 accumulator-spill vs target's caller-saved/$s0-reuse) → saved to
  `.run/backlog_drafts/func_80176D94.c` as grinder/wave fuel (§27 step 5: permuter territory).
- **VALIDATION (the de-risk):** giants reach structurally-matched FAST (recipe steps 1-3); the last mile is
  regalloc-coalescing → ISOLATED-AGENT + permuter work, NOT main-loop serial grind (`breadth-isolated-agents-not-serial`).
- **NEXT: the worker_wave over the giants** (the efficient finish) — isolated xHigh agents each draft a giant with
  the §27 recipe seeded → I gate (`gate_stage`, flock-safe; `--src-file` for the `_a` giants) + propagate ×134.
  Pending Drew's confirm to launch the multi-agent Workflow (the Phase-21 T4 mechanism).

**★ UPDATE (cont.7d): the 6-giant wave (1.16M tokens) BANKED 0 — giants do NOT auto-bank (the honest result):**
- Drew greenlit the wave; 6 xHigh agents drafted func_801770E0/80144090/80178004/8014F74C/8014EA4C/801412A8 with
  the §27 recipe. They got the SHAPE (recipe works) but the whole-binary byte-gate (G3/P9, sole arbiter) rejected
  **all 6**: func_8014F74C close=0 match_one MATCH but **its RAW draft fails the byte-gate too** (verified — no
  callee/data conflict → match_one OVER-predicted, §25 masked residual); the rest are pure regalloc/scheduling
  residuals the agents themselves call "not C-steerable → permuter fuel" (close 6/25/53/91/164).
- **Confirms cont.2 / Phase-20 / Phase-16 (~3% wall): giants are HAND-FINISH / permuter fuel, NOT auto-bankable.**
  cookbook §27 updated with the wave result. **Do NOT scale more giant auto-waves for %** (1.16M tokens → 0 banks).
- **A gate bug surfaced (R16, noted not fixed):** `gate_stage`'s canon/cast/sig_unify transforms REGRESSED the
  close near-misses (func_8014EA4C 6→128) and logged the regressed closeness → **poisoned the backlog** (hid the
  bankable-via-permuter drafts from the grinder). Re-logged the 6 with the agents' TRUE closeness + raw drafts
  (`source=giant-raw`); **func_8014EA4C (6) + func_80144090 (25) are now grinder-eligible** (token-free permuter
  may finish them). Fix candidate: gate should log the BEST of (raw, post-transform) closeness for near-misses.
- **THE INFLECTION (P9, byte-proven across cont.7/7b/7c/7d): the automated reach-134 harvest is COMPLETE at
  63.17%.** Every automated lever — cheap close=0 recovery (0 fresh), permuter grinder (banks ~0 on the hard
  tail), giant auto-wave (0/6) — is exhausted. Forward %-progress = HAND-FINISHING (deep per-fn, Drew or me) or
  CLOSING Phase 21 (bank the 58.82%→63.17% arc + the ranked near-miss backlog). **→ surfaced to Drew.**

**★ NEXT — cont.6 option-3 is now CONFIRMED: the cached reach-134 cheap fuel is dry; the genuine levers are
token-heavy (fresh-session work, Drew's ROI greenlight per R26/R27/§20):**
1. **The GIANTS** (8 reach-134 >150 ins — the high-BYTE-WEIGHT lever, the one that moves the decomp.dev-comparable
   ~30% number; ~3% auto-yield, so mostly worker-gets-close → hand-finish/backlog fuel). A focused deep session.
2. **Per-fn pin-cracking** the genuine codegen near-misses (schedule-coalescing §25 / regalloc-order) — token-heavy,
   ~50% ×134 yield, distill each idiom (R16/R30). Probe ×134-shareability on the cracked exemplar BEFORE waving.
3. **[durable tool, highest leverage]** build the **RESOLVED-reach probe** (compare per-overlay *linked* `.text`
   from `expected/`, not masked `h_exact`) → every `--assess` gets the REAL ×134 leverage, ending the over-count
   at its source. Token-free; makes all future giant/wave ROI calls honest. (cookbook §26 open item.)

**★ THE `/loop` PROMPT for the NEXT session** (Drew pastes it; the cheap-recovery step is now correctly a no-op):
> `/loop` Phase-21 idiom cycle (cont.7+). Read CURRENT_PHASE cont.7 + cookbook §26 first. (1) `idiom_loop.py
> --assess` — the close=0 recovery lever is now honest (0 FRESH / 46 WALLED → SKIP it; do NOT re-run recovery on
> walled fns). (2) The cheap fuel is dry — pick the token-heavy lever WITH Drew's ROI greenlight: EITHER (a) a
> focused GIANT session (8 reach-134 >150-ins in `.run/fuel_manifest.json` class=GIANT — re-draft fresh w/ current
> canonical context + §17–§25 toolkit → gate+propagate ×134), OR (b) build the RESOLVED-reach probe first (§26
> open item) so the next wave targets only genuinely-×134 fns. (3) PROBE ×134-shareability before any wave (§25/§26
> — h_exact over-counts). Distill each idiom (R16/R30); honest (R14/P9). Grinder runs token-free alongside.

---

## ★★★ SESSION 2026-06-25 (cont. 6) — schedule idiom = COALESCING (pin-crackable), 2 durable gate fixes, h_exact over-counts ×134 (SUPERSEDED by cont. 7 above for the "NEXT" — the cheap lever is now byte-proven dry)

> Drew's `/loop` (the cont.5 prompt) + `/effort Max`. Ran the cont.5 cycle: assess → cheap recovery → learn the
> `schedule` idiom. The grinder ran token-free alongside (still permuting the hard tail, banked 0 — expected).
> All byte-gated (G3/P9); 0 NON_MATCHING throughout.

**Fleet 63.17%** (217,316 / 344,010, +0.04% this session) · 136/136 byte-identical (R22 re-verified at close) · HEAD = the cont.6 commit below. Local, not pushed (R6).

**★ TWO DURABLE TOOLING FIXES (the real value this session — they compound on every future wave):**
1. **`sig_unify.py --src-file`** (closes the §24 open item). It read `cur_stubs`/decls from the MAIN `.c` only →
   silently DROPPED every `_a`/`_o0` split-file draft (0 unified vs 21 with the flag) → split-file near-misses
   never got the def-side arity-adopt recovery. Now `--src-file src/ov_SC01_077/ov_SC01_077_a.c` reads the split
   file. `gate_stage` passes it to BOTH `cast_call_sites` and `sig_unify` in `--src-file` mode. → banked
   func_8012F568 ×134 from the `_a` close=0 backlog (commit:0277).
2. **`gate_stage.py` is now CANON-FIRST two-stage (§19 design folded into the shared gate).** It ran
   canon→cast→sig_unify in ONE pass; sig_unify REGRESSED the func_80128ED8 crack (rewrote its byte-correct def
   `s32 f(s32,s32*)` → a banked caller's `void* f(void*,void*)` → gate reject). Fix: **stage 1** canon+cast →
   gate (already-correct/hand-pinned cracks bank here); **stage 2** sig_unify ONLY the stage-1 failures → re-gate
   (def-side recovery, no regression). `harvest_verify` accumulates verified across the two calls (reads current
   src as baseline). Cookbook §25.

**★ THE `schedule` IDIOM — CRACKED, but it's COALESCING not scheduling (cookbook §25):** func_80128ED8 (close=3,
the assess's lowest-closeness reach-134 schedule exemplar) → `match_one` MATCH 53/53 via two §17 pins: pin the
index-preserve copy to its target reg ($a3) so gcc can't fold it into the multiply operand (multiply uses $v1
directly), and route `idc+1` through a dead $v0-pinned temp. The "schedule" label was misleading — the residual
was gcc-2.7.2 **copy-coalescing**. Also distilled the genuine `rank_for_schedule` tie-break (priority → class-vs-last
→ LUID source-order) and the genuine WALLS (func_8014FD54 §10 cross-jump/delay-slot; func_8014F2E0 store-vs-load).

**★ THE STRATEGIC FINDING (R14/P9 — reshapes the cont.5 model): `h_exact` OVER-COUNTS ×134.** func_80128ED8 is
byte-identical in ov_SC01_077 but **does NOT propagate ×134** — `dedup_propagate --addr 0x80128ED8` alone still
`[drop]`s it at ov_SC01_000 (cross-overlay byte-gate reject). So it banks **×1**, despite h_exact `members=134`
(h_exact is relocation-masked → over-counts). **Consequence:** `idiom_loop --assess`'s per-class "reach-134"
count is OPTIMISTIC; the `schedule` class is NOT a confirmed ×134 vein (its 2 closest reach-134 exemplars = 1 ×1
coalescing crack + 1 §10 wall). **Before a token-heavy wave, probe ×134-shareability on the cracked exemplar**
(`dedup_propagate --addr <fn>`), don't trust the h_exact count.

**★ SESSION BANKS:** func_8012F568 ×134 (commit:0277, `_a` recovery) + func_80128ED8 ×1 (commit:0278, schedule crack).
The MAIN-region close=0 recovery banked 0/40 (the §20 def-side wall, as expected — sig_unify already tried on them).

**★ NEXT — the schedule WAVE (cont.5 step 4) is NOT yet justified (ROI-gated, §20 "don't wave a wall"):** the
exemplar came out ×1 and the class's reach-134 count is h_exact-inflated. Options for the next session, in order:
1. **Probe-first:** run `dedup_propagate --addr` on 5-10 more cracked schedule fns to MEASURE the real ×134 fraction
   before any wave (cheap, ~0 tokens). If a meaningful fraction is ×134 → wave with the §25 coalescing-pin idiom.
2. **Re-assess for a higher-ROI idiom:** `idiom_loop --assess` after this session's banks; consider that the
   median-0 classes (regalloc-order 44 r134, plumbing 34 r134) are RECOVERY-dominated — the now-fixed
   `sig_unify --src-file` + canon-first gate may unlock some via a re-gate of their close=0 backlog (cheap).
3. The fresh fuel is genuinely thinning; the honest read is that the cached reach-134 tail is mostly walls +
   ×1-overlay-local. The high-byte-weight lever remains the **giants** (§ Phase-21 backlog) — token-heavy, deep.

---

## ★★★ SESSION 2026-06-24 (cont. 5) — Phase 21 is now a NEVERENDING idiom-learning loop (was READ FIRST; cont.6 supersedes the model caveat)

> **Drew's directive (2026-06-24): Phase 21 does NOT end until he says it does — assume neverending.**
> The model: harvest the EASY reach-134 fuel until ~80% consumed (a WALL), then **LEARN the next
> gcc-quirk IDIOM** that unlocks the highest-leverage residual, hand off to a **FRESH session** (clean
> context) with a `/loop` prompt to crack + harvest it, and **repeat forever → toward 100% decomp**.
> Each session ≈ one idiom. The vote is always: *target new gcc quirks, learn idioms, 100% the game.*

**Fleet ~62.98%** (wave-4 in flight) · 136/136 byte-identical · 0 NON_MATCHING · grinder running (token-free).
The `_a` reach-134 EASY fuel is ~exhausted (waves 1–4 this session: 62.31 → 62.98%, +0.67%) — **we are AT
the first idiom wall.**

**★ THE META-LOOP TOOL (new, committed): `tools/idiom_loop.py`**
- `--fuel-status` — rough wall indicator (counts ALL fresh cached incl. reach-1; the *precise* reach-134
  wall = `wave_targets --region a/main` returns a small / re-attempt-heavy batch, as now: 24→24→20→13).
- `--assess` — clusters the backlog near-misses by gcc-quirk class, ranks by reach-134 leverage, names
  (a) the next IDIOM to learn + (b) the cheap deterministic recovery lever.
- `--gen-fuel <class> [--out f]` — writes the research+harvest fuel manifest (closest-first) for a session.

**★ FIRST ASSESSMENT (`--assess`, byte-backed from the 316-record backlog):**
- **NEXT IDIOM TO LEARN → `schedule`** (49 reach-134 fns, median 13 ins off): the gcc-2.7.2
  **instruction-scheduler (sched.c) load/store tie-break** — drafters consistently stub it "unsteerable"
  after pins+barriers. Fuel: `.run/auto/idiom_fuel_schedule.json` (68 fns). Crack it on a **low-but-NONZERO**
  closeness exemplar (e.g. func_80128ED8 / func_80131A34, close=3 — a single misplaced copy/load-order),
  research sched.c (R17, `tools/reference/gcc-papermario`), distill to the cookbook, then re-wave ×134.
- **DETERMINISTIC RECOVERY LEVER → 64 close=0 reach-134 fns** (byte-correct, declaration-blocked = the `_a`
  sig_unify-skip casualties + main plumbing). A def-side recovery (make `sig_unify` `--src-file`-aware so it
  doesn't drop `_a` drafts, OR cast the def) banks them ×134 for ~0 agent tokens. **DO THIS FIRST each cycle.**

**★ THE NEVERENDING CYCLE (every fresh session = the `/loop`):**
1. `idiom_loop.py --assess` → confirm the target idiom + the close=0 recovery count.
2. **Cheap harvest first:** run/extend the def-side recovery over the close=0 backlog → gate (drop-straggler-safe) → ×134.
3. **Learn the idiom:** research the gcc pass (R17) + crack 1 low-closeness exemplar (hand/agent) → distill to the cookbook (R16).
4. **Harvest the idiom:** `worker_wave` over the fuel manifest (seed agents with the new idiom) → `gate_stage --src-file --commit` → ×134.
5. At ~80% of this class's fuel → `--assess` next idiom → `--gen-fuel` → **request a fresh session + hand Drew a new `/loop` prompt.** Forever.

**★ THE `/loop` PROMPT for the NEXT (fresh) session** (Drew pastes it to start):
> `/loop` Phase-21 idiom cycle. Read CURRENT_PHASE cont.5 + the cookbook. (1) `idiom_loop.py --assess`. (2) FIRST harvest the close=0 deterministic-recovery lever: make `sig_unify --src-file`-aware (don't drop `_a` drafts) or cast the def, re-gate the close=0 backlog → bank ×134. (3) LEARN the `schedule` gcc-2.7.2 idiom: research sched.c (R17), crack a close≈3 exemplar (func_80128ED8/func_80131A34) by hand, distill to the cookbook. (4) `worker_wave` the schedule fuel (`.run/auto/idiom_fuel_schedule.json`) seeded with the idiom → gate ×134. (5) At ~80% fuel → `--assess` the next idiom → `--gen-fuel` → request a fresh session + give Drew a new `/loop` prompt. Phase 21 is NEVERENDING; grinder runs token-free alongside (`tools/auto_status.sh`).

---

## ★★★ SESSION 2026-06-24 (cont. 4) — the `_a` vein IS a ×134 lever (10/11); cont.3 §24 pessimism CORRECTED (superseded by cont. 5)

> Authoritative. The first real `_a` measurement wave ran (Drew greenlit + `/effort Max`). CORRECTS cont.3/§24:
> the `_a` vein is NOT ×1 loose-typing-walled — **10/11 banked fns propagate ×134 byte-identical**. The "×1"
> reading was TWO tooling bugs, now diagnosed (R14, byte-proven). The byte-gate (G3/P9) held throughout.

**Fleet 62.70%** (215,699 / 344,010, **+0.39% this turn**) · 136/136 byte-identical · 0 NON_MATCHING.
HEAD = the commit below. Grinder still running (token-free, banked 0 — the permuter-resistant hard tail; don't stop). Local, not pushed (R6).

**★ THE RESULT — `_a` is a ×134 lever (probe-proven):**
- Wave: 24 xHigh agents over `wave_targets.py --pool tractable --region a` (61–129 ins) → **16/24 self-MATCH, 11 byte-banked** in `ov_SC01_077_a.c` (commit `commit:0266`). All 11 are reach-134 (members=134).
- The gate reported **`propagated: 0`** — a TOOLING artifact, NOT the §24 wall. Two stacked bugs:
  1. **`dedup_propagate` batch propagation is ALL-OR-NOTHING** (lines 456–464): one cross-overlay-incompatible fn reverts the whole batch.
  2. The poison was **`func_8013C360`** — the pre-existing **-O0 overlay-local** straggler (§18/§20: masked h_exact falsely reports reach-134, but its real bytes reference per-overlay data → fails the cross-overlay byte-gate). Swept into `--auto-from`, it reverted all 10 clean matches.
  3. **`gate_stage`'s `sh()` swallows dedup_propagate's non-zero exit** (no return-code check) → reported 0 with no error surfaced.
- **Per-function probe (each vs ov_SC01_000, gate.lock held): 10/11 PASS, 1 FAIL** (the FAIL = func_8013C360 ONLY).
- **Realized the gain:** propagated the 10 clean fns ×134 (`dedup_propagate --addr <10> --source-overlay ov_SC01_077 --min-reach 2`, straggler excluded) → `[ OK ] 134 overlays byte-identical`, 10 new dedup groups → **commit `commit:0267`, fleet 62.31→62.70%**.

**★ THE 10 PROPAGATED ×134:** `0x80128DB4 0x801300F4 0x80136D08 0x80130AF0 0x8012944C 0x8012D4B4 0x80137030 0x80132288 0x8012DBD0 0x8013339C`. **×1 (local-types-skip → needs the §20 type-lift):** func_8012EA90 (banked in `_a.c` only). **Excluded straggler:** func_8013C360 (-O0 overlay-local — keep OUT of cross-overlay propagation).

**★ ENABLER FIX (committed this session):** `worker_wave.js` now derives each agent's `match_one` self-check `--asm-subdir` from `t.asm` (was hardcoded to the MAIN subdir → every `_a` agent self-check crashed on a missing `.s` → blind drafting). THIS produced the high close rate (16/24); without it the `_a` wave drafts blind.

**★ FIXES DONE + VALIDATED (this session) — the `_a` pipeline is now HANDS-FREE:**
1. **`gate_stage` surfaces propagation failures** (`commit:0269`): `prop_error` + `.run/auto/last_propagate_error.log` — no more silent swallow (it caught wave-2's failure live).
2. **`dedup_propagate` excludes -O0 overlay-local fns from `--auto-from`** (`commit:0269`): `*_o0.c` defs (incl. func_8013C360) never cross-overlay-propagate (find_site-detected; --addr still forces).
3. **`dedup_propagate` DROP-STRAGGLER retry** (refactor): on a byte-gate fail it isolates the culprit(s) for the failing overlay (per-fn trial), drops them (kept ×1), and retries the survivors — handles BOTH straggler classes (-O0 byte-mismatch + cross-overlay loose-typing compile-error) failing ANY overlay. Byte-gate stays sole arbiter; the plan strictly shrinks so it always terminates.

**★ WAVE-2 (validated the fixes end-to-end):** 24 fresh `_a` targets → 13 self-MATCH → gate banked **6** (the `_a` path SKIPS sig_unify, so def-side near-misses don't auto-recover → lower bank rate than main). Drop-straggler `--auto-from` then auto-dropped 2 loose-typing stragglers (func_8012E5CC/func_8012C750 — compile-fail ov_SC01_000, kept ×1) + propagated **3 clean ×134** (`commit:0271`). The 11 near-misses are permuter-class schedule/regalloc walls (grinder fuel; 7 were last wave's re-attempts, still walls).

**★ SESSION ARC: 62.31% → 62.82% (+0.51%):** wave-1 +10 ×134 (`commit:0267`) · wave-2 +6 ×1 (`commit:0270`) +3 ×134 (`commit:0271`). 136/136 byte-identical, 0 NON_MATCHING throughout.

**★ NEXT — the `_a` scaling loop is now hands-free (~55 fresh `_a` reach-134 fns remain):** `wave_targets --pool tractable --region a` → worker_wave → `gate_stage --src-file --commit` (auto-drops stragglers + auto-propagates clean ×134). ~+0.2–0.4% fleet/wave. **Improvement idea:** a def-side recovery that doesn't drop `_a` drafts would lift the `_a` bank rate (sig_unify-skip is the current cap). **Pending Drew's direction** (continue scaling vs checkpoint/close).

---

## ★★★ SESSION 2026-06-24 (cont. 3) — the `_a.c` split-file vein: enabler tooling built (SUPERSEDED by cont. 4 — the vein IS ×134)

> Authoritative. Pursued the fresh-fuel recommendation; found the fresh fuel is in `ov_SC01_077_a.c` (a tooling
> gap), built the split-aware enabler, and characterized the vein honestly (it hits the same loose-typing wall).

**Fleet 62.31%** (unchanged — **no net banks this turn**; func_8012C098 matched ×1 in `_a.c` then reverted by a
diag's `git checkout`, negligible + a propagation-wall). 136/136 byte-identical. HEAD = the commit below.

**RUNNING NOW (2026-06-24):** token-free **grinder relaunched** (`DRIVER=tools/grinder.py auto_supervisor.sh
--permute-secs 120 -j 14`, detached) on the close≤30 backlog; byte-gated (G3/P9), auto-commits ×134,
self-supervising. Monitor `bash tools/auto_status.sh`; stop `bash tools/auto_stop.sh`. A `/loop` check-in reports
progress (kill switch = `.run/auto/STOP`). CAVEAT: the close≤30 backlog is the permuter-resistant hard tail
(§20/§24) — it banked **0 in ~1h** on a prior run; expect low/slow yield. The real % lever is the **`_a`
measurement wave** (below), pending Drew's token greenlight — the grinder is the free background filler meanwhile.

**★ THE FINDING (where the fresh fuel is):** the main-`.c` reach-134 fuel is byte-exhausted (1 fresh fn); the
**66+ fresh cached reach-134 fns live in `ov_SC01_077_a.c`** (the Phase-19 `-O0` 3-way split), never waved because
the harvest pipeline defaults to `src/{ov}/{ov}.c`. Full write-up: **cookbook §24**.

**★ ENABLER TOOLING BUILT (committed, validated as far as possible, fail-closed/safe):**
- **`dedup_propagate.py` split-aware** — `overlay_files()` handles main + `_a`/`_o0`; source-find scans all,
  member-loop edits the right split file, structural-check spans all. Single-file overlays unchanged. Validated:
  source-find (`--check-only` → 134 members) + fail-path revert. (×134 success-path of an `_a` fn pending the wave.)
- **`cast_call_sites.py --src-file`** — canonicalize callee decls against the file the draft LANDS in (cross-file
  loose typing: e.g. `RotTransSV` declared differently in main vs `_a.c`). Default = main (unchanged).

**★ THE WALL (honest — `_a` is NOT the clean +2-3% I projected):** the `_a` bodies are matchable (func_8012C098
cast-banked ×1), but matching/propagation hits the SAME §16/§20 loose-typing wall: cross-overlay def-conflict
(func_8012C098 → caller declares it `(void)` but body uses a param → ×1 wall, can't propagate), within-`_a`
multi-sig callees (func_8012F274 → `RotTransSV` declared inconsistently in `_a.c`). The ×134 yield is uncertain.

**★ THE `_a` WAVE IS NOW TURNKEY (built + wired this session — run from a FRESH session; Drew greenlit waving `_a`):**
All four pieces committed: `wave_targets.py` region-aware (`--region a` serves the 68 fresh `_a` reach-134 fns
with the correct `..._a` asm paths) · `cast_call_sites.py --src-file` (canonicalize vs the `_a.c` decls) ·
`gate_stage.py --src-file` (cast `--src-file` + SKIP sig_unify, which drops `_a` fns; harvest_verify `--src` `_a.c`) ·
`dedup_propagate.py` split-aware (propagates an `_a`-matched fn ×reach).

**THE `_a` WAVE CYCLE (fresh session; grinder runs alongside, free):**
1. `.venv/bin/python tools/wave_targets.py --pool tractable --region a --n 24 --out .run/auto/wave_batch.json`
   (small `_a` WAVE/PINS/STRUCT ≤150-ins; or `--pool any-reach134 --region a` for all 68 incl. giants).
2. Read `.run/auto/wave_batch.json`; launch `tools/workflows/worker_wave.js` (Workflow tool),
   `args={draftDir:".run/drafts-wave", targets:<batch array PASTED VERBATIM>}` (args = JSON ARRAY, §20 gotcha).
3. On completion GATE in `_a` mode — **BACKGROUNDED + dangerouslyDisableSandbox** (NOT `orchestrator.py finish`, which is main-only):
   ```
   .venv/bin/python tools/gate_stage.py --binary ov_SC01_077 \
     --src src/ov_SC01_077/ov_SC01_077_a.c --asm-subdir asm/ov_SC01_077/nonmatchings/ov_SC01_077_a \
     --src-file src/ov_SC01_077/ov_SC01_077_a.c \
     --out build/ov_SC01_077/ov_SC01_077 --good-sha d19c9580a02dc63ba1f0e7e0c770f3b10de35635 \
     --drafts .run/drafts-wave --commit
   ```
   Prints `{banked, propagated, near, failed, fleet_pct}`. `propagated` ≈ #fns that went ×134; banked-not-propagated = ×1 walls (§24).
4. `make report` for fleet%; distill new idioms (`tools/workflows/distill.js`); loop step 1. STOP all: `bash tools/auto_stop.sh`.

**MEASURE FIRST (probe-before-scale):** run ONE wave, read the ×134-vs-×1 yield. High ×134 → scale the rest
(~60 `_a` fns, real fleet%); mostly ×1 → the loose-typing wall (§24) dominates → pivot. The byte-gate guarantees
correctness either way (a wrong/conflicting draft reverts, never banks). Cookbook §24 has the full context.

---

## ★★★ SESSION 2026-06-24 (cont. 2) — GIANTS ARE STALE+INCOMPLETE DRAFTS, not cheap near-misses

> Authoritative. CORRECTS the "(cont.) GIANTS-AS-NEAR-MISSES" section below: only func_80153E00 was a clean
> near-miss; the rest are stale-draft RE-DRAFT work. A diag self-correction (R14) — the byte-gate was right.

**Fleet 62.31%** (214,358/344,010) · 136/136 byte-identical · 0 NON_MATCHING · banked_total 288 · waves 34.
**No new banks this turn** (func_80153E00 ×134 was the prior turn). HEAD `commit:0261`+ (docs). Grinder STOPPED.

**★ THE GIANT VERDICT (byte-proven, P9/R14):** the 14 MAIN-file giants' prior-wave drafts are **STALE +
INCOMPLETE** vs the grown `engine_core.h` — `conflicting types` (draft `u8 D_80126B58` vs canonical `s32`;
`u8 D_80126948` vs `u8[]`), **undeclared** data symbols (`D_800A5E8C`, `D_800B9A08` → link `undefined reference`),
incomplete types. The whole-binary gate (`harvest_verify`) banks **0 of 10**. They are **NOT cheap near-misses** —
they need **RE-DRAFTING fresh** (worker wave, current canonical context + §17–§23 toolkit incl. the data-cast),
not a recovery transform. func_80153E00 banked only because its draft was complete + 1-instruction clean.
- **⚠ A DIAG MIRAGE bit me (cookbook §23, §20 stale-`.o`):** a per-function `objdump` diff that builds WITHOUT
  removing `build/src/<ov>.o`+`.elf` first reports **FALSE byte-matches** when a draft fails to compile (make
  leaves stub artifacts). It faked "10 giant MATCHes." Fixed `.run/diag_funcdiff.py` to `os.remove` artifacts
  first. **The whole-binary SHA gate is the SOLE arbiter (G3/P9)** — it removes the output, so it was right.
- **sig_unify bug found (not fixed — reverted):** `DRAFT_EXTERN_LINE_RE` anchors `;$` so it SKIPS externs with a
  trailing `/* */` comment → can't canonicalize them. A regex fix works but (a) is unproven to bank (the giants
  have deeper undeclared-symbol issues) and (b) broader canonicalization regresses value-read divergent-type
  drafts — the right lever is a **data-CAST** (keep canonical decl, cast the read; §23), not canonicalization.
- **11 `_a.c` giants** (func_8013339C/8012D098/80129CF8/8012EC04 + 7 more): live in `ov_SC01_077_a.c` (Phase-19
  3-object split), but `dedup_propagate`/the gate are hardwired to `src/{ov}/{ov}.c` → can't source from `_a.c`.
  Banking/propagating them needs split-aware tooling. (`func_8012EC04` is GTE — also needs raw-byte verify, §18.)

**★ NEXT — a FORK for Drew (the cheap-giant-recovery premise is refuted):**
(a) **Re-draft the giants fresh** — a worker Workflow over the 28 GIANT-class fns (`.run/fuel_manifest.json`,
    class=GIANT) with current canonical callee/data sigs embedded + the §17–§23 toolkit, then gate+propagate ×134.
    High byte-weight payoff (func_80144B9C=770 ins ×134) but token-heavy + each needs its own near-miss grind.
(b) **Pivot to a more tractable pool** (fresh reach-134 ≤90-ins via a Ghidra-C regen, or relaunch the grinder).
(c) **Build split-aware + data-cast tooling** first (unlock the 11 `_a.c` giants + auto-recover the data class).
Recommendation: (b) for steady % now, with (a) as a focused deep session for the byte-weight. Drew chooses.

---

## ★★★ SESSION 2026-06-23 (cont.) — GIANTS-AS-NEAR-MISSES (partially SUPERSEDED by cont. 2 above)

> The func_80153E00 crack below is correct; the "giants are near-misses, diagnose+bank" GENERALIZATION is
> corrected by cont. 2 (most giant drafts are stale+incomplete → re-draft, not recover).

**Fleet 62.31%** byte-identical (**214,358 / 344,010**, +134 vs the checkpoint) · 136/136 binaries byte-identical · 0 NON_MATCHING.
banked_total 288 · waves 34 · grinder STOPPED (`.run/auto/STOP` present). Committed locally (`commit:0260`), **not pushed** (R6).
This session (Drew's `/loop`, one giants cycle): **banked `func_80153E00` ×134** (the 195-ins giant), fleet 62.27→62.31%.

**★ THE CORRECTED GIANTS FINDING (R14, byte-proven — supersedes the FINAL HANDOFF "callee-declaration plumbing" claim):**
The 5 "body-correct but plumbing-blocked" giants are **NOT** plumbing-blocked. `func_80153E00` **compiles AND links
CLEAN** in the whole binary (no `conflicting types`, no `undefined reference`) and was a **1-instruction near-miss**
(1/195). `match_one` over-predicted — it compiles STANDALONE with the draft's own externs AND masks jal/%hi/%lo, so it
never sees the real residual. **The giants are individually-diagnosable near-misses; diagnose + fix the 1–N off
instructions + bank ×134.** Full write-up: **cookbook §23**.
- **THE DIAGNOSTIC (use this on every giant):** `.venv/bin/python .run/diag_funcdiff.py <fn> <draftdir>` — a linked-ELF
  per-function `objdump` diff (target = stub build, candidate = spliced build), address-column normalized so only real
  opcode/reg/operand diffs show. Tells you in seconds whether the residual is relocation/codegen/type. **Run only when
  NO `ov_SC01_077` build is in flight** (concurrent `make build BINARY=ov_SC01_077` clobbers `build/`).
- **`func_80153E00`'s blocker = scalar-data-signedness conflict (the data analog of cast_call_sites):** target `lhu`,
  candidate `lh` on `D_8011DB0C` (declared `extern s16` canonically but the fn needs a `u16` read). Declaring `u16` →
  `sig_unify` reverts to canonical `s16`. **Fix: keep canonical `extern s16`, cast the READ: `*(u16*)&D_8011DB0C`** →
  gcc folds to one `lhu`, no decl conflict, survives the gate. Refutes §20's "data-cast moot" (which only checked
  struct/union, not scalar signedness). Writes (`sh`) are signedness-agnostic — only reads need casting.

**★ NEXT (fresh cycle) — diagnose the OTHER 4 giants the same way (drafts in `.run/drafts-wave-cn/`):**
`func_8013339C` (schedule), `func_8012EC04` (GTE — verify on RAW bytes via objcopy, NOT objdump/match_one, idiom
`commit:0253`), `func_8012D098` (struct), `func_80129CF8` (struct; its note already flags `D_80126DB8` lh-vs-lw — likely the
SAME scalar-data-cast class). For each: `cp .run/drafts-wave-cn/<fn>.c .run/dg/` → `diag_funcdiff` → fix the diffs →
`cp` to `.run/drafts-wave/` → `orchestrator.py finish --drafts .run/drafts-wave --commit` (BACKGROUNDED +
dangerouslyDisableSandbox). **Struct-class giants** (D_*-struct local typedefs) also need the type-lift
(`build_engine_types.py --strip`) to propagate ×134 (Phase-20 §20 T1) — else they bank ×1 local.
**TOOLING LEVER (probe-first):** if the scalar-data-signedness conflict recurs on ≥1–2 more giants, build
`cast_data_sites.py` (data sibling of `cast_call_sites.py`) into `gate_stage` → auto-recovers the class for ~0 tokens.

---

## ★★★ SESSION 2026-06-23 FINAL HANDOFF — (SUPERSEDED by the GIANTS-AS-NEAR-MISSES section above; historical trail)

> Authoritative current state at a clean committed checkpoint. Everything below this section is HISTORICAL trail.

**Fleet 62.27%** byte-identical (**214,224 / 344,010**) · **+1.11% this session** (started 61.16%) · 136/136 binaries
byte-identical · 0 NON_MATCHING. **Nothing running** — grinder STOPPED (`.run/auto/STOP` present; `rm` it to relaunch).
Clean checkpoint; committed locally, **not pushed** (R6 — Drew pushes). orch_state: `pool=any-reach134 waves=32 banked_total=287` (worker) + 5 grinder banks.

**THE SESSION ARC (Drew's `/loop`, steered via 5 AskUserQuestions):**
1. **Waves 17–29 — reach-1 (×1) smallest-first harvest:** ~183 banks but fleet only **+0.06%** — reach-1 fns are overlay-unique → ×1, and the fleet metric counts functions across all 136 binaries. Band climbed 14→75 ins, close-rate fell 0.9→0.33. **LESSON: reach-1 is poor fleet-ROI; its value was ov_SC01_077 completeness + idiom-mining.**
2. **Waves 30–31 — THE REACH-134 PIVOT (Drew's call), ×134:** banked 26 reach-134 STUB fns, each propagated ×134 → fleet **61.22% → 62.19% (+0.97% in 2 waves)** — ~16× the *entire* reach-1 run, per wave. Fuel = the `any-reach134` pool (STUB-class reach-134 fns the WAVE/PINS/STRUCT `tractable` pool never covered); now **EXHAUSTED**.
3. **Giants scout (Drew's call) — BODY-TRACTABLE but PLUMBING-BLOCKED (the key finding):** 10 giants (159–207 ins, ×134) → **5/10 self-MATCH at the body level** (relocation-masked) but **0 banked** — all failed the whole-binary gate on **callee-declaration plumbing** (giants call many fns; the recovery pipeline couldn't reconcile all their callee sigs → won't compile standalone). The 5 body-correct giants — `func_8013339C` `func_8012EC04`(GTE) `func_8012D098` `func_80129CF8` `func_80153E00` — are ×134, byte-correct bodies, blocked ONLY on callee decls. Best drafts saved in `.run/backlog_drafts/`.
4. **Grinder (token-free permuter, alongside):** banked **5** reach-1/permuter walls (+~0.05%); stopped for this checkpoint.

**★ THE EUREKA LEVER FOR THE FRESH SESSION — RECOVERY-TOOLING (highest leverage, ~0 agent tokens):**
The giants prove the BODIES are crackable; the wall is purely **callee-declaration plumbing** (§16/§20 loose-typing). Extend the recovery pipeline (`tools/canon_resident_calls.py → cast_call_sites.py → sig_unify.py`) to declare the giants' callees correctly → **bank the 5 body-correct giants ×134** (potentially **+1–2% fleet**) PLUS the ~5 plumbing-blocked reach-134 STRUCT self-MATCHes — all for ~0 drafting tokens. **Do this BEFORE more scout waves** (scouting finds more self-MATCHes but they won't bank until the callee plumbing is cracked).
  - **Start here:** take `func_80153E00`'s draft in `.run/backlog_drafts/`, run it through `tools/gate_stage.py` manually, read the standalone-compile error (a callee sig conflict), extend the recovery for that class, re-gate. Repeat for the other 4. Each bank is a giant ×134.

**SECONDARY:** (a) more giant-scout waves to grow the body-correct ×134 backlog (only valuable once recovery banks them — the 28 giants are in `.run/fuel_manifest.json` class=GIANT; 5 body-banked, rest fresh/near); (b) the grinder (relaunch, token-free) for permuter-walls; (c) the reach-1 big-fn tail remains (×1, low-ROI — skip).

**12 NEW COOKBOOK IDIOMS this session** (the durable knowledge): `commit:0225 commit:0227 commit:0230 commit:0232 commit:0235 commit:0237 commit:0240 commit:0243 commit:0245 commit:0247 commit:0249 commit:0253`. The last CRACKED the GTE-sqr "unproducible" false dead-end — **verify GTE/cop2-nop fns on RAW bytes (`objcopy -O binary --only-section=.text`), NOT objdump/match_one** (they elide zero-word runs → false mismatch). `func_8012EC04` confirms a 2nd GTE fn matches this way.

**3 POOL-TOOLING FIXES this session:** `commit:0228` (plumbing_blocked scans ALL raw backlog records) · `commit:0239` (NEW reserved_walls skips ≥2×-redrafted near-miss walls) · `commit:0257` (--class filters to still-unbanked genuine near-misses) → ~149+ churners correctly skipped from worker waves.

**RESUME COMMANDS (fresh session):**
- **Grinder** (token-free, relaunch): `rm -f .run/auto/STOP && DRIVER=tools/grinder.py setsid nohup bash tools/auto_supervisor.sh --permute-secs 120 -j 14 >/dev/null 2>&1 &` (dangerouslyDisableSandbox). Stop: `bash tools/auto_stop.sh`. Monitor: `bash tools/auto_status.sh`.
- **Worker finish** (after a worker_wave Workflow): `.venv/bin/python tools/orchestrator.py finish --drafts .run/drafts-wave --commit` — **BACKGROUNDED + dangerouslyDisableSandbox** (foreground make/git get sandbox-killed exit 144). It gates → banks → propagates ×134 (`dedup_propagate --auto-from`) → logs near-misses.
- **Manual giant batch** (worker_wave args.targets): pick fresh GIANT-class fns from `.run/fuel_manifest.json`, build `{name,addr,nins,class:"GIANT",asm,ghidra_c}` per target (addr=`0x`+name[5:].lower(); asm=`asm/ov_SC01_077/nonmatchings/ov_SC01_077/<name>.s`; ghidra_c=`.run/ghidra_c/<name>.c`).
- **Live fleet:** `grep byte-identical docs/progress.fleet.md` or `make report`. **Verify invariant:** `make check-all` → 136/136 (R22); per-bank whole-binary byte-gate (G3/P9) is the sole arbiter.

---

## ★★ REACH-1 HARVEST HANDOFF — READ THIS FIRST (2026-06-22, authoritative current state)

> Everything below this section (the prior ×134 QUEUED-RUN block, TRIP HAND-OFF, POST-REBOOT, etc.) is a
> HISTORICAL session-layer kept for the trail. **THIS section is the current state + the fresh-session plan.**

**★ SESSION UPDATE 2026-06-23 (waves 17–30 — Drew's `/loop`; PIVOTED to reach-134 at wave 30):** Fleet **61.73%** ·
banked_total **274** · 136/136 byte-identical · 0 NON_MATCHING throughout (per-wave byte-gate, G3/P9).
**ARC:** waves 17–29 = reach-1 (×1) smallest-first harvest, banked ~183 over 13 waves but fleet only +0.06%
(61.16→61.22) because reach-1 is ×1; the band climbed 14→75 ins and close-rate fell 0.9→0.33 (permuter-class
scheduler/regalloc walls). **Wave 30 = the PIVOT (Drew's call): worker → `any-reach134` pool (reach-134, ×134).
13 banks × propagated ×134 → fleet 61.22→61.73% (+0.51% in ONE wave, ~8.5× the entire reach-1 run).** `tractable`
& `giants` pools are byte-exhausted (Phase 19/20); `any-reach134` (STUB-class reach-134 fns the WAVE/PINS/STRUCT
`tractable` pool never covered) is the live ×134 fuel. **GRINDER RUNNING** (token-free decomp-permuter on backlog
close≤30 near-misses; `.run/auto/STOP` CLEARED per Drew's explicit authorization "run the grinder / permission to do
whatever"; kill switch is now `bash tools/auto_stop.sh` / interrupt). **12 new cookbook idioms** distilled
(`commit:0225 commit:0227 commit:0230 commit:0232 commit:0235 commit:0237 commit:0240 commit:0243 commit:0245 commit:0247 commit:0249 commit:0253`); the last CRACKS
a false dead-end — the GTE-`sqr` cop2-nop family was wrongly recorded "unproducible" (objdump elides zero-word runs →
false match_one miss; verify on RAW bytes via `objcopy`). **TWO pool-exclusion bugs FIXED** (`commit:0228`
`plumbing_blocked` scans ALL raw backlog records; `commit:0239` NEW `reserved_walls` skips ≥2×-redrafted near-miss walls)
→ ~149+ churners skipped. **CURRENT:** orch_state `pool=any-reach134 waves=30`; worker continues reach-134 (fresh
`any-reach134` thinning → then `--mode auto`/`--class` to re-attempt reach-134 backlog walls with the 12 new idioms,
each ×134); grinder grinds alongside. NEXT cookbook fuel: the ~7-fn GTE-sqr family (idiom `commit:0253`).

**Fleet ≈ 61.16% byte-identical** *(↑ 61.19% — see SESSION UPDATE above)* · 136/136 binaries byte-identical · 0 NON_MATCHING.
**Nothing running** — grinder STOPPED (Drew; `.run/auto/STOP` present), no worker wave in flight. Paused at a
clean, committed checkpoint (HEAD = the reach-1 handoff commit). Committed locally; **not pushed** (R6 — Drew pushes).

**What this session did (×134 tail harvest → pivot):**
- Worker waves **13–16** on the cached reach-134 fuel: banked **+6** (incl. the 476-ins `func_80141CA4` ×134)
  + 1 grinder bank; **fleet 60.93% → 61.16%**. Yield diminished 3→2→0→1: the reach-134 ≤150-ins cached fuel is
  now **confirmed walls** (§20 IV-combine / LICM-hoist / schedule + DEF-side loose-typing; o0 pool empty; the
  capped-7 = the Phase-16 loose-typing wall). Re-firing them is the poor-ROI anti-pattern (Drew agreed).
- **Guard committed (`commit:0219`):** worker drafters now write ONLY their draft `.c` — a wave-13 drafter had
  appended UNVERIFIED near-miss idioms to the cookbook directly (distill owns the cookbook). See "Open for Drew".
- **PIVOT (Drew's call, gate-2 AskUserQuestion):** stop the reach-134 wall-waves + grinder; harvest the
  **reach-1 (overlay-unique) fuel** instead — abundant, small, far less loose-typed → much higher crack rate.

**★ THE REACH-1 FUEL IS BUILT + WIRED (this session's deliverable — ready for the fresh session):**
- **420 reach-1, region-main, draftable fns in `ov_SC01_077`, ALL cached** (298 prefetched this session via
  headless `DecompileFunctions.java` → `.run/ghidra_c`: 298 ok / 0 fail / 0 no-func). Small: median 47 ins,
  185 ≤40, 251 ≤60, 330 ≤100.
- **`tools/wave_targets.py --pool reach1`** serves them **SMALLEST-FIRST** (new pool, committed). The
  orchestrator's `POOLS` + `.run/auto/orch_state.json` are set to `reach1`, so **`prep --mode pool` serves it
  out of the box**. Verified: prep → clean 24-target batch of 14–15-ins fns; asm + ghidra_c paths resolve.
- **Leverage = ×1** — overlay-unique, so they bank in `ov_SC01_077` only (dedup_propagate skips reach<2, no
  ×134). But `ov_SC01_077` is the largest overlay → 420 small fns ≈ a real fleet chunk (plausibly **+1–3%**).

**THE PLAN — smallest-first idiom-MINING harvest (Drew's design, agreed):** run the same loop on the `reach1`
pool, **distilling after EVERY wave** (this is idiom-mining, not just banking): the tiny fns one-shot for free
%, the small-medium (~30–80 ins) band surfaces fresh gcc idioms → distill → the cookbook grows → bigger reach-1
fns one-shot, AND a new idiom occasionally cracks a reach-134 **wall** (×134 bonus, e.g. the Phase-18 pin idiom).

**FRESH-SESSION CYCLE (Drew starts + controls pacing — full runbook: `docs/automation-runbook.md` §reach-1):**
1. `.venv/bin/python tools/orchestrator.py prep --mode pool --n 24` → reach1 smallest-first batch → `.run/auto/wave_batch.json`.
2. Read the batch; launch `tools/workflows/worker_wave.js` with `args={draftDir:".run/drafts-wave", targets:<batch array PASTED VERBATIM>}`.
3. On completion: `.venv/bin/python tools/orchestrator.py finish --drafts .run/drafts-wave --commit` — **BACKGROUNDED + `dangerouslyDisableSandbox`** (foreground make build/git get sandbox-killed exit 144). Prints `{banked, near, verified, fleet_pct, …}`.
4. **Distill EVERY wave that has `verified` banks:** `tools/workflows/distill.js` `args={draftsDir:".run/drafts-wave", verified:<array>}` (the idiom-mining step).
5. Loop (~17 waves for all 420). close-rate should stay HIGH (small fns) → the orchestrator won't rotate off `reach1`; if it ever does (close-rate <0.15 ×2 → rotates to tractable walls), re-route: set `pool":"reach1"` in `.run/auto/orch_state.json`.
6. **Optional token-free grinder** (parallel, permutes reach-1 near-misses): `rm -f .run/auto/STOP && DRIVER=tools/grinder.py setsid nohup bash tools/auto_supervisor.sh --permute-secs 120 -j 14 >/dev/null 2>&1 &` (dangerouslyDisableSandbox). **STOP all:** `bash tools/auto_stop.sh`. Live %: `make report`.

**More fuel if 420 runs dry:** region `a` (65) + `o0` (8) reach-1 (excluded from the pool — different build paths
/ -O0 handling; add later); the deferred reach-134 walls + capped-7 (hand-finish backlog).

**Open for Drew:** the uncommitted 2 §21 cookbook bullets are **CANDIDATE / unverified** (from near-miss
`func_801775E0`) — marked as such this session; keep/refine/drop. ("Don't start the waves" was this session's
instruction; the fresh session launches them.)

---

## (SUPERSEDED by the REACH-1 HANDOFF above — historical trail) prior ×134 state (2026-06-22 07:40)

> The dated sections lower down (TRIP HAND-OFF, POST-REBOOT RESUME, FRESH-SESSION RUN LIVE, SUSTAINED LOOP,
> OPTION C) are HISTORICAL session-layers, kept for the trail. **This section is the authoritative current state.**

**Fleet: 209,593 / 344,010 = 60.93% byte-identical** · 136/136 binaries byte-identical · 0 NON_MATCHING.
**Nothing running** — grinder STOPPED (`.run/auto/STOP` present; `rm` it to allow relaunch), no worker wave in flight.
The loop is **paused at a clean, fully-committed checkpoint** (HEAD = `commit:0214`). All work committed locally; **not pushed** (R6 — Drew pushes).

**What this (overnight `/loop`) session did** (Drew: "keep waves going, don't stop till I check in ~8h" → ran 12 worker waves + the grinder):
- Fleet **59.05% → 60.93%** (+1.88%); ~55 functions banked (worker gates + 1 recovery gate + 1 grinder bank), each propagated ×134 where shared. dedup groups → 1560.
- **3 gate-safe tooling upgrades** (Option C + follow-ons), all committed:
  - `tools/sig_unify.py` — **DEF-side arity-extend recovery**: adopt the canonical engine_core.h param list on arity mismatch (unused params free at -O2). Banks the DEF-side loose-typing wall. (`commit:0200`)
  - `tools/grinder.py` — **blacklist** of permuter-won-but-gate-rejected (plumbing) fns → `.run/auto/grinder_blacklist.json` (13 fns); stops the futile churn. (`commit:0200`)
  - `tools/wave_targets.py` — **pool excludes self-MATCH-but-gate-rejected** near-misses (closeness==0 OR drafter "none — MATCH" verdict) so waves draft FRESH targets. (`commit:0205`, `commit:0208`)
- **6 new cookbook idioms** (4 distilled + 2 drafter-authored): cookbook §21 + §22. (`commit:0194 commit:0196 commit:0198 commit:0203 commit:0211`)
- **Grinder's work:** banked 1 (`func_801493D0`, permuter), blacklisted 13 plumbing-bound near-misses, token-free. It went 0→1 banks *after* the Option-C fixes.

**Key finding (where the wall is now):** the **tractable reach-134 ≤150-ins pool is depleting** — easy fresh wins are banked; close-rate fell from ~0.25 to **0.037 on wave 12**. What remains in this size-band is the genuine hard tail: DEF-side plumbing (`sig_unify` handles the simple arity case; the rest is multi-way loose typing) + the §20 **IV-combine** (`combine_givs` won't fold byte+halfword-RMW) and **LICM-hoist** (`move_movables` threshold) walls — drafters correctly stub these "unsteerable from C." They are **backlog / hand-finish fuel**, not re-draftable.

**HOW TO RESUME the loop** (the proven cycle; grinder is optional — `rm .run/auto/STOP` then relaunch per `docs/automation-runbook.md`):
1. `rm .run/auto/STOP` (only if relaunching the grinder).
2. `.venv/bin/python tools/orchestrator.py prep --mode pool --n 24` → writes `.run/auto/wave_batch.json`. **Use `--mode pool`** (auto-mode keeps firing class-focused REGALLOC waves on a saturated class; pool harvests fresh). The orchestrator auto-rotates `s["pool"]` tractable→giants→o0 when close-rate <0.15 for 2 waves — **so when tractable yield stays low (it's there now), the next prep will serve `giants`; let it.**
3. Read `.run/auto/wave_batch.json`; launch the `tools/workflows/worker_wave.js` Workflow with `args={draftDir:".run/drafts-wave", targets:<the batch array PASTED VERBATIM>}` (Workflow scripts have no fs access; transcribe carefully).
4. On completion: `.venv/bin/python tools/orchestrator.py finish --drafts .run/drafts-wave --commit` — **run BACKGROUNDED + `dangerouslyDisableSandbox`** (foreground `make build`/`git` get sandbox-killed exit 144; detached daemons escape it). Prints `{banked, propagated, verified, fleet_pct, ...}`.
5. If a *banked* fn flags a genuinely new idiom, launch `tools/workflows/distill.js` with `args={draftsDir:".run/drafts-wave", verified:<array>}` (else skip — distill is conservative; the drafter's "new idiom" claim is often already covered).
6. Loop. The byte-gate (G3/P9) is the sole arbiter; a wrong draft reverts, never banks. Each bank auto-commits.

### ▶ QUEUED 10-HOUR RUN — Drew starts this in the FRESH SESSION (do NOT start now; 2026-06-22 07:45)

Drew's call: **continue** (not close yet) — queue ~10h more of waves + grinder, drawing down the remaining
fuel, then close after. **Everything below is STAGED, NOTHING STARTED** (`.run/auto/STOP` is present; no wave running).

**Fuel verified (all cached — NO MCP/prefetch needed for the run):** tractable **80** + giants **28** + o0 **9**
cached-unbanked non-wall (167 reach-134 total); 563 Ghidra-C cached; 96 walls/plumbing excluded. Grinder has
**21 eligible near-misses** to start on (then self-feeds on each wave's new near-misses). Enough for ~15–20 waves.
**First wave batch staged:** `.run/auto/queued_wave1.json` (23 tractable, = wave 13) — informational; the cycle's
`prep` regenerates it.

**FRESH-SESSION START SEQUENCE (paste in order):**
1. **Grinder** (token-free, detached — run with `dangerouslyDisableSandbox`):
   `rm -f .run/auto/STOP && DRIVER=tools/grinder.py setsid nohup bash tools/auto_supervisor.sh --permute-secs 120 -j 14 >/dev/null 2>&1 & disown`
   (it stops the MCP first — fine, the run is cache-based; monitor `bash tools/auto_status.sh`).
2. **Worker loop** — run the cycle in “HOW TO RESUME” above (prep --mode pool → launch `worker_wave.js` →
   `finish --commit` backgrounded+`dangerouslyDisableSandbox` → distill-if-flagged → repeat) for ~15–20 waves.
   The pool **auto-rotates tractable→giants→o0** as close-rate drops (`low_streak`=1 now; giants is the high-byte-weight
   payoff). Run it as a `/loop` (self-paced) or hand-cycle. **STOP:** `bash tools/auto_stop.sh` + interrupt the loop.

**Expected:** ~+1–2% fleet over the run (diminishing — the hard tail dominates as fuel draws down). Then **T7 (close
Phase 21 → PhaseEnd)** is the natural next step. The byte-gate guarantees correctness unattended; worst case = "it paused."

**Pointers:** runbook `docs/automation-runbook.md` · backlog ledger `docs/backlog.md` (+ `.run/backlog.jsonl`, near-miss drafts `.run/backlog_drafts/`) · diagnostics `.run/{diag_plumbing,repro_gate,test_defsig}.py` (gitignored scratch) · monitor `bash tools/auto_status.sh`.

---

## Locked decisions (AskUserQuestion, 2026-06-21)
1. **Milestone = build→validate→stage, then close.** Sample-validate a few hours hands-on, bank that increment, populate the backlog, close ready-to-launch.
2. **Keep-alive = hybrid.** `/loop` self-pace primary + external `claude --continue` watcher fallback; `auto_stop.sh` = kill switch.
3. **Run posture = balanced, ROI-gated.** Worker waves per-pool until close-rate drops K rounds → route next; free permuter grinder in parallel; everything logs to backlog.

## Architecture (three components, one gate, one ledger)
- **Grinder (token-free)** = existing `tools/auto_driver.py` + `auto_supervisor.sh`, repointed to permute the worker's near-misses + log backlog.
- **Worker (token-heavy, LLM)** = NEW Workflow, parallel drafter agents (`opts.effort:'xHigh'`) using the §17–§20 toolkit → serial gate stage → compact summary.
- **Orchestrator (me, Max)** = ROI loop + hybrid keep-alive; routes pools, banks checkpoints, maintains `docs/backlog.md`.
- Both bank through the same `harvest_verify` gate + `dedup_propagate`; both log to the same backlog ledger.
- Effort: stay at Max all phase; Workflow sets per-agent xHigh (no R26/R27 toggle dance).

## Task checklist
- [x] **T1 — Target-pool manifest + giants byte-verification** (no MCP; Max) → `.run/fuel_manifest.json`; h_exact-verify the 28 giants are genuinely ×134 (R14). **DONE.**
- [x] **T2 — Fuel prefetch → complete Ghidra-C cache** (MCP-stop headless; Max) → `.run/ghidra_c/` cache-complete over the manifest. **DONE.**
- [x] **T3 — Backlog ledger + shared deterministic bank/log stage** (Max) → `tools/gate_stage.py` + `tools/backlog.py` + `docs/backlog.md`; validated on a real 30-draft sample (banked+propagated+logged). **DONE.**
- [x] **T4 — Worker Workflow** (Max; agents xHigh) → `tools/workflows/worker_wave.js` + `tools/wave_targets.py`. **VALIDATED.**
- [x] **T5 — Grinder daemon** (xHigh) → `tools/grinder.py` (permutes backlog near-misses → gate_stage) + `auto_supervisor.sh` (DRIVER-param). **VALIDATED.**
- [x] **T6 — ROI orchestrator + hybrid keep-alive + launch** (Max) → `tools/orchestrator.py` built; **the worker `/loop` RAN — 12 waves across 2026-06-21→22, fleet 59.05%→60.93%** (see ★ CURRENT STATE). Worker driven by Workflow-completion (not the hybrid keep-alive); grinder ran detached. **DONE.**
- [ ] **T7 — Stage ready-to-launch + Phase close (PhaseEnd)** (Max, Tier-1) — pending Drew's gate-2 milestone confirmation. The "build→validate→stage" milestone is met; closing is defensible (see ★ CURRENT STATE open decision).

**Current task:** paused at a clean checkpoint after 12 worker waves (fleet 60.93%). NEXT = Drew's call (rotate worker to `giants` pool / other band / **close Phase 21 → T7 PhaseEnd**). See ★ CURRENT STATE & FRESH-SESSION RESUME at the top.

## Verification invariant (every banked step + at close)
`make clean && (extract all 136) && make check-all` → 136/136 byte-identical (R22); `make report` → 0 NON_MATCHING (G4), `dedup-check 0 failed`.

### T4/T5/T6 — worker + grinder + orchestrator (2026-06-21, trip-imminent push)
- **T4 worker Workflow** (`tools/workflows/worker_wave.js`): parallel xHigh drafter agents, each given the asm + cached Ghidra-C + the §17–20 toolkit; writes its best C; orchestrator gates after. `tools/wave_targets.py` selects the batch (ROI pool). **args gotcha (§20): the harness serializes args to a JSON STRING → the script parses it.** VALIDATED: a 3-target wave → all 3 self-MATCH; whole-binary gate **banked func_80164530 ×134** (5 register-pins + offset-fold + scheduling — a hard toolkit match), 1 near + 1 failed logged. ~275k tokens / 13 min for 3 agents. fleet 58.90→**58.98%**.
- **T5 grinder** (`tools/grinder.py`): token-free — permutes backlog near-misses (close≤30) → gate_stage → bank; STOP/heartbeat, idles for new worker fuel. VALIDATED: permuter WON func_8014F3E8 but the whole-binary gate correctly REJECTED it (§20 — match_one/permuter over-predict; gate is truth; integrity intact, 0 wrong banked). `auto_supervisor.sh` now `DRIVER`-parameterized (launch grinder under it).
- **T6 orchestrator** (`tools/orchestrator.py`): `prep` (pick ROI pool → emit wave batch) / `finish` (gate_stage → record close-rate → rotate pool when tapped) / `status`. Pool rotation tractable→giants→o0→capped, ROI-gated (threshold 0.15, patience 2). The model launches the Workflow between prep/finish (the one step only it can do).
- **gate_stage flock**: grinder + orchestrator gates serialize on `.run/auto/gate.lock` (one build/commit at a time — safe concurrency).
- **SANDBOX finding:** foreground Bash-tool builds (`make build`/`git`) get killed (exit 144) by the sandbox; **detached daemons (setsid/nohup) escape it** — so the launched grinder/orchestrator build fine; interactive gates need `dangerouslyDisableSandbox`.

## TRIP HAND-OFF (2026-06-21) — what's running, what's staged

**Status:** the automation manager is BUILT + VALIDATED end-to-end; fleet **58.82% → 58.98%** (3 real
matches banked during validation: func_801710DC, func_80164530, + the T3 sample; all ×134, 136/136
byte-identical). Drew is travelling **with remote access** to this dev box.

**RUNNING NOW (autonomous, token-free):**
- The **grinder** (`tools/grinder.py` under `tools/auto_supervisor.sh`, launched detached) — permutes the
  backlog's closest near-misses → byte-gate → banks → ×134; idles for worker fuel; supervisor relaunches
  on crash. Monitor: `tools/auto_status.sh`. Stop: `tools/auto_stop.sh`.

**STAGED (Drew drives remotely — the high-yield token engine):**
- The **worker** waves: `tools/orchestrator.py prep` → launch the `tools/workflows/worker_wave.js`
  Workflow → `tools/orchestrator.py finish --commit`. Run it via **`/loop`** (the runbook has the exact
  cycle prompt). ~24 xHigh agents/wave, ~275k tokens/wave; ROI-gated pool rotation. **The full runbook
  is `docs/automation-runbook.md`.**
- An in-flight 16-target worker wave (`.run/drafts-wave2`) was launched at hand-off; gate it with
  `tools/orchestrator.py finish --drafts .run/drafts-wave2 --commit` (or it's the first thing the /loop
  picks up).

**Why safe to leave running:** the whole-binary byte-gate (G3/P9) is the sole arbiter — a wrong draft is
reverted, NEVER banked; `make check-all` stays 136/136; every bank is a checkpoint commit (push is manual,
R6); `auto_stop.sh` halts at the next safe boundary. Worst case of any crash = "it paused," never "it broke."

**Phase close:** T7 (formal PhaseEnd) awaits Drew's gate-2 milestone confirmation on return. Until then this
file + `docs/automation-runbook.md` are the durable state. Sandbox note: detached daemons build fine;
interactive build gates need `dangerouslyDisableSandbox`.

## POST-REBOOT RESUME (2026-06-21) — the learning flywheel + ready for the fresh-session run

After the reboot (BIOS startup-on-power-loss configured; Drew has remote access):
- **R1 — gated the 15 pre-reboot drafts:** banked **4** (func_80156FA8/801678F0/80156848/8017742C; 2 propagated
  ×134); backlog 30→41. R22 check-all **136/136**. (The standalone gate was killed pre-commit twice — a harness
  quirk on detached `nohup gate_stage` runs; recovered by committing the working tree. Does NOT affect the
  orchestrator, which calls gate_stage **in-process**.)
- **R2/R3 — the learning flywheel (Drew-approved):**
  - Residual gcc-quirk class now **travels with the draft**: the drafter stamps `// @class` / `// @stuck`;
    `gate_stage` logs the worker's class (not the coarse manifest class) → enables class buckets.
  - **Class-grouped waves:** `wave_targets.py --class <C>` / `--list-classes` (REGALLOC/SCHEDULE/REMAT/STRUCT/
    IV/LOOPGUARD/LOOSE/PLUMBING). `orchestrator prep` auto-fires a class-focused re-attempt wave when a class
    accrues ≥6 near-misses (drafters get the prior stuck-point), else a fresh pool harvest.
  - **Distill** (`tools/workflows/distill.js`): post-wave agent extracts NEW byte-verified gcc idioms → cookbook
    §21 (R16, conservative); drafters read the **live** cookbook so idioms feed forward (the Phase-18 loop, automated).
- **R4 — grinder relaunched** (token-free); fleet **59.05%** (phase: 58.82→59.05, +0.23%, 5 fns ×134); 136/136;
  tree clean. **Ready for Drew's fresh session to run the worker `/loop`** (this session is at low context).

**Fresh-session launch (Drew):** start a Claude Code session here → run **`/loop`** with the cycle in
`docs/automation-runbook.md` (prep → worker_wave Workflow → finish gate → distill). The grinder is already
running alongside. Monitor: `bash tools/auto_status.sh`. Stop: `bash tools/auto_stop.sh`.

## FRESH-SESSION RUN LIVE (2026-06-21 ~14:40 — Drew away ~8h, remote access)

Drew launched the unattended grind ("run the worker /loop cycle, then start the grinder; I'll check back in ~8h").
Both engines are RUNNING:
- **Worker** — wave 1 launched as Workflow `wx91bmadi` (run `wf_b173a013-d6a`): 24 xHigh drafters over the
  **tractable** reach-134 pool (nins 93–142). The loop is driven by **Workflow-completion notifications** (not a
  polling timer): on each wave's completion the orchestrator runs `finish --commit` (gate→bank→propagate ×134→
  backlog), `distill` if anything verified, then `prep`+launches the next wave. Race-free (one wave at a time;
  `prep` rm-rf's `.run/drafts-wave`). ROI-gated pool rotation via `orch_state.json`.
- **Grinder** — relaunched detached (was dead post-reboot, heartbeat 24 min stale): supervisor pid 2573950 +
  `grinder.py` pid 2574026, `--permute-secs 120 -j 14`, token-free, draining the backlog near-misses.
- Fleet at launch: **59.05%**, 136/136 byte-identical, 0 NON_MATCHING. Gate (G3/P9) is the sole arbiter — a wrong
  draft is reverted, never banked; worst case of any crash is "it paused."
- Monitor: `bash tools/auto_status.sh`. Stop both: `bash tools/auto_stop.sh` (then `rm .run/auto/STOP` to resume).
- **Sandbox note (R/§ build-infra):** my foreground `make build`/`git` calls get sandbox-killed (exit 144) →
  `orchestrator.py finish` and any commit run with `dangerouslyDisableSandbox`; detached daemons (grinder) escape it.

**Run progress (worker waves):**
| Cycle | Wave drafted | Byte-banked | Fleet | Commit |
|---|---|---|---|---|
| 1 | 24 (19 self-MATCH) | 7 (4 ×134) | 59.05→59.21% | `commit:0193`; distill `commit:0194` (cookbook §21 added) |
| 2 | 24 (18 self-MATCH) | 5 (4 ×134) | 59.21→59.37% | `commit:0195` |
| 3 | 24 (17 self-MATCH) | 7 (6 ×134) | 59.37→59.60% | `commit:0197`; distill `commit:0198` |
| recovery | 7 close=0 re-gated | 2 (×134) | 59.60→**59.68%** | `commit:0199` (sig_unify DEF-side fix) |
- **Distill flywheel:** 3 NEW byte-verified cookbook idioms added across the 3 waves (`commit:0194` Blk16/memcpy
  unaligned-copy; `commit:0196` disjoint-bits add→ori re-tie barrier; `commit:0198` giv-anchor store-order).
- **Wave-2 "6.5h" was NOT throttling** — it was idle on a CC **permission prompt** (Drew approved on check-in);
  waves 1 & 3 ran in ~25–32 min. (R14: corrected my earlier rate-limit read.)

## OPTION C — grinder fix + DEF-side recovery (Drew-approved, 2026-06-21 ~22:50)
The grinder had banked **0 in ~8h**: stuck re-permuting 2 plumbing-bound near-misses (`func_8014F3E8`,
`func_8014FE60`) — permuter "wins" them (base already masked-0) but the whole-binary gate correctly rejects every
cycle; after idle it did `tried.clear()` and looped forever (§20 trap). Fixed BOTH halves of option C:
- **(a) `tools/grinder.py` blacklist:** record every permuter-won/gate-rejected fn → `.run/auto/grinder_blacklist.json`,
  skip permanently, survives restarts. Frees its CPU for genuine regalloc/schedule near-misses. Grinder restarted with it.
- **(b) `tools/sig_unify.py` DEF-side fix:** diagnosed the wide self-MATCH→bank gap as the **DEF-side loose-typing
  wall** (draft's byte-correct def has FEWER params than engine_core.h's canonical cross-overlay decl →
  `conflicting types`). `rewrite_def` previously only rewrote params on arity MATCH (return-type-only fallback
  otherwise). Patched it to **adopt the canonical param list on arity mismatch** (draft names + synth `_argN` for
  the unused extras; they sit in `$a0–$a3`, free at -O2). Validated: banked `func_8016EDEC` + `func_8016EE40`
  through the real gate (`commit:0199`). **Compounds: it's in the gate pipeline, so every future wave + the grinder
  now auto-recover DEF-side near-misses.** (Remaining close=0: a data-conflict + narrow-param arity gcc's
  promotion rule blocks + multi-way loose typing — genuinely harder, diminishing returns.)

**Session totals (2026-06-21):** 3 worker waves + recovery → **21 fns banked**, fleet **59.05% → 59.68%** (+0.63%),
136/136 byte-identical (per-bank gate G3/P9; full check-all deferred to a checkpoint), 0 NON_MATCHING, 3 new
cookbook idioms, grinder + sig_unify both upgraded. Diagnostics in `.run/{diag_plumbing,repro_gate,test_defsig}.py`.

## SUSTAINED LOOP (2026-06-21→22, Drew: "keep waves going, don't stop till I check in ~8h")
Continuous worker loop running, driven by Workflow-completion (NOT a timer): per wave →
`orchestrator.py finish --commit` (gate+bank+propagate ×134) → `distill.js` if verified → `orchestrator.py prep
--mode pool --n 24` → launch `worker_wave.js` with the batch pasted **verbatim** from the compact dump (Workflow
scripts have no fs access; transcribe carefully). Gate/finish run **backgrounded + dangerouslyDisableSandbox**
(foreground `make build`/`git` get sandbox-killed exit 144). Grinder runs alongside (token-free, blacklist-aware).
- **POOL-mode override (policy):** auto-mode keeps firing class-focused REGALLOC waves, but that class has
  saturated with permuter-class/DEF-side-plumbing residuals agents can't crack from C → low yield. Use
  `prep --mode pool` to harvest FRESH reach-134 targets (higher yield); leave regalloc residuals to the grinder
  (permuter) + backlog (hand-finishing). The DEF-side `close=0` set (func_80174CB0/80169228/80167714 …) won't bank
  via re-drafting — they're hand-finish fuel.
- **Running tally (this session, fleet 59.05% start):** waves 1-6 launched; banked via worker gates + the sig_unify
  recovery. Fleet **59.87%** after wave 5 (wave 6 in flight). 4 new cookbook idioms distilled
  (`commit:0194 commit:0196 commit:0198 commit:0203`). Commits `commit:0193…commit:0202` + option-C `commit:0200`.
- **To resume after compaction:** read this section + `docs/automation-runbook.md`; the next step is always
  gate the in-flight wave (`.run/auto/finish_wave<N>.log` / orchestrator finish) → distill → prep --mode pool →
  launch. Stop only when Drew says so (`bash tools/auto_stop.sh` halts the grinder).

## Blockers
(none — grinder running blacklist-aware + enhanced sig_unify; worker loop sustained per Drew until check-in.)

## Per-task log

### T1 — fuel manifest + giants byte-verification (DONE, 2026-06-21)
- New tool `tools/build_fuel_manifest.py` → `.run/fuel_manifest.json` (gitignored, regenerable). reach RECOMPUTED from the current 134 overlay sigs (distinct-overlay h_exact histogram), not trusted from cached fields (R14).
- **803 live func_ stubs** classified: GIANT 28, WAVE 425, STRUCT 148, PINS 104, STUB 88, O0 9, O1 1 (+1 named stub `listCdBuffer` skipped). Reach buckets: 310 reach-134, 486 reach-1 (overlay-unique), 7 partial.
- **R14 giants: 28/28 verified genuinely reach-134** (byte-identical ×134 — the giants' label is honest, unlike the -O0 cluster). Top leverage: func_80144B9C (770 ins), func_80141CA4 (476), func_80132784 (400).
- **R14 -O0 nuance (byte-finding):** 8/9 -O0 stubs are overlay-local (reach-1, matches Phase-20), but **func_8013C08C is reach-134** — a genuine exception to the blanket "overlay-local" assumption (propagatable ×134 if matched).
- **T2 workload:** 253 reach-134 stubs uncached (of 310); tractable reach-134 (WAVE/PINS/STRUCT ≤150 ins) = 223, 171 uncached; giants 25/28 uncached. Ghidra-C cache currently 300.
- No MCP, no build mutation. Checkpoint commit: tool + this log.

### T2 — fuel prefetch → Ghidra-C cache complete (DONE, 2026-06-21)
- Stopped MCP (R23, clean Save). Headless `analyzeHeadless ... -process ov_SC01_077 -readOnly -postScript DecompileFunctions.java <addrs> .run/ghidra_c` over the **263 uncached ROI-pool fns** → **263 ok / 0 fail / 0 no-func**. Cache 300 → **563**.
- **Naming bug found + fixed:** Ghidra emits `FUN_<lowerhex>` (raw-import default); consumers + the 300 existing files use `func_<UPPERHEX>`. Renamed the 263, and **fixed `DecompileFunctions.java` to key output by entry address (`func_<UPPER>`)** so re-prefetch is reproducible. Added `build_fuel_manifest.py --emit-prefetch` (reproducible addr-list for the T7 runbook).
- **T2 verification (cache-complete):** ROI-pool fuel = **325 fns, ALL cached, 0 uncached** (28/28 giants, 310/310 reach-134, 7/7 capped). The unattended run will never need live MCP.
- Scope (P9): 349 reach-1 ×1-leverage fns intentionally NOT prefetched (not in the ROI pool rotation: tractable reach-134 → giants → -O0 → capped). A later prefetch can add them if ever needed.
- MCP left STOPPED (the run is cache-based; the grinder supervisor stops it anyway). `ghidra/ db.*.gbf` churn is the MCP-stop's no-op SLUS save — R23 restart-noise, NOT staged.
- Checkpoint commit: `DecompileFunctions.java` + `build_fuel_manifest.py` + this log (cache + manifest are gitignored/regenerable).

### T3 — backlog ledger + shared deterministic gate stage (DONE, 2026-06-21)
- **`tools/backlog.py`** — the near-miss ledger (`.run/backlog.jsonl` append + `docs/backlog.md` ranked render). Ranks by reach → closeness → size; **drop-now-matched** filter (a banked fn leaves the backlog, P9). Tested: append/render/show + drop-matched all correct.
- **`tools/gate_stage.py`** — the shared deterministic spine (worker + grinder call it): drafts → `canon_resident_calls → cast_call_sites → sig_unify → harvest_verify --chunk 1 → dedup_propagate --auto-from` → log non-matches to backlog → compact JSON summary. Byte-gate is the sole arbiter (G3/P9).
- **Validated end-to-end** on a real 30-draft m2c sample of reach-134 main WAVE stubs → `{drafts:30, banked:1, propagated:2, near:20, failed:8}`. **func_801710DC banked + propagated ×134** (dedup 1506→1508, every ov_*.c touched); **29 near-misses logged + ranked** (top: func_80174684 close=0 "MATCH but plumbing", func_8014F3E8 close=1; captured the §20 unsteerable regalloc class func_80149374/801493D0). All paths exercised: bank→propagate→log→render→summary.
- **R22: `make check-all` → 136/136 byte-identical**; `make report` → fleet **58.82% → 58.90%** (+0.08%, the func_801710DC ×134 increment), `dedup-check 1508 validated / 0 failed` (G3/P9). A real, byte-gated increment — kept.
- **Capped-fns reframe (R14):** the 7 capped are matched-**inline** (propagation-blocked on undeclared callees/data), NOT draftable stubs — so they don't flow through the gate stage's draft path; the plan's "warm-up on the 7 capped" premise was slightly off. The stronger honest validation is the real 30-draft sample above. The capped propagation-recovery is **deferred to the worker** (T4 re-drafts them through gate_stage's recovery pipeline; the manifest's `capped_recovery` documents them). Not claiming the unbanked ~+0.3% (P9).
- Best-draft `.c` files saved to `.run/backlog_drafts/` (local, gitignored — Drew accesses them on this machine; `docs/backlog.md` is the committed index).
- Checkpoint commit: the 2 tools + `docs/backlog.md` + the func_801710DC match & ×134 propagation (src/ov_*, engine_core.h, dedup.us.yaml, progress digests) + this log.