mirror of https://github.com/Druthulu/BFM-decomp synced 2026-09-27 22:45:39 -04:00

Files

T

Drew T b8ee9fa9d2 feat(phase-29 Task-13B): directed permuter wins first try; 3 latent gate defects fixed at root

First run of the Task-13A-targeted grinder (--once --batch 8 --permute-secs 90):
  targeting: ON — 1665 classified; only bucket=permuter is admitted
  targeting skipped 1601 non-permuter candidates
    {redraft 707, structural 583, integration 305, unclassified 4, unknown 2}
  permuter WON func_80181F78 @ ov_SC03_014 (close was 1)   [~6 min]

BANKED 2 (both whole-binary byte-gated, R22 clean-fleet 140/140):
- func_80181F78 (8 ins)  — classified DELAY-SLOT / schedule
- func_80141B90 (29 ins) — classified IMM-VALUE / cse
Both were classified bucket=permuter by residual_class BEFORE the run: the classifier
predicted a search-closer could reach them, and one did. First end-to-end validation of
the targeting thesis.

THREE latent defects, all pre-existing, all unreachable while the grinder banked nothing
since Phase 21 — the fix made it win and every one fired at once (cookbook §60a):

1. gate_stage commit path crashed on src=None. `src` is DELIBERATELY never defaulted
   (Phase 26-A: a default silently PINS the gate to the main .c), but the commit did
   `git add src …` unconditionally -> every caller that omits it (grinder, orchestrator,
   idiom_hunt) crashes THE MOMENT IT BANKS. Now `git add -u src/`, which also retires the
   `src/ov_*/*.c` filename glob that once omitted 4 R22-verified banks from a commit.
2. _xform ladder dirs (-cn/-cast/-rc/-uni) ACCUMULATE across runs: they held 34 stale
   drafts, so the gate processed 34 when the grinder submitted 1, and banked one function
   it was never asked to try — which would have been committed under a message naming a
   different one. Nothing wrong entered the tree (G3/P9 held; the gate banks only
   byte-identical output) but report and work had diverged. Now cleared per run.
3. grinder called gate_stage with the default propagate=True = `dedup_propagate
   --auto-from`, the §55b fleet-wide path that timed out at 3600s and left 90/140 overlays
   broken — and being INSIDE the gate it takes the banks down with it. Now propagate=False;
   banks commit cheap, propagation is its own targeted --addr batch (§55b law).

R22: make clean && extract-all && check-all -> 140 passed, 0 failed of 140.
tools-health OK (dedup 1847/0, C1 234343/234343); 0 NON_MATCHING (G4).

2026-07-21 11:24:48 -06:00

71 KiB

Raw Blame History

CURRENT PHASE — Phase 29: The Family Campaign (cores + members)

Opened: 2026-07-16 · Effort: Max · Generation: Gen2 (21st phase of the arc) · Baseline: PhaseEnd_Phase28 (v1.27.0) · Roadmap: docs/roadmap-to-100.md §3 P29 Plan approved (P3 gate 1): 2026-07-16. Full plan mirror: ~/.claude/plans/max-effort-plan-mode-mutable-castle.md (out-of-repo; this file is the in-repo authority + crash-recovery log).

Fleet at open: 68.9% instr-weighted / 49.5% distinct-code / 83.94% fn-count · 140/140 byte-identical · 0 NON_MATCHING · dedup 1840/0.

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

Fable5 = reserved for NEW wall classes only (default cheap-Opus + permuter). Window ~7/19.
Scope = a longer multi-session campaign (drive both tracks substantially down before closing; ROI-gated on per-session yield floors; velocity + 3 metrics reported each session).

The one question this phase must answer first

The swing number: does the legacy PURE-non-jr h_seq tier (~95 families / ~7,993 members / ~478k ins, ~3.6 pp) template mechanically (⇒ one exemplar crack banks ×137) or not? Phase-28 measured ~3% as-tooled with 274 genuine gate-DIFF members that are byte-PURE (reloc-only) at the same vram — so either (a) the remap is incomplete (fixable; ceiling ≫ 3%) or (b) it's a TU-context regalloc wall (3% real). Task 1's disambiguating probe decides it before any yield arithmetic scales (R14/R35). Every prior "structural wall" (B2, SC07, pin-crash) resolved to (a).

Standing invariants (every task)

Whole-binary byte-gate is the sole arbiter (G3/P9); match_one/closeness/h_seq are candidates.
R22 clean-fleet per banked batch: make clean && make extract-all && make check-all → 140/140.
make tools-health green + fail-closed before matching (corpus · cdecl · audit-binaries(R36) · report/lint/dedup-check).
§53 carve law: has_mid_jr families → jtbl_family_bank.py, never carve-less family_sweep.
Predictions gate-validated on a SAMPLE before scaling; verify the TOOL before trusting its scan.
Flywheel: idioms → cookbook + tooling in-session (R16/R30); pivots → decision-log (R31).
Effort/model transitions prompted, never assumed (R26/R27) — STOP + WAIT for the toggle.
One commit per task after this file's update; Drew pushes (R6/R20). R23 no-op on db.*.gbf.

Task checklist (current-task pointer = ▶)

Task 1 — T3b disambiguating probe: build tools/diff_regions.py + the swing verdict [Max] ✅ VERDICT: (a) TOOLING — an -O0 compile-flag artifact, NOT a regalloc wall. The two families supplying ~272 of the 274 DIFF (0x8013c964, 0x8013c938) are -O0 functions; family_sweep --hseq compiled them -O2 (member stub files are -O2). Compiled -O0 they masked-MATCH. 106-member sample (nins 2..133): O0-FLAG 45 · already-banked 29 · TEMPLATES 17 · type-lift-plumbing 15 · REGALLOC 0. Ceiling ≫ 3%; the pool is back on the table. → calibration.md + decision-log.md. (masked-MATCH = candidate; whole-binary bank is Task 2a's gate, §52b.)

🛑 SESSION CHECKPOINT (2026-07-17) — safe to open a FRESH session here. Tree clean, 140/140 byte-identical, tools-health green, dedup 1843/0, 0 NON_MATCHING, main 143dbb89. Fleet: 71.4% instr · 53.3% distinct-code · 86.42% fn-count (opened at 68.9/49.5/83.94). Tasks 1, 2, 3, 6 DONE. Remaining: Task 4 (member harvest behind each crack + grinder family-warm-start + the 2 Phase-22 grinder bug-fixes), Task 5 (fleet Ghidra-C prefetch — needs /mcp, R23/R29), Task 7 (burn-down tracker + ROI-gated close). THE HIGHEST-VALUE NEXT MOVE: bank the 12 preserved giants in .run/giants/p29t3_README.md — all match_one-MATCH or near, each with its exact blocker and a cheapest-first order (func_8013FAF8 312 = pure def-sig plumbing is the best value). They cost ~~2.6M agent tokens; banking is plumbing, not drafting. Also carried: the 2 local-type-blocked cores (func_8014E284, func_80137DD4) need the build_engine_types type-lift to propagate ×137 (~~+276 instances, ~0 tokens). READ FIRST: cookbook §55b (the gate-orchestration law) — --no-propagate per group → commit the banks → THEN one targeted dedup_propagate --addr (~233s/core). It is the distilled cost of ~3.5h I lost this session.

Task 13A — deterministic residual→class classifier + the corpus it reads [Max] ✅ 2026-07-21 residual_class.py + autopsy.py + corpus.is_o0; grinder targeting wired (1,303→78). FINDING: only 75/972 (7.7%) of the grinder-admissible backlog is permuter-shaped — the problem was TARGETING, not a missing transform. R22 140/140. Cookbook §60 + decision-log + SETUP.
▶ Task 13B (RE-SCOPED) — run the DIRECTED permuter over the 75, then autopsy what actually plateaus — the LLM batch autopsy is deferred until genuine plateaus exist (R35: do not diagnose a search that never ran under correct targeting). Then Task 14 (gate_stage ladder §57/§59 — priced by the 1/12 probe).
Task 2 — Act on the verdict [Max/xHigh] — branch = 2a (tooling). Build the -O0-cluster split rollout (adapt rollout_whale_o0.py → per-overlay [0x13410,c,<ov>_o0] carve, -O0 Makefile rule) + teach family_sweep --hseq per-member opt-level awareness; WHOLE-BINARY gate one overlay (convert the verdict to a banked fact), then fleet + the type-lift sweep. member_adapt.py NOT needed for this pool. Originally: (2a) extend family_remap.symbol_map + re-run the legacy-PURE family_sweep --hseq (the ~478k-ins mechanical win); OR (2b) build tools/member_adapt.py (exemplar→member delta engine + per-member delta briefs); OR both.
Task 3 — Core-crack track: fresh exemplar + B3 near-miss cracks [Ultracode/xHigh/Max] — top substantial stub exemplars (non-jr 0x80176734/0x80176218/0x8013faf8/0x8014d820/ 0x801670e4/0x80140958; jr via jtbl_family_bank 0x8013f350/0x80131340/0x80159c84/ 0x8013c414) + B3 high-close near-miss cores (func_8014F4C0 127, func_80137DD4 107, func_8014E284 83, func_80177940 65, func_801387B8 50, func_8014ADE0 19, func_801325B8 4). FRESH re-drafts only (0/958 stored are dead). Add a family_sweep has_mid_jr interlock. Fable5 for NEW walls only (prompt Drew).
Task 4 — Member harvest behind each crack + grinder family-warm-start [xHigh/Ultracode] — propagate members per Task-2's mechanism; build the grinder family-warm-start + 2 Phase-22 bug-fixes (split-file-blind lookup; churn-without-blacklist).
Task 5 — Fleet Ghidra-C prefetch (JIT drafting fuel) [xHigh; MCP: R23/R29 — prompt /mcp] — built only when Task-3 waves exhaust the ~300-fn cache.
Task 6 — Mechanical mass: tiny-IMM mega-pools + permuter backlog sweep [Ultracode/permuter] — 0x80131eec (2,887×15) + 0x80130d0c (2,679×15) via imm_map; the 550 close-1..4 backlog drafts via grinder/permuter_ils.
Task 7 — Burn-down tracker + velocity/3-metric report + ROI-gated close [Max] — close when per-session yield across both tracks floors out; Roadmap delta; hand P30 an honest frontier.

OUT of scope: parallel gate farm (bulk_harvest already is it) · family-adapt fine-tune (bounded, conditional) · main-EXE/B9 + GLM/B6 + resident's 14 walls (P30) · behemoths B7 + walls B8 (P31).

Blockers

(none — Arm B substantial-band sweep running in background as of 2026-07-16)

Task 2 progress (in flight)

Verdict → branch 2a (tooling). Sized the fix: Arm A (-O0 cluster carve) = 9 families / 1,233 stub members / ~24k ins (~0.6pp), needs a per-overlay -O0 carve tool (adapt rollout_whale_o0.py; the -O0 cluster 0x13410..0x14834 is deferred-since-Phase-19). Arm B (-O2 type-lift sweep, EXISTING family_sweep --hseq --no-preclassify) = 398 families / 7,541 stub members / ~520k ins (~4pp) — the ROI winner; unbanked pool concentrates in the 4 newest (SC07) overlays.
Arm B gate-probe (10 families): BANKED 32/40 = 80% — gate-validated (R14). Substantial band alone = 76 banks (size-dependent: substantial is pin/drift-limited, 1,799 pinned skips). Comprehensive --band all --allow-pins sweep then banked across ~140 overlays (891 src files) before a SIGTERM (exit 143) interrupted it mid-gate (during/after ov_SC07_006 346/570). Triage: 3 clean single-binary rebuilds all BYTE-IDENTICAL → the incremental banks survive R22.
✅ ARM B CHECKPOINT COMMITTED (2026-07-16). R22 clean-fleet verify = 136 PASS / 1 FAIL; the FAIL (ov_SC07_010, the SIGTERM mid-gate partial) reverted → byte-identical. 3,407 member-matches banked across 136 overlays. make check-all → 140/140 byte-identical; dedup-check 1840/0; audit-binaries OK; audit-cdecl green. Fleet: instr-weighted 68.9→70.2% (+1.3pp) · distinct-code 49.5→51.9% (+2.4pp) · fn-count 83.94→84.73% (+0.79pp); 0 NON_MATCHING (G4).
⚠️ LESSON: --band all sweeps are too long for one background pass (SIGTERM'd). Future Arm B runs go band-bounded + committed-per-batch (resumable). The comprehensive sweep still had residual FAILED members (pin/drift/plumbing) not yet re-attacked.
✅ ARM B TAIL FINISHED (2026-07-16). Band-bounded family_sweep --hseq --allow-pins in 3 clean bounded passes (substantial 53 + mid 372 + tiny 323 = 748 member-matches), the SIGTERM lesson applied (each band completed exit 0). All 748 confined to the 4 undermatched SC07 tail overlays (the files=1 ones): ov_SC07_010 897→516 (+381) · ov_SC07_011 797→436 (+361) · 006 457→454 (+3) · 007 595→592 (+3). Verified pure-reduction (0 NEW stubs, 0 dup INCLUDE_ASM). 006/007's residual is jr-families (§53 carve → Task 3) + plumbing/DIFF — the plain-sweep tail is drained. R22 clean-fleet 140/140 byte-identical; audit-binaries OK; dedup-check 1840/0; main 143dbb89. Fleet: instr 70.2→70.4% · distinct-code 51.9→52.3% · fn-count 84.73→84.94%; 0 NON_MATCHING linked (G4).
✅ ARM A: swing verdict CONFIRMED as a BANKED FACT (2026-07-16). Built tools/rollout_o0_cluster.py (the -O0-cluster carve, adapting rollout_whale_o0.py) + the Makefile O0_CLUSTER_OBJS -O0 wildcard. On ov_SC07_010 the carve is byte-neutral and family_sweep --hseq banked 9/9 of the -O0 exemplar families' members whole-binary (R22 clean-fleet 140/140) — so the -O0 cluster members DO bank at -O0, not just masked-MATCH (§52b candidate → fact; Phase-20's "func_8013B7AC overlay-local" also refuted). BUT the fleet-scale carve hits a splat-integration wall: the same carve on 006/007/011 byte-shifts the whole image (+0x20 data-symbol shift, 34% diff) from a CLEAN build — a splat %lo re-disassembly sensitivity (boundaries verified correct), the Phase-20 "-O0 split infra" wall now characterized. Full -O0 fleet rollout (~1,233 / ~0.6pp) DEFERRED on ROI: 3/4 sampled overlays walled + 134 overlays have the cluster inside the jr_801380E0 carve + bigger levers wait. Details → docs/decision-log.md. (c) opt-level awareness is moot — the -O0-ness is per-FILE via the Makefile rule; family_sweep/stub_map already route to the carved split. Hindsight fix logged: mirror the whale's shared-header _o0b shape.
TASK 2 SUBSTANTIVELY COMPLETE. Arm B tail (748 members) + Arm A (verdict = banked fact). NEXT: Task 3 (core-cracks + B3 near-misses) and/or Task 6 (tiny-IMM mega-pools ~5,566 members) — the bigger levers.

Per-task log

(appended after each task; the crash-recovery trail — becomes phase-ends/logs/Phase29.md at close, R19)

2026-07-18 — jtbl 8-align fix OPENED (Fable5 Max, plan approved). Plan mirror: ~/.claude/plans/fable5-max-set-jtbl-ancient-marble.md. ⚠️ CORRECTION of the session-2 checkpoint's half-pin (R35/R14 — do NOT re-trust it): the claim "cc1 AND maspsx both emit the jtbl .align 2" is INVERTED, and both preserved probes (.run/probe_jtbl_{cc1,maspsx}.s) are VACUOUS (empty j $31 fn, no jtbl). True chain (byte-grounded this session): (1) Sony cc1 emits .align 3 before EACH jump table in .rdata (clean jr_8012ACE0.o has .rodata sh_addralign=8 w/ a single 51-entry table); (2) maspsx passes .align through VERBATIM (maspsx/__init__.py:872-873 output catch-all; the L435-437 continue is an inventory-only pass — jtbl_carve.py:132's "maspsx drops .align" docstring is FALSE); (3) as bakes the pad SECTION-RELATIVE (intra-object, linker can't remove); (4) placement is always tight (SUBALIGN(2) fleet-wide + ld_interleave ALIGN(.,4) — the 0xb07dc 4-mod-8 carve proves it); (5) original semantics: separate TUs pack TIGHT (078→144 abutment), intra-TU tables 8-align w/ real zero-word pads (tail2.data.s 8158/8170/8188/81A0). THE BUG: merging originally-separate TUs into one decomp TU fires an intra-TU .align 3 where the original had a tight TU boundary → +4 at rodata 0xCC → image-wide %lo shift (build_g2.log SHA1 FAIL). THE FIX (red-team-hardened, empirically pre-verified): pad-spec filter tools/jtbl_rodata_pads.py (post-maspsx, per-object JTBL_PADS make var, fail-loud guards) + jtbl_carve interval-arithmetic specs + merge relaxation (gap 4 must be verifiably zero) + revert/stale-.o coverage + jtbl_family_bank stub_file uniqueness assert (yesterday's ladder failure spliced into a stale _a.c duplicate stub — byte-witnessed in bank_func_80131340.log). Isolation is NOT general (as aligns section-relative; a 4-mod-8-start multi-table object mis-pads internally) — kept as NON-CONTIGUOUS fallback.
✅ 2026-07-18 — jtbl §8e fix BUILT + fleet-neutral (Steps 1-3 of the approved plan). Honest probes persisted (.run/probe_jtbl/verdict.md + objdumps; the vacuous pair deleted): cc1 .align 3 per table (2 tables → 2 aligns, byte-listed), maspsx verbatim passthrough in situ, the +4 pad materialized at object rodata 0xCC (0xE4 verbatim), as-controls (bare rodata → Al=4; +.align 3 → Al=8). Built: NEW tools/jtbl_rodata_pads.py (spec-driven align→pad-bytes replacement; guards byte-tested rc=1 ×3; pad=4 direction synthetically proven), jtbl_carve.py (spec-aware merge: gap∈{0,4-zero-checked-in-payload}, interval-arithmetic pads CARRIED never re-derived, JTBL_PADS target-var emission into overlays.mk + revert() restore + stale-.o invalidation, honest docstring), Makefile $(if $(JTBL_PADS),…) stage + env-shield default, jtbl_family_bank.stub_file duplicate-stub fail-loud. Object-layer byte proof: filtered .rodata = 0xE0, table 2 TIGHT at 0xCC = the merged carve span exactly. Dry-run build_carve → span 0xaff20..0xb0000 spec [0,0] as designed. R22 clean-fleet WITH the fix wired: 140/140 byte-identical, tools-health green (dedup 1846/0, C1 234205/234205), zero new banks — fleet-neutral. Flywheel captured in-session (R30): cookbook §8e + §8a/§8a-pad corrections, decision-log entry, SETUP.md row. NEXT: Step 4 — bank func_80131340 ×1.
✅ 2026-07-18 — func_80131340 (424) BANKED ×1 — the first 4-mod-8 non-first jtbl bank ever (§8e live). Draft spliced at the L1635 slot (stub 0, def 1); jtbl_carve --func func_80131340 → merged span 0xaff20..0xb0000 + JTBL_PADS := 0,0 (stale-.o auto-invalidated); make extract + whole-binary gate → [ OK ] d19c9580 == check (build log .run/bank_80131340_build.log). Production object proof: .rodata 0xE0 / Al=4 / table 2 TIGHT at 0xCC — the filter ran in the real pipeline. NEXT: Step 5 — ×137 family sweep (jtbl_family_bank --raw).
✅ 2026-07-18 — func_80131340 family COMPLETE ×138 (the §8e mechanism's ×N proof): 137/137 siblings BANKED, 0 failed. 3 bounded chunks (50+50+37, committed per chunk commit:0680/commit:0681/commit:0682), every sibling whole-binary gated, per-sibling §8e carve+JTBL_PADS auto-derived from each overlay's own island addresses. R22 clean-fleet: 140/140 byte-identical; tools-health green; dedup 1846/0. Fleet 72.1→72.5% instr · 54.0→55.0% distinct-code · 86.61% fn-count (~+58.5k ins from one family — vs the B2 precedent's 102/115 this ran 138/138). NEXT: Step 6 — the 3 remaining giants (59C84 → F350 (pad=4 spec case!) → C414 -O0).
✅ 2026-07-18 — THE JTBL 8-ALIGN CAMPAIGN COMPLETE (Steps 4-7): 4 giants ×1 + 3 families swept; fleet 72.1→73.4% instr (+1.3pp — the checkpoint's +1..1.5pp ceiling hit in one session). Banked: func_80131340 (424) 138/138 (0 fail) · func_80159C84 (337) 134/138 (isolate path + the FIRST pad=4 spec; 4 SC07 residuals named) · func_8013F350 (490) 138/138 (0 fail — the 4-table [0,0,4,0] span, tables= persistence, --like structure transfer ×137, §30#2 fleet-widen ×267) · func_8013C414 (329, -O0) ×1 (family name-deferred: uniform -O2 gate-fail — rides the Arm-A -O0-cluster rollout wall, NOT codegen). ≈ +165k ins total. BATCH R22: check-all 140 passed, 0 failed of 140; tools-health green; dedup 1846/0; 0 NON_MATCHING. Fleet 73.4% instr · 56.9% distinct-code · 86.69% fn-count (session opened 72.1/54.0/86.57). Sweep lessons distilled (§8e-2, R30): the CLEAN-DRAFT law (59C84 went 3/8→100% once the exemplar's canonical-form reconciles were mirrored into the --raw draft — diagnosed by ONE failed-sibling re-run, §55b); zero-word spec rule + tables= persistence + --like role-transfer (built after the F350 pre-§8e merged-double archaeology); the SC07 _o2b composition class (fail-loud, 4 overlays); commit-per-chunk sweeps with auto-commit chaining. Tooling: jtbl_carve span-structure engine + jtbl_rodata_pads filter + jtbl_family_bank --like/stub-uniqueness (commits commit:0678..commit:0696). Burn-down residuals (named): 4× SC07 59C84-members (o2b span composition) · 137× C414 members (-O0 rollout dependency) · the -O0 cluster rollout itself (Arm-A splat wall). Ghidra-C/Task-5, permuter backlog/Task-6-tail, Task-7 ROI-close remain the open phase items.
2026-07-16 — Phase opened. Session Start Protocol complete (all 28 PhaseEnds + roadmap + calibration + decision-log read). 3 Explore surveys grounded the plan (tooling state, frontier data, idiom bank). Plan approved at Max/plan-mode. Beginning Task 1.
2026-07-16 — Task 1 DONE (the swing RESOLVED = (a) tooling). Built tools/diff_regions.py (composes family_remap.remap_hseq + match_one + masked_diff; auto-detects the exemplar's -O0 opt from the Makefile rules). Byte-proof: the 274-DIFF pool is dominated (~272) by two -O0 families the sweep compiled -O2; at -O0 they masked-MATCH. 106-member sample across nins 2..133 → 0 REGALLOC walls; all failure modes recoverable tooling (-O0 flag / already-banked / template / type-lift plumbing). Verdict + byte evidence → docs/calibration.md (swing RESOLVED section) + docs/decision-log.md (R31). §52b caveat: masked-MATCH is a candidate — Task 2a whole-binary-gates the -O0 split rollout. Run artifacts in .run/probe29/.
2026-07-16 — Task 2 (Arm B tail) DONE. Resumed the interrupted comprehensive --band all sweep as 3 band-bounded passes (substantial/mid/tiny, --allow-pins, each exit 0 — the SIGTERM lesson) → 748 member-matches banked across the 4 files=1 SC07 tail overlays (010 +381, 011 +361, 006 +3, 007 +3), each whole-binary-gated by harvest_verify (G3/P9). R22 clean-fleet 140/140 byte-identical; fleet instr 70.2→70.4% / distinct 51.9→52.3% / fn-count 84.73→84.94%; audit-binaries OK, dedup 1840/0, main 143dbb89, 0 NON_MATCHING (G4). Verified pure-reduction (0 new/dup stubs, R14/H5). Logs .run/armB_tail_{substantial,mid,tiny,checkall}.log. NEXT: Arm A (-O0 cluster carve) + item (c).
✅ 2026-07-16 — Task 6 tiny-IMM mega-pools CRACKED (+4,801 members). 0x80131eec (2887) + 0x80130d0c (2679) went from 1/4966 (0.0%) to pool1 2331/2470 (94%) + pool2 2470/2496 (99%) = 4,801 banked. Root cause (byte-proven after 3 masked-metric mis-reads — R14/R35, see decision-log): NOT a symbol-definition gap (my commit:0665 scout was WRONG) — it's a def-signature conflict: engine_core.h forward-declares the member (extern void func_8015FAAC(s32 *a0), a shared fn calls it) while family_remap copies the EXEMPLAR's sig (void *a0) → conflicting types → the member TU never compiles (invisible to standalone diff_regions/match_one AND to --reconcile). FIX: new family_sweep --fix-def-sig (header_sig_map + reconcile_def_sig, 1005 mapped fns) rewrites the member draft's def sig to the shared-header canonical — byte-neutral, gate-arbitrated (G3/P9); one member hand-verified byte-identical first. R22 clean-fleet 140/140; pure-reduction (0 new/dup stubs); fleet instr 70.4→71.0% · distinct 52.3→53.2% · fn-count 84.94→86.30%; dedup 1840/0; 0 NON_MATCHING. §54 cookbook + R31 decision-log. The 4th "reproduce the build step" instance (§53-carve, -O0-flag, now the member's canonical DECLARATION). --fix-def-sig likely should be default-on for the h_seq path.
✅ 2026-07-17 — Task 4 giants #2 (func_8014F4C0) BANKED + PROPAGATED ×134. func_8014F4C0 (141) banked ×1 in ov_SC01_077_after.c (its earlier "gate reject" was pure §55b propagate-damage — it gated clean on the healthy tree, no fleet change needed). h_exact family → dedup_propagate --addr 0x8014F4C0 --recover (ov_SC01_000 straggler; --recover reconciled conflicting caller externs, kept it) = 134 overlays byte-identical after propagation, +1 dedup group registered. R22 clean-fleet 140/140; ~+19k ins. §55b honored (targeted --addr, fail-closed, committed as its own batch). GIANT TAXONOMY (the session's key finding): the 12 giants split into NON-jtbl (func_8013FAF8, func_8014F4C0 — bank clean once the tree is healthy + propagate ×137 via macro/h_seq alone) and jtbl (func_80131340/func_80159C84/func_8013C414/func_8013F350 — each needs a per-overlay jtbl carve ×137 AND hits an 8-align tooling gap). func_80131340 DEFERRED with a precise root cause: gcc emits a non-first jump table .align 3 (8-aligned) but the original island packs it 4-aligned → +4B padding → island +4 → every downstream data symbol shifts → %lo relocs break image-wide (+5B, 3077 diffs, byte-proven). A jtbl_carve 8-align/isolation fix would unlock ~4 giants × ~137 members — a real lever, flagged as a distinct tooling task.
✅ 2026-07-17 — func_8013FAF8 PROPAGATED x137 (h_seq family sweep) → giant DONE fleet-wide. h_seq (not h_exact, so dedup_propagate refused it: reach<2); path = family_sweep --hseq --only 0x8013FAF8 --allow-pins (per-overlay symbol remap). First sweep 0/137: family_sweep copies the exemplar's extern block VERBATIM and my hand-crafted exemplar had 4 callee externs diverging from the fleet-canonical (func_8005A600 void→s32, func_80024054 s32→void*, func_80137D08 s32*→int, func_8013AB54 s32*→s32) → every member conflicting types. Aligning those 4 in the COMMITTED exemplar .c to the member-consensus form (byte-neutral; ov_SC01_077 stays byte-identical) → re-sweep 137/137 banked, 0 failed. +312 ins x137 ≈ +42.7k ins. R22 clean-fleet 140/140. Cookbook §56b (exemplar-externs-must-be-canonical for h_seq; contrast dedup_propagate --recover which auto-reconciles CALLER externs). Both NON-jtbl giants now fully banked+propagated (func_8013FAF8 x137, func_8014F4C0 x134); the 4 jtbl giants stay deferred on the 8-align carve gap.
✅ 2026-07-17 — 2-core type-lift + propagate x138 each (func_8014E284 108, func_80137DD4 129). Both were banked x1 in Task 3 but dedup_propagate skipped them ("not self-contained: local types"). Lifted EntSC01077 (func_8014E284) + P_TAG_80137DD4 (func_80137DD4) into src/shared/engine_types.h (fleet-included via engine_core.h) and inlined func_80137DD4's file-local #define OTE into the body (byte-neutral macro expansion, re-evaluated per use to preserve codegen) → both self-contained → dedup_propagate --recover = 138 overlays byte-identical, 0 stragglers, 2 new dedup groups. ~+32.7k ins. R22 clean-fleet 140/140; dedup 1846/0; C1 234205. Cheap carried Task-3 win closed (§55c local-type cap lifted for these 2).

🛑 SESSION-2 CHECKPOINT (2026-07-17) — supersedes the checkpoint above; safe to open a FRESH session here. Tree clean, 140/140 byte-identical, tools-health green, dedup 1852/0, 0 NON_MATCHING. Fleet 72.1% instr · 54.0% distinct-code · 86.57% fn-count (session opened 71.4/53.3/86.42 → +0.7pp instr). This session banked ~94k ins across 4 fns ×~137 overlays: func_8013FAF8 (312) ×137 + func_8014F4C0 (141) ×134 (the 2 NON-jtbl giants, fully done) + func_8014E284 (108) ×138 + func_80137DD4 (129) ×138 (the 2-core type-lift). Commits commit:0673, commit:0674, commit:0675 + the type-lift commit (Drew pushes). Cookbook §56/§56b added. THE TEED-UP NEXT TASK (Drew-directed): the jtbl 8-align tooling fix — unblocks the 4 remaining giants (func_80131340/func_80159C84/func_8013C414/func_8013F350), ceiling ≈ +1 to +1.5pp instr (biggest lever left). Root cause HALF-PINNED (do not re-derive): cc1 AND maspsx both emit the jtbl .align 2 (correct) — the +4B 8-align pad is a downstream as/ld_interleave artifact. START from .run/giants/p29t3_README.md (the STATUS section — full findings, probes at .run/probe_jtbl_*.s) + cookbook §8/§8a. Step 1: pin as section-align vs interleave; Step 2: fix jtbl_carve to pack the non-first jtbl 4-aligned; Step 3: prove x137 on func_80131340 before scaling. Also open: Task 6 permuter backlog, Task 5 Ghidra prefetch (needs /mcp), Task 7 ROI-close.

2026-07-17 — Task 3 core-crack wave: 13 agents → 7 MATCH → 5 BANKED ×1. Ultracode worker_wave (13 xHigh drafters over 6 cores 260–371 ins + 7 B3 near-misses 100–141 ins; all had cached Ghidra-C). Wave hit a usage limit at 2/13, resumed cleanly (cached agents replay) → 13/13 done: 7 match / 6 near. BANKED (whole-binary, R22 clean-fleet 140/140): func_8014ADE0 (139), func_8014E284 (108), func_80137DD4 (129), func_801325B8 (113), func_801387B8 (100). Near (2 of the 7): func_8013FAF8 (312 giant — def-sig s16/s16 vs fleet-canonical s32/s32 plumbing), func_8014F4C0 (byte-verified in-TU; a decl conflict fix_arity_callers didn't resolve). Fleet 71.0% instr / 53.3% distinct / 86.30% fn-count. NEW levers to distill (R16/R30): §49-variant birthing-boost suppression via reg_n_sets 1→2 (func_801325B8); sched1 birthing/LUID + cc1 -dL movable introspection (func_80177940); switch-tree vs jtbl CASE_VALUES_THRESHOLD (func_801387B8).
⚠️ 2026-07-17 — THREE tooling traps hit in the T3 gate (all mine; ~3.5h lost, no data lost): (1) gate_stage propagate is FLEET-WIDE (dedup_propagate --auto-from), so running gate_stage per-src-group ran it 4× redundantly; 3 hit the 3600s timeout → partial propagate damage: 90/140 overlays broken, 887 files, engine_core.h +561. → Always --no-propagate per group, then ONE targeted dedup_propagate --addr <banked> at the end. (2) A reverted src needs a RE-EXTRACT (R22 corollary): git checkout -- src left asm/ in the banked state (no .s for banked fns) → corpus.CorpusError: 5 stub(s) have NO .s on disk (R34's second oracle caught it — working as designed). (3) gate_stage's default .run/harvest_verified.txt ACCUMULATES across runs and its CLI exposes no --verified-out → it reported a phantom banked:1 for a function still stubbed in src (stale residue of a reverted run). Trust the SOURCE, not the report (R32/R35 class — still armed). Sequencing law learned: COMMIT the cheap verified banks BEFORE the expensive propagate, else every propagate failure takes the banks with it.
✅ 2026-07-17 — PROPAGATE DONE + a self-correction (R14/R35). Dry-run plan = 3 of 5 cores self-contained (0x8014ADE0/0x801325B8/0x801387B8, 138 members each ≈ 414 instances); 2 skipped (local types → needs the build_engine_types type-lift). Straggler ov_SC03_093 forces --recover (h_exact share is all-or-nothing). CORRECTION: my earlier "needs ~2h+" was WRONG — that timing came from propagating into the tree still carrying the killed---auto-from damage (90/140 broken), so every member-gate was failing/retrying. On a healthy tree a targeted --addr propagate is ~233s/core ([ OK ] 138 overlays byte-identical) — ~20× faster. Only --auto-from is genuinely fleet-slow. A timing taken on a broken tree measures the breakage, not the tool (§55c).
✅ 2026-07-17 — TASK 3 COMPLETE (both deliverables) + 12 giant drafts preserved. (a) The jr cores — 4/4 match_one MATCH, 0/4 banked (integration, not codegen). A 2nd ultracode wave cracked all four giants: func_8013F350 (490), func_80131340 (424, verified TWICE — standalone AND in-TU cc1 rc=0), func_80159C84 (337), func_8013C414 (329, -O0). All four gate-rejected on plumbing (def-sig / rodata-island / decl-conflict), each blocker NAMED. func_8013C414 only matched because of the new worker_wave --o0 fix — against an -O2 self-check a -O0 target can never match (the §53/§54 wrong-build-step trap, Task-1's "~3%" artifact). Drafts + exact blockers + a suggested cheapest-first bank order → .run/giants/p29t3_README.md (12 drafts, tracked; ~2.6M agent tokens to reproduce — do NOT re-draft, bank them). (b) The §53 has_mid_jr INTERLOCK — BUILT + negative-control-proven (commit:0670): family_sweep now refuses to sweep a has_mid_jr family carve-less, names jtbl_family_bank, and states that a 0% from that path is a TOOL ARTIFACT not a wall. Uses the manifest's has_mid_jr (R33 — one oracle, shared with dedup_extend). Verified: 11 jr families / 163 slots of 1418 sweepable; --band substantial skips 9 families / 155 slots (159→150); --allow-jr → 159 (does not skip). It flags 0x8017bebc (n=115) = B2 — the very family whose missing carve manufactured the Phase-26 "≈0%" doctrine. That class of self-inflicted wall is now structurally impossible.
2026-07-16 — broad --fix-def-sig harvest = TAPPED beyond the mega-pools (+19). Fleet-wide --band substantial (17) + --band tiny (2) with --fix-def-sig (all families, not just the 2 pools) = 19 more members banked (the def-sig conflict was highly concentrated in the 2 tiny-IMM mega-pools; 8491 tiny members now skip as not-stub). R22 clean-fleet 140/140; fleet instr 71.0% (steady) / distinct 53.2→53.3% / fn-count 86.30%. Task 6 mega-pool track COMPLETE. Remaining Task 6: the permuter backlog sweep (the 550 close-1..4 drafts via grinder/permuter_ils) — separate track, not yet run.
2026-07-16 — Task 2 (Arm A) DONE = swing verdict → banked fact + wall characterized. New tool tools/rollout_o0_cluster.py + Makefile O0_CLUSTER_OBJS -O0 wildcard. Carved 4 SC07 tail overlays; byte-neutrality gate (clean R22): ov_SC07_010 byte-identical, 006/007/011 FAIL (+0x20 splat data-symbol shift, boundaries verified — the Phase-20 splat "-O0 split infra" wall, not the compiler). Kept 010's carve, reverted the 3; family_sweep --hseq --only <9 -O0 exemplars> --band all banked 9/9 -O0 members in ov_SC07_010 whole-binary → the -O0 cluster masked-MATCHes ARE real banks (§52b fact). R22 clean-fleet 140/140 byte-identical; fleet 70.4% instr / 52.3% distinct / 84.94% fn-count; dedup 1840/0; main 143dbb89. Full -O0 fleet rollout DEFERRED (splat wall on 3/4 + jr-embedded on 134 + ROI vs Task 3/6). R31 writeup in docs/decision-log.md. Logs .run/armA_*.
✅ 2026-07-17 — Task 4 giant-bank #1: func_8013FAF8 (312) BANKED ×1 in ov_SC01_077 (whole-binary byte-identical; R22 clean-fleet 140/140). The README billed it "pure def-sig plumbing" but it was a multi-symbol reconciliation (3 data + 2 fn conflicts, ~5 gate iterations) — distilled to cookbook §56. Fixes, all byte-neutral + gate-arbitrated: (1) def-sig s16/s16 vs canonical s32/s32 → narrowed the extern fleet-wide (404 decls / 266 files; NOT --fix-def-sig — that rewrites the DRAFT to the canon and the s32 variant diverges at insn 22; verified via match_one R35). All callers pass (s16)-cast/small-const → neutral. (2) 3 data-symbol conflicts (D_80115128 lh, D_800B9A02 lhu, D_80187AC0 s32[]) declared BEFORE the splice (block-scope §55a-blocked) → the TU's §18 cast-at-use-site convention (*(s16*)&, *(u16*)&, ((s32*)&sym)[i]) — forces the load width regardless of decl signedness, keeps the TU decl untouched, propagation-safe. No CSE-hoist across 5 uses. (3) 2 fn-extern conflicts (func_8013FFD8 s16 arg0, func_80141100 int(int)) → reconciled draft decl to the TU def + byte-neutral call-site cast. Still MATCH 312/312. Stubs 138→137, defs 1, 0 NON_MATCHING (G4). Resolved draft .run/drafts_faf8/func_8013FAF8.c. NEXT: giant #2 func_80131340 (424, _jr_8012ACE0.c — in-TU-verified twice, earlier "gate reject" was a §55b propagate-damage artifact; re-gate on the clean tree). Propagation of all banked giants = batched (§55b).
✅ 2026-07-18 — CRACK-WAVE (Ultracode, 7 fresh-core agents, ~2M tokens): 3 MATCH / 4 near; 1 family banked ×138. Fan-out over the top unbanked substantial families (m2c + §31 map + gcc-2.7.2 source + match_one). MATCH: func_8013CB84 (249, non-jr) → banked ×138 (5-lever crack: §32 struct-base-hoist + §18 address-caching + packed-struct block-move + 1-arg-callee + Rec12 stride array; §8d reconcile D_801DAA78 Rec9→u8 cast-at-use). func_8015B950 (271, jr) + func_8013B83C (272, jr-O0) — MATCH but DEFERRED on real walls (8015b950 = def-side register-threading: canonical (void) vs def-reads-$a0, thin-wrapper caller func_8015BEE4 forwards $a0 implicitly, pin perturbs codegen; 8013b83c = Arm-A -O0 sweep-block + -O0 jr-isolation gap). Both preserved+characterized (.run/giants/wave_func_*.c, R20). Near (permuter/Fable5 fuel, rich probes): func_8012956C (15), func_8013D53C (27, CSE address-merge — literal-probe gives structural match, family-wide), func_80175DA8 (30), func_80135EB0 (36, jr). Permuter: func_8014D820 33→27 (regalloc-order wall → Fable5 seed, preserved). CRACK-WAVE SWEEP LESSON (new memory + §-note): a freshly-cracked exemplar is draft-ov077 in the stale map → family_sweep finds 0; --reconcile-raw mishandles per-overlay externs (0/137). FIX: bank ×1 → make sig-overlays + family_hseq.py regen (→matched-ov077) → standard family_sweep --hseq --only (137/137). BATCH R22: check-all 140/140 byte-identical; tools-health green; dedup 1846/0. Fleet 73.4→73.7% instr · 56.9→57.5% distinct · 86.73% fn-count. Commit commit:0699.
✅ 2026-07-18 — CRACK-WAVE 2 + FABLE AGENTS + TYPE-LIFT RECOVERY (Ultracode→xHigh). Fleet 73.4→74.6% instr. Two Opus crack-waves (15 fresh-core agents) + 3 Fable5 agents (gcc-2.7.2 source-readers) + a permuter track. Wave-1: func_8013CB84 (249) MATCH → banked ×138. Wave-2 (8 non-jr cores 93-209 ins): 6 MATCH (8016cbc0/8015ea3c/8015d738/8015f448/8014ffdc[×276]/801412a8) + 2 near (80175ab8=58, 80178004=39). Fable5 (each read the compiler source): 3 MATCH — func_8013D53C (240, the cse.c cross-statement address-CSE wall: *(S9*)(&D_801DA998+0x20) never unifies with SYMBOL_REF while gas folds %hi/%lo(sym+k) byte-identical — NEW family-portable idiom), func_801670E4 (279, post-reload scheduler boost-kill re-ties), func_8012956C (226, 4 stacked mechanisms incl. the reorg j-slot-steal barrier) — plus 2 near driven far closer (8014D820 33→11, 80175DA8 30→11, permuter/Fable seeds preserved). BANKED: 8 exemplars ×1 (all but 801412a8) + ~815 members swept: first sweep 538 (4 clean families: 8015ea3c 134 / 8015d738 134 / 8015f448 138 / 8014ffdc 135) + type-lift recovery (8012956c 137/137, 801670e4 partial 4). R22 clean-fleet 140/140 byte-identical; tools-health green; dedup 1846/0; 0 NON_MATCHING. Fleet 74.6% instr · 59.4% distinct-code · 86.92% fn-count (crack-wave arc start 73.4/56.9/86.61; session-total 72.1→74.6 = +2.5pp instr). Commits commit:0699..commit:0708. NEW LESSONS (R30): (a) crack-wave sweep needs a map-regen step (freshly-cracked exemplar is draft-ov077 → family_sweep finds 0; bank ×1 → sig-overlays + family_hseq.py → matched-ov077 → standard sweep). (b) The reconcile ladder (cast_call_sites→reconcile_tu→scope_data_externs) handles most, but recurring manual fixups: func_80161208/func_801670E4 all-decls-normalized-to-no-proto (a reconcile re-adds a file-scope prototyped decl that poisons every no-proto call), scalar-typedef strip, §17a-1 fn-ptr casts, local-typedef uniquify vs same-file siblings. (c) Type-lift recovers clean-TYPE families 137/137 (Blk16_956C/Ent_956C, SVec/Fr → engine_types.h, byte-neutral) but NOT def-sig/per-sibling-decl-conflict families. CARRIED FOLLOW-UPS (all preserved, R20): (1) 801670e4/8016cbc0 — type-lifted but the sweep hits a per-sibling decl-conflict (see BUILD SPEC below). (2) 8013d53c family — void* def-sig caller-decl thread per sibling. (3) 801412a8 — §29 narrow-u16-param def-side wall (caller decl int; matching adds masking). (4) permuter/Fable fuel: 8014d820 (11), 80175da8 (11), 80175ab8 (58), 80178004 (39). Drafts in .run/giants/{wave2_,fable_,.close11}.
▶ NEXT-SESSION BUILD SPEC — the sweep DECL-NORMALIZE enhancement (Drew-directed 2026-07-18; effort Max). The problem, byte-verified: family_sweep --hseq templates the banked function F's DEF into each sibling TU, but the sibling's own already-banked callers may carry a block-scope decl of F whose signature differs from F's canonical — a HARD conflicting types. Byte-proof (func_801670E4, sibling ov_SC01_004): the sibling's caller has extern void func_801670E4(struct Entity_80167540 *, s32, s32, s32); (jr_8015AE2C.c:5076) while F's canonical/def is s32 func_801670E4(s32,s32,s32,s32) (engine_core.h:19003) → 133/137 fail. Crucially the EXEMPLAR's copy of that same caller used a fn-ptr CAST instead of a decl (ov_SC01_077 jr_8015AE2C.c:5338: ((void(*)(struct Entity_80167540 *,s32,s32,s32))func_801670E4)(...)) — different overlays' callers were matched in different C forms, so the conflict is per-sibling, invisible in the exemplar. Same root as the func_80161208 ×1 whack-a-mole (a callee declared inconsistently → a reconcile re-adds a file-scope prototyped decl that poisons every no-proto call). THE FIX (a per-sibling decl-normalize pass — the SAME-FUNCTION analog of tools/cast_call_sites.py, which only does the CALLEE direction): after templating F into the sibling, scan the sibling TU for EVERY decl of F (block- or file-scope) whose sig ≠ F's engine_core canonical; for each, rewrite the decl to canonical (or drop it) AND fn-ptr-cast the associated call site(s) so codegen is byte-neutral (§17a-1). Generalize to conflicting CALLEE decls too (func_80161208 class: normalize all decls of the callee to the canonical/no-proto form; a reconcile that re-adds a file-scope prototyped decl must be suppressed). Whole-binary gate is the sole arbiter (G3/P9) — the pass only needs to make it COMPILE; wrong casts fail the gate. WHERE: a new stage in tools/family_sweep.py's per-sibling ladder (raw→scoped→recovered→reconciled), or extend tools/reconcile_tu.py/cast_call_sites.py. Model it on cast_call_sites.py (decl→canonical + cast). VALIDATE on: re-sweep func_801670E4 (expect ~137; type-lift already committed) then func_8016CBC0 (also type-lifted-needed — lift Blk_8016CBC0 + Mtx8_8016CBC0 first, byte-neutral, like 8012956c). 8013D53C is a DISTINCT class (void* def-sig where the sibling CALLER declares/calls F(void) — needs the def-sig+caller thread, not this pass). Reproduce a failure fast: family_sweep --hseq --only 0x801670E4, then manually splice a .run/sweep/<ov>/func_801670E4.c staged draft into the sibling stub + make build BINARY=<ov> to read cc1. Est. reward: ~+300-400 members (801670e4 + 8016cbc0 + the residual SC07 tails) ≈ +0.7pp. Cookbook §-note when done.
✅ 2026-07-18 — DECL-NORMALIZE ENHANCEMENT BUILT + VALIDATED: func_801670E4 family 4→137/137 (+133 banked, 0 failed). Built tools/normalize_self_decls.py — the third §17a-1 direction (cast_call_sites = callee decls in the DRAFT; reconcile_tu = data decls in the DRAFT; this = F ITSELF, declared divergently by the sibling TU's OWN already-banked callers). fix(tu_text, fn, ref_decl): drop each decl of F incompatible with F's def (cdecl.compatible oracle; skips no-proto void f() which never conflicts, §51g) + cast its in-scope calls to the dropped sig (scope via cdecl._masked brace-depth). Wired into family_sweep --hseq as --normalize-self-decls (new per-sibling stage after reconcile_def_sig; edits the sibling TU FILE = harvest_verify's baseline, like edit_remap_sweep) + a snapshot/final-SHA-MISMATCH revert backstop (a MISMATCH ⇒ transform bug — a wrong DRAFT is always reverted by harvest_verify, so only a non-neutral TU edit can MISMATCH). Byte-proof before the tool existed: manually dropped the ov_SC01_004 decl + cast the call + spliced F's def → fresh build (output removed first — dodged the §42b STALE-binary false-pass) BYTE-IDENTICAL. Survey: all 133 still- stubbed siblings carried the identical block-scope extern void func_801670E4(struct Entity_80167540*,s32,s32,s32). R14 CORRECTION (do not re-trust the confound): my first repro added --fix-def-sig, which renamed F's def params to a0..a3 while the body used arg0..arg3 → arg0 undeclared (a DIFFERENT bug — the "rare name mismatch" reconcile_def_sig's own docstring warns of). The raw draft def s32 func_801670E4(s32 arg0,…) is already type-compatible with canonical (param NAMES are irrelevant to a C prototype), so this family needs NO --fix-def-sig — the caller-decl conflict is the SOLE blocker. Sweep family_sweep --hseq --only 0x801670E4 --band substantial --allow-pins --no-preclassify --normalize-self-decls → 133/133 banked, 0 failed, 0 backstop fires; 0 func_801670E4 stubs remain fleet-wide. R22 clean-fleet 140/140 byte-identical; tools-health OK (dedup 1846/0, C1 234205/234205); 0 NON_MATCHING linked (G4). Fleet 74.6→74.9% instr · 59.4→60.1% distinct · 86.92→86.96% fn-count (~+37k ins). Cookbook §57 (R30). R14 finding for Task-4/8016CBC0: survey proved its 137 members have NO divergent self-decl — it is TYPE-LIFT-blocked (6-typedef cluster Rec_/Blk_/SVEC_/CLR_/ Poly_/Mtx8_8016CBC0), a DIFFERENT lever (like 8012956c), NOT this pass. Route by the real cc1 error, not by "stuck 137-family." NEXT: the func_8016CBC0 type-lift (separate commit) + the 8013D53C void*-def-sig class + the permuter/Fable backlog.
✅ 2026-07-18 — func_8016CBC0 TYPE-LIFT + sweep COMPLETE ×138 (the separate lever the R14 survey predicted). Confirmed the survey: func_8016CBC0's 137 members are NOT self-decl-blocked (§57) — blocked purely on the exemplar's 6 local typedefs (Rec_/Blk_/SVEC_/CLR_/Poly_/Mtx8_8016CBC0). Lifted all 6 VERBATIM into src/shared/engine_types.h (marked "Phase-29 crack-wave lift (func_8016CBC0 family)" section, fleet-visible via engine_core.h) + removed the locals from the exemplar TU (ov_SC01_077_jr_8016AB6C.c). Verified no fleet name-collision (all 6 exclusive to the exemplar, grep) and byte-neutral (exemplar overlay rebuilds byte-identical d19c9580). Sweep family_sweep --hseq --only 0x8016CBC0 --no-preclassify --normalize-self-decls → 137/137 banked, 0 failed (--normalize-self-decls a correct no-op here — 0 divergent self-decls, as surveyed); 0 func_8016CBC0 stubs remain fleet-wide. R22 clean-fleet 140/140 byte-identical; tools-health OK (dedup 1846/0, C1 234205/234205); 0 NON_MATCHING linked (G4). Fleet 74.9→75.1% instr · 60.1→60.6% distinct · 86.96→87.00% fn-count. Session-total (both families): 74.6→75.1% instr (+0.5pp), 59.4→60.6% distinct (+1.2pp), +270 members — the decl-normalize win (§57, +133) and the type-lift win (+137) from the SAME BUILD-SPEC validation set that looked like one "stuck 137-family" but needed two different levers. NEXT: 8013D53C (void*-def-sig + caller-thread class), the SC07 tails, permuter/Fable backlog. ⚠️ COMMIT GOTCHA (caught + fixed by amend): a family's members do NOT all live in the same-named split file — SC07 overlays carve func_8016CBC0 into jr_8013F350.c/o2b.c, not jr_8016AB6C.c. A filename-glob git add "src/ov_*/*_jr_8016AB6C.c" silently missed 4 R22-verified banks. Use git add -u src/ (all modified tracked) for sweep commits, never a split-name glob — else a pushed tree omits banks the R22 verified.

🛑 SESSION-3 CHECKPOINT (2026-07-18) — safe to open a FRESH session here. Tree clean (only db..gbf R23 churn), 140/140 byte-identical, tools-health OK (dedup 1846/0, C1 234205/234205), 0 NON_MATCHING (G4). Main commit:0712. Fleet 75.1% instr · 60.6% distinct-code · 87.00% fn-count (session opened 74.6/59.4/86.92). This session delivered the DECL-NORMALIZE ENHANCEMENT (Drew's teed-up BUILD SPEC) + banked both its validation families: func_801670E4 4→137/137 (+133, the new §17a-1 self-decl pass, tools/normalize_self_decls.py + family_sweep --normalize-self-decls, cookbook §57) and func_8016CBC0 1→138/138 (+137, a 6-typedef engine_types.h lift — the R14 survey proved it was a DIFFERENT blocker than it looked). +270 members, +0.5pp instr, commits commit:0711 + commit:0712 (Drew pushes). NEXT levers (BUILD SPEC residue): func_8013D53C (the DISTINCT void-def-sig + per-sibling caller-thread class — NOT the self-decl pass), the SC07 span-composition tails (§8e-2), and the permuter/Fable close-1..N backlog (Task 6). The decl-normalize pass is now a standing family_sweep stage for any future family whose members' own callers declare F divergently.

✅ 2026-07-18 — BROAD SWEEP (honest yield +137) + func_8013D53C (14/137) + NSD HARDENED (2 bug-fixes). After the SESSION-3 checkpoint: ran the broad substantial-family sweep, then attacked func_8013D53C. All findings → cookbook §57a. (1) The substantial-family frontier is NOT broadly mechanical (R14/R35): 60 families / 2,169 stubbed members STAGE but only 137 bank with --fix-def-sig — staging ≠ banking; I over-projected ~1,500 from the staged count instead of gate-probing a sample (the phase's own invariant, violated). Banked func_801502EC ×134 + func_80131B14 ×3 (commit commit:0714). (2) NSD is SURGICAL-ONLY: broad --normalize-self-decls (esp. combined with --fix-def-sig, which changes NSD's reference sig) makes byte-neutral-but-wrong TU edits that poison whole (overlay,split) groups — the backstop reverts them (0 false banks) but banked 7 / reverted 752. --fix-def-sig edits DRAFTS (bisect-safe per member) so it IS broad-safe. Law: NSD per-family, --fix-def-sig broad. (3) NSD HARDENED — 2 real bug-fixes (validated on D53C): rewrite-to-canonical instead of DROP (dropping broke def-AFTER-caller forward visibility → func undeclared); and (void) is a genuine 0-param conflict, NOT skippable like a true no-proto () (the bug that filed D53C's arity class as "not this pass"). (4) func_8013D53C = PARTLY-mechanical: NSD + a byte-neutral Cmd_8013D53C type-lift clear its plumbing → 14/137 bank (the h_seq members whose bodies template); 123 carry genuine per-member codegen DIFFs (the hard cse.c-wall crack does not fully template → permuter/Fable fuel). Reverted the 123 bankless NSD edits (byte-neutral but churn on matched code — §57a NB). R22 clean-fleet 140/140; tools-health OK (dedup 1846/0, C1 234205/234205); 0 NON_MATCHING (G4). Fleet 75.2% instr · 60.6% distinct · 87.04% fn-count. SESSION-TOTAL from 74.6/59.4/86.92: +0.6pp instr, +1.2pp distinct, ~+421 members across 4 commits (commit:0711, commit:0712, commit:0714, + this). REFRAME (the session's strategic finding): the family campaign is per-family cracking, not one broad sweep — each substantial family carries its own blocker (self-decl / type-lift / def-sig+caller / genuine codegen), and the mechanical fraction is small (~137 broad + 14 D53C). Remaining Task-4/6 levers: the permuter backlog (551 close-1..4 drafts, high-reach) + per-family type-lift/crack of the ~50 remaining substantial families + the tiny/mid bands.
✅ 2026-07-18 — CRACK-WAVE (session-4, Ultracode 11-core): 9 MATCH / 2 near → 6 BANKED ×1 in ov_SC01_077. PAUSED at Drew's request after the bank (before sweeps). Regenerated the family_manifest frontier FIRST (R35 — the Jul-14 digest still listed this phase's already-banked families as draftable): 14 draftable (ov077-STUB) families; 11 with 138-fleet reach dispatched to xHigh drafters (cached Ghidra-C + m2c + §31 + match_one). 9 MATCH / 2 near (func_8014D820 close-11 intrinsic-sched wall, func_8012E364 close-22 div-block regalloc — both preserved .run/giants/wave_*, R20). Banking = the §55b reality (new cookbook §58): all 9 match_one MATCHes gate-failed on INTEGRATION, 0 codegen — match_one compiles STANDALONE so it is blind to (a) Ghidra symbol names (DAT_/PTR_DAT_ vs splat D_), (b) def-sig conflict vs the fleet (draft sig is byte-truth; the engine_core void is a stale stub-era guess — canon_sig_reconcile forcing void DIFFed), (c) callee-decl conflict, (d) -O0-vs-O2. A focused reconcile agent banked 6/9 byte-identical: func_80150170 (95, hexR=138 DEDUP core) + func_8016D1D8 (148) + func_8016D688 (60) + func_80164E40 (25)
- func_80165240 (63) + func_801457A4 (79, -O0 → relocated into _o0b). Levers: 3 engine_core.h decls narrowed void→s32 (byte-neutral fleet-wide, callers ignore the return), normalize_self_decls, cast_call_sites,
- a D_801D9C20/60 u8 symbols mirror (fixed my type:data→type:u8 splat-format bug that failed ov_SC01_077 extract). 3 NOT banked (func_801549F8/func_8013BD74/func_8013C0F8) — ALL match standalone, blocked ONLY by the §8 jtbl-rodata carve (NOT codegen; 8013C0F8 was NOT a real DIFF — corrected). Drafts preserved. R22 clean-fleet 140/140 byte-identical; tools-health OK (dedup 1846/0, C1 234205/234205); 0 NON_MATCHING (G4). Fleet 75.2/60.6/87.04 (FLAT — these are ×1 banks; the ×138 sweep is the deferred fleet-mover). Commit <this>. NEXT (paused, not started): map-regen + family_sweep --hseq --only --normalize-self-decls the 4 -O2 cores (8016D1D8/80165240/8016D688/80164E40) + dedup_propagate 0x80150170 (hexR=138 → ~138 free) + jtbl-carve the 3 (Task 6). §58 flywheel captured (R30).
✅ 2026-07-18 — SESSION-4 FLEET-MULTIPLIER PASS (Ultracode auto, resumed): +275 members / 2 commits. Propagated the 6-core bank fleet-wide: func_80150170 ×138 (dedup_propagate --addr, hexR=138 group registered — commit commit:0717; first run SIGTERM'd mid-gate at the 2-min timeout → reverted the half-gated state, re-ran clean fail-closed) + func_80164E40 ×137 (family_sweep --hseq --only --normalize-self-decls; the fleet-wide engine_core void→s32 narrow made it clean — commit commit:0718). Map-regen (sig-overlays + family_hseq) done first (crack-wave-map-regen rule). R22 clean-fleet checkpoint: 140/140 byte-identical, extract-all 139/0. Fleet ~75.3% instr (make report will confirm; the ×137/×138 propagations register now). 3 sweep-residuals (delegated): func_80165240 (63, byte-DIFF/reconcile — compiles standalone), func_8016D1D8 (148) + func_8016D688 (60) reference the carve-boundary data-label D_801D9C20/D_801D9C60 only in ov077's symbols; siblings need it propagated (per-sibling symbols + re-extract). Plus the 3 §8 jtbl-carve cores (Task 6). NEXT: reconcile the residuals (ROI-triaged), then the next crack-wave / permuter backlog.
✅ 2026-07-19 — SESSION-4 RESIDUALS BANKED + VERIFIED (delegated agent): +412 more members, 3 commits. A focused agent ROI-triaged the 3 residual classes (byte-gate arbitrated): func_80165240 137/137 (commit:0720 — the sweep dropped the exemplar's LOCAL struct W4 type → per-member memcpy DIFF; carried the decl into each member draft, §59#1), func_8016D1D8+func_8016D688 274/274 (commit:0721 — my "fixed 0x801D9C20 data" premise was WRONG: h_seq data is per-overlay RELOCATED, no fleet-fixed address; derived each overlay's base = symbol_map[offset]−offset, declared D_<base> per sibling + re-extract, §59#2), and func_8013C0F8 ×1 (commit:0722 — jtbl_801D82FC carve, def-sig reconcile). BLOCKED (genuine tooling walls, §59#3): func_801549F8 ×137 (jtbl §8c isolation — trim can't partition the Phase-17 canonical-sig layer TU) + func_8013BD74 ×1 (§8e-2 table-count drift). R22 clean-fleet: 140/140 byte-identical, extract-all 139/0; tools-health OK (dedup 1847/0, C1 234343/234343); 0 NON_MATCHING linked (G4). SESSION-4 TOTAL (from the 74.6→ session open, this conversation): fleet 75.2→75.7% instr · 60.6→61.3% distinct · 87.04→87.24% fn-count — 6 cores cracked + propagated ≈ 687 member-banks across commit:0716/commit:0717/commit:0718/commit:0720/commit:0721/commit:0722 (+ commit:0719 checkpoint). Cookbook §58/§59 captured (R30). 2 near cores preserved (func_8014D820 close-11, func_8012E364 close-22 — permuter fuel). NEXT: next Ultracode crack-wave over a freshly-regenerated frontier + the permuter backlog (Task 7).

🛑 SESSION-4 CHECKPOINT (2026-07-19) — safe to open a FRESH session here. Tree clean (only db.*.gbf R23 churn + 2 preserved near-drafts + progress.fleet.md digest), 140/140 byte-identical, tools-health OK (dedup 1847/0, C1 234343/234343), 0 NON_MATCHING (G4). Main commit:0734. Fleet 76.3% instr · 62.8% distinct-code · 87.47% fn-count (session opened 75.2/60.6/87.04 → +1.1pp instr, +2.2pp distinct — ~1,500 member-banks across TWO crack-waves).

✅ 2026-07-19 — CRACK-WAVE 2 (absent-from-ov077 pool) + propagation: +819 members, HEAD commit:0734. Broad substantial sweep first = 0 banked / 858 failed (the mechanical frontier is DRAINED — §57a confirmed). So cracked the FRESH absent-from-ov077 substantial pool instead: 9 families drafted from ov_SC01_000 (cached Ghidra-C, NON-MCP) → 7 MATCH / 2 near. Banked ×1 (4 clean via the §58 ladder, 2 residuals via §18 cast-at-use
- K&R self-decl reconcile) then propagated: func_8013EF88 ×136, func_801418F8 ×136, func_8013D8FC ×136, func_80141A60 ×136, func_8013D9B0 ×136, func_8016DC20 ×135 (1 wall). 2 walls (reported, not forced): func_8016DC20 in ov_SC07_010_o2b (-O2 recon TU trips as --fatal-warnings $at), func_80156044 (byte-match needs a void def but fleet-canonical is int(int,int) via a 138-overlay DEFINE macro — a disproportionate fleet-wide decl flip for 74 ins). R22 clean-fleet 140/140 byte-identical; tools-health OK; 0 NON_MATCHING. ⚠️ TOOLING FINDING (R35, fix next): family_sweep --hseq --source <ov> is IGNORED — it templates from the MANIFEST exemplar (pick_exemplar hard-prefers ov_SC01_077), so a non-ov077 source silently used ov077's heavy-local-struct spelling → 0 banks until the manifest exemplar was redirected. The --source flag lies; the agent worked around it by editing the manifest. §57a NSD-hazard re-confirmed (NSD mis-parses else func(N); call statements as decls → wrong void(*)(void) cast; use K&R self-decl reconcile, not NSD, for these). FRONTIER STATE (honest): the cheap NON-MCP substantial-family pool (ov077-draftable + absent-cached) is now WORKED OUT (broad sweep 0; ~14 absent-substantial → 10 cracked/6 banked-families, 2 walls, 2 uncached needing MCP). Remaining levers: (a) fresh cracks need a Ghidra-C prefetch → /mcp (mid/tiny bands, resident's 14, main-EXE); (b) the permuter backlog (4 preserved nears: 8014D820/8012E364/8017B490/80143D28 + the 551 close-1..4 — uncertain yield, §26 exhausted-lever caution); (c) tooling fixes (family_sweep --source; the §8c/§8e-2 jtbl walls unlock func_801549F8 ×137 + func_8013BD74). This is the ROI-floor signal for non-MCP cracking (Task 7).
✅ 2026-07-20 — CRACK-WAVE 3 (16 fresh cached ov077 substantial families) + propagation: ~1,378 instances, 23 commits (commit:0736..commit:0759). The h_seq frontier revealed ~95 cached substantial families still crackable NON-MCP (the h_norm view had undercounted); 16 fresh (non-attempted) cracked → 12 MATCH / 4 near (100% on the first 8; wave hit + recovered from a session-limit mid-run via resume). Banked ×1 + propagated (delegated agent, §58/§59 ladder, K&R self-decl reconcile NOT NSD per §57a): 9 cores fully 138/138 (func_80160534/8016C998/ 8016B234 non-jtbl + func_8015C32C/80154C24/801588CC/801594E8/80140608/801555F4 jtbl via jtbl_family_bank), func_80169BBC 134/138 (4 SC07 special-split residuals), func_8014032C + func_8017AE2C exemplar-only (§59(3) jtbl span-fit carve walls — cracks are true MATCHes, recoverable if jtbl_family_bank learns span-fit auto-isolate). 4 near preserved (permuter seeds: 80175AB8/80177B5C/8015D1B8/80179B74). R22 clean-fleet 140/140 byte-identical, extract-all 139/0. Fleet 76.3→77.8% instr · 87.47→88.1% fn-count. New idiom (cookbook-worthy): a jtbl core that isolate-fails early can succeed after sibling jtbl cores bank (the overlay's jr-structure evolves) — func_80140608 went isolate-fail → 138/138. ⚠️ WEEKLY usage limit hit (resets 5am MT 2026-07-20) — session winding down here.
✅ 2026-07-20 — TASK 8 (2 tooling fixes) DONE + immediate payoff: func_8017AE2C ×137 recovered. (1) family_sweep --hseq --source no longer a no-op (commit): it templated from the manifest exemplar (pick_exemplar hard-prefers ov077), silently ignoring --source; now overrides to the --source overlay's MATCHED member per family (self-correcting via the gate; ov077-default path unchanged). (2) jtbl_family_bank auto-isolates on the span-fit wall too (commit): was NON-CONTIGUOUS-only; now also fires on "do not fit the span" (jr_isolate unblocks it — byte-proven). The distinct table-count-drift error ("more rodata .align than pad specs") stays excluded (not isolate-fixable). PAYOFF: func_8017AE2C (174 ins) recovered ×137 (was exemplar-only from wave-3's jtbl wall) — the fixed tool banked all 137 members whole-binary; R22 clean-fleet 140/140 byte-identical, extract-all 139/0. func_8014032C STAYS blocked (its wall IS the excluded table-count-drift, confirmed rc=1/0-banked — a separate future fix). ~+24k ins. NEXT: Tasks 9 (crack remaining cached fuel), 10 (permuter backlog), 11 (burn-down tracker).
✅ 2026-07-20 — CRACK-WAVE 4 (cached-fuel tail) + the crack-track FLOOR. 10 fresh cached targets from ov_SC01_000 → 10/10 MATCH, but the tail is thin: 6 -O2 cores banked ×1 (commit:0766, reconciled: func_80142C84 cast + func_80143994 s32-cast; R22 clean-fleet 140/140), the 6 -O2 ×138 propagation banked 0 (per-family §59 reconcile bottleneck — deferred to Task-14 gate_stage-ladder enrichment), and the 4 -O0 cores didn't bank (the ov_SC01_000 -O0-build wall; drafts in .run/drafts_wave4/). The non-MCP cached substantial crack-fuel is now DRAINED (waves 1-4). Remaining crack levers are all gated: -O0-cluster rollout, jr (jtbl path), or uncached/absent (need a Ghidra-C prefetch → overlay import → /mcp). → PIVOT to the permuter-automation program (Tasks 12-14, Drew-directed): make the offline permuter+ILS pipeline self-improving so it drains the backlog + the deferred propagations without an LLM in the loop except for genuine humps. ⚠️ GRINDER CONCURRENCY LESSON (this session): running the grinder concurrently with a crack-wave + killing it mid-flight left an 872-file mid-gate_stage state AND lost 3 permuter wins' C (not durably saved before banking) → reverted clean. The grinder needs (a) a fast/clean STOP between functions, (b) durable winner-C saving BEFORE gate_stage banks, (c) clear commit boundaries — folded into Tasks 12/14.
✅ 2026-07-20 — TASK 12 (permuter-autopsy prerequisite) DONE + committed commit:0768. Structured failure telemetry now FLOWS: masked_diff.structured_diff() (per-instruction masked residual) + match_one --json ({status,closeness,nins,residual}) + backlog fields residual/passes_tried + gate_stage logs the residual on every near/fail (verified end-to-end: a near-miss's [idx,mine,tgt] residual lands in backlog.jsonl) + grinder durably saves the winning C to .run/permuter-winners/ BEFORE banking (the lost-3-wins lesson). NEXT (fresh session): Task 13 (A+B — deterministic residual→class classifier + LLM-batch autopsy that routes each plateau to missing-transform/mis-classified/seed-structural/wall + extends permuter_weights), then Task 14 (C+D — enrich gate_stage's ladder with §57/§59 so more wins auto-integrate + grinder auto-R22 every N wins). Then run the closed loop: improved permuter over the whole backlog → collect telemetry → extend ILS → re-run → track the LLM-free fraction (burndown.py). Design substrate: docs/hindsight-study.md §7.
✅ 2026-07-21 — TASK 13A DONE: the deterministic residual classifier + the corpus it reads; the permuter's problem is TARGETING, not a missing transform. Built tools/residual_class.py (decode each mismatching MIPS word → (op-skeleton, register-fields, immediate); drift FIRST, then consistent-injective register map → REGALLOC-PERM, same-multiset-different-order → SCHEDULE-REORDER, DELAY-SLOT, WIDTH/BRANCH-POLARITY/STRENGTH/ADDRESSING/IMM-OFFSET/IMM-VALUE; every class routes to a BUCKET = which tool the failure wants; uncovered opcode → UNKNOWN, counted; 16 unit tests) + tools/autopsy.py (collect recompiles every open draft through the EXISTING match_one path, deriving the asm subdir and the -O0 flag via the new coverage-asserted corpus.o0_sources()/is_o0(); report → docs/autopsy.md). Why a collect step at all (R35): Task-12's telemetry only fills records written after it landed — 1 of 6,169 had a residual, 0 had passes_tried — but 1,752 open near-misses had draft+.s on disk, i.e. ~1 s of CPU each. Full corpus in 21 s at -j12; closeness cross-checked against masked_diff.structured_diff on 1,673/1,673 rows (R34), 0 classifier errors. THE MEASUREMENT (byte-grounded, whole open backlog): redraft 699 · structural 578 · integration 306 · permuter 75 · unknown 2. Of the 972 records the grinder's own filter admits, only 75 (7.7%) are permuter-shaped — 547 structural, 348 drafts that are not the function at all. ~92% of the grinder's CPU has been going where a search-closer provably cannot win, which is the byte-grounded explanation of the Phase-22 audit's "7 banks all-time, all Phase 21, 0 since." Fixed free: grinder.candidates() now filters on the measured bucket (1,303 → 78) and takes its directed permuter_weights profile from the measured class instead of the logged label (91% of records carry none → the "directed" search was silently running on gcc defaults). Degrades to undirected if the corpus is absent, says which mode it is in, --no-targeting A/Bs it. Two corollaries (R14, both measured not projected): (1) closeness conflates "one instruction off" with "this draft is a different function" — 699 records rank as near-misses at closeness up to 278 from a pure length artefact; they are un-attempted work misfiled as a backlog of hard functions (fresh crack fuel), so docs/backlog.md's closeness ranking overstates how nearly-done the frontier is. (2) A 12-draft gate probe of the integration bucket (reach-134, ov_SC01_077) banked 1/12, 11 PLUMBING — so the 306 prices Task 14's reconcile ladder, it is not 306 free banks. One real bank landed: func_80167714 (104 ins, reach-134) ×1, un-propagated by design (§55b: propagate is its own batch). Two defects fixed forward: masked_diff._common_typedefs() used ONE shared probe path src/.masked_diff_probe.c, so N parallel match_one/permuter processes clobbered each other — 14 of 1,752 drafts lost in a single 12-way run (0.8%), silently, in every parallel wave ever run (a drafter that crashes on its self-check is indistinguishable from one that failed); now per-PID. And gate_stage's match_one_closeness never passed --o0, so every -O0 function it scored produced a phantom residual written straight into the backlog this autopsy reads. R22 clean-fleet: make clean && extract-all && check-all → 140 passed, 0 failed of 140; make tools-health OK (dedup 1847/0, C1 234343/234343); 0 NON_MATCHING (G4). Flywheel captured in-session (R30/R31): cookbook §60, docs/decision-log.md entry, SETUP.md 3 inventory rows + the grinder row. ▶ TASK 13B RE-SCOPED BY THE DATA (the pivot): do NOT run an LLM batch autopsy over the backlog — the deterministic classifier resolves 96% of it into three non-LLM routes, and the 75 permuter-bucket functions have not yet been permuted under correct targeting, so calling any of them a "plateau" today would be diagnosing a search that never properly ran (R35). Correct order: run the directed permuter over the 75 → collect genuine plateaus with real passes_tried → only then spend the LLM on what survives.
✅ 2026-07-21 — TASK 13B (first run): the directed permuter WINS on its first target; two gate defects fixed at the root. Ran the newly-targeted grinder bounded (--once --batch 8 --permute-secs 90 --max-closeness 12). Log: targeting: ON — 1665 classified; only bucket=permuter is admitted / targeting skipped 1601 non-permuter candidates {redraft 707, structural 583, integration 305, unclassified 4, unknown 2} → permuter WON func_80181F78 @ ov_SC03_014 (close was 1) in ~6 min. Banked 2 (both byte-gated): func_80181F78 (8 ins, DELAY-SLOT/schedule) + func_80141B90 (29 ins, IMM-VALUE/cse). Both were classified bucket=permuter by the Task-13A classifier before the run — it predicted a search-closer could reach them and one did; the first end-to-end validation of the targeting thesis. THREE defects found + fixed at the root (all pre-existing, all surfaced by the grinder finally winning): (1) gate_stage commit path crashed — git add src … with src deliberately never defaulted (the Phase 26-A audit), so EVERY caller that omits it (grinder/orchestrator/idiom_hunt) crashes the moment it banks. Unreachable while the grinder banked nothing since Phase 21; the targeting fix made it win and it crashed instantly. Now git add -u src/ (also kills the §-lesson filename-glob hole that once omitted 4 R22-verified banks from a commit). (2) _xform ladder dirs ACCUMULATE across runs — -cn/-cast/-rc/-uni held 34 stale drafts from earlier sessions, so the gate processed 34 when the grinder submitted 1, and banked one function it was never asked to try (which would then have been committed under a message naming a different one). Now cleared per run. Nothing wrong entered the tree — G3/P9 held throughout, the gate banks only byte-identical output — but the report and the work had diverged (the R32 defect class, inverted: a stage silently WIDENING its input set). (3) grinder was calling gate_stage with the default propagate=True = dedup_propagate --auto-from, the fleet-wide path that timed out at 3600s and left 90/140 overlays broken (§55b) — unacceptable for the unattended caller; now propagate=False, banks committed cheap, propagation left as its own targeted --addr batch per the §55b law. R22 clean-fleet: 140/140 byte-identical. Cookbook §60 extended; SETUP.md updated.

🛑 SESSION-5 CHECKPOINT (2026-07-20) — superseded by the Task-13A/13B entries above. Tree clean (only db.*.gbf R23 churn), 140/140 byte-identical (last R22 clean-fleet at the crack-wave-4 verify + func_8017AE2C ×137; Task-8/12 tooling changes touch only matching-loop tools, no build/src output). tools-health OK (dedup 1846/0 class). Main HEAD after this = the checkpoint commit. Fleet 78.0% instr · 66.5% distinct-code · 87.9% fn-count (remaining substantial frontier 572 families / 1.58M templatable ins). THIS SESSION delivered (commits commit:0736..this): (1) crack-waves 1–4 — the non-MCP cached substantial crack-fuel is now DRAINED; crack-wave 4 = 6 -O2 cores ×1 (commit:0766), its ×138 propagation + 4 -O0 cores DEFERRED (integration/-O0 walls). (2) 2 tooling fixes — family_sweep --source now honored + jtbl_family_bank span-fit auto-isolate → recovered func_8017AE2C ×137 (commit:0763, R22 140/140). (3) tools/burndown.py (the ROI-close instrument, commit:0764). (4) docs/hindsight-study.md (commit:0765) — the optimal-decomp-ordering study for a future Fable roadmap pass; §7 = the permuter-failure-autopsy design. (5) Task-12 (commit:0768) — structured failure telemetry NOW FLOWS (masked_diff.structured_diff + match_one --json + backlog.residual/ passes_tried + gate_stage logs the residual per near/fail, verified end-to-end) + grinder durably saves the winning C to .run/permuter-winners/ before banking. THE SINGLE NEXT TASK (fresh session): Task 13 (A+B) — build the deterministic residual→class classifier + the LLM-batch autopsy that routes each backlog plateau to missing-transform (extend permuter_weights pass→class map) / mis-classified (fix classifier) / seed-structural (one LLM seed) / genuine-wall (file w/ expiry). Then Task 14 (C+D) — enrich gate_stage's ladder with §57/§59 so more wins auto-integrate + grinder auto-R22 every N wins. Then run the closed loop (improved permuter over the whole backlog → collect telemetry → extend ILS → re-run → track the LLM-free fraction via burndown.py). DESIGN SUBSTRATE: docs/hindsight-study.md §7 + Tasks 12–14. Carried residuals: crack-wave-4's 6 -O2 ×138 propagation + 4 -O0 (needs the Task-14 ladder / -O0 rollout); the permuter backlog (Task 10, 550 close-1..4 — the autopsy loop's input). Effort: Max for the classifier/autopsy design (Task 13 is Tier-1 synthesis); prompt Ultracode only for a breadth backlog-sweep. Drew pushes all commits (R6/R20).

71 KiB Raw Blame History Unescape Escape