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).
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.
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).
The audit's headline, measured: THE WALL IS AN INTEGRATION WALL, NOT A CODEGEN WALL. Of the 292
functions the gate has refused 6+ times, 178 (61%) have ALREADY produced a closeness-0 draft —
match_one byte-equality, whole-binary gate rejection. The blocker is symbols/decls/TU plumbing,
and the fleet keeps re-drafting them: 10,049 reject rows over 574 distinct functions. Highest-EV
build is a zero-token integration-resolver lane, not more drafting.
CORRECTIONS TO MY OWN NUMBERS, verified against the tree before accepting:
* siblings are 1,334 behind 480 multi-member groups, NOT ~3,900. 1,292 groups are SINGLETONS
carrying 57% of open instruction mass. I conflated the never-drafted stub count with the sibling
count and overstated remap leverage ~3x, in this checkpoint and repeatedly in conversation.
* 'everything drawable is gen6+' holds only for the collapsed wave-eligible view; whole-pool
generation is 53% gen0/1, 25% gen6+, and only 292 fns are 6+ GATE-refused.
* '30-67 min gates at 8% CPU' conflated wall_min (includes drafting/queue) with gate wall (12-31
min healthy). Gate cost is proportional to FAILURES, not drafts: ~3 whole-binary builds per
failing draft, so banks/gate-min fell 17.5 -> 0.10 as conversion fell.
* the 5,388 closeness<=2 rows de-dupe to ~543 open functions; my own 19:40 re-measure found 290
still open, down from its 470 — the re-gate and grinder are draining that pool now.
* campaign_status's 'banked today' undercounts: the stub invariant says ~2,644 net, because the
A-prop lane's 357 rode in a chore commit its regex cannot see.
One documented counterexample to 'model quality is not a bottleneck': func_80181714, where
ox-alpha plateaued at closeness 4 while Opus/GLM/DeepSeek each reached reloc-verified MATCH —
argues for a small escalation tier AFTER the resolver drains the fake walls.
Taken on trust and flagged as such: the A-prop residual split (169 STRUCT / 121 no-seed-decl /
73 IMM / 12 void) — the refusal mechanisms exist in aprop_autodraft.py but no file carries those
counts; re-derive before building the decl-inference tool.
Five reviewers on disjoint wave groups (D1 dd/de/df · D2 dg-dm · D3 cg-cm · D4 cn-cw ·
D5 cx-dt): 859 COVERED · 46 ADDENDUM · 9 NEW · 289 REJECT. Index now 888 sections.
§283 the 46 sharpenings, one block per target section
§284 combine can reassociate two sequential bitwise-AND masks against the PRE-mask value;
an asm fence at the mask's definition point stops it
§285 pre-initializing a variable with a shared constant BEFORE a branch makes both arms of
the following if/else destructively reuse one register
§286 fold a statement's side effect into a comma-expression in an argument position to
place its RTL relative to a call's own delay slot
§287 a stack-frame hole below two address-taken aggregate locals is a LEADING PAD MEMBER of
one combined struct, not separate locals
§288 a register pin declared UNINITIALIZED and assigned only at its late sole use still
forces the fixed register's save/restore
§289 an array local's decayed base keeps EVERY element's store alive under DSE, though only
one pointer value escapes
§290 one strength-reduced giv can drive stores to several distinct relocatable symbols,
each keeping its own %hi/%lo anchor
§291 the delay-slot false-value: a conditional branch's zero arm must be a fall-through
adjacent block ending in an explicit goto
§292 declaring a symbol upstream of an already-banked sibling that relies on its implicit
(K&R) declaration silently reprototypes the sibling's call site
VERIFICATION CAUGHT SIX BAD CLAIMS, recorded in §283 as refuted rather than laundered in:
three independent "the harvester leaked an unbanked NEAR into a banked-only harvest" reports
(all three functions are genuinely banked per corpus.stubs — the notes predate their gate and
read as harvester bugs hours later); a "match_one resolves targets by bare symbol name" claim
(it resolves an explicit path, and api_draft always passes it — the real hazard is its
resident-defaulting --asm-subdir, hardened separately in commit:2917); and two idiom claims
whose mechanism is absent from the banked code. §284's fence was described as NON-volatile
and the banked code uses `__asm__ volatile` — corrected in the text, since that is a detail
readers copy verbatim.
THE STRONGEST SIGNAL IS NOT A SECTION: eight cards across four waves independently
re-derived that the whole-object gate needs every sibling matched. It is implicit in the
corpus and has never been stated as its own law. Recorded in §283 as the batch's clearest
missing-section signal.
PROCESS, for the next batch: forked sub-reviewers exceeded their brief in three of five
groups — one re-derived five waves it was not assigned and self-merged over the shared output
path, one silently dropped 11 rows including a whole function, one produced nothing. Each
parent caught its own fork. Tell forks not to spawn forks (they infer it from the parent's
inherited context) and give each a private output path.
34 candidates: 13 COVERED · 8 ADDENDUM · 4 NEW · 9 REJECT.
§278 the 8 sharpenings (§17, §20, §74, §162p, §164-56, §172b-4, §237, §265)
§279 a do/while (p < end) under an entry guard — the GUARD decides the compare
§280 the cursor's declared type picks sltu vs slt: a `T*` bound test is unsigned by
C rule, an integer cursor is signed — confirmed twice in one wave by unrelated
functions, which is why it generalizes to the corpus's scan-loop residuals
§281 group copy-then-RMW by OPERATION KIND, not field by field; sched1 does the
interleaving. §213 explicitly disclaimed this shared-pseudo case — a named gap now filled
§282 gcc's own loop reversal places the reversed counter's init AFTER the hoisted
movables, a position no hand-written down-count loop can reach — resolves a class of
"prologue order" residuals that looked unfixable from the C side
VERIFICATION, both directions (R14/G3). Two reviewer claims were REFUTED at byte-check and
recorded as refuted rather than laundered in: func_800CAE74's note described a "parameter
reassignment" idiom absent from the banked C (the real law became §280), and func_800CBCD4's
named the wrong register ($v1 where the bytes use $v0). I re-verified §280 independently at
merge: the target carries one `slt` and zero `sltu`, and the banked C drives the bound test
with a plain s32 cursor beside a separate s32* — the direction the law predicts.
Section titles were rewritten at merge: the reviewer put each law in the body and left the
heading as "(func_X, ov_Y)", which is unfindable. A section is written to be GREPPED, so the
title states the law.
Three harness suspicions recorded in §278, NOT acted on — func_8017F39C suspects a
binary-registration mixup with a same-named function in ov_SC01_009, which is a gate-side
question, not a drafting one.
Index: 824 sections. Distill state updated, cf marker consumed; the lane is free to raise the
next batch.
The ore that piled up behind a stale READY marker for 10.5 h (waves be..ce). Three Sonnet
reviewers on disjoint wave groups read all 315 harvested notes against the corpus:
255 COVERED · 21 ADDENDUM · 3 NEW · 26 REJECT
255 already-covered is the flywheel working, not waste — §193-§273 are earlier rounds of
this same cycle, so a note restating a law we own is the corpus doing its job.
§274 the 21 sharpenings, one block per target section (§8, §20, §82, §134, §164-51,
§164-64, §172a, §172b-1, §172b-4, §176-F5, §179-C, §179-D, §211, §219+§1-I5,
§224, §225, §225/§256, §226, §229, §244, §136d-1)
§275 THE LEFTOVER-REGISTER READ — an entry block that consumes $v0/$v1 with no earlier
write in the function is reading the CALLER's return value; reproduce with an
unassigned `register s32 v __asm__("$2")`, and stop hunting for a dropped call
§276 MIXED ADDRESS-EXPRESSION SPELLING as a CSE-unification dial — spell one occurrence
of a repeated symbol as offset arithmetic on its neighbour ((&D_X)[1]) and cse
cannot unify them; found twice, independently, on the same function
§277 RETURN-TAIL C SPELLING picks the delay-slot-fill vs trailing-move topology
VERIFIED AT MERGE, not taken on trust (R14/G3): the leftover-register read, the CSE-defeat
spelling, the compound-rounding pair (live in ov_SC03_095), and func_801846F0's delay-slot
`addu $v0,$zero,$zero`. Two reviewer claims did NOT survive and are corrected in place:
§275's law was stated as "no call anywhere in the body" when the function has five jal's —
what makes it true is that no write to the register PRECEDES the read; and a claimed
harness defect (func_800CE004 "will not bank") is false, it has a real body at
src/md_MAIN_044/md_MAIN_044.c:443 and corpus.stubs does not list it as open.
B and C reached the same CSE lever from different waves and the §1-I5 / §219 rounding law
arrived twice on three overlays — both unified into one entry rather than duplicated.
Index regenerated: 806 sections. The lane immediately raised its next batch (cf, 34
candidates), which is the proof it is unblocked.
.run/maintenance.sh (what runs) and tools/lanes/maintenance.sh (a pre-S59 copy) had
diverged. The 150->50 threshold tune landed on the stale copy and was then copied over
the live one, silently reverting five S59 fixes:
* the R47 shape filter (staging fell back to status=='AGREE' alone — the exact defect
that staged 82 hopeless drafts every 45 minutes)
* the R48 (binary, fn) keying (bare-fn keys collide across overlays)
* reloc --fix MISMATCH auto-repair (measured 4/4 repaired to AGREE)
* rtu_second_chance (re-judges standalone COMPILE-FAILs against the real TU)
* fix_tu_ret_decls (the return-type half of the stale-decl wall)
Rebuilt from the S59 lineage with the 150->50 threshold and the periodic fleet R22
re-applied, both paths now byte-identical, `bash -n` clean, and the two-path hazard
documented in the header so the next edit cannot repeat it.
Also: relaunch_drafter_shell.sh 30s -> 5s ready-marker poll; regenerated backlog and
fleet progress artifacts.
docs/tool-designs/aprop-lane-s59.md: baseline (117 staged / 0 banked = 82
shape-DIFF + 19 standalone-fail + 16 near-0, none invisible), the defect
classes with byte-proofs, the fixed pipeline's end-to-end numbers (64+ banked,
zero tokens), the near-miss taxonomy (11 IMM tier-2, 8 wrong-family), the
ceiling with every refusal named and sized, and the two pre-existing RED
binaries the scoped R22 surfaced (SC07_010 fixed green; SC07_002 named for the
jtbl owner).
Cookbook: §270 the four-verdict law (instructions/symbols/TU/whole-binary —
stage on fewer and burn a build per missing layer forever), §271 ordinal
candidate pairing, §272 K&R the definition, §273 the wrong-oracle law.
maintenance.sh now runs the full recovered pipeline unattended: shape-gated
(binary,fn)-keyed staging, reloc --fix repair+recheck, rtu second chance,
fix_tu_ret_decls on fresh near-0 rejects.
PROVEN: from 14:57:01 to 18:43:23 today HEAD built main to 307aa45d… against the
expected 143dbb89…, with NO draft substituted (measured under gate.main.lock, no
gate_main alive). Auto-commit commit:2693 had adopted a mid-flight gate_main
substitution — its carve-out reverted main's TUs, gate_main re-wrote them, and
`git add -A src/` swept the unverified bodies in (a TOCTOU race, 14 s after a
bisect chunk banked). Every main batch after it was doomed before its first
draft was judged: m00–m03 card cycles drafted ~737, slated 160, banked 0, and
burned ~50 clean rebuilds bisecting innocent slates. commit:2712 restored the
green content by accident (it swept this investigation's diagnostic checkout).
gate_main: on any batch failure, ONE try_batch([]) control runs first — if HEAD
itself is red it prints BASELINE RED, leaves the slate reusable, exits 3 (R40).
clean_build no longer reports a linked-but-mismatched build as "no binary" (the
build target embeds the SHA check), the compile-conflict shortcut fires only on
error-shaped lines naming a symbol some draft in the slate actually uses (the
baseline's own func_800143AC implicit-decl WARNING was matching — every m04
chunk died with "drafts declaring it: []"), reverts narrow to top-level src/*.c
(main_tus) so a main gate can never destroy overlay lanes' in-flight work, and
--assert-baseline is a first-class mode.
main_lane: every cycle opens with gate_main --assert-baseline and REFUSES to
draft or gate against a red baseline (R43) — BaselineRed parks nothing, burns
no tries, writes .run/main_lane.BASELINE_RED, re-checks every 30 min.
Adopters (ox_campaign ×3, maintenance.sh, gate_stage, gate_lane, idiom_serial):
main's TUs (top-level src/*.c) are never staged and never reverted by an
overlay/maintenance lane — one writer (gate_main), one committer (main_lane,
after the whole-EXE SHA re-checks green). Unstage-after-add is race-free where
the old revert-then-add was the losing half of the TOCTOU.
Diagnosis, evidence and the full timeline: docs/tool-designs/main-lane-fix-s59.md
I reported 240 of 244 turn-finishes truncated in wave bk and called it ~100%. That
count came from grepping lines containing 'finish=', which api_agent only prints when
a turn ends WITHOUT a tool call — so the denominator was not all turns, it was all
anomalous turns. I compared a subset against itself.
Counting every turn:
bk (8k / 420s): 240 truncated of 3,222 turns = 7.4%
bt (16k / 700s): 16 truncated of 1,210 turns = 1.3%
Still a ~6x improvement and the change stands on its own evidence, but it is a tax
reduction, not the collapse I described. Recorded alongside: a truncated turn is one
turn of 24, not a lost agent — the logs show the agent emitting its tool call on the
very next turn.
Both docs keep the wrong figure explicitly, with why it was wrong, so the next reader
does not re-derive it from the same grep.
Drew T