- 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)
Structure-first crack (agent, 371/371 byte-exact, independently re-verified by match_one before
gating). Levers were type- and placement-driven rather than pins: u8 locals produce the andi masks
(a QImode result sends the arithmetic arms through force_to_mode while the comparison keeps its
zero_extend); cross-BB placement defeats combine (LOG_LINKS are per-BB); a DUPLICATED store keeps
the following re-read in a fresh EBB so it stays a real lbu; and a deliberately-unused u8 dum[8]
because the target's .frame says vars=8 with no spill in the body — the original had a dead local.
Only non-call-spanning pins used, so the body is x137-safe (§44).
Family: 371 ins x 138 = 51,198 templatable ins — the single largest item on the board.
func_8016706C func_80131A34 func_80161A90 func_801549F8 func_8014C4AC — each match_one-verified
by me before gating (R14), then whole-binary byte-gated. func_8014C4AC is the standout: the agent
resolved its 'conflicting types' with the §37/§124 ASM-LABEL ALIAS (s32 aF8014C4AC(...) __asm__
("func_8014C4AC")) instead of a header edit — exactly the alternative to the fleet-sed that failed
earlier today. 9 remain blocked on declaration conflicts.
Chartered as a diagnostic ('classify; build a fix only if >=3 share a class'). Result: no cheap
shared class, so nothing was scaled — the correct outcome for the charter.
- 30 x138 family heads carry a stored draft = 182,850 templatable ins (plan estimated ~12 drafts)
- only 7 of 30 still verify; 23 have DECAYED (LENGTH-DRIFT/SIZE-MISMATCH/WIDTH/ADDRESSING)
=> a stored draft's recorded closeness is NOT a current fact (extends A10/T1a)
- of the 7: 1 banked clean (func_801754A8, 37 ins x138); 6 hit "conflicting types", and
gate_stage's ladder recovered 0/6 -> 1 is the §30#2 return-widen class, 5 are PARAMETER
conflicts (the Phase-16 def-side loose-typing wall)
- the §30#2 attempt REVERTED (R14): the draft's note claimed no split .c carries its own decl —
the gate named two that do; a sed over all of them touched 2,046 files and still was not green.
That is the 'bulk header edits BREAK builds' pattern; a fleet-wide decl reconcile needs a gated
TOOL, not a sed. Exemplar re-verified d19c9580 after revert.
The stored backlog draft was 2 mismatches from perfect (88/88, DELAY-SLOT) for one reason its own
notes had already recorded: the definition must return VOID, not the canonical s32. An s32 return
keeps $v0 live-out at the epilogue, so dbr refuses to steal the loop-top addiu $v0,$zero,0x1858
into the loop-back bne delay slot -> nop + a branch target one insn early. void -> steal -> MATCH.
This is the one place §3a-1's 'void->s32 is byte-neutral' claim is FALSE (S27 finding, now banked).
Applied with the draft's own //@EDIT directive: 5 in-TU 'extern s32 func_8016EC0C' decls flipped
to void (every call site already casts the fn pointer, so no caller changes). ov_SC01_077
d19c9580 BYTE-IDENTICAL. Family: 88 ins × 138 = 12,144 templatable ins; sweep next.
- head func_8014032C 137/137 (25,071 ins, --span-rel §132b) + jr tier 46 members incl.
func_8017BEBC 13/13 (12,376), func_8015A3C8 6/6, func_8015AE2C 4/4, func_8017A4AC 4/4,
func_8013FFD8 9/10 + non-jr pass 3.
- MY ROUTING ERROR (recorded): pass 1 ran all 28 families through jtbl_family_bank; 13 are NOT
jr functions, so they carve-failed by construction — §123's own law ('propagate a family with
the tool its TIER needs'), which I had quoted in the task description. Re-routed via
family_sweep --hseq: 3 banked / 38 failed => that residue is the genuine stage-but-DIFF class.
- MEASURED: 13 of 29 zero-crack families have remaining members ONLY in the 4 P27-onboarded SC07
overlays (18,856 ins) — not a stub-count gap; they simply missed every sweep that predates them.
- R22 clean-fleet 140/140. Fleet 93.38% fn / 90.0% instr / 82.4% distinct; dedup 1905/0.
Phase arc: +1.38pp fn / +2.5pp instr / +4.4pp distinct.
Drew T