diff --git a/docs/LANES/LANE_F_NOTES.md b/docs/LANES/LANE_F_NOTES.md index 6121200..3840f17 100644 --- a/docs/LANES/LANE_F_NOTES.md +++ b/docs/LANES/LANE_F_NOTES.md @@ -1413,3 +1413,37 @@ precious. **What ships is the sweep, and the tag says exactly that:** **Filed for R29 (D, one opt):** `rigs.js` gains `look` the way it gates `sit`; F passes it from the shell. Then the pose gate has a subject and F will run it. **v6 has not begun in-game — the tag must not say it has.** + +--- + +## 29. Round 29 wave 0 — **the pose gate gains its subject. v6's first clip is in the game.** + +R28's gate had **no subject** and skipped with the reason printed. D bound the clip in wave 0, so the +gate binds too — and it is now permanent, not a hand-proof: + +| assertion | result | +|---|---| +| default boot: `look.glb` **bound** | **6.5 s, 64 tracks** | +| **the glance reaches the game** | **peak 46 of 396 peds glancing** · 0 console errors | +| `?classic=1`: the clip | **never fetched** — the zero-fetch-delta covenant holds | +| `?classic=1`: the behaviour | **inert at the source** — 0 of 269 peds, **and the rng stream still draws** | + +**That last row is the whole design, and it's D's cleverness worth naming: the determinism lives in the +DRAW, not the outcome.** D takes from a dedicated `glanceRng` stream *always* — so the seeded sequence is +identical whether or not a clip exists — and only flips the flag when `fleet.lookClip` is real. Under +`?classic` the roll still happens, the flag never sets, nothing is fetched, and the covenant is +byte-identical. Add a behaviour without touching a hash. + +**And the gate asserts the clip's ABSENCE under classic, not just "0 glancing."** "0 glancing" alone +passes on a fleet that failed to load entirely — the vacuous form of this exact check. Present on the +default boot + absent under classic is the pair that can't both be satisfied by a broken fleet. + +### ⚠ F's gate crashed the suite before it ran — worth recording +The first cut checked for its subject with `pg.goto('.../look.glb')`. Navigating to a `.glb` starts a +**download**, Playwright aborts the navigation, and the exception took `flags_check` down with it — +before a single assertion ran. **A gate that dies looking for its subject is worse than one that skips: +it doesn't report "no subject", it reports nothing at all, and takes the suite with it.** The +subject-presence check now reads the disk. *The vacuous-gate law has a sibling: a gate must survive its +own subject being absent.* + +**No tag** — wave 0 rides Spike 2's close, which is gated on John's footage. Nothing else is owed on m3. diff --git a/tools/flags_check.py b/tools/flags_check.py index 55f6a3d..6484cea 100644 --- a/tools/flags_check.py +++ b/tools/flags_check.py @@ -1369,6 +1369,75 @@ def smoke_tier2(p): _gv_start(REAL_DB) # leave the box as we found it: the REAL POS serving +def smoke_glance(p): + """R29 Spike 1 — THE POSE GATE, un-SKIPPED. v6's first thread, and the first clip to reach the game. + + R28 wrote this gate and it had NO SUBJECT: `look.glb` was converted, verified, published, and + sha1-proven by fetching the bytes back off the depot — and nothing bound it. Every check E ran was + real and passed; none could see that no consumer existed (a gate on the artifact cannot see the wire + — the R17 pattern's fifth outing). It SKIPPED with its reason printed rather than report green over + nothing. D bound it in R29 wave 0, so the gate binds too. + + Asserts the two things that matter, and they pull in opposite directions: + · the glance REACHES THE GAME — peds actually enter the state, on the default boot; + · `?classic=1` never fetches the clip and never glances — while STILL DRAWING THE ROLL, because + D takes from a dedicated rng stream always and only flips the flag when a clip exists. That is + what keeps the covenant byte-identical while the behaviour is gated: the determinism is in the + draw, not in the outcome. Asserting "0 glancing" alone would pass on a fleet that failed to load + — so we assert the clip is ABSENT under classic and PRESENT on the default boot.""" + head('SMOKE: the glance (R29 Spike 1 — v6\'s first clip in the game · classic still zero-fetch)') + b, pg, errs = new_page(p) + try: + # Check the subject on DISK, not via pg.goto — navigating to a .glb starts a download and + # Playwright aborts the navigation, which crashes the gate instead of skipping it. A gate that + # dies looking for its subject is worse than one that skips: it takes the suite with it. + if not os.path.exists(os.path.join(str(ROOT), 'web', 'models', 'peds', 'look.glb')): + print('· SKIP: look.glb not on disk — subject absent, nothing asserted (Lane E)'); return + boot(pg, 'plansrc=osm&town=redhill_godverse') + r = pg.evaluate("""async () => { + const P = window.PROCITY, c = P.citizens; + let peak = 0; + for (let i = 0; i < 9000; i++) { c.update(1/60); + if (i % 30 === 0) { const p = (c._activeList||[]).concat(c.roster||[]); + const g = p.filter(x => x && x.glance === true).length; if (g > peak) peak = g; } } + const p = (c._activeList||[]).concat(c.roster||[]); + return { bound: !!P.fleet.lookClip, dur: P.fleet.lookClip ? P.fleet.lookClip.duration : 0, + tracks: P.fleet.lookClip ? P.fleet.lookClip.tracks.length : 0, + peak, pop: p.length, rng: p.some(x => x && !!x.glanceRng) }; + }""") + OK(f"default boot: look.glb BOUND — {r['dur']:.1f}s, {r['tracks']} tracks") \ + if r['bound'] else FAIL('default boot: look.glb is NOT bound — the R28 gap is back') + OK(f"the glance REACHES THE GAME — peak {r['peak']} of {r['pop']} peds glancing") \ + if r['peak'] > 0 else FAIL(f"no ped ever glanced across 9000 ticks ({r['pop']} peds) — clip bound, behaviour absent") + if errs: FAIL(f'glance: {len(errs)} console error(s); first: {errs[0][:120]}') + else: print(' · 0 console errors') + finally: + b.close() + + b, pg, errs = new_page(p) + try: + boot(pg, 'classic=1') + r = pg.evaluate("""async () => { + const P = window.PROCITY, c = P.citizens; + let peak = 0; + for (let i = 0; i < 6000; i++) { c.update(1/60); + if (i % 40 === 0) { const p = (c._activeList||[]).concat(c.roster||[]); + const g = p.filter(x => x && x.glance === true).length; if (g > peak) peak = g; } } + const p = (c._activeList||[]).concat(c.roster||[]); + return { bound: !!P.fleet.lookClip, peak, pop: p.length, rng: p.some(x => x && !!x.glanceRng) }; + }""") + # NOT bound is the assertion: ?classic must not fetch the clip at all (zero-fetch-delta covenant) + OK('?classic=1: look.glb NEVER FETCHED — the zero-fetch-delta covenant holds') \ + if not r['bound'] else FAIL('?classic=1 FETCHED look.glb — the covenant is breached') + OK(f"?classic=1: glance inert at the source — 0 of {r['pop']} peds, and the rng stream still draws " + f"({r['rng']}) so determinism is in the DRAW, not the outcome") \ + if (r['peak'] == 0 and r['rng']) \ + else FAIL(f"?classic=1: peak {r['peak']} glancing / rng stream present={r['rng']}") + if errs: FAIL(f'glance/classic: {len(errs)} console error(s); first: {errs[0][:120]}') + finally: + b.close() + + def smoke_continuity(p): """R15 identity continuity (ledger #3): the ped who queued/surged into a venue turns up in its crowd. Exercises F's real relay end-to-end — VenueQueue.admitOne() → onAdmit → citizens.recordVenueEntry → @@ -1478,6 +1547,7 @@ def main(): smoke_audio(p) # R11 — audio house-law (silent-happy · pre-gesture · mute · noassets · leak) smoke_gigs(p) # R12/13 — the district gig layer (schedule · band · crowd · budget · cover · noassets) smoke_continuity(p) # R15 — identity continuity (the ped you followed is in the crowd · settled tris) + smoke_glance(p) # R29 — Spike 1: v6's first clip in the game (classic zero-fetch) smoke_tier2(p) # R27 — the kill-the-server gate (charter law #1) smoke_real_crate(p) # R24 — THE REAL CRATE (per-shop atlas identity · soft fall · no-op off the path) finally: