mirror of
https://github.com/Druthulu/BFM-decomp
synced 2026-09-26 21:36:06 -04:00
3daa647bb35b094e35c4b2788e16faebe15cb8dc
608 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Drew T
|
3daa647bb3 |
docs(phase-30 S11): cookbook §138 + SESSION-33 checkpoint
§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). |
||
|
Drew T
|
62042f65ca |
fix(phase-30 S11): multi-line-comment blindness in dedup_propagate; func_8012A598 x138
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). |
||
|
Drew T
|
c7ad41c8a3 |
feat(phase-30 T6/S11): the propagation lag — EXTEND 31/36, and the PROPAGATE head measured
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`. |
||
|
Drew T
|
1859266d60 |
feat(phase-30 S10): Sonnet wave — 13 heads + 57 members; the §136i ~120 boundary is too LOW
- 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). |
||
|
Drew T
|
cf10d28459 |
feat(phase-30 S9): x2-9 calibration wave — 22/25 banked + 67 members; the grind rate is MEASURED
- 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.
|
||
|
Drew T
|
a4bc49a23d |
feat(phase-30 S8): the x10-99 band closes 23/23; §137 makes REGALLOC-PERM arithmetic, not a permuter job
- 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.
|
||
|
Drew T
|
18fc50d0f8 |
docs(phase-30): §136i — insert SONNET between Haiku and Opus in the drafter ladder (Drew 2026-08-03)
- 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. |
||
|
Drew T
|
e8a57b13fa | docs(phase-30 S8): CORRECTION §136h — the zero-crack pool is residue, not a lever (1 bank / 1,781); my R37 violation | ||
|
Drew T
|
1b8f26113c |
feat(phase-30 S7): close the B-shape queue — 144/144 drafts banked; §136b closes 9/9
- 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). |
||
|
Drew T
|
b61d805b8b |
feat(phase-30 S7): wave 4b batch 3 — 35 heads + 305 members; the 144-family B-shape queue is worked
- 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.
|
||
|
Drew T
|
7f70b6850a |
feat(phase-30 S7): batch 2 + reconcile + redraft — 41 heads + 431 members; §136b closes 8/8
- 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.
|
||
|
Drew T
|
cc3c49d7af |
feat(phase-30 S7): wave 4b batch 1 — 32 heads + 365 members; §136b (a DIFF verdict is not evidence)
- 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.
|
||
|
Drew T
|
d00dfe363b |
feat(phase-30 S7): reconcile lane 7/7 — wave 4a closes at 30/33 (91%), +76 members
- 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). |
||
|
Drew T
|
fdb5813fc1 |
docs(phase-30 S7): S6c banked ×12 (all in the P27 SC07 quartet); blockers classified 7/3; §136a
- 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). |
||
|
Drew T
|
09d96b1531 |
feat(phase-30 S7): wave 4a — 23 heads + 251 members banked ×N; cookbook §136 (the local-variable lever)
- 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).
|
||
|
Drew T
|
0ffb2c04d7 | docs: regenerate family-hseq digest at HEAD (the checkpoint's queue is derived from it) | ||
|
Drew T
|
bfbcb86b3d |
docs(cookbook §135): six byte-verified gcc-2.7.2 idioms + the two-lane wave shape (P30 S6f-h)
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. |
||
|
Drew T
|
6fe9b66f2d |
feat(phase-30 S6h): wave 3 — 34/38 banked, +639 members, reconcile lane now 12/12 (R22 140/140)
- 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).
|
||
|
Drew T
|
372dc62d35 |
feat(phase-30 S6g): wave 2 — 93% bank rate (was 83%), all 4 reconciles closed, +342 members (R22 140/140)
- 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).
|
||
|
Drew T
|
6e181db771 |
feat(phase-30 S6f): B-shaped wave — Haiku drafts, Opus closes, +544 members (R22 140/140)
- 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). |
||
|
Drew T
|
e6cec30736 |
feat(phase-30 S6f): calibrate the B-shaped vein — 3/3 one-shot by hand, +65 members (R22 140/140)
- 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. |
||
|
Drew T
|
381cd56d40 |
feat(phase-30 B): the x138 era was NOT over — 2 tiny cracks -> 268 members (R22 140/140)
- 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.
|
||
|
Drew T
|
39558b2991 |
fix(phase-30 S6b): MULTI-LINE BLINDNESS in family_remap — 4 faces, 3 fixed; +740 members (R22 140/140)
- 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.
|
||
|
Drew T
|
8a519addf7 |
feat(phase-30 S6a): source-agnostic zero-crack sweep — 842 members banked (R22 140/140)
- 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).
|
||
|
Drew T
|
7e0caf3d25 |
docs(phase-30): post-wave frontier re-derived + TWO pricing corrections (§133 both ways)
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. |
||
|
Drew T
|
21ccb171ac |
feat(phase-30 UC): wave-2 propagation — 2,192 members, fleet 91.4% instr (R22 140/140)
19/19 wave-2 heads banked and propagated: 2,192 member-matches / 411 stage-but-DIFF residue (each individually gate-rejected and reverted). FLEET 94.43% fn / 91.4% instr / 84.0% distinct; dedup 1905/0; 0 NON_MATCHING (G4). Session arc: 93.25->94.43 fn / 89.2->91.4 instr / 80.5->84.0 distinct. Phase arc: 92.00->94.43 fn / 87.5->91.4 instr / 78.0->84.0 distinct. |
||
|
Drew T
|
1a1463b1c6 |
feat(phase-30 UC): wave-1 propagation — 1,370 member instances, fleet 90.9% instr (R22 140/140)
- 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
|
4a23c82a33 | feat(phase-30 S2): func_8016EC0C x138 complete — 137/137 siblings, fleet 90.1% instr (R22 140/140) | ||
|
Drew T
|
56210fdadd |
feat(phase-30 S1): zero-crack tier — 186 members banked; fleet crosses 90% instr
- 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
|
bdb0b0f60a | docs(phase-30 S1): digests after func_8014032C x137 — fleet 89.8% instr / 82.0% distinct (R22 140/140) | ||
|
Drew T
|
e64b3cbe41 |
docs(phase-30): T6 approved — P30 stays open; the measured-frontier continuation (S1-S5)
Drew's call (2026-08-01, P5d in-phase re-plan): gate 2 was reached and deliberately NOT taken — closing now would strand roadmap-v2 bucket W3 (the overlay family mass) with no owner phase (P31 = scope-complete/main/resident, P32 = walls/behemoths). Order derived from the S29 frontier regen, ranked by TEMPLATABLE weight: S1 zero-crack propagation (29 families / 67,470 ins, ~0 agent tokens) S2 the LAST two reach-138 fresh cracks (func_80176734 51,198 + func_8016EC0C 12,144) S3 close=0 stored drafts as a DIAGNOSTIC pass (not a blind re-sweep) S4 PINS bounded wave (14 fns / 44,279 ins) S5 the x10-133 mid-multiplicity families (142,527 ins) Excluded: the 2 GIANT walls (P32), the x2-9 mass, the x1 singleton residue. THE PRICING FINDING (R14/R35): worklist.md ranks by h_exact reach, so a per-location PURE family is priced x1 — under-pricing the frontier head by up to 138x. Byte-proof: S29's pair was priced 272 and 198 ins and delivered 37,536 + 27,324. func_80176734 (the single largest item on the board) sits at rank ~50 in worklist.md. Rank family work by .run/family_hseq.json. THE STRUCTURAL SIGNAL: after S2 the x138 era ENDS (last two crackable fleet-wide families); everything after is <=133 members and mostly <=9. That cost-per-point rise, not a session count, is P30's honest ROI floor and T5's trigger. |
||
|
Drew T
|
34c667cc26 |
docs(phase-30): T5 pre-close — P7 checkbox walk (T1/T3 closed with measured verdicts) + fresh frontier
- tools-health OK: sigs regenerated post-bank; corpus(+resident) 0 PHANTOM/0 TRUNCATED; cdecl; audit-binaries 140/140 citizens (R36); report(lint+dedup) 1905/0; cookbook-index 357 sections. - Fresh overlay frontier at HEAD: 93.6% fn / 90.1% instr / 82.5% distinct; unmatched 22,550 instances / 1,298,980 ins / 15,029 distinct classes -> 2,414 families + 3,767 singletons (472 substantial / 543,901 templatable ins; 29 zero-crack). - T1 ticked with its honest scope: delivered as T1a (+18 banked, 16% vs the S16 39% prior which did NOT generalize); the ~90 integration-decayed drafts route to T3 redraft lanes (A10). - T3 ticked with a PER-LANE verdict: Lane B (top-mass) pays and is not exhausted; Lane C (x2-reach cached tail) is at the floor (1.33M tokens -> 12 banks -> +0.00pp). The ROI floor is a lane property, not a phase property. |
||
|
Drew T
|
fc307418a5 |
docs(phase-30): the jr-pair sweep landed 137/137 ×2 — §132a --like over-transfer + fleet 89.6% instr
- 2 × 138 = 276 function-instances banked (exemplar + 137 siblings each); the -O0 cluster is now COMPLETE fleet-wide (these were the last open stubs in every overlay's _o0* region) - §132a: --like matches by subseg ROLE NAME; ov_SC07_010 shares the exemplar's _o0 role (the only other overlay so named — the other 136 are _o0c, whose role never matched, which is the only reason the sweep worked at all). Six derived starts for three emitted tables; guard shipped. - R22 clean-fleet 140/140. Fleet 93.33% fn-count / 89.6% instr / 81.6% distinct (+260 unique fns); dedup 1905/0; 0 NON_MATCHING (G4). Phase arc: 92.00->93.33 / 87.5->89.6 / 78.0->81.6. |
||
|
Drew T
|
b9efe66f91 |
fix(phase-30): the JR-PAIR "wall" was TWO instrument defects — pair banked, class retired
S28 ledgered `JR-PAIR-IN-ONE-O0-OBJECT` (two jr fns matched in one -O0 object => a clean build that cannot link: `undefined reference to $L105` + `func_8013C938`) with §81 step 1 (isolate one into its own code subseg) as the untested escape. BOTH the class and the escape are REFUTED — no isolation, no compiler wall, both fns banked from a genuinely clean fleet. The 4th consecutive "structural wall" to resolve to our own tooling (§124/§125/§126/§131). - DEFECT 1 (tools/jtbl_carve.py): 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 2nd owner is MATCHED so extract pruned the stub .s naming its table. The single-table- predecessor inference derived 3 starts where the object emits 4 tables -> JTBL_PADS 0,4,4 -> jtbl_rodata_pads refused mid-stream, correctly. FIX: R32 coverage assertion + payload recovery at the single choke point (spec_from_starts) — 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 structure is known (the 134 sibling _o0c spans carry tables=+0x0,+0x70). Honest limit: tight (0-pad) boundaries stay unrecoverable but fail LOUD via the filter's count guard — never silent. - DEFECT 2 (Makefile): no .DELETE_ON_ERROR, so `as` (a pipeline consumer) left a TRUNCATED .o on disk — 12 of 16 T func_, undefined $L57/$L59/$L63/$L75/$L76 — newer than its .c, and the NEXT build linked the corpse. That IS the S28 link error, one build downstream of a loud, correct compile error. Negative-control-proven on a scratch invocation. - BANKED: func_8013B83C (272 ins) + func_8013BD74 (198 ins) in ov_SC01_077 (d19c9580). Byte proof: 4 tables 0x801D8254/828C/82FC/836C (13/27/27/27 entries, each zero-pad separated); span 0xb00fc..0xb0280 = 388 B = 52+4+108+4+108+4+108 exactly; spec 0,4,4,4. - R22 clean-fleet (make clean + extract-all + check-all): 140 passed, 0 failed of 140. The incremental result was NOT trusted (§130). Fleet 93.25% fn-count / 89.2% instr / 80.5% distinct; dedup 1905/0; 0 NON_MATCHING (G4). - cookbook §132 + index (356 sections): the mechanism, the fingerprint (an undefined $L<n> in a LINK error is a truncated object, never codegen), the 30-second standalone-TU ladder that named the 4th table owner before any build, and the transferable rule — a fail-loud guard is only as trustworthy as the artifact hygiene around it. |
||
|
Drew T
|
b58fd82068 |
docs(phase-30): SS131 the jtbl OVER-SPAN + checkpoint — #9 SOLVED, JTBL-CARVE-BREAKS-BYTES retired
SS131: `sltiu N` is ground truth in BOTH directions. jtbl_range already EXTENDS a span the dlabel cut short and WARNS when a span is shorter than the bound, but had no clamp for a span too LONG for a NON-ZERO reason — and the trailing trim only removes ZERO words, so ordinary data that spimdisasm ran into the dlabel slipped through and under-filled the piece. Records the reusable FINGERPRINT of an under-fill, because it does not look like codegen: hundreds of 1-byte diffs spread over most of the overlay, ~95% at byte 0 (mod 4) = the low byte of a 16-bit immediate, every one changing by exactly -4. Bucket differing bytes by offset%4 and decode a few words; uniform small deltas in the immediate field mean LAYOUT, not codegen. (Measured: 812 of 853 at pos 0 mod 4, all -4.) The clamp's authorization matches the extension path exactly: unambiguous sltiu bound only, and REFUSE LOUDLY if any surplus word is a plausible code address. This was the single instrument failure that survived SS125's retraction round — the one case where "the tool is broken" was actually true. Now fixed, with the 710-ins behemoth banked. |
||
|
Drew T
|
20e970a928 |
docs(phase-30): SESSION-28 CHECKPOINT — fresh-session handoff for T1/T3, Max prompt for #9
Fleet 93.25% fn-count / 89.2% instr / 80.5% distinct; R22 140/140 (thirteen runs). Nothing running, tree clean, lock FREE. Records for the fresh session: the ordered resume list (T1 + T3 need /effort ultracode and a WAIT for the toggle; #9 and T5 need Max), the JR-PAIR-IN-ONE-O0-OBJECT wall with its untested SS81-step-1 escape, and the S28 ROI evidence that a 15-target wave bought 12 banks and +0.00pp headline — so waves are only worth resuming against HIGH-REACH targets. Flags the milestone reality plainly rather than leaving it for T5 to discover: 89.2% instr against a >=95% bar, with the remaining volume in main + the 39 type-1 modules (P31 scope). P30 realistically closes on the milestone's LEDGER branch, which is an explicit either/or in the approved milestone — Drew's call, deliberately. Adds the S28 HONESTY LEDGER: five wrong calls this session, each caught by an oracle, none committed. The standing consequence is stated once, at the top of the handoff: only a full clean-fleet R22 counts, and a tool's exit status is never the oracle. Also removes a duplicated results section left by my own earlier checkpoint edit. |
||
|
Drew T
|
8d40d55c7a |
docs(phase-30): SS130 — an INCREMENTAL build reported BYTE-IDENTICAL for a change the CLEAN build cannot LINK
I reported func_8013B83C + func_8013BD74 as "BOTH BANKED - BYTE-IDENTICAL". That was
WRONG. My in-loop gate ran `make extract && make build` without `make clean`, and it gave
a FALSE PASS. The clean rebuild does not link at all:
ov_SC01_077_o0.c:(.text+0x10f8): undefined reference to `$L105'
ov_SC01_077_jr_801588CC.o: undefined reference to `func_8013C938'
- the first is a local label from the C-emitted jump table;
- the second is a PREVIOUSLY-MATCHED cluster fn going undefined (the incremental build
reused objects that still satisfied it).
Reverted; R22 140/140; nothing lost, nothing was committed.
SS42b named the stale-object trap for a FALSE FAIL. This is its MIRROR: a FALSE PASS, on a
change that is not even linkable — false in the most convincing direction possible, a green
SHA. Anything touching config/ (carve, resegment, split) must be gated by a full
clean-fleet R22 before it is BELIEVED, let alone reported.
THREE WRONG CLASSIFICATIONS ON THIS PAIR, all corrected in the ledger:
CC1-FAIL-UNREAD -> it has no compile error at all
JTBL-PAD-SPEC-DRIFT -> I had carved ONE fn of a TWO-table span; carving both gives
pad spec [0,4,4] and the filter is satisfied
"both banked" -> the false pass above
Real class: JR-PAIR-IN-ONE-O0-OBJECT. Both bodies ARE byte-correct (match_one --o0 and
rtu_match --o0 both MATCH, 272 / 198 ins); the blocker is integrating TWO jr fns into ONE
-O0 object. Untested escape: SS81 step 1, isolate one into its own code subseg so each
object owns exactly one table.
Also records the diagnostic ladder that found it: diff the two BINARIES and bucket each
differing byte against the function's own vram range. 3,749 of 3,791 diffs were OUTSIDE the
function, first diff near the overlay START, image 57 bytes LONGER - the SS8 signature of
.rodata floating to the front. That fingerprint separates a codegen residual from a layout
effect in one build, and it is what finally redirected three wrong guesses.
|
||
|
Drew T
|
7281e0af57 |
docs(phase-30): SS129 (two jr traps) + checkpoint — 1 of 3 reach-138 targets banked, 2 ledgered
SS129a: post-carve, rtu_match/match_one COUNT THE JUMP TABLE AS INSTRUCTIONS. For func_8013BD74 it reported `mine=198, target=226, 206 mismatched` — and 226-198=28 is exactly the table's entry count. A draft that verified cleanly BEFORE the carve reads as a total mismatch AFTER it, and the number looks like deep codegen trouble. SS81 says a jr fn's match_one MATCH is not a bank; SS129a says its post-carve DIFF is not a diff either. Let the whole-binary gate arbitrate. SS129b: NEVER commit a carve whose owner is still a stub. harvest_verify refuses a dirty tree (SS97) and the carve dirties config/, so committing the carve to get a clean tree is tempting — and it STRANDS the carve. jr_inventory refused instantly (R32: "carve ownership is not 1:1 ... UNOWNED 0x801d828c"), blocking every later jr operation on that overlay. Reverted; R22 140/140. The route for a jr fn is the INTEGRATED jtbl_family_bank (carve -> extract -> remap -> gate per sibling in ONE uncommitted transaction). The SS81 hand-chain is for diagnosis; as a banking path its two constraints contradict each other. Both were mine, both caught by oracles before any lasting damage, both now documented. Ledger: JTBL-PAD-SPEC-DRIFT (func_8013BD74, with the exact SS8e error) and CC1-FAIL-UNREAD (func_8013B83C — the diagnostic is genuinely unread; say so rather than guess). Fleet 93.21% fn-count / 89.1% instr / 80.4% distinct. |
||
|
Drew T
|
2ab945035a | docs(phase-30): SS128/SS128a — a raw NUL makes grep silently skip a C source (137 files); negative controls use scratch copies | ||
|
Drew T
|
d2c2d2de58 | docs(phase-30): regenerate backlog digest | ||
|
Drew T
|
a98d138c73 |
docs(phase-30): SS127 the -O0 idiom set + SESSION-28 wave checkpoint (honest ROI)
SS127/SS127a/SS127b distil what the wave's agents kept re-deriving, because the index fired on only 3 of 15 targets: - the -O0 CONSTANT-OFFSET FOLD: `p->f` folds to `lbu 3(r)`, `p[i]` does NOT (addiu + 0-displacement load). At -O2 these converge, which is why nothing in SS1-SS126 covers it. - the -O0 regime generally: spill/reload pairs are REAL named locals; load-delay nops and redundant copies are normal; write plain C, the -O2 steering levers are inert here. - SS127a: SS71 sibling-first is the STRONGEST -O0 lever — an -O0 TU is a near-uniform code regime, so a banked sibling's shape transfers far better than at -O2. - SS127b: two agents' decisive levers came from a SOURCE COMMENT in ov_SC01_077_o0.c, not from docs/. Promote levers out of source comments or every future agent re-buys them. Checkpoint records the wave AND its honest ROI: 1.33M tokens for 12 banks and +0.00pp headline. The value is contingent on three reach-138 functions, and all three are currently unpropagated (func_8013C08C 0/137, SS94 type-carry) or gate-failed (func_8013BD74 CARVE-REFUSED, func_8013B83C CC1-FAIL). Fix propagation before wave 2 — drafting more x2-reach targets is not where the leverage is. |
||
|
Drew T
|
74d7f93c8a |
feat(phase-30): T3 -O0 crack wave — 15 drafted / 15 rtu-confirmed / 12 BANKED, R22 140/140
First Ultracode wave against the population the -O0 routing made draftable. 30 agents (15 drafters + 15 adversarial verifiers), 1.33M tokens, 8.8 min. Every drafter self-checked with match_one --o0 AND rtu_match --o0; every MATCH claim was then re-run from scratch by an independent skeptic instructed to default to REFUTED. Result: 15/15 confirmed, 0 disputed. WHOLE-BINARY GATE (the sole arbiter, G3/P9): **12 banked / 3 failed** — a textbook SS52b outcome (an rtu MATCH is a CANDIDATE, not a bank). All three failures are NAMED INTEGRATION classes, none a compiler wall: func_8013BD74 CARVE-REFUSED — it is a jr function; needs the SS81 carve chain (reach 138) func_8013B83C CC1-FAIL — real-TU compile, error not yet read (reach 138) func_80184058 PLUMBING — recovery ladder BANKED: func_8013C08C + the 11 fourth-region fns (func_80183CF0/D50/F28, func_80184028/264/ 2E0/354/474/538, func_801847EC, func_80184868). Bank truth read from the SOURCE (INCLUDE_ASM absence), never the gate report (SS55b trap 4). R22 CLEAN-FLEET: extract-all 139/139 (+main); check-all 140 passed, 0 failed of 140. PROPAGATION OF func_8013C08C (reach 138) IS NOT DONE: the first sweep returned "0 families" because the family map still listed it as a stub — regenerated it (the documented crack-wave-sweep-map-regen path), after which the sweep found 137 candidates and banked **0/137**. Per SS94 a family 0/N is a TYPE-CARRY failure until proven otherwise, and this body carries a SS100 body-scoped typedef, so that is the first hypothesis to test. Recorded as open, NOT as a wall. FLYWHEEL FEEDBACK (R16), the honest read: the cookbook index fired on only 3/15 targets. Agents independently re-derived the SAME undocumented idiom — the -O0 CONSTANT-OFFSET FOLD (`p->f` folds to `lbu 3(r)`; `p[i]` does NOT, it emits `addiu; lw 0(r)`) — and two found their decisive levers in a SOURCE HEADER COMMENT in ov_SC01_077_o0.c rather than in the cookbook. The -O0 regime is under-documented relative to how much of the frontier now lives in -O0 TUs. SS71 also generalises to -O0: several agents cracked their target off an already-banked sibling in the same TU (func_80184868 came straight off the shape banked earlier today). |
||
|
Drew T
|
feb32ed23e |
feat(phase-30): T4 — grinder ILS warm-restart wired in; SS119 posture audited + a stale doc hazard struck
(1) --fix-def-sig POSTURE: AUDITED CLEAN. `action="store_true"` (defaults False), one
consumer via getattr(a,"fix_def_sig",False), and NO caller anywhere passes it — checked
tools/, .run/ scripts, docs recipes and the Makefile. The flag help already carries the
SS119 warning.
BUT the audit surfaced a live hazard the earlier pass missed: docs/decision-log.md
still recommended "--fix-def-sig should likely be default-on for the h_seq path".
That was byte-REFUTED by T84/SS119 — the flag is a REPAIR, not a default; on 0x80161c98
it imposed a signedness-wrong `s32 a1` over the true `u32`, turned a byte-correct draft
into a 1-instruction DIFF (slti vs sltiu), and held 137 members at 0 until DROPPED.
Struck through in place with a superseding note rather than deleted, so the original
reasoning stays legible (R31) — but a forward-looking "should be default-on" sitting in
a doc a fresh session reads FOR DIRECTION is a hazard, not a historical note.
(2) GRINDER WARM-START: tools/permuter_ils.py has sat beside grinder.py since Phase 24 and
was never wired in, so every grind was a COLD search that burned its whole time box
re-descending ground the previous run had already covered. grinder.py now runs `--cycles`
(default 4) timeboxed permutes, each warm-restarted from the previous cycle's best byte
waypoint, stopping early on no gain. `--cycles 1` reproduces the old cold behaviour exactly,
so it is opt-out. --permute-secs is now documented as the PER-CYCLE box.
JUSTIFIED BY MEASUREMENT, not by the task list: the lane looked dead (Phase-22 audit: 7
all-time banks, all Phase 21, 0 since), so I checked for live fuel before building. The
backlog holds 665 open near-misses in the permuter-tractable band (close 1-20), 157 of them
close 1-4, including func_8016BA68 at close=1 with reach=134.
HONEST LIMIT: this is a WIRING change whose yield is UNPROVEN. The Phase-24 evidence for ILS
is one function (func_80148094, 72 -> 36 over ~8 restarts); I have not run it on this
backlog. A winner remains a CANDIDATE — the whole-binary byte-gate is still the sole arbiter
(G3/P9), and an intermediate waypoint is only ever re-seeded, never banked.
|
||
|
Drew T
|
e91a6deb32 | docs(phase-30): regenerate progress.fleet.md digest (93.17/89.1/80.4) | ||
|
Drew T
|
b5362c7b7f |
feat(phase-30): the -O0 cluster HARVEST — 1,364 banks for ZERO agent tokens; fleet 92.71->93.09% fn / 88.3->88.6% instr / 78.7->79.3% distinct
The payoff of routing the cluster to -O0 (commit:1270). These functions were ALREADY
CRACKED in ov_SC01_077 and could not be banked anywhere else purely because every
destination file compiled -O2. With the destinations now -O0, they template in
deterministically -- no drafting, no agents.
dedup_propagate --recover 0x8013C360 (h_exact x138) -> 137 overlays byte-identical
family_sweep --hseq 10 variant families -> 1,227 banked / 133 failed (90%)
1360 staged across 136 groups
------------------------------------------------------------------------------------
1,364 new banks
FLEET: fn-count 92.71 -> 93.09% · instr 88.3 -> 88.6% · distinct-code 78.7 -> 79.3%
(71,756 / 87,459 unique fns; +1,162 unique). dedup 1904 -> 1905 groups, 0 failed;
C1 coverage 240496/240496. 0 NON_MATCHING in any default build (G4).
R22 CLEAN-FLEET: extract-all 139/139 (+main); check-all 140 passed, 0 failed of 140.
--recover WAS LOAD-BEARING (SS75): without it dedup_propagate took its historical
all-or-nothing branch -- one failing overlay (the SOURCE, ov_SC01_077) dropped the whole
function and it printed "all candidates dropped", which reads exactly like a wall. Reading
the exclusion code instead of believing the message showed the remedy: --recover excludes
only that overlay (kept x1 with its own inline match) and propagates to the other 137.
The two has_mid_jr families in the cluster were REFUSED BY DESIGN, not attempted (SS53
interlock): 0x8013C0F8 (154 ins) and 0x8013C414 (329 ins), ~137 members each = ~466
members queued behind the jtbl carve path they actually need, rather than a fake 0% from
the wrong tool.
REMAINING in the cluster: the 133 sweep failures + the 2 jr families + the 3 addresses
never cracked anywhere (0x8013B83C, 0x8013BD74, 0x8013C08C) -- the last are genuine
drafting work, now finally possible since their TU is -O0.
|
||
|
Drew T
|
bbd51be24a |
docs(phase-30): SS126a — a bare except around a coverage oracle re-creates the silent skip
I under-counted this cluster 8x (reported 275 stubs/18 overlays; truth 2,184/138). The scan ran during a background rebuild AND wrapped corpus.stubs() in `except: continue`, so every R32 coverage refusal became a silent skip and the total was taken over the few overlays that happened to be re-extracted already. Two of our own rules broken at once: a measurement taken during a rebuild is not a measurement (caught EARLIER the same session, by the same assertion I then suppressed), and R32 lives in the CALLER — an oracle only asserts coverage if the caller lets it raise. It also cost credibility the other way: I used the bad number to declare the T0(f) "2,192 open members" pin STALE. The pin was right. R35 applies to a re-measurement as much as to the original measurement. Checkpoint updated with the corrected population and the completed fleet-wide sweep. |
||
|
Drew T
|
803d73bb97 |
docs(phase-30): SESSION-28 checkpoint — T2 proven + tooled; fleet 92.71/88.3/78.7, R22 140/140
Records the T2 result as the phase's biggest unblock: the carve-within-a-carve is byte-neutral (Arm-A does NOT bite), the real constraint is that an address range is not an optimization region (SS126), and tools/o0_subsplit.py implements the correct bound. Measured, not assumed, what it unblocks: 275 open stub instances across 18 overlays in the 0x8013B568..0x8013C98C cluster, homed in an -O2 jr split — plus a note that the T0(f) "2,192 open members" pin is STALE and must be re-derived before costing (R37). Also flags my own under-count: the "15 contiguous -O0 fns" came from an asm scan that cannot see matched functions. |
||
|
Drew T
|
d2b48b7680 |
feat(phase-30): tools/o0_subsplit.py — the T2 carve-within-a-carve driver; +3 banked in ov_SC03_015
Promotes the proven probe (commit:1266) into a real tool, and validates it FIRST-TRY on a
fresh overlay.
tools/o0_subsplit.py <ov> --lo <vram> --hi <vram>:
- derives the range's contents from the SOURCE ANCHORS (overlay_src_split.parse_overlay_c:
`asm` = unmatched stub, `define`/`def`/`nonmatch` = already matched), NEVER from an asm
scan -- a matched fn emits no .s, which is exactly the blindness that made the range look
like a clean contiguous run (SS126 / SS124's shape);
- computes the -O0 bound as (address range MINUS already-matched bodies) and emits ONE
sub-region per maximal run of unmatched anchors (K matched islands => K+1 regions);
- names each `<ov>_o0<letter>` picking free suffixes, so the widened Makefile glob selects
them; refuses loudly if it runs out or if the range spans >1 object or is already -O0;
- honours the one-carve-per-region law (forces a cut at every already-banked jr in the
object) and reuses jr_isolate_all's plan/build_new_config/ascending-unique validation
verbatim, so carve-repoint + source-repartition stay on the proven path;
- warns (does not refuse) when a stub in an -O0 run lacks the frame-pointer prologue --
the byte-gate is the arbiter, not the heuristic.
VALIDATION on ov_SC03_015 (untouched by the manual probe): the tool independently derived the
SAME structure found by hand on ov_SC03_014 -- 2 matched -O2 islands (func_80184440,
func_801848E4), 2 -O0 regions (8 + 7 fns), same 5 cuts. Sub-split -> BYTE-IDENTICAL. Then 3
drafts, each global DERIVED FROM THAT OVERLAY'S OWN ASM (%hi operand) rather than copied:
3/3 match_one --o0 MATCH (22 ins), 3/3 through the whole-binary gate.
BANKED this commit: func_801846E4 / func_8018473C / func_80184794 in ov_SC03_015 (6 across
the two overlays now). The other 24 stubs in the region are undrafted -- the route makes them
DRAFTABLE (they were un-bankable at any effort before); drafting them is crack-wave work.
R22 CLEAN-FLEET: extract-all 139/139 (+main); check-all 140 passed, 0 failed of 140.
cookbook SS126 (the address-range-is-not-an-optimization-region law + the probe ladder).
|
||
|
Drew T
|
8d4f2a38cb |
fix(phase-30): RETRACT 2 of 3 jr wall verdicts — SS125 rewritten; my measurement was the defect
Max-effort re-measurement of the three jr refusals I ledgered earlier this session.
Two of the three verdicts were FALSE. Every number below is SHA vs config/check.<ov>.sha
from a clean tree, with the restore re-verified.
func_8018057C / ov_SC01_009 : jr_isolate_all is BYTE-NEUTRAL
-> "JR-ISOLATE-BREAKS-BYTES" RETRACTED; original failure not reproducible.
func_80191C50 / ov_SC06_018 : isolate NEUTRAL -> carve DIVERGED
(got 1b1667ea, want cbbc4f44) -> the ONE real instrument failure. CONFIRMED.
func_8017BEBC / ov_SC04_004 : carve is BYTE-NEUTRAL (body-free)
-> failure is the TEMPLATED BODY, the OPPOSITE of what SS125 first claimed.
Re-probed once more from a verified-clean tree: still gate-fail. Reclassified
BODY-TEMPLATE-GATE-FAIL.
So the tidy "two apparent walls are ONE tooling problem" conclusion was wrong: they
are two different problems, and the third target has no demonstrated problem at all.
ROOT CAUSE, and it is mine not the tools': a grep-of-the-build-log gate inside a driver
that did not revert on abort. config/overlays.mk is SHARED, so target 1's half-applied
isolate was still in the tree while target 3 was measured. Separately reproduced the
SS42b stale-object trap head-on: `git checkout -- config/` WITHOUT a re-extract turned a
byte-identical overlay into [FAIL] got 8f28aa77 / want 38a3d919 (Phase-20's R22
corollary, live).
SS125 rewritten. The METHOD (split the carve from the body, one build) is kept and is
what refuted this section's own first conclusion; what is added is the instrument rules
that make its answer trustworthy: compare the SHA against config/check, never grep the
log; re-extract after every config change AND every revert; a driver that aborts a
target must revert it before the next; verify the BASELINE against canonical too.
Meta-lesson recorded: SS53 says a 0% from the wrong TOOL manufactures a doctrine — this
is the same failure one level up, a verdict from the wrong MEASUREMENT, and my own
diagnostic script is an instrument subject to R35 like any other.
Ledger corrected in place (3 entries, superseding the earlier misattributions), so the
scheduled repair is the right one. No source/config change; no bank affected; the fleet
is untouched at 140/140 (last full R22 this session, HEAD commit:1263).
|
||
|
Drew T
|
c95b61063f |
docs(phase-30): SS125 split the CARVE from the BODY; 3 jr residues ledgered by STAGE
The session's most useful finding is an instrument ticket, not a match. SS125 (new): before ledgering any jr residue, run jtbl_carve with NO body spliced and rebuild. Byte-identical => the carve is neutral and the failure is the template; NOT identical => the failure is the carve and the body was never fairly tested. One build, and it collapses ambiguity that SS53 warns has twice steered strategy. MEASURED: group B func_8017BEBC had gate-failed 3 probes in a row (default AND --raw, cross-address ov_SC02_015 AND same-address ov_SC04_004). Carve-only on ov_SC04_004 broke the bytes with nothing spliced — so all 3 probes were testing a body that never got a fair run. The SAME stage had already refused behemoth func_80191C50/ov_SC06_018. Two "unrelated walls" = ONE tooling problem. func_8018057C/ov_SC01_009 fails at a DIFFERENT stage (jr_isolate_all, step 1) and is deliberately NOT grouped with them. Both tools reported SUCCESS on every failing target; only the whole-binary gate refused (G3/P9). A tool's exit code is not the oracle. Ledger: the three logged by STAGE (JTBL-CARVE-BREAKS-BYTES / JR-ISOLATE-BREAKS- BYTES), not by function, so a carve fix auto-reopens every target it should. None is diagnosed, so none is called a compiler wall — that guess has been wrong four times running on this project (R35). CURRENT_PHASE: SESSION-28 checkpoint refreshed; the carve diagnosis is now resume item 1 (it gates 13 members + a 710-ins behemoth and every future jr family). |