QA pass: fix Enter storm-skip (deployed), log findings; Sprint 13 plan + prompts

LANE_PROMPTS.md

@@ -668,3 +668,86 @@ E 8828; integration holds 8823).
 > 0.22/0.30/0.35 hints from B's re-audit once the sim reads them — the
 > numbers are yours to defend or move, with B's audit as the evidence. The
 > tree-move stays cancelled.
+
+---
+
+# SPRINT 13 prompts (the garden matters, the night looks like a night)
+
+Same rules: own clone, own branch, rebase onto latest main FIRST (your local
+branch may be BEHIND origin after integration fast-forwards — start with
+`git fetch origin && git reset --hard origin/lane/<x>` on a clean tree). Read
+THREADS from the last two [I] entries — the QA pass entry is this sprint's
+evidence base — then SPRINT13.md. Per-clone launch.json: copy the example,
+pick your port (A 8824, B 8825, C 8826, D 8827, E 8828). Baseline selftest
+335/0/0; keep it green after every landing; new asserts get mutation-checked.
+The game is PUBLIC now (partly.party/hardyards) — main must always be
+shippable.
+
+## Lane A — Sprint 13
+> You are Lane A on SHADES 3D, Sprint 13. Rebase onto main, read THREADS'
+> last two [I] entries, then SPRINT13.md. Gate 3 is yours and it's the front
+> door of a public game: pin the Enter-exploit fix with a regression assert
+> (the hot-fix is already in your main.js with a comment — an advance()
+> reachable from 'storm' must go red; mutation-check by reverting the guard),
+> then the splash card (premise + controls + START, one more .card, not a
+> menu system), P pause / M mute, and the touch-visitor notice. Gate 2 gives
+> you two camera fixes: spawn framing (no pole through the player on boot)
+> and the aftermath cloth-swallow (dead sail joins the camera's solid set).
+> Two rulings will route to you: C's garden separation target (gate 1) and
+> whether GARDEN_DRAIN moves once the shadow geometry is honest. Move the dev
+> fps line out from under the anchor panel. Do NOT start reputation, site_03,
+> or heatwave — gate 4 decides Sprint 14. Shepherd as always.
+
+## Lane B — Sprint 13
+> You are Lane B on SHADES 3D, Sprint 13. Rebase onto main, read THREADS'
+> last two [I] entries, then SPRINT13.md. Gate 1.2 is yours: the audit's
+> "cover%" told three people a $20 rig was bad while the sim paid it +$97 —
+> once C lands the shadow-geometry fix, make the audit PREDICT the sim's
+> garden outcome (same quantity, two harnesses) and re-post the per-night
+> winnable-lines table; propose fee/bonus retunes in THREADS if night balance
+> re-breaks, A rules. Gate 3 smalls in your files: BLOWN label collision for
+> adjacent corners, setHardware() must not silently no-op on a bad key,
+> standing-kN preview per corner in the prep panel (D's "first lesson costs
+> $60 blind"), and rig.t must reset between nights. Stretch, only if room:
+> sweep mixed-hardware fuse lines (D's +$147 exhibit) and rule-or-flag
+> whether cheap-corner-as-fuse is depth or a hole.
+
+## Lane C — Sprint 13
+> You are Lane C on SHADES 3D, Sprint 13. Rebase onto main, read THREADS'
+> last two [I] entries, then SPRINT13.md. You carry this sprint. Gate 1: the
+> shadow GEOMETRY is the bug — measure rain/hail shadow over the bed (held
+> rig vs bare bed, both yards, five storms), fix the model not the constant
+> (hail's damage share, bed-level occlusion, storm hail timing — your pick,
+> measured), and propose the separation target to A BEFORE tuning to it. The
+> sim must make "sail up" vs "sail dead" read alive-vs-dead on wild nights.
+> Gate 2: storm grade (sky/light/shadow keyed on intensity — the noon-blue
+> 65 km/h sky is the QA pass's biggest visual finding), ground the front
+> wall's base on the horizon and feather its hard vertical seam (judge from
+> IN-YARD eye height, not your bench), and a handful of deterministic leaves
+> streaming with the wind from ~30 km/h. Everything (dt, t) as always.
+
+## Lane D — Sprint 13
+> You are Lane D on SHADES 3D, Sprint 13. Rebase onto main, read THREADS'
+> last two [I] entries, then SPRINT13.md. You are the verdict on both big
+> gates. Gate 1: replay the QA pass's three scenarios exactly (night 2 cheap
+> line; night 3 carport line with the sail dead at t=3; night 3 honest line)
+> after C's model lands — losing the sail must COST the garden, holding it
+> must SAVE it, numbers filed. Gate 2: judge the storm grade, the wall from
+> inside the yard, the leaves, and wire E's wind clips in player.js
+> (thresholds off wind.speedAt(player.pos), brace on the existing C key).
+> Fix your two pool nits: the ladder label says "fascia" on a carport
+> bracket, and the dropped spare's whereabouts after a knock. Also run down
+> the ghost-white sliver near the shed table in aftermath — it smells like
+> your ladder's placement ghost.
+
+## Lane E — Sprint 13
+> You are Lane E on SHADES 3D, Sprint 13. Rebase onto main, read THREADS'
+> last two [I] entries, then SPRINT13.md. One job, done to your own standard:
+> wind clips for the player — lean / stagger / brace, staged by wind band
+> (calm, working breeze, gale), through the Mixamo pipeline. Deterministic
+> factory, byte-identical across runs, dims verified, and LOOK at the
+> silhouette before you ship (your bike rule: the verify can't answer "is
+> this the right shape"). D wires them; agree the clip names and band
+> thresholds with D in THREADS before you export. Stand by for retune
+> arguments if gate 1's garden fix moves your bonus numbers — yours to
+> defend or move, evidence in THREADS.

SPRINT13.md

@@ -0,0 +1,129 @@
+# SPRINT 13 — THE GARDEN MATTERS, AND THE NIGHT LOOKS LIKE A NIGHT
+
+*Sprint 12 made the trap real and the paperwork beautiful, and the integrator's
+QA pass (THREADS, last [I] entry — read it FIRST, it is this sprint's evidence
+base) found the gap that's left: the game PLAYS dramatically and LOOKS calm.
+The sail died at t=3 on the funnelled buster and the bare bed still finished
+83%; a 65 km/h southerly ran under a noon-blue sky; and the public URL
+(partly.party/hardyards is LIVE — strangers can reach this game now) had an
+Enter exploit that paid full price for a storm that never ran. 335/0/0 at
+integration; the Enter fix is hot-fixed and deployed, unpinned.*
+
+Baseline: selftest **335/0/0**. Every landing keeps it green and adds asserts
+that can actually fail — mutation-check anything you'd call coverage.
+
+## Gate 1 — THE GARDEN MATTERS (C owns the model, B the audit, D the verdict, A rules)
+
+Three independent sightings of one variable (QA entry, 🌱 section): the sim's
+garden outcome barely responds to whether a sail is up. A's GARDEN_DRAIN
+comment in main.js names the suspect — the rain shadow decays to ~nothing as
+wind builds (driving rain walks under the sail), so a perfect rig is ~23%
+drier than a bare bed and NO drain constant can separate good rigging from
+none. The core fantasy ("the seedlings are the whole point") is not currently
+true in the sim.
+
+1. **C — the shadow geometry is yours.** Diagnose where protection actually
+   goes: measure rain-shadow-over-bed and hail-shadow-over-bed across wind
+   speeds for (a) a held honest rig, (b) a bare bed, both yards, all five
+   storms. Then fix the MODEL, not the constant. Candidate levers, yours to
+   choose with measurements: hail carrying more of the damage budget on windy
+   nights (stones fall ≤20° off vertical — a sail honestly stops them; rain
+   at a 73° lean honestly doesn't), a bed-level occlusion term (the bed has
+   sides; driving rain at 73° hits the planting from the side the FENCE and
+   sail edge shadow, not the sky), or storm-profile hail timing. The DESIGN
+   target A rules on (propose it in THREADS before you tune to it): **a held
+   honest rig vs a bare bed must separate by enough that the garden bonus
+   reads as earned — think alive-vs-dead on the wild nights, not 88-vs-83.**
+2. **B — cover% and bed-HP must become the same quantity.** Your audit's
+   "cover" told three people a $20 rig was bad while the sim paid it +$97.
+   Whatever C lands, your audit must PREDICT the sim's garden outcome — same
+   number, two harnesses, or the tool goes back to lying politely. Re-post
+   the per-night winnable-lines table once C's model lands; expect the cheap
+   lines to finally price honestly. If the fix re-breaks night balance
+   (nights 4–5 were already bank-funded), propose fee/bonus retunes in
+   THREADS with the table as evidence — A rules.
+3. **D — the verdict.** Replay the three QA scenarios exactly: night 2 cheap
+   line, night 3 carport line (sail dead at t=3), night 3 honest line. The
+   acceptance is felt, not asserted: losing the sail must COST the garden,
+   holding it must SAVE it, and the invoice's garden line must feel earned in
+   both directions. File numbers like always.
+4. **A — two rulings.** The separation target (C proposes, you rule), and
+   whether GARDEN_DRAIN itself moves once the geometry is honest (your
+   comment says the constant was compensating; it may want lowering back).
+
+## Gate 2 — THE NIGHT LOOKS LIKE A NIGHT (C + E + D judges; A wires camera)
+
+The QA 🌤 section, in priority order. All sim-visible work stays deterministic
+`(dt, t)` — no Date.now, no Math.random in the render path keyed off wall time.
+
+1. **C — storm grade.** Sky colour, light intensity, and shadow softness keyed
+   on storm intensity: as the wind builds the sky dims toward slate, the sun
+   loses its noon edge, the yard reads WEATHER. Cheap version first (lerp the
+   sky/hemisphere/directional intensities off the same intensity curve the
+   rain already uses); a dusk baseline palette for the whole week is in scope
+   if it stays one constant away from reversible — it is the NIGHT shift.
+2. **C — the wall's edges.** From in-yard eye height (not the bench): kill
+   the hard vertical seam (soften/feather the bank's ends) and ground the
+   base ON the horizon — blue sky under the wall reads as a floating slab.
+   D re-judges from inside the yard this time.
+3. **C — ambient debris.** A few leaves streaming with the wind from ~30 km/h
+   sells the gale better than any HUD number. debris.js is yours; keep the
+   count tiny (single digits) and deterministic.
+4. **E — wind clips for the player.** Lean/stagger/brace Mixamo clips, staged
+   by wind band (calm / working breeze / gale). Ship them like every clip:
+   deterministic factory, byte-identical, dims verified, and LOOK at the
+   silhouette — your own bike rule. **D wires them** (player.js is D's):
+   thresholds off `wind.speedAt(player.pos)`, brace pinned to the C key that
+   already exists.
+5. **A — two camera fixes.** Spawn framing: the boot camera puts a pole
+   dead-centre through the player on every single first impression — bias the
+   spawn yaw so the opening frame is player + bed + sail line, no pole. And
+   aftermath: the dead draped sail can swallow the camera whole; the cloth
+   needs to join the camera's solid set (you own camera.js and its setSolids).
+6. **D — judge all of it in play** and fix your two pool nits while you're in
+   there: the ladder label says "fascia" on a carport bracket, and the dropped
+   spare's whereabouts after a ladder knock are unknown.
+
+## Gate 3 — THE FRONT DOOR (A owns; the public URL earns it)
+
+1. **Pin the Enter fix.** The hot-fix is in main.js with a comment; write the
+   regression assert — an `advance()` reachable from 'storm' via keydown must
+   go red. Mutation-check it by reverting the guard.
+2. **Splash card.** Name, one line of premise ("rig shade sails; keep the
+   client's garden alive through the storm"), controls (WASD · mouse orbit ·
+   [ ] tension · S spare · E repair · C brace · Enter commit), one START
+   button. It is the game's real front door now — a stranger from
+   partly.party's arcade should know what to do in five seconds. Keep it in
+   hud.js's card system (.card, .go) — it is one more card, not a menu system.
+3. **Pause + mute.** P pauses the fixed-dt accumulator (storm only; cards
+   already pause by construction), M mutes C's audio bus. Two keys, shown on
+   the splash and the help line.
+4. **Touch notice.** A coarse-pointer/no-keyboard visitor gets a polite card
+   ("HARD YARDS needs a keyboard and mouse — grab a laptop") instead of a
+   dead canvas.
+5. **Small ones, spread by ownership:** BLOWN label collision when adjacent
+   corners die together (B — marker layout is rigging.js); `setHardware()`
+   silently no-ops on an unknown key — throw or ticker it (B); dev fps line
+   sits under the anchor panel (A); ghost-white sliver near the shed table in
+   aftermath — identify and fix or explain in THREADS (D, it smells like the
+   ladder ghost); standing-kN preview per corner in prep (B — the panel is
+   yours; D's "first lesson costs $60 blind" find); `rig.t` never resets
+   between nights (B). **B stretch, only if the gate-1 re-audit leaves room:**
+   sweep mixed-hardware lines for fuse behaviour (D's +$147 exhibit) and say
+   whether cheap-corner-as-fuse is emergent depth to keep or a hole to close.
+
+## Gate 4 — JOHN PLAYS (six sprints standing, and the URL makes it easy)
+
+partly.party/hardyards, five nights, three sentences in THREADS. The Sprint 14
+branch — reputation/warranty vs site_03 vs heatwave days — stays undecided
+until they land. Nobody builds any of the three this sprint.
+
+```
+gate 1: shadow geometry fixed by measurement · separation target ruled and hit ·
+        audit cover% predicts sim garden · D feels the difference both ways
+gate 2: storm grade in · wall grounded and seamless from in-yard · leaves fly ·
+        player leans into the gale · spawn frame clean · camera can't drown in cloth
+gate 3: Enter assert pinned · splash, pause, mute, touch notice shipped ·
+        the small-ones list empty or argued in THREADS
+gate 4: John's three sentences
+```

THREADS.md

@@ -4511,3 +4511,53 @@ anchors are your GLB), but the tooling is now waiting, not TODO.
 
     **Gate 4 is OPEN: Sprint 13's branch — reputation/warranty vs site_03 vs heatwave — waits on
     John's three sentences, and the game is the best argument for playing it that it has ever been.**
+
+[I] 2026-07-17 — 🔍 **INTEGRATOR QA PASS — I played it. Three nights, both yards, took the carport
+    bait on purpose. HARD YARDS is live at partly.party/hardyards, and this entry is the snag list
+    the deploy earned.** Everything below was seen in the running game, not reasoned about.
+
+    **⚠️ FIXED AT INTEGRATION, A to pin: Enter skipped the storm and paid in full.** main.js's
+    keydown fell through to `game.advance()` in EVERY phase, so Enter during a storm jumped straight
+    to a perfect invoice — I banked +$90 on a night that never ran; garden 100%, "every corner
+    held", clean bonus, on the public URL. Hot-fixed (`if (game.phase !== 'prep') return;` before
+    the commit path — forecast/aftermath already advance through their cards, which `hud.cardOpen`
+    catches). Selftest 335/0/0 after; Enter-in-prep still commits; Enter-spam in storm verified
+    inert. **A: the fix is in your file with a comment; give it the regression assert it deserves —
+    an advance() reachable from 'storm' must go red.**
+
+    **🌱 THE BIG ONE — the garden barely matters, and this is now THREE sightings of one variable.**
+      1. D's replay table: their in-sim $20 flat rig banked 39/45 garden bonus on night 2 where B's
+         audit calls that line "29% cover".
+      2. My night 2: $20 all-carabiner line, P4 blown mid-storm — garden 88%, +$97.
+      3. My night 3: sail DEAD at t=3 (carport line, both cb corners gone in the settle), bare bed
+         through the entire funnelled buster — garden 83%, bonus +$37 of $45.
+    A's own GARDEN_DRAIN comment names the suspect: the rain shadow decays 0.38→0.04 as wind builds
+    (driving rain walks under the sail), so a perfect rig is only ~23% drier than a bare bed and no
+    drain constant can separate good rigging from none. The game's core fantasy — "the seedlings
+    are the whole point" — is not currently true in the sim. This is Sprint 13 gate 1.
+
+    **🌤 The night doesn't look like a night.** At 65 km/h with driving rain the sky is noon-blue,
+    shadows are razor-sharp midday, the player stands bolt upright and unbothered, and debris reads
+    0 through night 3. All the drama is mechanical, none of it is atmospheric. Also seen: C's front
+    wall from IN-YARD eye height (not the bench) shows a hard vertical seam on its edge and its
+    base floats above the horizon with blue sky underneath — direction and timing are excellent,
+    the edges need licking. Sprint 13 gate 2.
+
+    **🚪 Front-door gaps, now that strangers can reach it:** no splash/onboarding (a cold visitor
+    lands on the job sheet and learns the controls only from prep's help line), no pause, no mute
+    (and C just added audio), no restart short of reload, nothing shown to a phone/touch visitor
+    but a dead canvas. Spawn framing puts a pole dead-centre through the player on every boot; in
+    aftermath the dead draped sail can swallow the camera whole (no cloth-vs-camera handling).
+
+    **Smaller, seen in play:** adjacent BLOWN labels overlap (CB1/CB2 died together and typeset on
+    top of each other); `setHardware()` silently no-ops on an unknown hardware key; the dev fps
+    line sits under the anchor panel; a ghost-white sliver floats near the shed table in aftermath
+    (the ladder's placement ghost?). Plus the carried pool from D: standing-kN readout in prep,
+    rig.t never resets between nights, ladder label says "fascia" on a carport bracket, dropped
+    spare's whereabouts, mixed-hardware fuse lines unswept.
+
+    **The good news, so nobody reads this as a bad report card: the invoice is the best thing in
+    the game** — the .void strike-through, the −$126 in red, "THE GARDEN MADE IT. The sail didn't"
+    — a bad night reads as a story you did to yourself. The trap fires as theatre, the Vasilaros
+    brief is perfect bait, and the loop is solid. The gap between how the game PLAYS and how it
+    LOOKS is the whole of Sprint 13.

web/world/js/main.js

@@ -875,15 +875,18 @@ export async function boot(opts = {}) {
 
   addEventListener('keydown', (e) => {
     if (e.key !== 'Enter' || hud.cardOpen) return;
-    // Leaving prep means committing the rig — Lane B's session refuses if it
+    // Enter means ONE thing: commit the rig and start the night. It used to
-    // isn't four corners, and says so in the ticker.
+    // fall through to game.advance() in every phase, which made Enter DURING
-    if (game.phase === 'prep') {
+    // a storm skip straight to a perfect invoice — the storm never ran, every
-      if (!rigging.commit()) return;
+    // corner "held", full pay. Found in the SPRINT12 QA pass, live on the
-      // Off the bank, not off START_BUDGET — see the note on showTonight().
+    // public deploy. Forecast/aftermath advance through their cards (cardOpen
-      spentThisNight = week.bank - rigging.summary.budget;
+    // catches those above); nothing else may advance the phase machine.
-      player.sim.carrying = null;
+    if (game.phase !== 'prep') return;
-      if (rigging.summary.spares > 0) pushEvent(`spare shackle on the shed table — grab it before you need it`);
+    if (!rigging.commit()) return;
-    }
+    // Off the bank, not off START_BUDGET — see the note on showTonight().
+    spentThisNight = week.bank - rigging.summary.budget;
+    player.sim.carrying = null;
+    if (rigging.summary.spares > 0) pushEvent(`spare shackle on the shed table — grab it before you need it`);
     game.advance();
   });