From eb132b719aed0ec0307e2a25c8102b482fad2e20 Mon Sep 17 00:00:00 2001 From: Drew T <50529377+Druthulu@users.noreply.github.com> Date: Wed, 26 Aug 2026 00:32:08 -0600 Subject: [PATCH] =?UTF-8?q?docs(phase-31):=20S61=20interim=20checkpoint=20?= =?UTF-8?q?+=20cookbook=20=C2=A7293=20(the=20sibling=20law=20decomposed:?= =?UTF-8?q?=20the=20baseline,=20not=20the=20siblings)=20+=20decision-log?= =?UTF-8?q?=20entries=20+=20accelerator=20#12?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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. --- docs/accelerators.md | 8 ++++ docs/decision-log.md | 80 +++++++++++++++++++++++++++++++++++++ docs/matching-cookbook.md | 50 +++++++++++++++++++++++ phase-ends/CURRENT_PHASE.md | 57 ++++++++++++++++++++++++++ 4 files changed, 195 insertions(+) diff --git a/docs/accelerators.md b/docs/accelerators.md index 6c30a4dac..7e53844a0 100644 --- a/docs/accelerators.md +++ b/docs/accelerators.md @@ -261,3 +261,11 @@ accelerator: for ANY lane that mass-produces candidates from a template, build t FIRST (cheapest oracle to most expensive, every verdict consumed, every drop named), and treat "an oracle exists but the lane doesn't consume it" as a defect with a per-pass machine cost, not a nice-to-have (`docs/tool-designs/aprop-lane-s59.md`, cookbook §270–§273). + +## #12 — Byte-locate the residual before blaming the draft (P31 S61) +`cmp -l built retail | map through .map` names the first misplaced symbol, its delta, section +and OBJECT in ~2 minutes; name-encoded symbols (D_/func_/jtbl_) mean the retail address is +already in the name. One derivation replaced days of "CAUSE NOT DETERMINED" backlog rows and +turned 15 mystery walls into three named config repairs. Corollary: gate verdicts need a green +baseline — audit `make build BINARY=` per binary BEFORE trusting any per-draft verdict +(gate_stage now refuses red-listed binaries' drafts as BASELINE-RED). diff --git a/docs/decision-log.md b/docs/decision-log.md index 9f717dfb9..266e3c19e 100644 --- a/docs/decision-log.md +++ b/docs/decision-log.md @@ -2489,3 +2489,83 @@ three-quarters-hopeless numerator. The real denominator is 973 open members; the reachable slice is ~120/pass banking at ~50–60%; the remaining ~850 are named residuals (169 STRUCT cracks, 121 type-inference, ~73 IMM tier-2, wrong-family cards) — work for different tools, not this lane. Saying so beats reporting a flattering fraction of the wrong denominator. + +## 2026-08-25 (P31 S61) — the wall is an integration wall: stop re-drafting solved functions, re-judge them + +**Context and belief.** Through S58–S60 the campaign optimised the wide wave: band, mix, card +count, sibling-inclusive draws, straggler handling, gate parallelism. Each lever moved yield by +single digits while first-gate conversion slid from 51% (dd) to 1–6% (en/eo/ex/ey/ez), and the +going explanation was population exhaustion of a *codegen* frontier — the gen6+ "wall". + +**What the measurement said instead** (`docs/tool-designs/frontier-analysis-s60.md`, a read-only +Fable audit at session end): of the 292 functions refused six or more times, 178 had ALREADY +produced a closeness-0 draft — byte-equal at the object level, refused by the whole-binary gate — +and across the open pool ~571 functions had finished drafting. The fleet kept re-drafting them +(10,049 reject rows over 574 distinct functions), and the gate spent ~3 whole-binary builds per +failing draft confirming failures that were never about the draft's text. + +**The pivot.** Build the deterministic lane the analysis asked for instead of touching the wave +again: `tools/integration_resolver.py` treats the ledgers as an INDEX (not a promise — a July +closeness-0 draft can CC1-fail today because the fleet's declarations moved), re-judges every +candidate at the REAL split TU with `rtu_match`, requires `reloc_identity` to agree on symbols +(rtu masks relocation fields, so a wrong symbol name still reads MATCH — R34's disagreeing +oracle), rebases with `aprop_symfix` where only names are wrong, stages, gates on the whole-binary +SHA, commits at once (R42). Refuses main by name, `//@EDIT` drafts, dirty trees, collapsed +registries; a negative control over recently-banked functions must pass N/N before a verdict is +read (its first form picked carve moves as banks and failed 9/12 — fixed before any stock verdict +existed, R35). + +**Why, in numbers (denominators, R41).** First pass, 2026-08-25 23:38–23:48: 1,352 nominated +(binary, fn) pairs → 901 already banked, 27 main → **424 judged in 41 s → 245 staged (57.8%) → +63 banked** (net INCLUDE_ASM delta; the commit subject's "72" counted 9 carve moves), zero model +tokens, ~10 minutes wall. The wave lane's best recent gate banked 13 of 222 in a ~30-minute gate. +The falsifier (<5% survive intake) was not close. + +**What the refusals then taught, byte by byte.** 182 doubly-verified drafts were still refused. +Probe 1 (`md_SC03_076/func_801EFBB4`, 407 ins): the spliced binary builds and 66 bytes differ at +file offsets 324–2440 — the `.rodata` jump tables the stub's `.s` carried (`jtbl_801EF5AC`, +`jtbl_801EF5E4`) move by one word when the compiler emits them itself: the §8e/§260 table-placement +class, not codegen. Only 43 of the 182 carry rodata at all; 139 (in 16 binaries) were refused with +no rodata coupling — that residual is the next thing to characterise (cookbook §293 records what the +probes find). + +**Hindsight — the better path.** The ledgers held the evidence for weeks: `closeness: 0` rows with +"whole-binary gate rejected — CAUSE NOT DETERMINED" as their verdict. A verdict that names no cause +is a measurement nobody can act on; the cheap move — re-judge the stored body at the real TU and +diff the BYTES of the built image against the good one — costs ~90 s per function and should have +been the gate's own failure report from the day the ladder was built. Generalisable: when a +correctness oracle says "no" without saying where, build the second instrument that says where +before tuning anything upstream of it. + +## 2026-08-26 (P31 S61, small hours) — the RED fleet: the wave collapse had a third cause nobody was billing + +**Context.** After the resolver banked 63 zero-token functions, 182 of its doubly-verified drafts +(rtu-MATCH at the real TU, reloc-AGREE on symbols) were still refused by the whole-binary gate, and +the per-binary refusal counts were all-or-nothing: 23/23, 23/23, 18/18, 13/13 in single binaries. + +**What the probes said.** All-or-nothing per binary is not a property of drafts. A clean-tree build +of the fully-refusing binaries: 15 of 214 fleet binaries were baseline-RED at HEAD — seven not even +building (stale JTBL_PADS after S60's evening banks/reverts), the rest byte-shifted (a missing +interleave entry; a wave-committed half carve). They had been red for 4–12 hours because the fleet +R22 sweep was guard-skipped whenever any gate was in flight — i.e., always. Every wave gate and +every resolver gate against them since was a measurement of the BINARY billed to the DRAFTS — +part of the "1–6% conversion" story S58–S60 attributed to population exhaustion. + +**The pivot.** Stop diagnosing drafts; audit and repair baselines: per-binary clean audit → the +byte-proven repairs (jtbl_pads_fix for pad drift — itself first un-broken three ways, R40; +insertions-only interleave regeneration from the splat yaml for layout shifts) → a gate-side +BASELINE-RED refusal so a red binary's drafts are never judged (negative-controlled both ways) → +re-open the mislabeled refusals in the resolver ledger for automatic re-judging. + +**Casualties of the night, recorded because they are the pattern.** The repair tool's own writer +poisoned the registry into a make parse error that failed every build of every binary for ~9 +minutes, voided one wave's re-gate and its own candidate search, and was adopted by a blanket +pre-gate commit (R52 instance #2). Two gater-restart helpers killed themselves via unanchored +pgrep self-match (the S60 hazard, from the other side). Every one of these is the same lesson: +the instrument — including its write path, its restart path, and the baseline it measures against +— is part of the experiment. + +**Hindsight.** The S60 close declared "tree clean, all lanes stopped" and was true, while 15 +binaries were silently red — "clean" and "green" are different invariants, and only one of them +was checked. A session-close ritual (and any wave post-mortem) should quote the fleet's GREEN +count next to the tree's cleanliness; tonight that number was 197/214 pretending to be 214/214. diff --git a/docs/matching-cookbook.md b/docs/matching-cookbook.md index 43cde197f..1efafd63a 100644 --- a/docs/matching-cookbook.md +++ b/docs/matching-cookbook.md @@ -29017,3 +29017,53 @@ the per-candidate verdicts above: ## §292 — DECLARING A SYMBOL UPSTREAM OF AN ALREADY-BANKED SIBLING THAT RELIES ON THAT SYMBOL'S IMPLICIT (K&R) DECLARATION CAN SILENTLY REPROTOTYPE THE SIBLING'S OWN CALL SITE (P31 S60; waves #, byte-proven) # + +## §293 — THE "WHOLE-OBJECT GATE NEEDS EVERY SIBLING" LAW, WRITTEN PROPERLY: IT IS THREE LAWS, AND THE LOAD-BEARING ONE IS "THE BASELINE, NOT THE SIBLINGS" (P31 S61; byte-proven on 15 binaries in one night) + +Eight cards across four waves independently re-derived "the whole-object gate needs every sibling +matched" (§283 flagged it as the strongest missing-section signal). Taken literally it is FALSE — +`--chunk 1` gates one draft per build and a correct draft banks with every sibling still a stub — +but the agents were observing something real. It decomposes into three separable laws: + +**(1) The batch-revert policy artifact (historical, already ended).** §12/§14-L1144/§20: a chunked +gate or an all-or-nothing slate reverts every co-spliced draft when ONE fails, so a byte-perfect +body reads as refused. `--chunk 1` + stage-0-first ended the mechanism; the folklore survives in +cards because the SYMPTOM (my perfect draft won't bank) persists via (2) and (3). + +**(2) The structural coupling that is real: a bank moves rodata.** A stub's `.s` carries the +function's jump tables and migrated rodata islands at their RETAIL positions; banking the function +makes the COMPILER emit them into the TU object's `.rodata` instead. Retail layout then survives +only if the carve chain is complete and current: the splat yaml `.rodata` subsegment (§8), the +object's entry at the right position in `_JTBL_INTERLEAVE` (§8b), and a correct per-object +`JTBL_PADS` spec (§8e). ONE missing or stale piece shifts every later rodata/data/text reference — +byte-witnessed tonight: a single absent `ov_MAIN_012_jr_8016AB6C.o` interleave entry displaced +1,671 symbols by +0x20; a stale 2-entry pad spec (its `switch` function had been reverted, taking +a table with it — the R51 stored-derived-property class) held ov_SC01_006 RED; ov_SC04_000's wave- +committed carve left the order list one object short (+0x2944 from `tail19` on). None of this is +about siblings — it is about the OBJECT's rodata bookkeeping. + +**(3) The load-bearing law: A GATE VERDICT IS A MEASUREMENT OF THE DRAFT ONLY WHILE THE BINARY'S +BASELINE IS GREEN.** When (2) breaks, the BINARY fails its locked SHA with no draft spliced at all +— and then every draft gated against it is refused regardless of quality, which reads exactly like +"my sibling is blocking me." Measured tonight (S61 fleet audit, 214 binaries): **15 binaries were +baseline-RED at HEAD**, and they accounted for **174 of the 182 refusals of the resolver's +doubly-verified drafts** (245 staged; rtu-MATCH at the real TU AND reloc-AGREE on symbols). They +went red DURING S60's evening incremental banking — §61c's "incrementally valid, clean-invalid" — +and the fleet sweep that would have caught them had been guard-skipped since 12:54 (R54). The gate +now refuses a red-listed binary's drafts as class BASELINE-RED before any build (gate_stage, +`.run/baseline_red.txt` ∪ `.run/fleet_red.txt`), so a broken baseline can never again be billed to +the drafts. Corollary, one night, same class: an INSTRUMENT'S OWN WRITE PATH IS PART OF THE +INSTRUMENT — `jtbl_pads_fix.write_pads` split its target line on ':' (but `:=` contains one), +poisoned the registry into a make parse error ("target pattern contains no '%'"), which failed +EVERY build of EVERY binary, voided its own candidate search (0 winners: its writer broke the +build it was measuring), and was adopted by a blanket pre-gate commit (R52's second instance). +`mk_write` now refuses parse-poisoned lines. + +**Recipe when a "wall" function won't bank and the body is proven:** (a) `make build BINARY=` +on a CLEAN tree first — if the baseline is red, stop blaming drafts; (b) locate the shift, don't +guess: `cmp -l` the built image against the retail bytes and map offsets through the linker map — +name-encoded symbols (`D_/func_/jtbl_`) make "first misplaced symbol, delta, section, object" +a two-minute derivation; (c) the object it names tells you which carve piece is missing/stale +(yaml subsegment / interleave entry / pad spec); repair THAT, byte-prove, commit; (d) only then +re-judge the drafts — tonight the resolver's ledger re-opened them automatically (BASELINE-RED is +not a final verdict). diff --git a/phase-ends/CURRENT_PHASE.md b/phase-ends/CURRENT_PHASE.md index 0785fa49c..d2828356a 100644 --- a/phase-ends/CURRENT_PHASE.md +++ b/phase-ends/CURRENT_PHASE.md @@ -1991,3 +1991,60 @@ Every serious stall traced to **an instrument trusted without a control**, never ## (superseded) previous checkpoint (end of build arc) **T0–T9 ALL COMPLETE AND COMMITTED** (through `commit:2181`). Phase totals: **17 banked, 0 agent tokens**; stubs 12,059 → 12,042; R22 213/213 verified twice (post-T1, post-T6). The machine: the Atlas (5,139 groups, `make atlas`), the widened lanes (symfix STALE-DELTA, recover_integration isolation + macro-externs/tu-scope, family_align + len_tells + lenmiss routing), the armed queues (grinder: 59 warmstart records; cards: 954 weak + 192 len + 704 adapt; permuter-49). NEXT = **T10+ the campaign loop**: L3 grinder running in background (launched at checkpoint time); **card/crack WAVES need Drew's `/effort ultracode` toggle first (R27)** — prompt and WAIT. Campaign cadence + close criterion: the plan file §Leg-C. If resuming fresh: read the approved plan + this log; check `.run/auto/grinder_heartbeat.json`; run `make atlas` to refresh; continue the loop. + +--- + +## 🛑 SESSION CHECKPOINT — S61 INTERIM (2026-08-26 00:5x). Phase 31 T10+ CONTINUES. Lanes: gater + maintenance + resolver_lane UP (drafter deliberately DOWN). + +**The session so far, in one paragraph.** Read `frontier-analysis-s60.md` and executed its sequence: +built the INTEGRATION-RESOLVER (tools/integration_resolver.py + lanes/resolver_lane.sh) — first pass +1,352 nominated → 424 judged in 41 s → 245 staged (57.8%) → **63 banked, zero tokens, ~10 min** +(commit:2991; subject says 72 = gross incl. 9 carve moves). Probing why 182 doubly-verified drafts +still refused exposed the night's real story: **15 of 214 binaries were baseline-RED at HEAD** +(stale JTBL_PADS / missing interleave entries / half-committed carves from S60's evening), refusing +174 of those 182 regardless of draft quality; the fleet R22 sweep had been guard-skipped since +12:54. Repairs so far (each byte-proven, committed): ov_SC01_006 (pad spec 0,0→0), ov_MAIN_012 + +ov_SC02_037 (missing jr_8016AB6C.o interleave entry; +0x20, 1,671/2,176 misplaced symbols). A +background batch (`.run/resolver/probe/repair3.sh`) is running jtbl_pads_fix over 9 more + +insertions-only interleave regeneration for 3. Casualties fixed en route: jtbl_pads_fix was broken +three ways (stale OBJ_ERR bracket regex; only one drift phrasing; write_pads' colon-split poisoning +the registry into a make parse error that failed EVERY build for ~9 min and was adopted by a blanket +commit — R52 #2); mk_write now REFUSES parse-poisoned lines; gate_stage now refuses red-listed +binaries' drafts as BASELINE-RED pre-build (negative-controlled both ways). + +**Measurement/tooling shipped:** campaign_status derives banked-today from the INCLUDE_ASM +invariant (+ anchored pgrep alive()); gater ledger carries gate_min beside wall_min; maintenance +fleet sweep is draw.lock-aware (it actually runs now); rtu_shadow.py (prospective ledgers for +fa–fd EXIST at .run/rtu_shadow/.jsonl; join handles 0-bank waves + excludes REDs); +build_wave_atlas holds resolver-owned (binary,fn) from draws; resolver ledger re-opened 146 +refusals on RED binaries as BASELINE-RED (auto re-judged next pass). Cookbook §293 (the sibling +law decomposed — the load-bearing part is THE BASELINE, NOT THE SIBLINGS), two decision-log +entries, accelerators #12. + +**In flight right now:** gater re-gating fb honestly (third attempt — attempts 1–2 were voided by +a NameError guard then the poisoned registry), queue fc/fd/fe/ff behind it; repair3 batch; +a Fable agent building tools/decl_from_use.py (negative-control-first; its scratch may appear as +src/*/.cdecl_*.c dotfiles — untracked noise, sweep after it reports). Resolver lane wakes every +45 min and will re-judge the re-opened items against repaired binaries. + +**Next after the notifications:** (1) repair3 results → update .run/baseline_red.txt → commit → +trigger a resolver pass early; (2) fb..ff gates → `tools/rtu_shadow.py --join fb --join fc ...` → +the INVERSION decision (§3: false-negative <~2% flips the gate to rtu-first); (3) decl_from_use +slate → resolver intake; (4) then S61-5 re-aim (gen0/main/3–8 band) + the 8k-vs-16k A/B on the +first relaunched wave; (5) escalation tier only after the resolver stock drains. + +**Hazards for whoever resumes:** kill lane PYTHONS by PID and verify with `ps -o lstart` (pgrep -f +self-matches your own wrapper — it killed two restart helpers AND the gater tonight); never let a +script's own text contain the pattern it pkills; the gater blanket-commits src/ config/ at gate +entry — probes that splice into src/ must hold the per-binary lock AND finish before gate entry, or +ride into a chore commit (the ov_MAIN_012 repair did — commit commit:2998 — harmless but +mis-attributed). Stop sentinels are CLEAR; `.run/baseline_red.txt` is live gate input — keep it +current as repairs land. + +**Rule candidates added tonight (P10):** R56 — A GATE VERDICT IS A MEASUREMENT OF THE DRAFT ONLY +WHILE THE BINARY'S BASELINE IS GREEN; check the baseline before billing the subject (extends +R35/R40 to the subject's environment; enforcement shipped as the BASELINE-RED skip + the fleet +audit). R57 — AN INSTRUMENT'S OWN WRITE PATH IS PART OF THE INSTRUMENT: a repair tool whose writer +corrupts what it measures voids its own search and reports the corruption as the subject's failure +(write_pads; extends R40/R43). R58 — A SESSION-CLOSE "CLEAN" MUST QUOTE THE FLEET'S GREEN COUNT: +tree-clean and fleet-green are different invariants (S60 closed "clean" with 15 binaries red).