One clean whole-EXE rebuild verified the batch (gate_main), and main re-checked
BYTE-IDENTICAL against config/check.us.sha before anything was credited.
func_8005C020
One clean whole-EXE rebuild verified the batch (gate_main), and main re-checked
BYTE-IDENTICAL against config/check.us.sha before anything was credited.
func_80028D9C
One clean whole-EXE rebuild verified the batch (gate_main), and main re-checked
BYTE-IDENTICAL against config/check.us.sha before anything was credited.
SYS_OBJ_18AC
One clean whole-EXE rebuild verified the batch (gate_main), and main re-checked
BYTE-IDENTICAL against config/check.us.sha before anything was credited.
func_8001C810
func_80028DE0
Drafts the ledgers already recorded as byte-correct (closeness 0 / reloc shape MATCH), re-judged against today's tree by rtu_match + reloc_identity, staged, and gated on the whole-binary SHA. Ledger: .run/resolver/verdicts.jsonl
aprop_autodraft: where the seed carries no decl, infer a minimal extern from the MEMBER'S OWN
target .s (decl_from_use, negative-controlled 97.4%/4,702) and place it at BLOCK scope via
insert_decls — file scope collides with the fleet's per-function loose-typing (the ov_SC04_018
lesson). Strictly additive: runs only where the old path refused; genuine refusals keep the old
behaviour with the class named.
integration_resolver: (1) a CC1/CPP verdict is billed to the DRAFT only after the split TU passes
a TU-alone compile probe WITHOUT the draft — else TU-BROKEN, no demotion, auto-reopened when the
TU's hash changes (S61: one broken TU was billed to 39 drafts; one-off sweep over the CC1 stock:
1 broken TU of 55, 39 verdicts reclassified). (2) dup-def→extern demotion: a draft that DEFINES
data a still-stubbed sibling .s in the same TU also emits dies at the assembler with 'symbol
already defined' — invisible to rtu (INCLUDE_ASM neutralized). Single-line file-scope defs whose
symbol a sibling .s emits are demoted to extern as an ADDITIONAL candidate (new sha, so the
ledger's unchanged-skip does not hide it). Smoke test: md_MAIN_003/func_800D3204 demoted
D_800D3200 → rtu MATCH (12 ins); the whole-binary SHA remains the sole arbiter.
42-case first run: 39 were one uncompilable TU (ov_SC04_018_jr_8017AE2C.c), not draft defects —
the resolver's 'undeclared' classification needs a TU-alone compile probe first (open follow-up).
The 08-25 maintenance revert/restore cycle left the TU uncompilable under the TU-alone/rtu view,
which the resolver billed to 39 separate drafts as 'undeclared'. File-scope declaration is closed
off by the TU's own §63 block-scope convention (later functions declare the symbol with other
types), so the decl lives inside the function; the use is address-only, hence byte-neutral. The
real build's pads drift ('consumed 3 but 4 pad specs') is unchanged and remains the open repair
for this binary (stays on .run/baseline_red.txt).
A 08-25 'fix RED' commit (commit:2833) restored func_8017E7CC's body but not its 'extern s32
D_801B9AA8;' and left an 'extern void func_8017E7CC(void);' after the (int) definition. Under the
INCLUDE_ASM-neutralized view every rtu/TU-alone judgment of ANY draft for this TU died on that
line — the resolver billed it to 39 separate drafts as 'undeclared' (measured by the decl-from-use
negative-control agent; its verdicts in .run/decl_from_use/). The real-build pads drift for this
binary is a separate open repair; it stays on .run/baseline_red.txt.
R30/R31 capture while hot: the resolver pivot (63 zero-token banks of 245 staged of 424 judged of
1,352 nominated), the RED-fleet finding (15/214 baseline-RED refusing 174/182 doubly-verified
drafts), the three byte-proven repairs so far, and rule candidates R56–R58.
gate_stage: a binary on .run/baseline_red.txt (+ fleet_red.txt) refuses its drafts with class
BASELINE-RED before any build — a RED binary rejects every draft gated against it, and 174 of the
resolver's 245 doubly-verified drafts were refused exactly that way (negative-controlled both
directions: RED refused without a build, GREEN still reaches the ladder).
jtbl_pads_fix: (1) OBJ_ERR required the make bracket to start with build/src but make prints
[Makefile:687: build/src/...] — find_drift returned None over failing builds ('no pad-count drift',
six binaries); (2) only the 'consumed N but M' phrasing was handled — the 'more rodata .align
directives than pad specs' direction (a NEW table from a banked switch) now searches declared+1/+2;
(3) write_pads split its line on ':' but ':=' contains a colon, appending a second ': JTBL_PADS'
per write, and wrote via a raw truncating open() — the fifth un-converted mk write site; now
path-split-once + mk_write.
mk_write: refuses a parse-poisoned registry line (R43) — one such line kills EVERY build of EVERY
binary at make parse time, strictly worse than the wipes the line-count floor guards.
rtu_shadow: a 0-bank wave has no commit — gatedness now comes from the ox ledger; baseline-RED
binaries are excluded from the prediction metrics with their count reported (R41).
integration_resolver: stub_removals() nets out carve moves (72 gross -> 63 real in the first pass).
Uncommitted src/ changes found at gate entry. These are banked functions from a lane that gates with commit=False, not residue — preserved, not reverted. Top-level src/*.c (main TUs) are excluded by construction (S59).
jtbl_pads_fix.write_pads split its line on ':' but ':=' contains a colon, so each write appended a
second ': JTBL_PADS'; its 'restore' path wrote the poisoned form, and the gater's pre-gate blanket
commit (commit:2996) adopted it — R52's exact shape. From that moment every 'make' of every binary
died with "target pattern contains no '%'", which voided wave fb's re-gate, the 10-binary pads
re-audit, and two interleave probes. Line restored to its pre-damage text (JTBL_PADS := 0,0,
tables=+0x0,+0x28), byte-verified by a GREEN resident build. write_pads now splits the path once
and writes through mk_write; mk_write now REFUSES parse-poisoned lines (R43).
Uncommitted src/ changes found at gate entry. These are banked functions from a lane that gates with commit=False, not residue — preserved, not reverted. Top-level src/*.c (main TUs) are excluded by construction (S59).
tools/rtu_shadow.py: --wave X records rtu_match's verdict for every draft of a not-yet-gated wave
(mapped to its binary through the SHARD's targets file, never by bare name — 54 of wave fa's 470
cards share a name across binaries); --join X after the gate commit prints rtu-verdict x outcome,
P(bank | rtu MATCH), the false-negative rate and current-vs-inverted build counts (R41 denominators).
build_wave_atlas: a (binary, fn) whose latest resolver verdict is STAGED/BANKED/GATE-REJECTED is not
drawn — its body already matches at the real TU and on symbols; DIFF/CC1 verdicts stay drawable
with the CURRENT closeness the resolver demoted them to.
frontier-analysis-s60 §4 measured that ~571 open functions had FINISHED drafting (closeness-0 backlog
rows / reloc shape-MATCH rejects) and were being re-drafted wave after wave. tools/integration_resolver.py
treats those ledgers as an index: still-open? -> rtu_match at the real split TU (CC1: the gate ladder's
draft-side transforms, one retry) -> reloc_identity as the disagreeing oracle (rtu masks reloc fields)
-> aprop_symfix on MISMATCH/shape-MATCH -> stage -> sweep_parallel (whole-binary SHA, sole arbiter)
-> commit at once (R42). Refuses main by name (gate_main owns it), //@EDIT drafts, dirty trees, collapsed
registries; every drop is counted (R32); a negative control over recently-banked functions must pass
N/N before any verdict is trusted (R35/R39 — its first form picked carve moves as banks, 9/12 FAIL,
and was fixed before a single stock verdict was read). Ledger .run/resolver/verdicts.jsonl keyed by
(binary, fn, draft-sha, split-TU-sha) so unchanged rejects are never re-judged.
First pass (commit:2991): 1,352 nominated -> 901 already banked, 27 main -> 424 judged in 41 s ->
245 staged (57.8%; 242 raw, 3 via transforms) -> 63 banked (net INCLUDE_ASM delta; that commit's
subject says 72 = gross incl. 9 carve moves), 182 gate-refused, zero model tokens, ~10 min total.
Lane wrapper tools/lanes/resolver_lane.sh (holds .run/auto/draw.lock for judge+gate: rtu reads the
TUs a gate splices into).
campaign_status: 'today: N banked' summed '— N banked' commit subjects and missed every bank that
rode in a chore/maint commit (S60: 2,185 reported vs 2,644 net stubs removed); it now derives the
number from INCLUDE_ASM stub counts at last-commit-before-midnight / HEAD / working tree (R33), and
alive() is anchored so pgrep no longer matches its own wrapper (every lane read ok with 0 processes).
ox_campaign gater: the ledger's wall_min counts drafting + queue wait since the ready marker's t0;
gate_min is the gate alone (the '30-67 min gates' picture was this conflation).
maintenance lane: the fleet R22 sweep skipped whenever any gate was in flight, i.e. always (last
real sweep 12:54 08-25); it now takes .run/auto/draw.lock and waits its turn, skipping only for gate_main.
Drafts the ledgers already recorded as byte-correct (closeness 0 / reloc shape MATCH), re-judged against today's tree by rtu_match + reloc_identity, staged, and gated on the whole-binary SHA. Ledger: .run/resolver/verdicts.jsonl
Drew asked whether waves cracked better before MAXTOK went 8000 -> 16000. Recording both halves
of the answer so next session does not relitigate it from memory:
CLEAN: raising to 16k did cause a real regression — draft completion 84-89% (8k) -> 41% on wave
bt, 69% on bu — but the cause was a harness interaction, not the model. A 16k generation runs
~530 s at ~30 tok/s while STRAGGLER_GRACE was 120 s, so agents were cut off mid-thought with no
draft. Grace at 700 s fixed it; completion has run 97-99% since.
CONFOUNDED: on banks per draft the 8k era looks better (S59: 1,335 of 2,996 = 44.6%; today's best
16k waves dd 34.7%, de 29.7%) — but the populations differ completely. 8k waves had never-drafted
work; today's draw from skeletons that refused six times. Budget and exhaustion moved together, so
neither figure isolates the other. Neither should be cited as evidence about the budget.
AGAINST the simple story: truncated-turn rate is INVERSELY correlated with bank rate (cx 8.7%
trunc/43.9% bank, dd 8.3%/51.4% vs dl 1.3%/0.5%, ej 0.6%/0%). Budget exhaustion driving the
decline would produce the opposite relationship.
THE A/B: split ONE wave's card pool — half the shards at 8k, half at 16k, same generation mix,
same binaries, same gate, same tree, grace 700 s in both arms. Compare banks per DRAFT and per
GATE MINUTE. Holding the population constant is the whole point; every historical comparison
fails exactly there. If 8k matches 16k, the cheaper budget also buys more agents per unit time.
Every campaign process stopped deliberately at session end (0 alive, verified after settling).
.run/ox_campaign.stop and .run/auto/STOP are SET — delete both before relaunching, or every lane
exits immediately.
One dirty overlay TU left by a killed gate was BUILD-VERIFIED as an abandoned substitution (the
binary failed to build with it) and reverted rather than committed — R42's distinction between a
proven bank and mid-gate residue, decided by the bytes.
Two shutdown hazards recorded: pkill on a lane's shell leaves its python running (hit the
drafter, gater and main lane tonight — kill by PID, verify with ps -o lstart), and a bash case
pattern 'src/[a-z0-9_]*.c' matches ACROSS SLASHES, which classified an overlay TU as a main TU
and nearly reverted the wrong file.
Also committing the two lanes built today: tools/lanes/elastic.sh (starts serial idiom lanes when
the API window is idle and the gate queue is deep — it scales the work that is NOT gate-bound,
because adding drafters to a full gate queue makes the backlog worse) and
tools/lanes/grinder_lane.sh (runs tools/grinder.py, the Phase-21 LLM-free permuter, which had
never been run this campaign against 5,388 near-miss rows).
Re-gate of the false-verdict waves finished 21:42: ei 34 · ej 0 · ek 4 · el 6 · em 3 · en 8 =
55 recovered from 2,814 pre-paid drafts for zero model tokens. Only ei paid well (18% of gated);
the rest returned 0-4% because the live lanes had already banked those functions in the interim,
so they come back NOT-A-STUB rather than as banks.
IMPORTANT FOR PLANNING: this does NOT confirm the uncollapsed-wave thesis. eh's 129/380 (34%)
stays an outlier with ei's 18% as its only corroboration — do not plan on sibling drafting
reproducing eh without more evidence.
Session close: 2,238 banked by the commit-message count (the stub invariant is higher — the
A-prop lane's banks ride in chore commits the regex cannot see), open crackable 2,981, fleet
98.2% instruction-weighted and 96.4% distinct-code, up from 97.4%/94.6% this morning.
Next session starts from docs/tool-designs/frontier-analysis-s60.md: the wall is an INTEGRATION
wall, and the first build is the zero-token integration-resolver lane.
One clean whole-EXE rebuild verified the batch (gate_main), and main re-checked
BYTE-IDENTICAL against config/check.us.sha before anything was credited.
func_8001C320
Uncommitted src/ changes found at gate entry. These are banked functions from a lane that gates with commit=False, not residue — preserved, not reverted. Top-level src/*.c (main TUs) are excluded by construction (S59).
Drew T