rollout_o0 hardcoded `<ov>_o0b.c` as the whale object and listed SC07_006/007/010/011 as
OUT-OF-SCOPE. They were never out of scope structurally — the suffix letter just drifts:
_o0b across the fleet, _o0c in SC07_010, _o0d in SC07_006/007/011. The invariant that
actually identifies the object is that it ENDS at the whale and therefore includes
shared/func_80144B9C.h.
whale_file_of() resolves on that content, and refuses (never guesses) when two -O0 files in
one overlay match, or none do.
NEGATIVE CONTROL (R39) over the already-succeeding population: across all 134 overlays that
bank through the legacy `_o0b.c` path, content resolution returns EXACTLY that file — 134
agree, 0 disagree. The four SC07 overlays resolve to their _o0c/_o0d objects, and overlays
with no -O0 object at all (ov_MAIN_012, ov_SC02_037, ov_SC03_107 — the U3 carve group) are
still refused with `no-o0b`.
Result: func_801457A4 BANKED in all four, each proven by `make build BINARY=<ov>` matching
config/check.<ov>.sha. 4 functions / 316 instructions, no splat change, no drafting.
Also: build_ok() now takes `.run/auto/gate.<bin>.lock`, the same per-binary lock the gater,
sweep_parallel and the maintenance sweep take. This driver was written to be run by hand
between waves; with six lanes live, two processes in one build/<ov> tree would produce a
verdict about neither.
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.
GsTMDfastF3GNL
GsTMDfastG4GNL
SetSXSYfifo
VM_NO1_OBJ_184
func_8002F150
func_80053AD8
func_800626F0
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.
MEASURED across the harvested notes: 13 citations to sections that do not exist — §2329
(x5), §13446, §13474, §1914, §19189, §2392, §3478 — against a corpus that stops at §273.
Every one is a grep -n LINE NUMBER cited as a section number, and each resolves to a real
section that says what the note claimed: line 2329 is inside §28 (the stranded/pure-extern
class), 13446/13474 inside §164, 1914 inside §20 > §21.
The cost is compounding: the next agent greps "§2329", finds nothing, and re-derives a
lever we already own — and a distill reviewer scores the note "covered by §2329" as covered
by a section nobody ever wrote. Both directions of the flywheel corrupt.
Not a warning in the brief (R33): grep now returns the right answer. Every hit in
matching-cookbook.md is prefixed with its containing heading, nested where the corpus nests
(`§164 > §16Xy | docs/...:13446: ...`), so the number in front of the model is the one to
cite. Index is built once per process and cached by mtime; 555 headings resolve.
Takes effect on the next shard — api_agent is spawned fresh per draft, no restart needed.
Found by the S60 distill reviewers reading 218 harvested notes.
The code landed in commit:2780 ("main lane m11aab — 3 banked"), not under its own message:
the main lane ran `git add -A src/ config/ && git commit` while my files sat STAGED, and a
lane commit takes whatever the shared index holds. Lesson for every future session: with
lanes running, never leave anything staged — commit with `git commit --only <paths>`, which
builds its own temporary index, or stage and commit in one atomic command.
WHAT commit:2780 ACTUALLY CONTAINS, beyond its 3 banked functions:
perf(drafter): overlap a wave's straggler tail with the next wave instead of blocking on it.
Measured four waves for four: once 95% of shards exit, collect_drafts() blocked through the
whole STRAGGLER_GRACE before the wave queued and the next one started — 11m40s each time
(cd 22:32->22:43, cc 23:06->23:18, ce 23:53->00:04, cf 00:37->00:48) at 4-13 live agents of
a 2,000-worker fleet. Against a ~44-minute wave cycle that is 27% of the campaign's wall
clock at 2-5% utilisation; the API rate fell from ~65 req/min to 2-5 in every trough, while
the API's own throttle knee — measured over 160,534 requests — is 150-250 req/min.
The 700s grace is correct and unchanged: a straggler mid-generation needs one full turn, and
a shorter grace guillotines agents mid-thought and costs drafts (S59, the 8k->16k
regression). What was wrong is BLOCKING on it. wait_for_tail() now returns the moment 95% of
shards are done and finish_wave_async() waits out the stragglers in a thread, then collects
and queues the wave; the tail overlaps the next wave's draw and ramp. Nothing in the thread
touches src/, config/ or a lock.
Tested: returns in 0.0s at 95% with the tail alive; NEGATIVE CONTROL (R39) — blocked at 75%,
released only at the real threshold; the marker is written only after the tail lands, with
the true draft count.
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.
FGO_06_OBJ_64
LightColor
OuterProduct0
VM_NO1_OBJ_1F4
VM_NO1_OBJ_264
VM_NO1_OBJ_28C
VM_NO1_OBJ_4A4
func_80010AE0
func_800144D4
start
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_2DD8
_clr
func_8005EA68
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_80027058
A marker is a CLAIM on work, not a record of it. axbm.json sat in .run/distill_ready
for 10.5 hours AFTER its waves were distilled into cookbook §269 — the reviewer landed
the sections, updated the mined state, and never removed the marker — and distill_scan's
one-pending-marker-at-a-time rule (correct, it stopped eight overlapping batches) then
refused to raise anything while 18 waves / 315 novel candidates accumulated behind it.
The marker's own waves are checkable against the mined state, so check them: a marker
whose every wave is already mined clears itself and says so. Negative control (R39): a
marker naming any still-unmined wave survives untouched.
Same family as R47 — a stage that consumes work must also consume the token that
represents it.
.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.
1,342 banked, 140 commits, open stubs 6,575 (main 1,493 / overlay-md 5,082).
The session's one lesson, measured six times: every lane that looked like the models
underperforming was a harness defect — an -O0 oracle nothing ever passed, a lane
retired on a card-size verdict, carve machinery nothing fed, a poisoned main baseline
that made 737 drafts read as bad, a soft 429 killing 44-72% of shards at turn 1, and a
stager consuming one bit of one verdict.
Records what landed (jtbl island split + gate automation, the -O0 census and unlock,
the new main and distill lanes, two RED binaries fixed, the throughput settings with
their probe evidence, the portable-workflow doc), seven rule candidates for PhaseEnd
approval, the ranked open threads with the A-prop residual named and sized, and a
resume procedure that starts from campaign_status.py and verifies from the process
rather than the file.
150 was tuned for a lane that only re-swept an unchanged sibling pool and banked
nothing. The lane now consumes every verdict layer in the A-prop pipeline, carries the
free pre-gate reject recovery, and runs the periodic fleet R22 — a pass is worth
running on a much smaller refill.
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_11C
SYS_OBJ_19A4
SYS_OBJ_222C
SYS_OBJ_2CC4
SYS_OBJ_640
SetDrawOffset
VM_NOWON_OBJ_230
VM_NOWON_OBJ_2C8
func_80028488
func_80041354
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_8002EB10
func_8005EA88
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_800525DC
Two binaries sat RED for hours today and nothing noticed: ov_SC07_010 from a
maintenance commit whose final tree state was provably never built, and ov_SC07_002
from a stale 2-table jtbl pad spec written at wave bp. Every lane only ever checks the
binary it is currently touching, so a byte-gate — a correctness oracle — was silent
about everything it did not build. They were found by accident, by an agent's scoped
R22 sweeping 141 binaries.
Every 4th maintenance pass (~3h), skipped while any gate is in flight (check-all
rebuilds stale objects and must not race a gate), it runs the fleet check and writes
any REDs to .run/fleet_red.txt with a loud log line. It FIXES NOTHING: a wrong repair
to a pad spec or a config is exactly how a silent byte shift gets committed, and the
two we fixed today each needed a different, evidence-led remedy.
The binary has been RED since wave bp (commit:2687), where the gate-time jtbl carve
wrote 'JTBL_PADS := 0,0 # tables=+0x0,+0x20' for ov_SC07_002_jr_8017C8D0.o. The
object emits ONE rodata .align, so jtbl_rodata_pads refused every build:
consumed 1 rodata .align(s) but 2 pad spec(s) given — table-count drift vs the carve
make: *** [build/src/ov_SC07_002/ov_SC07_002_jr_8017C8D0.o] Error 1
The carve itself is legitimate — jr_isolate_all's jr_inventory resolves every
committed .rodata carve in this binary to exactly one banked owner (R32/R33), so this
was never an orphaned carve. Only the pad SPEC was wrong, and §8e's own rule is that a
single-table span gets no line at all (its pipeline stays byte-identical to pre-§8e).
Removing the line restores it:
sha1 fad71342019704d1dd6ec25f2f3934c97e322624 == config/check.ov_SC07_002.sha
Found by the A-prop agent's scoped R22 (141 binaries affected, 96 SHA-checked), which
also fixed ov_SC07_010 — a binary whose committed tree state had provably never been
built. Two RED binaries had been sitting in the fleet while every lane gated against
them; neither was noticed because no lane checks a binary it is not currently touching.
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_16C
SYS_OBJ_1A70
SYS_OBJ_FD8
SetPriority
SetRGBfifo
SetRii
SquareRoot12
func_80010BB4
func_80028304
func_8002EA10
func_80047D3C
func_8005AB00
func_8005B75C
gfx2D_BG0_OBJ_1B4
gfx2D_BG0_OBJ_4A0
gteMIMefunc
OpenRouter returns a provider throttle as HTTP 200 whose body has no 'choices' and an
error of {"message": "Provider returned error", "code": 429}. That never reached the
429 handler, which keys on HTTPError, so it fell through to the 'no choices' raise and
ended the agent at turn 1 with no draft, no submit, $0.00 spent.
Measured, and it is not marginal:
wave cb: 169 of 260 shards hit a soft 429
wave cc: 115 of 260
wave cd: 187 of 260 <- 260 shards 'finished cleanly', 72 drafts produced
wave ce: 119 of 258
That is the draft-completion collapse. I had attributed 28-60% completion (against
84-89% before) to the straggler grace and raised it to 700s; the grace was never the
cause. The shard logs said 'finished cleanly' because the agent DID exit normally —
after being killed by an unretried rate limit on its first API call.
Now treated like every other transient: back off, retry, and log it as SOFT-BODY so
the rate telemetry stops under-counting 429s. Takes effect on the next wave's shards —
api_agent is spawned fresh per shard, so no lane restart is needed.
R40 again: the fleet looked like it was giving up, and the harness was hanging up on it.
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.
DrawSyncCallback
SetSZfifo3
_drs
func_80059888
func_80059D68
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_8002E818
func_8005EAA8
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.
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_80011DA0
func_80011E84
func_800273F4
func_8002D4C8
Measured 23:20: the maintenance lane held .run/auto/draw.lock for a multi-minute
sweep, the pre-draw buffer happened to be empty, and the drafting fleet — the one
clock-limited resource — sat at 13 agents and 3 req/min printing 'gate holds the draw
lock and nothing is pre-drawn — waiting 30s' every thirty seconds.
That wait dates from when drawing during a gate was genuinely unsafe: corpus.stubs()
misreports for a binary whose sources carry a substituted draft (R35), so the draw
refused outright. Since 15:23 build_wave_atlas excludes exactly the binaries whose
per-binary gate lock is held and draws from the rest, so the hazard is handled at the
right granularity and the blanket wait now protects nothing.
Same lesson as the draw's own refusal earlier today: a guard scoped more broadly than
the hazard gets routed around or, worse, quietly starves the thing it sits in front of.
1. decl_for searched the DESTINATION for the SEED's name: a RENAMED symbol's
destination spelling can only exist under the MEMBER's name, so the
destination preference silently never applied to renamed data symbols
(D_801B9DF8 adopted the seed's 'short' against the TU's file-scope 's32').
dest/fleet tiers now search target_sym; seed tiers keep the seed name.
2. dest_scope is FILE-SCOPE-ONLY (brace-masked): the TUs are full of
block-scope externs inside banked bodies, and a flat regex adopted one of
those as 'the destination spelling' over the DEFINE macro's true file-scope
decl.
3. A body-embedded block extern that diverges from the destination file scope
is rewritten to the destination spelling when every use is ADDRESS-ONLY
(type is codegen-irrelevant for &sym); valued uses keep the seed spelling.
+ fix_tu_ret_decls.draft_ret now parses K&R definitions (its first run SKIPped
30 of 32 because the param decls sit between ')' and '{').
tools/fix_tu_ret_decls.py: sweep-1's dominant residual (32 fresh near-0 rejects
— byte-correct bodies, TU-refused) is the RETURN-TYPE half of the stale-decl
wall: the TU forward-declares 'extern void f(void);' while the byte-true
definition returns s32; the gate's arity pre-pass relaxes the PARENS but not
the return. Retyping the TU's own decls to 'extern s32 f();' (byte-neutral:
every declared-void caller ignores $v0 — fix_header_decl's proven argument,
TU-scoped) banked 14 byte-identical, journaled edits kept only where the gate
paid. 12 SKIPs are void-returning defs (a different conflict, suspected
freshly-spliced (void) preambles), 4 retyped-but-refused.
The S59 scoped R22 sweep (96 binaries whose TUs instantiate the DEFINE macros
my engine_core edit touched) found ov_SC07_010 RED at HEAD: the 14:57
maintenance commit (commit:2694) banked func_8017F2BC's (s16*) definition into a
TU that still carries an earlier draft-preamble decl 'extern void
func_8017F2BC(void);' at line 4932 — conflicting types, TU uncompilable, though
the TU is byte-identical to its committed state (how that pass reported green
is an open question for the lane's arity/splice ordering). Provenance checked:
my commits touch only func_80162CCC decls; the pinned cc1 accepts the
no-proto+definition pair in isolation. Fix: the arity pass's own byte-neutral
no-proto form; whole-binary SHA re-checked green. ov_SC07_002 remains RED on a
jtbl_rodata_pads carve drift (also pre-existing, also from earlier passes) —
named in docs/tool-designs/aprop-lane-s59.md, not papered over.
Two new recovery mechanisms, both byte-proven this sweep:
6/7 rtu-second-chance: standalone COMPILE-FAILs re-judged in their REAL TU
(rtu_match) — 6 banked whole-binary; the standalone verdict was the
wrong oracle for a TU-destined draft
6/15 reloc UNRESOLVED/shape-MATCH: identity unverifiable locally, but the
whole-binary gate is the arbiter — staging them is free banks
Not banked: 5 MISMATCH?-advisory, 4 reloc-repaired (symbols now right, bytes
still differ), 2 old K&R conversions, 9 UNRESOLVED, 1 rtu (all reverted by the
gate; drafts retained in backlog).
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).
The population that banked 0/117 on three consecutive passes banks 38/80 with
the S59 fixes, attributed against the 21:04 baseline classes:
29 the closeness-2 ordinal cluster (value/offset swap -> candidate pairing
adjudicated by match_one at draft time)
4 the near-0 TU-integration class (K&R definitions + the arity pre-pass;
func_80162CCC x3 overlays among them — 42 engine_core.h caller decls
kept no-proto for the banked set, byte-neutral for empty calls)
5 drafts the old pipeline refused or mis-staged
Every bank is whole-binary SHA-verified by gate_stage/harvest_verify (G3/P9).
reloc_identity --fix's rowmap keyed rows by fn alone, so three same-named
func_8013BCDC rows across binaries all received ONE binary's draft — 2 of 4
'no textual occurrence' refusals were the tool editing the wrong file. Keyed
by (binary, fn): 4/4 repaired to AGREE/MATCH (byte-checked by re-run).
maintenance.sh: stage on status in {AGREE,UNRESOLVED} AND shape==MATCH keyed
(binary,fn); run reloc --fix on MISMATCH rows and re-check so repairs stage the
same pass; add rtu_second_chance for standalone COMPILE-FAILs (7/27 measured
TU-byte-MATCH, previously dropped unjudged).
aprop_autodraft decl_for gains the BORROW tier: when both home TU and seed are
silent, adopt a sibling TU's extern spelling under the same body-compatibility
guards — 'which TU may conflict' (home only) and 'where a guess may come from'
(anywhere) are different questions; refusing outright left 125 members undrafted.
Baseline measured on the 21:04 pass (117 staged, 0 banked): 82 near real-diff /
19 standalone compile-fail / 16 near-0 TU-integration; zero drafts invisible to
the gate (the 'drafts: 0' probe was the triage harness racing itself — a shared
per-fn probe dir rm -rf'd by a concurrent triage run, not lane plumbing).
1. K&R definitions (aprop_autodraft.kr_definition): the near-0 class is the TU's
own '(void)' decls + empty K&R call sites rejecting the draft's ANSI def
('too few arguments' after the arity pre-pass relaxes the decls). K&R the def
when every param is promotion-safe; byte-proven MATCH on func_80162CCC's real
TU (rtu_match) where the ANSI form CC1-failed.
2. decl_for scope: the destination is the HOME TU ONLY, macro-expanded
(dest_scope) — the whole-binary concat adopted spellings the home TU never
declares; and a dest spelling is adopted only when the seed body can compile
against it (void-return-value guard + call-arity guard; measured 42 and 15
fresh drafts died on each before the guards).
3. Ordinal IMM pairing is now a CANDIDATE SET (family_remap._ordinal_candidates):
the single-guess form paired the first spelling's occurrences only and shipped
35 of 117 drafts with value/offset swapped ('*(p+3)=2' for '*(p+2)=3',
closeness-2 forever); candidates are adjudicated with match_one at draft time.
4. Staging filter (maintenance.sh): stage only AGREE + shape==MATCH, keyed by
(binary, fn) — status-only staging burned 82 whole-binary builds per pass on
drafts match_one had already refuted, every 45 minutes.
+ tools/rtu_second_chance.py: standalone COMPILE-FAIL is the wrong oracle for a
TU-destined draft; re-judge those against the real TU (rtu_match) and stage
the MATCHes.
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.
ClearImage2
GsSortBg
SYS_OBJ_1578
SYS_OBJ_1790
SetGraphReverse
func_800167F0
func_8005C1C0
func_8005D8A0
func_8005E804
func_8005EA54
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.
StartRCnt
func_800145EC
func_8005E79C
func_8005EAC8
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.
VectorNormal
func_80018714
func_8001A0FC
func_80029240
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_19D8
func_8001751C
func_8005B684
Drew T