HONEST CORRECTION to commit:1382. That commit's message implies the 42 `(void)`
relaxes unblocked the PROPAGATE remainder. They did NOT: the re-run banked 0/1
in all 134 overlays with the same error, because DEFINE_func_8016BA68 declares
func_80146C3C `(u8*)` — the MIRROR of the EXTEND-lane pair — and my relax only
touched the `(void)` direction.
Root cause is the R37 shape a third time: I bucketed by SYMBOL and stopped. The
lever is set by the (macro-shape, TU-shape) PAIR, and the same symbol conflicts
in BOTH directions across this fleet. One awk over the macro I was ACTUALLY
fixing — which I ran for the EXTEND macros and not for this one — shows the pair
before a 134-build run. §138 amended with the PAIR rule; correction logged in
CURRENT_PHASE.md rather than rewritten out of history.
The 42-decl relax still stands: byte-neutral, R22 140/140, removes a real
conflict class. It just did not do what I predicted.
THIS commit relaxes the 2 remaining `(u8*)` decls (uses are cast; `()` is
compatible with the (void)/()/(u8*) forms the fleet carries and no decl of this
symbol has a default-promotion param). R22 clean-fleet: 140 passed, 0 failed.
ALSO: tools/overlay_src_split.py `_split_macro_body` — the §134 sweep's one real
target, fixed. It carried the identical single-line-only comment test, and it
decides where a macro body's file-scope externs END, so a multi-line comment
truncated the extern set. SIZED FIRST: 38 live lines in engine_core.h macro
bodies hit it today. Now decides on cdecl._mask (one oracle, R33) with the
length-preservation invariant asserted (R32). Proven both directions by a
control: pre-fix it stopped at `/* multi` carrying 1 of 2 externs and treated the
comment as the definition head; post-fix both externs carry and the def head is
correct. Not in the gate path (only o0_subsplit + jr_isolate_all import it).
Diagnosed the 11,147-ins PROPAGATE remainder with one probe, in §138's order:
1. ONE COMMAND, NO BUILD: the originals of BOTH 0x8016BA68 and 0x8012F274 are
sha1-identical across ov_SC07_006 / ov_SC06_025 / ov_SC01_000 / ov_SC01_077 /
ov_SC03_001 -> 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, same (void)-vs-(u8*)
shape, same one-token lever. The 137 [exclude] lines were one declaration.
Relaxed the remaining 42 `extern void func_80146C3C(void);` in engine_core.h to
`()`. Measured safe BEFORE editing (§138): every fleet decl of the 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 a no-arg call or already
cast, so it is codegen-neutral. R22 clean-fleet: 140 passed, 0 failed of 140.
TOOL BOUNDARY worth recording: `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 with "no source overlay has it matched". Extending an
already-macro-ized group is `dedup_extend`'s job. Probe: exactly 1 extendable
group per ordinary overlay — so the fleet has no hidden wiring backlog beyond
this function (a useful negative, R32-shaped).
Also logged: the §134 scanner sweep is sized and has ONE real target —
tools/overlay_src_split.py:345 (_split_macro_body) carries the identical
single-line-only comment test, and it decides where a macro body's file-scope
externs END, so a multi-line comment there silently truncates the extern set.
The other scanners in that file track block-comment state; split_src_region.py
and family_remap.py already handle the multi-line form.
§138 — "the propagation lanes: a gate refusal is a DECLARATION, and which lever
you owe depends on blast radius". The durable content of this session:
- the 4-lever triage table ranked by blast radius, and the rule to grep the
fleet's decl shapes BEFORE relaxing to `()` (illegal only against a
default-promotion param — 4,020 decls measured, 8 of 36 banked for one token)
- `volatile` in the host TU is a SCHEDULING BARRIER that masquerades as a codegen
wall; the tell is a positional shift with a `nop` at a delay slot, and the
h_exact contract is confirmed/refuted in ONE command with no build
- the DEFINITION-side asm-label alias as the only zero-radius escape when the
fleet canon disagrees on a promoting param (1,725 in-tree precedents)
- rank a lane by measured concentration, not class count (5 of 45 classes carried
89%), and `--recover` is not a retry (16/16 on drafts, 4/138 on a propagation)
- §134 multi-line blindness recurring in a second tool; decide on `cdecl._mask`
- the waiter rule CORRECTED: `pgrep -x make` is wrong for a campaign of
sequential makes, `pgrep -f` self-matches, `nohup … &` signals the wrapper
Checkpoint refreshed and placed below the task checklist (fresh-session safe):
fleet 96.10 / 93.7 / 88.0, dedup 1908/0, R22 140/140 four times this session,
nothing running, lock free. Three named next items, none yet diagnosed against a
build — the PROPAGATE head remainder (11,147 ins), the 41-class tail (2,316),
and EXTEND's last 5 (the whale needs the §38 -O0 route; dedup_extend should
refuse-and-name that class per R32).
Fleet 96.06 -> 96.10% fn-count / 93.7% instr / 88.0% distinct; dedup 1907 -> 1908
groups, 0 failed, C1 240807/240807. R22 clean-fleet: 140 passed, 0 failed of 140.
func_8012A598 (3,288 templatable ins) was being written off as CARRY-FIXABLE.
It took TWO fixes; either alone leaves it skipped.
1. TOOL (R33) — find_site's preamble backscan. The SESSION-18 fix handled blank,
`//`, and SINGLE-LINE `/* … */` lines, but a MULTI-LINE block comment still
halted the walk: its middle lines start with `*` and its last line ends `*/`
without starting `/*`. So the three externs above the body were dropped and
the body then failed compiles_standalone on now-undeclared data. This is the
§134 multi-line-blindness class — S6b fixed the identical shape three times in
family_remap (D1/D2/D5) and this copy was never reached.
Fixed by deciding skippability on `cdecl._mask` — the project's ONE masking
oracle — instead of on line syntax: it subsumes every comment form at once and
cannot be fooled by a `/*` inside a string, with 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, so a bug here
can fail to bank but 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 would redefine it in a
single 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 and drops the alias too.
Probed on ONE member before scaling (R37/S29): byte-identical 9052dc0e first try;
then 138 overlays byte-identical.
PROPAGATE head accounting after this: 7,398 of 18,545 ins banked (func_80147364
4,110 + func_8012A598 3,288). Still open, each with a NAMED cause and none yet
diagnosed against a build: func_8012f274 (3,973, dropped), func_8016ba68 (3,886,
4/138), func_801466f0 (3,288, the S6b D4 wrapped-alias gap).
Continues the S11 lane. Fleet 96.01 -> 96.06% fn-count / 93.6 -> 93.7% instr /
88.0% distinct; dedup 1905 -> 1907 groups, 0 failed, C1 240669/240669.
R22 clean-fleet: 140 passed, 0 failed of 140. 0 NON_MATCHING (G4).
EXTEND (SC07): the 16 volatile-blocked DIFF slots banked on retry after the
data asm-label alias -> lane total 31/36.
PROPAGATE head, measured rather than projected. .run/s8_lag.json re-split: the
checkpoint's "45 classes / 20,837 ins" is really 5 classes carrying 18,545 ins
(89%) and 41 carrying 2,316. Per-class outcome:
func_80147364 30x137 = 4,110 BANKED x137 (definition-side asm-label alias)
func_8012f274 29x137 = 3,973 DROPPED — byte-diverges in ~130 overlays
func_8016ba68 29x134 = 3,886 4 of 138 banked; excluded from ~130
func_8012a598 24x137 = 3,288 SKIPPED, cause NAMED by the tool
func_801466f0 24x137 = 3,288 no source found — the S6b D4 gap, still open
func_80147364's byte-true definition is `(u16, u16)` while 4,046 fleet decls
say `(u16, s32)`. u16 is a default-promotion type, so the `()` no-prototype
escape is ILLEGAL (the documented gcc-2.7.2 dead-end) and conforming the decl
would change caller codegen. The DEFINITION-SIDE asm-label alias gives the def
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 137 overlays clean.
In-tree precedent for the form: 1,725 files.
MEASURED NEGATIVE, recorded not buried: `dedup_propagate --recover` banked only
4 of 138 on func_8016ba68 and dropped func_8012f274 entirely (137 [exclude]
lines). The caller-extern reconcile that is 16/16 lifetime ON DRAFTS does NOT
transfer to PROPAGATION of these two. Cause not yet diagnosed -- probe one
excluded overlay's build output before any further attempt (§136a), do not
re-run the lever hoping.
NAMED NEXT (cheapest first): func_8012a598 skips on `missing file-scope extern
(CARRY-FIXABLE): D_801151D4, D_80126DB8_a, D_80127504` -- the SESSION-18
preamble-backscan class. Its body is 2 statements and `struct BigCopy` is
ALREADY in the shared engine_types.h (L312) with the identical statement already
macro-ized at engine_core.h:16158, so a hand-authored macro (the func_80147364
path) should take it x137 for ~0 tokens.
Process errors recorded in CURRENT_PHASE.md, all three one mechanism -- the
signal sampled is not the thing waited for: (1) a `nohup CMD &` wrapper's exit
read as the fleet check finishing (it stood at 63/140); (2) a corpus.stubs probe
mid-rebuild, which R32's coverage assertion refused rather than answer wrongly;
(3) CORRECTION to the S10 checkpoint's own rule -- `pgrep -x make` is right for
one make and WRONG for a campaign of sequential makes (it fired in a gap and
reported a live campaign done), and `pgrep -f <pattern>` SELF-MATCHES so that
waiter can never exit. Wait on the campaign process or `treelock.sh --status`.
Banked 15 h_exact members into the 4 SC07 overlays via dedup_extend, and
diagnosed the class that dedup_extend's own header records as UNDIAGNOSED.
THE 4 DIFFs ARE NOT A CODEGEN WALL. dedup_extend's correctness argument says an
h_exact match guarantees byte-identity including relocs, so a DIFF should be
impossible. Both halves of that tension 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...), so the registry is not lying.
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 against the payload:
built +0x090 addu / lui,sw x3 / jal / NOP
ref +0x090 lui,sw x3 / jal / addu-in-delay-slot
All 4 DIFF 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
(`extern s32 aD_80127090 __asm__("D_80127090")`) -- a distinct C identifier is
immune to any TU's declaration of the symbol, and is byte-neutral by
construction in the other 134 (same symbol, same type, same non-volatile
semantics). In-tree precedent: ov_SC06_008_jr_80135D20.c:1434.
R22 clean-fleet: make clean && extract-all && check-all -> 140 passed, 0 failed
of 140, with the 15 banks AND the alias edit in.
Remaining in this lane, both named not walled: func_80144B9C x4 (the whale --
its registry `func` field is a bare name, not a DEFINE_ macro, so write_drafts
emits a CALL; it needs the §38 -O0 shared-header route, and dedup_extend should
refuse-and-name it per R32) and func_80149954 x1 (blocked behind func_80147364,
whose u16 params make the `()` no-prototype escape illegal -- the documented
gcc-2.7.2 default-promotion dead-end; needs the alias or a de-macroize).
The dedup_extend SC07 lane banked 0/36. Captured every failure's own compiler
error rather than guessing: 5 PLUMBING (declaration conflicts) + 4 DIFF per
binary, and the PLUMBING set reduces to 4 distinct symbols repeated across all
four binaries.
Fixed at the lowest available blast radius, each byte-neutral BY CONSTRUCTION
and proven by R22:
- func_80146C3C (8 of 36): T2, but 1 token. DEFINE_func_8016A08C /
DEFINE_func_8016A1CC declared it `(void)` while the SC07 TUs declare
`(u8 *a0)`. Both macros already CAST at the call site, so the prototype is
codegen-irrelevant -> relax to `()` (no-prototype). Measured first: all 4,020
fleet decls are (void)/()/(u8*)/(u8 *a0) — no default-promotion param
anywhere, so `()` is compatible with every one of them (the gcc-2.7.2 `()`
dead-end needs a promoting param; there is none).
- func_8014F4C0 (4 of 36, self-axis), D_80126CC4 (3), func_8012E5CC (1): T1
binary-local. Conformed the SC07 decls to the fleet-canonical form. Every one
has ZERO uncast uses in its TU (verified per file), so the decls were pure
splat boilerplate with no codegen effect.
Deliberately NOT touched: engine_core.h beyond those 2 lines. The §29 law is
about BULK header edits (the 2,046-file sed that still didn't build); 2 targeted
macro lines with a measured compatibility argument is not that.
R22 clean-fleet: make clean && extract-all && check-all -> 140 passed, 0 failed
of 140. Enabling change only; no function banked in this commit.
Method note (mine, recorded): I read `corpus.stubs` 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). Also: `nohup CMD &` inside a backgrounded
Bash call makes the harness signal completion of the WRAPPER, not the campaign —
the R22 "finished" at 63/140. Waited on `pgrep -x make` instead.
- DREW'S CALL (2026-08-03): route the 30-target x2-9 wave to SONNET instead of Opus. The §136i
>=120-ins Opus threshold was MY EXTRAPOLATION, never measured; this wave (125-793 ins) probes
exactly the region where there was no data.
- RESULT: 13 banked of 16 that ran = **81%**, vs Opus's 10/13 = 77% on the comparable S8-3 slice.
At least 8 banked SONNET-DIRECT (65 agents spawned: 60 sonnet, 5 opus escalations). Propagated
57 member-matches / 4 failed across 42 overlays. 70 instances. R22 clean-fleet 140/140.
FLEET 96.01% fn / 93.6% instr / 88.0% distinct (77,550 uniq).
=> **Sonnet is at least as capable as Opus on 125-793 ins. The ~120 boundary is too low.**
NOT rewriting it to a specific number yet: 16 samples under a throttle confound cannot name a
cliff. The controlled A/B (task #12) is how that number gets fixed properly.
- THE REAL LIMITER IS CAPACITY, NOT CAPABILITY: 14 of 30 agents were killed by SERVER-side
throttling ("Server is temporarily limiting requests (not your usage limit)") that 30 concurrent
Opus agents did not trigger. Practical rule: run Sonnet waves at ~12-16 concurrency, not 30.
The 14 unrun targets are listed in the checkpoint for a smaller-batch retry.
- Sonnet's work quality was not shallow — three examples: func_8018797C read local-alloc.c and
forced loads into an AGGREGATE to stop find_free_reg greedily taking 3 callee-saved regs;
func_8018D870 used §136c sibling-first for ~70% of the body then blocked a coalesce with a pin;
func_8017E3AC diagnosed an RC-3 callee-saved-order swap and noted the pin must be s32 or a stray
`andi 0xffff` appears.
- MY ERROR, RECORDED: `until [ -s <output> ]` fires at the FIRST LINE of output, not at completion.
It fired mid-propagation and I ran `make clean` on top of a live family_sweep, deleting asm/ and
aborting both the regen and the sweep (corpus's R32 assertion refused to answer rather than return
a wrong stub set — working as designed). No bad bytes: R22 verified 140/140 immediately after, and
the propagation simply re-ran clean. Correct waiter is `pgrep -x make` (exact process name), which
also cannot self-match the way `pgrep -f <pattern>` did when it leaked 4 waiter shells earlier.
Third instance today of ONE root cause: trusting a proxy instead of the thing itself (a weight
column vs a probe §136h; an exit status vs build output §136a; file-existence vs process exit).
- CALIBRATION (25 stratified targets: 12 head-by-weight + 13 sampled across the band, so the
measurement captures the DECAY, not just the head): 28 agents -> 22 claimed -> gate BANKED 22/25
(88%) -> propagated 67 member-matches / 13 failed across 38 overlays. 89 instances.
**22,937 templatable instructions banked in one wave.**
HEAD 9/12 -> 19,492 of 28,584 templ ins
BODY 13/13 -> 3,445 of 3,445 templ ins (the small ones are EASY; all 3 misses were 611-793 ins)
- FIRST SONNET DATA (§136i ladder's new middle rung): **Sonnet 6/6 · Haiku 6/6 · Opus 10/13.**
The two cheap tiers went 12/12 and Opus absorbed every hard failure — consistent with correct
size-routing rather than luck. Small n; the controlled A/B stays parked (task #12).
- THE PROJECTION for the >=95% instr bar (Drew's decision input): 411 of 1,872 families cover the
212,594-instruction gap = ~19 waves optimistic, 20-30 realistic. Mean templ ins/family decays
1,844 (top-25) -> 1,046 (top-100) -> 525 (top-400) -> 193 (band-wide), so early waves look like
this one and later ones bank MORE functions for FEWER instructions.
- DECISION (Drew): NO phase close — keep grinding. Campaign tracked as task #15.
- Carried failures -> next lanes: func_8017D174 (793 ins, closeness 5 after ~90 variants; diagnosed
a backward-scheduler priority race -> permuter, correctly NOT ledgered a wall), func_80186E24
(611 ins, 133 of 139 diffs pure register numbers -> a natural §137 test), func_8017E2EC.
- §136c sibling-first paid again: func_8017DF84 (766 ins) MATCHED because a banked byte-matched twin
existed in the same TU; its 697 index-diffs traced to ONE root cause (a bare 0xFFFFFF literal that
loop.c hoisted to the OUTER preheader, stealing $s3) — closed by binding it to a local declared as
the FIRST statement of the inner loop body. Verified via rtu_match (real-TU), not just match_one.
- S8-3 (23 fresh x10-99 families, 121-328 ins — the hardest band this session): draft 16/23 ->
capture (1 PLUMBING / 6 DIFF) -> reconcile 1/1 -> redraft 6/6 => **23/23 (100%)**.
Propagated 206 + 81 = 287 member-matches across 80+54 overlays. R22 clean-fleet 140/140.
FLEET 95.97% fn / 93.4% instr / 87.5% distinct (77,404 uniq); dedup 1905/0; 0 NON_MATCHING.
- §136b CLOSES AT 15/15 — no function ledgered "genuine byte-DIFF" survived a redraft, all session.
- §137 (NEW, the session's most reusable result): REGALLOC-PERM — a clean 2-register swap — is a
TWO-COMPILE ARITHMETIC PROBLEM. global.c:allocno_compare ranks by floor_log2(R)*R/L*1e4*size;
read R and L out of `cc1 -dl -dg` for BOTH contenders AND their ranked neighbours to get the
admissible priority WINDOW, then place a zero-byte `__asm__ __volatile__("" ::"r"(v))` so L lands
inside it. func_801833F0: contenders ONE unit apart (1297 vs 1296), window (1228,1296), five
placements probed, only L=219 -> pri 1232 worked. R and L are FORCED BY THE EMITTED CODE (L is
recomputed post-sched1), which is exactly why source-reordering is a dead end for this class.
Converts a class the permuter banked 0 from all session into a deterministic calculation.
Companion: floor_log2 makes ref-count a STEP function (5/6/7 refs are worthless, you must reach 8)
— func_8017EFA8 closed 30 register-name mismatches by taking a pseudo 4 refs -> 8 with a dead read.
- §136j — the failure MIX FLIPS WITH SIZE: <=120 ins fails ~70% on declarations; 121-328 ins fails
86% on genuine codegen. Budget reconcile for the small band, redraft for the big one — and do NOT
read 70% on a big-function wave as a broken pipeline; that is the expected shape.
- §137a — a gate verdict has a TIMESTAMP. Two "DIFF" ledger entries were STALE (draft rewritten 28
min after the gate ran, never re-gated); both were already byte-perfect. Compare verdict time to
draft mtime before redrafting. Plus two offline oracles an agent built: a FULL RELOCATION RESOLVE
(catches wrong jal/%hi/%lo targets that match_one's mask hides) and a COLLATERAL CHECK (whole-TU
objdump with/without splice). Together they discriminate all three causes of "match_one says MATCH
but the overlay SHA differs" without running make.
- §136f addendum — the collider is often an already-banked SIBLING BELOW the splice; locate it by
arithmetic (draft grows the file N lines, so TU line L reports at L+N).
- cookbook-index 380 -> 382 sections.
- MEASURED BASIS (P30 S7, 144-target campaign): the two-tier rule from the 2026-06-29 A/B left the
~50-120-ins band unassigned, and every wave since defaulted it to Haiku-with-Opus-escalation.
Haiku-direct banked 3/8 on that band while Opus-escalation-after-a-Haiku-miss banked 10/11 — i.e.
Haiku was acting as EXPENSIVE TRIAGE (a wasted draft + a full Opus redraft), not a cheap drafter.
The original A/B only proved parity <=52 ins; everything above that was extrapolation.
- LADDER: haiku <=~50 ins · SONNET ~50-120 · opus >=~120 or escalation · fable5 for a genuinely NEW
wall class only. Never haiku->opus directly; never default a whole wave to opus because the band
"looks hard" (the same extrapolation in the other direction).
- WIRED, not just documented: s7_manifest.py routes by the new thresholds; s7_wave4b.js escalates
haiku->sonnet->opus instead of haiku->opus, and its meta/prose say so.
- Boundaries (~50/~120) are current best estimates — re-measure per-tier from the journal + the gate,
never from the workflow's by_tier (it counts claims, not banks — §136).
- Byte-gate remains the sole arbiter, so a weaker drafter is a throughput risk, never a correctness
risk (G3/P9). cookbook-index 378 -> 379.
- FINAL LANES: reconcile ×5 (5/5) + redraft ×1 (1/1) -> gate BANKED 6/6 -> propagated 50 members
across 28 overlays. **ALL 144 DRAFTED TARGETS BANKED (100%); zero stubs remain in the queue.**
R22 clean-fleet 140/140 (seventh time this session).
FLEET 95.88% fn / 92.9% instr / 86.5% distinct (77,106 unique fns); dedup 1905/0; 0 NON_MATCHING.
- LANE RECORDS: reconcile 15/15 lifetime · redraft 9/9 · §136b closes at 9 FOR 9 (every function
ever ledgered "genuine byte-DIFF" banked on redraft).
- THE CAPTURE CLASSIFIER, third and final defect (§136a): it decided PLUMBING by matching a regex
against cc1's PROSE, and cc1's vocabulary is open-ended — `too many arguments to function` matched
nothing, so a trivially reconcilable function sat UNKNOWN through two gate rounds. Now DERIVES the
class from the closed invariant (did the compile produce an object: `make ... Error N` +
`Deleting file`). Re-running it moved 5 PLUMBING / 1 UNKNOWN -> 5 PLUMBING / 1 DIFF, and BOTH
reclassified functions then banked. Three defects in one small tool in one session — an
unreachable exit-status branch, a missed phrasing, and the prose-matching design behind both —
each SILENTLY MIS-ROUTING REAL WORK. R33 in one line: if an invariant answers it, never re-parse.
- §136f — two declaration sub-cases: (1) a symbol you call may be DEFINED, not just declared, BELOW
your splice point (func_8017D540 is defined 275 lines below as int(int); the draft guessed
void(s32) from a bare jal); (2) an ARITY clash on the symbol you are DEFINING cannot be fixed by a
cast — use the §37/§124 asm-label alias (func_801848DC; in-TU precedent at :8872).
- §136g — TWO INDEX ROUTINGS BYTE-REFUTED (func_801863B4). The index sends BRANCH-POLARITY to §3-T4
(invert) and §34 (zero-byte fence); the agent tested BOTH at zero, read the gcc-2.7.2 source, and
found jump.c:1806 `if (foo) bar; else break` range-swap — which runs long BEFORE reorg, so a fence
CANNOT block it. Real lever: put a label between the if-join and the return label (wrap the loop
in the guard). Also: same-address lh+lhu is MIPS LOAD_EXTEND_OP==ZERO_EXTEND (mips.h:1163), and
combine collapses the pair unless the HImode pseudo has two reaching defs.
REFUTED ROUTINGS ARE RECORDED NEXT TO THE CORRECT ONE — otherwise the next agent re-runs them.
- cookbook-index 375 -> 377 sections (§136 .. §136g earned this session).
- BATCH 3 (37 targets, 41 agents, 2.75M tok -> 35 claimed): gate BANKED 35; family_sweep propagated
305 member-matches / 39 failed across 77 overlays (14 STRUCT skipped by design). 340 instances.
R22 clean-fleet 140/140 (sixth time this session).
FLEET 95.86% fn / 92.9% instr / 86.5% distinct (77,061 unique fns); dedup 1905/0; 0 NON_MATCHING.
- WAVE 4b COMPLETE: b1 32/37 + b2 35/37 + b3 35/37; with wave 4a (30/33) the whole 144-family
B-shape queue that opened this session is worked through — 138 of 144 drafts banked (96%).
- §136e — batch 3's two HONEST NEGATIVES, worth as much as the wins:
(1) §136c SIBLING-FIRST HAS A PRECONDITION. func_801899AC's family has all 13 members still
unmatched and no engine_core.h twin, so there IS no byte-verified sibling and the search is
pure cost. Check a banked sibling EXISTS before spending the greps.
(2) A loop increment in the loop-back DELAY SLOT + a compensating negative addiu is a SOURCE
SHAPE, not a reorg artefact — MIPS1 has no annulling, so reorg CANNOT invent the
compensation. Write `p += 2; if (t == cur) break; ... p -= 2;`. combine's reg_n_sets==1 guard
stops the addiu folding into the following lw. The index's delay-slot entries point at reorg,
which is a dead end for this class.
Plus a new §136-L1 application on the RETURN axis (an over-scoped temp became a global allocno and
swapped $v0/$v1 with the returned local, collapsing the target's `j` + `addu` return).
- COMPOSITION, demonstrated on func_8017D5F4 (46 ins): flat early-returns -> dead-local frame pad ->
s16 locals -> operand order -> 3 register pins -> 2 zero-byte re-ties -> permuter for the last 2.
THE PERMUTER IS THE LAST STEP ON AN ALREADY-PINNED BASE, not the first.
- cookbook-index 374 -> 375 sections. 6 stubs remain; per §136b none is a wall on one attempt.
- THREE LANES: wave 4b batch 2 (37 targets, 46 agents, 3.44M tok -> 35 claimed) + the reconcile lane
on 3 PLUMBING failures (3/3) + a REDRAFT lane on 4 DIFF-ledgered failures (4/4). Combined gate
BANKED 41; family_sweep propagated 431 member-matches / 29 failed across 79 overlays.
103 of 107 drafts banked (96%). R22 clean-fleet 140/140 (fifth time this session).
FLEET 95.77% fn / 92.9% instr / 86.4% distinct (76,824 unique fns); dedup 1905/0; 0 NON_MATCHING.
- §136b CLOSES AT 8/8: every function ledgered "genuine byte-DIFF" banked on redraft — wave 3's
four, the THREE I classified from wave 4a's capture, and one from batch 1. The classifier is
right about what it measures ("this draft compiles clean and differs in bytes"); reading that as
"this function resists matching" is the error. A DIFF verdict is a fact about ONE DRAFT.
- §136a CORRECTED (a reconcile agent refuted me 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. Two of three second-round PLUMBING drafts had a real codegen
residual behind the conflict (func_80188694 DIFF/4 SCHEDULE-REORDER, closed with a §21 zero-byte
re-tie after six other variants failed; func_8018C638 DIFF/6 ADDRESSING/cse). Both agents ran
match_one on the untouched draft FIRST and rejected my premise — which is what §135 asks for.
- §136c SIBLING-FIRST IS A DERIVATION SHORTCUT, not just a conflict fix: grep engine_core.h's
DEFINE_func_* bodies for a byte-verified NEAR-TWIN before deriving from the .s. func_801859D8
found DEFINE_func_80185978 (identical offset chain, 3 differing constants), reused its expression
forms verbatim -> FIRST-DRAFT MATCH, and the twin generalizes to its whole 10-member family.
Search order: near-twin -> banked same-TU sibling -> the .s -> the Ghidra seed LAST (byte-proven
an entirely different body twice this session).
- §136d, four new gcc-2.7.2 levers from the redraft lane, each with its REFUTED axis recorded:
RC-12 $0-add opaque copy (cse.c canonical-copy promotion; do NOT pin the pair to real regs);
jump.c if-then-else -> conditional-overwrite collapse (defeat with TWO SEPARATE CALLS, not a
ternary); fix the STORE not the load for a load hoisted above a constant-address store (the
INDIRECT_REF reshape is the wrong half of the /s lattice, 2 -> 32 mismatched); a branchless flag
is -(a != b) & 0xFF, never a ternary.
- cookbook-index 372 -> 374 sections. Batch 3 staged with all of the above promoted into its prompt.
- WAVE 4b BATCH 1 (37 volume-lane targets, 10-19 members, <=60 ins; wave 4a's §136 idioms promoted
into the drafting prompt per the measured 83%->93% law): 50 agents / 4.35M tokens / 32 min ->
34 claimed MATCH -> gate BANKED 32 -> family_sweep propagated 365 member-matches / 4 failed
across 84 overlays (3 STRUCT skipped by design). 397 function-instances from 37 targets.
- §136b — THE FINDING THAT CHANGES THE BACKLOG: all FOUR functions wave 3 ledgered as "genuine
byte-DIFF" BANKED on redraft. The recorded causes were never codegen:
func_801845B0 a branch to the EPILOGUE misread as an inner early-exit -> the whole tail was
hoisted out of its enclosing if (control-flow misread)
func_80184A94 a declaration conflict on a symbol declared BELOW the splice point; closed by
copying an already-banked family sibling's decl forms verbatim (§71)
func_8017BEBC the cached Ghidra seed was an ENTIRELY DIFFERENT body and the prior draft
followed it; the .s was the only usable source
func_8018480C re-derived clean
=> a DIFF verdict describes THE DRAFT THAT WAS ATTEMPTED, never the function's matchability.
Never retire a target on one; route it to REDRAFT. And re-GATING an unchanged draft is not a
retry — which is exactly why wave 4a's 3 DIFFs stayed stubs through this gate (same bytes
resubmitted); they still owe an actual redraft and are now likely winnable.
Corollary: backlog entries carrying an old closeness/class are stale by construction (P29
measured 77% of stored drafts decayed) — re-verify before valuing one.
- The wave-4b prompt handed each retry its prior verdict EXPLICITLY LABELLED "a data point, not a
verdict — re-derive from the .s". Every retry agent did exactly that and refuted it.
- R22 clean-fleet 140/140 (fourth time this session). FLEET 95.63% fn / 92.8% instr / 86.3% distinct
(76,499 unique fns); dedup 1905/0; C1 240496/240496; 0 NON_MATCHING (G4).
- Orchestration: this batch's workflow script was GENERATED from the manifest files rather than
hand-pasted — transcription had already cost this session one dead launch (args-as-string) and
cost the prior session three agents' time (hand-typed _jr_* paths). Generate the artifact; do not
ask yourself to be careful. cookbook-index 371 -> 372 sections.
- RECONCILE LANE: all 7 PLUMBING failures FIXED and banked (329K tokens — ~13x cheaper than the
drafting wave's 4.44M). Propagated +76 member-matches / 0 failed across 51 overlays.
Wave 4a final: 30/33 heads (91%) + 327 members = 357 function-instances from 33 drafted targets.
- THE CAPTURE CLASSIFICATION WAS EXACTLY PREDICTIVE: all 7 PLUMBING banked, all 3 DIFF stayed stubs
(func_8017E978 / func_80184494 / func_80184960 -> redraft lane, their C is wrong). That is what
makes the ~10-build capture step worth running before any reconcile fan-out. The lane is now
19/19 across three waves.
- EVERY reconciled draft had a HIDDEN SECOND CONFLICT cc1 never reached (it reports only the first)
-> "grep the whole TU in one pass" must be in the RECONCILE prompt, not just the drafting prompt.
One agent additionally assembled the spliced TU and masked-compared its function IN TU CONTEXT
(67/67) — proving the casts byte-neutral in situ, not merely standalone.
- NEW HAZARD, agent-surfaced (§136a corollary): an agent chose a SHARED scratch path, a concurrent
agent overwrote it, and its verification silently compiled ANOTHER agent's TU and returned a
meaningless rc=0. It caught the swap only because the emitted .s lacked its own function. A shared
scratch path yields a CONFIDENT WRONG VERDICT, and no tool fix reaches it — the choice happens
inside the agent, so the PROMPT must mandate a process-unique path. This is the Phase-28
match_one fake-isolation defect recurring one level up.
- R22 clean-fleet 140/140 (third time this session). FLEET 95.52% fn / 92.7% instr / 86.1% distinct
(76,273 unique fns); dedup 1905/0; C1 240496/240496; 0 NON_MATCHING in any default build (G4).
- .run/s7_extra.txt: wave 4a's idioms compiled into the wave-4b drafting prompt (the promotion that
measured 83%->93% between waves 1 and 2).
- S6c (deterministic, ~0 agent tokens): 12 sibling banks across 3 of 9 jr zero-crack families
(func_80178D40 890ins 4/4, func_801734BC 4/4, func_8012ACE0 4/4). The other 6 are ledgered:
5 gate-fail (genuine byte DIFF) + 1 carve-fail (span table starts do not fit the span).
R22 clean-fleet 140/140 over the whole S6c series.
- FINDING: all 12 banks landed in ov_SC07_006/007/010/011 — the four overlays P27 discovered and
P28 made citizens (R36). P28 drained their h_exact backlog via dedup_extend; the jr/h_seq
propagation lane was still owed. R14 GUARD AGAINST OVER-READING IT: the quartet are the top four
overlays by remaining zero-crack residue (2,190-2,355 ins each vs 500-870 typical) but hold only
7% of the 2,114 remaining slots — a per-overlay priority signal, NOT a bulk lever.
- BLOCKER CAPTURE for the 10 wave-4a gate failures -> .run/s7_blockers.json: 7 PLUMBING (all
`conflicting types for func_X`) / 3 genuine byte-DIFF. 70% of "the gate refused" is declaration
paperwork. New tool .run/s7_capture.py (any overlay/any draft dir; reverts the TU in a finally:).
- MY DEFECT, FIXED AND DISTILLED (§136a): the capture tool first classified on the EXIT STATUS, so
its `rc == 0 => byte DIFF` branch was UNREACHABLE — `make build` runs `check`, so a draft that
compiles perfectly and merely differs in bytes also exits non-zero, and all 3 real DIFFs were
filed as "unknown". Now classifies on the OUTPUT ([FAIL]/got/want vs a non-warning error line);
the warning-exclusion matters because `conflicting types` also appears benignly for builtins.
- Also probe-discipline: my first S6c probe reported 1/9, which was 1 bank + 8 CORRECT REFUSALS —
jtbl_family_bank refuses on a dirty config/+src/ (its per-sibling revert restores from HEAD).
Driver now commits between families. A uniform failure across N functions is a statement about
the mechanism, not the functions (§134).
- cookbook-index 364 -> 371 sections, --check green. CURRENT_PHASE SESSION-31 checkpoint refreshed
with the queue re-derived at HEAD (the S30 ROI-floor trigger stays REFUTED — do not close on it).
- WAVE 4a (T6, the 33 high-value B-shape families, 61-120 ins / >=10 members):
33 targets, 46 agents, 4.44M tokens, 29 min -> 29 claimed match_one MATCH.
Whole-binary gate BANKED 23/33 (70%); family_sweep --hseq --band all propagated
251 member-matches across 69 overlays (13 failed, 4 STRUCT skipped by design).
Total 274 function-instances from 33 drafted targets.
- R22 clean-fleet: make clean + extract-all + check-all -> 140 passed, 0 failed of 140.
make report: fn-count 95.49% / instr 92.6% / distinct 85.9% (76,180 unique fns);
dedup 1905 validated / 0 failed; 0 NON_MATCHING in any default build (G4).
- COOKBOOK §136 (R30, distilled in-session from 25 banked functions' index-gap reports):
the wave's finding is that in the 60-120-ins band most "regalloc residuals" are decided
by HOW MANY C LOCALS AND AT WHAT SCOPE, not by register pins (local-alloc.c:472 promotes
any pseudo with REG_N_DEATHS>1 to a global allocno). 19 byte-verified idioms: 6 splitting/
merging rules, 6 type-form rules, 5 scheduling rules refining §135-2/§135-4, 2 declaration-
surface rules. One case explicitly REFUTES the pin as the lever for a redundant copy.
cookbook-index regenerated 364 -> 370 sections, --check green.
- TWO SELF-CORRECTIONS (R37/R14), both caught before they could mislead sizing:
(1) I wrote the tier split from the workflow's by_tier, which counts CLAIMED matches (29)
not banks (23). Derived per-function: Opus-direct 10/14, Haiku-direct 3/8, Opus
escalation-after-Haiku-miss 10/11. The operative number is the 10-of-11 rescue rate;
on this band Haiku is triage, not a substitute (it is == Opus only at <=50 ins).
(2) The gate printed "1/1 banked FAILED: func_X" on single-draft groups (the known
double-list artifact) -> bank set DERIVED from corpus.stubs instead. Totals agreed.
- TOOLING: the wave scripts now parse args-as-string and assert Array.isArray, so the
roadmap's standing "args must be an array" gotcha cannot silently kill a future wave
(it killed wave 4a's first launch in 60ms with 0 agents).
- tools-health green + fail-closed before matching (corpus+resident 0 PHANTOM/0 TRUNCATED,
audit-binaries 140/140 citizens, cdecl, report/lint/dedup).
- Fleet 95.42% fn / 92.4% instr / 85.5% distinct; phase arc +3.42 / +4.9 / +7.5pp; R22 140/140 x9.
- ~3,500 members in 11 commits, from TWO engines that both paid: deterministic tooling repair
(same population scored 842 pre-fix vs 1,582 post-fix; cookbook §134) and two-lane agent waves
(bank rate 83->93->89%, reconcile lane 12/12; cookbook §135).
- Queue RE-DERIVED at HEAD after the final bank (not carried forward): the >=20-member/<=60-ins
B-shape is EXHAUSTED; 33 families/34,895 ins remain at 61-120 ins and 111/33,554 at 10-19 members;
S6c's 9 jr families (9,364 ins) still untouched. Unmatched fleet-wide 15,161 instances/935,927 ins.
- Flags for a fresh session: (1) the T6 ROI-floor trigger is REFUTED — do not close P30 on it;
(2) measured token economics — deterministic ~0 tokens/+0.5pp vs wave-3 4.1M/+0.3pp; probe the
cheap lever before funding the expensive one.
Distilled from ~100 agent-drafted functions gated whole-binary across three waves; each idiom CLOSED
a specific residual, none is a hypothesis.
CODEGEN:
1. UNSIGNED switch index => pure equality chain — for an unsigned index the case-0 leaf satisfies
node_has_low_bound (0==TYPE_MIN) so emit_case_nodes drops the range test entirely.
2. ARRAY_REF vs INDIRECT_REF changes ALIASING hence SCHEDULING — a[i] sets MEM_IN_STRUCT_P and
true_dependence() drops the dependence vs a constant-address store, so the load hoists.
A '4-ins scheduling residual' that is really a type-form choice.
3. A constant store with the top bit set in the STORED width needs an UNSIGNED destination
(u16 -> ori via force_fit_type; s16 -> sign-extended fold -> addiu).
4. The list scheduler PRESERVES relative order of disambiguable stores — a store written late SINKS.
Move it earlier in SOURCE. Closed 9 mismatches with no permuter.
5. A short loop counter blocks strength reduction on array indexing; the original walked pointers.
6. Frame size off by a constant => DEAD LOCALS (every diff is an sp displacement of one delta).
INTEGRATION (what decides whether a byte-correct draft BANKS):
7. match_one MATCH != a bank (83%/93%/71%->89% survived the gate across the three waves).
8. cc1 reports only the FIRST conflict — grep the whole TU for every symbol in one pass (one draft
had SIX bad prototypes, two BELOW the splice point).
9. An INTERIOR address has no symbol (D_801DA0F0 is +0x6C into D_801DA084) -> undefined reference
at LINK, not a compile error.
10. Never redeclare a C-library name (one TU declares memcpy THREE times, incompatibly).
WAVE SHAPE: two lanes; the reconcile lane is 12/12 across two waves because the orchestrator captures
the compiler error BEFORE the fan-out. Promote wave-N's Opus discoveries into wave-N+1's cheap-tier
prompt (83->93%). Paste args from a DERIVED manifest. If N reconcile targets share ONE TU, forbid
agent builds. An agent that rejects your premise is working correctly.
- 38 targets / 44,297 templ ins, model-routed (Haiku <=89 + Opus escalation, Opus direct >=90):
52 agents, ~4.1M tokens -> gate 27/38 (71%). All 11 failures captured + classified: 8 declaration/
link plumbing, 3 genuine byte-DIFF. An 8-agent Opus reconcile wave fixed 8/8 (7 banked) ->
wave-3 total 34/38 = 89%. Propagation +639 members / 1 failed / 83 overlays.
R22 clean-fleet 140/140. Fleet 95.42% fn / 92.4% instr / 85.5% distinct.
- DESIGN (S27 law applied BEFORE it bit): six of eight reconcile targets share ONE TU, so this wave
FORBADE agents any build — six concurrent splice-builds would have clobbered a tracked file.
- THE AGENTS OUT-DIAGNOSED MY BLOCKERS:
* func_801848B0 — an agent REJECTED MY PREMISE: I said byte-correct + decl-blocked; it ran
match_one first, found a real 1-ins DIFF, fixed both. R14 aimed back at me, correctly.
* func_8017C5F0 — the "invented symbol" D_801DA0F0 is an INTERIOR ADDRESS: offset 0x6C into
D_801DA084 (0x801DA084..0x801DA103). The lui/addiu pair builds an interior pointer.
* func_8018A860 — the TU declares memcpy THREE times with incompatible signatures, with a latent
byte bug behind it. One symbol declared three ways is a defect awaiting the next draft.
- Carried (4): func_80184A94 (match_one MATCH, gate-refused) + 3 genuine byte-DIFFs
(func_801845B0, func_8017BEBC@ov_SC02_026, func_8018480C).
- Fleet 95.23% fn / 92.1% instr / 85.0% distinct; phase arc +3.23 / +4.6 / +7.0pp; R22 140/140 x6.
- S6 was scoped as a harvest and delivered as a TOOLING REPAIR: 6 defects found, 5 fixed, all of
them a multi-line C construct read one line at a time (or a guard firing on a condition it never
verified). Pre-fix tool scored the population at 842; post-fix, 1,582. Cookbook §134.
- BLOCKS T5: the checklist's ROI-floor trigger ('after S2 the x138 era ENDS') 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.
- Live queue re-derived at HEAD: the >=20-member/<=60-ins vein is EXHAUSTED (1 family); 133 families
/48,689 ins at 10-19 members and 11 families/25,742 ins at 61-120 ins remain, plus S6c's 9 jr
families (9,364 ins) untouched.
- 15 targets (11 fresh Haiku + 4 gate-failed reconciles on Opus), 15 agents, ~0.74M tokens.
Gate banked 14/15 (93%) vs wave 1's 20/24 (83%); ALL 4 RECONCILES BANKED.
Propagation +328 members / 0 failed / 76 overlays. R22 clean-fleet 140/140.
Fleet 95.23% fn-count / 92.1% instr / 85.0% distinct (phase opened 92.00 / 87.5 / 78.0).
- THE 83->93% CAME FROM THREE FIXES, ONE PER WAVE-1 FAILURE (the S27 finding reproducing):
(1) args pasted from the DERIVED manifest, never typed — all 30 paths verified on disk first;
(2) blocker-capture BEFORE the reconcile fan-out (S29 law: agents cannot run the gate, so a
match_one-MATCH draft dying on `conflicting types` reads to them as a codegen wall) —
each got the exact symbol+line plus the two byte-neutral levers;
(3) wave-1's Opus DISCOVERIES became wave-2's Haiku INSTRUCTIONS (ori-vs-addiu unsigned
destination; store-sinking scheduler order).
- THE RECONCILES OUT-DIAGNOSED MY CAPTURE: func_80189B78's error named ONE symbol; the agent found
SIX invented prototypes, two AFTER the splice point where cc1 had not yet reached — all fixed by
copying the TU's decls verbatim + casting at the call site, zero bytes changed. func_8018584C had
lever (A) blocked in BOTH directions (the draft must also compile standalone for match_one) and
closed with the DATA form of the asm-label alias. func_80180A4C was one character class (s32[] vs
the TU's u8[], declared 11 lines after the splice point).
- Carried: func_80189C4C (the one agent that returned no structured result; gate refused).
- POOL (derived from the regenerated map): 36 families / 28,829 templatable ins, 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. Hand-calibrated 3/3 one-shot before scaling (Phase-15/18 discipline).
- WAVE (ultracode; Haiku drafters + Opus escalation, 24 targets): 31 agents, 0 errors, ~2.0M tokens,
12.5 min. Agents claimed 24/24 MATCH; the whole-binary gate banked 20/24 (83%); propagation
+524 members / 0 failed / 91 overlays. 17 of 20 banks were HAIKU, 3 Opus — the
cheap-tier-ab-validated call (Haiku == Opus at <=~50 ins, ~4.8x cheaper) held on real work.
- WHAT OPUS BOUGHT: (1) a `sh` of a constant with the stored width's top bit set needs a u16
destination — via s16 gcc folds it sign-extended and li emits addiu, via u16 force_fit_type keeps
it positive and li emits ori; (2) a schedule-reorder closed by STATEMENT ORDER not the permuter
(gcc's list scheduler preserves relative order of disambiguable stores); (3) three loose-typing
fn-ptr casts a cheap drafter had misread as delay-slot/permuter residuals.
- MY ERROR (R37/R14): I generated the manifest to .run/s6f_wave_targets.json then HAND-TRANSCRIBED
the args into the Workflow call, pattern-filling _jr_8017BEBC across overlays where no such split
exists (corpus.stubs says _jr_8017AE2C). Three agents lost time rediscovering real paths. The gate
driver written after (.run/s6f_gate.py) DERIVES every TU/split from corpus.stubs and asserts
nothing. Assert nothing you can derive.
- The 24->20 gap is the known match_one->gate gap (standalone compile cannot see a TU decl conflict;
Phase 19 measured 88-92% -> 60-71%). 4 carried: func_8018584C, func_80180A4C, func_8017CC80,
func_80189B78.
- R22 clean-fleet 140/140. Fleet 95.13% fn-count / 92.0% instr / 84.9% distinct
(phase opened 92.00 / 87.5 / 78.0).
- func_8017E934 (ov_SC05_001, 29 ins x65): hand-drafted off the .s, match_one MATCH first try,
whole-binary gate byte-identical, propagated 64 members / 0 failed across 63 overlays.
- That makes the B-shaped lane 3-for-3 one-shot (func_8017CDD8 17ins, func_8017CE7C 16ins,
func_8017E934 29ins) for ~0 agent tokens = 330 member-matches from 62 instructions of C.
- 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 ever reach them) with >=20 members
and <=60 ins, non-jr. NOT ONE exemplar is in ov_SC01_077 — they are invisible to exactly the
two habits this phase already corrected (the ov077-source default and --band substantial).
- The calibrated recipe, now the wave prompt: read the .s as ground truth (a cached Ghidra-C seed
was measured this session decompiling a DIFFERENT body) -> conform every callee decl to what the
TU already says (the PLUMBING class: standalone-MATCH C is gate-REJECTED as `conflicting types`
when it redeclares a callee the TU defines as (void)) -> match_one -> whole-binary gate.
- R22 clean-fleet 140/140; fleet 94.96% fn-count / 91.9% instr / 84.7% distinct.
- A: frontier regen at HEAD (sigs + family_hseq) before pricing anything (R35). Also the reason
it was needed: .run/hseq_verified.*.txt has accumulated 22,841 files across every sweep ever
run, so any per-family analysis globbing them over-counts; the regenerated map derives state
from sigs + corpus.stubs (R33), which is the authority.
- B / THE FINDING (third §133-class miss in a row): the S29 checkpoint's structural signal
"after S2 the x138 era ENDS — those are the last two crackable fleet-wide families" — the stated
TRIGGER for the phase close — is wrong. Two fresh-crack families with >=126 members were open:
0x8017cdd8 ov_SC02_039 17 ins x 142 members PURE
0x8017ce7c ov_SC03_114 16 ins x 126 members IMM
Both kind=modal (NO member matched anywhere, so no sweep could reach them) and neither exemplar
in ov_SC01_077 — 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. First gate
attempt failed PLUMBING (not DIFF): the draft declared `extern void func_8017CFCC(s32 a0)` while
the TU DEFINES `void func_8017CFCC(void)` — the target passes $a0 only because the caller's
incoming argument still sits in the register (loose typing). Byte-true C calls it with no
argument; re-verified MATCH, gated byte-identical, propagated 266 members / 0 failed / 118 overlays.
- R14 on the seed: the cached Ghidra-C for func_8017CE7C decompiled an entirely DIFFERENT body
(three calls absent from the asm). Reading the .s is what made it one-shot.
- R22 clean-fleet 140/140. Fleet 94.88->94.96% fn-count, 91.9% instr, 84.6->84.7% distinct.
- D6: hseq_sweep took the tu_snapshots snapshot UNCONDITIONALLY, one line before the `if nfix:`
that decides whether to edit. A TU that normalize_self_decls merely INSPECTED was therefore
registered, and the phase-2 MISMATCH backstop attributed ANY group failure to a "self-decl edit"
that was never made -> revert + `0/N banked`. Measured: 909 of 909 groups took that branch while
NSD actually fires on ~25% of members (3 of 12 probed). The §103 tu-scope path below has always
snapshotted inside `if _rep["moved"]:`; NSD now matches it.
- After the fix: NON-NEUTRAL 909 -> 303 (consistent with the fire rate) and STILL 0 banked — the 606
groups that now take the normal path bank nothing, so the lever's verdict is REAL, not an artifact:
this residue is not self-decl-conflict-bound. Lever measured, closed, zero.
- R14 on my own conclusion: I byte-measured a firing case instead of trusting the backstop —
func_80162CCC/ov_SC01_000 builds to 9052dc0e... WITH and WITHOUT the NSD edit (byte-NEUTRAL), so
the surviving 303 verdicts are wrong too (likely accumulated multi-member edits in one TU).
Logged as a named open item, not chased: the lever yields 0 either way.
- The tell, twice in one session (§134): a 100% rate is a property of the mechanism, not of 1,622
different functions. Three earlier sweeps over the same population reported 0 NON-NEUTRAL.
- ONE root cause, four faces (cookbook §134): extract_unit's preamble scanner reads C
one line at a time, so every construct that WRAPS was misread.
D1 the {-guard fired on a documentation comment mentioning a brace -> carry truncated
mid-comment -> `parse error before 'the'`.
D2 _def_head_at's "param list continues -> ANSI definition" fallback accepted a WRAPPED
DECLARATION as a definition head -> a 16-line fragment with no body, closed by a brace
pair inside a comment -> a silent 0/137 that reads exactly like a compiler wall.
D5 the backscan met a multi-line typedef's CLOSING line `} T;` first and stopped -> the
type never travelled -> `T undeclared` across 17 families / 24,332 templatable ins.
(The code comment claimed they "route through the engine_types.h lift"; measured, they
routed nowhere.)
D4 wrapped __asm__("func_...") alias invisible to a single-line regex — MEASURED (1 exemplar,
3,288 ins, second blocker behind it) and deliberately NOT fixed; it now returns None so the
sweep reports a VISIBLE skip instead of 137 silent failures (R32).
- Fixes: _def_head_at(ln, idx, more=()) lookahead (no-lookahead keeps the historical answer);
{-guard exempts comment-only lines + an R32 dangling-comment backstop; forward brace scan
counts over cdecl._mask (R33, one masking oracle); _typedef_block_start carries whole blocks.
- BLAST RADIUS (R14): extract_unit diffed vs the pre-fix tool over all 181 zero-crack exemplars
-> 157 byte-IDENTICAL, 24 changed, all in the intended direction.
- PAYOFF: D1+D2 +323 members from families that banked ZERO; D5 +417 incl. func_8012B77C 139/139
(8,062 ins) and func_80128C98 137/275. S6 total 1,582 members (pre-fix tool scored 842).
- R22 clean-fleet 140/140. Fleet 94.43->94.88% fn-count, 91.4->91.9% instr, 84.0->84.6% distinct.
- TELL worth keeping (§134): bimodal bank rates (57 all / 52 zero / 8 partial) are a TOOLING
signature, not codegen. Probe one member and read one compiler error before writing a family off.
- family_sweep --hseq --band all (no --source override), 117 pre-classified families:
staged 2735 drafts / 1239 groups / 0 skips -> BANKED 842, R22 clean-fleet 140/140.
Fleet 94.43->94.67% fn-count, 91.4->91.6% instr, 84.0->84.5% distinct.
- R37 setup: the 190 zero-crack families decomposed with ZERO builds — 117 sweepable /
17 §94-§100 multi-line-typedef-blocked (24,332 ins incl. the 275-member 0x80128c98) /
9 jr (§53 carve path) / 47 remap-REFUSED.
- R14 PREMISE CORRECTION: the "every sweep passed --source ov_SC01_077" mechanism in the
post-wave checkpoint is wrong (that IS the default and overrides nothing). The real gate
was --band substantial: only 13 of 181 non-jr families are substantial. --band all is it.
- FINDING: the residue is bimodal — 57 families ALL-banked, 52 ZERO, 8 partial — the shape
of a per-family blocker, not per-member codegen. 8 probed via the new generic
.run/s6_diag.py (one build per family, not 137): 7 of 8 are declaration/carry plumbing.
Two proven family_remap defects located at source (D1 comment-line {-guard truncating the
preamble carry; D2 _def_head_at accepting a wrapped multi-line DECLARATION as a def head).
Frontier at HEAD after the 2,192-member propagation: overlays 94.7% fn / 91.8% instr / 85.0%
distinct; 13,658 distinct classes remain.
- S4 PINS RETIRED WITHOUT EXECUTION: planned at 44,279 ins from worklist.md (h_exact-priced,
x138/fn); family-map priced after the waves it is 24 fns / 101 ins. The same mis-pricing that
under-valued the frontier head by 138x over-valued this by ~440x.
- S6 ADDED, highest ROI: 190 zero-crack families / 129,997 ins, ~0 agent tokens. 106 of them have
exemplars OUTSIDE ov_SC01_077, and every sweep this project has run passed --source ov_SC01_077 —
structurally unreachable, not walled. Probe-confirmed on func_8012B77C (defined in ov_SC07_006,
still a stub in ov_SC01_000).
- S5 re-derived as the x10-99 band: 243 families / 239,058 ins.
The reconcile lane's second pass. Every one match_one-verified by me before gating, then
whole-binary byte-gated: 11 verified / 0 failed.
Escapes used (no header edit anywhere): the §37/§124 ASM-LABEL ALIAS for return/arity conflicts on
the function itself (7 of 11), and conform-the-decl + cast-at-use for conflicts on OTHER symbols —
func_80142A80, RotTransSV, func_80146C3C (4 of 11). Agents also proved each fix WITHOUT the gate by
compiling the real TU with the body spliced on a .run/ copy.
R14 on my own capture: the ':5201/:5219/:5223/:5228 note:' lines I fed the agents were pre-existing
SHB macro-redefinition NOISE, not the conflict — my blocker filter let 'note:' lines through and I
mislabelled one target as a redefinition on that basis. The agents caught it and said so.
Banked: func_80170CF0 func_801708B0 + the six gate-blocked wave-1 survivors (func_80151664
func_801376E8 func_80176144 func_8012EFB8 func_80146AFC func_8014E5B4). Every one match_one-verified
by me before gating (19/19), then whole-binary byte-gated.
The reconcile lane's whole premise held: agents cannot run the gate, so I captured each blocker with
a splice-build-revert first and embedded the exact compiler error in the brief. Three of the six
conflicts were on a DIFFERENT symbol than the function (D_800AF634, D_8011D030, func_80153C18) —
invisible in the summary, decisive in the brief. All six cleared WITHOUT a header edit, via the
§37/§124 asm-label alias (aF<ADDR> __asm__("func_<ADDR>")) or conform-the-decl + cast-at-use.
- 9 banked heads propagated: 1,096 non-jr member-matches (family_sweep --hseq --band all, 0 failed)
+ 137 (func_80159A20, jr) + 137 (func_801549F8, jr)
- func_80176734 (371 ins, the largest single item in the frontier) banked + propagated
- FLEET 93.81% fn / 90.9% instr / 83.9% distinct; dedup 1905/0; 0 NON_MATCHING (G4)
- cookbook §132b (--span-rel: the already-matched owner that is ITSELF multi-switch) and §133
(the DEFAULT-FILTER class — three times in one session a tool silently answered a narrower
question than the one asked: my own >=80-ins cut, worklist's h_exact pricing, --band substantial)
Drew T