mirror of
https://github.com/Druthulu/BFM-decomp
synced 2026-10-03 00:05:11 -04:00
Drew T
41a3de342d
- ROOT CAUSE PINNED, and my first hypothesis was WRONG (R14, corrected in the log): I wrote that a gate transform ate a `/*` opener and turned comment prose into code. REFUTED — cast_call_sites, sig_unify and reconcile_tu each run with the gate's real --src-file all preserve it. The real cause is family_remap's preamble backscan, whose accept-set (blank/extern/comment/typedef) HALTS AT THE FIRST `#define` and never reaches typedefs above the macro block. `_carry_macros` then re-attaches the macros, which HIDES the truncation — the unit looks complete and is not. "parse error before 'unsigned'" was that failure surfacing at the next token (the following `extern unsigned char` line): a misleading label, not a second defect. - FIX: _carry_typedefs() — additive, TRANSITIVE (a carried typedef may name another; measured: carrying Vec8_80182FD4 alone then failed on SVECTOR_8016E7C8), and BRACE-AWARE (a `;`-terminated scan stops INSIDE the struct at its first member line, emitting a truncated unclosed typedef). Emits dependency-first for C89. Only types the unit actually names and does not already carry. - VERIFIED: the 0x80182FD4 unit now carries its Prim_8016E7C8 block complete; the 0xECC family's remaps now carry the four typedefs I had prepended BY HAND before gating them — i.e. the fix automates the exact workaround that banked those three siblings. Residual isolated-compile failure on SVECTOR_8016E7C8 is a match_one artifact: that type lives in src/shared/engine_types.h, which the real TU includes — the typedef gap is fatal ONLY when the target TU lacks the type, which is why this class failed loudly for some families and silently succeeded for others.
3163 lines
245 KiB
Markdown
3163 lines
245 KiB
Markdown
# CURRENT PHASE — Phase 30: The Recovery & Concentration Campaign (overlays to their ceiling)
|
||
|
||
**Opened:** 2026-07-30 · **Effort:** Max (Fable 5; saved defaults) · **Generation:** Gen2 (22nd phase of the arc) ·
|
||
**Baseline:** PhaseEnd_Phase29 (v1.28.0) · **Roadmap:** `docs/roadmap-to-100.md` **v2** §3 P30
|
||
**Plan approved (P3 gate 1):** 2026-07-30, in-session (Drew's explicit waiver of the fresh-session step at 28% context).
|
||
Full plan mirror: `~/.claude/plans/continue-dazzling-newt.md` (out-of-repo; this file is the in-repo authority + crash-recovery log).
|
||
|
||
**Fleet at open:** 87.5% instr-weighted / 78.0% distinct-code / 92.00% fn-count · 140/140
|
||
byte-identical · 0 NON_MATCHING · dedup 1886/0 · tools-health RC=0.
|
||
|
||
**Drew's Phase-Start decisions (2026-07-30):**
|
||
- In-session start (fresh-session step waived at 28% context).
|
||
- The Ghidra-C prefetch batch pulled forward from P31 → **T0.5** (tail + main's 1,034 stubs; headless, background).
|
||
- T2's primary path = the **two-file atomic o0b substitution driver** (the log's costed no-splat route); Arm-A splat research is the fallback only.
|
||
- ROI floor for T3: two consecutive sessions each < +0.3pp instr with all lanes exercised (Drew-adjustable).
|
||
|
||
**⚠️ PRECONDITION (R6):** Drew makes the milestone-close commit + push (`PhaseEnd_Phase29.md` +
|
||
`phase-ends/logs/Phase29.md`, both in the tree) **before P30's first commit lands**. P30 work
|
||
proceeds; the first P30 commit waits on it.
|
||
|
||
---
|
||
|
||
## The numbers this phase must pin FIRST (T0 — do not consume until re-derived, R35/R14)
|
||
- family_hseq **29,961** vs progress.py **28,296** remaining instances — an unexplained R32 gap.
|
||
- The `-O0` population: "10 families / ~1,287 raw distinct" (checkpoints) vs "123 families /
|
||
121,264 ins / 3,100 distinct" (the log's R14 correction) vs "129 distinct on the table" (the
|
||
costed o0b route) — three numbers, one T0 job.
|
||
- The zero-crack family list (map said **61** on 07-29) and the concentration table (top-20/top-100 shares).
|
||
|
||
## Standing invariants (every task)
|
||
- Whole-binary byte-gate is the **sole arbiter** (G3/P9); match_one/closeness/masked = candidates (§52b).
|
||
- **R22 clean-fleet per banked batch:** `make clean && make extract-all && make check-all` → 140/140.
|
||
- `make tools-health` green + fail-closed before matching (corpus · cdecl · audit-binaries(R36) · report/lint/dedup).
|
||
- Blast-radius typing on every integration write (T0 draft-only / T1 binary-local / T2 fleet-shared ⇒ R22 mandatory).
|
||
- **Probe before costing** (R37-candidate discipline): probe one member before pricing a job; derive
|
||
attribution from `corpus.stubs` before/after; diff the artifact to prove an edit ran (§120).
|
||
- Flywheel: idioms → cookbook + tooling in-session (R16/R30); pivots → decision-log (R31).
|
||
- Effort/model transitions **prompted, never assumed** (R26/R27) — STOP + WAIT for the toggle.
|
||
- One commit per task/sub-repair after this file's update; Drew pushes (R6/R20). R23 no-op on db.*.gbf churn.
|
||
|
||
---
|
||
|
||
## Task checklist (current-task pointer = ▶)
|
||
|
||
- [x] **T0 — Frontier regen + instrument repair [Max]** ✅ (all six letters; see per-task log; frontier
|
||
report = `docs/frontier-p30.md`, report point #1):
|
||
(a) `gate_stage.py` snapshot/restore (the ladder destroys good drafts) ·
|
||
(b) `rtu_match.py` surface the real cc1 error in the verdict ·
|
||
(c) reconcile the family_hseq↔progress instance gap (R32) ·
|
||
(d) purge since-banked rows from the backlog ledger + still-a-stub filter from `corpus.stubs` (R33) ·
|
||
(e) refresh `.run/autopsy/residuals.jsonl` + fix the 21-file absolute-include defect ·
|
||
(f) regenerate the frontier (report / family_hseq / worklist / fuel manifest) + **pin the three
|
||
contested populations** → the one-page frontier report (**report point #1**).
|
||
Verify: tools-health green; digests committed; velocity derives from digest git history (R33).
|
||
- [x] **T0.5 — Fleet Ghidra-C prefetch batch [background]** ✅ (SESSION-27: 124/124 programs, 7,716
|
||
files, 335 min unattended; 95.2% of crack-needing families seeded, main 2,001/2,002, resident
|
||
14/14. *Was left unticked through S27 — corrected S28.*) — `ImportOverlay.java` (~130 missing
|
||
programs) + `DecompileFunctions.java` over every remaining distinct stub (overlay tail + main's
|
||
1,034; skip LINKED) → `.run/ghidra_c/`. **R23 lock discipline** (stop the hook-launched MCP
|
||
server first or route through it). Verify via `build_fuel_manifest.py` counters + 5 spot-reads.
|
||
- [x] **T1 — Integration-recovery sweep** ✅ **DELIVERED as T1a (report point #2), then CLOSED both
|
||
ways.** 108 fresh autopsy-MATCH strandeds / 50 binaries through the tiered driver → **+18
|
||
banked** (derived: fn-count +18 / distinct +12; the commit-message sum of 19 was a gate-report
|
||
double-list — the metric wins), R22 140/140. **The measured verdict:** the S16 "39%" prior did
|
||
NOT generalize (it was measured on FRESH same-wave drafts); on this stored-backlog population —
|
||
the class decision-log **A10** had already byte-proved non-bankable by plain re-gate (0/958) —
|
||
the driver's reconcile/de-macroize lifted **18 of ~111 ≈ 16%**, a real but bounded delta. The
|
||
~90 that did not bank stay `match_one`-MATCH but are integration-DECAYED: they route to T3's
|
||
REDRAFT lanes, not another recovery pass. No Ultracode was needed (the lever was deterministic).
|
||
- [x] **T2 — The `-O0` cluster [Max, deep]** ✅ **ROUTE PROVEN, TOOLED, AND SWEPT FLEET-WIDE (S28).**
|
||
**Report point #3 = this entry.**
|
||
DEVIATION from the phase-start plan, byte-justified — **BOTH named routes were refuted:**
|
||
the PRIMARY "two-file atomic o0b substitution driver" mis-places by construction unless the
|
||
target abuts the o0b object's END (the ×1 probe), and the FALLBACK premise was also wrong —
|
||
the Arm-A splat `%lo +0x20` **does not bite** (a pure `-O2` sub-split of a jr object is
|
||
byte-neutral, probe 1). The real constraint is **§126**: *an address range is not an
|
||
optimization region* — it contains already-matched `-O2` bodies, so the bound is
|
||
(range MINUS matched) and K islands ⇒ K+1 regions (probes 3–4).
|
||
**Shipped:** `tools/o0_subsplit.py` · Makefile `-O0` glob `_o0b`→`_o0?` · cookbook §126/§126a.
|
||
**Swept:** 135/135 overlays, 0 refusals; 140 new `-O0` region files; `o0_sources()` 137→277;
|
||
0 invisible to the oracle; **2,200 open stubs now in a genuinely `-O0` TU**. 6 fns banked
|
||
(ov_SC03_014/015). R22 140/140; tools-health OK.
|
||
**Population correction (R14):** my "275 stubs / 18 overlays" was an 8× under-count from a
|
||
bare `except` swallowing R32 during a rebuild; truth **2,184 / 138**, which **vindicates the
|
||
T0(f) "2,192" pin** I had wrongly called stale (§126a).
|
||
**Handoff → T3:** drafting the 2,200 is crack-wave work; seeds cached; `match_one --o0`.
|
||
- [x] **T3 — The standing crack-wave loop** ✅ **RAN across S26–S29, all four lanes exercised, with a
|
||
measured per-lane verdict** (the ROI floor is a LANE property, not a phase property):
|
||
· **Lane B (top-mass fresh families) PAYS and is not exhausted** — S27 waves 1–4 (8/14 · 15/19 ·
|
||
48/48 · 69/70) + 7 confirmed behemoths at 700–970 ins; S28 the jtbl OVER-SPAN fix + the 710-ins
|
||
`func_80191C50`; S29 the jr-pair = frontier families #3 and #4 by templatable weight, banked
|
||
×138 each for ~0 agent tokens after the instrument repair.
|
||
· **Lane C (tail mass, ×2-reach cached band) is AT the floor** — S28 measured 1.33M tokens →
|
||
12 banks → **+0.00pp headline**. That, not the phase, is what the ROI floor names.
|
||
· Lane A (zero-crack propagation) + Lane D (PINS/W4/permuter) exercised; 29 zero-crack families
|
||
remain as propagation-only fuel behind matched exemplars.
|
||
*(Original text:)* — lanes interleaved,
|
||
propagate behind every crack same-session:
|
||
A zero-crack (~61, propagation-only) · B top-mass fresh families (no size cap; jr via
|
||
`jtbl_family_bank`; `gate_stage` call-site-casts, never bulk header edits) · C tail mass on
|
||
prefetched seeds (local v3 ≤15 → GLM/Haiku ≤~50 → cheap-Opus mid) · D PINS (19) + W4 bounded
|
||
diagnoses + permuter backlog via the T4-fixed grinder.
|
||
Per-session checkpoint + velocity + 3 metrics. **ROI floor: 2 consecutive sessions < +0.3pp
|
||
instr each with all lanes exercised.**
|
||
- [x] **T4 — Carried-tool resolution [xHigh]** ✅ (S28, `commit:1279`). The 2 "Phase-22 grinder bugs"
|
||
were struck as STALE in S27 (already fixed). This session: **`--fix-def-sig` posture audited
|
||
clean** (defaults False, one consumer, no caller passes it) — and the audit found the live
|
||
hazard the earlier pass missed: `docs/decision-log.md` still recommended making it
|
||
**default-on**, which T84/§119 byte-refuted; struck in place with a superseding note (R31).
|
||
**Grinder ILS warm-restart WIRED** — `permuter_ils.py` had sat unused beside `grinder.py`
|
||
since Phase 24, so every grind was a COLD search; now `--cycles` (default 4) warm-restarts
|
||
from the best byte-waypoint, `--cycles 1` = old behaviour. Justified by measurement before
|
||
building (the lane looked dead: 0 banks since Phase 21) — **665 open near-misses in the
|
||
permuter-tractable band, 157 at close 1–4, incl. `func_8016BA68` close=1 reach=134**.
|
||
⚠️ **Yield UNPROVEN on this backlog** — wiring only; the ILS evidence is one Phase-24 fn.
|
||
- [ ] **T6 — The measured-frontier continuation [approved by Drew 2026-08-01, in-phase re-plan
|
||
(P5d)]** — P30 stays OPEN. Order derived from the S29 frontier regen, ranked by the family
|
||
map's TEMPLATABLE weight (see the pricing finding below), NOT by `worklist.md`:
|
||
**S1** zero-crack propagation sweep — 29 families / **67,470 ins**, ~0 agent tokens
|
||
(head `0x8014032C` 183×137 = 25,071 jr · `0x8017BEBC` 12,376 · ~8 ×4-straggler families) ·
|
||
**S2** the LAST two reach-138 fresh cracks — `func_80176734` (371×138 = **51,198**, no jr,
|
||
cached) + `func_8016EC0C` (88×138 = 12,144) ·
|
||
**S3** the close=0 stored drafts as a **diagnostic** pass (§132 ladder per draft), not a
|
||
blind re-sweep (T1a's ladder measured 16%; S29 resolved 2 of 2 "gate refuses" to tooling) ·
|
||
**S4** PINS bounded wave (14 fns / 44,279 ins; the pin-crash wall dissolved in P27) ·
|
||
**S5** the ×10-133 mid-multiplicity families (142,527 ins).
|
||
**Deliberately excluded:** the 2 GIANT walls (close=110/91 — P32's track), the ×2-9 mass
|
||
(339,742 ins, worst multiplier), the singleton/non-substantial residue (635,805 ins, ×1).
|
||
**⚠ THE PRICING FINDING (R14/R35):** `worklist.md` ranks by **h_exact** reach, so a
|
||
per-location PURE family is priced ×1 — it under-prices the frontier head by up to **138×**.
|
||
Byte-proof: S29's pair was priced 272 and 198 ins and delivered **37,536 + 27,324**.
|
||
`func_80176734` sits at rank ~50 in `worklist.md` and is the single largest item on the board.
|
||
**Rank by `.run/family_hseq.json` templatable weight for family work; the worklist is correct
|
||
only for genuinely h_exact-reach functions.**
|
||
**⚠ THE STRUCTURAL SIGNAL:** after S2 the **×138 era ENDS** — those are the last two crackable
|
||
fleet-wide families; everything after is ≤133 members and mostly ≤9. That rise in
|
||
cost-per-point, not a session count, is P30's honest ROI floor and the trigger for T5.
|
||
- [ ] **T7 — THE FABLE-5 FRONTIER PLAN [approved by Drew 2026-08-04, in-phase re-plan (P5d)]**
|
||
**📄 FULL REPORT: `.run/fable_frontier/ANALYSIS.md`** (verbatim; the agent's harness blocked it
|
||
from writing to disk, so the orchestrator transcribed it — future sessions read it THERE, not
|
||
here). Its computed pools are `.run/fable_frontier/pool_ovres.json`. **Its two headline
|
||
refutations were independently re-verified; its POOL NUMBERS were not — verify before scaling
|
||
a wave onto them (R14).**
|
||
**Why this supersedes T6's wave order:** the base rate across every sweep run is **~24k
|
||
PLUMBING vs 4,917 DIFF (5:1)**. Sweep failure here has always been mostly plumbing, so fixing
|
||
the plumbing moves work from the 490-tok/ins column to ~0 — and S1 restores the propagation
|
||
multiplier that makes every later wave ~3× cheaper. **DO S1 BEFORE ANY WAVE.**
|
||
· **S1** fix the 2 plumbing classes (typedef/macro gather in `family_remap`; wire the
|
||
extern-conflict reconcile into `--hseq`) → re-sweep the **148 matched-exemplar families**
|
||
(1,585 members / 75,383 ins gross, 71,178 PURE+IMM). **35-60k ins @ ~10-25 tok/ins.**
|
||
*Mechanism already PROVEN this session:* `0x801833f0` went **0/6 → 6/6** after lifting 3
|
||
types (R22 140/140). Kill-test: after the typedef fix `--only 0x801833f0` must stay 6/6, and
|
||
after the extern fix `--only 0x80128c98` must move off 0/138.
|
||
· **S2** jr matched-exemplar families via `jtbl_family_bank` (§53) — 11 fams / 52 members.
|
||
**10-18k ins @ ~0 tok.**
|
||
· **S3** the SC07 carve/pin fix (T2 Arm-A `%lo +0x20`) → the **whale ×4 (3,080 ins of
|
||
BYTE-IDENTICAL code)** + 61 SC07 `-O0` members. **5-15k ins @ ~0 tok.**
|
||
· **S4** draft-recovery on 39 draft-exemplar families (382 members) + the 2 resident stubs that
|
||
already have match_one-MATCH drafts gate-rejected for TU plumbing. **10-25k ins @ ~10-50.**
|
||
· **S5** **re-aim waves at the open-only h_norm clusters** — 1,689 clusters / 5,956 fns /
|
||
**326,261 ins = 46% of all open overlay code**, at a **2.7× propagation multiplier**. Nobody
|
||
has ever aimed a wave here. **Needs S1 first or the propagation never realizes.**
|
||
· **S6** the 2 GIANT exemplar walls — **50,094 ins riding on 2 cracks** (close=91/110; their
|
||
138 members each classify PURE). Time-boxed siege, hard budget stop.
|
||
· **S7** the singleton tail + **main** (regen main's Ghidra sig FIRST — it is 7 weeks stale and
|
||
missing 757 of 2,002 stubs; main is structurally barren, zero h_exact overlap, so it is the
|
||
genuine ~490-tok/ins agent tail).
|
||
**🚨 STANDING PRE-PROBE RULE:** check h_norm identity across a family's members from the sig
|
||
files BEFORE probing. If members are h_norm-identical, a 0% is a **compile-error certainty**,
|
||
not evidence about codegen. And **read `.run/hseq_failed.*.classified.txt` before theorising
|
||
about any sweep failure** — 23,211 of them exist and both of S38's zeros were already in there.
|
||
- [ ] **T5 — Phase close [Max]** — burn-down from digest history; P7 milestone walk; Roadmap delta
|
||
(**including the v2 gap this analysis exposed: bucket W3's remainder has NO owner phase after
|
||
P30 — P31 is T/M/R, P32 is walls/behemoths**); gate 2; PhaseEnd_Phase30.
|
||
|
||
**Milestone:** overlays at their measured ceiling — **≥95% instr fleet, or every remaining overlay
|
||
stub on a named wall/behemoth/queue ledger** — 140/140 byte-identical throughout.
|
||
|
||
## Blockers
|
||
- (none) — the precondition (Drew's milestone-close commit) landed at `commit:1213`.
|
||
|
||
---
|
||
|
||
# 🛑 SESSION S43 CHECKPOINT (2026-08-05) — FRESH SESSION SAFE HERE
|
||
> **Tree CLEAN** but for R23 `db.*.gbf` churn (never stage). **Nothing running.** Effort **Max**.
|
||
> **NO phase close** — T5 unopened, needs Drew's gate-2.
|
||
> **No src/ or config/ change this session** ⇒ the fleet cannot have moved: metrics below are S42's,
|
||
> carried forward unchanged, and no R22 run was owed (nothing was banked).
|
||
|
||
## ✅ FINAL S43 STATE — R22 CLEAN-FLEET **140/140**, ALL 18 BANKS CONFIRMED
|
||
**FLEET: 96.63% fn-count · 94.99% instr-weighted (12,501,204 / 13,160,961) · 89.4% distinct-code
|
||
(78,096 / 87,459 uniq)** · 0 NON_MATCHING (G4) · dedup 1919 groups.
|
||
**Session: 12,484,373 → 12,501,204 = +16,831 instructions, 18 functions banked.**
|
||
**P30's 95% instr milestone bar is 1,708 instructions away** (was 18,539 at session open — the report
|
||
line rounds to "95.0%"; the precise figure is 94.99%, and the bar is NOT yet met).
|
||
|
||
**The 18:** `func_8017C6F4` ×4 (Fable5, §150) · `func_8017EF68` ×1 (Fable5, §151) · the **0xECC family
|
||
×12** (one body, 5 names, 6 addresses — §152) · `func_8018D98C` ×1 (§153).
|
||
**Near-misses banked to the ledger, not forced (P9):** `func_8017C6F4`'s pre-crack seeds; the
|
||
246-ins body at **2/246 across 4 instances** (`func_8017CE58` + `func_8017C294`).
|
||
|
||
## WHAT S43 WAS: FOUR INSTRUMENT DEFECTS, AND THE TWO QUESTIONS THEY HID
|
||
The session opened on the serial crack queue's named next move ("demacroize `func_8017C6F4` so the
|
||
permuter can be aimed") and found that neither the blocker nor the two work items behind it were what
|
||
the checkpoint said. **Nothing was banked; four tools now tell the truth, one floor moved, and one
|
||
phantom item left the board.** Full detail in the S43-1..4 per-task log entries below.
|
||
|
||
| # | recorded as | actually | consequence |
|
||
|---|---|---|---|
|
||
| 1 | "the GTE `#define` block defeats `make_base_c` — demacroize first" (§148) | `cpp_expand_macros` ran BEFORE `#include` was stripped → cpp rc=1 → **silent fallback** returned the unexpanded draft | the permuter was **silently dead on 63 stored drafts**, incl. the behemoth renderer drafts |
|
||
| 2 | "an artifact-less backlog rumour outranks the real 63" | the row is real and reproduces (14/15) — but on a **different body**: `0x8017C6F4` is 15 ins in SC03_010/011/013, **948** in SC03_126/003, SC04_021, SC05_019 | `load_best` keyed on ADDRESS → 7%-correct masked 93%-correct; and `binary:null` → absent scored as **banked** |
|
||
| 3 | "the classifier writes `CC1-FAIL: make: *** Error 33`" | `errs[-1]` and make prints its summary LAST, always | **~3,000 of ~4,000** CC1-FAIL labels were content-free |
|
||
| 4 | "26 unpropagated members — cheapest fuel, levers exist, ~0 tokens" | **0 of 31 templatable** from any matched source | phantom item; they are **per-member drafting work** |
|
||
|
||
## THE ONE NUMBER THAT MOVED
|
||
`func_8017C6F4` (947 ins): hand floor **63** → permuter **41**. Both basins then plateau flat
|
||
(pin-free masked 44 / 8 cycles; `pin-t5` masked 43 / 5 cycles). **Best draft
|
||
`.run/s43/func_8017C6F4.ils43-pin.c` (closeness 41), logged + allowlisted.** The ~40 hand probes that
|
||
"proved" 63 unmovable were all run while the permuter was silently broken.
|
||
|
||
### ▶ S43-10 — the wave's 5th agent: §147 REFUTED, and a parked family un-parked
|
||
`func_8017CE58` is **two bodies at one address** (246 ins in ov_SC02_000/003; 734 in ov_SC03_092).
|
||
The 246 body is byte-identical to **`func_8017C294`** — *the function §147 was written from* — so one
|
||
draft covers **4 instances**. It went from the recorded **12 with a "stop searching" verdict → 2**.
|
||
Three §147 verdicts fell (correction written into §147 in place):
|
||
- **§147-A "stratum 3, unreachable from C" — REFUTED. There is no stratum 3.** The frame is declared
|
||
locals then reload spill slots in pseudo-regno order; the mystery `0x108` slot is an ordinary spill
|
||
belonging to a **`loop.c`-created** pseudo — reachable by writing the loop as an *index* loop (a
|
||
pointer walk puts it at the bottom). Every prior draft faked it with `volatile pEnd` + `dead[7]`.
|
||
- **§147-B** — the unreferenced block is **combine-orphaned sign-extension intermediates**
|
||
(`combine.c:10839`), not `?:`-on-memory cost.
|
||
- **§147-E** — the `qty_compare` tie **is** breakable via §148-C's zero-emission ref slider.
|
||
**Consequence: `func_8017C294`'s 15 siblings were parked "until stratum 3 is explained" — that hold is
|
||
VOID.** The last 2 are a *cse1 elision-count* fact (target 16 orphan slots, draft 12), permuter-confirmed
|
||
from both basins. The 734-ins body is a **singleton** (§152 size-key: the only other 0xB74 differs in
|
||
766 normalized lines) — queue it as its own behemoth crack seeded from `.run/s43/fable/8017C6F4/v2_rtu.c`.
|
||
**Process lesson recorded in §147: a confident NEGATIVE verdict is a claim like any other — date it,
|
||
name its evidence, and re-measure before letting it park work.**
|
||
|
||
## ▶ RESUME HERE (S43)
|
||
1. **`func_8017C6F4` — do NOT re-run the ILS on these two seeds** (measured flat, 14 restarts).
|
||
Remaining levers: **§148-C** the zero-byte allocno-priority slider (`__asm__ ("" :: "r"(a),"r"(b))`
|
||
inside the loop — the documented lever for exactly this two-callee-saved-register swap) by hand;
|
||
then Fable5 on a fresh seed. Then the rest of the serial queue (`func_8017C59C` 947 reach 6,
|
||
`func_8017CE58` 733×3, `func_8017EF68` 969, …) — **every brief opens with the all-drafts scan +
|
||
the §147-A frame test**, and any ×N claim needs the §148-E draft test.
|
||
2. **`func_8017C294` NEAR(12)** still parked on §147-A stratum 3; its 15 siblings stay parked with it.
|
||
3. **Re-check the 63 GTE drafts** the silent fallback disabled — the behemoth renderer drafts are the
|
||
high-byte-weight ones and have **never** actually had a permuter run.
|
||
4. **Then L1+L2 disc audit (task #10), then L3 + type-1 onboarding (task #11)** — Drew's agreed plan,
|
||
unchanged, below.
|
||
5. **Cheap fuel:** the 61 SC07 `-O0` members · `func_80183BAC`'s R22 revert (capture WHICH binary) ·
|
||
2 resident stubs with gate-rejected match_one-MATCH drafts · the 263×5 cluster (`0x80182fd4`,
|
||
`parse error before 'unsigned'`, undiagnosed — **the fixed classifier will now name it**).
|
||
⚠️ **"26 unpropagated members" is REFUTED — struck from this list** (S43-4).
|
||
|
||
## 🧰 HAZARD INTRODUCED-AND-DOCUMENTED THIS SESSION
|
||
`tools/harvest_verify.py` has **no `if __name__ == '__main__'` guard**: `import harvest_verify` runs a
|
||
full build, splices drafts, and overwrites `.run/harvest_*.txt`. I tripped it unit-testing
|
||
`classify_fail` (no damage — resident stayed `8e17e02f`, 0 banked, tree clean). Nothing imports it, so
|
||
it is flagged in the file header rather than fixed by a risky 500-line refactor of our most
|
||
load-bearing gate. **To test a helper in it, `exec` that function's source — never import the module.**
|
||
|
||
## 🧰 MY PROCESS ERRORS THIS SESSION
|
||
1. **Queried the wrong field name** (`draft` vs `best_draft`) and briefly read *all 838* rows as
|
||
artifact-less — the §133 default-filter shape, self-inflicted. Caught by sanity-checking a number
|
||
that was too round.
|
||
2. **Inherited a checkpoint claim without probing it** ("no draft survives on disk"); the draft was
|
||
there, and one `ls` would have shown it. The whole S43-4 refutation exists because I probed the
|
||
*second* such claim instead of the first.
|
||
3. **Imported a module that runs a build** (above).
|
||
4. **Wrote a "negative control" that never exercised the changed branch** — the PLUMBING path returned
|
||
first, so old and new agreed and the test proved nothing. Rebuilt it to hit the branch under test.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION S39–S42 CHECKPOINT (2026-08-05)
|
||
> **Tree CLEAN** but for R23 `db.*.gbf` churn (never stage). **MCP was stopped by me for the main sig
|
||
> regen** — the SessionStart hook restarts it; **run `/mcp` before any Ghidra work (R29)**.
|
||
> **ONE AGENT MAY STILL BE RUNNING:** a serial crack on `func_8017C6F4` writing to
|
||
> `.run/s42/ov_SC03_126/`. If its result never arrived, re-run it (brief pattern below).
|
||
> **NO phase close** — T5 is unopened and needs Drew's gate-2.
|
||
|
||
## FLEET — R22 **140 passed / 0 failed of 140** (run ~25× this session, green every time)
|
||
**96.62% fn-count (341,775/353,717) · 94.9% instr-weighted (12,484,373/13,160,961) · 89.2%
|
||
distinct-code (5,043,472/5,654,184; 78,081 uniq)** · 0 NON_MATCHING · audit-digest OK.
|
||
**Session: 12,405,402 → 12,484,373 = +78,971 instructions, +129 unique fns, 46 commits.**
|
||
⚠️ **The denominator CHANGED mid-session** (13,141,652 → 13,160,961) when main's sig was regenerated.
|
||
Compare percentages only within one denominator. **No numerator ever fell.**
|
||
|
||
### REMAINING (measured at close)
|
||
**676,588 ins across 12,902 open stubs** — main **79,074 / 2,001 stubs** (12% of remaining, and the
|
||
least tractable: structurally barren, zero h_exact overlap, no free dedup, checked twice) · overlays +
|
||
resident **597,514 / 10,901**. **Distinct remaining 610,684 ins across 11,330 unique fns — only 1.1×
|
||
compression.** *The ×138 propagation era is over: what is left is largely genuinely distinct code, so
|
||
the fleet number and the work are now nearly the same thing.*
|
||
|
||
---
|
||
|
||
# 🎯 THE AGREED NEW PLAN (Drew, 2026-08-05) — DO NOT LOSE THIS
|
||
Drew: *"im getting tired of learning there was more code all along, we really need a full audit that
|
||
definitively lists ALL code that we need to decomp."* **Agreed and approved.** Full rationale in
|
||
`docs/decision-log.md` (2026-08-05 entry); tasks **#10** and **#11**.
|
||
|
||
**THE INVARIANT:** *every byte on the disc belongs to exactly ONE bucket — onboarded-code /
|
||
classified-data / audio-video / filesystem-metadata / unused — the buckets sum to the disc, and
|
||
**residue is a DEFECT** (R32).* **A partition with an asserted residue of zero is a completeness
|
||
proof; a longer list is only a longer list.** Same move as `audit-digest` (S1e) and `audit-binaries`
|
||
(R36) applied to the DENOMINATOR.
|
||
|
||
**Why three surprises happened:** every tool was **correct about the subset it examined and silent
|
||
about the rest** — a `0.4.dec` glob (missed 4 SC07 overlays whose code is at PAC entry 1), a decode
|
||
layer (`disc_code_sweep` was blind to COMPRESSED code), a 4,096-word window. **Measured: 782 of 1,328
|
||
PAC payloads are only PARTIALLY classified (~55.5M words never examined).** Probably data — but
|
||
nothing has checked, which is the exact shape of all three findings.
|
||
|
||
**L1 (task #10, cheap, deterministic, no RE):** walk from the DISC IMAGE not our configs — every ISO
|
||
file → `.CD` sub-file → PAC entry → **both raw AND decompressed** layers; classify **whole payloads,
|
||
no window**; emit `docs/disc-ledger.md` with per-payload `claimed-by <binary> | UNCLAIMED`; assert
|
||
`sum(buckets) == disc bytes`; ship as **`make audit-disc`**.
|
||
**L2 (task #10, R34):** a SECOND, DISAGREEING oracle. Today's code test is a heuristic
|
||
(`valid ≥ 0.90` AND `jr $ra ≥ 0.01`) — a small code payload can fall below 1% `jr` density.
|
||
Cross-check with `sig_image` boundary carving; disagreements are the review queue.
|
||
**L3 (task #11, the proof — AND the type-1 onboarding, SAME RUN):** instrument PCSX-Redux (R11:
|
||
Windows-native, WSL via `172.17.208.1:8081`) over a scripted tour of every location; log **every**
|
||
load (payload → RAM addr → len) and every executed PC range. Delivers (a) the **load addresses** the
|
||
39 un-onboarded type-1 modules need — they are NOT location overlays, each loads at its own address
|
||
like the resident at `0x800CEDF8`, so they cannot be onboarded mechanically and a build binary needs
|
||
its address to byte-verify (P9); (b) **completeness proof** — anything executed but absent from the L1
|
||
ledger is a hole; (c) **honest exclusion** — never-loaded payloads marked out-of-scope WITH EVIDENCE.
|
||
**Do L3 and the onboarding together or you pay for the tour twice.**
|
||
**EXPECT THE HEADLINE TO FALL** when the 39 land (denominator grows) — the honest direction, as with
|
||
today's main regen (94.5→94.4) and P27's overlays (68.9→67.0). **"100%" is not claimable until the 39
|
||
are onboarded-and-matched or explicitly excluded with a stated reason.**
|
||
|
||
**SEQUENCE (Drew's):** finish the serial crack queue → **L1+L2** (they sharpen L3's target list) →
|
||
**L3 + type-1 onboarding**. Fold into **P31**, which already owns roadmap bucket T.
|
||
|
||
---
|
||
|
||
# 🏆 WHAT S39–S42 DID
|
||
### S6 — BOTH "PERMANENT" GIANT WALLS CRACKED ×138 (+50,094 ins)
|
||
| wall | recorded verdict | what it took |
|
||
|---|---|---|
|
||
| `func_80178004` 165×138 = 22,770 | P26: Fable5, **~477k tokens**, "intrinsic 3-integer regalloc wall" | **a stored draft, gated as-is, no new work** |
|
||
| `func_801412A8` 198×138 = 27,324 | close=29/110 since P24 | 1 of **31** stored drafts + the §37/§124 alias |
|
||
**Why #2 looked intrinsic:** TU declares `extern int f(int×6)` and callers USE the return, but the
|
||
byte-true def returns a pointer and takes two `u16`s — so **the byte difference is in the CALLERS,
|
||
which `match_one` never compiles.** Propagation then returned 0/137 **twice**, both times a missing
|
||
TYPE (`_carry_macros` carries `#define`s but **not typedefs**, and is **not transitive**). **→ cookbook §146.**
|
||
|
||
### The `cast_call_sites` BUG — it DELETED `return` STATEMENTS
|
||
`return func_X(…);` — `return` is a valid identifier where `DECL_LINE_RE` expects a type, so the
|
||
"rewrite decl to canonical" path replaced the STATEMENT with a declaration. C89 → `parse error before
|
||
'extern'`, which reads as the DRAFT's fault. **Fix = statement-keyword guard. Sweep 0/39 → 18/39.**
|
||
⚠️ **Routing it through `cdecl` (the obvious R33 move) is a SILENT NON-FIX** — `cdecl.parse()` calls
|
||
`return func_X(…)` a declaration of `func_X` and `if (f(a));` a declaration of `if`. **Checked before
|
||
shipping.** In `gate_stage`'s DEFAULT pipeline since Phase 20; **318 of 44,833 stored drafts** carry a
|
||
line it mis-reads. **→ §143.**
|
||
|
||
### S1e — the "distinct-code regression" NEVER HAPPENED
|
||
A **stale committed digest** (`commit:1426` generated from a tree holding work reverted before the
|
||
commit landed; overstated +7,879 ins / +130 uniq). True delta: **everything rose.** Fixes:
|
||
`progress.py stub_addrs` no longer swallows `corpus.stubs` (it had reported **100.00%/100.00%** in a
|
||
tree with no `asm/`); the same swallow fixed in `cast_call_sites.tu_for` + `reconcile_tu.tu_for`
|
||
(they silently reconciled against the WRONG TU); **NEW `make audit-digest`. → §140.**
|
||
|
||
### S5 — two waves, 24 exemplars, 24/24 banked, **ZERO codegen walls**
|
||
Pool verified first (R14): **1,677 clusters / 5,795 fns / 319,755 ins at 3.68×** (Fable claimed 2.7× —
|
||
accurate here, though its whale claim was 3/4 wrong: **verify each claim separately**). Wave 1 8/8
|
||
match_one → 5/8 gate → **8/8 after recovery**; wave 2 16/16 → 14/16 → **16/16**. All six first-pass
|
||
failures were TU-integration plumbing with documented levers. **⇒ THE GATE NUMBER MEASURES
|
||
INTEGRATION, NOT MATCHING — run the recovery ladder BEFORE recording a wave's yield.** Then **61/87
|
||
members propagated**. 3.73M subagent tokens, 0 errors.
|
||
|
||
### S4 (REDONE — the first pass was wrong) · S7 · §134
|
||
**S4:** the first pass re-gated only the NEWEST draft per head (8 banked). **S6 proved that is
|
||
sampling** — its giant's match was the 9th of 31. Rescanned ALL drafts over 38 targets: **14 matched
|
||
on disk, 7 banked**, incl. `func_8018057C` (897 ins) that was on the "needs an agent" list.
|
||
**S7:** main's sig regenerated (1,729→2,205 sigs; stub coverage 1,525→**2,001 of 2,002**) — **main is
|
||
now the single largest open target at 79,074 ins / 10.7% of all open code**, and only became visible
|
||
at that size today. **§134 CLOSED:** the last two line-shape scanners route through `cdecl._mask`.
|
||
|
||
### NEW COOKBOOK THIS SESSION — §140 §141 §142 §143 §144 §145 §146 §147
|
||
**§147 (from the serial run, most transferable):** the **three-stratum frame law** — stratum 3 is a
|
||
trailing block `?:` chains allocate and never reference, **unreachable from C**; the 30-second test is
|
||
*delete the min/max tail, re-read `.frame … # vars=`; the drop IS stratum 3*. Plus: a `?:` on MEMORY
|
||
operands costs ~16 bytes of frame and on REGISTER operands zero; inner-block declaration does NOT
|
||
delay slot allocation (**byte-refuted**); a lone `$t8`/`$t9` is RELOAD SCRATCH (reproduce the spill,
|
||
don't pin — the pin CREATED a diff); a `qty_compare` tie is **not spelling-reachable** (72 statement
|
||
permutations × 4 decl orders × 7 retypings × pins × permuter, floor never moved).
|
||
**§142** the free `h_exact` pool (propagate the MATCHED body, don't gate a draft) · **§144** the
|
||
literal's SPELLING picks the immediate encoding (`cnt + 0xff` vs `cnt - 1`) · **§145** combine_givs
|
||
anchor rule / `p = r;` combine barrier / chained assignment stores right-to-left.
|
||
|
||
---
|
||
|
||
# ▶ RESUME HERE
|
||
1. **Serial crack queue** (Drew's explicit choice: SERIAL, one agent per fn, so a transferable idiom
|
||
makes the rest cheaper). Order + status:
|
||
`func_8017C294` **NEAR(12)** — draft `.run/s42/ov_SC01_077/`, blocked on §147-A stratum 3;
|
||
**DO NOT spend its 15 siblings until that is explained** (all hit the same 12; `family_remap`
|
||
takes all 16 in one pass when it closes).
|
||
`func_8017C6F4` (947×3) — **NEAR(63)** pin-free (`.run/s42/ov_SC03_126/func_8017C6F4.c`); a
|
||
`register … __asm__("$13")` variant reaches **47** (`.pin-t5.c`). Frame `0x120` + `vars=232` EXACT;
|
||
all opcodes/immediates/stack-offsets/branch-targets correct; residual is ONE register rotation
|
||
(`mnc`→`$a0` mine vs `$t0` target, cascading `xmx1`→`$t1`, `cell`→`$t3`, `prim`→`$t5`). Did not
|
||
move under ~40 probes (decl order, inner-block scoping, split X/Y, statement order, aliasing,
|
||
direct-field reads, 6 pin combos). **NEXT MOVE: demacroize so the permuter can be aimed** —
|
||
`run_masked` currently fails "Function not found in base.c" because the `gte_*` `#define` block
|
||
defeats `make_base_c`. Idioms → **§148**.
|
||
⚠️ **The agent claimed all sixteen 947-ins instances are ONE body (→ 15,152 ins on one crack).
|
||
I CHECKED AND IT DOES NOT HOLD:** its draft scores 63 on ov_SC03_126 but **340** on both
|
||
`func_8017C59C` and `func_8017CF90`, with an IDENTICAL first diff on each — so those two match
|
||
each other, not the cracked one. Consistent with the h_norm clustering (947×3, 947×2, singletons):
|
||
**several groups, not one of 16.** Test a ×N claim by `sed`-renaming the draft and running
|
||
`match_one` against the sibling's asm — a normalized diff says "same shape", only that says
|
||
"same body" (§148-E).
|
||
Then: `func_8017C59C` (947, reach 6) · `func_8017CE58` (733×3) · `func_8017EF68` (969) ·
|
||
`func_8017D538` · `func_8017C974` (close=47, re-measure first) · `func_8017DF98` ·
|
||
`func_8017CF90` · `func_8018D98C`. *(`func_8018057C` already banked free.)*
|
||
**Every brief MUST open with the all-drafts scan and the §147-A frame test.**
|
||
2. **Then L1+L2 disc audit (task #10), then L3 + type-1 onboarding (task #11).**
|
||
3. **Cheap fuel any time:** the **26 unpropagated members** (20 CC1-FAIL + 5 callee conflicts:
|
||
`func_8017EFA0` ×3, `func_8012B23C` ×2) — levers exist. **FIRST FIX THE CLASSIFIER:** it writes
|
||
`CC1-FAIL: make: *** Error 33` **without the cc1 message**, so each costs a manual splice-and-
|
||
rebuild to diagnose (done 3× today). `harvest_verify` already captures cc1 stderr — copy that.
|
||
4. **Also open:** the 263×5 cluster (`0x80182fd4`) sweeps **0/5**, `parse error before 'unsigned'`,
|
||
**undiagnosed — do not assume codegen** · 7 S4 drafts still near/failed in `.run/s41/rec/` ·
|
||
the 61 SC07 `-O0` members · `func_80183BAC`'s R22 revert (capture WHICH binary this time) ·
|
||
2 resident stubs with gate-rejected match_one-MATCH drafts.
|
||
|
||
# 💾 THE SERIAL DRAFTS ARE NOW COMMITTED — AND ONE LEDGER ROW IS A RUMOUR
|
||
The two NEAR drafts (~680k subagent tokens) were **gitignored**, one `git clean` from gone. A curated
|
||
`/.run/s42/` allowlist now tracks them; both are logged to the backlog with measured closeness, class,
|
||
reach and draft path:
|
||
`.run/s42/ov_SC01_077/func_8017C294.c` NEAR **12** / 246
|
||
`.run/s42/ov_SC03_126/func_8017C6F4.c` NEAR **63** / 947 (frame 0x120 + vars=232 EXACT)
|
||
`.run/s42/ov_SC03_126/func_8017C6F4.pin-t5.c` NEAR **47**, `register … __asm__("$13")` variant
|
||
|
||
⚠️ **`func_8017C6F4` carries a PRE-EXISTING backlog row `closeness=14` (2026-07-01, ov_SC03_010,
|
||
source=bulk-harvest) with `draft: None, klass: None, nins: None, reach: None`.** No artifact behind
|
||
it, and no draft of it survives on disk (the S42 agent scanned every stored draft: two, both junk).
|
||
**`load_best` takes the LOWEST closeness, so this unverifiable row OUT-RANKS today's real 63 in every
|
||
future target selection.** Same defect class as Phase 28's `func_80178004 close=0` myth (truth 91).
|
||
**Treat the 14 as UNVERIFIED; start from the committed 63/47 drafts; purge the row if it cannot be
|
||
reproduced.** General rule worth adopting: *a backlog row with no draft artifact is a rumour, not a
|
||
result* — `backlog.py log` should require a draft path or mark the row unverifiable.
|
||
|
||
# 🧰 MY PROCESS ERRORS THIS SESSION (all caught; each is a rule now)
|
||
1. **Sampled instead of scanning** — `head -8` of 31 drafts, reported "closeness 40" for a function
|
||
whose MATCH was in the 9th. Cost: nearly skipped a 27,324-ins crack.
|
||
2. **Substring false positive** — `grep -c "Prim_1412A8"` matches inside `addPrim_1412A8`; I briefly
|
||
concluded a type-carry worked when it hadn't.
|
||
3. **Lift without strip** — lifted typedefs to `engine_types.h` without removing the originals →
|
||
duplicate typedef → **R22 139/140**. `build_engine_types --strip` does both.
|
||
4. **Nearly ran `make clean` (deletes `asm/`) while 8 agents were reading it.**
|
||
5. **Asserted two mechanisms before deriving either** (S1e) — three greps settled it; I ran them third.
|
||
6. **A worktree probe that silently measured the wrong tree** (symlinked `tools/` → `ROOT` resolved
|
||
back to the main repo). A control that cannot fail is not a control.
|
||
7. **Wrong `match_one` flags in the wave-1 prompt** (`--binary/--src`; real: `--c/--asm-subdir`).
|
||
|
||
---
|
||
|
||
# 🛑 SESSION-39 CHECKPOINT (2026-08-04) — FRESH SESSION SAFE HERE
|
||
> **NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN** but for the R23 `db.*.gbf` churn — never stage.
|
||
> Effort **xHigh**. **R22 run FOUR times: 140/140 every time. No failures, nothing reverted.**
|
||
> **NO phase close — keep grinding.** Plan = **T7**; full report `.run/fable_frontier/ANALYSIS.md`.
|
||
> **VERIFY:** `git log --oneline -4` at/near HEAD + `docs/progress.fleet.md` agrees with FLEET below.
|
||
|
||
## FLEET — R22 **140 passed / 0 failed of 140** (run ~14× this session, 140/140 every time)
|
||
**96.51% fn-count (341,365/353,717) · 94.4% instr-weighted (12,419,169/13,160,961) · 89.0%
|
||
distinct-code (5,029,454/5,654,184; 77,973 uniq)** · 0 NON_MATCHING · audit-digest OK.
|
||
Session opened 341,186 / 12,405,402 / 77,952 ⇒ **+13,767 instructions, +21 unique fns, +179 fn-count**,
|
||
**~0 agent tokens — NO WAVE WAS RUN.** Every gain came from re-gating stored work, mechanical
|
||
propagation, and fixing instruments.
|
||
**⚠️ THE DENOMINATOR MOVED +19,309 ins (main's sig regen, S7).** instr 94.5%→94.4% and distinct
|
||
89.3%→89.0% are a **DENOMINATOR CORRECTION, NOT a regression** — both numerators are unchanged across
|
||
that edit. main's sig covered only 1,525 of its 2,002 stubs (dated 2026-06-14); now 2,001/2,002 (the
|
||
1 is `func_80049600`, a LINKED PsyQ region the Ghidra sig excludes by design). Phase-27 precedent:
|
||
an honest denominator moves the headline DOWN.
|
||
|
||
## 🔑 THE SESSION'S HEADLINE — S38's "distinct-code REGRESSION" NEVER HAPPENED
|
||
The v4 checkpoint gated the phase's best lever on it (*"do NOT scale the alias lever"*). It was a
|
||
**STALE COMMITTED DIGEST**. `commit:1426`'s digest was generated from a working tree still holding work
|
||
**reverted before the commit landed** (+7,879 ins / +130 uniq overstated) and never regenerated, so
|
||
the next HONEST digest read as a fall.
|
||
|
||
| | instr | distinct | uniq |
|
||
|---|---|---|---|
|
||
| `commit:1426` **true** | 12,394,533 | 5,022,306 | 77,895 |
|
||
| `commit:1426` *as committed* | 12,402,412 | 5,029,324 | **78,025** |
|
||
| its successor, true **=** committed | 12,405,402 | 5,025,082 | 77,952 |
|
||
|
||
**True delta over that span: instr +10,869 · distinct +2,776 / +57 uniq — EVERYTHING ROSE.**
|
||
**⇒ THE ALIAS LEVER IS UNGATED.** Both recorded leads were wrong (R14): `progress.py:423`'s `SIG`
|
||
feeds **fn-count only** (neither weighted metric sees a C identifier — both derive
|
||
`matched = sig − corpus.stubs`), and "reverted to INCLUDE_ASM" died on one grep (**483 removed, 0 added**).
|
||
|
||
**THE 3-GREP PROOF, before forming any hypothesis about a metric move:** identical sigs (both
|
||
denominators unchanged) + unchanged `tools/` + `git diff A B -- src/ | grep -c '^+.*INCLUDE_ASM('` = 0
|
||
⇒ HEAD's stub set is a strict SUBSET ⇒ both numerators are **mathematically forbidden to fall**.
|
||
|
||
## 🧰 FOUR INSTRUMENT DEFECTS FIXED — all ONE class: a bare `except` around a fail-CLOSED oracle
|
||
1. **`progress.py stub_addrs`** swallowed `corpus.stubs`' refusal → empty stub set → `matched = sig −
|
||
stubs` credited EVERY function. **Byte-witnessed reporting instr 100.00% / distinct 100.00%** in a
|
||
tree with no `asm/`. Now propagates.
|
||
2–3. **`cast_call_sites.tu_for` + `reconcile_tu.tu_for`** — identical swallow, falling back to the
|
||
default `<ov>.c` instead of the `_jr_`/`-O0` split TU: **the exact bug `cast_call_sites`' own
|
||
docstring says it exists to fix.** A wrong-TU reconcile fails the gate, and the phase's base rate is
|
||
~24k PLUMBING vs 4,917 DIFF ⇒ it presents as a codegen wall. Both propagate; `ValueError` fallback
|
||
for curated names kept; derived path re-verified on a `_jr_` stub.
|
||
4. **NEW `make audit-digest`** (`tools/audit_digest.py`, in `tools-health` after `report`) — recomputes
|
||
the three headline metrics from the tree and fails if the committed digest disagrees. **Compares
|
||
INTEGERS, not percentages** (the staleness printed "94.4%" on both sides). Negative-control-proven
|
||
against the stale digest. R34: the byte-gate is a null oracle for DOCUMENTS.
|
||
|
||
## ✅ BANKED THIS SESSION (+4,727 ins, every step R22 140/140)
|
||
| what | ins | note |
|
||
|---|---|---|
|
||
| **the whale ×1 → 138/138** (`ov_SC07_010`) | **+770** | `o0_subsplit --lo 0x80144B9C --hi 0x801457A4`; 0 already-matched in range ⇒ no §126 island; split byte-neutral FIRST, then banked. S38's stated cause (reused `_o0c`) did not recur — `free_letters` derives an unused suffix. |
|
||
| **4 wave-6 drafts** (SC06_032 710 · SC03_001 557 · SC04_018 513 · SC02_027 125) | **+1,905** | **banked UNCHANGED — see the finding below** |
|
||
| **`func_801878E8` family 4/4 siblings** | **+2,052** | `jtbl_family_bank.py`, ~0 agent tokens |
|
||
| **4 re-gated stored drafts** (the 2 REVERTED overlays) | **+146** | `ov_SC06_030` ×2 · `ov_SC07_010` ×2; incl. a fleet-wide `engine_core.h` no-proto arity edit proven byte-neutral |
|
||
| **8/35 draft-exemplar heads** re-gated | **+474** | 4 gate cycles, 0 agent tokens; 23% vs 8% for the general pool |
|
||
| **5 families propagated ×N** (10 siblings) | **+718** | `jtbl_family_bank`; 1 family auto-REVERTED on R22 (§61), 1 found nothing |
|
||
| **`func_801758FC` ×137** | **+7,535** | **the largest free h_exact class** — see the third finding |
|
||
| **8 small free h_exact classes** | **+175** | the rest of that pool `--addr` could reach |
|
||
|
||
## 🔑 THE SECOND FINDING — RE-GATE STORED DRAFTS AFTER ANY TOOL REPAIR
|
||
All 4 wave-6 drafts banked with **no change to the drafts**. S38 recorded them blocked on a class
|
||
needing a crack (*"cracking this one class frees 6 drafts at once"*); they had **already been freed by
|
||
S38's own tool repairs** (the `jr_isolate_all`/`overlay_src_split` alias-DEFINITION-deletion blindness
|
||
+ `harvest_verify._reload_corpus`). The drafts were correct; the instruments were failing them.
|
||
**A stored verdict is only as current as the instrument that produced it** (R35, applied to the backlog
|
||
rather than to metrics). **This is the 5th "wall" this phase to resolve to our own tooling.**
|
||
|
||
## 🔑 THE THIRD FINDING — MEASURE THE FREE POOL, DON'T TRUST THE REPORT
|
||
`.run/fable_frontier/ANALYSIS.md` claimed the whale was "open only in SC07_006/007/010/011" — **3 of
|
||
those 4 were already banked**; only 010 was open (closed this session). Its pool numbers are **not
|
||
reliable** (the checkpoint's own R14 caveat, now demonstrated). Re-measured from the bytes instead:
|
||
**215 open instances / 8,763 ins are h_exact-identical to an already-matched function**, and ONE class
|
||
was 86% of it — `func_801758FC`, 55 ins, same address in all 138 overlays, matched in `ov_SC01_000`,
|
||
open in **137**. `dedup_propagate --addr` banked all 137 byte-identical (**+7,535 ins**).
|
||
**It had been in the stored-draft backlog and re-gated "no" earlier the same night** — because gating
|
||
a DRAFT is the wrong move for an h_exact class; propagating the MATCHED body is the free one. Same
|
||
function, two routes, only one is free. **Remaining free pool: 66 instances / 1,061 ins across 25
|
||
classes, all macro-backed (so `--addr` refuses — they need a `dedup_extend`-style route).**
|
||
|
||
## 🏆 S6 (2026-08-05) — **BOTH GIANT WALLS CRACKED ×138, +50,094 ins** — FLEET **96.62% fn / 94.8% instr / 89.2% distinct**, 140/140
|
||
The two functions the roadmap carried as **PERMANENT WALLS since Phase 24** are matched in all 138
|
||
overlays. **Neither needed a siege — both matched from drafts ALREADY ON DISK.**
|
||
|
||
| wall | recorded verdict | what it took |
|
||
|---|---|---|
|
||
| `func_80178004` 165×138 = **22,770** | Phase 26: Fable5, **~477k tokens**, "intrinsic 3-integer regalloc wall" | a stored draft, gated as-is, **no new work** |
|
||
| `func_801412A8` 198×138 = **27,324** | close=29/110 since Phase 24 | 1 of **31** stored drafts + the §37/§124 alias |
|
||
|
||
**Why the second looked intrinsic:** its TU declares `extern int func_801412A8(int×6)` and callers USE
|
||
the return, while the byte-true def is `Prim_1412A8 *(Prim_1412A8*, int,int,int, u16,u16)`. Narrow
|
||
params can't agree with an `int` prototype and the no-proto escape is illegal once a param promotes —
|
||
so the byte difference lives in the **CALLERS**, which `match_one` never compiles. The measuring
|
||
instrument was blind to where the difference was.
|
||
**Propagation then returned 0/137 TWICE, both times a missing TYPE:** `_carry_macros` carries
|
||
`#define`s but **not typedefs**, and is **not transitive**. Lifted `Env_1412A8`/`PTag_1412A8`/
|
||
`Prim_1412A8` + `OT`/`getaddr`/`setaddr` → **137/137**.
|
||
**MY ERROR, caught by the gate:** lifted without STRIPPING the originals from `ov_SC01_077.c` →
|
||
duplicate typedef → R22 **139/140 `[FAIL] ov_SC01_077`**. Stripped → 140/140. *A proper lift strips
|
||
the source (`build_engine_types --strip`).* Also: my first draft scan used `head -8` of 31 and missed
|
||
the match in the 9th. **SCAN, don't sample.** cookbook **§146**.
|
||
|
||
### 🚨 ROADMAP DELTA — the "2 permanent giant walls" line is RETIRED
|
||
Every roadmap/backlog reference to `func_801412A8` + `func_80178004` as permanent INCLUDE_ASM walls is
|
||
now false. **P32's behemoth/wall track loses its two headline items.** More importantly the *class* of
|
||
claim is suspect: **when a tool is repaired, every verdict it produced becomes a HYPOTHESIS again.**
|
||
The backlog's `closeness` values and residual classes were produced by tooling that has changed
|
||
materially this session (§143 alone). **Re-measure before respecting any of them.**
|
||
|
||
## 🚀 S40 (2026-08-05, ULTRACODE) — FLEET **96.54% fn / 94.5% instr / 89.2% distinct**, 140/140
|
||
**Session arc: 12,405,402 → 12,432,941 instr (+27,539), +120 unique fns**, R22 green at every step.
|
||
⚠️ The denominator is now **13,160,961** (was 13,141,652) — main's sig regen made it honest. Compare
|
||
percentages only across the same denominator; the numerator never fell.
|
||
|
||
### THE `cast_call_sites` BUG (the session's most consequential find)
|
||
It read a RETURN STATEMENT as a prototype and **deleted it**. `return func_X(…);` — `return` is a
|
||
valid identifier where `DECL_LINE_RE` expects a type — so the "rewrite this decl to canonical" path
|
||
replaced the STATEMENT with `extern … func_X(…);`. C89 then says `parse error before 'extern'`, which
|
||
reads as the DRAFT's fault. **Fix = a statement-keyword guard.** `family_sweep` over 5 families went
|
||
**0/39 → 18/39**; the same machinery later propagated **24/24** and **61/87**.
|
||
**⚠️ THE TRAP INSIDE THE FIX:** routing it through `cdecl` (the obvious R33 move) is a **SILENT
|
||
NON-FIX** — `cdecl.parse()` calls `return func_X(…);` a declaration of func_X and `if (f(a));` a
|
||
declaration of `if`. It parses declarator GRAMMAR; statement-vs-declaration is not a question it
|
||
answers. **Checked before shipping.** Blast radius: in `gate_stage`'s DEFAULT pipeline since Phase 20;
|
||
**318 of 44,833 stored drafts** carry a line it mis-reads, across 67 callees. cookbook **§143**.
|
||
|
||
### THE WAVES — 24 exemplars, 24/24 banked, **ZERO codegen walls**
|
||
Pool VERIFIED first (R14): **1,677 clusters / 5,795 fns / 319,755 ins at 3.68×** vs Fable's claimed
|
||
1,689 / 5,956 / 326,261 at 2.7× — accurate here, and the multiplier is BETTER. (The SAME document's
|
||
whale claim was 3/4 wrong. **Verify each claim; never accept or reject a source wholesale.**)
|
||
|
||
| wave | targets | match_one | gate 1st pass | after recovery |
|
||
|---|---|---|---|---|
|
||
| 1 | 8 | 8/8 | **5/8** | **8/8** |
|
||
| 2 | 16 (lessons folded into the prompt) | 16/16 | **14/16** | **16/16** |
|
||
|
||
**ALL SIX first-pass failures were TU-integration plumbing with documented levers** — §77 probe-layer
|
||
strip · `recover_giant` block-scoping · §37/§124 def-side asm-label alias · §17a-1 no-proto + call-site
|
||
cast. **⇒ THE GATE NUMBER MEASURES INTEGRATION, NOT MATCHING.** Run the recovery ladder BEFORE
|
||
recording a wave's yield, or the metrics under-report the drafters and send the next wave hunting
|
||
walls that are not there (`docs/wave-metrics.md` S40-1). Cost 3.73M subagent tokens / 24 agents / 0 errors.
|
||
Then **61/87 members propagated** (+7,087 ins).
|
||
|
||
### NEW IDIOMS (all byte-derived by the drafters, distilled in-session)
|
||
**§144** the LITERAL'S SPELLING picks the immediate encoding (`cnt + 0xff` vs `cnt - 1` — mod-256
|
||
identical, both one `addiu`, but gcc emits 0x00FF vs 0xFFFF from the source text; looks exactly like an
|
||
intrinsic wall and is free) · **§145a** `combine_givs` anchors the address-giv group on the LAST
|
||
address-giv in SOURCE order · **§145b** a bare `p = r;` is a COMBINE BARRIER that preserves a
|
||
pointer-bump `addiu` · **§145c** chained assignment emits stores RIGHT-TO-LEFT.
|
||
|
||
### ▶ CHEAPEST FUEL NEXT SESSION (all named, all deterministic)
|
||
1. **The 26 unpropagated members** (20 CC1-FAIL + 5 callee `conflicting types`: `func_8017EFA0` ×3,
|
||
`func_8012B23C` ×2) — the recovery ladder already has every lever.
|
||
2. **FIX THE CLASSIFIER FIRST:** it writes `CC1-FAIL: make: *** Error 33` **without the cc1 message**,
|
||
so 20 of those 26 carry no actionable reason and each costs a manual splice-and-rebuild to diagnose
|
||
(done twice this session). `harvest_verify` already captures cc1 stderr — do the same here.
|
||
3. **Scale the wave** — the verified pool still holds ~450 tractable clusters; both waves closed 100%.
|
||
4. Carried: the 61 SC07 `-O0` members · `func_80183BAC`'s R22 revert (my loop logged THAT check-all
|
||
failed, not WHICH binary — capture the failing binary on the retry) · S6's 2 giant walls (50,094
|
||
ins on 2 cracks, untouched) · main's 79,074-ins tail (agent work, structurally barren).
|
||
|
||
## 🌙 OVERNIGHT (S39 cont., 2026-08-05 ~00:40–)
|
||
**`tools/grinder.py -j 14 --cycles 4 --permute-secs 240 --max-closeness 20 --max-nins 400`** — the
|
||
token-FREE permuter daemon, running the P30-T4 ILS warm-restart whose yield was **never proven**.
|
||
Targeting ON: 1,286 classified, only `bucket=permuter` admitted (skipped 805: 447 redraft, 272
|
||
structural, 53 integration). **First evidence the ILS wiring does something:** `func_80182C9C` hit
|
||
"best 5, warm-restarting" (a cold search would have restarted from scratch). **It commits its own
|
||
verified banks** (`gate_stage --no-propagate`, §55b).
|
||
**⚠️ MORNING: its banks are per-binary gated but NOT fleet-verified — run a full R22 before
|
||
treating them as a fleet claim (§61), then `make report` + propagate anything it landed.**
|
||
Log `.run/s39/grinder.log`; 6h box from 00:42.
|
||
|
||
### Also delivered overnight (all zero-agent, all committed)
|
||
- **§134 CLOSED** (task #7) — the last two line-shape scanners (`progress.py.strip_comments`,
|
||
`lint_symbol_refs.strip_comments_strings`) now route through `cdecl._mask`. The progress one was
|
||
**not string-aware**, so a `}` inside a string literal walked the body-depth to −1 and would
|
||
mis-bucket a function in fn-count; metrics identical before/after (a latent defect). cookbook §141.
|
||
- **main's sig regenerated** (task #6/S7) — 1,729→2,205 sigs, stub coverage 1,525→**2,001 of 2,002**.
|
||
Denominator +19,309 ⇒ the honest re-baseline above. **MCP IS DOWN** (I stopped it for the lock);
|
||
SessionStart restarts it — **run `/mcp` before any Ghidra work (R29)**.
|
||
- **`make audit-frontier`** (task #9, Drew's MASTER_REMAINING in its DERIVED form) — reconciles every
|
||
"what's left" view against `corpus.stubs`; on first run caught `family_hseq` publishing 11,456
|
||
unmatched instances when only 11,297 are still open (**delta +159**, the map predates tonight's
|
||
banks). **Deliberately NOT in `tools-health`** — additive until Drew has seen it; `--strict` exits 1.
|
||
Assessment in `docs/decision-log.md`: adopt the goal, reject the maintained list (R33).
|
||
- **`docs/frontier-s39.md`** — measured frontier + the T5 burn-down, with the **−0.14pp last row
|
||
annotated as a denominator correction, not a regression** (T5 must not report it as one).
|
||
**main is now the single largest open target: 79,074 ins / 2,001 stubs = 10.7% of all open code.**
|
||
- **cookbook §142** — the free-`h_exact` lever and the trap that hid it.
|
||
|
||
## ▶ RESUME HERE
|
||
1. **S4 continues** (task #3): the **39 draft-exemplar families (382 members)** + the **2 resident
|
||
stubs** that already have `match_one`-MATCH drafts gate-rejected for TU plumbing.
|
||
⚠️ **Do NOT blanket-re-gate the stored backlog — MEASURED this session** (`docs/calibration.md`):
|
||
fresh wave-6 drafts **4/6**, unbiased stored sample **1/12**, the two REVERTED overlays **3/17**.
|
||
**A10's 0/958 broadly STANDS**; 1,155 whole-binary builds are not justified by ~8%. The rule is
|
||
narrower: **re-gate the drafts a repair plausibly touched, targeted by its blast radius.**
|
||
2. **S5 the wave** (task #4) — 1,689 h_norm clusters / 326,261 ins at a claimed 2.7×. **VERIFY Fable's
|
||
pool numbers first (R14 — its two headline refutations were re-verified, its POOL NUMBERS were
|
||
NOT)**, then ONE 8-target calibration wave, measure REALIZED propagation. **Prompt for the toggle (R27).**
|
||
3. **S6/S7** — the 2 giant exemplar walls (50,094 ins on 2 cracks); then main (regen its 7-week-stale
|
||
sig FIRST — missing 757 of 2,002 stubs).
|
||
4. **NEW (Drew, 2026-08-04, task #9 — do NOT start without his go):** the **frontier reconciliation
|
||
gate + denominator completeness** (his MASTER_REMAINING idea in its derived form). Full assessment
|
||
in `docs/decision-log.md`: adopt the goal, reject the maintained list (R33). Fits P31's opener.
|
||
5. **Carried, not lost:** the **61 SC07 `-O0` members** (S3's untouched half) · the §134→`cdecl._mask`
|
||
consolidation (task #7; the class has now appeared in SIX tools) · `progress.py`'s `SIG` alias
|
||
blindness (fn-count only — resolve defs through `overlay_src_split.asm_label_aliases`, R33).
|
||
|
||
## 🚧 LEFT ON THE BACKLOG AS GENUINE (not forced, P9)
|
||
`func_8017C974` (ov_SC01_077, 947 ins, close=**47**, REGALLOC-PERM, 12 permuter variants inert) ·
|
||
`func_80188C68` (ov_SC03_124, 551 ins, close=**370**, the only target with no twin anywhere).
|
||
|
||
## 📌 A METRIC SHAPE WORTH KNOWING (R30)
|
||
A body banked by `#include`-ing a shared header is **invisible to fn-count's NUMERATOR** (the
|
||
definition is not in the `.c`) while its stub leaves the denominator — the whale bank moved fn-count
|
||
`341186/353718 → 341186/353717`. The **weighted** metrics counted it correctly (+770) because they
|
||
derive from `corpus.stubs`, not re-parsed C. **Trust the weighted pair.** Same root as the `SIG` lead.
|
||
|
||
## 🧰 MY PROCESS ERRORS
|
||
1. **Asserted two mechanisms before deriving either** — the recorded `SIG` lead (feeds fn-count only)
|
||
and "the harvest reverted functions to INCLUDE_ASM" (483 removed, **0 added**). Three greps settle
|
||
it; I ran them third instead of first. **R14/R37 — derive, then assert.**
|
||
2. **Built a worktree probe that silently measured the wrong tree** — symlinking `tools/` made `ROOT`
|
||
resolve back to the main repo, so the "843 tree" reported HEAD's numbers. Caught because the
|
||
numbers were *identical*, which was too good. A control that cannot fail is not a control.
|
||
3. **Chased the conflicting-decl bank one build at a time** (2 iterations) before enumerating all
|
||
collisions with `cdecl` in one pass — which found exactly 3 re-declarations, 2 conflicting.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-38 CHECKPOINT — **v4, POST-S1d** (2026-08-04)
|
||
> **NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN** but for the R23 `db.*.gbf` churn — never stage.
|
||
> Effort **xHigh**. **R22 run THIRTEEN times: 140/140 on eleven, TWO REAL FAILURES (both caught,
|
||
> both reverted, both recorded below).** **NO phase close — keep grinding.**
|
||
> Plan = **T7**; full report `.run/fable_frontier/ANALYSIS.md`; task list has 11 items.
|
||
> **VERIFY:** `git log --oneline -3` at/near HEAD + `docs/progress.fleet.md` agrees with FLEET below.
|
||
|
||
## FLEET — R22 **140 passed / 0 failed of 140**
|
||
**96.46% fn-count · 94.4% instr-weighted · 89.2% distinct-code** (77,952 uniq) · 0 NON_MATCHING.
|
||
Session opened 96.28 / 94.1 / 88.7 ⇒ **+37,166 instructions**, ~0 agent tokens after the opening wave.
|
||
**✅ RESOLVED S39 (S1e) — the "distinct-code FELL 89.3 → 89.2" alarm was a STALE COMMITTED DIGEST, not
|
||
a regression. True delta over that span: instr +10,869 · distinct +2,776 ins / +57 uniq — everything
|
||
ROSE. THE ALIAS LEVER IS UNGATED. Guard added: `make audit-digest` (in `tools-health`). See §140.**
|
||
|
||
## 🔑 THE SESSION'S BIGGEST FIND — the def-side asm-label alias is a CLASS lever
|
||
The dominant sweep blocker was `conflicting types for func_80146A6C` (**208 of ~398** conflicts).
|
||
Diagnosed by READING THE DRAFT after eliminating three levers by measurement:
|
||
draft def : void func_80146A6C(s16 a0, s32 a1, s16 a2, s16 a3, u16 a4, s32 a5, s32 a6)
|
||
TU decl : extern s32 func_80146A6C(s32 a0, void *a1, s32 a2, s32 a3, s32 a4, s32 a5, s32 a6);
|
||
**The NARROW PARAMS are the wall:** C default argument promotion means `s16`/`u16` cannot agree with
|
||
an `s32` prototype, and the `()` no-prototype escape is ILLEGAL *precisely* when a param promotes —
|
||
so NEITHER declaration side can move.
|
||
| lever | result | why wrong |
|
||
|---|---|---|
|
||
| `cast_call_sites` (already default-on) | no effect | fixes CALLEE decls, not the def's own |
|
||
| `--normalize-self-decls` | 0 banks + non-neutral reverts | fixes the target's decl in CALLERS |
|
||
| `--fix-def-sig` | **0/138**, error unchanged | cannot reconcile a promoting param at all |
|
||
| **§37/§124 def-side asm-label alias** | **138/138** | removes the DECLARATION from the equation |
|
||
void aF80146A6C(<byte-true params>) __asm__("func_80146A6C");
|
||
void aF80146A6C(<byte-true params>) { ... }
|
||
Zero blast radius; byte-neutral by construction. `.run/alias_defs.py` applies it to a staged set.
|
||
S33 proved this once on `func_80147364` (×137 first try, 1,725 in-tree precedents) — **it was never
|
||
generalised.** Generalised run: 971 drafts → 192 files → R22 140/140 (after 1 revert).
|
||
|
||
## ⚠️ TWO R22 FAILURES — "per-binary BANKED" IS NOT A FLEET CLAIM (§61)
|
||
Both passed their per-binary/per-draft gate and FAILED the clean-tree rebuild:
|
||
1. **`ov_SC07_010`** (S3) — its `-O0` split reused an EXISTING `_o0c` instead of a fresh `_o0d`,
|
||
creating region `_jr_801457A4` whose asm dir splat never generated. **Reverted; still open.**
|
||
2. **`ov_SC06_030`** (S1d) — `D_800AF648' undeclared in func_8017E120`: a draft that gated fine
|
||
broke once the REST of the harvest landed in the same TU (its decl displaced by another banked
|
||
draft's preamble). **Reverted.** In a WIDE harvest, per-draft acceptance is not even a per-TU
|
||
claim. The narrow 138/138 run was clean BECAUSE it was narrow ⇒ **prefer smaller batches.**
|
||
|
||
## ✅ T7 PROGRESS
|
||
| task | result |
|
||
|---|---|
|
||
| **S1a** lift local types | DONE — 895 types / 1,259 files |
|
||
| **S1c** re-sweep families | DONE — 97 members |
|
||
| **S1b** "wire the reconcile" | **PREMISE REFUTED** — already wired; NSD re-tested post-fix = 0 |
|
||
| **S2** jr families | DONE — 10 members; 7 families now CLASSIFIED |
|
||
| **S3** the whale | ✅ **COMPLETE — 138/138 (S39).** `ov_SC07_010` closed: `o0_subsplit --lo 0x80144B9C --hi 0x801457A4` (1 stub, **0 already-matched in range** ⇒ no §126 island; 3 regions, `_o0c` free) → split byte-neutral → banked via `../shared/func_80144B9C.h` → **R22 140/140 clean-tree**, fleet instr **+770** (12,405,402 → 12,406,172). The S38 cause ("reused an existing `_o0c`") did not recur — `o0_subsplit.free_letters` picks an unused suffix. Two decl conflicts hit on the way, enumerated with `cdecl` in ONE pass (R33) instead of one build at a time: of the header's 94 symbols the §8b carried layer re-declared 3, and 2 conflicted (`D_801274D0` `s32(*)(s32)`, `D_801274CC` `void*` vs header `s32`) — dropped, matching all 137 precedents (0 of them carry either), byte-neutral per §8c. **The 61 SC07 `-O0` members remain NOT attempted.** |
|
||
| **S1d** the alias class | **138/138 on family 1**; generalised harvest committed w/ the accounting caveat |
|
||
| **S1e** (#11) | ✅ **RESOLVED — THE REGRESSION NEVER HAPPENED (S39).** The `commit:1426` digest was committed **STALE** (generated from a tree still holding work reverted before the commit landed; overstated **+7,879 ins / +130 uniq**, never regenerated), so the next honest digest read as a fall. True delta 843→HEAD: **instr +10,869 · distinct +2,776 ins / +57 uniq — everything ROSE.** HEAD's digest reproduces EXACTLY. **⇒ THE ALIAS LEVER IS UNGATED — scale it (§61 small batches).** Both recorded leads were wrong (R14): `progress.py:423`'s `SIG` feeds **fn-count only**, and "reverted to INCLUDE_ASM" died on one grep (483 removed, **0 added**). Fixes: `stub_addrs` no longer swallows `corpus.stubs` (the bare `except` byte-witnessed reporting **100.00%/100.00%** in a tree with no `asm/`); **NEW `make audit-digest`** in `tools-health` (integers, not percentages — the staleness printed as "94.4%" both sides), negative-control-proven vs the stale digest; the SAME swallow fixed in `cast_call_sites.tu_for` + `reconcile_tu.tu_for`, where it reconciled against the **wrong TU** (the bug that file's own docstring exists to fix). cookbook **§140** · decision-log 2026-08-04. |
|
||
| **S4** draft-recovery | 🔄 **IN PROGRESS (S39) — the 6 open wave-6 drafts triaged; 4 BANKED (+1,905 ins), R22 140/140.** `func_801919A0` (ov_SC06_032, 710) · `func_80189030` (ov_SC03_001, 557) · `func_801878E8` (ov_SC04_018, 513) · `func_8018A564` (ov_SC02_027, 125). **⚠️ THE FINDING: all four banked UNCHANGED — no new work on the drafts.** S38 recorded them blocked on a class needing a fix ("cracking this one class frees 6 drafts at once"); they were already freed by S38's own tool repairs (the `jr_isolate_all`/`overlay_src_split` alias-DELETION blindness + `harvest_verify._reload_corpus`). The drafts were correct; the instruments were failing them. **⇒ RE-GATE STORED DRAFTS AFTER ANY TOOL REPAIR before treating a stored verdict as a fact about the code** — this is the 5th "wall" this phase to resolve to our own tooling. Note each bank also did a jtbl carve ⇒ config touched ⇒ fleet blast radius (R22 mandatory, run). **Left on the backlog as GENUINE codegen residuals (not forced, P9):** `func_8017C974` (ov_SC01_077, 947, close=47 REGALLOC-PERM, 12 permuter variants inert) · `func_80188C68` (ov_SC03_124, 551, close=370, no twin anywhere). **Family propagation DONE:** `func_801878E8` **4/4 siblings BANKED** (+2,052 ins, ~0 agent tokens) via `jtbl_family_bank.py` — `family_sweep --hseq` had correctly REFUSED it (§53 interlock: `has_mid_jr` ⇒ jtbl carve route, "a 0% from this path would be a TOOL artifact, not a wall"), and the tool requires a CLEAN tree (it reverts from HEAD per sibling), so the ×1 banks had to commit first. R22 140/140. **Stored-draft re-gate MEASURED (S39, `docs/calibration.md`):** A10's "0/958" was re-tested after S38's tool repairs — **fresh wave-6 drafts 4/6 · unbiased stored sample 1/12 · the two REVERTED overlays 3/17** (+146 ins banked: `ov_SC06_030` func_80161208/func_80162CCC, `ov_SC07_010` func_801506A4/func_8016F0AC; R22 140/140, incl. a fleet-wide `engine_core.h` no-proto arity edit proven byte-neutral). **A10 broadly STANDS** — ~8% on the general pool is not a harvest and a 1,155-wide sweep (1,155 whole-binary builds) is NOT justified. The real rule: **re-gate the drafts a repair plausibly touched, targeted by its blast radius — not the whole ledger.** **Still to do in S4:** the 39 draft-exemplar families (382 members) + the 2 resident stubs with gate-rejected match_one-MATCH drafts. |
|
||
| S5 · S6 · S7 | pending |
|
||
|
||
## ▶ RESUME HERE
|
||
1. ~~**S1e (task #11) FIRST**~~ ✅ **DONE (S39)** — no regression existed; the alias lever is ungated
|
||
and is the cheapest large lever on the board. Both recorded leads were wrong (R14): the
|
||
`progress.py:423` `SIG` lead feeds **fn-count only** (neither weighted metric sees a C
|
||
identifier — they derive from `matched = sig − corpus.stubs`), and the "reverted to INCLUDE_ASM"
|
||
theory died on one grep (483 removed, 0 added). Still worth doing opportunistically: the `SIG`
|
||
alias blindness is REAL for fn-count — resolve a def through its `__asm__` label via
|
||
`overlay_src_split.asm_label_aliases` (R33, reuse it) rather than a new regex.
|
||
2. ~~**`ov_SC06_030` + `ov_SC07_010`**~~ ✅ **DONE (S39).** `ov_SC07_010` whale banked → **138/138**, R22
|
||
140/140, +770 ins. `ov_SC06_030/func_8017E120` needed nothing — it is **already banked** (defined at
|
||
`ov_SC06_030_jr_8017C8D0.c:3491`); what S38 reverted was the surrounding batch, not that function.
|
||
**Metric note (R30, same class as S1e):** a body banked by `#include`-ing a shared header is
|
||
invisible to **fn-count**'s numerator (the definition is not in the `.c`) while removing its stub
|
||
from the denominator — the whale bank moved fn-count `341186/353718 → 341186/353717`. The
|
||
**weighted** metrics counted it correctly (+770) because they derive from `corpus.stubs`, not from
|
||
re-parsed C. Same root as S1e: `classify()` re-parses C and inherits blindness; trust the weighted pair.
|
||
**Still open here: the 61 SC07 `-O0` members** (S3's untouched half).
|
||
3. **S4** (task #6) + wave 6's 3 still-failing alias drafts (the three LARGEST — size-correlated).
|
||
4. **S5 the wave** (task #7) — 1,689 h_norm clusters / 326,261 ins at 2.7×. **VERIFY Fable's pool
|
||
numbers first (R14)**, ONE 8-target calibration wave, measure REALIZED propagation. **Prompt for
|
||
the toggle (R27).**
|
||
5. **S6/S7** — the 2 giant exemplar walls (50,094 ins on 2 cracks); then main (regen its 7-week-stale
|
||
sig FIRST — missing 757 of 2,002 stubs).
|
||
|
||
## 🧰 ELEVEN TOOL DEFECTS FIXED — nine of the ten "walls" were our own instruments
|
||
`harvest_verify._reload_corpus` (deleted the stub it had just followed through a carve → **10 of
|
||
wave 6's 16 drafts vanished with no verdict**) · `.run/s6f_gate.py` (booked a crash as silence; now
|
||
asserts 1:1 accounting + exits 1) · `classify_fail` (truncated the symbol away) · `jr_isolate_all`/
|
||
`overlay_src_split` (**silently DELETED** def-side alias functions — FIFTH tool with that blindness,
|
||
fixed in `family_remap` and never propagated) · `partition`/`_partition` (now REFUSE to rewrite when
|
||
an address won't resolve, R32) · the type-scope class (**895 types lifted**) · `jtbl_family_bank`
|
||
(`gate-fail` with no reason) · `family_hseq` stdout (overlays-only called "fleet") · **my own alias
|
||
scanner (the §134 defect I documented that morning — caught by the R32 guard I added that morning)**
|
||
· the S3 ambient filter's `endswith(';')` (§134 again).
|
||
**§134 has appeared in SIX tools. The fix is routing every line-shape decision through `cdecl._mask`
|
||
(R33), not a seventh patch.**
|
||
|
||
## 🧰 MY PROCESS ERRORS
|
||
1. **Claimed `family_sweep` hides per-member errors** — FALSE; **23,211 `.classified.txt` files**
|
||
exist and both of the day's zeros were already diagnosed in them. Two probes wasted.
|
||
**READ THE PAYLOAD FIRST.**
|
||
2. **Called 4 families "chance collisions"** while my own printout showed them `PURE`/`IMM`.
|
||
3. **Reverted `config/` and re-extracted ONE overlay of sixteen** — a gate cycle read 3 real banks
|
||
as failures against stale asm (the Phase-20 R22 corollary).
|
||
4. **A backticked `` `make extract` `` in a `-m` message EXECUTED** — use quoted heredocs.
|
||
5. **`… | tail` swallowed a non-zero exit**, and later **`tail -5` destroyed a gate summary** I then
|
||
could not report. A pipeline's status is the LAST command's; don't pipe away evidence.
|
||
6. **Looked a just-banked head up in `members`** — it moves to `exemplar.kind='matched'`.
|
||
7. **Reported "138/138" for the whale before R22 spoke** — it was 137/138.
|
||
No bad bytes from any of them — the byte-gate and R22 caught everything.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-38 CHECKPOINT v3 — POST-S1/S2/S3
|
||
> **NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN** but for the R23 `db.*.gbf` churn — never stage.
|
||
> Effort **xHigh**. **R22 clean-fleet run TEN times; 140/140 on nine, ONE REAL FAILURE (see S3).**
|
||
> **NO phase close — keep grinding.** Plan = **T7**; full report `.run/fable_frontier/ANALYSIS.md`.
|
||
> **VERIFY BEFORE TRUSTING:** `git log --oneline -3` at/near HEAD + `docs/progress.fleet.md` agrees.
|
||
|
||
## FLEET — R22 **140 passed / 0 failed of 140**
|
||
**96.32% fn-count · 94.4% instr-weighted · 89.3% distinct-code** (78,025 uniq) · 0 NON_MATCHING.
|
||
Session opened 96.28 / 94.1 / 88.7 ⇒ **+34,176 instructions** (12,368,236 → 12,402,412), the great
|
||
majority for **~0 agent tokens** — instrument repair, not drafting.
|
||
|
||
## ✅ T7 PROGRESS
|
||
| task | result |
|
||
|---|---|
|
||
| **S1a** lift local types | **DONE** — 895 types / 1,259 files; killed the type-scope class |
|
||
| **S1c** re-sweep matched-exemplar families | **DONE — 97 members** (were 0) |
|
||
| **S1b** "wire the reconcile" | **PREMISE REFUTED** — already wired; `--normalize-self-decls` re-tested post-fix = 0 banks |
|
||
| **S2** jr families via `jtbl_family_bank` | **DONE — 10 members**; 7 families now CLASSIFIED |
|
||
| **S3** the whale | **DONE-PARTIAL — 137/138** (3 of 4 SC07s); `ov_SC07_010` reverted, still open |
|
||
| S1d · S4 · S5 · S6 · S7 | pending — see the task list |
|
||
|
||
## ⚠️ THE ONE R22 FAILURE — READ THIS BEFORE TRUSTING ANY PER-BINARY "BANKED"
|
||
`ov_SC07_010` passed its **per-binary** build and **FAILED the clean-tree R22** (139/140). Its
|
||
`-O0` split landed in an EXISTING `_o0c` file instead of a fresh `_o0d`, creating region
|
||
`_jr_801457A4` whose asm dir splat never generated. Reverted; the overlay is still open.
|
||
**A per-binary pass is NOT a fleet byte claim (§61)** — committing on that "BANKED" would have
|
||
shipped a broken overlay and reported 138/138. This is the whole reason R22 exists.
|
||
|
||
## 🔑 S3'S REAL MECHANISM — the plan's framing was WRONG, do not repeat it
|
||
Recorded as "the T2 Arm-A `%lo +0x20` carve defect". **The carve was never broken** —
|
||
`o0_subsplit` reported `split byte-neutral ✓` on the FIRST attempt in all four. The blocker: carving
|
||
the whale out of a **jr** file makes `jr_isolate_all` hoist the parent's file-scope decls into the
|
||
new region as its **ambient** set, so the fleet's loose-typed spellings share a TU with the shared
|
||
header's for the first time (`extern void *D_801274CC` vs the header's `extern s32 D_801274CC`). In
|
||
the 134 working overlays the whale sits in a CLEAN `-O0` file (`common.h` + the header, nothing
|
||
else) and they never meet. **Fix: drop the ambient duplicates in that one file** — the header is the
|
||
byte-proven side. Three iterations, each a DECLARATION: data syms → function syms → the alias form
|
||
ending in a trailing COMMENT (§134 comment-blindness, the THIRD time today).
|
||
|
||
## 🧰 TEN TOOL DEFECTS FIXED — every "wall" today was our own instrument
|
||
1. `harvest_verify._reload_corpus` re-applied `--src` after a carve → deleted the stub it had just
|
||
followed → uncaught KeyError → `_jtbl_restore` never ran → **stranded carve**; **10 of wave 6's
|
||
16 drafts vanished with no verdict.**
|
||
2. `.run/s6f_gate.py` never checked the child rc — a crash read as silence. Now asserts
|
||
`banked+failed+no-verdict == drafts`, prints rc + tail, exits 1.
|
||
3. `classify_fail` truncated diagnostics **from the LEFT**, severing the symbol.
|
||
4. `jr_isolate_all`/`overlay_src_split` **silently DELETED** definition-side `__asm__`-alias
|
||
functions (addr_of resolves by C name; an alias def is spelled `aF…`). **Fifth tool with that
|
||
blindness** — `family_remap` fixed it and never propagated it.
|
||
5. `partition`/`_partition` now REFUSE to rewrite a file when an address won't resolve (R32).
|
||
6. The type-scope class — **895 types lifted**, class gone.
|
||
7. `jtbl_family_bank` reported `gate-fail` with **no reason** (only stage-construction errors were
|
||
captured, never the build's).
|
||
8. `family_hseq` stdout called an OVERLAYS-ONLY number "fleet".
|
||
9. **My own alias scanner had the §134 defect I documented that morning** — greedy `[^;{}]*` over
|
||
unmasked source matched from inside a comment and swallowed the real decl. Caught by the R32
|
||
guard from #5, on its first real encounter. Fixed via `cdecl._mask` (scan the MASK, read the
|
||
symbol from the SOURCE — rejecting after the fact does not work, finditer resumes past the
|
||
swallowed decl).
|
||
10. The S3 ambient-decl filter's `endswith(';')` skipped comment-terminated lines (§134 again).
|
||
|
||
**THE STANDING LESSON:** every wall today was a tool keyed on the wrong thing — verdicts by grep not
|
||
accounting · stub location by `--src` not the tree · a banked head by `members` not `exemplar` · a
|
||
definition by C name not emitted symbol · a type by where it sat in a file · a line-shape by a test
|
||
a comment invalidates. **§134 has now appeared in SIX tools; the real fix is routing every
|
||
line-shape decision through `cdecl._mask` (R33), not another per-tool patch.**
|
||
|
||
## ▶ RESUME HERE
|
||
1. **S1d** (task #10) — the two dominant conflict symbols, ~383 member failures. `func_80146A6C`:
|
||
fleet decls UNIFORM ⇒ the DRAFT is wrong (bug hunt; work out why `cast_call_sites`, which runs at
|
||
family_sweep.py:632, is not already resolving it). `func_80161208`: FOUR incompatible fleet shapes
|
||
⇒ the genuine Phase-16 loose-typing wall; candidate = the §37/§124 definition-side alias.
|
||
2. **`ov_SC07_010`** — force a FRESH `_o0` region instead of reusing `_o0c`, then re-run
|
||
`.run/s3_sc07_whale.py` (it self-skips the 3 already banked). Also: the **61 SC07 `-O0` members**
|
||
in S3's original scope were never attempted.
|
||
3. **S2 residue** — `.run/jrprop/*.log`: 2 families `isolate-fail`, 1 `carve-fail` (tool refusals,
|
||
likely routable); only 2 members are genuine DIFF.
|
||
4. **S4** (task #6) + wave 6's 3 still-failing alias drafts (the three LARGEST — size-correlated).
|
||
5. **S5 the wave** (task #7): 1,689 h_norm clusters / 326,261 ins at 2.7×. **VERIFY the pool numbers
|
||
first (Fable's, unverified — R14)**, ONE 8-target calibration wave, measure REALIZED propagation
|
||
before scaling. **Prompt Drew for the toggle (R27).**
|
||
|
||
## 🧰 MY PROCESS ERRORS
|
||
1. **Claimed `family_sweep` hides per-member errors** — FALSE, **23,211 `.classified.txt` files**
|
||
exist and both of the day's zeros were already diagnosed in them. Two probes wasted.
|
||
2. **Called 4 families "chance collisions"** while my own printout showed them `PURE`/`IMM`.
|
||
3. **Reverted `config/` and re-extracted ONE overlay of sixteen** — a gate cycle read 3 real banks as
|
||
failures against stale asm.
|
||
4. **A backticked `` `make extract` `` in a `-m` message EXECUTED** — use quoted heredocs.
|
||
5. **`… | tail` swallowed a non-zero exit** — a pipeline's status is the LAST command's.
|
||
6. **Looked a just-banked head up in `members`** — it moves to `exemplar.kind='matched'`.
|
||
7. **Reported "138/138" before R22** — it was 137/138. See the R22 failure above.
|
||
No bad bytes from any of them — the byte-gate and R22 caught everything.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-38 CHECKPOINT v2 — POST-S1/S2
|
||
> **NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN** but for the R23 `db.*.gbf` churn — never stage.
|
||
> Effort: **xHigh** (Drew set it for the eventual S5 wave; the S1/S2 work was deterministic).
|
||
> **R22 clean-fleet run SEVEN times this session, 140/140 every time.**
|
||
> **Drew's standing decision: NO phase close — keep grinding.** Plan = **T7 (the Fable-5 plan)**;
|
||
> **full report at `.run/fable_frontier/ANALYSIS.md`**, pools at `pool_ovres.json`.
|
||
> **VERIFY BEFORE TRUSTING:** `git log --oneline -3` should show this at/near HEAD and
|
||
> `grep -E 'FLEET (fn-count|instr|distinct)' docs/progress.fleet.md` must agree below. Digest wins.
|
||
|
||
## FLEET — R22 **140 passed / 0 failed of 140**
|
||
**96.32% fn-count · 94.3% instr-weighted · 89.1% distinct-code** (77,884 uniq) · 0 NON_MATCHING (G4).
|
||
Session opened 96.28 / 94.1 / 88.7 ⇒ **+19,300 instructions**, the great majority for **~0 agent
|
||
tokens** (instrument repair, not drafting).
|
||
|
||
## WHAT S38 ACTUALLY WAS: EIGHT TOOL DEFECTS, NOT A COMPILER PROBLEM
|
||
Every "wall" hit today was our own tooling keyed on the wrong thing. In order:
|
||
1. **`harvest_verify._reload_corpus`** re-applied `--src` after a carve → deleted the stub it had
|
||
just followed → uncaught `KeyError` → `_jtbl_restore` never ran → **stranded carve** → later gate
|
||
groups built against a mutated tree. **10 of wave 6's 16 drafts vanished with no verdict.**
|
||
2. **`.run/s6f_gate.py`** never checked the child's rc — booked a crash as silence. Now asserts
|
||
`banked+failed+no-verdict == drafts`, prints rc + output tail, exits 1.
|
||
3. **`classify_fail`** truncated diagnostics **from the LEFT**, severing the symbol name.
|
||
4. **`jr_isolate_all` / `overlay_src_split`** SILENTLY DELETED definition-side `__asm__`-alias
|
||
functions during a repartition (`addr_of` resolves by C name; an alias def is spelled `aF…`).
|
||
→ 3 wave-6 drafts recovered instantly. **Fifth tool with this same blindness** — `family_remap`
|
||
fixed it and the fix was never propagated.
|
||
5. **`partition`/`_partition`** now REFUSE to rewrite a file when a construct's address won't resolve
|
||
(R32) instead of dropping it.
|
||
6. **The type-scope class** — a remapped body names the exemplar's TU-local types → parse error, never
|
||
reaches codegen. **895 types lifted fleet-wide** → the class is gone.
|
||
7. **`jtbl_family_bank`** reported `gate-fail` with NO reason (only stage-construction errors were
|
||
captured, never the build's). Fixed → S2's failures are now classified.
|
||
8. `family_hseq`'s stdout called an OVERLAYS-ONLY number "fleet".
|
||
|
||
## ✅ T7 PROGRESS
|
||
| task | result |
|
||
|---|---|
|
||
| **S1a** lift local types | **DONE** — 895 types / 1,259 files |
|
||
| **S1c** re-sweep matched-exemplar families | **DONE — 97 members banked** (were 0) |
|
||
| **S1b** "wire the reconcile" | **PREMISE REFUTED — nothing to wire** (see below) |
|
||
| **S2** jr families via `jtbl_family_bank` | **DONE — 10 members banked**, 7 families classified |
|
||
| S1d, S3–S7 | pending — see the task list + T7 |
|
||
|
||
**S1b is closed by measurement:** `cast_call_sites` is ALREADY called in `hseq_sweep`
|
||
(family_sweep.py:632, default-on), as are tu-scope §103 and `scope_data_fix`. And
|
||
`--normalize-self-decls` — whose only negative (0/1,622) its own author proved was a tool artifact —
|
||
got a fair post-fix re-test: **0 banks + repeated "self-decl edit NON-NEUTRAL → reverted TU"**. It
|
||
also targets the wrong axis (the target's OWN decl; the residue conflicts are on callees/data).
|
||
|
||
## 🎯 THE REAL RESIDUE — **TWO SYMBOLS, 383 of ~398 CONFLICTS** (→ task S1d)
|
||
- **`func_80146A6C` (208)** — the fleet is **UNIFORM** (4,262 decls of
|
||
`extern s32 func_80146A6C(s32,void*,s32,s32,s32,s32,s32)` + 297 unnamed-param copies of the same
|
||
types), so **the TU is right and the templated draft carries the bad decl.** A draft-side bug hunt,
|
||
NOT a new lever — and work out why `cast_call_sites` is not already resolving it.
|
||
- **`func_80161208` (175)** — the fleet genuinely disagrees: `s32 f()` ×3730 · `int f()` ×1775 ·
|
||
`s32 f(void)` ×1517 · `s32 f(void*)` ×138. **That is the Phase-16 loose-typing wall**, not plumbing.
|
||
Candidate: the §37/§124 DEFINITION-side asm-label alias (zero blast radius). **Probe one member.**
|
||
|
||
## ▶ RESUME HERE (cheap deterministic lanes still pay; the wave costs ~20M tokens)
|
||
1. **S3 — the SC07 carve** (task #5): the whale `0x80144b9c` is matched in 134/138 overlays and open
|
||
ONLY in the 4 SC07s = **3,080 ins of BYTE-IDENTICAL code** blocked by the T2 Arm-A `%lo +0x20`
|
||
defect. ~0 tokens.
|
||
2. **S1d** (task #10) — the two symbols above, worth ~383 member failures.
|
||
3. **S2 residue** — `.run/jrprop/*.log`: 2 families `isolate-fail`, 1 `carve-fail` (tool refusals,
|
||
likely routable); only 2 members are genuine DIFF.
|
||
4. **S4** (task #6) — 39 draft-exemplar families + the 2 resident stubs with match_one-MATCH drafts
|
||
already gate-rejected for TU plumbing; **plus wave 6's 3 still-failing alias-class drafts**
|
||
(func_80189030 / 801878E8 / 801919A0 — the three LARGEST, so the residual cause is size-correlated).
|
||
5. **S5 — the wave** (task #7): 1,689 open-only h_norm clusters / 326,261 ins at a 2.7× multiplier.
|
||
**VERIFY the pool numbers first (Fable's, unverified — R14)**, then ONE 8-target calibration wave
|
||
measuring REALIZED propagation before scaling. **Prompt Drew for the toggle (R27).**
|
||
|
||
## 🧰 MY PROCESS ERRORS THIS SESSION
|
||
1. **I claimed `family_sweep` hides the per-member error.** FALSE — **23,211
|
||
`.run/hseq_failed.*.classified.txt` files** exist and both of the day's zeros were already
|
||
diagnosed in them. I asserted a tool limitation without looking, then spent two probes and a
|
||
manual `--stage-only` round rediscovering one. **Read the payload first.**
|
||
2. **I called 4 families "chance collisions"** while my own printout showed them `PURE`/`IMM` — and
|
||
PURE means every differing word is at a RELOC position, the opposite of chance. Refuted by Fable.
|
||
3. **I reverted `config/` and re-extracted ONE overlay of sixteen** (the Phase-20 R22 corollary),
|
||
so a whole gate cycle measured against stale asm and read 3 real banks as failures.
|
||
4. **A backticked `` `make extract` `` in a `-m` commit message EXECUTED** — corrupted the message
|
||
and ran a real extract. Use quoted heredocs. (No damage; re-committed.)
|
||
5. **`family_sweep … | tail` swallowed a non-zero exit** — a pipeline's status is the LAST command's.
|
||
6. **I looked a just-banked head up in its family's `members` list** — a banked head LEAVES `members`
|
||
and becomes `exemplar.kind='matched'`.
|
||
No bad bytes from any of them — the byte-gate and R22 caught everything.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-38 CHECKPOINT v1 — wave 6 banked + the gate defect fixed
|
||
|
||
> **NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN** but for the R23 `db.*.gbf` churn — never stage.
|
||
> Effort: **high** (Drew lowered from ultracode as an experiment; he will enable xHigh for wave 7).
|
||
> **R22 clean-fleet run TWICE this session, 140/140 both times.**
|
||
> **Drew's standing decision: NO phase close — keep grinding.** Next: **wave 7 at ~50k templ ins**
|
||
> (Drew's explicit direction: "chase that 50k like you tried"; he toggles xHigh when it is staged).
|
||
> **VERIFY THIS BLOCK IS CURRENT BEFORE TRUSTING IT**: `git log --oneline -3` should show this
|
||
> checkpoint at/near HEAD, and `grep -E 'FLEET (fn-count|instr|distinct)' docs/progress.fleet.md`
|
||
> must agree with the FLEET line below. If they disagree, **the digest wins** (R35).
|
||
> **Nothing is owed.** All 16 wave-6 drafts are gated; the 9 unbanked are diagnosed and preserved.
|
||
|
||
## FLEET — R22 **140 passed / 0 failed of 140**
|
||
**96.29% fn-count · 94.2% instr-weighted · 88.9% distinct-code** (77,796 uniq) · dedup **1910/0** ·
|
||
**0 NON_MATCHING** (G4). Session opened 96.28 / 94.1 / 88.7 ⇒ **+10,616 instructions** banked
|
||
(12,368,236 → 12,378,852 — the digest delta matches the hand-derivation EXACTLY).
|
||
Phase opened 92.00 / 87.5 / 78.0 ⇒ **+4.29pp fn, +6.7pp instr, +10.9pp distinct.**
|
||
|
||
## WHAT THIS SESSION DID
|
||
| lane | result |
|
||
|---|---|
|
||
| wave 6 (16 tgt / **50,596** templ ins) | **7 heads banked**, 9 refused-and-diagnosed |
|
||
| propagation (5 jr-families, carve path) | **25 of 38 sibling slots** (15+3+3+2+2) |
|
||
| instrument repair | **4 defects fixed** — see below |
|
||
|
||
## ⚠️ THE HEADLINE IS NOT THE BANK COUNT — THE GATE WAS BOOKING CRASHES AS SILENCE
|
||
Wave 6's first gate printed `BANKED 5 / FAILED 1` over **16** drafts. **Ten produced no verdict at
|
||
all**, nine of them claiming MATCH, and the tally looked clean. Chain (cookbook **§139**):
|
||
1. `harvest_verify._reload_corpus` re-applied the `--src` filter AFTER a jtbl carve — deleting the
|
||
very stub it had just followed to its new TU, which is that function's whole documented purpose.
|
||
→ `KeyError` in `render()` → **UNCAUGHT** → `_jtbl_restore(snap)` never ran → **carve STRANDED in
|
||
config/+src/** → every LATER group in the same gate then built against a mutated tree.
|
||
2. `.run/s6f_gate.py` never checked the child's returncode — it grepped stdout for two line-prefixes
|
||
and booked "neither" as nothing (the §136a defect, in the gate itself).
|
||
**Both fixed.** The gate now asserts `banked+failed+no-verdict == drafts`, prints the child's rc +
|
||
output tail, and **exits 1** (a crashed child may have stranded a carve). **Proof it was not
|
||
cosmetic: `func_8017EA84` (579 ins) banks BYTE-IDENTICAL under the fixed path — reported as NOTHING
|
||
before.** Also fixed: `classify_fail` truncated diagnostics **from the LEFT**, severing the symbol
|
||
name that is the label's entire routing value (`undefined reference to \`func_801` ← cut at four hex
|
||
digits). Now keeps both ends.
|
||
|
||
## 📌 THE 9 UNBANKED WAVE-6 DRAFTS — ALL DIAGNOSED, DRAFTS COMMITTED IN `.run/w6/`
|
||
**6 are ONE class (the highest-value thing to fix next):** `undefined reference` to a sibling that
|
||
IS defined in the overlay but only through a **definition-side `__asm__` alias**
|
||
(`void aF<X>(...) __asm__("func_<Y>");` — §37/§124). **The carve repartitions the object and
|
||
separates the call site from the alias definition.** Worked example: `func_801884D8` (ov_SC02_028) →
|
||
`func_80183AF8`, whose definition is the alias `aF8018A860` at `_jr_8017D898.c:4753`. Cracking this
|
||
one class frees 6 drafts at once, and it will recur in every carve-heavy wave.
|
||
| fn | overlay | class |
|
||
|---|---|---|
|
||
| func_801884D8 | ov_SC02_028 | undefined ref `func_80183AF8` (alias) |
|
||
| func_80189030 | ov_SC03_001 | undefined ref `func_80186F88` |
|
||
| func_801878E8 | ov_SC04_018 | undefined ref `func_801848DC` |
|
||
| func_80180B04 | ov_SC06_020 | undefined ref `func_80184F18` |
|
||
| func_801919A0 | ov_SC06_032 | undefined ref `func_8018B878` |
|
||
| func_801380E0 | ov_SC07_006 | undefined ref `func_80137614` |
|
||
| func_8018A564 | ov_SC02_027 | CC1-FAIL (Error 33) — different, needs its own read |
|
||
| **func_8017C974** | ov_SC01_077 | **genuine** DIFF close=**47**, REGALLOC-PERM (947 ins, Opus, 12 variants inert) |
|
||
| **func_80188C68** | ov_SC03_124 | **genuine** DIFF close=370 (551 ins, the only target with NO twin anywhere) |
|
||
|
||
## 📊 `docs/wave-metrics.md` — Findings 5 and 6 added
|
||
**Rank waves by INSTRUCTIONS, not heads.** Wave 6 banked ~45% more instructions than wave 5 while
|
||
banking less than half as many heads (10,616 exact vs ~7,200 est.), because a bigger head carries
|
||
more instructions AND its family propagates at the same cost per sibling — `func_8017FEE0`, ONE
|
||
299-ins head, became **4,485 ins across 15 siblings** for ~0 agent tokens. **The metric to beat is
|
||
POOL REALISATION (21%), not bank rate**; wave 6's bank rate is not comparable to waves 3–5 because
|
||
the difficulty knob moved deliberately (median target 438 ins vs 143, mostly `has_mid_jr`).
|
||
|
||
## 🔬 THE FAMILY FRONTIER — **MY S38 READING WAS WRONG; CORRECTED HERE** (Fable5 + byte-checked)
|
||
**Superseded claims (do NOT act on them):** "the ×138 era is over", "4 of the 8 big families collide
|
||
by chance", "0x80175820 / 0x80132018 are not templatable", "the free-sweep zeros are undiagnosed",
|
||
"family_sweep reports failures without the per-member error". **Every one is refuted.**
|
||
|
||
**What is TRUE:** the open-member DISTRIBUTION does skew small (5,792 families / ~702k open ins;
|
||
8 families at 100+, 1,534 at 2-4, 3,807 singletons). **What is FALSE is the conclusion I drew from
|
||
it.** The map's own `classify_member` (family_remap.py:213) is a per-word diff with reloc tracking —
|
||
**PURE means every differing word sits at a RELOC position, i.e. the exact opposite of a chance
|
||
collision.** All four families I called "chance" classify PURE or IMM ×138. `0x80161418` has **552
|
||
already-matched siblings** — that family has swept successfully before. The two "ledgered
|
||
not-templatable" entries are contradicted too (`0x80175820` IMM×137 / 7,535 ins; `0x80132018`
|
||
PURE×132 / 6,072 ins). Only the 2 GIANT walls survive, and those are **exemplar** walls (close=91/110)
|
||
whose 138 members each classify PURE — **50,094 ins ride on 2 cracks.**
|
||
|
||
**THE BASE RATE, which settles it:** across ALL sweep runs' classified files, blockers are
|
||
**~24k PLUMBING vs 4,917 DIFF — 5:1.** Sweep failure in this project has ALWAYS been mostly
|
||
plumbing. My "families don't template" reading had the base rate exactly backwards.
|
||
|
||
## ✅ BOTH S38 ZEROS DIAGNOSED — BOTH PLUMBING, BOTH ALREADY ON DISK
|
||
- `0x801833f0` **0/6 → 6/6 (FIXED, banked, R22 140/140)**. Cause: the remapped body carries the
|
||
EXEMPLAR's TU-local types (`PTag_/Ft4_/Drm_801833F0`); undeclared type ⇒ gcc-2.7.2 parses the
|
||
declarator as an expression ⇒ `parse error before 'vtx'`. Never reached codegen. Fix = lift the
|
||
types (`lift_types --apply`). **This is §20's propagation cap on the h_seq sweep path.**
|
||
- `0x80128c98` **0/138**: `PLUMBING: conflicting types for 'cdFileLocTable'` — the §103/§20
|
||
extern-conflict class. Also never reached codegen.
|
||
- **`.run/hseq_failed.<ov>.<n>.classified.txt` — 23,211 files — carried both diagnoses all along.**
|
||
My claim that the sweep hides the per-member error was FALSE and is struck (R37).
|
||
|
||
## 🎯 THE UNTARGETED POOL (Fable5, computed from sig+corpus — verify before scaling)
|
||
- **Open-only h_norm clusters: 1,689 clusters / 5,956 fns / 326,261 ins = 46% of ALL open overlay
|
||
instructions**, with a **2.7× propagation multiplier** (exemplar 88,649 ins → propagated 237,612).
|
||
Nobody has aimed a wave here.
|
||
- **h_exact pool**: 250 open fns / 12,981 ins byte-identical to already-matched code — incl. the
|
||
**whale `0x80144b9c` matched in 134/138 overlays, open only in the 4 SC07s (3,080 ins)**, blocked
|
||
solely by the SC07 carve defect (T2 Arm-A +0x20).
|
||
- **main is structurally barren** (zero h_exact overlap; different compiler era) — genuine agent tail.
|
||
Its Ghidra sig is 7 weeks stale and missing 757 of 2,002 stubs — regen before pricing it.
|
||
- 2 of the resident's 14 stubs already have match_one-MATCH drafts in backlog.jsonl, gate-rejected
|
||
for TU plumbing — same class.
|
||
|
||
## 📋 THE RANKED PLAN (tokens/instruction vs a 490 t/ins wave baseline)
|
||
| # | strategy | reachable ins | tok/ins |
|
||
|---|---|---|---|
|
||
| **S1** | fix the 2 plumbing classes (typedef/macro gather + extern-conflict reconcile) → re-sweep the 148 matched-exemplar families | **35-60k** | **~10-25** |
|
||
| S2 | jr matched-exemplar families via `jtbl_family_bank` (§53) — 11 fams / 52 members | 10-18k | ~0 |
|
||
| S3 | SC07 carve fix → whale ×4 + 61 SC07 o0 members | 5-15k | ~0 |
|
||
| S4 | draft-recovery on 39 draft-exemplar families + the 2 resident MATCHes | 10-25k | ~10-50 |
|
||
| S5 | **re-aim waves at open-only h_norm cluster exemplars**, sweep after every bank | up to 326k | ~130-150 |
|
||
| S6 | the 2 GIANT exemplar walls (50,094 ins on 2 cracks) | 50k | ~50-200 |
|
||
| S7 | singleton tail + main (regen main's sig FIRST) | remainder | ~490+ |
|
||
**S1-S4 ≈ 80-115k ins moved from the 490-t/ins column to ~0**, and S1 restores the propagation
|
||
multiplier that makes every later wave ~3× cheaper. **DO S1 BEFORE ANY WAVE.**
|
||
|
||
## 🚨 STANDING PRE-PROBE RULE (this session's cheapest lesson)
|
||
**Before probing a family, check h_norm identity across its members from the sig files.** If members
|
||
are h_norm-identical, a 0% is a compile-error CERTAINTY, not evidence about codegen — it would have
|
||
predicted both of today's zeros without spending a probe. And **read
|
||
`.run/hseq_failed.*.classified.txt` before theorising about any sweep failure.**
|
||
|
||
## ▶ RESUME HERE — wave 7, ~50k templ ins (Drew's direction)
|
||
1. `.venv/bin/python .run/w6_pool.py 16 .run/w7_wave.json` — the pool derivation is a SCRIPT now
|
||
(ranks by OPEN templatable weight from `corpus.stubs`, carries the walls/ledgered exclusions,
|
||
drops previously-attempted-and-still-open addrs, one target per (overlay,TU)). Pool at this
|
||
checkpoint: **2,928 fresh families / 476,611 open templ ins** — nowhere near exhausted.
|
||
**Add wave 6's 9 unbanked addrs to its exclusion list** (or fix the alias class first and re-gate
|
||
them — that is 6 drafts already written and paid for).
|
||
2. Build the script from `.run/w6.js` (it is `.run/s37w.js`'s pipeline block + the S37/W6 prose).
|
||
**Prompt Drew for `/effort xhigh` and WAIT for the toggle (R27) before launching.**
|
||
3. Land: gate (`.run/s6f_gate.py '.run/w7/*/func_*.c'`) → diagnose failures (`.run/w6_diag.py`, which
|
||
runs the REAL gate path; `s36_capture.py` splices WITHOUT the carve and is wrong for jr targets)
|
||
→ propagate (**`family_sweep --hseq` REFUSES has_mid_jr families by design — route those to
|
||
`.run/w6_jtbl_prop.py` / `jtbl_family_bank`, and note it needs a CLEAN TREE between families**)
|
||
→ **R22** → commit → **append a wave-metrics row**.
|
||
|
||
## 🧰 MY PROCESS ERRORS — one mechanism: a tool answered a NARROWER question than I asked
|
||
1. **I reverted `config/` and re-extracted ONE overlay of sixteen.** The Phase-20 R22 corollary (a
|
||
reverted config needs `make extract`) — which I know. Three genuinely-banked functions then read
|
||
as failures against stale asm. *A gate result measured against stale asm is not a measurement.*
|
||
2. **`family_sweep ... | tail` swallowed a non-zero exit** (`--only` wants comma-separated). A
|
||
pipeline's status is the LAST command's — use `pipefail`/`PIPESTATUS`.
|
||
3. **A backticked `` `make extract` `` inside a double-quoted `-m` commit message EXECUTED**,
|
||
corrupting the message and running a real extract. Re-committed with quoted heredocs (what I used
|
||
everywhere else and lapsed on once). No damage — src/config verified clean vs HEAD.
|
||
4. **I looked a just-banked head up in its family's `members` list** and got "NO FAMILY" for all 5
|
||
heads `family_sweep` had just enumerated — a banked head LEAVES `members` and becomes
|
||
`exemplar.kind='matched'`. (Distinct from §138 rule 4, which governs target SELECTION.)
|
||
5. `jtbl_family_bank` logs `gate-fail` per sibling **without the underlying error** — same
|
||
"outcome without the payload that routes it" class as the `classify_fail` truncation. The 13
|
||
sibling failures are therefore unrouted. **Worth fixing before a carve-heavy wave 7.**
|
||
No bad bytes from any of them — the byte-gate and R22 caught everything.
|
||
|
||
---
|
||
|
||
# 🛑 SESSION-33..37 CHECKPOINT (2026-08-04, wave 5 BANKED) — FRESH SESSION SAFE HERE
|
||
> **NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN** but for the R23 `db.*.gbf` churn — never stage.
|
||
> Effort: **ultracode**. **R22 clean-fleet run TWENTY times this session, 140/140 every time.**
|
||
> Last CODE commit `commit:1393` (wave-5 bank); this checkpoint commits on top of it.
|
||
> **Drew's standing decision: NO phase close — keep grinding.**
|
||
> **VERIFY THIS BLOCK IS CURRENT BEFORE TRUSTING IT** (it goes stale, and stale is worse than
|
||
> absent): `git log --oneline -3` should show this checkpoint at or near HEAD, and
|
||
> `grep -E 'FLEET (fn-count|instr|distinct)' docs/progress.fleet.md` must agree with the FLEET
|
||
> line below. If they disagree, the digest wins — re-derive before scoping anything (R35).
|
||
> **Nothing is owed.** The 16 wave-5 drafts flagged in the previous checkpoint are BANKED.
|
||
|
||
## FLEET — R22 **140 passed / 0 failed of 140**
|
||
**96.28% fn-count · 94.1% instr-weighted · 88.7% distinct-code** (77,765 uniq) · dedup **1910/0** ·
|
||
C1 241216/241216 · **0 NON_MATCHING** (G4).
|
||
Session opened 96.01 / 93.6 / 88.0 ⇒ **+0.27 / +0.5 / +0.7pp**.
|
||
Phase opened 92.00 / 87.5 / 78.0 ⇒ **+4.28pp fn, +6.6pp instr, +10.7pp distinct.**
|
||
|
||
## WHAT THIS SESSION DID
|
||
| lane | result |
|
||
|---|---|
|
||
| SC07 EXTEND | **0/36 → 31/36** |
|
||
| PROPAGATE head | **0 → 18,545/18,545 ins** (5/5 classes) |
|
||
| wave 1 (17 tgt) | 15 banked + 65 members |
|
||
| wave 2 (13 tgt) | 10 banked + 18 members |
|
||
| wave 3 (13 tgt) | **13/13** + 21 members |
|
||
| wave 4 (14 tgt) | **14/14** + 26 members |
|
||
| wave 5 (16 tgt) | **16/16, ZERO reconcile** + 26 members |
|
||
| reconcile lane | **21/22 lifetime** |
|
||
|
||
## 📊 NEW: `docs/wave-metrics.md` — the wave performance log (Drew asked for this)
|
||
Wave-by-wave targets / tokens / wall-clock / parallelism / bank rate, with the derivation commands
|
||
so future rows are COMPUTED not transcribed (R33). **Append a row after every wave.** Four findings,
|
||
each with its caveat recorded rather than as a bare number:
|
||
1. **The prompt is the lever, and the agents write it** — 76→77→100→100→100% with models and gate
|
||
held constant. The jump was STEP 0 (magic-literal grep of `src/`, ahead of `engine_core.h`),
|
||
which came from a **wave-2 agent's `index_gap` report**. *Caveat: waves 3–5 targets also trended
|
||
easier; the mechanism is the durable claim, not the exact %.*
|
||
2. **`pipeline()` beats batched `parallel()`** — 136 min/14 tgt → **82 min/16 tgt**, 2.5×→3.8×.
|
||
The two-batch design was a hard barrier (37–50 min dead gaps); the harness already caps at 16.
|
||
**Copy `.run/s37w.js`'s execution block for every future wave.** *Floor: the slowest agent is
|
||
still ~50 min of real `match_one` iteration ⇒ the lever is target SELECTION, not concurrency.*
|
||
3. **Economics** — ~170–300k tokens/banked head, but the unit of value is head + propagated members,
|
||
and sweep yield is **bimodal not average** (21/21 vs 18/165) because it is a property of the FAMILY.
|
||
4. **A perfect gate means the prompt rules landed** — waves 1–4 each needed 1–2 post-gate reconciles;
|
||
wave 5 needed none. The reconcile lane is the fallback, not the plan.
|
||
|
||
## 📌 THE DISTILLED RULES (cookbook §138 + index; memory `wave-prompt-seed-step0-and-gaps`)
|
||
1. **Bucket a gate refusal by the (macro-shape, TU-shape) PAIR, not the SYMBOL.**
|
||
2. **Reconcile direction depends on WHERE the TU's decl is** — ABOVE the splice ⇒ DELETE your
|
||
duplicate (§100); BELOW ⇒ KEEP a decl in the TU's EXACT shape and cast at the use (§17a-1 D2).
|
||
**A wave can manufacture this for itself**: two targets in one TU means the first to bank puts
|
||
its type tags in the second's way.
|
||
3. **STEP 0: `grep -rn "<MAGIC>" src/`** with a distinctive literal from the `.s`, ahead of
|
||
`engine_core.h` — the only step that reaches a banked twin in ANOTHER overlay's TU.
|
||
4. **Never rank off the family map's `exemplar` field** — derive open sites from `corpus.stubs`
|
||
(measured 16,696 ins → **41,023** on the same map).
|
||
5. **Three carry variants hide in one "CARRY-FIXABLE" bucket** — multi-line comment (fix the tool) ·
|
||
draft-local `struct Tag` (use the shared type) · file-scope `static inline` helper (hand-author +
|
||
EXCLUDE the source overlay).
|
||
|
||
## 🔬 SETTLED — do not re-litigate
|
||
- **`func_801758FC` / `func_80132018` / `func_8018A808`'s families are NOT templatable.** Probed
|
||
(`.run/s6_diag.py`, 2 builds): remapped member is **BUILD OK + byte diff** ⇒ genuine per-member
|
||
codegen. The h_seq refusal ceiling, confirmed.
|
||
- **`_alias_decl_for` was ONE function, not a class** (91 alias decls fleet-wide, 90 already matched).
|
||
- **"normalized distance 0" is NOT an h_exact guarantee** — relocs are masked.
|
||
|
||
## ▶ RESUME HERE — wave 6, nothing blocked
|
||
1. **Regenerate the map, then derive the pool the `corpus.stubs` way** (rule 4). Pool at the last
|
||
regen: **852 families / 225,217 ins**. Exclude the 3 walls (`0x801412a8`, `0x80178004`, whale
|
||
`0x80144b9c`) and the ledgered residuals (`0x8017c294` close=12, `0x8017f7b4`, `0x801898e4`,
|
||
`0x80186e24` close=187, `0x801758fc`, `0x80132018`, `0x8018a808`).
|
||
2. **Build the script from `.run/s37w.js`** (pipeline block + the accumulated `extra` prose), 16
|
||
targets. Launch → gate (`.run/s6f_gate.py '.run/<w>/*/func_*.c'`) → capture any failure
|
||
(`.run/s36_capture.py <ov>:<fn>`) → reconcile per rule 2 → `make sig-overlays` +
|
||
`family_hseq.py` + `family_sweep --hseq --band all --only <addrs>` → **R22** → commit →
|
||
**append a row to `docs/wave-metrics.md`**.
|
||
3. **EXTEND's last 5**: `func_80144B9C` ×4 needs the §38 `-O0` shared-header route (and
|
||
`dedup_extend` should refuse-and-name that class per R32); `func_80149954` ×1 sits behind
|
||
`func_80147364`'s u16 params.
|
||
|
||
## 🧰 MY PROCESS ERRORS — one mechanism: the signal sampled was not the thing measured
|
||
1. `nohup CMD &` inside a backgrounded call ⇒ the harness signalled the WRAPPER; the fleet check
|
||
stood at **63/140** and I nearly read it as a pass.
|
||
2. **`pgrep -x make` is right for ONE make, WRONG for a campaign** of sequential makes; **`pgrep -f`
|
||
SELF-MATCHES** so that waiter never exits. Use the campaign's real argv or `treelock.sh --status`.
|
||
3. A `corpus.stubs` probe mid-rebuild returned garbage; R32's assertion refused to answer.
|
||
4. **I predicted a fix without reading the macro in front of me** (relaxed 42 `(void)` decls; that
|
||
macro declares `(u8*)` — banked 0/1 in all 134) → the PAIR rule.
|
||
5. **I violated §136a in my own capture tool** — a narrow keyword filter reported "NO COMPILE ERROR"
|
||
on a build failing with `redefinition of struct PW8017C290`.
|
||
No bad bytes from any of them — the byte-gate and R22 caught everything.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-33..37 CHECKPOINT (2026-08-04) — pre-wave-5-bank
|
||
> **NOTHING IS RUNNING. Tree lock FREE. Tree CLEAN** but for the R23 `db.*.gbf` churn — never stage.
|
||
> Effort: **ultracode**. **R22 clean-fleet run NINETEEN times this session, 140/140 every time.**
|
||
> Drew paused here to restart Windows. **Drew's standing decision: NO phase close — keep grinding.**
|
||
|
||
## ⚠️ THE ONE THING THAT IS OWED: 16 UNGATED WAVE-5 DRAFTS
|
||
`.run/s37/*/func_*.c` — **16 drafts, all claiming MATCH, NONE gated, NONE banked.** They are
|
||
**force-added to git** (`.run/` is otherwise gitignored) because they cost ~2.7M agent tokens and
|
||
the Workflow `resumeFromRunId` cache is SAME-SESSION-ONLY, so it does not survive the restart.
|
||
**Resume by gating them — do not re-run the wave:**
|
||
```
|
||
tools/treelock.sh g .venv/bin/python .run/s6f_gate.py '.run/s37/*/func_*.c'
|
||
```
|
||
then: capture any failure (`.venv/bin/python .run/s36_capture.py <ov>:<fn>` — it ranks HARD errors
|
||
above warnings) → reconcile per the §138 direction rule → `make sig-overlays` +
|
||
`tools/family_hseq.py` + `family_sweep --hseq --band all --only <banked addrs>` → **R22** → commit.
|
||
Manifest: `.run/s37_wave.json` (16 targets / 16,884 templatable ins). Script: `.run/s37w.js`.
|
||
|
||
## FLEET (at the last commit, before the ungated drafts)
|
||
**96.27% fn-count · 94.1% instr-weighted · 88.6% distinct-code** (77,723 uniq) · dedup **1910/0** ·
|
||
C1 241216/241216 · **0 NON_MATCHING** (G4). HEAD `commit:1391` + this checkpoint.
|
||
Session opened 96.01 / 93.6 / 88.0. Phase opened 92.00 / 87.5 / 78.0 ⇒ **+4.27 / +6.6 / +10.6pp.**
|
||
|
||
## WHAT THIS SESSION DID
|
||
| lane | result |
|
||
|---|---|
|
||
| SC07 EXTEND | **0/36 → 31/36** |
|
||
| PROPAGATE head | **0 → 18,545/18,545 ins** (5/5 classes) |
|
||
| wave 1 (17 tgt) | 13 heads + 65 members + 2 reconciled |
|
||
| wave 2 (13 tgt) | 9 heads + 1 reconciled + 18 members |
|
||
| wave 3 (13 tgt) | **13/13** + 21 members |
|
||
| wave 4 (14 tgt) | **14/14** + 26 members |
|
||
| wave 5 (16 tgt) | **16/16 claimed — UNGATED, see above** |
|
||
| reconcile lane | **21/22 lifetime** |
|
||
|
||
## 🔑 THE RESULT WORTH KEEPING: the wave prompt is the lever, and agents write it
|
||
Bank rate, **same models and same gate — the prompt was the only variable**:
|
||
**76% → 77% → 100% → 100%** (wave 5 pending its gate).
|
||
The jump came from **STEP 0: `grep -rn "<MAGIC>" src/`** with a distinctive literal from the target
|
||
`.s`, placed AHEAD of `engine_core.h` in §136c's search order. §136c's first two steps are
|
||
same-TU/shared-header scoped and structurally CANNOT reach a banked twin in another overlay's TU —
|
||
where the big template classes live. **That step came from a wave-2 agent's `index_gap` report.**
|
||
By wave 4 most agents cited it by name and reported `index_gap: none`. → memory
|
||
`wave-prompt-seed-step0-and-gaps`; cookbook §138.
|
||
|
||
## ⚡ THE `pipeline()` FIX — measured, not assumed (Drew asked why waves were slow)
|
||
The two-batch `parallel()` design was a **hard barrier**: batch 2 could not start until batch 1's
|
||
slowest agent finished.
|
||
| | wave 4 `parallel()` | wave 5 `pipeline()` |
|
||
|---|---|---|
|
||
| targets | 14 | **16** |
|
||
| wall-clock | 136 min | **82 min** |
|
||
| parallelism | 2.5× | **3.8×** |
|
||
| median agent | 14 min | 9 min |
|
||
**40% faster on 14% more targets.** `.run/s37w.js` is the pipeline version — copy its execution
|
||
block for every future wave. (Slowest single agent is still ~50 min; that is real `match_one`
|
||
iteration, 200-300 turns, and is the irreducible floor now.)
|
||
|
||
## 📌 THE DISTILLED RULES (cookbook §138 + index; all measured this session)
|
||
1. **Bucket a gate refusal by the (macro-shape, TU-shape) PAIR, not the SYMBOL** — the same symbol
|
||
conflicts in BOTH directions across the fleet.
|
||
2. **Reconcile direction depends on WHERE the TU's decl is.** ABOVE the splice ⇒ DELETE your
|
||
duplicate (§100); BELOW ⇒ KEEP a decl in the TU's EXACT shape and cast at the use (§17a-1 D2).
|
||
Picking wrong CREATES the next error. **A wave can manufacture this for itself**: two targets in
|
||
one TU means the first to bank puts its type tags in the second's way (wave 4's only failure).
|
||
3. **STEP 0 magic-literal grep** (above).
|
||
4. **Never rank off the family map's `exemplar` field** — it is IN-FAMILY and can name an
|
||
ALREADY-BANKED instance. Derive open sites from `corpus.stubs`: 16,696 ins → **41,023** on the
|
||
same map.
|
||
5. **Three carry variants hide in one "CARRY-FIXABLE" bucket** — multi-line comment (fix the tool) ·
|
||
draft-local `struct Tag` (use the shared type) · file-scope `static inline` helper (hand-author +
|
||
EXCLUDE the source overlay; gcc-2.7.2 accepts implicit decls so it passes `compiles_standalone`
|
||
and only fails 137 gates later).
|
||
|
||
## 🔬 SETTLED — do not re-litigate
|
||
- **`func_801758FC` / `func_80132018` are NOT templatable.** Probed with `.run/s6_diag.py` (2 builds):
|
||
the remapped member is **BUILD OK + byte diff** ⇒ genuine per-member codegen. The h_seq refusal
|
||
ceiling, confirmed. Same for `func_8018A808`'s family (0/14).
|
||
- **`_alias_decl_for` was ONE function, not a class** (91 alias decls fleet-wide, 90 already matched).
|
||
- **"normalized distance 0" is NOT an h_exact guarantee** — relocs are masked.
|
||
|
||
## ▶ RESUME ORDER
|
||
1. **Gate `.run/s37/*/func_*.c`** (above) → reconcile → propagate → R22 → commit.
|
||
2. **Wave 6**: derive the corpus.stubs way (rule 4) from a REGENERATED map. Pool at pause: **852
|
||
families / 225,217 ins**. Exclude the 3 walls (`0x801412a8`, `0x80178004`, whale `0x80144b9c`)
|
||
and the ledgered residuals (`0x8017c294` close=12, `0x8017f7b4`, `0x801898e4`, `0x80186e24`
|
||
close=187, `0x801758fc`, `0x80132018`, `0x8018a808`). Use `.run/s37w.js`'s pipeline block.
|
||
3. **EXTEND's last 5**: `func_80144B9C` ×4 needs the §38 `-O0` shared-header route (and
|
||
`dedup_extend` should refuse-and-name that class per R32); `func_80149954` ×1 sits behind
|
||
`func_80147364`'s u16 params.
|
||
|
||
## 🧰 MY PROCESS ERRORS — one mechanism: the signal sampled was not the thing measured
|
||
1. `nohup CMD &` inside a backgrounded call ⇒ the harness signalled the WRAPPER; the fleet check
|
||
stood at **63/140** and I nearly read it as a pass.
|
||
2. **`pgrep -x make` is right for ONE make, WRONG for a campaign** of sequential makes (fires in a
|
||
gap); **`pgrep -f <pat>` SELF-MATCHES** so that waiter never exits. Use the campaign's real argv
|
||
or `treelock.sh --status`.
|
||
3. A `corpus.stubs` probe mid-rebuild returned garbage; R32's assertion refused to answer.
|
||
4. **I predicted a fix without reading the macro in front of me** — relaxed 42 `(void)` decls and
|
||
asserted it unblocked the lane; it banked 0/1 in all 134 because that macro declares `(u8*)`.
|
||
→ the PAIR rule.
|
||
5. **I violated §136a in my own capture tool** — a narrow keyword filter reported "NO COMPILE ERROR"
|
||
on a build failing with `redefinition of struct PW8017C290`.
|
||
No bad bytes from any of them — the byte-gate and R22 caught everything.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-33/34/35 CHECKPOINT (2026-08-04)
|
||
> **Tree CLEAN** but for the R23 `db.*.gbf` churn — never stage. Effort: **ultracode**.
|
||
> **R22 clean-fleet run FIFTEEN times, 140/140 every time.** HEAD `commit:1388`.
|
||
> **Drew's standing decision: NO phase close — keep grinding, run waves all night.**
|
||
> ⚠️ A wave (`.run/s35w.js`, 13 targets / 17,644 ins) may still be IN FLIGHT — check
|
||
> `/workflows` and `.run/s35/*/*.c` before assuming the tree is idle. Agents write `.run/` ONLY.
|
||
|
||
## FLEET — R22 **140 passed / 0 failed of 140**
|
||
**96.24% fn-count · 94.0% instr-weighted · 88.4% distinct-code** (77,655 uniq) ·
|
||
dedup **1910/0** · C1 241216/241216 · **0 NON_MATCHING** (G4).
|
||
Session opened 96.01 / 93.6 / 88.0 ⇒ **+0.23pp fn, +0.4pp instr, +0.4pp distinct.**
|
||
Phase opened 92.00 / 87.5 / 78.0 ⇒ **+4.24pp fn, +6.5pp instr, +10.4pp distinct.**
|
||
|
||
## WHAT THIS SESSION DID — the deterministic lane first, then two agent waves
|
||
| lane | result |
|
||
|---|---|
|
||
| SC07 EXTEND | **0/36 → 31/36** |
|
||
| PROPAGATE head | **0 → 18,545/18,545 ins** (5/5 classes) |
|
||
| wave 1 (17 targets, 26,227 ins) | 13 heads + 65 members + 2 reconciled = **80 instances** |
|
||
| wave 2 (13 targets, 37,943 ins) | 9 heads + 1 reconciled + 18 members |
|
||
| reconcile lane | **19/20 lifetime** |
|
||
|
||
## 🔑 THE THROUGH-LINE: every blocker was TOOLING or a DECLARATION — not one was gcc
|
||
**Five tool defects, four of them the SAME §134 multi-line-blindness class in THREE tools:**
|
||
`dedup_propagate.find_site` (was discarding a 3,288-ins fn) · `overlay_src_split._split_macro_body`
|
||
(38 live instances in engine_core.h) · `family_remap._alias_decl_for` (the wrapped alias) ·
|
||
`dedup_propagate` blind to the asm-label alias form entirely. All now decide on **`cdecl._mask`** or
|
||
reuse `_alias_decl_for` — one oracle (R33), never a second hand-rolled line test.
|
||
|
||
## 📌 THE DISTILLED RULES (all in cookbook §138 + index)
|
||
1. **Bucket a gate refusal by the (macro-shape, TU-shape) PAIR, not by the SYMBOL.** The same symbol
|
||
conflicts in BOTH directions across the fleet; `func_80146C3C` cost this twice in one session.
|
||
2. **Reconcile direction depends on WHERE the TU's decl is.** ABOVE the splice ⇒ DELETE your
|
||
duplicate (§100); BELOW ⇒ KEEP a decl in the TU's EXACT shape and cast at the use (§17a-1 D2).
|
||
Picking wrong CREATES the next error. Grep the TU and compare line numbers with the stub FIRST.
|
||
3. **STEP 0 of sibling-first: `grep -rn "<MAGIC>" src/`** with a distinctive literal from the `.s`.
|
||
§136c's first two steps are same-TU/shared-header scoped and CANNOT reach a banked twin in
|
||
another overlay's TU — where the big template classes live. Found func_80188C04 (328 ins)
|
||
byte-identical to a banked twin in a different overlay, reused verbatim.
|
||
4. **Never rank off the family map's `exemplar` field.** It is an IN-FAMILY pointer and can name an
|
||
ALREADY-BANKED instance, hiding the family. Derive open sites from `corpus.stubs` over the member
|
||
list: measured 16,696 ins → **41,023** on the same map.
|
||
5. **Three carry variants hide in one "CARRY-FIXABLE" bucket** — multi-line comment (fix the tool) ·
|
||
draft-local `struct Tag` (switch to the shared type) · file-scope `static inline` helper
|
||
(hand-author + EXCLUDE the source overlay). gcc-2.7.2 accepts implicit decls, so the third PASSES
|
||
compiles_standalone and only surfaces as a byte DIFF 137 gates later.
|
||
|
||
## 🔬 MEASURED THIS SESSION, so nobody re-litigates it
|
||
- **`func_801758FC` / `func_80132018` are NOT templatable.** They banked as heads but the sweep
|
||
managed 18/165 members. Probed with `.run/s6_diag.py` (2 builds): `0x80132018`'s remapped member
|
||
**BUILD OK (byte diff)** — it compiles clean and the bytes still differ ⇒ genuine per-member
|
||
codegen, not plumbing. That is the known h_seq refusal ceiling, confirmed, not a new wall.
|
||
(`0x801758fc` reported "(no family)" — the diag keys on `exemplar.addr`; find its real map key.)
|
||
- **`_alias_decl_for` is ONE function, not a class**: 91 distinct alias decls fleet-wide, the old
|
||
per-line matcher resolved 90. The S6b note implied a class; it is not one.
|
||
- **"normalized distance 0" is NOT an h_exact guarantee** — relocs are masked. An agent's
|
||
distance-0 claim is why `dedup_propagate` correctly answered `reach<2`.
|
||
|
||
## ▶ RESUME HERE
|
||
1. **Gate `.run/s35/*/*.c`** when the wave lands: `tools/treelock.sh g .venv/bin/python
|
||
.run/s6f_gate.py '.run/s35/*/*.c'` → capture blockers for any claimed-MATCH failure
|
||
(`.run/s34_capture.py <ov>:<fn>`, which now ranks HARD errors above warnings) → reconcile per
|
||
rule 2 → `make sig-overlays` + `family_hseq.py` + `family_sweep --hseq --band all --only <addrs>`
|
||
→ **R22** → commit.
|
||
2. **Derive wave 4** the corpus.stubs way (rule 4). Pool at this checkpoint: **864 families /
|
||
250,799 ins**. Exclude the 3 walls (`0x801412a8`, `0x80178004`, the whale `0x80144b9c`) and the
|
||
ledgered residuals (`0x8017c294` close=12, `0x8017f7b4`, `0x801898e4`, `0x80186e24` close=187).
|
||
3. **EXTEND's last 5** (unchanged): `func_80144B9C` ×4 needs the §38 `-O0` shared-header route, and
|
||
`dedup_extend` should refuse-and-name that class per R32; `func_80149954` ×1 sits behind
|
||
`func_80147364`'s u16 params.
|
||
|
||
## 🧰 MY PROCESS ERRORS — all ONE mechanism: the signal sampled was not the thing measured
|
||
1. `nohup CMD &` inside a backgrounded call ⇒ the harness signalled the WRAPPER; the fleet check
|
||
stood at **63/140** and I nearly read it as a pass.
|
||
2. **CORRECTION to the S10 rule:** `pgrep -x make` is right for ONE make, **wrong for a campaign** of
|
||
sequential makes (it fires in a gap). And **`pgrep -f <pat>` SELF-MATCHES**, so that waiter can
|
||
never exit. Wait on the campaign's real argv or `treelock.sh --status`.
|
||
3. A `corpus.stubs` probe mid-rebuild returned garbage; R32's assertion refused rather than answer.
|
||
4. **I predicted a fix without reading the macro in front of me** — relaxed 42 `(void)` decls and
|
||
asserted it unblocked the lane; it banked 0/1 in all 134 because that macro declares `(u8*)`.
|
||
The PAIR rule (#1 above) is the distillation.
|
||
5. **I violated §136a in my own capture tool** — filtered the build log for
|
||
`error|conflicting|undefined reference`, so it reported "NO COMPILE ERROR" on a build failing with
|
||
`redefinition of struct PW8017C290`. A narrow keyword filter is how a real error goes unseen.
|
||
No bad bytes from any of them — the byte-gate and R22 caught everything.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-33 CHECKPOINT (2026-08-04)
|
||
> **Nothing is running. Tree lock FREE. Tree CLEAN** but for the R23 `db.*.gbf` churn — never stage.
|
||
> Effort: **ultracode**. **R22 clean-fleet run FOUR times this session, 140/140 every time.**
|
||
> HEAD `commit:1380`. **Drew's standing decision: NO phase close — keep grinding.**
|
||
|
||
## FLEET — R22 **140 passed / 0 failed of 140**
|
||
**96.10% fn-count · 93.7% instr-weighted · 88.0% distinct-code** · dedup **1908/0** ·
|
||
C1 240807/240807 · **0 NON_MATCHING** (G4).
|
||
Phase opened 92.00 / 87.5 / 78.0 ⇒ **+4.10pp fn, +6.2pp instr, +10.0pp distinct.**
|
||
|
||
## WHAT S33 DID — lane 2 of the S10 checkpoint (the propagation lag), taken FIRST on the
|
||
standing "probe the cheap lever before funding the expensive one" doctrine. **~0 agent tokens.**
|
||
- **SC07 EXTEND: 0/36 → 31/36.** Commits `commit:1377` · `commit:1378`.
|
||
- **PROPAGATE head: 7,398 of 18,545 ins banked** — `func_80147364` ×137 (4,110) + `func_8012A598`
|
||
×138 (3,288). Commits `commit:1379` · `commit:1380`.
|
||
- **Distilled to cookbook §138** (+ index regenerated) — the full triage is there, not here.
|
||
|
||
## 🔑 THE FINDING: a gate refusal in these lanes is a DECLARATION, not codegen
|
||
**Not one of the 36 EXTEND blockers was compiler codegen.** Nine failures per binary reduced to
|
||
**4 distinct symbols** repeated across all four. Two masqueraded as walls:
|
||
1. **The 4 "undiagnosed DIFF"s in `dedup_extend`'s own header are a `volatile`.** Its correctness
|
||
argument says an h_exact match makes a DIFF impossible — and the contract HELD (original bytes
|
||
sha1-identical across the failing and working overlay, `af1aceb2…`, *checked in one command with
|
||
no build*). The host TU declared `extern volatile s32 D_80127090/94/98` at FILE scope, which no
|
||
working overlay's copy does ⇒ the macro's three stores became a scheduling barrier ⇒ `addu`
|
||
could not sink into the `jal` delay slot ⇒ built body emitted it early **plus a `nop`**, one
|
||
instruction longer. **Tell: a positional shift with a `nop` at a delay slot is an ORDERING
|
||
constraint, not a wrong body.** Fixed by the §37/§124 DATA asm-label alias. 16/16 on retry.
|
||
2. **`func_80147364`: definition `(u16,u16)` vs 4,046 fleet decls `(u16,s32)`.** u16 promotes, so
|
||
the `()` escape is ILLEGAL. The **DEFINITION-side** asm-label alias is the only zero-radius
|
||
escape (1,725 in-tree precedents). Banked ×137 first try.
|
||
**Before relaxing a decl to `()`, grep the fleet's decl shapes for that symbol** — `()` is illegal
|
||
only against a *default-promotion* param. 4,020 decls of `func_80146C3C` were all `(void)/()/(u8*)`
|
||
⇒ safe ⇒ 8 of 36 for ONE token.
|
||
|
||
## 🧰 TOOL FIX — §134 multi-line blindness, now in a SECOND tool
|
||
`dedup_propagate.find_site`'s preamble backscan had the SESSION-18 fix for blank/`//`/single-line
|
||
comments and still halted on a **multi-line block comment**. Same class S6b fixed 3× in
|
||
`family_remap`. Now decides on **`cdecl._mask`** (one oracle, R33) with an R32 length-preservation
|
||
assertion. Monotone + byte-gate-fed ⇒ can fail to bank, never falsely bank. Paired with switching
|
||
the `func_8012A598` exemplar off its draft-local `struct BigCopy164` to the shared `struct BigCopy`
|
||
(engine_types.h L312, already used identically at engine_core.h:16158). **Either fix alone leaves
|
||
the function written off.**
|
||
|
||
## 🔬 S33b — the PROPAGATE remainder DIAGNOSED: it is `func_80146C3C` again
|
||
Ran the one probe the checkpoint asked for, in the order §138 prescribes:
|
||
1. **Originals byte-identical** across ov_SC07_006 / ov_SC06_025 / ov_SC01_000 / ov_SC01_077 /
|
||
ov_SC03_001 for BOTH `0x8016BA68` and `0x8012F274` (one command, no build) ⇒ the registry is
|
||
sound, the cause is TU context.
|
||
2. **One build in an excluded overlay named it:** `conflicting types for func_80146C3C` — the SAME
|
||
symbol as the EXTEND lane, the same `(void)`-vs-`(u8*)` shape, the same one-token lever.
|
||
⇒ **Relaxed all 42 remaining `extern void func_80146C3C(void);` in engine_core.h to `()`.**
|
||
Measured safe before editing: every fleet decl of that symbol is `(void)/()/(u8*)/(u8 *a0)` (no
|
||
default-promotion param anywhere, so gcc-2.7.2's `()` rule cannot bite), and every use in the header
|
||
is either a no-arg call or already cast ⇒ codegen-neutral.
|
||
**`dedup_propagate` cannot finish this one** — the 4 SC07 members are now `macro` sites, so
|
||
`find_site` never returns a `def` and the auto-source scan errors. **`dedup_extend` is the tool for
|
||
an already-macro-ized group.** Probe: exactly **1** extendable group per ordinary overlay (so the
|
||
fleet has no hidden wiring backlog beyond this) ⇒ run it across the 134 non-SC07 overlays.
|
||
|
||
## ✅ S33b RESULT — the PROPAGATE head is 15,257 of 18,545 ins banked (82%)
|
||
| class | ins | outcome |
|
||
|---|---|---|
|
||
| `func_80147364` | 4,110 | ×137 — definition-side asm-label alias |
|
||
| `func_8016BA68` | 3,886 | **×134 via `dedup_extend`** (not dedup_propagate — see the tool boundary) |
|
||
| `func_8012F274` | 3,973 | ×136 — hand-authored macro, source overlay excluded |
|
||
| `func_8012A598` | 3,288 | ×138 — the `cdecl._mask` backscan fix + the shared-type switch |
|
||
| `func_801466F0` | 3,288 | **OPEN** — the wrapped-alias regex, measured as exactly ONE function |
|
||
|
||
**THREE DISTINCT CARRY VARIANTS, each needing a different response** (they were all filed as one
|
||
"CARRY-FIXABLE" bucket before):
|
||
| variant | what `extract_unit` cannot carry | response |
|
||
|---|---|---|
|
||
| a MULTI-LINE comment halts the backscan | the externs above it | **fix the tool** (`cdecl._mask`) |
|
||
| a draft-local `struct Tag {…}` in the preamble | the type | switch the exemplar to the **shared** type |
|
||
| a file-scope `static inline` helper | the helper | hand-author the macro **and exclude the source overlay** |
|
||
The third is the sneakiest: **gcc-2.7.2 accepts implicit function declarations**, so the extracted
|
||
body PASSED `compiles_standalone` with the helper undeclared and the miss surfaced only as a
|
||
whole-binary byte DIFF, 137 gates later. And instantiating that macro in the SOURCE overlay is a
|
||
duplicate definition (its file-scope helper is still there) — `--source-overlay X --binaries
|
||
<all-but-X>` is the shape; `--binaries` alone removes the source from the scan pool and errors.
|
||
|
||
**`_alias_decl_for` measured, NOT assumed (R37):** 91 asm-label alias decls exist fleet-wide, the
|
||
current single-line regex matches **90**, and the one miss is `func_801466F0`. The S6b note implied a
|
||
class; it is one function worth 3,288 ins. Fix the regex (join-and-map, the §134 shape) or hand-author.
|
||
|
||
## ⚠️ MY WRONG PREDICTION, CORRECTED BY THE BYTES (R14/R37) — and it refines §138
|
||
Commit `commit:1382` relaxed 42 `extern void func_80146C3C(void);` decls and its message implies that
|
||
unblocked the PROPAGATE remainder. **It did not.** The re-run banked **0/1 in every one of the 134
|
||
overlays**, with the same error — because **`DEFINE_func_8016BA68` declares that symbol
|
||
`(u8*)`, not `(void)`**, and the TU declares it `(void)`. That is the **MIRROR** of the EXTEND-lane
|
||
pair, and my relax only touched one direction.
|
||
|
||
**Root cause (the R37 shape, again): I bucketed by SYMBOL and stopped there.** §138 says "bucket by
|
||
which symbol is named" — that is not sufficient. **The lever is determined by the (macro-shape,
|
||
TU-shape) PAIR**, and the same symbol conflicts in BOTH directions across the fleet:
|
||
· EXTEND lane: macro `(void)` vs TU `(u8*)` → relax the MACRO decl.
|
||
· PROPAGATE lane: macro `(u8*)` vs TU `(void)` → relax the MACRO decl *of the other form*.
|
||
One `awk` over the specific macro's own body — which I ran for the EXTEND macros and NOT for this
|
||
one — would have shown it before the 134-build run. **Read the decl of the macro you are actually
|
||
fixing, not of its sibling.**
|
||
|
||
The 42-decl relax is still **byte-neutral and still useful** (it removes a real conflict class and
|
||
R22 proved it 140/140) — it simply did not do the thing I predicted. Relaxing the remaining **2**
|
||
`(u8*)` decls is the actual fix for this lane. §138 to be amended with the PAIR rule.
|
||
|
||
## 🧹 THE §134 SCANNER SWEEP — sized, one clear target
|
||
Hand-rolled comment tests still outside the `cdecl._mask` oracle:
|
||
· **`tools/overlay_src_split.py:345`** (`_split_macro_body`) — **the IDENTICAL single-line-only
|
||
form** I just fixed in `dedup_propagate` (`not s or s.startswith("//") or (s.startswith("/*") and
|
||
s.endswith("*/"))`); it decides where a macro body's file-scope externs END, so a multi-line
|
||
comment there silently truncates the extern set. Same defect, same consequence. **Highest value.**
|
||
· `tools/overlay_src_split.py` 239/242/520/523 — same file, other scanners (these DO track a
|
||
block-comment state; lower risk).
|
||
· `tools/split_src_region.py:71-73` and `family_remap.py:829` already handle the multi-line form.
|
||
Already on the oracle: conform_decls · normalize_self_decls · reconcile_tu · scope_tu_externs ·
|
||
dedup_propagate · family_remap.
|
||
|
||
## ▶ RESUME HERE — three named items, none diagnosed against a build yet
|
||
1. **The PROPAGATE head remainder — 11,147 ins.** `func_8012f274` (3,973, **dropped**),
|
||
`func_8016ba68` (3,886, **4 of 138**), `func_801466f0` (3,288, **no source found** — the S6b
|
||
**D4** gap: its def at `ov_SC01_077_after.c:495` carries a *wrapped* `__asm__` alias decl that
|
||
`_alias_decl_for`'s single-line `rx.match` cannot see, with a file-scope `typedef struct
|
||
Rec801466F0` behind it, §100). **`--recover` is NOT a retry** — it banked 4 of 138 here, and the
|
||
reconcile lane that is 16/16 lifetime *on drafts* does not transfer to *propagation*. **Probe
|
||
ONE excluded overlay's build output (§136a) before re-running any lever.**
|
||
2. **The 41-class PROPAGATE tail** — 2,316 ins total. Low value; batch it or ledger it.
|
||
3. **EXTEND's last 5:** `func_80144B9C` ×4 — the whale's registry `func` field is a bare name, not
|
||
a `DEFINE_` macro, so `write_drafts` emits a CALL (hence "undefined reference" in ov_SC07_010);
|
||
it needs the §38 `-O0` shared-header route, **and `dedup_extend` should refuse-and-name the
|
||
class per R32** rather than feed the gate a draft that cannot pass. Plus `func_80149954` ×1,
|
||
blocked behind `func_80147364`'s u16 params.
|
||
Then: **lane 1** (S10's 17 unbanked targets, 26,227 templ ins, Sonnet at ~12-16 concurrency — the
|
||
manifest `.run/s10.json` / script `.run/s10.js` are still valid) and **lane 3** (the ×2-9 grind).
|
||
|
||
## 🧰 MY PROCESS ERRORS THIS SESSION — all ONE mechanism, all now in §138
|
||
**The signal I sampled was not the thing I was waiting for**, three times:
|
||
1. `nohup CMD &` inside a backgrounded call ⇒ the harness signalled the **wrapper**'s exit; the
|
||
fleet check stood at **63/140** and I nearly read it as a pass.
|
||
2. **CORRECTION to the S10 checkpoint's own rule.** It says use `pgrep -x make`. Right for ONE
|
||
make, **wrong for a campaign** of sequential makes — it fired in a gap and called a live
|
||
campaign done. And **`pgrep -f <pattern>` SELF-MATCHES**, so that waiter can never exit (two
|
||
spinning shells, killed). **Wait on the campaign's real argv or on `treelock.sh --status`.**
|
||
3. A `corpus.stubs` probe run mid-rebuild returned garbage — R32's coverage assertion refused to
|
||
answer rather than hand me a wrong stub set. *A measurement taken during a rebuild is not a
|
||
measurement* (S27's law, re-earned).
|
||
No bad bytes from any of them — the byte-gate and R22 caught everything.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-31/32 CHECKPOINT (2026-08-03)
|
||
> **Nothing is running. Tree lock FREE. Tree CLEAN** but for the R23 `db.*.gbf` churn — never stage.
|
||
> Effort: **ultracode**. **R22 clean-fleet run TWELVE times, 140/140 every time.** HEAD `commit:1375`.
|
||
> **Drew's standing decision: NO phase close — keep grinding** (task #15).
|
||
|
||
## FLEET — R22 **140 passed / 0 failed of 140**
|
||
**96.01% fn-count · 93.6% instr-weighted · 88.0% distinct-code** (77,550 / 87,459 uniq) ·
|
||
dedup 1905/0 · **0 NON_MATCHING** (G4).
|
||
Phase opened 92.00 / 87.5 / 78.0 ⇒ **+4.01pp fn, +6.1pp instr, +10.0pp distinct.**
|
||
|
||
## SESSION TOTAL — ~2,320 function-instances; **167/167 drafted targets banked earlier (100%)**
|
||
Campaigns: wave 4a (33) · wave 4b b1/b2/b3 (111) · S8-3 x10-99 (23) · S6c jr (12 members) ·
|
||
x2-9 calibration (22 heads + 67 members) · **S10 Sonnet wave (13 heads + 57 members)**.
|
||
Lane records: **reconcile 16/16 lifetime · redraft 15/15 · §136b closed 15/15.**
|
||
**A first-pass gate failure is a ROUTING DECISION, not a wall** (capture -> reconcile/redraft).
|
||
|
||
## 🔬 THE SONNET FINDING (Drew's call — override my routing; he was right)
|
||
| | Opus (S8-3, 121-328 ins) | **Sonnet (S10, 125-793 ins)** |
|
||
|---|---|---|
|
||
| first-pass bank rate | 10/13 = 77% | **13/16 = 81%** |
|
||
| 30-wide concurrency | fine | **SERVER-throttled, 14 of 30 never ran** |
|
||
**The §136i ~120-ins Opus threshold is TOO LOW** — it was my extrapolation, never measured. Sonnet
|
||
is at least as capable to ~800 ins. **The limiter is CAPACITY, not capability:** run Sonnet waves at
|
||
**~12-16 concurrency, not 30**. Not naming a new cliff number — 16 samples under a throttle confound
|
||
can't. Task #12 (controlled A/B) is how that gets fixed properly.
|
||
|
||
## ▶ RESUME HERE — three lanes, all measured, none blocked
|
||
1. **S10's 17 unbanked targets = 26,227 templ ins** (14 server-throttled + 3 gate-failed). Re-run in
|
||
TWO batches of ~9 at ~12 concurrency. Manifest `.run/s10.json`, script `.run/s10.js` (already all
|
||
sonnet), banked list `.run/s10_banked.txt`. Heads: func_8017D174(793x5) func_80186E24(611x5)
|
||
func_8017E2EC(296x7) func_8017C8FC(210x7) func_8017F2E8(207x7) func_80181EE0(198x7)
|
||
func_8017CDF0(693x2) func_8017E9F4(221x6) func_8017D318(184x7) func_801829BC(150x8)
|
||
func_8018F060(397x3) func_8017F624(170x7) func_80190144(128x9) func_801813D0(163x7)
|
||
func_80187DD0(174x6) func_8018457C(160x6) func_8018A390(136x7).
|
||
2. **The propagation lag — 26,006 ins, ~0 agent tokens, PARTLY BLOCKED** (task #14):
|
||
- **EXTEND shape** (14 classes / 48 stubs / **5,169 ins**): `dedup_extend --binaries
|
||
ov_SC07_006,ov_SC07_007,ov_SC07_010,ov_SC07_011` planned 36 groups and banked **0/36** —
|
||
**6 PLUMBING / 4 DIFF**, and the PLUMBING conflicts repeat the SAME ~5 symbols across all four
|
||
binaries: `func_80146C3C` (the same one that blocked func_8017C120), `func_80144B9C`,
|
||
`func_8014F4C0` (both self-axis => §37 asm-label alias), `func_8012E5CC`, `D_80126CC4`.
|
||
**~5 declaration fixes unlock most of the 36.** Reconcile-lane shaped (16/16 lifetime).
|
||
The 4 DIFFs are ODD — dedup_extend's contract says h_exact identity guarantees byte-identity
|
||
*including relocs*, so a DIFF should be impossible. Probe one (overlays-share-VAs trap?).
|
||
- **PROPAGATE shape** (45 classes / 780 stubs / **20,837 ins**): NEVER PROBED. Needs
|
||
`dedup_propagate --addr` from the single matched source. **Probe ONE before costing (§136h).**
|
||
3. **The x2-9 grind** (task #15): 411 of 1,872 families cover the 212,594-ins gap to 95% instr.
|
||
Measured ~22,937 templ ins/wave at the head; mean ins/family decays 1,844(top-25) -> 525(top-400)
|
||
-> 193(band-wide). **Est 19-30 waves.** Work highest-templatable-weight-first.
|
||
|
||
## ⚠️ P32's BEHEMOTH LEDGER IS STALE — REBUILD BEFORE PLANNING IT
|
||
roadmap-v2 claims `0x80183814` = 5,122 ins in ov_SC07_006, "largest fn in the game". **Measured: it
|
||
is ~108 ins in ov_SC02_000/003.** The largest unmatched function fleet-wide is **969 ins**
|
||
(`0x8017ef68`, ov_SC06_000); **NOTHING >=1,000 ins remains unmatched.** Of 45 distinct live stubs
|
||
>=400 ins: **21 are already cracked elsewhere (propagation lag, 24,354 instruction-instances)** and
|
||
24 are genuinely never-cracked (22,065). ~Half of "P32 wall tonnage" is not wall at all.
|
||
|
||
## ✅ MAIN IS NOT FREE DEDUP — checked two ways, both negative
|
||
main's 1,525 stubs vs 39,917 banked overlay classes: **0 h_exact hits AND 0 h_norm hits**
|
||
(h_exact alone would be meaningless — different vram base, so relocs differ by construction).
|
||
Resident 14 stubs: also 0. Consistent with Phase-11's EXE-vs-resident finding, now extended to
|
||
overlays. **Main's stubs are all genuinely fresh work — P31 scope, not a dedup opportunity.**
|
||
(Caveat: main's sig is Ghidra-derived from June 14 — valid since the binary is unchanged, but the
|
||
relocation-masked `xsig` tool is the instrument built for cross-base comparison if you want proof.)
|
||
|
||
## 🧰 MY PROCESS ERRORS TODAY — the corrected patterns (all ONE root cause)
|
||
**Trusting a proxy instead of the thing itself**, three times:
|
||
1. **§136h** — priced a 141-family sweep off `byte_weight_templatable`; it banked **1 of 1,781**.
|
||
That column counts what COULD template if bodies reproduced — the very question. **Probe one
|
||
member per family.** (Also: I pointed `family_sweep --hseq` — which REMAPS — at an h_exact-
|
||
identical population, where the correct tool is `dedup_extend`/`dedup_propagate` and no remap is
|
||
needed at all. Wrong tool, not a wall.)
|
||
2. **§136a** — classified blocker captures on EXIT STATUS, then on error PROSE. `make build` runs
|
||
`check`, so a clean-compiling byte-DIFF also exits non-zero; and `too many arguments` matched no
|
||
regex. **Derive from the invariant: did the compile produce an object?**
|
||
3. **The waiter** — `until [ -s <output> ]` fires at the FIRST LINE, not completion. It fired
|
||
mid-propagation and I ran `make clean` on a live `family_sweep`. **Use `pgrep -x make`** (exact
|
||
process name; `pgrep -f <pattern>` also SELF-MATCHES and leaked 4 spinning shells earlier).
|
||
No bad bytes from any of them — the byte-gate and R22 caught everything.
|
||
|
||
## 🔑 THE FOUR FINDINGS THIS SESSION PRODUCED (cookbook §136 · §136a · §136b · §136c · §136d)
|
||
1. **§136 — the LOCAL-VARIABLE lever.** In the 60–120-ins band most "regalloc residuals" are decided
|
||
by **how many C locals you declare and at what scope**, not by register pins (`local-alloc.c:472`
|
||
promotes any pseudo with `REG_N_DEATHS > 1` to a global allocno, which loses the low register).
|
||
One case explicitly REFUTES the pin as the lever for a redundant copy.
|
||
2. **§136b — a "genuine byte-DIFF" verdict is a fact about ONE DRAFT, closed at 8/8.** Every
|
||
DIFF-ledgered function banked on redraft: wave 3's four, the **three I classified myself**, and
|
||
one from batch 1. **Never retire a target on a DIFF verdict; route it to REDRAFT.** And
|
||
re-GATING an unchanged draft is not a retry (that is why wave 4a's 3 DIFFs survived one gate).
|
||
3. **§136a CORRECTED, by an agent, against the bytes.** I wrote "70% of gate refusals are paperwork,
|
||
not codegen." **Wrong** — a declaration conflict ABORTS the compile, so a PLUMBING verdict says
|
||
NOTHING about the body. 2 of 3 second-round PLUMBING drafts had a real codegen residual behind
|
||
the conflict. Also: classify on the build's OUTPUT, never its exit status (`make build` runs
|
||
`check`, so a clean-compiling byte-DIFF also exits non-zero).
|
||
4. **§136c — SIBLING-FIRST is a DERIVATION shortcut**, not just a conflict fix. Search order:
|
||
`engine_core.h DEFINE_* near-twin` → same-TU banked sibling → the `.s` → **the Ghidra seed LAST**
|
||
(byte-proven an entirely different body twice this session). Produced first-draft matches.
|
||
§136d adds four new levers, each with its **refuted axis** recorded.
|
||
|
||
## ▶ RESUME HERE
|
||
1. **Gate batch 3** if it was in flight (see the header) → propagate → R22 → commit.
|
||
2. **The 4 remaining stubs of 107**: `func_8017C120`(SC02_026 — classified **UNKNOWN**, neither a
|
||
compiler error nor a SHA mismatch; **owes a direct look at its build output**, not a guess) ·
|
||
`func_8017CD9C`(SC04_003) · `func_801848DC` + `func_80185904`(SC04_018). Capture then route —
|
||
**and per §136b none of these is a wall on one attempt.**
|
||
3. **The wave-4b remainder**: batch 3 was the last of the 111-family volume lane. After it, the
|
||
B-shape lanes are spent — re-derive the queue from a freshly regenerated `family_hseq` before
|
||
scoping anything new (the ×138 era already ended; the next tiers are ×10-99 and the zero-crack
|
||
non-jr residue at 120 families / 65,946 ins).
|
||
4. **T5 close** — only after re-deriving; the checklist's ROI-floor trigger is REFUTED and must not
|
||
be used to close the phase.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-30 CHECKPOINT (2026-08-01, S6 complete through wave 3)
|
||
> **Nothing is running. Tree lock FREE. Tree CLEAN** (0 non-ghidra entries; the `db.*.gbf` churn is
|
||
> R23 restart-noise — never stage). **HEAD `commit:1352`.** Effort: xHigh → **ultracode** (Drew enabled
|
||
> mid-session for the waves). `make tools-health` green at session open; frontier REGENERATED at HEAD
|
||
> after the last bank, so every number below is current (not carried forward).
|
||
|
||
## FLEET — R22 clean-fleet **140 passed / 0 failed** (run 9× this session, 140/140 every time)
|
||
**95.42% fn-count · 92.4% instr-weighted · 85.5% distinct-code** (75,926 unique fns) · dedup 1905/0 ·
|
||
0 NON_MATCHING. Phase opened 92.00 / 87.5 / 78.0 ⇒ **+3.42pp fn, +4.9pp instr, +7.5pp distinct.**
|
||
|
||
## WHAT S6 DID — ~3,500 member-matches in 11 commits
|
||
`commit:1343` S6a 842 · `commit:1344` S6b +740 · `commit:1345` S6e fix · `commit:1346` B +268 ·
|
||
`commit:1347` S6f calib +65 · `commit:1348` S6f wave-1 +544 · `commit:1349` S6g wave-2 +342 ·
|
||
`commit:1351` S6h wave-3 +673 · `commit:1352` cookbook §135 (+ 2 checkpoint/doc commits).
|
||
|
||
**Two distinct engines ran, and BOTH paid:**
|
||
1. **Tooling repair (deterministic, ~0 agent tokens).** The pre-fix tools scored the zero-crack
|
||
population at 842 members; with three scanner fixes the SAME population scored 1,582. Six defects
|
||
found, five fixed — all one root cause: **a multi-line C construct read one line at a time**, or a
|
||
guard firing on a condition it never verified. → **cookbook §134**.
|
||
2. **Agent waves (two-lane: cheap drafts + Opus reconciles).** Bank rate **83% → 93% → 89%**;
|
||
the **reconcile lane is 12/12**. → **cookbook §135** (6 codegen idioms + 4 integration rules).
|
||
|
||
## ⚠️ TWO THINGS A FRESH SESSION MUST NOT INHERIT UNCHECKED
|
||
1. **The T6 ROI-floor trigger is REFUTED. Do not close P30 on it.** The checklist says T5 fires when
|
||
"the ×138 era ENDS after S2". That was wrong twice today: two ≥126-member families were open
|
||
(33 ins of C → 266 members), and a 36-family / 28,829-ins pool of the same shape sat unexamined
|
||
behind them. **Three §133-class misses now share one mechanism — a conclusion drawn from a view
|
||
that silently excluded the thing being looked for.** Re-derive from a freshly regenerated
|
||
`family_hseq` before any close.
|
||
2. **Token economics, measured today (re-check before scaling wave 4):** deterministic sweeps ≈ **0
|
||
tokens for +0.5pp instr**; wave-1 ≈ 2.0M for +0.1pp; wave-3 ≈ 4.1M for +0.3pp. The agent lane is
|
||
still paying, but the **tooling lane paid better** — the same finding Phase 15 recorded. Probe the
|
||
cheap lever before funding the expensive one.
|
||
|
||
## 📊 THE LIVE QUEUE — re-derived at HEAD after the final bank
|
||
| lever | families | templ ins | note |
|
||
|---|---|---|---|
|
||
| B-shape ≥20 memb, ≤60 ins | **0** | 0 | **EXHAUSTED** (was 36 / 28,829) |
|
||
| B-shape ≥10 memb, **61-120 ins** | **33** | **34,895** | best per-target value; Opus ≥90 ins |
|
||
| B-shape 10-19 memb, ≤60 ins | **111** | **33,554** | volume lane, Haiku |
|
||
| zero-crack non-jr residue | 116 | 61,230 | S6-diagnosed; bimodal residue |
|
||
| zero-crack `has_mid_jr` (**S6c, untouched**) | 9 | 9,364 | needs `jtbl_family_bank`, 26 slots, ~0 tokens |
|
||
| fresh ×2-9 | 1,877 | 363,873 | worst multiplier — deprioritised |
|
||
| fresh ×1 singletons | 3,642 | 207,945 | ×1 — deprioritised |
|
||
Unmatched fleet-wide: **15,161 instances / 935,927 ins**.
|
||
|
||
## 🔁 THE WAVE RECIPE (cookbook §135 has the full version)
|
||
Manifest **derived** from `corpus.stubs` + `family_hseq`, paths verified on disk, **pasted from the
|
||
file — never typed** (a hand-transcribed list cost wave 1 three agents' time). Draft lane: Haiku ≤89
|
||
ins (≡ Opus at ≤~50, ~4.8× cheaper), Opus direct ≥90, Opus escalation between. Then: gate whole-binary
|
||
via `.run/s6f_gate.py '<glob>'` (derives every TU/split; agents' `match_one` MATCH is NOT a bank) →
|
||
**capture each failure's compiler error** → Opus reconcile lane → gate → `family_sweep --hseq
|
||
--band all --only <addrs>` → R22 → commit. **If N reconcile targets share ONE TU, forbid agent builds.**
|
||
|
||
## ▶ RESUME HERE
|
||
1. **Wave 4** over the two B-shape slices (144 families / 68,449 ins) — recipe above, §135 in prompt.
|
||
2. **S6c** — the 9 jr zero-crack families (9,364 ins, ~0 agent tokens) via `jtbl_family_bank`,
|
||
probing ONE sibling first (the S29 discipline: 1 build, not 137).
|
||
3. **The 4 carried failures:** `func_80184A94` (reconciled to `match_one` MATCH, still gate-refused)
|
||
+ 3 genuine byte-DIFFs `func_801845B0`, `func_8017BEBC`@ov_SC02_026, `func_8018480C`.
|
||
4. **T5 close** — only after re-deriving; see the refuted trigger above.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-29 CHECKPOINT (2026-08-01, refreshed ~11:2x)
|
||
> Supersedes the earlier S29 block below (which said "AT GATE 2"; Drew then directed **P30 stays
|
||
> OPEN** and approved the T6 continuation). **Nothing is running. Tree lock FREE. Tree clean** but
|
||
> for the R23 `db.*.gbf` churn (never stage). **HEAD `commit:1335`.** Effort: Max → **xHigh** (Drew).
|
||
|
||
## FLEET — R22 clean-fleet **140 passed / 0 failed** (run 7× this session, 140/140 every time)
|
||
**94.43% fn-count · 91.4% instr-weighted · 84.0% distinct-code** (73,787 unique fns) · dedup 1905/0 ·
|
||
0 NON_MATCHING. Phase opened 92.00 / 87.5 / 78.0 ⇒ **+2.43pp fn, +3.9pp instr, +6.0pp distinct.**
|
||
Session start (S28 close) was 93.25 / 89.2 / 80.5 ⇒ **+1.18 / +2.2 / +3.5pp today.**
|
||
|
||
## THE UC WAVES (Drew opted in mid-session) — 33 heads banked, ~3,560 members propagated
|
||
- **Wave 1** (14 agents, 2 lanes): 14/14 `match_one` MATCH → **8 heads banked** by three mechanisms
|
||
(plain gate · a NEW targeted decl reconcile that edits ONLY the line the compiler names · the
|
||
`gate_stage` ladder) → **1,370 members** propagated, 0 failed.
|
||
- **Wave 2 + 3** (19 + 11 agents): **19/19 heads banked** — the best conversion of the phase →
|
||
**2,192 members** / 411 stage-but-DIFF residue.
|
||
- **THE RECONCILE LANE IS THE RESULT WORTH KEEPING.** 17 of 19 wave-2 heads needed a declaration fix
|
||
and **not one needed a header edit**. Two escapes did all of it: the **§37/§124 asm-label alias**
|
||
(`<ret> aF<ADDR>(...) __asm__("func_<ADDR>")`) when the conflict is on the function ITSELF
|
||
(return-type or arity), and **conform-the-decl + cast-at-use** when it is on a DIFFERENT symbol the
|
||
draft declares (`func_80142A80`, `RotTransSV`, `func_80146C3C`, `D_8011D030`, `D_800AF634`).
|
||
This is the direct answer to the morning's failure: the documented fix for that class was a
|
||
fleet-wide decl widen, which touched **2,046 files and still did not build**. The alias sidesteps
|
||
the collision at ZERO blast radius.
|
||
- **Agents cannot run the gate**, so a blocker-capture pass (splice→build→revert) had to precede each
|
||
reconcile fan-out and embed the exact compiler error per agent. Without it they are blind on the one
|
||
axis that matters. *(R14 on my own capture: the `note:` lines I passed through were pre-existing SHB
|
||
macro-redefinition NOISE — four agents independently called it and worked the real error.)*
|
||
|
||
## WHAT S29 DID
|
||
1. **`JR-PAIR-IN-ONE-O0-OBJECT` RETIRED** — two instrument defects (§132), not a compiler wall:
|
||
`jtbl_carve` blind to a merged-double span + no `.DELETE_ON_ERROR` (a truncated `.o` outlived its
|
||
own loud compile error and the NEXT build linked it). Pair banked ×138 = 276 instances.
|
||
2. **S1 zero-crack tier — 186 members** (head `func_8014032C` 137/137 = 25,071 ins via the new
|
||
`--span-rel`, §132b; `func_8017BEBC` 13/13; + jr tier). My routing error recorded: 13 of 28
|
||
families are not jr and carve-failed by construction (§123's own law).
|
||
3. **S2 — both remaining reach-138 heads cracked.** `func_8016EC0C` (void-return delay-slot idiom)
|
||
×138; **`func_80176734` (371 ins — the largest single item in the frontier) banked first try** and
|
||
propagated. TWO agents reached byte-identical solutions independently via different lever sets.
|
||
4. **S3 measured, not scaled** — 77% of stored drafts have DECAYED (7/30 still verify); the survivors
|
||
are def-side-walled. A fleet `sed` over decls touched 2,046 files and failed ⇒ reverted (§29 law).
|
||
5. **UC wave 1 (14 agents): 14/14 match_one MATCH → 8 banked heads** by three different mechanisms
|
||
(plain gate · a NEW targeted decl reconcile that edits only the line the compiler names · the
|
||
`gate_stage` ladder). **1,370 member instances propagated, 0 failed.**
|
||
6. **Cookbook §132 · §132a · §133** (the DEFAULT-FILTER class — three times in one session a tool
|
||
silently answered a narrower question than the one asked).
|
||
|
||
## 📊 THE POST-WAVE FRONTIER (re-derived at HEAD after the 2,192-member propagation — R35)
|
||
Overlays: **94.7% fn / 91.8% instr / 85.0% distinct**; unmatched **18,635 instances / 1,069,466 ins /
|
||
13,658 distinct classes** → 2,378 families + 3,767 singletons.
|
||
|
||
| lever | scale | cost | verdict |
|
||
|---|---|---|---|
|
||
| **Zero-crack propagation (source-agnostic)** | **190 families / 129,997 ins** | **~0 agent tokens** | **DO FIRST (S6)** |
|
||
| ×10-99 fresh-crack band | 243 families / 239,058 ins | agent waves | next (S5) |
|
||
| STRUCT class (ov077 surface) | 29 fns / 39,892 ins | agent waves | after S5 |
|
||
| GIANT | 4 fns / 100,188 ins | 2 are the known walls (close=110/91) | P32's track |
|
||
| ×2-9 fresh-crack | 1,941 families / 410,671 ins | biggest mass, worst multiplier | deprioritised |
|
||
| ×1 singletons | 3,767 / 230,367 ins | ×1 | deprioritised |
|
||
| ~~S4 PINS~~ | **101 ins** (not 44,279) | — | **RETIRED, see below** |
|
||
|
||
**TWO PRICING CORRECTIONS (both §133, in OPPOSITE directions — this is why the table is re-derived):**
|
||
1. **S4 PINS is retired on measurement.** The plan priced it at **44,279 ins** from `worklist.md`,
|
||
which prices by **h_exact reach** (×138/fn). Re-priced against the family map after the waves, the
|
||
PINS functions' families are almost all already matched/propagated: **24 fns / 101 templatable ins**.
|
||
Running the planned wave would have bought ~0.001pp. The same mis-pricing that once *under*-valued
|
||
the frontier head by 138× *over*-valued this by ~440×.
|
||
2. **106 of the 190 zero-crack families have exemplars OUTSIDE `ov_SC01_077`** (ov_SC03_014 17,
|
||
ov_SC06_018 10, ov_SC01_084 9, ov_SC02_027 7, ov_SC02_011 7, …). **Every sweep this project has run
|
||
passed `--source ov_SC01_077`**, so those families were structurally unreachable — not hard, not
|
||
walled, just never addressed. Probe-confirmed: `func_8012B77C` is DEFINED in ov_SC07_006 and still
|
||
an `INCLUDE_ASM` stub in ov_SC01_000.
|
||
|
||
## ▶ RESUME HERE (T6: S1–S3 done, both UC waves done; nothing blocked, nothing running)
|
||
- **The ×138 redraft band is now CONSUMED.** All 33 fresh-crack ≥100-member families are banked
|
||
except the 2 GIANT walls (`func_801412A8` close=110, `func_80178004` close=91 — P32's track).
|
||
- **S6 (NEW, highest ROI): source-agnostic zero-crack propagation** — 190 families / 129,997 ins,
|
||
~0 agent tokens. Drive each family from ITS OWN exemplar overlay, not always ov_SC01_077; route by
|
||
tier (§123) and pass **`--band all`** (the S1 trap). Probe one sibling per family first.
|
||
- **S5: the ×10-99 band** — 243 families / 239,058 ins, the proven 3-lane workflow. Expect the ROI
|
||
floor here: the multiplier is 10-99, not 138.
|
||
- ~~S4 PINS~~ **RETIRED on measurement** (101 ins, not 44,279 — see the pricing corrections above).
|
||
- **The 411 stage-but-DIFF propagation residue** — per-overlay variants whose remapped bodies do not
|
||
reproduce; individually gate-rejected, ledger material not a lever.
|
||
- **Reusable machinery from today** (all committed): the 3-lane workflow scripts under
|
||
`.claude/…/workflows/scripts/p30-uc-wave{1,2,3}-*.js` · `.run/uc_capture.py` (blocker capture, the
|
||
precondition for any reconcile fan-out) · `.run/uc_reconcile.py` (compiler-named decl edits only) ·
|
||
`tools/jtbl_family_bank.py --span-rel` (§132b) and its `like_arg` guard (§132a).
|
||
- **T5 close** fires on the measured ROI floor. The ×138 lever is spent; S4/S5 are the remaining
|
||
in-phase levers, and their multiplier is materially lower — that is the honest floor signal.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-29 CHECKPOINT (2026-08-01 ~00:40) — AT GATE 2
|
||
> Supersedes SESSION-28 below. **Nothing is running. Tree lock FREE. Tree clean** but for the R23
|
||
> `db.*.gbf` churn (never stage). **HEAD `commit:1303`.** Effort: **Max** all session.
|
||
> `make tools-health` **RC=0** at close; **R22 clean-fleet run TWICE this session, 140/140 both times.**
|
||
|
||
## FLEET — R22 clean-fleet **140 passed / 0 failed**
|
||
**93.33% fn-count · 89.6% instr-weighted · 81.6% distinct-code** (72,416 unique fns) · dedup 1905/0 ·
|
||
C1 240496/240496 · 0 NON_MATCHING. Overlays-only: 93.6% fn / **90.1% instr** / 82.5% distinct.
|
||
Phase opened 92.00 / 87.5 / 78.0 ⇒ **+1.33pp fn-count, +2.1pp instr, +3.6pp distinct this phase.**
|
||
|
||
## WHAT S29 DID (all committed, all R22-verified)
|
||
1. **`JR-PAIR-IN-ONE-O0-OBJECT` RETIRED** — the S28 class and its §81-isolate escape are BOTH refuted.
|
||
Two instrument defects: `jtbl_carve`'s merged-double blindness + no `.DELETE_ON_ERROR` (a truncated
|
||
`.o` outliving its own loud compile error). Both fixed; cookbook **§132**.
|
||
2. **The jr pair banked ×138 each — 276 function-instances.** Frontier families **#3 and #4** by
|
||
templatable weight (37,536 + 27,324 ins). The `-O0` cluster is now COMPLETE fleet-wide.
|
||
3. **§132a** — the `--like` role-name over-transfer (`ov_SC07_010`), guard shipped.
|
||
4. **§100 type-locality** — a file-scope typedef in a draft is an *exemplar-only bank*: it passes the
|
||
gate and silently cannot travel. Caught by probing ONE sibling before 137 builds (R37).
|
||
5. **T1/T3 closed with measured per-lane verdicts** (see the checklist), tools-health + fresh frontier.
|
||
|
||
## ▶ RESUME HERE — **P30 STAYS OPEN; T6 approved (Drew, 2026-08-01)**
|
||
Gate 2 was reached and **deliberately not taken**: the ≥95% branch is out of reach (89.6%) and the
|
||
ledger branch IS met, but closing now would strand roadmap-v2 bucket **W3** (the overlay family mass)
|
||
with **no owner phase** — P31 is scope-complete/main/resident, P32 is walls/behemoths. So P30
|
||
continues on the **T6** order in the checklist above (S1 → S2 → S3 → S4 → S5), and T5 fires on the
|
||
measured ROI floor (the end of the ×138 era after S2), not on a session count.
|
||
|
||
**Start here:** S1's head — `0x8014032C` (183 ins ×137, jr, per-location, exemplar matched in
|
||
ov_SC01_077) via `jtbl_family_bank`, **probing ONE sibling first** (the S29 discipline: 1 build
|
||
instead of 137). Then `0x8017BEBC`, then the ×4-straggler families.
|
||
Frontier data: `.run/family_hseq.json` (regenerated at HEAD `commit:1303`, same-tree as the digests).
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-28 CHECKPOINT (2026-07-31 08:1x)
|
||
> Supersedes SESSION-27 below. **Nothing is running. Tree lock FREE. Tree clean** but for the R23
|
||
> `db.*.gbf` churn (never stage). **HEAD `commit:1293`** (+ this doc commit).
|
||
> Effort: opened **xHigh** → **Max** for the jr re-measurement and the T2 probe ladder → back to
|
||
> **xHigh** for the driver + sweep. `make tools-health` RC=0 at session open.
|
||
> **R22 clean-fleet run THIRTEEN times this session, 140/140 every time** (one 139/140 and one
|
||
> 137-file false-pass, both MINE, both caught and reverted — see the honesty ledger).
|
||
|
||
## FLEET — R22 clean-fleet **140 passed / 0 failed** (verified THIRTEEN times this session)
|
||
**93.25% fn-count · 89.2% instr-weighted · 80.5% distinct-code** (72,154 / 87,459 unique fns) ·
|
||
dedup 1905/0 · C1 240496/240496 · 0 NON_MATCHING. Phase opened 92.00 / 87.5 / 78.0
|
||
⇒ **+1.25pp fn-count, +1.7pp instr, +2.5pp distinct this phase.**
|
||
|
||
## 🎯 THE THREE REACH-138 TARGETS + THE SWEEP RESIDUE — 270 members banked, 1 wall
|
||
**✅ `func_8013C08C` 0/137 → 137/137** (`commit:1286`) — §94 type-carry; `E_13C08C` was a MULTI-LINE
|
||
typedef at FILE scope and `extract_unit`'s backscan cannot carry one (it presents its CLOSING line
|
||
first). Fix = §100 draft-local. Byte-neutral.
|
||
**✅ `0x8013BC7C` 133/133** (`commit:1291`) — the sweep residue. My hypothesis (split tracks the `-O0`
|
||
file) was REFUTED (SC07_006/007/011 were sub-split today and banked anyway), so I staged one member
|
||
and READ the error: (1) a typedef textually identical to `engine_types.h`'s, which C89 still rejects
|
||
— already handled by `harvest_verify`'s `cdecl.strip_provided_typedefs`; (2) §57 self-decl divergence
|
||
⇒ **`--normalize-self-decls`**. One flag, 133/133.
|
||
**⛔ `func_8013B83C` + `func_8013BD74` — NOT BANKED, class `JR-PAIR-IN-ONE-O0-OBJECT`.** Both bodies
|
||
byte-correct (`--o0` MATCH, 272/198 ins). Two jr fns sharing one `-O0` object: carving both gives a
|
||
valid span (pads `[0,4,4]`) and an INCREMENTAL build says BYTE-IDENTICAL, but the CLEAN build **cannot
|
||
link** — `undefined reference to $L105` (local label from the C-emitted jtbl) + `undefined reference
|
||
to func_8013C938` (a previously-MATCHED fn). **Untested escape: §81 step 1 — isolate one into its own
|
||
code subseg so each object owns exactly one table.** Drafts preserved at `.run/s28w/`.
|
||
|
||
## ▶ RESUME HERE — FRESH SESSION SAFE. Nothing running, tree clean, lock FREE.
|
||
**Drew's directive at the S28 close:** items 1–3 done; **item 6 wants Max** (prompted, not started);
|
||
**items 4–5 are for a FRESH SESSION** (this checkpoint is that handoff).
|
||
|
||
1. **[T1, Ultracode] Integration-recovery sweep** — the ~90 stored drafts that are `match_one`-MATCH
|
||
but integration-decayed, + the 10 named SESSION-16 blockers. Prior measured recovery 39%.
|
||
**Report point #2.** Prompt for `/effort ultracode` and WAIT (R26/R27).
|
||
2. **[T3, Ultracode] More crack waves** — 3,873 fresh cached cores across 119 binaries
|
||
(`.run/p30w4_pool.json`). ⚠️ **S28 ROI evidence: a 15-target wave cost 1.33M tokens for 12 banks
|
||
and +0.00pp headline.** Only worth resuming against HIGH-REACH targets; ×2-reach drafting is not
|
||
where the leverage is. Deal ACROSS binaries so the gate fans out.
|
||
3. ~~**[Max] #9 — `jtbl_carve` diverges on ov_SC06_018**~~ ✅ **SOLVED + BANKED (S28, `commit:1293`).**
|
||
Root cause: a jtbl **OVER-SPAN**. `sltiu 0xC` names 12 entries, the object emits 12 words, the carve
|
||
reserved 13 — the 13th being ordinary NON-ZERO data spimdisasm ran into the dlabel, which the
|
||
zero-word trim cannot see. The piece under-filled ⇒ every later symbol slid −4 ⇒ 812 `%lo`
|
||
immediates changed. Fixed with an `sltiu`-authorized clamp (refuses loudly if a surplus word looks
|
||
like a real entry). **`func_80191C50` (710 ins) BANKED**, R22 140/140. Cookbook **§131**.
|
||
⇒ the `JTBL-CARVE-BREAKS-BYTES` class is RETIRED — it was a real bug, now fixed.
|
||
4. ~~**[Max, xHigh-able] `JR-PAIR-IN-ONE-O0-OBJECT`** — try §81 step 1~~ ✅ **SOLVED + BANKED (S29).**
|
||
The class is RETIRED and the §81-isolate escape was never needed: it was TWO instrument defects
|
||
(a merged-double span `jtbl_carve` could not see + no `.DELETE_ON_ERROR`, so a truncated `.o`
|
||
survived its own loud compile error and the NEXT build linked it). Both fns banked, R22 140/140.
|
||
Cookbook **§132**. Sibling sweep (2 × 137) unblocked — see the S29 log entry.
|
||
5. **[T5, Max] Phase close.** ⚠️ **Milestone reality: 89.2% instr vs a ≥95% bar.** The remaining
|
||
overlay volume is small; the bulk is main's 1,034 stubs + the 39 type-1 modules, both **P31 scope**.
|
||
P30 realistically closes on the milestone's **ledger branch** ("every remaining overlay stub on a
|
||
named wall/behemoth/queue ledger"), which is an explicit either/or in the approved milestone —
|
||
**Drew's call, to be made deliberately at T5, not discovered.**
|
||
|
||
## ⚠️ S28 HONESTY LEDGER (read before trusting any S28 conclusion)
|
||
Five wrong calls, every one caught by an oracle, none committed:
|
||
1. **Two of three jr "wall" verdicts RETRACTED** — a grep-of-the-build-log gate in a driver with no
|
||
revert-on-abort contaminated its own measurements (§125).
|
||
2. **An 8× population under-count** (275 vs 2,184) — a bare `except: continue` swallowed R32's
|
||
coverage assertion during a rebuild; it also made me wrongly call a good T0 pin "stale" (§126a).
|
||
3. **"15 contiguous -O0 fns"** — an under-count from scanning `asm/**/*.s`, which cannot see matched
|
||
functions (§126).
|
||
4. **Broke the fleet gate to 139/140** — a negative control that corrupted the REAL tracked file and
|
||
restored it with tangled escaping (§128a). *A negative control must mutate a scratch copy.*
|
||
5. **Reported "BOTH BANKED — BYTE-IDENTICAL" from an INCREMENTAL build** that the clean build cannot
|
||
even LINK (§130). **The sharpest lesson of the session: an incremental byte-gate result can be
|
||
actively FALSE, in the most convincing direction.**
|
||
Standing consequence: **only `make clean && make extract-all && make check-all` counts**, and a
|
||
tool's exit status is never the oracle — read the output.
|
||
|
||
## 📌 THE 4th `-O0` REGION — verified, sized, and correctly BLOCKED (do not re-litigate)
|
||
My own byte scan (not the agent's claim — R14/R37) over all 156 fns of `ov_SC03_014_jr_8017EB7C`:
|
||
the `-O0` frame-pointer prologue covers **exactly** the contiguous run `0x80183CF0..0x80184868`
|
||
(15 fns), with `-O2` neighbours `0x80183A54` below and `0x80184920` above — a clean cut.
|
||
**Prize: 30 fn-instances / 1,504 ins** — the region is h_exact-identical in **ov_SC03_014 +
|
||
ov_SC03_015 ONLY**; the 3 other overlays holding a `func_801846E4` (SC03_090, SC04_005, SC05_018)
|
||
are DIFFERENT code at the same VA (overlays share VAs — the §-index warning, live).
|
||
**Blocked structurally:** all 15 live in an `-O2` split (`corpus.o0_sources` confirms), and the
|
||
append-to-`_o0b` route fails BY CONSTRUCTION (the existing `_o0b` covers the whale at file
|
||
`0x1CA44..0x1D64C`; this region is far above it, so appended bytes land at the wrong VA — the same
|
||
reasoning that killed the T2 ×1 append probe). ⇒ needs the re-carve; it IS T2.
|
||
|
||
## ⚠️ TWO CORRECTIONS TO THE SESSION-27 CHECKPOINT (mine, R14)
|
||
1. **The 137 were SKIPS, not failures.** S27 folded them into the 401 gate-failures;
|
||
`137+22+10 = 169 ≠ 401`. They are a separate `skipped{}` bucket.
|
||
2. **The cause was NOT "the exemplar banked in a different binary."** It is banked in
|
||
`ov_SC01_077` under the §37/§73 **asm-label alias** (`int aF8016191C(...) __asm__("func_8016191C")`),
|
||
and `extract_unit` only matched a head literally named `func_<ADDR>`. One exemplar × 137
|
||
same-address members — a tool lookup miss, the 4th consecutive "structural" residual to resolve
|
||
to our own tooling (R35). Fixed T0-only; the alternative (widen `engine_core.h`, drop the alias)
|
||
was REJECTED — it fixes only §73's RETURN axis while the decl/body also disagree on PARAMS, and
|
||
it is a T2 fleet-shared edit. §124.
|
||
|
||
## 🧪 A METHOD NOTE WORTH KEEPING (cost me one probe this session)
|
||
I ran a `corpus.stubs` probe **while `make extract-all` was mid-flight** and got 4 binaries' worth of
|
||
garbage. `corpus.py`'s R32 coverage assertion caught it and refused to answer instead of returning a
|
||
wrong stub set — the assertion earning its keep. *A measurement taken during a rebuild is not a
|
||
measurement* (SESSION-27's law, re-earned). Re-derive after the campaign exits.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-27 CHECKPOINT (2026-07-31 01:25)
|
||
> Supersedes SESSION-26 below. **Nothing is running. Tree lock FREE. Tree clean** but for the R23
|
||
> `db.*.gbf` churn (never stage). **HEAD `commit:1258`.**
|
||
|
||
## FLEET — R22 clean-fleet **140 passed / 0 failed** (verified at HEAD)
|
||
**92.67% fn-count · 88.3% instr-weighted · 78.7% distinct-code** (70,590 / 87,459 unique fns).
|
||
Phase opened at 87.5 / 78.0 / 92.00 → **+0.8pp instr, +0.7pp distinct, +0.67pp fn-count** so far.
|
||
|
||
## WHAT LANDED THIS SESSION (all committed, all R22-verified)
|
||
- **T0 instrument repair (a–f)**, 6 commits — incl. `gate_stage` stage-0 (§122) and the
|
||
`fix_arity_callers` per-edit journal undo.
|
||
- **T0.5 fleet Ghidra-C prefetch COMPLETE** — 124/124 programs, **7,716 files**, 335 min unattended.
|
||
**95.2% of the 6,070 crack-needing families are seeded; main 2,001/2,002; resident 14/14.**
|
||
- **T3 waves 1–4 + behemoths:** wave1 8/14 · wave2 15/19 · wave3 **48/48** · wave4 **69/70 banked**
|
||
(70/70 drafted) · **7 behemoths CONFIRMED** at 700–970 ins (4 banked; 3 jr deferred).
|
||
- **Propagation:** 548 + 911 members via `family_sweep --hseq`; h_exact leg 14 propagated / 42
|
||
benign skips / 0 failures.
|
||
- **New instruments:** `tools/treelock.sh` · `tools/prefetch_fleet.py` · `tools/cookbook_index.py`
|
||
+ **`docs/cookbook-index.md` (324 sections, symptom-keyed, in `tools-health`)**.
|
||
- **Cookbook §122, §123.**
|
||
|
||
## ▶ RESUME HERE (nothing blocked, nothing in flight)
|
||
1. **`func_801846E4`** (ov_SC03_014) — the 1 of 10 resumed drafts that did NOT bank (agent reported
|
||
MATCH; gate refused). Draft at `.run/drafts-p30w4/ov_SC03_014/func_801846E4.c`. Its agent flagged
|
||
it as the **-O0** class (SIZE-MISMATCH/short + frame-pointer prologue) — likely needs `--o0`.
|
||
2. **The 137 "no matched unit for func"** sweep-routing gap — `family_sweep` looks for the exemplar's
|
||
banked unit in the wrong binary. Cheap, worth ~137 members.
|
||
3. **3 jr behemoths** (`func_80191C50`, `func_8018057C`, `func_80181CDC`; staged in
|
||
`.run/beh-gate/<binary>/`) **+ group B's carve** (13-member IMM/jr @952, 103 already matched →
|
||
`jtbl_family_bank.py`). **Both run `make extract` — run ALONE under `tools/treelock.sh`.**
|
||
4. **T2 `-O0` carve-within-a-carve** (13 families / 1,746 members). Newly cheaper: wave-4 agents
|
||
documented the `match_one --o0` flag AND found a **4th -O0 region** beyond the 3 known ones.
|
||
5. **Next wave:** 3,873 fresh cached cores across 119 binaries remain (`.run/p30w4_pool.json`);
|
||
deal them ACROSS binaries so the gate fans out.
|
||
|
||
## 🔁 THE LOOP THAT WORKS (proven 4 waves running)
|
||
draft (agents, `.run/` only) → **`--no-propagate` gate, per-binary IN PARALLEL** → sig+map regen →
|
||
**propagate per-function, routed by tier (§123)** → **one R22** → commit. Wrap every tree-writing
|
||
campaign in `tools/treelock.sh`.
|
||
|
||
## ⚠️ THE THREE LAWS THIS SESSION COST US (all mine, all now mechanised)
|
||
1. **Guard the CAMPAIGN, not the process** — a `pgrep` poll cannot see a campaign made of sequential
|
||
processes; mine started in a gap → 63/140 broke. → `treelock.sh`.
|
||
2. **A killed process performs no undo** — a fixed 3600s propagation timeout killed the driver
|
||
mid-fleet-write. → timeout scales with bank count AND is caught.
|
||
3. **A measurement taken during corruption is not a measurement** — I reported a "per-binary bank-rate
|
||
cliff" and theorised a cause; re-gated clean it was 6/6 everywhere.
|
||
*Both incidents cost build cycles and ZERO work, because agents only ever write `.run/`.*
|
||
|
||
## 📊 THE MEASURED FINDING WORTH KEEPING
|
||
Bank rate by wave: **57% (no index) → 79% → 100% → 99%** (index-first). Same models, same gate. The
|
||
bottleneck was **discoverability of our own knowledge**, not the compiler. Agents also self-report
|
||
`index_hit`/`index_gap`, and their gap reports are now curated symptom lines — the flywheel is
|
||
closing on itself.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION-26 CHECKPOINT (2026-07-30 23:05)
|
||
> Supersedes the in-flight block below. Paused for the 5h usage limit; **a one-shot cron is set for
|
||
> 00:47 (2026-07-31)** to resume — but cron is SESSION-ONLY and dies with this session, so if the
|
||
> session ended, just follow "RESUME HERE" manually.
|
||
|
||
**HEAD `commit:1254`.** Fleet at last verified point: **92.59% fn-count · 88.2% instr · 78.7%
|
||
distinct · R22 140/140** (commit `commit:1252`).
|
||
|
||
## ⏳ RUNNING AT PAUSE (check these FIRST)
|
||
- **`w4-gate`** under `tools/treelock.sh` (pid at pause 1313761): gating wave-4's **68 drafts across
|
||
14 binaries** in parallel, then sig+map regen, then R22. Log: `.run/w4gate_run.log` +
|
||
`.run/w4gate/<binary>.log`. If it did not finish: `tools/treelock.sh w4-gate bash .run/p30w4_gate.sh`.
|
||
**Nothing from it is committed yet** — commit only after R22 shows 140/140.
|
||
- Tree carries **Lane A's 15 banks** (sweep finished: 15 banked / 712 failed / 910 already-not-stub —
|
||
the population was largely consumed by the earlier sweep, so Lane A is now nearly spent).
|
||
|
||
## ▶ RESUME HERE (in order)
|
||
1. Finish/verify the w4-gate → R22 140/140 → commit.
|
||
2. **RESUME THE 12 UNFINISHED AGENTS** (`.run/p30w4_remaining.json`) — Drew's explicit instruction,
|
||
cron `799f00d8` set for **00:49 on 2026-07-31**. Wave 4 launched 70, **58 returned (ALL 58
|
||
match_one MATCH)**, 12 were killed mid-run:
|
||
`func_8017EA1C`(SC02_041) · `func_8018A150`(SC02_027) · `func_80185680`(SC02_017) ·
|
||
`func_8017D900`,`func_801846E4`(SC03_014) · `func_80187940`,`func_80185B5C`,`func_801885C0`(SC04_011) ·
|
||
`func_801832D4`,`func_80183CBC`,`func_80183258`,`func_8017D7A4`(SC02_035).
|
||
Workflow scriptPath
|
||
`/tmp/claude-1000/-home-musashi-bfm-decomp/f1a9b030-5924-4b17-b102-3de2ca684a6f/scratchpad/p30w4.js`,
|
||
args = the 12 targets **as an ARRAY** (a JSON string breaks `pipeline()`).
|
||
⚠️ 10 of the 12 have a **PARTIAL draft** on disk from the killed run — a starting point, NOT a
|
||
verified result; re-verify with `match_one` before any MATCH claim.
|
||
*(Counting note, R14: my first count said "2 remaining" because I measured draft-FILE existence.
|
||
An agent writes its draft early and then iterates, so a file proves nothing about completion —
|
||
the journal's `result` records are the truth. Drew's "12" was right and my measure was wrong.)*
|
||
3. The **h_exact propagation leg** that halted at `0x801466F0` (rc=1, stopped by design).
|
||
4. The **137 "no matched unit for func"** sweep-routing gap — the exemplar banked in a DIFFERENT
|
||
binary than `family_sweep` looks in. Likely cheap and worth ~137 members.
|
||
5. **3 jr behemoths** (`func_80191C50`, `func_8018057C`, `func_80181CDC`, staged in
|
||
`.run/beh-gate/<binary>/`) + **group B's carve** (13-member IMM/jr family @952, 103 already
|
||
matched → `jtbl_family_bank`). Both run `make extract` — run them ALONE under the lock.
|
||
6. **T2's `-O0` carve-within-a-carve** (13 families / 1,746 members walled) — the deep arc.
|
||
|
||
## ⚠️ THE TWO LAWS THIS SESSION COST US (both self-inflicted, both now mechanised)
|
||
- **Guard the CAMPAIGN, not the process** (`tools/treelock.sh`). A `pgrep` poll cannot see a campaign
|
||
made of sequential processes; mine started in a gap and 63/140 binaries broke.
|
||
- **Gate with `--no-propagate`, then propagate PER FUNCTION, routed by tier (§123).** A fixed 3600s
|
||
propagation timeout killed the driver mid-fleet-write; a killed process performs no undo.
|
||
- Corollary proven twice: **agents must only ever write `.run/`** — that is why both incidents cost
|
||
build cycles and zero work.
|
||
|
||
## 📓 NEW THIS SESSION
|
||
Cookbook **§122** (gate raw before transforming; undo belongs to the writer as a per-edit journal),
|
||
**§123** (propagate a family with the tool its TIER needs + routing table), **`docs/cookbook-index.md`**
|
||
(226→324 sections, symptom-keyed, in `tools-health`), `tools/treelock.sh`, `tools/prefetch_fleet.py`,
|
||
`tools/cookbook_index.py`.
|
||
|
||
---
|
||
|
||
# 🛑 (superseded) SESSION CHECKPOINT (2026-07-30, in-flight)
|
||
> Written while two background campaigns run; REFRESH before any pause (the stale-checkpoint trap).
|
||
|
||
**Running in background:** (1) **T0.5 full prefetch batch** (`prefetch_fleet.py`, 126 programs —
|
||
imports ~3 min each + define+decompile; cache was 3,680 at launch; task `baw61zyz6`; resumable —
|
||
re-run the same command if interrupted). (2) **T1a recovery sweep** (`.run/recover/t1a_runner.py`
|
||
→ `.run/recover/t1a.log`; 108 autopsy-MATCH fns / 50 binaries; driver commits banks per binary via
|
||
gate_stage's scoped add; **OWED AFTER IT LANDS:** a config sweep-up commit — jr-bank preps edit
|
||
`config/overlays.mk` + splat yamls which `gate_stage --commit` does NOT stage — then R22 clean-fleet
|
||
+ report point #2).
|
||
|
||
**HEAD at checkpoint:** `commit:1223`. **Fleet:** 87.5 / 78.0 / 92.00 (pre-T1a-banks). Tree: T1a's
|
||
in-flight src/config edits (theirs); `.run/` artifacts.
|
||
|
||
**T0 ✅ (6 commits) · T0.5 ▶ (batch running; main+3 overlays done: +2,241 cached) · T1a ▶ ·
|
||
T2 ▶ (two probes done, arc re-scoped — see log; NEXT session opener: sub-split carve + shift-diff
|
||
+ symbol-pin probe on ov_SC07_007) · T3/T4/T5 pending.**
|
||
|
||
**If resuming fresh:** read `docs/frontier-p30.md` (report point #1, with the T2 R14 correction) +
|
||
the T2 log entries; check both background tasks' outcomes first (`git log` for t6-recover commits;
|
||
`ls .run/ghidra_c | wc -l`); the Ultracode prompt for T3's first wave is still OWED to Drew
|
||
(R26/R27) — T1b agent-residue wave folds into it.
|
||
|
||
## Per-task log
|
||
|
||
### ▶ S43-1 — the §148 "GTE macro wall" was a SILENT CPP FALLBACK; the permuter lane was dead on 63 drafts (2026-08-05)
|
||
First task of the serial-crack continuation. §148's tooling note recorded *"the `gte_*` `#define` block
|
||
defeats `make_base_c` — demacroize first."* **That diagnosis was wrong (R14/R35), and the fix is in our
|
||
tooling, not the drafts.**
|
||
|
||
**Root cause (reproduced, not inferred):** `make_base_c` called `cpp_expand_macros` **before**
|
||
`drop_preproc_and_scalar_typedefs` removed `#include` lines, so `mipsel-linux-gnu-cpp -P -nostdinc -`
|
||
died on `#include "common.h"` (`rc=1`, **empty stdout**) and the `return c` fallback handed back the
|
||
**unexpanded** draft. `hide_asm` — which is built for `__asm__` *statements*, not multi-line macro
|
||
*definitions* — then chewed through the `gte_*` block and swallowed the function with it. pycparser
|
||
reported *"Function … not found in base.c"* and decomp-permuter **no-opped in 0 s**, which at the call
|
||
site is indistinguishable from "searched and found nothing". `cpp_expand_macros` exists precisely to
|
||
prevent this; its detector fired correctly; the silent fallback undid it.
|
||
|
||
**Shipped (`tools/p16_permute.py`):**
|
||
- `cpp_expand_macros` strips `#include` before the cpp call (byte-neutral — they are dropped downstream
|
||
regardless) and **RAISES** on cpp failure instead of returning its input (R32/R35: no silent fallback).
|
||
- **NEW `defines_fn(base_c, fn)`** + an assertion in `setup()`: base.c must still contain a *definition*
|
||
of the target. This guards the **output**, so it catches every swallow cause (this cpp path, the §G
|
||
unterminated-comment class, future macro shapes), not just the one diagnosed today.
|
||
- `main()` catches the RuntimeError per function so one bad draft is loud + counted but cannot abort a batch.
|
||
|
||
**Verification:** target `func_8017C6F4` → `defines_fn` True, 0 `gte_` macros left, 35 asm statements
|
||
correctly hidden as b64 pragma carriers; **proxy validated over 388 stored drafts with a plain
|
||
definition → 0 false alarms, 0 cpp raises** (macro-free drafts byte-untouched); end-to-end the permuter
|
||
now loads the draft at **base score 65** and iterates (was a 0 s no-op).
|
||
|
||
**Blast radius (measured, 14,899 stored drafts scanned):** **63 drafts** carry both a `#define … __asm__`
|
||
and an `#include` — including `drafts-behemoth2/3` — so **the permuter lane has been silently dead on
|
||
the GTE-heavy renderer/behemoth drafts, the highest-byte-weight targets on the board.**
|
||
|
||
**⚠️ Consequence for §147/§148's floors:** the ~40 hand probes on `func_8017C6F4` (and `func_8017C294`'s
|
||
sweep) were run with the permuter *unavailable*. "The permuter also plateaus" was never measured on
|
||
these functions — do not treat those floors as permuter-tested. → cookbook §148 tooling note corrected
|
||
in place.
|
||
|
||
### ▶ S43-2 — the permuter took the "unmovable" 63 to 42; and the ledger row was NOT a rumour (2026-08-05)
|
||
**The floor moved.** With `base.c` fixed (S43-1), `permuter_ils` on the S42 hand draft: masked base 65
|
||
→ **44 in cycle 1**, then flat across 5 warm restarts. Re-measured in `match_one` terms (the metrics are
|
||
NOT interchangeable — always re-measure before comparing): **63 → 42 mismatched**, same 947/947 ins,
|
||
residual still the register-rotation class but with fewer instances. **The first movement on this
|
||
function after ~40 hand probes** — and it came from repairing an instrument, not from new C.
|
||
Draft preserved + allowlisted: `.run/s43/func_8017C6F4.ils44.c` (+ `ils_8017C6F4.log`), logged to the
|
||
backlog at closeness 42.
|
||
|
||
**Final permuter verdict for this function (14 warm restarts across two basins):** pin-free seed
|
||
**masked 44 / match_one 42** (flat over 8 cycles); the `pin-t5` seed **masked 43 / match_one 41**
|
||
(flat over 5). **Best known draft = `.run/s43/func_8017C6F4.ils43-pin.c` at closeness 41**, logged.
|
||
So the permuter is worth **63 → 41** here and is now itself exhausted on both basins — the residual
|
||
register rotation survives it. Next lever is §148-C (the zero-byte allocno-priority slider) by hand,
|
||
or Fable5 on a genuinely fresh seed; **do not re-run the ILS on these two seeds, it is measured flat.**
|
||
|
||
**The S42 "rumour row" claim was WRONG (R14) — and the truth is a worse defect.** The 2026-07-01 row
|
||
*does* have an artifact, it *is* on disk (`.run/backlog_drafts/func_8017C6F4.c`, one of 3,335 there),
|
||
and it *reproduces exactly*: `match_one` vs `ov_SC03_010` → **14 mismatched of 15 target ins**,
|
||
`SIZE-MISMATCH/redraft`. It is not a rumour; it is a near-worthless draft on a **different function**.
|
||
**`0x8017C6F4` hosts TWO bodies:** 15 ins in `ov_SC03_010/011/013`, **948 ins** in
|
||
`ov_SC03_126/003`, `ov_SC04_021`, `ov_SC05_019` (§148-E, ledger side).
|
||
|
||
Three defects, all in `tools/backlog.py`, all fixed:
|
||
1. **`load_best` keyed on address alone**, so the two bodies merged and the LOWER absolute closeness
|
||
won — a 14-of-15-wrong draft (7% correct) masked a hand-won 63-of-947 (**93% correct**). Now
|
||
sub-keyed by known `nins`; unknown-`nins` rows keep the old behaviour and fold into the sole known
|
||
body when unambiguous (so legacy name-vs-addr dedup is preserved).
|
||
2. **`binary: null` defaulted to `ov_SC01_077`, where `func_8017C6F4` does not exist at all** — and
|
||
"not an open stub there" was read as "banked", so today's real result was **invisible to render,
|
||
the grinder, and target selection**. *Absent ≠ done* (R32/R34). Now: derive the binary from the
|
||
draft path, and only drop when the fn is closed in every binary that has it (`_open_anywhere`).
|
||
3. **`backlog.py log` had no `--binary` flag at all** — the root cause of every null. Added, plus
|
||
`append_record` derives it from the draft path (the S20 `addr_of` lesson, applied to `binary`).
|
||
|
||
**Measured impact, derived not asserted (R37):** replaying the exact pre-fix selection → **836 → 837
|
||
rows, 1 appeared, 0 vanished**, and the one that appeared is `func_8017C6F4 nins=947`. The live blast
|
||
radius is one row *today* — `s42-serial` is the only logger that omitted `binary` — but the mechanism
|
||
would silently eat every future serial/agent result logged the same way.
|
||
**Note on ranking (documented, NOT fixed):** `closeness` is an ABSOLUTE mismatch count, so it is not
|
||
comparable across sizes — 14/15 outranks 63/947. A relative-closeness rank was probed and **not built**:
|
||
only **24 of 836** live rows carry both `closeness` and `nins`, and on those the two orderings agree
|
||
14/15 (most are closeness=0 integration-stranded). Revisit if `nins` coverage ever rises.
|
||
|
||
### ▶ S43-3 — the CC1-FAIL label named MAKE, not the compiler: ~3,000 content-free labels (2026-08-05)
|
||
The checkpoint's cheap-fuel note ("the classifier writes `CC1-FAIL: make: *** Error 33` **without the
|
||
cc1 message**, so each costs a manual splice-and-rebuild") is exactly right, and the cause is one line.
|
||
`classify_fail` picked `errs[-1]` — the LAST error line — and make prints its own summary
|
||
(`make: *** [Makefile:N: build/src/<ov>/<tu>.o] Error N`) **last, always**. So make's wrapper won every
|
||
time, and the label carried nothing but the TU name the record already stores.
|
||
|
||
**Measured over the committed `.classified.txt` corpus (R37, derived not asserted): ~3,000 of ~4,000
|
||
CC1-FAIL labels are that wrapper**, plus 1,019 bare `CC1-FAIL` with no message at all.
|
||
|
||
**Fix:** `_MAKE_WRAP` guard — make's summary lines are excluded from the label, and the **FIRST** real
|
||
diagnostic wins (cc1 cascades: error #1 is the root cause, error #N its aftershock). When nothing but a
|
||
wrapper exists the label is now `CC1-FAIL(no-diagnostic):` — honest about the gap rather than
|
||
disguising it (R32). This is the same family as the §58 warning red-herring guard immediately above it
|
||
in the source: *a label identical for every input carries no information.* Verified on the exact branch:
|
||
`CC1-FAIL: make: *** [...] Error 33` → ``CC1-FAIL: src/…/tu.c:2240: error: too few arguments to
|
||
function `gte_ldv3'``.
|
||
|
||
**⚠️ HAZARD FOUND (mine, and now documented in the file's header):** `harvest_verify.py` has **no
|
||
`if __name__ == '__main__'` guard** — the entire gate runs at module level. Unit-testing `classify_fail`
|
||
by importing the module **ran a full 13-draft resident gate** and overwrote the unsuffixed
|
||
`.run/harvest_{verified,failed}*.txt` scratch. No damage (resident stayed `8e17e02f`, 0 banked, tree
|
||
clean, per-binary outputs untouched) and **nothing imports it today** (checked), so it is a documented
|
||
hazard rather than a risky 500-line refactor of the most load-bearing gate we own. **To test a helper
|
||
in it, `exec` that function's source (`ast.get_source_segment`) — never `import` the module.**
|
||
|
||
### ▶ S43-4 — the "26 unpropagated members = cheapest fuel on the board" is REFUTED: 0 of 31 templatable (2026-08-05)
|
||
The S40 close and the S42 checkpoint both list this as item #1/#3 cheap fuel — *"20 CC1-FAIL + 5 callee
|
||
conflicts; the recovery ladder already has every lever."* **Measured today: it does not.**
|
||
|
||
**Re-derived from the tree, not inherited (R35):** the S40 propagation commit `commit:1465` banked **59**
|
||
function families; **22 of them still have open members — 31 instances**, not 26 (the stale count was
|
||
taken before later sessions moved the board).
|
||
|
||
**The probe (SCAN, don't sample — S4's lesson):** for each of the 31, try a mechanical `family_remap`
|
||
from **every** binary where the same function is already matched (up to 4 sources each).
|
||
**RESULT: 0 templatable / 31 not.** Every attempt fails `reloc-count mismatch … (not an h_norm-clean
|
||
pair)` — and the mismatches are gross, not marginal: `2!=15`, `12!=2`, `11!=20`, `2!=0`.
|
||
Script + JSON preserved: `.run/s43/probe_leftovers.py`, `.run/s43/leftover_probe.json`.
|
||
|
||
**What they actually are:** structurally DISTINCT bodies that merely share an address and a name across
|
||
overlays — the same collision as `func_8017C6F4` (15 ins vs 948, S43-2), one level down. The `family_hseq`
|
||
manifest agrees independently (R34): these members cluster into families with **`matched=0`**, several
|
||
with `n_members=1`. There is no matched sibling to template from, so there is nothing for the recovery
|
||
ladder to recover — **the failures were never plumbing.**
|
||
|
||
**Scope of the claim (stated precisely, P9):** what is refuted is *mechanical remap from a matched
|
||
sibling* (0/31, strong). What remains formally untested is whether an h_seq-staged draft plus the
|
||
recovery ladder could bank some — but that is the path that produced the original CC1-FAILs, its
|
||
labels were content-free until S43-3, and `--hseq --only` now stages **0 families** for these addrs
|
||
because none has a matched exemplar. Treat them as **per-member drafting work (agent-class), not
|
||
deterministic fuel** — and cost the next wave accordingly.
|
||
|
||
**Board correction:** strike "26 unpropagated members" from the cheap-fuel list. It was three sessions
|
||
old, never probed, and would have been priced at ~0 tokens (R37: probe before costing — this is the
|
||
rule's own failure mode, caught by applying it).
|
||
|
||
### ▶ S43-5 — the serial queue: `func_8017EF68` is at **2 of 969** and was measured against the WRONG BODY for months (2026-08-05)
|
||
Ran the queue's mandatory all-drafts scan before drafting anything (S4's law). It paid immediately, and
|
||
in a way that indicts the queue's own annotations.
|
||
|
||
**The queue list's sizes are wrong** — `func_8017EF68` is listed as "969" but is **12 ins** in
|
||
`ov_SC03_007`; `func_8017CE58` is listed "733×3" but is **246** in `ov_SC02_000`. Cause: the *third*
|
||
instance of today's address-collision pattern. Both addresses host two unrelated bodies:
|
||
`0x8017EF68` = **12 ins** (ov_SC03_007) and **970 ins** (ov_SC06_000); `0x8017CE58` = **246**
|
||
(ov_SC02_000/003) and **734** (ov_SC03_092).
|
||
|
||
**Consequence:** the stored draft `.run/drafts-p30beh/func_8017EF68.c` is a **969-instruction** draft.
|
||
Measured against the 12-ins body — which is what every scan keyed on name+home did — it scores
|
||
`969 mismatched` and reads as garbage. Measured against its OWN body (`ov_SC06_000`):
|
||
**`DIFF 969/969 ins, 2 mismatched, SCHEDULE-REORDER/2, profile=schedule`.**
|
||
|
||
**It is a two-instruction adjacent transposition** — `lw $v0,0($s3)` ↔ `srl $a2,$a1,16` at idx 75/76,
|
||
*registers, frame, spill map and every other instruction already byte-exact.* The draft's header
|
||
documents five byte-measured levers that took it 827 → 2, a "DO NOT RE-BUY" list of ~20 spent hand
|
||
variants, a §49 root-cause analysis (a `sched2` `INSN_LUID` tie: both candidates measure priority 3, so
|
||
the backward scheduler picks the larger LUID, and `sched1` sinks the `srl` to just before its consumer
|
||
which gives it that larger LUID — the target needs the opposite sign), and it ends:
|
||
**"NEXT STEP: this is the permuter's exact profile."**
|
||
|
||
**And the permuter could not run on it.** `.run/drafts-p30beh/` is one of the 63 GTE-draft directories
|
||
S43-1 unblocked — so this function has been sitting **one working permuter run from a bank**, with a
|
||
note on disk naming the permuter as the next step, for as long as the silent fallback existed.
|
||
|
||
**Status:** ILS (schedule profile, 6 cycles × 240 s) reached the same **2** and held it flat — the tie
|
||
survives the repaired permuter's directed search. A longer free run (12 × 600 s) is queued. Logged to
|
||
the backlog at closeness 2 with the correct binary. **Escalation from here is Fable5** (§45's gdb-on-cc1
|
||
read of the scheduler is exactly this class) — that needs Drew's go (R27).
|
||
|
||
**Queue note:** `func_8017C974` (22 drafts on disk) best-of-22 is 812/947 — genuinely far, not a
|
||
near-miss; `func_8017CE58`'s only draft is Ghidra-C and CC1-FAILs. **Re-derive every queue entry's size
|
||
and home from the bytes before briefing an agent on it** — the list's annotations are unreliable.
|
||
|
||
### ▶ S43-6 — `func_8017C6F4` CRACKED by Fable5, pin-free, and banked ×4 (~3,788 ins) (2026-08-05)
|
||
Drew approved the Fable5 escalation (R27). Two isolated agents, one per function, never batched.
|
||
|
||
**RESULT: byte-exact, pin-free, 947 ins — and my diagnosis was wrong.** I had this filed as §147-E, a
|
||
`qty_compare` tie unreachable from source. It was **variable-identity evidence** all along:
|
||
1. the X-pass and Y-pass min/max intermediates are **different variables** (8, not 4 reused);
|
||
2. `mnc`/`mxc` **do not exist** — the cell clamps reuse the PRIM-LOOP `mn/mx` (X) and `mny/my` (Y).
|
||
Ablations prove the conjunction is required: split-only **63**, reuse-only **624**, both = MATCH.
|
||
That also explains why S42's "separate X vs Y variables" probe was recorded as a failure — it was
|
||
half the fix. And why every allocator lever was inert (pins, §148-C sliders, declaration order, 14
|
||
permuter restarts): **the draft had the wrong NUMBER OF PSEUDOS**, which no allocator steering reaches.
|
||
|
||
**Verified independently before believing it (R14):** `match_one` MATCH (947 ins) re-run by me, then
|
||
the whole-binary gate.
|
||
|
||
**BANKED ×4 — every 948-ins sibling of this body:**
|
||
| binary | SHA (byte-identical) |
|
||
|---|---|
|
||
| ov_SC03_126 | `c48a8bb894974dd3746a5833a20ee6da2feb831f` |
|
||
| ov_SC03_003 | `898bf52a903dcb74ce11d2a8389c483ecc24e49e` |
|
||
| ov_SC04_021 | `336142349b39ea4f5139b035fdb1ca8d8e7961c8` |
|
||
| ov_SC05_019 | `3f5b4f132ed3ca63522d75c4021033b9d32b7a39` |
|
||
`family_remap` produced all three siblings cleanly (SC03_003 remapped 4 per-overlay symbols; the other
|
||
two needed none). **≈3,788 instructions.** ⚠️ These are INCREMENTAL-build gates — R22 clean-fleet is
|
||
owed before the commit is trustworthy (§130: an incremental build can pass what a clean build cannot
|
||
even link). Deferred only because the second Fable5 agent is reading `asm/` and `make clean` would
|
||
destroy its inputs mid-run.
|
||
|
||
**The propagation gotcha (§146, seen again):** all three siblings first failed the gate with
|
||
`PLUMBING: parse error before 'MTX_C6F4'` — `family_remap`'s `_carry_macros` carries `#define`s but
|
||
**not typedefs**. Prepending the 9 typedef lines to each remapped draft fixed all three.
|
||
**Worth noting: that label is legible only because of this session's classifier fix — before it, this
|
||
would have read `CC1-FAIL: make: *** Error N` and cost three manual splice-and-rebuild diagnoses.**
|
||
|
||
**Idiom distilled → cookbook §150** (a register rotation across symmetric blocks is variable-identity
|
||
evidence; decode ownership from the MATCHING diff regions first; per-instance register asymmetry ⇒
|
||
per-instance variables; a deleted self-move in one of two symmetric blocks is the tell; and the
|
||
`global.c:719`-vs-`:729` death-before-store exemption that produces it). §147-E corrected: it named
|
||
the wrong allocator — these are `global.c` allocnos, not local `qty_compare` quantities.
|
||
|
||
### ▶ S43-7 — `func_8017EF68` CRACKED (the 2-of-969 wedge); R22 CONFIRMS ALL FIVE BANKS 140/140 (2026-08-05)
|
||
The second Fable5 agent matched the function whose draft had been sitting one working permuter run
|
||
from a bank — **MATCH 969/969**, re-verified by me, then gated: `ov_SC06_000` byte-identical at
|
||
`da4a26ffffe8759929aa078aac7285738089a1f2`.
|
||
|
||
**The mechanism is a machine-model constraint, not a tie** (read from cc1's own `-dR` trace): the r3000
|
||
description gives the memory unit load-ready-cost 2 and store 1, so **`blockage(load,store) = 2` — a
|
||
load can never be picked in the tick immediately after a store pick.** sched2 therefore ALWAYS wedges
|
||
one ready ALU insn between the `lw` and the `sh`, and the target's zero-wedge order is **unreachable by
|
||
any statement order**. That is why ~20 documented hand variants AND the repaired permuter both floored
|
||
at exactly 2. The draft's own §49 "sched1 LUID/sink" story was incomplete — real but secondary.
|
||
|
||
**The lever (→ cookbook §151, "the ghost wedge"):** a zero-emission tied in/out asm
|
||
`__asm__("" : "=r"(v) : "0"(v), "r"(rival));` — same-reg, empty template, **0 bytes**, but a
|
||
schedulable insn that absorbs the blocked tick; it also sets `reg_n_sets(v)=2`, killing sched1's
|
||
birthing boost, so one instrument acts on both passes. Two measured fallouts closed it: read the rival
|
||
in the same asm (density flip, 22→12), then a second re-tie on a **high-ref host** to restore
|
||
**allocno live-length parity** (each in-loop insn is +1 live length for every loop-spanning allocno,
|
||
and a trio of invariant addresses sat exactly on `allocno_compare`'s integer-floor boundary). Host
|
||
choice is empirical: `pkt` ⇒ MATCH, `ot` ⇒ 705 off, doubling the first host ⇒ 10 off.
|
||
|
||
## ✅ R22 CLEAN-FLEET — **140 passed, 0 failed of 140**
|
||
`make clean && make extract-all && make check-all` from a genuinely clean tree. **This discharges the
|
||
`[R22 PENDING]` caveat on commit `commit:1484`** — all five of today's banks are confirmed, not
|
||
incremental-build artifacts (§130).
|
||
|
||
### FLEET AFTER S43
|
||
**96.63% fn-count · 94.9% instr-weighted (12,489,130 / 13,160,961) · 89.2% distinct-code
|
||
(78,084 / 87,459 uniq)** · 0 NON_MATCHING in any default build (G4) · dedup 1919 groups.
|
||
Session delta: **+4,757 instructions** banked (12,484,373 → 12,489,130), all from 2 cracks ×5 binaries.
|
||
**Distance to P30's 95% instr milestone bar: 13,782 instructions** (was 18,539 at session start).
|
||
|
||
### ▶ S43-8 — the 0xECC family: ONE crack = 12 overlays / 11,364 ins; and SIZE is the family key (2026-08-05)
|
||
Three isolated cheap-Opus agents, briefed with §150/§151 and told to open with the all-drafts scan,
|
||
**converged independently on the same discovery**: `func_8017C6F4` is not one function. The same 947-ins
|
||
body (`0xECC`) appears in **12 overlays under 5 DIFFERENT NAMES at 6 DIFFERENT ADDRESSES**, each
|
||
differing by exactly **two per-overlay symbols** (a screen-rect helper + the 64×64 cell table).
|
||
|
||
| overlay | fn | overlay | fn |
|
||
|---|---|---|---|
|
||
| ov_SC01_077 | func_8017C974 | ov_SC03_007 | func_8017C59C |
|
||
| ov_SC01_080 | func_8017C59C | ov_SC03_012 | func_8017C59C |
|
||
| ov_SC02_000 | func_8017D538 | ov_SC03_023 | func_8017C59C |
|
||
| ov_SC02_003 | func_8017D538 | ov_SC03_028 | func_8017DF98 |
|
||
| ov_SC02_004 | func_8017C59C | ov_SC03_030 | func_8017C974 |
|
||
| ov_SC02_005 | func_8017CF90 | ov_SC07_010 | func_8017C59C |
|
||
|
||
**GATED 12/12 whole-binary, 0 failed** — and each built image independently re-checked against its own
|
||
`config/check.<bin>.sha` (12/12), stubs confirmed replaced by real definitions. **11,364 instructions
|
||
from this morning's single crack.** *(A cosmetic artifact: my gate log printed one `final SHA` for both
|
||
SC02_000 and SC02_003, whose locked SHAs differ; the independent per-binary check shows each matching
|
||
its own target. R22 is the arbiter.)*
|
||
|
||
**⚠️ WHY IT HID FOR 30 PHASES — and the new family key (→ cookbook §152):** name-keyed grouping
|
||
scattered these across five names, and **h_seq grouping scattered them too**. The key that finds them
|
||
in one command is **BYTE SIZE**: `grep -rl 'nonmatching .*, 0xECC' asm/*/nonmatchings/*/` returns
|
||
exactly the 12 with no false positives. Size is an allocator-independent, cache-independent family key
|
||
that reads the asm rather than a manifest. **This refines the Phase-26 "h_seq is spent" finding: h_seq
|
||
is still worth exactly ONE size-keyed sweep behind each FRESH core crack — here it paid 11:1.**
|
||
|
||
**Two agent-supplied cautions, both verified and both worth keeping:**
|
||
1. **A masked tool cannot validate a remap.** `match_one` and `rtu_match` both mask `jal` targets and
|
||
`%hi/%lo` immediates — precisely the fields a remap edits — so a WRONG symbol map still reports
|
||
MATCH. One agent re-checked all 12 against the raw unmasked call-site pattern before claiming them.
|
||
**Remaps are gated by the whole-binary SHA, never by a per-function tool.**
|
||
2. **A stale residual is not evidence that two functions differ.** I briefed one agent that
|
||
`func_8017C59C` was a different body because an old draft scored 340 against it. Refuted: that 340
|
||
came from a PRE-§150-fix draft, and a wrong draft scores nonzero against every family member
|
||
*including its own target*. Re-measure with the CURRENTLY BANKED draft before accepting a
|
||
"different body" verdict.
|
||
|
||
**Tool defect found (R32 class, not yet fixed):** `family_remap.py`'s raw output does not compile —
|
||
its unit backscan accepts only blank/`extern`/comment/`typedef` lines, so it **halts at the first
|
||
`#define`** and never chains back past it. Measured: **16/16 gte macros carried, 0/10 typedefs carried,
|
||
silently.** This is the same §146 gap seen from the other side, and it is why the sibling gates needed
|
||
typedefs prepended by hand. Fix: let the backscan skip `#define` continuation blocks, or floor it at
|
||
the macro-carry's own start line.
|
||
|
||
### ⚠️ S43-9 — MY ERROR, RETRACTED: I measured the STUB BASELINE and called it a bank
|
||
I reported the 263×5 cluster (`0x80182fd4`, 5 members, cross-address) as "all five byte-identical,
|
||
1,315 ins". **FALSE — nothing was banked.** `family_sweep --stage-only` staged the drafts, but they were
|
||
reverted before my hand-built `make build`, so every SHA I compared was the **`INCLUDE_ASM` stub
|
||
baseline** — which is byte-identical *by construction*, because INCLUDE_ASM pastes the original asm.
|
||
**This is R34's trap exactly** (the byte-gate is a perfect CORRECTNESS oracle and a NULL COVERAGE
|
||
oracle — green since Phase 5 at 0% decomp), self-inflicted by hand-building instead of using
|
||
`harvest_verify`, which splices/builds/reverts atomically and reports verified-vs-failed.
|
||
**The lesson, now paid for twice in one session:** *never hand-build to test a draft; the gate's
|
||
verified/failed count is the only reading that distinguishes "matched" from "the stub is still there".*
|
||
The cluster returns to UNRESOLVED. Its real finding stands and is separate: the staged draft compiles
|
||
clean, so the `0/5 parse error before 'unsigned'` came from a **gate-pipeline transform**, not the
|
||
remap — worth pinning, since it may be silently killing other sweeps.
|
||
*(Also corrected: my "41 behemoth drafts" was a FILE count — 79 unblocked files resolve to 20 distinct
|
||
functions, 36 of them fragments of one small function.)*
|
||
|
||
### ▶ S43-11 — the 263×5 cluster BANKED 5/5: the sweep's own pipeline was corrupting byte-correct drafts (2026-08-05)
|
||
Redo of S43-9's retracted claim, done correctly through `harvest_verify` (splice → build → keep iff
|
||
byte-identical → revert), not by hand-building. **5/5 banked, 1,315 instructions**, each independently
|
||
re-verified three ways: image SHA == locked SHA, stub gone, real definition present.
|
||
|
||
| binary | fn | binary | fn |
|
||
|---|---|---|---|
|
||
| ov_SC03_101 | func_801814F8 | ov_SC04_005 | func_80181054 |
|
||
| ov_SC03_104 | func_80184934 | ov_SC04_007 | func_8017FF08 |
|
||
| ov_SC04_003 | func_8017E4F4 | | |
|
||
|
||
**THE DEFECT, PINNED — and my first hypothesis was WRONG (R14, corrected in place).** I wrote that a
|
||
gate-pipeline transform was eating a `/*` opener and turning comment prose into code, because the only
|
||
`unsigned` in the draft sits inside a comment. **Refuted by test:** every ladder step —
|
||
`cast_call_sites`, `sig_unify`, `reconcile_tu`, each run with the gate's real `--src-file` — preserves
|
||
the comment intact.
|
||
|
||
**The real cause is the `family_remap` TYPEDEF-CARRY GAP (§146/§152), full stop.** The staged draft
|
||
fails as `` `Vec8_80182FD4' undeclared (first use this function) `` — the type the body needs was never
|
||
carried, because `family_remap`'s unit backscan halts at the first `#define`. `parse error before
|
||
'unsigned'` was simply that failure surfacing at the next recognizable token, the following
|
||
`extern unsigned char …` line. **A misleading label, not a second defect.**
|
||
|
||
**Why direct gating banked all 5 anyway:** the TARGET TUs already declare that type at file scope, so
|
||
the splice compiles even though the draft fails in isolation. **That is the rule worth keeping — the
|
||
typedef gap is fatal only when the target TU does not already declare the type**, which is exactly why
|
||
this family looked like an intractable "parse error" wall in the sweep and banked instantly when gated
|
||
directly. Fixing `family_remap`'s backscan (let it skip `#define` continuation blocks) closes the whole
|
||
class; until then, gate remapped drafts DIRECTLY rather than through `family_sweep`'s ladder.
|
||
|
||
**The workaround that banked them:** carry the exemplar's typedefs onto each remapped draft by hand
|
||
(the same `family_remap` `_carry_macros` gap as §146/§152) and gate directly, bypassing the sweep's
|
||
recovery ladder entirely. Drafts + gate logs: `.run/s43/cluster_gate/`.
|
||
|
||
### ▶ S11 — the propagation lag: EXTEND 0/36 -> 31/36, and every blocker was a DECLARATION (2026-08-03/04)
|
||
Lane 2 of the S10 checkpoint ("26,006 ins, ~0 agent tokens, PARTLY BLOCKED"), taken first on the
|
||
standing doctrine that the cheap deterministic lever is probed before the expensive agent one.
|
||
|
||
**EXTEND shape — 31 of 36 banked (was 0).** Every failure was captured from the compiler's own
|
||
output (§136a) rather than guessed, and the 9-per-binary failure set reduced to **4 distinct
|
||
symbols repeated across all four SC07 binaries** plus the 4 "DIFF"s:
|
||
- **`func_80146C3C` (8 of 36) — one token.** Two macros declared it `(void)`; the SC07 TUs declare
|
||
`(u8 *a0)`. Both macros already CAST at the call site, so the prototype is codegen-irrelevant ->
|
||
relaxed to `()`. Measured BEFORE editing: all 4,020 fleet decls are `(void)/()/(u8*)/(u8 *a0)` —
|
||
**no default-promotion param anywhere**, so gcc-2.7.2's `()` dead-end (which needs a promoting
|
||
param) cannot bite. T2 but 2 lines.
|
||
- **`func_8014F4C0` (self-axis, 4), `D_80126CC4` (3), `func_8012E5CC` (1) — T1, binary-local.**
|
||
Conformed the SC07 decls to the fleet-canonical form. Each has **zero uncast uses** in its TU
|
||
(verified per file), so they were splat boilerplate with no codegen effect.
|
||
- One conflict **hid another**: fixing `func_8012E5CC` revealed `func_80147364` behind it — the S29
|
||
law that a declaration conflict ABORTS the compile, so one error says nothing about the next.
|
||
|
||
**The 4 "DIFF"s are a `volatile` declaration, not a codegen wall.** `dedup_extend`'s own header
|
||
records them as UNDIAGNOSED while its correctness argument says an h_exact match makes a DIFF
|
||
impossible. Both halves resolved against the bytes:
|
||
1. The contract HOLDS — `func_80162FF4`'s original bytes are sha1-identical in ov_SC07_006 and
|
||
ov_SC01_000 (`af1aceb2…`).
|
||
2. The cause is TU CONTEXT — the SC07 host TU (`_jr_8015C32C.c:1177`) declares
|
||
`extern volatile s32 D_80127090/94/98` at FILE scope; **none of the 134 working overlays' copy of
|
||
that TU does**. Volatile makes the macro's three stores a scheduling barrier, so
|
||
`addu $a0,$s2,$zero` cannot sink into the `jal func_80146D30` delay slot — the built body emits
|
||
it early plus a `nop`, one instruction longer. Measured word-for-word:
|
||
built `+0x090 addu / lui,sw x3 / jal / NOP` vs ref `+0x090 lui,sw x3 / jal / addu-in-delay-slot`.
|
||
All 4 macros touch exactly those 3 symbols, which is why all 4 fail in all 4 binaries and nowhere
|
||
else. **Fix: the §37/§124 DATA asm-label alias** inside the 4 macros — a distinct C identifier is
|
||
immune to any TU's declaration and byte-neutral in the other 134. **16/16 banked on the retry.**
|
||
|
||
**Still open in this lane (both NAMED, neither a wall):** `func_80144B9C` x4 — the whale's registry
|
||
`func` field is a bare name, not a `DEFINE_` macro, so `write_drafts` emits a CALL (hence
|
||
"undefined reference" in ov_SC07_010); it needs the §38 `-O0` shared-header route, and
|
||
`dedup_extend` should refuse-and-name the class per R32. And `func_80149954` x1, blocked behind
|
||
`func_80147364`'s u16 params.
|
||
|
||
**`func_8012A598` banked x138 (3,288 ins) — and it took TWO fixes, either alone insufficient.**
|
||
The tool skipped it as `missing file-scope extern (CARRY-FIXABLE): D_801151D4, D_80126DB8_a,
|
||
D_80127504`.
|
||
1. **TOOL (R33):** `find_site`'s preamble backscan had the SESSION-18 fix for blank / `//` /
|
||
SINGLE-LINE `/* … */` lines, but a **MULTI-LINE block comment** still halted it — its middle
|
||
lines start with `*` and its last line ends `*/` without starting `/*`. The §134
|
||
multi-line-blindness class, which S6b already fixed three times in `family_remap`. Replaced the
|
||
line-syntax test with a decision on **`cdecl._mask`** (the project's ONE masking oracle) — it
|
||
subsumes every comment form and cannot be fooled by a `/*` inside a string — plus an R32
|
||
assertion on the length-preservation invariant it rests on. Strictly monotone: it can only carry
|
||
MORE preamble, and dedup_propagate is a byte-gate feeder (a bug here can fail to bank, never
|
||
falsely bank).
|
||
2. **EXEMPLAR:** the body also declared a draft-local `struct BigCopy164` tag, which the tool
|
||
refuses by design (two macros defining one tag redefine it in a TU). The shared
|
||
`struct BigCopy` (engine_types.h L312) is the identical layout and is **already used this exact
|
||
way at engine_core.h:16158**, so switching the exemplar to it is byte-neutral. Probed on ONE
|
||
member first: byte-identical `9052dc0e…`; then **138 overlays byte-identical**.
|
||
|
||
**PROPAGATE shape — the head is 5 classes, not 45.** `.run/s8_lag.json` re-split: EXTEND 13 classes
|
||
/ 45 stubs / 5,145 ins; PROPAGATE 46 / 783 / 20,861 — but **5 classes carry 18,545 ins (89%)** and
|
||
the other 41 carry 2,316. Ranked: `func_80147364` 30x137=4,110 · `func_8012f274` 29x137=3,973 ·
|
||
`func_8016ba68` 29x134=3,886 · `func_8012a598` 24x137=3,288 · `func_801466f0` 24x137=3,288.
|
||
|
||
**`func_80147364` banked x137 (4,110 ins) via the DEFINITION-SIDE asm-label alias.** Its byte-true
|
||
definition is `(u16, u16)` while the fleet declares it `(u16, s32)` in 4,046 places — u16 is a
|
||
default-promotion type, so the `()` escape is ILLEGAL and a decl conform would change caller
|
||
codegen. The alias gives the definition a distinct C identifier while emitting the real symbol:
|
||
zero blast radius on every caller. **Probed on ONE member first (1 build, not 137 — the S29
|
||
discipline): byte-identical `9052dc0e…` first try**, then the full run: 137 overlays byte-identical.
|
||
In-tree precedent for the form: 1,725 files already use it.
|
||
|
||
**Named + sized, not yet banked:** `0x8012a598` skipped `missing file-scope extern (CARRY-FIXABLE):
|
||
D_801151D4, D_80126DB8_a, D_80127504`. `0x801466F0` reports "no source overlay has it matched" —
|
||
the S6b **D4** case, still unfixed: its def in `ov_SC01_077_after.c:495` carries a **wrapped**
|
||
`__asm__` alias decl and `_alias_decl_for` is a single-line `rx.match` (the §134 multi-line-blindness
|
||
class), plus a file-scope `typedef struct Rec801466F0` that a macro body cannot travel with (§100).
|
||
|
||
**My process errors this block, recorded:** (1) I wrapped the first R22 in `nohup … &` inside a
|
||
backgrounded call, so the harness signalled completion of the WRAPPER while the fleet check stood at
|
||
**63/140** — I nearly read that as a pass. Wait on `pgrep -x make`, never on a wrapper's exit.
|
||
(2) I ran a `corpus.stubs` probe while `make extract-all` was mid-flight and got garbage; R32's
|
||
coverage assertion refused to answer instead of returning a wrong stub set. *A measurement taken
|
||
during a rebuild is not a measurement* — S27's law, re-earned.
|
||
(3) **CORRECTION to the S10 checkpoint's own waiter rule.** It says "use `pgrep -x make` (exact
|
||
process name)". That is right for a single `make`, and **wrong for a CAMPAIGN**: `dedup_propagate`
|
||
runs a SEQUENCE of `make build BINARY=<ov>` calls, so between any two there is a window with no
|
||
`make` process — my waiter fired in one and reported "done" on a live campaign whose log had one
|
||
line. This is the identical structure `tools/treelock.sh`'s own docstring warns about ("guard the
|
||
CAMPAIGN, not the process"; a `pgrep` poll is a sampling test on a gappy signal). **Wait on the
|
||
campaign itself — `pgrep -f dedup_propagate` / `family_sweep` — or on `tools/treelock.sh --status`,
|
||
which is a statement of intent that spans the gaps.** Three waiter failures now share one mechanism:
|
||
the signal being sampled is not the thing being waited for.
|
||
|
||
|
||
### ▶ S6a — the source-agnostic zero-crack sweep: 842 banked, and the residue is OUR TOOLING again (2026-08-01)
|
||
**Setup, measured before running anything (R37 — probe before costing).** The 190 zero-crack families
|
||
(129,997 templatable ins) were decomposed with **zero builds** by remapping each family's exemplar onto one
|
||
member and type-checking the resulting draft statically:
|
||
· **117 families / 92,368 ins / 2,735 member-slots** — draft self-contained ⇒ sweepable now.
|
||
· **17 / 24,332 ins** — the §94/§100 class: the body uses a **file-scope MULTI-LINE typedef**, which
|
||
`extract_unit` cannot carry (it carries single-line ones only). Head prizes `0x8012b77c` (ov_SC07_006,
|
||
139 members, `Ang2_8012B77C`) and `0x80128c98` (ov_SC01_077_a, **275 members**, `CdFileLoc`) = 14,937 ins.
|
||
· **9 / 9,364 ins** — `has_mid_jr` ⇒ the §53 carve path, not this sweep.
|
||
· **47 / 3,933 ins** — `remap_hseq` REFUSES (mostly unresolved immediates). Genuine, small.
|
||
|
||
**⚠ PREMISE CORRECTION (R14) — the checkpoint's stated mechanism was wrong.** The post-wave frontier says
|
||
these families were unreachable because "every sweep this project has run passed `--source ov_SC01_077`".
|
||
It is not the mechanism: `--source ov_SC01_077` is the **default**, and `hseq_sweep`'s override block only
|
||
fires when `source != EX_OV`, so the manifest's own non-ov077 exemplar was already being used. The real gate
|
||
is **`--band substantial`** (the default): of the 181 non-jr zero-crack families only **13 are substantial**
|
||
— 114 `mid`, 54 `tiny`. **`--band all` is the unlock**, exactly as the S1 trap note warned. (The 106
|
||
non-ov077 exemplars are real and interesting; they were not what blocked the sweep.)
|
||
|
||
**Result:** `family_sweep --hseq --band all -j12 --only <117 addrs>` staged **2,735 drafts / 1,239 groups,
|
||
0 skips** → **BANKED 842 / 1,893 failed**. **R22 clean-fleet `make clean` + extract-all + check-all → 140
|
||
passed, 0 failed of 140.** Fleet **94.43→94.67% fn-count · 91.4→91.6% instr · 84.0→84.5% distinct**.
|
||
|
||
**The residue is bimodal, and that is the finding: 57 families banked ALL members, 52 banked ZERO, 8
|
||
partial.** A per-member compiler wall does not produce that shape; one per-family blocker does. Eight
|
||
zero-banked families were probed with a new generic blocker-capture (`.run/s6_diag.py` — the any-overlay
|
||
sibling of S29's ov077-only `.run/uc_capture.py`: remap → splice → build THAT overlay → read the compiler's
|
||
own error → revert; **one build per family, not 137**). **Seven of eight are declaration/carry plumbing;
|
||
one is a genuine byte DIFF.** Two are proven defects in `tools/family_remap.py`, both located at source:
|
||
- **D1 — the preamble backscan's `{`-guard does not exempt comment lines.** The guard is a real T65 fix
|
||
(`extern void f(int); int g(){…}` on one line), but it fires on any *documentation* line that merely
|
||
mentions a brace, so the carry stops mid-comment and the sibling receives a dangling ` * …` fragment →
|
||
`parse error before 'the'` (`0x80176144`, `0x80146afc`).
|
||
- **D2 — `_def_head_at` returns `True` on "param list continues past this line ⇒ ANSI definition".** False
|
||
for a **wrapped multi-line DECLARATION** (`extern void func_801466F0(s32 a0, …,\n s32 sp8);`), so
|
||
`extract_unit` accepts line 457 of `ov_SC01_077_after.c` as a definition head and returns a **16-line
|
||
fragment that contains no function body at all** (`DEFINE_func_801466B4()` + `#include "common.h"` + a
|
||
comment), terminated by a brace pair *inside* that comment. Verified directly:
|
||
`_def_head_at('extern void func_801466F0(s32 a0, s32 a1, s32 a2, s32 a3,', idx) -> True`.
|
||
This is the §110/R35 class again — a silent 0/137 wearing a compiler wall's clothes.
|
||
|
||
**S6b — the fix belongs in the TOOL, not in 17 exemplars (R33).** The plan was to hand-move each
|
||
MISSING-TYPE exemplar's typedef into its function body (§100, byte-neutral, 17 edits + 17 verifications).
|
||
Probing the class first showed it is the SAME root cause as D1/D2 — a multi-line construct read one line
|
||
at a time — so it was fixed once, in `family_remap`, for every future family instead:
|
||
- **D5 — `_typedef_block_start()`**: on a `} T;` closing line, walk up to the matching `typedef` (both
|
||
the `typedef struct {` and brace-on-its-own-line forms) and carry the WHOLE block. Only blocks that
|
||
literally begin with `typedef` are carried (a struct VARIABLE closes identically but would be a
|
||
duplicate global in the sibling); safe because `harvest_verify` already strips a typedef the sibling
|
||
TU provides. The old code comment claimed these functions "route through the engine_types.h lift" —
|
||
measured, they routed **nowhere**: 17 families / 24,332 ins were simply dropped.
|
||
- **D4 — the wrapped asm-label alias** (`_alias_decl_for` is a single-line `rx.match`) was MEASURED
|
||
(1 exemplar, `0x801466f0`, 137 members / 3,288 ins, with a second blocker behind it) and deliberately
|
||
**left unfixed**. It now returns `None`, so the sweep reports `skipped {'no matched unit for func'}`
|
||
instead of failing 137 times. **A known gap that announces itself is not the same defect as a silent
|
||
one** (R32).
|
||
- Also hardened: the forward body scan now counts braces in `cdecl._mask`ed text (R33 — one masking
|
||
oracle), so a brace inside a comment or string can never close a function body.
|
||
|
||
**Blast radius verified, not assumed (R14):** `extract_unit` output diffed against the pre-S6 tool over
|
||
all 181 zero-crack exemplars — **157 byte-IDENTICAL**, 24 changed, every change in the intended
|
||
direction (more preamble carried; one → `None`, the D4 case that previously produced garbage).
|
||
|
||
**Measured payoff of the repairs, one sweep each:**
|
||
· D1+D2 → **+323 members** recovered from families that had banked **zero**.
|
||
· D5 → **+417 members**, including `func_8012B77C` **139/139** (8,062 ins — the head prize) and
|
||
`func_80128C98` 137/275; `func_80146AFC` 135/137, `func_80176144` 99/137.
|
||
· **S6 total: 1,582 member-matches.** The pre-fix tool scored this same population at 842.
|
||
**R22 clean-fleet `make clean` + extract-all + check-all → 140 passed, 0 failed of 140.**
|
||
Fleet **94.43→94.88% fn-count · 91.4→91.9% instr · 84.0→84.6% distinct**; phase arc from open
|
||
(92.00 / 87.5 / 78.0) = **+2.88pp fn · +4.4pp instr · +6.6pp distinct**.
|
||
|
||
**Family state now: 70 ALL-banked · 17 partial · 94 zero-banked; 64,050 templatable ins still open.**
|
||
Distilled to **cookbook §134** (the MULTI-LINE BLINDNESS class + the bimodality tell: 57/52/8 is a
|
||
tooling signature, not a codegen one — read ONE compiler error before believing the compiler).
|
||
|
||
### ✅ S6h — wave 3 (38 targets, size-routed) + an 8/8 reconcile lane (2026-08-01)
|
||
38 targets / 44,297 templatable ins — the 11 high-multiplier families at 61-120 ins plus the top 26 of
|
||
the 10-19-member band, model-routed (Haiku ≤89 with Opus escalation, **Opus direct ≥90**).
|
||
**52 agents, ~4.1M tokens, 30 min → gate banked 27/38 (71%).** All 11 failures were captured and
|
||
classified: **8 declaration/link plumbing · 3 genuine byte-DIFF**. An 8-agent Opus reconcile wave then
|
||
fixed **8/8** (7 banked; 1 re-failed) → **wave-3 total 34/38 = 89%**, propagation **+639 members /
|
||
1 failed / 83 overlays**. **R22 clean-fleet 140/140.** Fleet **95.23 → 95.42% fn · 92.1 → 92.4% instr ·
|
||
85.0 → 85.5% distinct**.
|
||
|
||
**The reconcile lane is now 12/12 across two waves** and is the most reliable stage in the pipeline.
|
||
**Design note (S27 law, applied BEFORE it bit):** six of the eight reconcile targets share ONE TU, so
|
||
this wave **forbade agents any build** — six concurrent splice-builds would have clobbered a tracked
|
||
file. Wave 2's reconciles were allowed one build each because they were spread across TUs.
|
||
|
||
**The agents out-diagnosed the blockers I handed them — three findings worth keeping:**
|
||
· **`func_801848B0`: an agent REJECTED MY PREMISE.** I told it the draft was byte-correct and only
|
||
declaration-blocked; it ran `match_one` first, found a real 1-instruction DIFF, and fixed both.
|
||
R14 coming back at me from a subagent, correctly.
|
||
· **`func_8017C5F0`: the "invented symbol" was an INTERIOR ADDRESS.** `D_801DA0F0` has no symbol
|
||
because it is offset `0x6C` into `D_801DA084` (which spans `0x801DA084..0x801DA103`,
|
||
`asm/ov_SC02_027/data/tail18.data.s`). The lui/addiu pair builds an interior pointer — a class the
|
||
drafters will hit again.
|
||
· **`func_8018A860`: the TU declares `memcpy` THREE times** with incompatible signatures (L81, L1518
|
||
builtin-compatible, L1524), and a latent byte bug sat behind it. A TU that declares one symbol three
|
||
ways is a defect waiting for the next draft that touches it.
|
||
|
||
**Carried (4):** `func_80184A94` (reconciled to `match_one` MATCH, still gate-refused) + the 3 genuine
|
||
byte-DIFFs `func_801845B0`, `func_8017BEBC`(ov_SC02_026), `func_8018480C` — real codegen residuals,
|
||
ledger material.
|
||
|
||
### ✅ S6g — wave 2: 83% → 93% bank rate from ONE batch of learning (2026-08-01)
|
||
15 targets (11 fresh Haiku + **4 gate-failed reconciles on Opus**), 15 agents, ~0.74M tokens.
|
||
**Gate banked 14/15 (93%)** — up from wave 1's 20/24 (83%) — **and all 4 reconciles banked**.
|
||
Propagation **+328 members / 0 failed / 76 overlays**. **R22 clean-fleet 140/140.** Fleet
|
||
**95.13 → 95.23% fn · 92.0 → 92.1% instr · 84.9 → 85.0% distinct**.
|
||
|
||
**Three changes between the waves, each fixing a wave-1 failure — this is the S27 finding reproducing
|
||
(57→79→100% there, 83→93% here):**
|
||
1. **Args pasted from the DERIVED manifest, not typed.** All 30 paths verified present on disk before
|
||
launch (`asm 15/15, tu 15/15`).
|
||
2. **Blocker-capture before the reconcile fan-out** (the S29 law: agents cannot run the gate, so a
|
||
`match_one`-MATCH draft that dies on `conflicting types for D_800A5E88` looks like a codegen
|
||
problem to them). Each reconcile agent got the exact symbol + line, plus the two byte-neutral
|
||
levers (conform-and-cast-at-use; the §37/§124 asm-label alias).
|
||
3. **Wave-1's Opus DISCOVERIES became wave-2's Haiku INSTRUCTIONS** (the `ori`-vs-`addiu` unsigned
|
||
destination rule; the store-sinking scheduler rule). The flywheel closing on itself.
|
||
|
||
**The reconciles produced better root causes than my captured blocker did** — worth keeping:
|
||
· `func_80189B78`: my capture named ONE conflicting symbol; the agent found the draft had invented
|
||
prototypes for **six** the TU already declares, **two of them AFTER the splice point** where cc1
|
||
had not yet reached. Fixed by copying all six from the TU verbatim and pushing every type
|
||
disagreement to a **cast at the call site** — zero bytes changed.
|
||
· `func_8018584C`: lever (A) was *blocked in both directions* — the draft cannot use the TU's tag
|
||
(it must also compile standalone for `match_one`) and cannot redefine it. Closed with the **data**
|
||
form of the asm-label alias: `extern struct B16_8018584C aD800A5E88 __asm__("D_800A5E88");`
|
||
(in-tree precedent at ov_SC06_008_jr_80135D20.c:1434).
|
||
· `func_80180A4C`: the draft declared `extern s32 D_801A9DA0[]`, the TU says `extern u8 D_801A9DA0[]`
|
||
eleven lines *after* the splice point — conform to `u8`, the use site already casts. One character
|
||
class, byte-neutral.
|
||
|
||
### ✅ S6f — the B-shaped wave: Haiku drafts, Opus closes, the gate arbitrates (2026-08-01)
|
||
**The pool.** Derived from the regenerated map: **36 families / 28,829 templatable ins** that are
|
||
`kind=modal` (no member matched ANYWHERE, so no sweep could reach them), ≥20 members, ≤60 ins, non-jr,
|
||
and **not one exemplar in `ov_SC01_077`**. Calibrated by hand first (Phase-15/18 discipline): **3/3
|
||
one-shot** — `func_8017CDD8` (17 ins ×142), `func_8017CE7C` (16 ins ×126), `func_8017E934` (29 ins ×65)
|
||
= **330 members from 62 instructions of C, ~0 agent tokens.**
|
||
|
||
**The wave (Drew enabled Ultracode; Haiku drafters + Opus escalation, 24 targets).** Haiku was the
|
||
right tier by the `cheap-tier-ab-validated` measurement (≡ Opus at ≤~50 ins, ~4.8× cheaper); this pool
|
||
is 16-53 ins. **31 agents, 0 errors, ~2.0M tokens, 12.5 min.**
|
||
· agents claimed **24/24 MATCH** · whole-binary gate banked **20/24 (83%)** · propagation
|
||
**+524 members / 0 failed / 91 overlays**. **17 of the 20 banks were Haiku, 3 Opus.**
|
||
**R22 clean-fleet 140/140.** Fleet **94.97 → 95.13% fn · 91.9 → 92.0% instr · 84.7 → 84.9% distinct**.
|
||
|
||
**What Opus actually bought** (it earned its slot on exactly the cases the A/B predicted):
|
||
· a `sh` of a constant whose stored-width top bit is set needs a **u16 destination** — through `s16`
|
||
gcc-2.7.2 folds it sign-extended and `li` emits `addiu`; through `u16`, `force_fit_type` keeps it
|
||
positive and `li` emits `ori` (`func_8018A0F4`).
|
||
· a **schedule-reorder closed by STATEMENT ORDER, not the permuter**: gcc's list scheduler preserves
|
||
relative order of disambiguable stores, so two field-zero stores had to be written ABOVE a
|
||
three-halfword copy to sink correctly — 9 mismatches → 0 (`func_8017CAB4`).
|
||
· three separate **loose-typing fn-ptr casts** (`((void(*)(s32))func_80178D18)(a0)`) where the TU
|
||
declares `(void)` but the asm passes `$a0` — a cheap drafter had misread all three as delay-slot /
|
||
permuter-class residuals (`func_8017EAAC`, `func_8017CBD4`, `func_8017D5C4`).
|
||
|
||
**⚠ MY ERROR, recorded (R37/R14).** I generated the wave manifest to `.run/s6f_wave_targets.json` and
|
||
then **hand-transcribed the args into the Workflow call instead of pasting the generated file**,
|
||
pattern-filling `_jr_8017BEBC` across overlays where no such split exists (`ov_SC02_027`,
|
||
`ov_SC04_018`, `ov_SC03_002` — `corpus.stubs` says `_jr_8017AE2C`). Three agents lost time
|
||
rediscovering the real paths and reported SPEC ERRATA. Cost: tokens, not correctness. The gate driver
|
||
written afterwards (`.run/s6f_gate.py`) **derives** every TU/split from `corpus.stubs` per draft and
|
||
asserts nothing — which is what the manifest should have done. *Assert nothing you can derive.*
|
||
|
||
**The 24→20 gap is the known `match_one`→gate gap, not new:** `match_one` compiles standalone and
|
||
cannot see a TU-level declaration conflict (Phase-19 measured 88-92% match_one → 60-71% banking).
|
||
4 carried: `func_8018584C`, `func_80180A4C` (ov_SC02_026), `func_8017CC80` (ov_SC02_027),
|
||
`func_80189B78` (ov_SC03_014).
|
||
|
||
### ✅ A + B — the ×138 era was NOT over: two 16-ins cracks bought 266 members (2026-08-01)
|
||
**A (frontier regen at HEAD, R35).** Sigs + `family_hseq` regenerated after S6's banks — required before
|
||
pricing anything, and doubly so because `.run/hseq_verified.*.txt` has accumulated **22,841 files across
|
||
every sweep ever run**, so any per-family analysis that globs them over-counts. The regenerated map
|
||
derives state from sigs + `corpus.stubs` (R33), which is the authority. Overlay-only frontier at HEAD:
|
||
**95.2% fn / 92.3% instr / 85.5% distinct**; zero-crack residue **106 families / 58,657 ins** (was
|
||
181 / 120,633 at S6 open).
|
||
|
||
**B — and the finding that matters.** The S29 checkpoint's structural signal said *"after S2 the ×138 era
|
||
ENDS — those are the last two crackable fleet-wide families"*, and made that the trigger for T5/phase
|
||
close. **It is wrong, and this is the THIRD §133-class miss in a row.** Re-derived from the family map,
|
||
two fresh-crack families with ≥126 members were open the whole time:
|
||
· `0x8017cdd8` ov_SC02_039 — **17 ins × 142 members** = 2,414 templatable ins, PURE
|
||
· `0x8017ce7c` ov_SC03_114 — **16 ins × 126 members** = 2,016 templatable ins, IMM
|
||
Both are `kind=modal` — **no member matched anywhere**, so no sweep could reach them, and neither
|
||
exemplar is in `ov_SC01_077`. They are invisible to exactly the two habits this phase already corrected.
|
||
|
||
**Both hand-drafted off the `.s`, `match_one` MATCH on the FIRST try, ~0 agent tokens.** Then:
|
||
- **First gate attempt FAILED, class PLUMBING (not DIFF)** — my draft declared `extern void
|
||
func_8017CFCC(s32 a0);` while the TU **defines** `void func_8017CFCC(void)`. The target passes `$a0`
|
||
anyway (the caller's incoming argument simply still sits in the register — loose typing, §16), so the
|
||
byte-true C calls it with **no argument** and declares it exactly as the TU defines it. Re-verified
|
||
MATCH, then gated byte-identical in both overlays.
|
||
- **Propagated: 266 member-matches / 0 failed across 118 overlays** — from 33 instructions of C.
|
||
- **R14 on the seed:** the cached Ghidra-C for `func_8017CE7C` decompiled an entirely DIFFERENT body
|
||
(three calls that do not exist in the asm). Reading the `.s` is what made it one-shot; a drafter
|
||
trusting the seed would have burned the target and possibly ledgered it as hard.
|
||
|
||
### ✅ S6e — `--normalize-self-decls` measured to ZERO, but only after fixing the guard that made the measurement impossible (2026-08-01)
|
||
The S6a blocker probe found `conflicting types for func_X` on the SELF axis, which is exactly what
|
||
`family_sweep --normalize-self-decls` targets (drop the sibling's divergent decl of the function being
|
||
defined, cast its in-scope calls). It is OFF by default, so it was the obvious next zero-token lever.
|
||
|
||
**Run 1: 0 banked / 1,622 failed — and 909 of 909 groups reported `⚠ self-decl edit NON-NEUTRAL`.**
|
||
A 100% rate is a statement about the mechanism, not about 1,622 different functions (the §134 tell,
|
||
one day old). The three earlier sweeps over the SAME population reported **0** NON-NEUTRAL.
|
||
|
||
**The defect (D6, `family_sweep.hseq_sweep`):** the TU snapshot was taken **unconditionally**, one line
|
||
before the `if nfix:` that decides whether to edit at all — so a TU that NSD merely INSPECTED still
|
||
landed in `tu_snapshots`, and the phase-2 MISMATCH backstop then attributed ANY group failure to a
|
||
"self-decl edit" that was never made, reverting the TU and reporting `0/N banked`. Measured directly:
|
||
**NSD fires on ~25% of members (3 of 12 probed)**, so ~75% of those reverts were attributing a failure
|
||
to an edit that did not exist. The §103 tu-scope path immediately below has always snapshotted inside
|
||
its own `if _rep["moved"]:`; NSD was the odd one out. Fixed to match.
|
||
|
||
**Run 2 (fixed): NON-NEUTRAL 909 → 303** (~33%, consistent with the measured fire rate) — the fix is
|
||
confirmed — **and still 0 banked**. The 606 groups that now took the NORMAL path banked nothing, so
|
||
**the verdict is real: this residue is not self-decl-conflict-bound.** Lever measured, closed, zero.
|
||
|
||
**One open item, deliberately not chased (it is no longer decision-relevant).** I byte-measured a
|
||
firing case myself rather than trusting the backstop (R14): `func_80162CCC` in `ov_SC01_000` builds to
|
||
`9052dc0e…` **with and without** the NSD edit — i.e. **byte-NEUTRAL**, so the surviving 303 verdicts are
|
||
wrong too. Most likely the sweep applies NSD to several members of the SAME TU and the backstop
|
||
attributes an accumulated-state mismatch to "the edit". Left as a named open item because the lever
|
||
yields 0 either way; it would matter only if a future population makes NSD worth re-testing.
|
||
|
||
### ✅ S3 — the close=0 stored-draft DIAGNOSTIC pass: measured, classified, and correctly NOT scaled (2026-08-01)
|
||
Chartered as "classify, and only build a fix if ≥3 share a named class". Ran exactly that; the answer
|
||
is that no cheap shared class exists, so nothing was scaled. **The population is bigger than the plan
|
||
thought and worth less than it looks:**
|
||
- **30 ×138 family heads carry a stored draft = 182,850 templatable ins** (the plan said ~12 drafts).
|
||
- **Only 7 of 30 still verify** (`match_one` MATCH). **23 have DECAYED** — mostly `LENGTH-DRIFT`, a few
|
||
`SIZE-MISMATCH`/`WIDTH`/`ADDRESSING`. ⇒ **a stored draft's recorded closeness is not a current fact:
|
||
77% of this backlog no longer matches.** Re-verify before valuing a draft (extends A10/T1a).
|
||
- Of the 7 survivors: **1 banked clean** (`func_801754A8`, 37 ins ×138 = 5,106). The other 6 failed
|
||
`conflicting types` — and `gate_stage`'s ladder recovered **0/6**.
|
||
- Those 6 split into: **1 §30#2 return-widen** (`func_8014C4AC`) and **5 PARAMETER-signature
|
||
conflicts** (the Phase-16 def-side loose-typing wall, unchanged).
|
||
|
||
**The §30#2 attempt, and why it was reverted (R14 + the anti-bulk-header law).** `func_8014C4AC`'s
|
||
draft documents its own fix (`extern void`→`s32` in `engine_core.h`, measured byte-neutral there) —
|
||
but the note's claim that no split `.c` carries its own decl is **wrong**: the gate named
|
||
`_jr_80154C24.c`, then `_jr_80182268.c`. A `sed` over every matching decl touched **2,046 files** and
|
||
STILL did not go green. That is precisely the "bulk header edits BREAK builds" pattern (§29 doctrine:
|
||
call-site casts are the integration spine). **Reverted; exemplar re-verified `d19c9580`.** A fleet-wide
|
||
decl reconcile needs a gated TOOL, not a sed — logged, not attempted.
|
||
|
||
**Ledger:** 23 decayed drafts → redraft lanes (they are not "nearly done"); 5 param-conflict → the
|
||
def-side wall; 1 widen → needs the gated decl-reconcile tool. S3 is CLOSED as a measurement.
|
||
|
||
### ✅ S29 — `JR-PAIR-IN-ONE-O0-OBJECT` RETIRED: two instrument defects, both fixed; the pair banked (2026-07-31)
|
||
The S28 ledger class and its recorded escape (§81 step 1, isolate one fn into its own code subseg)
|
||
are **both refuted**. Neither function needed isolation; neither is on a compiler wall.
|
||
|
||
**Root cause 1 — `jtbl_carve` could not see a 4th table.** `ov_SC01_077_o0`'s carve at `0xb01a4`
|
||
predates the §8e `tables=` persistence and is a **merged double** (`func_8013C0F8` `$L75` +
|
||
`func_8013C414` `$L105`); the second owner is MATCHED, so `make extract` pruned the stub `.s` that
|
||
named its table. The tool's "single-table predecessor" inference therefore derived 3 starts where the
|
||
object emits **4 tables**, wrote `JTBL_PADS := 0,4,4`, and `jtbl_rodata_pads` refused mid-stream —
|
||
correctly, with the exact message.
|
||
**Root cause 2 — the refusal left a corpse.** `as` reads a pipeline, so it had already written a
|
||
TRUNCATED `.o` (12 of 16 `T func_`; undefined `$L57/$L59/$L63/$L75/$L76`). `make` reported Error 1 and
|
||
**left the object on disk, newer than its `.c`** — no `.DELETE_ON_ERROR`. The next build linked the
|
||
corpse: that IS S28's `undefined reference to $L105` + `func_8013C938`, one build downstream of a
|
||
loud, correct compile error.
|
||
|
||
**Fixes (both byte-gated).** (a) `Makefile`: **`.DELETE_ON_ERROR:`** — negative-control-proven
|
||
(`make: *** Deleting file …`), scratch invocation, tracked files untouched. (b)
|
||
`tools/jtbl_carve.py` `spec_from_starts`: a **R32 coverage assertion + payload recovery** at the
|
||
single choke point — every zero word inside a span is an original `.align 3` pad (the tool's own
|
||
axiom), so the word after it starts a table; recovered starts are logged. No-op where the structure is
|
||
already known (the 134 sibling `_o0c` spans DO carry `tables=+0x0,+0x70`), so committed-green spans are
|
||
untouched. Honest limit: only pad-separated boundaries are recoverable; a tight boundary still fails
|
||
LOUD (short spec → filter refusal), never silently.
|
||
|
||
**Byte proof.** 4 tables at `0x801D8254 / 0x801D828C / 0x801D82FC / 0x801D836C` (13/27/27/27 entries,
|
||
each preceded by a zero pad); span `0xb00fc..0xb0280` = 388 B = 52+4+108+4+108+4+108 — closes exactly;
|
||
derived spec `0,4,4,4 tables=+0x0,+0x38,+0xa8,+0x118`. **`func_8013B83C` (272 ins) + `func_8013BD74`
|
||
(198 ins) banked**, ov_SC01_077 `d19c9580`, **R22 clean-fleet 140/140** (`make clean` + extract-all +
|
||
check-all — the incremental result was NOT trusted, §130). Fleet **93.25% fn-count / 89.2% instr /
|
||
80.5% distinct**; dedup 1905/0; 0 NON_MATCHING. Cookbook **§132** (incl. the reusable ladder: compile
|
||
the ONE TU standalone and let `.section .rodata` + the nearest preceding `.ent` name every table owner
|
||
— it found the 4th owner and attributed `$L105` in one command, before any build or carve).
|
||
|
||
**Sweep prep — the §94/§100 type-carry class, caught by probing ONE sibling (R37).** The first
|
||
sibling gate-failed. The §132 ladder named it in one command: the sibling object emitted only
|
||
`func_8013C0F8` + `func_8013C414` tables — BD74's body never compiled (`E_13BD74' undeclared`).
|
||
Cause: BD74's draft declared `E_13BD74`/`P_13BD74` at **FILE scope**, and `extract_unit`/`remap_hseq`
|
||
carry only the BODY — the exact class that held `func_8013C08C` at 0/137 earlier this phase. Fix =
|
||
**§100 draft-local types** (moved both typedefs inside the function body; byte-neutral, exemplar
|
||
re-gated `d19c9580`). B83C's draft was already draft-local, hence unaffected. *A file-scope type in a
|
||
draft is an exemplar-only bank: it passes the gate and silently cannot travel.*
|
||
|
||
**THE SWEEP — 137/137 both, i.e. 2 × 138 = 276 function-instances banked.** `jtbl_family_bank`,
|
||
BD74 first then B83C (order is load-bearing: B83C's table sits BELOW BD74's, so carving it while
|
||
BD74 is still raw leaves an unmatched table inside the span — `NON-CONTIGUOUS`, byte-observed on the
|
||
exemplar). ~8.5 s/sibling, zero-token. Both sweeps failed on the SAME single overlay, `ov_SC07_010`
|
||
— **which is a property of that sibling, not noise, so I probed it instead of ledgering it** and it
|
||
returned 2 banks plus a real tool defect (**§132a**): `jtbl_carve --like` matches donor→recipient by
|
||
the subseg's ROLE NAME; `ov_SC07_010`'s `-O0` region is named `_o0`, the same role as the exemplar's
|
||
and the ONLY other overlay so named (the other 136 are `_o0c`, whose role never matched — **the only
|
||
reason the sweep worked at all**). The exemplar had just banked 2 more owners than the sibling has,
|
||
so the transfer derived SIX starts for THREE emitted tables. Guard shipped
|
||
(`jtbl_family_bank.like_arg`: a sibling's own committed `tables=` is authoritative; `--like` is for a
|
||
span with NO record — inert for all 136 already-banked siblings, fixes exactly the broken one).
|
||
|
||
**Fleet after the sweep (R22 clean-fleet 140/140, `make clean` + extract-all + check-all):**
|
||
**93.33% fn-count · 89.6% instr-weighted · 81.6% distinct-code** (72,416 unique fns, **+260**);
|
||
dedup 1905/0; 0 NON_MATCHING. Phase arc so far: 92.00→93.33 fn / 87.5→89.6 instr / 78.0→81.6 distinct.
|
||
That `-O0` cluster is now COMPLETE across the fleet — the two functions were the last open stubs in
|
||
every overlay's `_o0*` region.
|
||
|
||
### ✅ T0.5 COMPLETE — the fleet Ghidra-C prefetch: 124/124 programs, 7,716 files, 335 min, unattended
|
||
Zero-token, headless, resumable; imported ~120 overlay programs on demand and ran the
|
||
`DefineFunctions` completion pass per program (raw-blob auto-analysis only finds the reachable
|
||
subset — the Phase-10 finding, now automated). **Coverage measured, not assumed:**
|
||
- **5,777 of 6,070 families needing a fresh crack (95.2%) have a cached seed**
|
||
- **main 2,001/2,002 (100%)** · **resident 14/14 (100%)** · 1 residue (one main addr with no fn)
|
||
|
||
**What this changes:** the drafting surface is now fully fueled with NO MCP dependency, so waves can
|
||
run unattended against any part of the fleet — the precondition Drew asked about. It also un-blocks
|
||
P31's main-EXE campaign early (its 1,034 game-code stubs are all cached), though that stays P31
|
||
scope. `tools/prefetch_fleet.py` is committed and re-runnable; the Ghidra programs are
|
||
script-reproducible, so only the tool is tracked, not the DB bulk.
|
||
|
||
### ✅ REDO UNDER LOCK — 52 cores + 911 members banked; R22 140/140; the "cliff" was an artifact
|
||
Re-ran the whole banking sequence serially under `treelock.sh`: parallel 8-binary gate → non-jr
|
||
behemoth gate → **sig+map regen** (a bank invalidates the map) → tier-routed propagation (§123) →
|
||
one R22 over everything.
|
||
- **Wave 3: 48/48 banked** through 8 PARALLEL per-binary gates (the throughput unlock, proven).
|
||
- **Wave 2: 15/19. Behemoths: 4 non-jr confirmed** (incl. `func_8017E120` 884 ins ×14).
|
||
- **`family_sweep --hseq`: 911 members banked / 401 failed across 137 overlays**, 49 families.
|
||
- **Fleet: 92.59% fn-count · 88.2% instr · 78.7% distinct (70,506 unique fns) · R22 140/140.**
|
||
|
||
**R14 CORRECTION, on my own earlier claim.** I reported a "per-binary bank-rate cliff" (SC03_014
|
||
1/6, SC04_018 1/6, SC06_018 2/6) and theorised a cause — canonical-decl maturity per binary. It was
|
||
an **artifact**: those gates ran against a tree that propagation was concurrently rewriting. Re-gated
|
||
clean, every binary banked **6/6**. *A measurement taken during corruption is not a measurement*,
|
||
and I theorised before re-running. Same failure shape as the phantom 91.4% in the same incident.
|
||
|
||
**Carried, honestly:** the h_seq sweep's 401 failures split as 137 "no matched unit for func"
|
||
(the exemplar banked in a DIFFERENT binary than the sweep expects — a routing gap, likely cheap),
|
||
22 unresolved-immediates, 10 STRUCT (refused by design). One `dedup_propagate` run stopped the
|
||
h_exact leg early (`0x801466F0` rc=1) — the loop halted as designed rather than risking a partial
|
||
write; the h_exact leg is unfinished and owed.
|
||
|
||
### ⚠️ INCIDENT 2 (mine) — a POLL is not a MUTEX: concurrent tree writers broke 63/140; reverted clean
|
||
**What I did.** Wave-3 gated 8 binaries in parallel (correct — the byte-gate IS per-binary) while
|
||
wave-2's propagation loop was still running, then I ran `make clean` (deleting `asm/`) on top of
|
||
both. `check-all` → **77/140**, and the corpus denominator itself moved (353,720 → 353,691), so the
|
||
apparent "91.4% instr" was an artifact of a half-written tree, not a gain.
|
||
|
||
**Root cause — the guard was structurally unsound, not merely unlucky.** My gate waited on
|
||
`while pgrep -f dedup_propagate; do sleep; done`. But a CAMPAIGN is a **loop of short-lived
|
||
processes** — 15 sequential `dedup_propagate` invocations — so between every pair there is a window
|
||
with no matching process. The poll sampled one of those gaps, read "clear", and started. Presence-
|
||
of-a-process is a sampling test on a gappy signal; it cannot express "a campaign owns the tree."
|
||
|
||
**Recovery (clean, nothing lost that mattered).** Killed the writers; `git checkout -- src/ config/`
|
||
back to `commit:1245` (the last R22-verified 140/140 commit); all 58 drafts survive untouched in
|
||
`.run/` because agents never write the tree — the discipline that made this cheap. Re-verifying
|
||
baseline, then re-gating and re-propagating serially under the lock.
|
||
|
||
**Fix shipped: `tools/treelock.sh`** — an flock(1) mutex held for the WHOLE campaign, released by
|
||
the kernel on exit or kill, with `--status`. Both drivers now refuse to run unlocked.
|
||
**The general law (worth a rule at close): guard the CAMPAIGN, not the process.**
|
||
Corollary, the second time this session a killed writer hurt: **a killed process performs no undo**,
|
||
so a fleet-tier write needs a lock ABOVE it, not cleanup inside it.
|
||
|
||
### T3 BEHEMOTH WAVE (10 agents, 3.23M tok) — **7/10 CONFIRMED byte-matches at 700–970 ins**, 0 disputed
|
||
Drew asked for up to 10 agents on the behemoths; grouping analysis first showed the ≥700-ins band is
|
||
**structured, not 29 singletons**: one 16-member family @947, one 14-member @884, a 5-member @793, a
|
||
3-member @710, a 2-member @728, 5 true singletons — plus two groups that are TOOL jobs, not agent
|
||
jobs (the 13-member IMM/jr @952 with **103 already matched** → `jtbl_family_bank` carve; two
|
||
134-matched families with 4 stragglers each → sweep). All 10 agents therefore went to genuinely
|
||
uncracked families/singletons, and each MATCH claim was adversarially re-verified by a second agent.
|
||
|
||
**CONFIRMED (7):** `func_8017E120` 884×**14** · `func_80191C50` 710×3 · `func_8017FA5C` 728×2 ·
|
||
`func_8018057C` 897 · `func_80181CDC` 769 · `func_8017CAD4` 755 · `func_8017E35C` 719.
|
||
**NEAR (3), all with byte-grounded residuals:** `func_8017EF68` 969 ins at **closeness 2** — two
|
||
transposed instructions, sched2 `rank_for_schedule` LUID tie-break, everything else (frame 0x228,
|
||
spill map, every register) byte-exact · `func_8017D174` 793 at 82 (allocno tie + pin damage, length
|
||
EXACT) · `func_8017C974` 947×16 at 812 (a pure regalloc cascade from ONE extra reserved reload reg;
|
||
598/957 regions already exact, no shape errors) — the last is the biggest family left and now has a
|
||
full structural map + the exact gcc mechanism written down.
|
||
|
||
**MY ERROR (recorded):** I hand-typed the `asm` paths into the workflow args instead of passing the
|
||
ones I had already DERIVED from `corpus.asm_path` in the same session — so several task cards named
|
||
a split that does not exist (`_jr_8017AE2C` where the truth was `_jr_8017C8D0` / `_jr_8017C294`).
|
||
The agents located the real paths themselves and reported the discrepancy. Deriving then discarding
|
||
the derivation is worse than never deriving it: it looks authoritative. Pass the artifact, never a
|
||
retyped copy of it.
|
||
|
||
**Gating plan (the jr/non-jr split matters):** 4 confirmed are non-jr → gate freely. 3 are jr →
|
||
their jtbl carve runs `make extract`, which rewrites `asm/` under the 48 running wave-3 agents, so
|
||
they are DEFERRED until wave 3 lands. Staged per-binary in `.run/beh-gate/<binary>/` for parallel
|
||
gating (7 distinct binaries).
|
||
|
||
### T4 (partial) ✅ — the two "Phase-22 grinder bugs" are STALE carry items; the real fixes were elsewhere
|
||
Verified against the code, not the list (R14 on our own defect ledger):
|
||
- **"split-file-blind lookup" — ALREADY FIXED.** `asm_subdir_for` globs `nonmatchings/*/` which
|
||
matches every split; verified on a `_jr_` fn, an `_o0` fn, and an absent fn. Struck.
|
||
- **"churn-without-blacklist" — ALREADY FIXED.** The blind `tried.clear()` was replaced by
|
||
input-signature gating in the T5 targeting work (re-open only fns whose draft mtime/closeness
|
||
changed), and the blacklist exists. Struck.
|
||
- **Real fix taken instead (R33):** `asm_subdir_for` was a PARALLEL implementation of
|
||
`corpus.asm_path` that silently took `g[0]` on multiple matches — now derived from the oracle.
|
||
- **`--fix-def-sig` posture:** flag correctly defaults OFF, but its help still advertised
|
||
"Byte-neutral; gate arbitrates" — the exact claim T84 refuted (it imposed a signedness-wrong
|
||
header decl over a byte-correct draft, `slti`/`sltiu`, and held 137 members at 0 until DROPPED).
|
||
Help now carries the §119 warning. **The posture was right; the documentation was the defect.**
|
||
**Lesson for the phase close:** the carried-defect list had 2 of its entries already fixed. A
|
||
defect ledger nobody re-verifies decays into busywork — verify before scheduling (R35's sequencing
|
||
applied to the backlog of *our own* bugs).
|
||
|
||
### T3 wave 1 (Ultracode, 14 agents, 1.20M tok) — 14/14 match_one MATCH → **8/14 BANKED**; the gate's propagation TIMEOUT left the fleet half-written (caught, reverted, tool fixed)
|
||
**The wave:** 14 fresh reach-138 cores in ov_SC01_077 (117,162 gain-ins in play), one agent each,
|
||
drafting against the §31 map + cookbook with `match_one`/`rtu_match` self-verification. **All 14
|
||
returned closeness 0**, most cross-verified in the real TU. **Whole-binary gate (the arbiter,
|
||
§52b): 8 banked** — `func_80175820` (×276!) · `func_8012E014` · `func_80133298` · `func_8015FBE0` ·
|
||
`func_8016E9EC` · `func_80151C54` · `func_8012F49C` · `func_80151B98`. Bank truth derived from
|
||
source (INCLUDE_ASM presence), never the gate report (§55b trap 4). 57% conversion = the §52b law
|
||
holding exactly; the 6 rejects are all declaration/integration work their agents had already named.
|
||
|
||
**THE INCIDENT (recorded, not buried).** `gate_stage` hardcoded `timeout=3600` on
|
||
`dedup_propagate`. Ample for one bank; with EIGHT (each rewriting ~138 overlays) it blew, and
|
||
`TimeoutExpired` propagated out and **killed the driver mid-write**: 313 files modified
|
||
(alphabetically ov_SC01_000..ov_SC03_013 — it died partway through the fleet),
|
||
`config/dedup.us.yaml` never updated, `engine_core.h` half-edited. **`check-all` 124/140.**
|
||
Caught by running the oracle before trusting the state; **`git checkout -- src/` reverted all of
|
||
it** (§61 — and note a KILLED process performs no undo at all, so the driver's own restore logic
|
||
was never reached). Nothing was committed at any point; zero contamination.
|
||
**Fix shipped:** timeout now SCALES with bank count (`1800 + 1800×banks`, capped 6h) AND is
|
||
CAUGHT — on expiry the driver reports `TREE DIRTY, REVERT REQUIRED` and returns cleanly instead of
|
||
dying with the fleet open. **Recovery path (also the new standing practice for multi-bank waves):
|
||
re-gate `--no-propagate`, then propagate PER FUNCTION via `dedup_propagate --addr` — bounded,
|
||
resumable, verifiable between steps — rather than one monolithic fleet write.**
|
||
|
||
**Three byte-grounded idioms to distill (R16/R30, owed):** (1) **`void`→`s32` return is NOT
|
||
byte-neutral** — an s32 return keeps `$v0` live-out and stops dbr stealing an `addiu` into the
|
||
loop-back delay slot; this CORRECTS cookbook §3a-1's neutrality claim (`func_8016EC0C`).
|
||
(2) **The asm-label alias** `extern s32 SYM_w __asm__("SYM")` — reads a `u8`-declared shared global
|
||
as a word WITHOUT `*(s32*)&SYM`, which force_regs the address and drags 3 extra `la` pseudos across
|
||
calls; found independently by two agents; a general unblock for the u8-vs-s32 loose-typing
|
||
collisions (`func_8012E014`, `func_80133298`). (3) **Zero-byte `__asm__("")` as a delay-slot
|
||
fence** — `reorg.c stop_search_p` halts the eager filler on an asm insn (`func_8015FBE0`).
|
||
|
||
### T1a ✅ — the deterministic recovery sweep: +18 banked; the stored-draft question CLOSED (report point #2)
|
||
Population: the 108 fresh autopsy-MATCH strandeds (+ the 012 abort re-run, 0/3) across 50 binaries,
|
||
47 min, 17 driver commits. **Metric truth (R14, derived): fn-count +18 instances / distinct +12
|
||
unique fns** (commit messages summed 19 — gate-report double-list; the metric wins). **R22
|
||
clean-fleet 140/140** after the sweep + residue revert. Fleet: 87.5 / 78.0 / 92.00 (+384 w-ins).
|
||
**The honest read:** the S16 "39%" prior did NOT generalize — it was measured on FRESH same-wave
|
||
drafts; this stored-backlog population is the class decision-log **A10** already byte-proved
|
||
non-bankable by plain re-gate (0/958). The driver's reconcile/demacroize lifted **18 of ~111
|
||
(≈16%)** over A10's 0% — a real but bounded delta. **The stored-draft recovery question is now
|
||
CLOSED both ways:** cheap wins taken; the ~90 not-banked stay match_one-MATCH but their drafts are
|
||
integration-decayed — they route to T3's REDRAFT lanes (A10's "fresh re-drafts only"), not another
|
||
recovery pass. §61 residue class found + reverted (2 orphan carve .c + overlays.mk/yaml edits from
|
||
FAILED jr attempts). **Two live gaps for T3 pre-work:** (1) `gate_stage --commit` add-scope cannot
|
||
stage NEW carve files / overlays.mk / yaml — moot at 0 jr banks here, live the moment a T3 wave
|
||
banks a jr fn through it; (2) my own checkpoint edit mid-sweep tripped the driver's blast-radius
|
||
assert (012's abort) — tracked-file writes and a tree-writing campaign cannot share a repo; queue
|
||
docs until the campaign exits.
|
||
|
||
### T2 finding 2 — the Arm-A reproduction target has MOVED: the fleet is jr-carved now (2026-07-30)
|
||
`rollout_o0_cluster.py ov_SC07_007` → SKIP ("cluster fns not in base .c"): since Arm A (07-16),
|
||
the P29 jr campaign carved every overlay (007 now: 16 `_jr_*.c` splits) and **the -O0 range
|
||
(0x8013B568..) sits INSIDE `<ov>_jr_80135D20.c`** (23 stubs there in 007). The Arm-A tool's
|
||
single-file premise is stale fleet-wide — the rollout is now the predicted **carve-within-a-carve**:
|
||
sub-split `_jr_80135D20.c` (pre / o0 / post) per overlay + the Makefile -O0 wildcard for the new
|
||
class + the +0x20 shift-diff at the NEW seam. Next concrete steps (deep arc, next session's opener):
|
||
(1) extend the carve tool to sub-split jr files; (2) probe on **ov_SC07_007** (zero T1a collision;
|
||
baseline `%lo/%hi` inventory saved: `.run/t2_007_baseline_syms.txt`, 951 operands); (3) on shift:
|
||
diff the generated asm symbol inventory → **pin the drifted `D_` symbols at pre-carve addresses in
|
||
the overlay symbol file** → re-extract → per-binary sha (the config-only fix hypothesis); (4) the
|
||
R31 whale-shape hypothesis (no INCLUDE_ASM in the -O0 split) as fallback. ov_SC07_010's carve is
|
||
still in-tree + byte-neutral (the Arm-A keeper) — the 010-vs-007 asm diff is a free shift oracle.
|
||
|
||
### T2 ▶ driver generalized; ×1 probe REFUTED the append route for the remaining cluster (2026-07-30)
|
||
`tools/rollout_o0.py` (generalizes T85's `rollout_801457a4_o0.py`): map-derived members
|
||
(cross-address-safe), stub located in any non-`_o0` split, jr+o0 composites routed out loudly,
|
||
atomic two-file + per-binary SHA gate + restore-both. **×1 probe (`0x8013b6a0`@ov_SC01_000):
|
||
gate-reject — and the diagnosis corrects the frontier report (R14 on my own doc):** T85's family
|
||
banked by APPEND because `0x801457A4` abuts the o0b object's END; the remaining 18 families
|
||
(`0x8013Bxxx–0x8013Cxxx`, below the whale) mis-place on append by construction, and per-fn
|
||
isolation IS the Arm-A re-carve. o0b-*bearing* ≠ o0b-*adjacent* — my "the wall never has to fall"
|
||
inference was wrong; caught at 1 build instead of 2,131. **T2's real substance = the Arm-A `+0x20`
|
||
defect.** First probe: identify WHICH symbol shifts on a failing overlay's re-carve; hypothesis:
|
||
splat re-GUESSES a data-symbol boundary the carve moves → pin it in config symbols and re-probe.
|
||
|
||
### T0.5 ▶ launched + probed (2026-07-30)
|
||
`tools/prefetch_fleet.py` (committed `commit:1220`): 126 programs / 7,966 uncached representatives.
|
||
**Probe 1 (main):** +1,525/2,002 cached in <1 min — the decompile leg is CHEAP; **477 main addrs
|
||
have no defined function in the program** (main's 06-14 auto-analysis gap) → follow-up: a
|
||
`DefineFunctions.java` completion pass over main from splat entries (the Phase-10 mechanism), then
|
||
re-run (resumable). **Probe 2 (import leg): FAILED then FIXED** — my missing-program matcher
|
||
checked "not exist"/"NOT_FOUND"; Ghidra's actual phrase is "Requested project program file(s)
|
||
**not found**" → the self-healing import never fired (+0/371, +0/315). One-line trigger broadening;
|
||
re-probe running. T1a (deterministic recovery sweep, 108 fns / 50 binaries, driver-committed banks,
|
||
no-propagate — reach≥2 winners ride T3 Lane A) launched concurrently; commit-scope interaction
|
||
VERIFIED safe (driver delegates to gate_stage's scoped `git add -u src/` — ghidra/ churn cannot
|
||
leak into bank commits).
|
||
|
||
### T0(e2)+(f) ✅ — autopsy refreshed; frontier regenerated + the three populations PINNED (2026-07-30)
|
||
- **Autopsy** (`collect -j12` + `report`): 1,349 rows — **1,178 near / 63 nobuild / 108
|
||
match_one-MATCH** (T1's stranded-draft fuel, 3× the S16 sample), 0 classifier errors,
|
||
second-oracle agree. `docs/autopsy.md` regenerated.
|
||
- **Worklist/manifest regen:** 101 live stubs / 261,789 gain-ins (stale 160/583k gone); R14 checks
|
||
inside the manifest: 28/28 giants verified reach-138.
|
||
- **THE `-O0` PIN (headline):** 18 families / **2,192 open members — 2,131 o0b-route-eligible /
|
||
61 SC07-no-o0b**; **15/18 exemplar-matched**. The "WALLED ~1,287" framing dissolves: the bulk
|
||
never needs the Arm-A splat fix — T2 = generalize the proven `rollout_801457a4_o0.py` (130/130).
|
||
Composites flagged: `0x8013c414`/`0x8013c0f8` are jr+o0 (carve inside the o0b TU — probe ×1 first).
|
||
- **Zero-crack roster:** 114 families / 3,166 open members / ~204k weighted ins (28 substantial);
|
||
its head IS the -O0 set (T2 and Lane A open together).
|
||
- **Concentration:** top-20 = 24.0% / top-100 = 44.8% of open family weight (head consumed vs S13's
|
||
53% — expected post-campaign flattening).
|
||
- **Report point #1: `docs/frontier-p30.md`** (all numbers same-tree at one HEAD, post-repair — R35).
|
||
|
||
### T0(e) — part 1 ✅: the 21-file absolute-include defect fixed (2026-07-30)
|
||
All 21 carriers were jr-carve split files including `engine_types.h` by absolute path
|
||
(`/home/musashi/bfm-decomp/...`, some twice); swapped to the house-relative
|
||
`#include "../shared/engine_types.h"`. `grep -rln /home/musashi src/ include/` → **0**.
|
||
**R22 clean-fleet from a genuinely clean tree: 140 passed, 0 failed of 140.** Part 2 (autopsy
|
||
refresh) next.
|
||
|
||
### T0(d) ✅ — backlog ledger: already clean; the scanner deleted (R33) (2026-07-30)
|
||
Findings, byte-verified: (1) the still-a-stub filter **already existed** (`load_best` drop +
|
||
`prune`, built 07-24) and the tracked jsonl was **already compacted** — the tree's pre-existing
|
||
uncommitted `.run/backlog.jsonl` edit was late-S25's un-committed prune output; `prune` today:
|
||
1350 → 1350, dropped 0. (2) The stale rows I'd flagged (`func_80151944` etc.) live in **worklist.md**
|
||
(regen at T0(f)), not backlog. (3) `_open_stubs` (private regex) vs `corpus.stubs` (the oracle):
|
||
**0 divergence across all 131 ledger binaries** — after fixing MY probe, which compared names
|
||
against int vram addrs (R35 pointed at my own instrument). Hardening: `_open_stubs` now **derives
|
||
from corpus.stubs** (STUB_RE deleted — R33's "best outcome is a deleted scanner"); hex-case
|
||
canonicalized on both sides of the membership test (a lower-hex record can't silently drop, R32);
|
||
count parity proven post-change (load_best 1350 == 1350). §83's doctrinal caveat (backlog ≠ work
|
||
queue; worklist is the queue) STANDS — that's classification quality, not staleness.
|
||
|
||
### T0(c) ✅ — family_hseq↔progress gap: ZERO definitional gap; stamped against recurrence (2026-07-30)
|
||
Same-tree regeneration of BOTH digests: family_hseq (overlays) **27,248 instances** == progress fleet
|
||
stubs 28,296 − main 1,034 − resident 14 = **27,248 — EXACT**. The carried "29,961 vs 28,296" was a
|
||
**cross-date, cross-scope misread**: the 07-29 map snapshot was SESSION-25's *open* state, and
|
||
29,961 − 27,248 = **2,713 = exactly the session's banked total**. The tools were never in
|
||
disagreement — both already derive from `corpus.stubs` (the Phase 26-A conversion, family_hseq:42).
|
||
Hardening: the family-hseq digest header now **stamps scope ("138 OVERLAYS only") + generation
|
||
HEAD + the shared-oracle note** ("compare digests only at the same HEAD") — a stale or
|
||
scope-mismatched comparison is now self-announcing. Roadmap v2 D-bucket corrected.
|
||
**Fresh frontier readings from the regen** (full pinning still at T0(f)): 478 substantial families /
|
||
678,404 templatable ins · **28 zero-crack** (was 61 on 07-29 — S25 consumed 33) · 3,626 PURE / 40
|
||
IMM / 6 STRUCT · overlays 27,248 instances / 17,629 distinct / 1,587,311 ins.
|
||
|
||
### T0(b) ✅ — rtu_match surfaces the real cc1 error in the verdict (2026-07-30)
|
||
`_diagnostics()` filter (the SESSION-25 recipe, in-tool): drop `warning:`/`In function`/`At top
|
||
level`/`###`/blank lines from the failing stage's stderr and print the FIRST 15 survivors — gcc-2.7.2
|
||
hard errors carry no `error:` prefix and the old `[-2000:]` tail was all warnings. Raw-tail fallback
|
||
if the filter empties (ICE/signal formats) — never prints less than before. Applied to all four
|
||
stages (CPP/CC1/MASPSX/AS). Verified on a real deliberate CC1 failure: the verdict now leads with
|
||
`t.c:3116: 'nonexistent_var' undeclared` instead of a 2 KB warning tail. `--stderr-out` unchanged
|
||
(full dump). Docstring updated.
|
||
|
||
### T0(a) ✅ — gate_stage stage-0 + fix_arity_callers journal undo (2026-07-30)
|
||
The carried defect pair closed structurally, not by root-causing:
|
||
- **`gate_stage.py`**: **stage 0 gates the RAW drafts before any transform** (`GATE_NO_STAGE0` to
|
||
disable) — the destroyed-good-draft mode (SESSION-22 reproduction: `_o0` pair + `func_80138C60`,
|
||
ladder-FAILED / bare-VERIFIED) is now impossible by construction; the canon/cast/rc ladder + arity
|
||
pre-pass run only on stage-0 failures. Root-cause hypothesis recorded in-code (transforms are
|
||
batch-`--src-file` TU-blind where the gate is per-draft TU-aware) — open, now harmless.
|
||
- **`fix_arity_callers.py`**: `--journal` (per-edit literal before/after) + `--undo-journal
|
||
[--keep <banked>]` — the exact undo now lives in the WRITER, shared by ladder AND bare workflows
|
||
(the 17-TU residue class). Replaces gate_stage's two-special-case file snapshot; undo moved to
|
||
after stage 2 (closes the latent stage-2 parity gap: a stage-2 bank used to lose its arity edit
|
||
before its own gate attempt). Stale-journal guard (`_arity_rc is not None`).
|
||
- **Verification:** negative control apply→undo → byte-identical tree; `--keep` retains exactly the
|
||
kept edit; in-process flow test `.run/t0a_flowtest/driver.py` **7/7 PASS** (stage-0-first, s1in =
|
||
failures-only, accumulation, undo-guard, src/ untouched). Real-tree at-scale proof lands with
|
||
T1's first sweep (R22-bracketed there). Cookbook **§122**.
|