mirror of
https://github.com/Druthulu/BFM-decomp
synced 2026-09-29 23:24:32 -04:00
Drew T
2409 lines
187 KiB
Markdown
2409 lines
187 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-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 SIX times this session, 140/140 every time)
|
||
**96.46% fn-count (341,198/353,717) · 94.4% instr-weighted (12,410,275/13,141,652) · 89.2%
|
||
distinct-code (5,028,621/5,634,875; 77,960 uniq)** · 0 NON_MATCHING · audit-digest OK.
|
||
Session opened 341,186 / 12,405,402 / 77,952 ⇒ **+4,873 instructions, +8 unique fns**, ~0 agent tokens
|
||
(no wave was run — every gain came from re-gating stored work and one mechanical propagation).
|
||
|
||
## 🔑 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 |
|
||
|
||
## 🔑 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.**
|
||
|
||
## ▶ 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
|
||
|
||
### ▶ 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**.
|