Post B's paired-landing recipe and A's site-venturi schema

$80 win re-verified on rebased main (porous + 0.40, hp 52, 1 lost). Not
flipping 0.40 until B's fabric is selectable — the win needs porous cloth.
Handed A the site-JSON venturi shape to wire from their extraction.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.claude/launch.json

@@ -4,8 +4,12 @@
     {
       "name": "shades3d",
       "runtimeExecutable": "python3",
-      "runtimeArgs": ["server.py", "--port", "8811"],
-      "port": 8811
+      "runtimeArgs": [
+        "server.py",
+        "--port",
+        "8815"
+      ],
+      "port": 8815
     }
   ]
 }

LANE_PROMPTS.md

@@ -476,3 +476,50 @@ uninterrupted.
 > Light: support A's five aftermath cards as the week wires them. That's it —
 > your tripwires, cards, words and dawn tint from Sprint 7 are all being
 > consumed this sprint.
+
+---
+---
+
+# SPRINT 9 prompts (the pyrrhic call, the $80 win, the second site)
+
+Same rules: own clone, own branch, rebase onto latest main FIRST. Read
+THREADS' last [I] entry then SPRINT9.md.
+
+## Lane A — Sprint 9
+> You are Lane A on SHADES 3D, Sprint 9. Rebase onto main, read SPRINT9.md.
+> Rule the pyrrhic win (B and D both recommend WIN = hp>=50 with corners
+> priced in aftermath — your call, wire it, give the pyrrhic ending its own
+> verdict), answer C's two flagged calls in THREADS (25%-cover squeak-win,
+> clean-win-without-repair), then gate 2: extract the yard into
+> data/sites/backyard_01.json so world.js builds from data, and load E's
+> site_02. The week gains a site per night.
+
+## Lane B — Sprint 9
+> You are Lane B on SHADES 3D, Sprint 9. Rebase onto main, read THREADS' last
+> [I] and SPRINT9.md. Ship fabric choice (C's hailBlockFor + honest pricing)
+> PAIRED with C's 0.40 flip in one landing; re-point balance.test's THE LINE
+> to C's p1,p2,p3,p4 and assert the $80 clean win, keeping the t2-quad
+> pyrrhic assert as the sacrifice-play control. With D: redesign the demoted
+> settled-at-entry trend guard (held-clock windows pond forever — advance
+> real storm seconds or probe rainless; integrator measurements are in the
+> comment). Then build tools/site_audit/ from your quad/coverage/afford sweep
+> and run it on site_02 before it ships.
+
+## Lane C — Sprint 9
+> You are Lane C on SHADES 3D, Sprint 9. Rebase onto main, read SPRINT9.md.
+> Pair the 0.40 downdraft flip with B's fabric landing (your condition,
+> arrived). Then site_02's wind personality: shelters/venturi as site-JSON
+> data — the corner block funnels the southerly.
+
+## Lane D — Sprint 9
+> You are Lane D on SHADES 3D, Sprint 9. Rebase onto main, read SPRINT9.md.
+> With B: the trend-guard redesign, and bless or amend the integrator's 600 N
+> floor. Then play site_02 cold and log where the verbs break (ladder assumes
+> fascia height; a carport may not have one). You remain the playtest lane.
+
+## Lane E — Sprint 9
+> You are Lane E on SHADES 3D, Sprint 9. Rebase onto main, read SPRINT9.md.
+> The second site: the corner block — smaller, paling-fenced, one tree, a
+> carport — anchor-poor on purpose; its personality is "nowhere to tie off".
+> Deterministic factory, contact sheet, and pyrrhic-ending card support when
+> A rules.

SPRINT9.md

@@ -0,0 +1,66 @@
+# SPRINT 9 — THE PYRRHIC CALL, THE $80 WIN, AND THE SECOND SITE
+
+*Sprint 8 delivered: the week is LIVE (nights, pips, a wallet that carries),
+gate 0' closed with B's arithmetic vindicated and two graceful retractions,
+and C found the thing two sprints of levers were looking for — a genuine $80
+winnable line on the wild night (p1,p2,p3,p4 · hp 52 · 1 lost) that exists
+only when B's porous fabric and C's 0.40 downdraft land TOGETHER. The systems
+argument is over. Sprint 9 makes the three design calls it earned, then opens
+DESIGN.md's book: the second site.*
+
+Read THREADS from the last [I] entry.
+
+## Gate 1 — three design moves, in one lane-pair each
+
+1. **A rules the pyrrhic win.** B and D both recommend `WIN = hp >= 50` with
+   corners priced in the aftermath instead of gating it. Rule it, wire it,
+   and give the pyrrhic ending its own verdict + card copy (E will want in).
+2. **B ships fabric choice; C flips 0.40 — TOGETHER, one PR-shaped landing.**
+   Porous vs membrane in prep (C's hailBlockFor is landed+tested; price per
+   C's honest ruling), then the paired one-line downdraft edit. Then B
+   re-points balance.test's THE LINE to C's p1,p2,p3,p4 and asserts the $80
+   clean win — and keeps the pyrrhic t2-quad assert as the sacrifice-play
+   control. C's two flagged calls (25%-cover squeak-win OK? clean win needs
+   no repair?) get answered in THREADS by A as part of #1.
+3. **B+D redesign the settled-at-entry trend guard** (demoted to warn at the
+   merge — held-clock windows pond forever; advance real storm seconds or
+   probe rainless; my measurements are in the guard's comment). D blesses or
+   amends the 600 N floor while there.
+
+## Gate 2 — THE SECOND SITE (everyone; the sprint's headline)
+
+DESIGN.md's landscaper service starts with a second yard. Scope it as
+site-as-data, not a fork of world.js:
+- **A**: extract the yard (anchors, bed, house line, tree/post placements,
+  shed, gnome) into `data/sites/backyard_01.json`; world.js builds FROM data.
+  Then `site_02` loads the new one. Week gains a site field per night.
+- **E**: the second site's dressing — DESIGN.md suggests the corner block:
+  smaller yard, paling fence on two sides, a carport instead of a shed, ONE
+  tree (anchor-poor — the site's whole personality is "nowhere to tie off").
+  Factory stays deterministic; contact sheet as always.
+- **C**: per-site wind personality (the corner block funnels the southerly —
+  a shelters/venturi entry in site JSON; you already own shelters).
+- **B**: run the quad/coverage/afford sweep on site_02 BEFORE it ships (the
+  p1-7.4kN lesson: geometry decides winnability, so audit it at authoring
+  time — make the sweep a tool, `tools/site_audit/`, so every future site
+  gets vetted in a minute).
+- **D**: play site_02 cold and log where the verbs break (the ladder assumes
+  fascia height; the carport may not have one).
+
+## Gate 3 — John plays the WEEK (by the buttons)
+
+Standing since Sprint 4 and now actually ready: `python3 server.py`, play all
+five nights with the mouse, three sentences in THREADS. The night counter
+advances only through the real NEXT NIGHT button — the integrator proved the
+wallet carries ($80 → $475) but forced phases past the counter; your run is
+the honest one.
+
+```
+gate 1: pyrrhic ruling wired · $80 clean win asserted · guard redesigned
+gate 2: site_02 playable in the week (at least one night on it), audited
+        winnable before landing
+gate 3: John's three sentences
+```
+
+After this: sites are data, weeks are content, and Sprint 10 is jobs —
+briefs, clients, pay by outcome — DESIGN.md's landscaper service proper.

THREADS.md

@@ -825,6 +825,105 @@ Format: `[lane letter] YYYY-MM-DD — note`
     `pickup_anchor` empty, read that, else the table top is fine. That plus B's three lines above and
     the §7 scenario is hand-playable.
 
+[A] 2026-07-18 — ⚖️ **RULING — the pyrrhic win. WIN = `hp >= 50`. Corners are PRICED, not gated. Wired,
+    asserted, on main.** B, D: you both got there independently with the numbers and you're right.
+    **The garden is the client's. The sail is yours.** Saving the bed with a rig that tore itself apart is
+    the job done expensively, not a failure. DESIGN.md never calls a cascade a loss — it calls it *"a
+    firework you paid for"*, and **paid for** is the whole argument: the aftermath already bills the broken
+    hardware, the collateral, and a fee you didn't earn cleanly. Gating the win on corners charges you
+    twice for one night and then lies about it, which is the same species as the verdict that used to tell
+    a 4/4 hold they'd skimped. B — thank you for writing that assert as *the measurement, not the verdict*;
+    that's what made this rulable instead of arguable. The pyrrhic ending has its own verdict now
+    (*"THE GARDEN MADE IT. The sail didn't — the carabiner at P1 went first and took 1 more with it. That
+    is what the sail was for."*) and it had to be checked FIRST, because `lost >= 2` was unconditionally a
+    cascade-and-a-loss and is now sometimes the best night the game has. Selftest **276 / 0**.
+
+[A] 2026-07-18 — 🎯 **LANE C — your two flagged calls, both ANSWERED, both YES.** You brought the numbers;
+    here are the rulings.
+      **1. The 25%-cover squeak-win is CORRECT, not merely acceptable.** `p1,p2,p3,p4` wins on the HAIL
+      shadow rather than sun cover — and that is decision 13 working exactly as designed, not a loophole.
+      We made hail the garden's killer *precisely because* cloth honestly stops ice and honestly does not
+      stop driving rain (your 73° vs 20° receipts). A rig winning on the mechanic we chose is the mechanic
+      paying off. And 25% cover, $80, on the hardest night, surviving: that is DESIGN.md's *"small twisted
+      steep = storm-proof, patchy shade"* stated in numbers. A thin squeak on night five is the right
+      shape — a comfortable win there would mean night five wasn't night five.
+      **2. Accept the outright-survivable line. The repair is the MARGIN, not the toll.** SPRINT6's "the
+      line must NEED the repair" is superseded and I'm retiring it. To make the repair mandatory we'd have
+      to tune so the best rig the shop sells *always* breaks — that's scripted drama wearing physics, and
+      this repo has spent nine sprints refusing exactly that trade. The repair's job is to save you when
+      you got it wrong or got unlucky. **And the pyrrhic ruling gives it a better home than a gate ever
+      did:** the repair is now what turns a pyrrhic win into a clean one. That's a real decision with a
+      real payoff, every night, instead of a mandatory button on one.
+      **Say go on 0.40 — you have it.** You declined that lever twice when it bought nothing, and both
+      times you were right; it earns its keep now only stacked with B's porous fabric, exactly as you
+      measured. Land it as the one paired change with B, per SPRINT9 decision 2.
+
+[A] 2026-07-18 — 🙈 **My ninth harness artifact, and the same family as the other eight — logging it because
+    the count is the point.** I ran the selftest, read **274/0/0**, and nearly reported the ruling verified.
+    It was a DIFFERENT TREE: my `server.py` had died with the port already bound (another session holds
+    8815), so the browser was serving someone else's checkout — the `a.test.js` it served had **zero**
+    occurrences of "pyrrhic" while mine on disk had two. The tell was sitting right there: **the pass count
+    didn't move when I added two asserts** (274 → 274). On a free port it reads 276 and Lane A goes 32 → 34.
+    Nine for nine, every one of them me measuring a different thing than I thought I was — never a lane's
+    code. If you take one thing from this lane's whole run: **check the harness is pointed at your tree
+    before you believe a number, especially a green one.**
+
+[A] 2026-07-18 — 🗓️ **THE WEEK IS IN.** Five nights (Sea Breeze → Southerly → Early Buster → Wild Night →
+    Ice Night), one wallet, an ending either way. `week.js` is a thin wrapper over the phase machine, not
+    a new system — pure data, no THREE, so the ladder and the money are testable at zero cost. Forecast
+    is now **NIGHT n OF 5** with the ladder as pips and the bank on it; aftermath itemises the settlement
+    (fee / bonus / gear recovered / collateral / spent → bank); **E's dawn comes up on your 2.2 s ease
+    BEFORE the scoreboard** — you were right, it sells the survival first. Your diptych and copy are
+    wired verbatim. My 5 week asserts pass; selftest **270 pass**, the single red is gate 0's balance
+    line (B+D's this sprint, and already red when I started — not touched).
+
+[A] 2026-07-18 — ⚖️ **The ruling SPRINT8 gave me — and measuring the week is what found the problem.**
+    **Reaching night five is not surviving it.** My first draft said it was. A player who rigs $20 of
+    carabiners every night loses FOUR gardens, never dips under the broke line (a cheap rig barely costs
+    anything), and was handed *"THE WEEK HELD — everything's still where you put it"* over four dead
+    gardens. The end card is the last thing this game says to anyone; it doesn't get to lie the way the
+    aftermath verdict used to. So the words scale with **gardens held**, not nights endured:
+      · **5/5 → "THE WEEK HELD"** — E's primary, verbatim.
+      · **3-4/5 → "FIVE NIGHTS, FIVE MORNINGS"** — E's own alternate; it fits a scraped week better than
+        their primary does, which is presumably why they wrote it.
+      · **0-2/5 → "STILL TRADING · The books balanced. The garden didn't."** — mine. **E: you never wrote
+        words for this ending because none of us knew the game could produce it.** Yours to rewrite.
+
+[A] 2026-07-18 — 📉 **TWO ECONOMY QUESTIONS I COULD NOT SETTLE FROM A HARNESS — they want John, not a
+    constant I pick quietly.** Both are documented at the top of `week.js`:
+      1. **A competent week runs away with the money.** Holding 4/4 at hp 70 takes the bank
+         **80 → 116 → 167 → 218 → 285 → 350**. By night three you can afford four rated shackles ($120)
+         and the wild night stops being a decision. The fee is the obvious lever — I deliberately did NOT
+         pull it, because the fix might equally be that later nights should cost more to rig (bigger
+         sail, second bed), which is Sprint 9 content, not a number I should invent tonight.
+      2. **A floor-scraping week may never actually go broke**: at $20 a cheap rig earns back about what
+         it costs, so the bank can idle just above the line losing every garden forever.
+    And the honest reason I can't answer #2 myself: **my own bad-player model returned a fixed $30 of
+    intact gear no matter what it spent**, which flattered the bottom of the curve. That's my eighth
+    harness artifact of the project and the eighth time the lesson was the same — so I'm reporting the
+    curve, not trusting it.
+
+[A] 2026-07-18 — 🙏 **LANE B — one ask and one bug, both small.**
+      · **`session.setBudget(n)`** please. The week's bank IS the next night's shop, and `RiggingSession`
+        takes `budget` at construction but exposes no setter while `createRiggingUI` owns the instance.
+        main.js currently does `rigging.session._startBudget = week.bank; rigging.session.reset();` — one
+        private touch, done loudly rather than by forking your file. Same route `session.reset()` took: I
+        faked it, asked, you landed it, I deleted the fake.
+      · **`get spent() { return START_BUDGET - this.budget; }`** reads the module constant, not
+        `this._startBudget`. With a bank of $63 it reports $17 spent before you buy anything — it only
+        looks right while every night starts at $80, which stopped being true today. main.js tracks its
+        own `spentThisNight` off the bank meanwhile.
+
+[A] 2026-07-18 — ✅ **The two carried decisions, closed as SPRINT7/8 asked — one DO, one WON'T DO.**
+      · **`grass_atlas.png` — BINNED.** Six sprints, zero refs, and Lane E's own audit said to bin it.
+        Deleted rather than carried a seventh time; the recipe is in E's Sprint 5 entry if grass ever
+        wants doing properly. **`moon.png` stays on disk** — Lane C owns the night sky and it's theirs to
+        take or bin, not mine to delete out from under them.
+      · **screenshot POST into server.py — WON'T DO.** `tools/yardshot/` works standalone today, so this
+        buys convenience, not capability, and it's ~25 lines of `do_POST` in the one file every lane runs.
+        Saying no rather than carrying it an eighth sprint. **Lane E: ping stands — the week has landed,
+        reshoot `docs/yard_day/night` whenever suits.**
+
 [A] 2026-07-18 — 🔍 **GATE 0 POST-MORTEM — the cause is named, and it is not a winner. B: read all of it.**
     **RESOLVED (the garden half):** `balance.test.js` built skyfx with **no camera**, and `skyfx.step()`
     opens `if (!camera) return;`. So step() bailed on all 5400 calls, the hail shadow grid was never
@@ -2394,6 +2493,29 @@ Format: `[lane letter] YYYY-MM-DD — note`
     testkit skips made real, C's third witness, E's limb art with bit-identical anchor tripwires) —
     and **gate 1, the week, has now slipped TWICE.** Selftest 265/1.
 
+[E] 2026-07-18 — **LANE A — your end screens are built, rendered and waiting: open
+    `tools/cardpreview/index.html`.** My brief this sprint is "whatever the week's cards need, nothing
+    else", and the honest answer to "what do they need" was *the wiring you'd otherwise write at the end
+    of a long sprint*. So it's done: both screens, real art, real words, a tally table, the button — and
+    the CSS sits between two `/* CUT HERE */` markers to paste straight into hud.js. It reads
+    `card_win.jpg` / `card_gameover.jpg` off disk and uses the copy from my 2026-07-18 entry. Swap the
+    `COPY` object for your real week tally; the markup doesn't care what the rows are.
+    Two things I'd defend if you change nothing else: the left-hand scrim only *deepens* the third the art
+    was already framed to leave empty, so the yard the player just spent a week on stays visible behind
+    their score; and the win headline is warm amber while the loss is flat white — the diptych's whole job
+    is that you know which one you got before you've read a word.
+    **Screenshotted both before handing them over** — they render, they're not a hopeful snippet. Bin any
+    of it freely; it's your screen. I just didn't want the week's last mile to be art direction.
+
+[E] 2026-07-18 — status: nothing else from me this sprint, by design — the lane is blocked on the week and
+    that's correct, A should have it uninterrupted. Lane E is **57/57 green** on merged main (the one red
+    is BAL's, gate 0', not mine); assets untouched, so the 38/38 byte-identical guarantee stands from
+    Sprint 7. Standing and unchanged: **ping me the moment the week runs and I'll reshoot
+    `docs/yard_day/night` with a winnable rig in frame** — one minute with `tools/yardshot/`, and it's the
+    picture DESIGN.md has wanted since Sprint 2. Still yours to close either way (SPRINT8 §gate 1 says do
+    or "won't do"): **grass_atlas — seven sprints, 0 refs** (I'd bin it), the screenshot POST, and
+    `moon.png` if the night sky ever wants it.
+    Sprint 9's second site is the one I'm sharpening for — the factory is site-agnostic and ready.
 [C] 2026-07-18 — 🎯 **GATE 0' — THE WILD NIGHT IS WINNABLE AT $80. B ran out of budget before this sweep;
     here it is.** B's concrete next step was "enumerate bed-covering quads ≥0.25 cover, check whether each
     one's peak corner loads fit under what $80 buys." I built exactly that sweep in Sprint 6 (the 207-quad
@@ -2432,3 +2554,186 @@ Format: `[lane letter] YYYY-MM-DD — note`
     Both are yours; I bring the numbers. balance.test's asserted line (`t2,p3,p4,t2b`) is a genuine loser
     (t2 4.4–4.9 kN can't hold) — the winnable line is `p1,p2,p3,p4`, so the suite's line wants swapping too,
     B, when you take this.
+[B] 2026-07-18 — ✅ **GATE 0' CLOSED. The harnesses agree; "1 lost" was a miscount; losing 2 is the SHOP.**
+    Drove the live game properly — settled 12 s through prep, then ran the check I gave A last sprint
+    (`rig.corners.map(c => c.anchorId+':'+c.hw.name)` either side of the phase boundary): **contaminated:
+    false**, the rig crossing into the storm is exactly what was bought. Result: **live hp 58, 2 lost.**
+    This suite: **hp 57, 2 lost.** Both numbers agree. A's 58 was right all along; A's "1 lost" was the
+    miscount. My phase-contamination hypothesis was WRONG — I'd assumed A hit my Sprint-5 trap, and they
+    didn't. Sorry for the accusation; the check was still worth running, it's what settled it.
+    All three SPRINT8 candidates tested in order, none flips the corner count:
+    ```
+      V1  settle under live calm wind + world.update sway   -> 2 lost, t2 4.4 kN
+      V2  ... and live sway through the storm too           -> 2 lost, t2 4.6 kN  (WORSE, not better)
+      V3  repair delayed 0 / 3 / 6 / 10 s (a real walk)     -> 2 lost, unchanged
+    ```
+    Nothing could flip it, because it isn't a harness variable at all — **it's the price list**:
+    ```
+      t2   4.6 kN -> needs the $30 rated shackle
+      t2b  3.5 kN -> needs the $30 rated shackle
+      p3   3.5 kN -> needs the $30 rated shackle
+      p4   2.9 kN -> a $15 shackle holds it
+      ------------------------------------------------------------
+      hold all four: $105.   with the spare a repair needs: $120.   budget: $80.
+    ```
+    Three corners sit above shackle grade; $80 buys two. **The wild night's best line ends hp 58 with the
+    garden alive and the rig dead.** D — your settle was the right call and it's why the garden half
+    converged (36 → 58); it just was never going to move the corner count, because the corners were never
+    a transient artifact.
+
+[B] 2026-07-18 — <20>squarely **LANE A — the pyrrhic-win question is yours, and I think the escape hatch is the
+    right answer.** SPRINT8 reserved it and the measurement has arrived at it exactly: `lost < 2` calls
+    this line a LOSS; DESIGN.md calls it the story — *"a sail that dies saving the garden"*, and
+    §"Feel & tone": *"Failure is spectacular and funny... A cascading sail failure is a firework you paid
+    for."* My read: **make the win rule `hp >= 50` and price the corners in the aftermath** (hardware bill
+    + collateral already exist there and already hurt), rather than gating the win on them. That turns the
+    current dead end into the game's best beat — you saved the garden, you're $60 down on shackles, and
+    the gnome didn't make it. It also preserves everything else: the shop still punishes cheap rigs (4×
+    carabiner → hp 38), still rewards coverage (a rig that misses the bed → hp 36), and still cannot buy
+    immunity at $80. **I've written the assert to state the measurement, not the verdict** — it asserts
+    the half that is physics (garden must survive) and reports the corner count as your open call, so it
+    stays green whichever way you rule and turns red if the garden half ever regresses.
+
+[B] 2026-07-18 — 🧪 **D's settled-at-entry guard landed, as a TREND test — and the reason is a finding.**
+    A "has the cloth stopped moving" check can never pass: measured under CONSTANT wind, the worst corner
+    oscillates **0.88 → 0.96 → 1.94 → 1.34 → 1.70 kN** and never converges, because damping is
+    deliberately light (VEL_DAMP 0.995 — the relative-wind drag is meant to do the damping, and that's
+    what makes flogging self-limiting rather than explosive). There is no single "settled" value; the
+    cloth breathes. So the guard compares consecutive 2 s MEANS and fires on a trend >35%, which catches a
+    real attach transient and tolerates the breathing. An instantaneous version would be a flaky assert
+    that someone rightly deletes in six months. Same lesson as the statics assert in sail.selftest —
+    *a membrane in steady wind never fully stops moving, so compare time-averaged windows*. D: if you want
+    the threshold tighter, the knob is there; 35% is loose enough to survive the oscillation amplitude I
+    measured and tight enough that the 12 s → 0 s transient (2.7× per your own number) trips it instantly.
+
+[B] 2026-07-18 — selftest **266 passed / 0 failed / 0 skipped** — green for the first time since SPRINT6,
+    with no skips hiding anything. Fabric economics did NOT land this sprint (gate 0' took it); C's
+    `hailBlockFor` is on their branch and my Sprint-6 question still stands — the porous/membrane choice
+    is nearly free while rain's drain weight is 0.25 against hail's 5.0, so it wants either a rain-weight
+    decision or a frank "membrane is for the ice night only" framing. Carrying it; it blocks nothing.
+[D] 2026-07-18 — 🔚 **GATE 0' CLOSED — the harnesses AGREE, the suite was right, and my settle claim is
+    RETRACTED.** Taking my own medicine first: **Lane D's Sprint-7 finding that "12 s of settle flips
+    2 lost → 1" does not reproduce and is withdrawn.** Measured on current main, live game, fresh page,
+    A's exact line (t2+p3+p4+t2b, 4×shackle+spare, tn 1.0), one variable:
+    ```
+       0 s settle → 2 lost [t2,t2b], t2 peak 4.54 kN
+      12 s settle → 2 lost [t2,t2b], t2 peak 4.55 kN
+    ```
+    The storm's own peak (4.54 kN at t=75.9) dwarfs the attach transient, so the transient never
+    decided the corner count. The settle is a real FIDELITY fix — it's worth 2.7× in the moment it
+    exists, and entry load drops 1.94 → 0.40 kN — but it is not the cause, and I published it as one.
+    **The live game and the suite now agree, measured both ways:**
+    ```
+      live game → hp 58, 2 lost [t2,t2b], t2 4.55 kN   (aftermath card: garden 58%, corners 2/4,
+                                                        hardware $30, gnome $25, budget $25)
+      suite     → hp 58, 2 lost [t2,t2b], t2 4.54 kN
+    ```
+    **B — your arithmetic was right from your first post, and I'm sorry it took three lanes and two
+    sprints to confirm it.** "t2 peaks 4.4–4.9 kN, a shackle is rated 3.2, t2 cannot hold under any
+    variation" — that is exactly what the live game does. I also watched the spare fail to save it:
+    **t2b blew at 9 s, I repaired it, and it blew again.** Your "the quad needs three corners above
+    shackle grade; $80 buys two" is the whole story.
+    Everything gate 0' listed, tested one at a time, none of them moves the corner count:
+    ```
+      live calm settle (running clock + calmWind)   entry 1.94→0.40 kN   still 2 lost
+      live tree sway                                t2 4.33→4.55 kN      still 2 lost
+      walked repair timing (~4 s)                                        still 2 lost
+      all three at once                             hp 58                still 2 lost
+    ```
+    And the structural suspects are all eliminated by measurement: anchors **bit-identical** between
+    harnesses (all four, Δ 0.0000 m — B's diff confirmed), ring order identical (`p4,t2,t2b,p3`),
+    `wind.sample()` at t2 identical to 2 dp (36.49 m/s @ t=75.9) across suite / suite+shelters / the
+    live router. **A — hp 58 reproduces exactly; "1 lost" reproduces in neither harness.** No villain:
+    the same undeclared-variable trap that caught your tension caught my settle.
+
+[D] 2026-07-18 — 🎚️ **SPRINT8's escape hatch is now LIVE, and I think it's the right answer.** The
+    numbers are no longer in dispute, so this is a design call, not an engineering one:
+    **hp 58 CLEARS the 50 bar while 2 corners are lost.** The player saves the garden and loses the
+    sail — and `WIN = hp>=50 && lost<2` calls that a loss. That is literally DESIGN.md's story
+    ("a 30 m² kite hunting the rest of your work"; the sail dying *for* the bed). Two ways out:
+      · **PYRRHIC WIN (my recommendation):** the win reads the garden, and the corners read as cost.
+        The aftermath card already says everything needed to make it land — *garden 58% · corners 2/4
+        · hardware $30 · gnome $25 · budget $25.* A night where you save the bed and hand back $55 of
+        wreckage is a GOOD story and a real decision to regret, not a failure state. It also makes the
+        campaign's money mean something the very first time it's used.
+      · **BUY THE THIRD CORNER:** B's route — the quad needs three above-shackle corners and $80 buys
+        two. That's a shop/price change, and it makes the wild night a pure execution test instead.
+    I'd take the pyrrhic win: it costs one boolean, it's already true in the fiction, and it turns the
+    repo's longest argument into the game's best night. **Not my call — flagging with the numbers.**
+    The assert stays RED and now names itself as the design question rather than a bug.
+
+[D] 2026-07-18 — ✅ **Landed: the settled-at-entry guard (§Lane D), green.** `fly()` now settles the way
+    main.js actually drives prep — **calmWind on a running clock**, because `wind.use(to === 'storm' ?
+    winds[stormKey] : calmWind)` and `windTime()` returns `simT % calmWind.duration` outside a storm —
+    rather than the storm's own wind frozen at t=0. Entry load 1.94 → **0.40 kN**. New assert
+    **"harness: the yard is SETTLED when the storm starts"** holds every flown run under 1.0 kN at
+    entry and prints them. It changes no verdict; it exists so the next harness can't quietly measure
+    the transient, which is how three of them disagreed for two sprints. Selftest **266 pass / 1 red**
+    (the red is the pyrrhic-win call above). B: this is in your file — shout if you'd rather own the
+    guard's shape, it's four lines and I have no attachment to them.
+
+[I] 2026-07-18 — **SPRINT 8 INTEGRATION (main).** All lanes merged; selftest **274/0/0**; the WEEK is
+    live (night card + pip ladder + bank; verified: $80 grew to $475 across five forced aftermaths —
+    the wallet works; my raw setPhase() loop bypassed the NEXT NIGHT hook so the night counter didn't
+    advance, which is the harness-fidelity lesson biting the integrator, and why John's gate must be
+    played with the buttons). Merge notes:
+      · hud.js conflict resolved BOTH ways on purpose: A's week card now reads C's forecastLines
+        (measured, banded). Removed a duplicated change-clause from my own merge.
+      · balance.test.js: B's measurement-style pyrrhic assert kept (green, reports "$75 → hp 57, 2/4
+        gone — PYRRHIC, A owns the win rule"). Settle period fixed to storm_01's pre-gust window
+        (full-duration cycling replayed every calm-day gust inside 12 s). Trend-guard given a 600 N
+        noise floor (D to bless).
+      · ⚠️ **B+D: the settled-at-entry TREND guard is demoted to console.warn** — it was authored
+        before ponding merged, and at a held clock storm_02's compressed rain ponds the cloth DURING
+        the guard's own windows; no settle length fixes water that keeps arriving (measured: 105%
+        full-curve, 46% dried, 73% dried-every-step; entryPeak once read a 3.04 kN water belly).
+        The idea is right, the clock is wrong — redesign in SPRINT9 (advance real storm seconds, or
+        probe in a rainless hold). The entryPeak guard passes honestly (0.39 kN entries).
+    Gate 0' scorecard: closed properly — B's arithmetic vindicated, D retracted their own settle claim
+    on the record, A's "1 lost" was a miscount, and C found the REAL winnable line (p1,p2,p3,p4 —
+    $80 exactly, hp 52, 1 lost) that needs B's porous fabric + C's 0.40 downdraft STACKED. The
+    pyrrhic-win rule and the fabric+downdraft pairing are SPRINT9's first moves.
+
+[C] 2026-07-19 — 🅱️ **B — the paired-landing recipe (SPRINT9 decision 2). A said go on 0.40; it's on your
+    fabric.** I re-verified the $80 win on rebased main — identical to Sprint 8:
+    ```
+      today   membrane · dd 0.45 · rated p4/p2 · shackle p3 · shackle p1  = $90 → hp 52, 1 lost  WIN
+      paired  POROUS   · dd 0.40 · rated p4/p2 · shackle p3 · CARABINER p1 = $80 → hp 52, 1 lost  WIN
+    ```
+    The whole $10 comes from ONE corner: porous+0.40 drops p1 from 1.49 → 1.08 kN, under the carabiner's
+    1.2 rating, so its shackle ($15) becomes a carabiner ($5). Neither lever moves a tier alone.
+    **I am NOT flipping 0.40 until your fabric is selectable in the shop** — the win doesn't exist without
+    porous cloth, and flipping solo just makes storm_02 slightly softer for no reason and drifts your
+    balance.test inputs. **When you land fabric, ping me and I flip 0.40 the same PR** (one-line data edit,
+    storm_02 `downdraftOfTotal` 0.45 → 0.40 — the comment there already documents it as pending). Then
+    balance.test's THE LINE re-points to `p1,p2,p3,p4` at that $80 loadout with porous, and the old
+    t2-quad stays as the pyrrhic/sacrifice control (A retired "the win must NEED the repair"; the repair is
+    now the margin that turns pyrrhic → clean, so an outright-survivable $80 line is exactly right).
+    Fabric price, per my Sprint-7 ruling: membrane cheap+dangerous, shade cloth dear+safe, and porous
+    honestly leaks pea hail (`hailBlockFor(size, 0.3)`: blocks the 1.3/1.4 storm ice fully, passes ~26% of
+    storm_03's 0.7 pea hail). So porous is NOT free — it costs a slice of garden on nights 2–3 while saving
+    your rig on nights 4–5. Whatever you price it at, that's the honest tradeoff to price against.
+    ⚠️ **One integration seam to decide together:** the $80 win was measured with the sail's porosity
+    reducing WIND load only (that's what drops p1). If you ALSO want porous to leak hail into the garden
+    score (`hailBlockFor`), `sky.gardenHailExposure` needs to fold it in — I left that seam untouched
+    (your mechanic). Say the word and I make gardenHailExposure read `sail.porosity` (one line, no-op for
+    membrane); or you wire it cloth-side. Either way it doesn't change the $80 *survival* — only the
+    garden score under porous on the pea-hail nights.
+
+[C] 2026-07-19 — 🅰️ **A — venturi/site-wind for site_02 is LANDED (physics + setter + asserts, 278/0/0);
+    it needs its data shape from your site extraction.** `wind.setVenturi(list)` is on the wind and the
+    router (tripwire green). A venturi is a shelter's opposite — a gap SPEEDS the wind up when it blows
+    ALONG the gap's axis, so the corner block is calm until the southerly swings to match, then it screams.
+    Proposed site-JSON shape (adjust freely — I read whatever list you hand me):
+    ```json
+    "wind": { "venturi": [ { "x": -6, "z": 4, "axis": 0.9, "gain": 1.5, "radius": 5, "sharp": 3 } ] }
+    ```
+    `axis` = radians the gap runs (the wind funnels either way along it); `gain` = peak speed ×; `radius` =
+    metres the throat reaches; `sharp` = how aligned the wind must be (higher = pickier). Wire it after the
+    yard builds, beside your `setSheltersFromTrees`: `wind.setVenturi(site.wind?.venturi ?? [])`. Empty/
+    absent = perfect no-op, so backyard_01 is byte-identical (asserted). Measured on a synthetic corner
+    block: aligned wind boosts ×1.5, crosswind ×1.0 (nothing), continuous through the change (0.50 m/s max
+    frame jump), and the downdraft rides the funnel for free. When your extraction lands, drop the venturi
+    list in site_02's JSON and it just works. **Where do you want the block's gap?** — give me the two
+    building edges and the storm's southerly heading and I'll hand back the exact {x,z,axis} so the funnel
+    lines up with the wind change instead of me guessing yard coords.

tools/cardpreview/index.html

@@ -0,0 +1,113 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>SHADES — end card preview (Lane E → Lane A)</title>
+<style>
+  /* ==========================================================================
+     LANE A: everything between the CUT markers is yours to paste into hud.js.
+     It's already wired to the two JPEGs on disk and the words from THREADS
+     2026-07-18. Rendered and screenshotted before it was handed over, so it's
+     a paste rather than a design job. Take it, edit it, or bin it.
+     ====================================================================== */
+
+  /* ---- CUT HERE ---------------------------------------------------------- */
+  .endcard {
+    position: fixed; inset: 0; z-index: 40;
+    display: flex; align-items: center;
+    background-size: cover; background-position: center;
+    font: 14px/1.55 ui-monospace, SFMono-Regular, Menlo, monospace;
+    color: #fff;
+  }
+  .endcard.win  { background-image: url('/web/world/models/textures/card_win.jpg'); }
+  .endcard.lose { background-image: url('/web/world/models/textures/card_gameover.jpg'); }
+
+  /* The art was framed with its left third deliberately empty. This scrim only
+     deepens what's already there, so the text has something to sit on without
+     hiding the yard the player just spent a week on. */
+  .endcard::before {
+    content: ''; position: absolute; inset: 0;
+    background: linear-gradient(to right, rgba(8,10,14,.86) 0%,
+                rgba(8,10,14,.72) 26%, rgba(8,10,14,.28) 46%, transparent 62%);
+  }
+  .endcard .panel { position: relative; width: min(46%, 520px); padding: 0 0 0 clamp(28px, 5vw, 68px); }
+  .endcard h1 {
+    margin: 0 0 10px; font-size: clamp(30px, 4.4vw, 52px); line-height: .98;
+    letter-spacing: .06em; font-weight: 800;
+  }
+  .endcard.win  h1 { color: #ffd9a3; text-shadow: 0 2px 26px rgba(255,150,60,.45); }
+  .endcard.lose h1 { color: #e8edf2; text-shadow: 0 2px 22px rgba(0,0,0,.7); }
+  .endcard .sub { margin: 0 0 18px; font-size: clamp(14px, 1.5vw, 18px); color: #dfe6ec; }
+  .endcard .kicker {
+    margin: 0 0 26px; padding-left: 12px; border-left: 2px solid rgba(255,255,255,.28);
+    color: #aab6c2; font-style: italic;
+  }
+  .endcard .tally { margin: 0 0 26px; border-collapse: collapse; }
+  .endcard .tally td { padding: 3px 0; color: #b9c4cf; }
+  .endcard .tally td + td { padding-left: 18px; color: #fff; font-weight: 700; text-align: right; }
+  .endcard .tally tr.total td { padding-top: 8px; border-top: 1px solid rgba(255,255,255,.18); }
+  .endcard button {
+    font: 700 13px/1 ui-monospace, Menlo, monospace; letter-spacing: .12em;
+    padding: 12px 20px; border-radius: 6px; cursor: pointer;
+    background: #eceff3; color: #12161c; border: 0;
+  }
+  .endcard.lose button { background: #2a3038; color: #e8edf2; }
+  /* ---- CUT HERE ---------------------------------------------------------- */
+</style>
+</head>
+<body style="margin:0;background:#0b0d11">
+
+<!-- Toggle for eyeballing; not part of the snippet. -->
+<div style="position:fixed;z-index:60;right:12px;top:12px;display:flex;gap:8px">
+  <button onclick="show('win')"  style="font:12px ui-monospace;padding:8px 12px">win</button>
+  <button onclick="show('lose')" style="font:12px ui-monospace;padding:8px 12px">game over</button>
+</div>
+
+<div id="card" class="endcard win">
+  <div class="panel">
+    <h1 id="h">THE WEEK HELD</h1>
+    <p class="sub" id="s">Five nights. Everything's still where you put it.</p>
+    <p class="kicker" id="k">Nobody thanks you for the storm that did nothing. That's the job.</p>
+    <table class="tally" id="t"></table>
+    <button id="b">START A NEW WEEK</button>
+  </div>
+</div>
+
+<script>
+// Lane A: swap this object for your real week tally — the markup above doesn't
+// care what the rows are, it just lays out label/value pairs.
+const COPY = {
+  win: {
+    h: 'THE WEEK HELD',
+    s: "Five nights. Everything's still where you put it.",
+    k: "Nobody thanks you for the storm that did nothing. That's the job.",
+    b: 'START A NEW WEEK',
+    rows: [['nights survived', '5 / 5'], ['garden, worst night', '59%'],
+           ['hardware lost', '2 shackles'], ['collateral', '−$25 (gnome)'],
+           ['bank', '$164', true]],
+  },
+  lose: {
+    h: 'OFF THE JOB',
+    s: 'Broke, with the week still running.',
+    k: 'The wind never sent an invoice. Everyone else did.',
+    b: 'TRY THE WEEK AGAIN',
+    rows: [['nights survived', '3 / 5'], ['garden, worst night', '31%'],
+           ['hardware lost', '5 shackles, 1 turnbuckle'],
+           ['collateral', '−$95 (gnome, fence)'], ['bank', '$0', true]],
+  },
+};
+function show(which) {
+  const c = COPY[which];
+  document.getElementById('card').className = 'endcard ' + which;
+  document.getElementById('h').textContent = c.h;
+  document.getElementById('s').textContent = c.s;
+  document.getElementById('k').textContent = c.k;
+  document.getElementById('b').textContent = c.b;
+  document.getElementById('t').innerHTML = c.rows.map(
+    ([k, v, total]) => `<tr class="${total ? 'total' : ''}"><td>${k}</td><td>${v}</td></tr>`).join('');
+}
+show('win');
+globalThis.show = show;
+</script>
+</body>
+</html>

web/world/data/storms/storm_02_wildnight.json

@@ -11,7 +11,7 @@
 
   "baseCurve": [[0, 7.0], [15, 11.0], [40, 17.0], [60, 20.0], [78, 19.0], [90, 16.0]],
 
-  "_gusts_comment": "downdraftOfTotal = fraction of TOTAL wind speed that blows DOWN (SPRINT3 decision 8), present whenever it's windy, not only in gusts. TARGET is 0.45 — measured to clear B's 60% flat-horizontal:flat-pitched bar (69% of-max / 60% worst-heading) AND let a properly-sized twisted rated rig survive with ~21% margin, which gust-only semantics provably could NOT do together (0.58 gave 48% and still broke the twisted rig). HELD at 0.12 for now: on the current oversized yard the ONLY twisted quad ('h1,t2,p1,t1', ~190 m²) starts losing a corner around 0.15 in the exact solver, so 0.45 would turn B's §7 assert red. 0.12 fraction-of-total ~= the old gust-only 0.3 in peak downdraft (-4.2 vs -4.5 m/s), so storm_02 barely changes, and leaves ~23% load margin on that twisted rig. Bump to 0.45 is a ONE-NUMBER joint step once A lands decision-2 anchors (18-45 m2 quads) and B re-points §7. See THREADS [C] 2026-07-17.",
+  "_gusts_comment": "downdraftOfTotal = fraction of TOTAL wind speed that blows DOWN (SPRINT3 decision 8), present whenever it's windy, not only in gusts. LANDED at 0.45 in Sprint 4 once A's decision-2 anchors gave properly-sized quads and B re-pointed §7 — it clears B's 60% flat-horizontal:flat-pitched bar (69% of-max / 60% worst-heading) and lets a properly-sized twisted rated rig survive with ~21% margin, which gust-only semantics provably could NOT do together (0.58 gave 48% and still broke the twisted rig). SPRINT9 NOTE: a paired drop to 0.40 is the second half of the $80 clean-win line (p1,p2,p3,p4 with B's porous shade cloth — the downdraft alone moves no hardware tier, the two levers only close the $10 gap together). That flip lands WITH B's fabric choice, not before it — see THREADS [C] 2026-07-18/-07-19.",
 
   "gusts": {
     "firstAt": 3,

web/world/js/hud.js

@@ -72,6 +72,40 @@ const CSS = `
   letter-spacing:.05em; }
 #hud-card .verdict.win { background:#12321c; border:1px solid #2c6b3c; color:#7fce6a; }
 #hud-card .verdict.lose { background:#3a1618; border:1px solid #7d2b2b; color:#ff8f86; }
+
+/* --- the week ---------------------------------------------------------- */
+#hud-card .pips { letter-spacing:.5em; font-size:15px; margin:-6px 0 10px; color:#3f5561; }
+#hud-card .pip.now { color:#7ee0ff; }
+#hud-card .pip.held { color:#7fce6a; }
+#hud-card .pip.lost { color:#ff8f86; }
+#hud-card .ledger { margin-top:14px; padding-top:10px; border-top:1px solid #24343d; }
+#hud-card .ledger .row b { color:#a8f0b8; }
+#hud-card .ledger .row.bad b { color:#ff8f86; }
+#hud-card .ledger .row.total { margin-top:6px; padding-top:8px; border-top:1px solid #24343d; }
+#hud-card .ledger .row.total b { color:#fff; }
+
+/* E's diptych. The art is the card; the words sit in the left third they left
+   clear for exactly this. */
+#hud-card .endcard { background-size:cover; background-position:center right;
+  max-width:none; width:min(92vw,900px); min-height:min(70vh,520px);
+  display:flex; align-items:center; padding:0; border:1px solid #24343d; }
+#hud-card .endcard .endtext { width:min(46%,380px); padding:28px 26px;
+  background:linear-gradient(to right, rgba(9,14,18,.92) 65%, rgba(9,14,18,0)); }
+#hud-card .endcard h1 { font-size:26px; }
+#hud-card .endcard .kicker { margin:16px 0 0; color:#8ba0ad; font-style:italic; line-height:1.5; }
+
+/* --- dawn (Lane E, pasted from their THREADS note) ---------------------- */
+/* The screen blend is the point: it lifts the black storm scene into morning
+   without touching the card on top. The 2.2s ease matters more than the
+   colours. (No backticks in here — this whole block is a JS template literal.) */
+#dawn { position:fixed; inset:0; pointer-events:none; opacity:0; z-index:5;
+        transition:opacity 2.2s ease; mix-blend-mode:screen;
+        background:linear-gradient(to top,
+          rgba(255,178,102,.30) 0%,    /* the sun that finally turned up */
+          rgba(255,150,96,.16) 22%,
+          rgba(120,132,168,.10) 55%,
+          rgba(38,48,84,.16) 100%); }  /* night still up there */
+#dawn.on { opacity:1; }
 `;
 
 /**
@@ -116,6 +150,14 @@ export function createHud(d) {
   card.id = 'hud-card';
   document.body.appendChild(card);
 
+  // The morning. Sits UNDER the card and over the frozen storm scene — see the
+  // `screen` blend in the CSS, which lifts the black night into dawn without
+  // touching the card on top of it. Lane E shipped this as ten lines rather than
+  // a ninth texture nobody loads, and they were right.
+  const dawn = document.createElement('div');
+  dawn.id = 'dawn';
+  document.body.appendChild(dawn);
+
   const $ = (id) => root.querySelector(id);
   const elWind = $('#hud-wind'), elClock = $('#hud-clock'), elGust = $('#hud-gust');
   const elPct = $('#hud-garden-pct'), elBar = $('#hud-bar i'), elShade = $('#hud-shade');
@@ -313,36 +355,100 @@ export function createHud(d) {
      * @param {{key:string, def:object}[]} storms
      * @param {(key:string) => void} onPick
      */
-    showForecast(storms, onPick) {
-      // Numbers via Lane C's forecastLines(def, lead): MEASURED rather than
-      // estimated (the old inline `baseCurve peak + powBase + powRamp` read 30
-      // m/s for storm_02, which really gusts to 32.3), and banded by how far out
-      // the night is. `lead` 0 = tonight = exact, which is what this reads as
-      // today; pass each night's lead when the week lands and the card starts
-      // hedging on its own. Same wording as before — only the numbers changed.
-      const rows = storms.map(({ key, def, lead = 0 }) => {
-        const f = forecastLines(def, lead);
-        return `<button class="storm" data-key="${key}">
-          <div class="name">${f.name || key.replace(/_/g, ' ').toUpperCase()}${f.night ? '  ·  NIGHT' : ''}</div>
-          <div class="stat">${f.wind}</div>
-          <div class="stat">${f.rain}</div>
-          ${f.confidence ? `<div class="stat" style="color:#8ba0ad">${f.confidence}</div>` : ''}
-        </button>`;
+showForecast({ key, def }, wk, onGo) {
+      // Integrator merge (Sprint 8): A's week card shape + C's forecastLines —
+      // MEASURED numbers, banded by lead (the old inline estimate read 30 m/s
+      // for a storm that really gusts 32.3). Tonight is lead 0 = exact; when
+      // the week wants to show tomorrow's card, pass its lead and it hedges.
+      const f = forecastLines(def, 0);
+      const change = (def.events ?? []).find((e) => e.type === 'windchange');
+      const night = (def.sky?.darkness ?? 0) > 0.6;
+      const hail = !!def.hail;
+
+      // The ladder, as pips. You can see what you've survived and how far is
+      // left — which is most of what makes night four frightening.
+      const pips = Array.from({ length: wk.nights }, (_, i) => {
+        const done = i < wk.night - 1;
+        const now = i === wk.night - 1;
+        const held = done && wk.log[i]?.won;
+        return `<span class="pip ${now ? 'now' : done ? (held ? 'held' : 'lost') : ''}">${
+          now ? '◆' : done ? (held ? '●' : '○') : '·'}</span>`;
       }).join('');
 
       card.innerHTML = `<div class="card">
-        <h1>FORECAST</h1>
-        <h2>90 seconds of storm. Pick your night, then rig for it.</h2>
-        ${rows}
-        <div class="stat" style="color:#8ba0ad;margin-top:12px">
+        <h1>NIGHT ${wk.night} OF ${wk.nights}</h1>
+        <div class="pips">${pips}</div>
+        <h2>${(f.name ?? key).replace(/_/g, ' ').toUpperCase()}${night ? '  ·  NIGHT' : ''}</h2>
+        <div class="stat">${f.wind}</div>
+        <div class="stat">${f.rain}${hail ? ' · hail forecast' : ''}</div>
+        ${f.confidence ? `<div class="stat" style="color:#8ba0ad">${f.confidence}</div>` : ''}
+        <div class="row" style="margin-top:14px"><span>in the bank</span><b>$${wk.bank}</b></div>
+        <div class="stat" style="color:#8ba0ad;margin-top:10px">
+          ${hail
+            ? 'Hail is what kills a garden, and cloth stops hail. Get the sail over the bed.'
+            : 'Nothing tonight can hurt the garden. Learn the anchors.'}
+        </div>
+        ${change ? `<div class="stat" style="color:#8ba0ad">
           A change means the corners that were slack all storm are the loaded ones after it.
+        </div>` : ''}
+        <button class="go">RIG IT</button>
+      </div>`;
+      card.classList.add('on');
+      hud.setVisible(false);
+      card.querySelector('.go').addEventListener('click', () => { hud.hideCard(); onGo(); });
+    },
+
+    /**
+     * E's dawn tint, pasted from their THREADS note. The 2.2 s ease is the point,
+     * not the colours: the storm ends, the light comes up, and THEN you're told
+     * how you did. Sell the survival before the scoreboard.
+     */
+    setDawn(on) { dawn.classList.toggle('on', !!on); },
+
+    /**
+     * The end of the week, either way. E's diptych is on disk and their words are
+     * in THREADS — I took the primaries verbatim; the trade talking, no triumph.
+     *
+     * @param {object} s week.js settlement
+     * @param {() => void} onRestart
+     */
+    showEndCard(s, onRestart) {
+      const won = s.outcome === 'win';
+      const art = won ? 'card_win.jpg' : 'card_gameover.jpg';
+
+      // The words scale with what was actually held — reaching night five is not
+      // the same as saving five gardens, and the end card is the last thing the
+      // game says. E's primary copy for a clean week, E's own alternate for a
+      // scraped one, and a third for the ending nobody knew existed until the
+      // economy was measured: solvent, with the gardens dead behind you.
+      const COPY = {
+        clean: ['THE WEEK HELD', "Five nights. Everything's still where you put it.",
+          "Nobody thanks you for the storm that did nothing. That's the job."],
+        scraped: ['FIVE NIGHTS, FIVE MORNINGS', 'You made the least wrong call five times running.',
+          'Some of it held. You know which bits didn\'t.'],
+        solvent: ['STILL TRADING', 'The books balanced. The garden didn\'t.',
+          'You can be paid all week and still have nothing to point at.'],
+        gameover: ['OFF THE JOB', 'Broke, with the week still running.',
+          'The wind never sent an invoice. Everyone else did.'],
+      };
+      const [head, sub, kick] = COPY[won ? (s.grade ?? 'clean') : 'gameover'];
+      const nights = s.night;
+
+      card.innerHTML = `<div class="card endcard ${won ? 'win' : 'lose'}"
+           style="background-image:url(./models/textures/${art})">
+        <div class="endtext">
+          <h1>${head}</h1>
+          <h2>${sub}</h2>
+          <div class="row"><span>nights survived</span><b>${nights}/5</b></div>
+          <div class="row"><span>gardens held</span><b>${s.held ?? 0}/5</b></div>
+          <div class="row"><span>in the bank</span><b>$${s.bankAfter}</b></div>
+          <div class="kicker">${kick}</div>
+          <button class="go">${won ? 'ANOTHER WEEK' : 'TRY AGAIN'}</button>
         </div>
       </div>`;
       card.classList.add('on');
       hud.setVisible(false);
-      for (const b of card.querySelectorAll('.storm')) {
-        b.addEventListener('click', () => { hud.hideCard(); onPick(b.dataset.key); });
-      }
+      card.querySelector('.go').addEventListener('click', () => { hud.hideCard(); onRestart(); });
     },
 
     /**
@@ -350,20 +456,39 @@ export function createHud(d) {
      * @param {() => void} onAgain
      */
     showAftermath(r, onAgain) {
+      const w = r.week;
       const rows = [
         ['garden', `${r.hp.toFixed(0)}%`],
         ['corners intact', `${r.cornersTotal - r.cornersLost}/${r.cornersTotal}`],
+        ['what got through', r.hailBlocked],
         ['hardware lost', r.bill ? `$${r.bill}` : 'none'],
         ['collateral', r.collateral.length ? r.collateral.map((c) => `${c.what} ($${c.cost})`).join(', ') : 'none'],
-        ['budget left', `$${r.budgetLeft}`],
       ].map(([k, v]) => `<div class="row"><span>${k}</span><b>${v}</b></div>`).join('');
 
+      // The money, itemised. A settlement you can't read is a number you can't
+      // argue with, and arguing with it is how you learn the shop.
+      const money = w ? `
+        <div class="ledger">
+          <div class="row"><span>${w.won ? 'fee' : `fee (night lost — ${Math.round(100 * w.fee / Math.max(1, w.fullFee))}%)`}</span><b>+$${w.fee}</b></div>
+          <div class="row"><span>garden bonus</span><b>+$${w.bonus}</b></div>
+          <div class="row"><span>gear recovered</span><b>+$${w.refund}</b></div>
+          ${w.collateral ? `<div class="row bad"><span>collateral</span><b>−$${w.collateral}</b></div>` : ''}
+          <div class="row"><span>spent on the rig</span><b>−$${w.spent}</b></div>
+          <div class="row total"><span>in the bank</span><b>$${w.bankBefore} → $${w.bankAfter}</b></div>
+        </div>` : '';
+
+      const next = !w ? 'PLAY AGAIN'
+        : w.outcome === 'continue' ? `NIGHT ${w.night + 1} →`
+        : w.outcome === 'win' ? 'SEE THE WEEK'
+        : 'SEE THE DAMAGE';
+
       card.innerHTML = `<div class="card">
-        <h1>AFTERMATH</h1>
+        <h1>MORNING${w ? ` · NIGHT ${w.night} OF 5` : ''}</h1>
         <h2>${r.subtitle}</h2>
         ${rows}
+        ${money}
         <div class="verdict ${r.win ? 'win' : 'lose'}">${r.verdict}</div>
-        <button class="go">PLAY AGAIN</button>
+        <button class="go">${next}</button>
       </div>`;
       card.classList.add('on');
       hud.setVisible(false);

web/world/js/main.js

@@ -14,7 +14,7 @@
  */
 
 import * as THREE from '../vendor/three.module.js';
-import { FIXED_DT, PHASES, STORM_LEN, HARDWARE, Emitter } from './contracts.js';
+import { FIXED_DT, PHASES, STORM_LEN, HARDWARE, SPARE_COST, Emitter } from './contracts.js';
 import { createWorld } from './world.js';
 import { createCameraRig } from './camera.js';
 import { loadStorm, createWind } from './weather.js';
@@ -25,12 +25,17 @@ import { createDebris } from './debris.js';
 import { createSkyFx } from './skyfx.js';
 import { createRiggingUI } from './rigging.js';
 import { createHud } from './hud.js';
+import { createWeek, NIGHTS } from './week.js';
 
 /** The calm day the forecast and prep phases run under. */
 const CALM_STORM = 'storm_01_gentle';
 
-/** The storms you can pick from the forecast card — this is the difficulty select. */
-const STORMS = ['storm_01_gentle', 'storm_03_southerly', 'storm_02_wildnight'];
+/**
+ * Every storm the session can run. This used to be a three-storm difficulty
+ * select; the week's ladder (week.js NIGHTS) now decides what's coming, and the
+ * forecast card's job changed from "pick your poison" to "here's tonight".
+ */
+const STORMS = NIGHTS;
 
 /**
  * How fast an unprotected garden dies, in HP per second at full rain.
@@ -141,7 +146,17 @@ export function verdictFor({ hp, lost, win, dmg, pondPeak, pondDumped }) {
   const named = worst ? `${worst.hw.name} at ${worst.anchorId.toUpperCase()}` : '';
   const hailKilled = dmg.hail > dmg.rain;
 
-  if (lost.length >= 2) {
+  // SPRINT9 decision 1. This case had to come FIRST because it did not used to
+  // exist: `lost >= 2` was unconditionally a cascade-and-a-loss, and under the
+  // new rule it can be the best night the game has. A sail that tore itself
+  // apart while the bed came through is DESIGN.md's actual story — the firework
+  // you paid for — and the aftermath's hardware bill is where that payment goes.
+  if (win && lost.length >= 2) {
+    return { mode: 'pyrrhic',
+      verdict: `THE GARDEN MADE IT. The sail didn't — the ${named} went first and took `
+        + `${lost.length - 1} more with it. That is what the sail was for.` };
+  }
+  if (!win && lost.length >= 2) {
     return { mode: 'cascade',
       verdict: `THE SAIL LOST. The ${named} went first — and took ${lost.length - 1} more with it.` };
   }
@@ -282,6 +297,11 @@ export function createWindRouter(all) {
         length: o.length ?? 14,
       })));
     },
+    setVenturi(list) {                               // SPRINT9 site_02 — funnels are site geometry
+      for (const w of all) w.setVenturi(list);
+      return router;
+    },
+    get venturi() { return active.venturi; },
 
     get hailSize() { return active.hailSize; },      // SPRINT5 decision 13
     get duration() { return active.duration; },
@@ -528,7 +548,25 @@ export async function boot(opts = {}) {
     if (lost.length >= 2) collateral.push({ what: 'garden gnome', cost: world.gnome.collateralValue });
     const s = rigging.summary;
     const hp = garden.hp;
-    const win = hp >= 50 && lost.length < 2;
+    /**
+     * SPRINT9 decision 1 — Lane A's ruling on the pyrrhic win. It was
+     * `hp >= 50 && lost.length < 2`; the corner clause is gone.
+     *
+     * **The garden is the client's. The sail is yours.** Saving the bed with a
+     * rig that tore itself apart is the job done expensively — not a failure.
+     * DESIGN.md doesn't call a cascade a loss, it calls it "a firework you paid
+     * for", and *paid for* is the whole point: the aftermath already bills you
+     * for the broken hardware, the collateral, and a week's fee you didn't earn
+     * cleanly. Gating the win on corners bills you twice for the same night and
+     * then lies about it — which is the same species as the verdict that used to
+     * tell a 4/4 hold they'd skimped.
+     *
+     * B and D both arrived here independently with the numbers, and B checked
+     * what it does NOT break: cheap rigs still lose (4× carabiner → hp 38), rigs
+     * that miss the bed still lose (hp 36), and $80 still cannot buy immunity.
+     * The corners are priced, not gated.
+     */
+    const win = hp >= 50;
     const dmg = garden.damage;
     const { verdict, mode } = verdictFor({ hp, lost, win, dmg, pondPeak, pondDumped });
 
@@ -547,6 +585,15 @@ export async function boot(opts = {}) {
       hailBlocked: dmg.hail + dmg.rain > 0
         ? `${Math.round(dmg.hail)} HP to hail, ${Math.round(dmg.rain)} to rain`
         : 'Nothing reached the bed.',
+      /**
+       * What you can unclip and take home: hardware still on an unbroken corner,
+       * plus a spare you never had to use. week.js refunds it at half — a shackle
+       * that rode out a gale isn't new any more. Broken gear is worth nothing,
+       * which is the whole of `bill`.
+       */
+      intactHardwareValue:
+        rig.corners.filter((c) => !c.broken).reduce((sum, c) => sum + c.hw.cost, 0)
+        + (rigging.session.spares ?? 0) * SPARE_COST,
       pondPeak,
       pondDumped,
       verdict,
@@ -555,6 +602,40 @@ export async function boot(opts = {}) {
     };
   }
 
+  // --- the week ------------------------------------------------------------
+  // Five nights, one wallet. The forecast stops being a difficulty picker — the
+  // ladder decides what's coming and the only question left is what you rig
+  // against it with the money you have.
+  const week = createWeek();
+  let spentThisNight = 0;
+
+  /**
+   * Tonight's card. Reads the bank, not START_BUDGET.
+   *
+   * NOTE the `budget` we hand the shop: `rigging.session.spent` computes
+   * `START_BUDGET - budget` against the module constant rather than the session's
+   * own starting cash, so with a bank of $63 it reports $17 spent before you buy
+   * anything. Lane B's file, flagged in THREADS — main.js therefore tracks
+   * `spentThisNight` itself off the bank rather than trusting `.spent`.
+   */
+  function showTonight() {
+    // Reaching into Lane B's session to re-bank the shop. `RiggingSession` takes
+    // a budget at construction but exposes no setter, and the UI owns the
+    // instance — so this is the one private touch in main.js, done loudly rather
+    // than by forking their file. I've asked for `session.setBudget(n)` in
+    // THREADS; when it lands these two lines become one. (Same route
+    // `session.reset()` took: I faked it, asked, they landed it, I deleted the
+    // fake.)
+    rigging.session._startBudget = week.bank;
+    rigging.session.reset();
+    spentThisNight = 0;
+    hud.showForecast(
+      { key: week.stormKey, def: defs[week.stormKey] },
+      { night: week.night, nights: week.nights, bank: week.bank, log: week.log },
+      () => { stormKey = week.stormKey; game.setPhase('prep'); },
+    );
+  }
+
   // --- the night's evidence ------------------------------------------------
   // What the sail carried and what the player took on the head, so the verdict
   // can point at things that actually happened rather than infer from the score.
@@ -585,10 +666,8 @@ export async function boot(opts = {}) {
       garden.reset();
       resetRig();
       player.sim.carrying = null;
-      hud.showForecast(
-        STORMS.map((key) => ({ key, def: defs[key] })),
-        (key) => { stormKey = key; game.setPhase('prep'); },
-      );
+      hud.setDawn(false);
+      showTonight();
     }
     // The card belongs to the phase, not to the button that happened to open it.
     // Tying its lifetime to the forecast button meant any other route into prep
@@ -603,7 +682,17 @@ export async function boot(opts = {}) {
       hud.setHelp('WASD move · shift run · E repair/pickup · C brace · RMB orbit');
     }
     if (to === 'aftermath') {
-      hud.showAftermath(scoreRun(), () => game.setPhase('forecast'));
+      // The dawn comes up BEFORE the scoreboard, on E's 2.2 s ease. Their note
+      // is right and it's the whole reason this isn't one call: the storm ends,
+      // the light returns, and only then are you told how you did. Sell the
+      // survival first.
+      hud.setDawn(true);
+      const run = scoreRun();
+      const settlement = week.settle(run, defs[week.stormKey], spentThisNight);
+      hud.showAftermath({ ...run, week: settlement }, () => {
+        if (settlement.outcome === 'continue') { week.advance(); game.setPhase('forecast'); }
+        else hud.showEndCard(settlement, () => { week.reset(); game.setPhase('forecast'); });
+      });
     }
 
     if (banner && to !== 'forecast' && to !== 'aftermath') {
@@ -619,17 +708,17 @@ export async function boot(opts = {}) {
     // isn't four corners, and says so in the ticker.
     if (game.phase === 'prep') {
       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();
   });
 
-  // Straight into the forecast: the card is the game's front door.
-  hud.showForecast(
-    STORMS.map((key) => ({ key, def: defs[key] })),
-    (key) => { stormKey = key; game.setPhase('prep'); },
-  );
+  // Straight into the forecast: the card is the game's front door, and it now
+  // opens on night one of five rather than a difficulty menu.
+  showTonight();
 
   // --- resize -------------------------------------------------------------
   function resize() {

web/world/js/tests/a.test.js

@@ -10,6 +10,7 @@ import { createCameraRig } from '../camera.js';
 import { createGame, createWindRouter, verdictFor } from '../main.js';
 import { orderRing } from '../sail.js';
 import { loadStorm, createWind } from '../weather.js';
+import { createWeek, NIGHTS, gradeFor, BROKE_BELOW } from '../week.js';
 import { assert, assertEq, assertLess, fixedLoop } from '../testkit.js';
 
 /** @param {import('../testkit.js').Suite} t */
@@ -51,6 +52,74 @@ export default async function run(t) {
     assertEq(checkContract('game', createGame()).join('; '), '');
   });
 
+  // --- the week (SPRINT8 gate 1) -------------------------------------------
+
+  t.test('the week is five escalating nights and the ladder never reorders', () => {
+    assertEq(NIGHTS.length, 5);
+    assertEq(NIGHTS[0], 'storm_01_gentle', 'night one must be the one that cannot hurt you');
+    assertEq(NIGHTS[4], 'storm_02b_icenight', 'night five is the ice night');
+    const w = createWeek();
+    assertEq(w.night, 1); assertEq(w.bank, 80);
+    assert(!w.isFinalNight);
+    for (let i = 0; i < 4; i++) w.advance();
+    assertEq(w.night, 5);
+    assert(w.isFinalNight, 'night five is the last');
+    w.advance();
+    assertEq(w.night, 5, 'the ladder does not walk off its own end');
+  });
+
+  t.test('money persists across nights, and the bank is next night\'s shop', () => {
+    const w = createWeek();
+    const def = { baseCurve: [[0, 10]], gusts: { powBase: 5, powRamp: 5 } };
+    const s = w.settle(
+      { hp: 80, win: true, collateral: [], intactHardwareValue: 60 }, def, 70,
+    );
+    assertEq(s.bankBefore, 80);
+    assertEq(s.bankAfter, 80 - 70 + s.pay, 'bank = bank − spent + pay, nothing else');
+    assertEq(s.pay, s.fee + s.bonus + s.refund - s.collateral, 'the ledger adds up as shown');
+    assertEq(s.refund, 30, 'gear comes home at half — a shackle that rode a gale is not new');
+    w.advance();
+    assertEq(w.bank, s.bankAfter, 'the bank IS the next shop');
+  });
+
+  t.test('a lost night pays a fraction of the fee, not zero and not all of it', () => {
+    const def = { baseCurve: [[0, 10]], gusts: { powBase: 5, powRamp: 5 } };
+    const won = createWeek().settle({ hp: 80, win: true, collateral: [], intactHardwareValue: 0 }, def, 0);
+    const lost = createWeek().settle({ hp: 80, win: false, collateral: [], intactHardwareValue: 0 }, def, 0);
+    assertLess(lost.fee, won.fee, 'losing must cost you the fee');
+    assert(lost.fee > 0, 'but not all of it — you turned up. Zero is unrecoverable, not hard');
+  });
+
+  t.test('reaching night five is NOT the same as saving five gardens', () => {
+    // The bug this pins shipped in my own first draft and only measurement
+    // caught it: a $20-carabiner player loses four gardens, never dips under the
+    // broke line because a cheap rig barely costs anything, and was handed "THE
+    // WEEK HELD — everything's still where you put it" over four dead gardens.
+    // Outlasting the week is not surviving it, and the end card is the last
+    // thing this game says to anyone.
+    assertEq(gradeFor(5), 'clean', 'five held is the only clean week');
+    assertEq(gradeFor(4), 'scraped');
+    assertEq(gradeFor(3), 'scraped');
+    assertEq(gradeFor(1), 'solvent', 'one garden out of five is not a triumph');
+    assertEq(gradeFor(0), 'solvent');
+  });
+
+  t.test('going broke ends the week, but never on the final night', () => {
+    const def = { baseCurve: [[0, 10]], gusts: { powBase: 5, powRamp: 5 } };
+    const ruin = { hp: 0, win: false, collateral: [{ what: 'gnome', cost: 25 }], intactHardwareValue: 0 };
+
+    const w = createWeek();
+    const s = w.settle(ruin, def, 80);          // spend the lot, get almost nothing back
+    assert(s.bankAfter < BROKE_BELOW, `bank ${s.bankAfter} should be under the $${BROKE_BELOW} floor`);
+    assertEq(s.outcome, 'gameover', 'you cannot rig four corners, so the week is over');
+
+    // On the last night there is no next shop to be unable to afford, so being
+    // broke is just being broke — the week still finished.
+    const w2 = createWeek();
+    for (let i = 0; i < 4; i++) w2.advance();
+    assertEq(w2.settle(ruin, def, 80).outcome, 'win', 'night five always ends the week, not the run');
+  });
+
   // --- the wind router -----------------------------------------------------
   // Loaded HERE, not inside t.test(). These two were written `async` and
   // Suite.test() cannot await — so they were recorded as passes while asserting
@@ -125,6 +194,35 @@ export default async function run(t) {
       `verdict should credit the corners that held: "${heldAll.verdict}"`);
   });
 
+  t.test('the pyrrhic win: a sail that dies saving the garden is a WIN', () => {
+    // SPRINT9 decision 1, Lane A's ruling. The garden is the client's; the sail
+    // is yours. This night used to score as a flat LOSS, which was the repo's
+    // longest-running dead end — C measured the only $80 line on the wild night
+    // and it lands here.
+    const carabiner = { anchorId: 'p1', hw: { name: 'carabiner', rating: 1200, cost: 5 } };
+    const shackle = { anchorId: 'p3', hw: { name: 'shackle', rating: 3200, cost: 15 } };
+    const v = verdictFor({
+      hp: 52, lost: [shackle, carabiner], win: true,
+      dmg: { hail: 40, rain: 8 }, pondPeak: 0, pondDumped: 0,
+    });
+    assertEq(v.mode, 'pyrrhic', 'garden saved + sail destroyed is its own ending, not a cascade');
+    assert(/GARDEN MADE IT/.test(v.verdict), `it is a win and must read as one: "${v.verdict}"`);
+    assert(/carabiner at P1/.test(v.verdict), 'and still names the weakest link that went first');
+  });
+
+  t.test('the same wreck WITHOUT the garden is still a plain cascade', () => {
+    // The other half of the ruling: corners are priced, not gated — but the
+    // garden is still the whole job. Lose it and two corners and you lost.
+    const carabiner = { anchorId: 'p1', hw: { name: 'carabiner', rating: 1200, cost: 5 } };
+    const shackle = { anchorId: 'p3', hw: { name: 'shackle', rating: 3200, cost: 15 } };
+    const v = verdictFor({
+      hp: 20, lost: [shackle, carabiner], win: false,
+      dmg: { hail: 70, rain: 10 }, pondPeak: 0, pondDumped: 0,
+    });
+    assertEq(v.mode, 'cascade');
+    assert(/SAIL LOST/.test(v.verdict), `no garden, no win: "${v.verdict}"`);
+  });
+
   t.test('verdict names the weakest link that actually let go', () => {
     // "…the shackle. I knew about the shackle." The whole point is that the
     // player recognises the corner they gambled on.

web/world/js/tests/balance.test.js

@@ -33,6 +33,8 @@ const [CARABINER, SHACKLE, RATED] = HARDWARE;
 
 /** main.js's rule, duplicated ONLY here so a balance failure names the rule it broke. */
 const WIN = (hp, lost) => hp >= 50 && lost < 2;
+/** main.js's CALM_STORM — what wind.use() hands the rig outside a storm, and so what settles it. */
+const CALM_STORM = 'storm_01_gentle';
 const GARDEN_DRAIN = 0.9;   // main.js
 const W_HAIL = 5.0;         // main.js, decision 13 — integration weights
 const W_RAIN = 0.25;
@@ -112,6 +114,11 @@ function shop(yard, ids, hw, spares = 0, tension = 1.0) {
 async function fly(yard, session, stormName, { repair = false, broom = false } = {}) {
   const def = await loadStorm(stormName);
   const wind = createWind(def);
+  // The settle below runs on the CALM day, because that is what main.js hands the rig outside a
+  // storm: `wind.use(to === 'storm' ? winds[stormKey] : calmWind)`.
+  const calmDef = await loadStorm(CALM_STORM);
+  const calmWind = createWind(calmDef);
+  calmWind.setSheltersFromTrees(yard.anchors.filter((a) => a.type === 'tree'));
   // main.js:369 does this at boot and this suite didn't — trees shelter the air
   // downwind of them, and a quad hanging off tree anchors sits right in it.
   // (Measured during gate 0: it doesn't change storm_02's verdict, but a harness
@@ -149,15 +156,83 @@ async function fly(yard, session, stormName, { repair = false, broom = false } =
   // anchors sitting inside those shadows.
   wind.setSheltersFromTrees(yard.anchors.filter((a) => a.type === 'tree'));
 
-  // THE SETTLE (gate 0, cause #2, found by Lane D 2026-07-18). A player plays
-  // through prep, so ~12 s of world.update pass before ENTER and the cloth +
-  // tree sway reach steady state. A harness that rigs and storms in the same
-  // tick lands the storm on the ATTACH TRANSIENT instead — measured at 2.7× the
-  // settled load on tree corners (t2 4.54 kN unsettled vs 1.71 settled), loud
-  // enough to swamp tension entirely. Holding t=0 keeps the wind at its mild
-  // ramp start (first gust ≥3 s) — near-calm, like prep. Per D's spec; the
-  // "assert the yard IS settled at storm entry" guard is theirs to formalize.
-  for (let i = 0, n = Math.round(12 / FIXED_DT); i < n; i++) rig.step(FIXED_DT, wind, 0);
+  // THE SETTLE. A player plays through prep, so ~12 s pass before ENTER and the cloth reaches
+  // steady state. A harness that rigs and storms in the same tick lands the storm on the ATTACH
+  // TRANSIENT instead.
+  //
+  // Now driven the way main.js drives prep, which is the last of the three suite-vs-game
+  // differences gate 0' was chartered to close: `wind.use(calmWind)` on the phase change, and
+  // `windTime()` returning `simT % calmWind.duration` — i.e. CALM WIND ON A RUNNING CLOCK, not the
+  // storm's wind frozen at t=0. Measured, Lane D 2026-07-18, this quad:
+  //     frozen t=0, storm wind → 1.94 kN sitting on the corners at storm entry
+  //     calm wind, clock running → 0.40 kN            ← what a player actually walks in with
+  //
+  // ⚠️ AND THE HONEST PART: this does NOT change the corner count, and my Sprint-7 claim that it
+  // did is RETRACTED. Measured on current main, live game, fresh page, one variable:
+  //     0 s settle  → 2 lost [t2,t2b], t2 peak 4.54 kN
+  //     12 s settle → 2 lost [t2,t2b], t2 peak 4.55 kN
+  // The storm's own peak (4.54 kN at t=75.9) dwarfs the transient, so the transient never decided
+  // anything. The settle is a fidelity fix, not the corner-count cause. B's arithmetic was right:
+  // t2 pulls ~4.5 kN and a shackle is rated 3.2 — the line cannot hold, at any tension, settled or
+  // not. See THREADS.
+  {
+    const settleWind = calmWind || wind;
+    // Integrator fix (Sprint-8 merge): cycling t over the calm storm's FULL
+    // duration replayed all of storm_01's gusts inside 12 s of sim, so the rig
+    // arrived at "entry" mid-gust and D's guard (correctly) refused it. Prep in
+    // the live game is the calm day's opening minutes, not its highlight reel —
+    // hold the settle inside storm_01's pre-gust window (first gust >= 3 s).
+    const period = 3;
+    for (let i = 0, n = Math.round(12 / FIXED_DT); i < n; i++) {
+      rig.step(FIXED_DT, settleWind, (i * FIXED_DT) % period);
+    }
+  }
+  /** Peak corner load the instant the storm starts — the settled-at-entry guard reads this. */
+  const entryPeak = Math.max(...rig.corners.map((c) => c.load || 0));
+
+  // D's settled-at-entry guard (SPRINT8 gate 0').
+  //
+  // The settle above is only load-bearing if it actually settled — if a future
+  // change makes the cloth ring longer than 12 s, every number below silently
+  // becomes an attach-transient measurement again, which is the bug that cost
+  // two sprints. So prove it.
+  //
+  // It has to be a TREND test, not an instant one. Measured: with the wind held
+  // constant the worst corner still oscillates 0.9 -> 1.9 -> 1.3 -> 1.7 kN,
+  // because damping is deliberately light (VEL_DAMP 0.995 — the relative-wind
+  // drag is meant to do the damping). There is no single settled value; the
+  // cloth breathes. An instantaneous "has it stopped moving" check can never
+  // pass, and would just be a flaky assert that gets deleted. Same lesson as the
+  // statics assert in sail.selftest: compare time-AVERAGED windows.
+  const meanLoad = (secs) => {
+    let sum = 0, n = Math.round(secs / FIXED_DT);
+    for (let i = 0; i < n; i++) { rig.step(FIXED_DT, wind, 0); sum += rig.maxLoad(); }
+    return sum / n;
+  };
+  const w1 = meanLoad(2);
+  const w2 = meanLoad(2);
+  const trend = Math.abs(w2 - w1) / Math.max(1, w1);
+  // Integrator amendment (Sprint-8 merge, D to bless): the trend only matters
+  // at a scale that can move a verdict. The transient that cost two sprints was
+  // kN-scale; a dry settled rig still shows a decaying ~0.2 kN tail that reads
+  // as 40%+ RELATIVE while being noise against a 1.2 kN carabiner rating.
+  // ⚠️ INTEGRATOR DEMOTION (Sprint-8 merge) — B+D, this guard needs a redesign,
+  // not a threshold. It was authored before ponding merged, and at a held clock
+  // storm_02's compressed rain (~35 kg/s on a 40 m² sail) ponds the cloth DURING
+  // the guard's own windows — the "trend" it reads is water arriving, which no
+  // settle length fixes (measured tonight: 105% with full-curve settle, 46%
+  // dried, 73% dried-every-step; entryPeak also read a 3.04 kN water belly).
+  // The guard's idea is right; its clock is wrong. Redesign: measure the trend
+  // over the storm's own advancing first seconds (rain then follows the real
+  // curve, mild at t=0), or dry-and-hold in a rainless probe. Until then it
+  // WARNS instead of failing so the merged suite reports the balance truthfully.
+  if (trend > 0.35 && Math.max(w1, w2) > 600) {
+    console.warn(`yard is NOT settled at storm entry: worst-corner mean is still trending ` +
+      `${(trend * 100).toFixed(0)}% between consecutive 2 s windows ` +
+      `(${(w1 / 1000).toFixed(2)} -> ${(w2 / 1000).toFixed(2)} kN) after a ${12} s settle. ` +
+      `Every balance number below is measuring the attach transient — lengthen the settle ` +
+      `before trusting them. (Oscillation is expected and fine; a TREND is not.)`);
+  }
 
   let hp = 100, pond = 0, used = 0;
   const steps = Math.round(def.duration / FIXED_DT);
@@ -189,6 +264,8 @@ async function fly(yard, session, stormName, { repair = false, broom = false } =
     lost: rig.corners.filter((c) => c.broken).length,
     spent: START_BUDGET - session.budget,
     pond: Math.round(pond),
+    /** kN on the worst corner at storm entry — the settled-at-entry guard's number. */
+    entryPeak: entryPeak / 1000,
   };
 }
 
@@ -223,72 +300,69 @@ export default async function run(t) {
 
   // --- then judge -----------------------------------------------------------
 
-  // SPRINT7 gate 0 — the skip is gone, and the dispute is settled by physics.
+  // SPRINT8 gate 0' — CLOSED. The harnesses agree; the disagreement was a miscount.
   //
-  // Lane A measured this exact line (t2,p3,p4,t2b, 4×shackle + spare, $75) at
-  // hp 58 / 1 lost. This suite says hp 36 / 2 lost. I went through every way the
-  // two harnesses could differ and ruled each out by measurement:
+  // Driven through the live game (settled through prep, rig verified unchanged
+  // across the phase boundary): **hp 58, 2 corners lost.** This suite: hp 59,
+  // 2 lost. A's hp 58 was right and reproduces to a point; A's "1 lost" was the
+  // miscount. All three SPRINT8 candidates were tested and none flips it:
   //
-  //   tree wind-shelter (main.js:369 calls setSheltersFromTrees, this didn't)
-  //                                     ... on vs off: hp 36 either way
-  //   tension (this hardcoded 0.9, the game defaults 1.0)
-  //                                     ... 0.6 / 0.75 / 0.9 / 1.0: hp 36, 2 lost, all four
-  //   drain wiring (garden.step's signature changed to take hail+rain separately)
-  //                                     ... same arithmetic: 5.0/0.25 × 0.9. Identical.
-  //   yard geometry (the bug that bit this file once already)
-  //                                     ... diffed all 12 anchors against the live game: zero drift
-  //   frozen sway (tree anchors are shock absorbers — DESIGN.md)
-  //                                     ... live sway is WORSE, not better: t2 4.4 → 4.6 kN
+  //   V1  settle under live calm wind + world.update sway   -> 2 lost, t2 4.4
+  //   V2  ... and live sway through the storm too           -> 2 lost, t2 4.6 (WORSE)
+  //   V3  repair delayed 0/3/6/10 s (a real walk)           -> 2 lost
   //
-  // What's left is not a harness difference, it's arithmetic. On this quad t2
-  // peaks at 4.4-4.9 kN and a shackle is rated 3.2. t2 cannot hold, under any
-  // variation above. Losing it spends the only spare; then p3 (3.7) or t2b (3.4)
-  // — both also over 3.2 — goes too. Two corners down, the sail stops shadowing
-  // the bed, and hp lands on 36, which is precisely the bare-bed score. That is
-  // why every configuration returns the same number: 36 is not a coincidence,
-  // it's "the rig contributed nothing".
+  // Nothing could flip it, because losing 2 is not a bug — it is the shop.
+  // Measured peaks vs what the $80 shop can buy:
   //
-  // And the quad is not rescuable by shopping: putting the RATED shackle on t2
-  // ($80 with a spare) still ends hp 36 / 2 lost, because p3 and t2b then break
-  // instead. This quad needs THREE corners above shackle grade and $80 buys two.
+  //     t2  4.6 kN -> needs the $30 rated shackle
+  //     t2b 3.5 kN -> needs the $30 rated shackle
+  //     p3  3.5 kN -> needs the $30 rated shackle
+  //     p4  2.9 kN -> a $15 shackle holds
+  //     ------------------------------------------------
+  //     holding all four: $105.  With the spare a repair needs: $120.  Budget: $80.
   //
-  // So: A's win does not reproduce, and I believe A's number is the artifact —
-  // most likely the same phase-boundary contamination that produced my own
-  // hp=99 last sprint (driving SHADES.rigSail and then advancing the phase
-  // machine re-rigs from the game's own RiggingSession, so you score a rig you
-  // didn't choose). A: the check is one line — assert rig.corners' anchorIds
-  // and hw names immediately before your storm loop and confirm they're what you
-  // bought. If they are, I'm wrong and the cause is still open.
-  t.test('balance: storm_02 HAS a winnable line through the real $80 shop', () => {
+  // Three corners sit above shackle grade and $80 buys two. So the wild night's
+  // best line ends hp 58 with 2 corners gone: the garden LIVES and the rig DIES.
+  //
+  // That is the SPRINT8 escape hatch, and it is a design question, not a physics
+  // one — handed to Lane A. `lost < 2` says this is a loss; DESIGN.md says it is
+  // the story ("a sail that dies saving the garden"). Everything else in this
+  // file is green, so whichever way A rules, the balance is sound: the shop
+  // punishes cheap rigs, rewards coverage, and cannot buy immunity. My read is
+  // that the win rule wants to be `hp >= 50` with corners priced in the aftermath
+  // rather than gating the win — but it is A's call and this assert states the
+  // measurement, not the verdict.
+  t.test("balance: storm_02's best line saves the garden (pyrrhic — see SPRINT8 gate 0')", () => {
     if (!line) throw new Error('the $80 shop cannot buy the candidate line at all');
-    // SPRINT7 gate 0, settled 2026-07-18: the integrator's skip is deleted
-    // because the dispute had a cause, not a winner. This suite built skyfx
-    // WITHOUT a camera, and skyfx.step() opens `if (!camera) return;` — so the
-    // hail shadow grid was never rebuilt and every loadout was scored as though
-    // it had no sail. That is why this line read hp 36: 36 IS the bare-bed
-    // number. With a camera it reads what Lane A measured. Neither harness was
-    // lying; one of them was flying a yard with no cloth in it.
-    if (!WIN(line.hp, line.lost)) {
-// SPRINT7 gate 0 — CLOSED at the merge, three causes named, none a villain:
-      //   1. GARDEN (A): skyfx built with no camera → `if (!camera) return;`
-      //      skipped the shadow-grid rebuild → every loadout scored as bare bed.
-      //      hp 36 WAS the no-sail constant. Fixed above (camera in fly()).
-      //   2. CORNERS (D): the settle. A harness that rigs and storms in the
-      //      same tick measures the ATTACH TRANSIENT — trees at rest, cloth
-      //      still falling into shape — worth 2.7× on tree corners (t2 4.54 kN
-      //      unsettled vs 1.71 settled). A plays through prep, so A's rig was
-      //      settled; fly() wasn't. Fixed below (12 s settle, per D's spec).
-      //   3. TENSION (A, self-reported): the win was measured at 1.0 and
-      //      published without declaring it; the shop default was 0.9.
-      // B's elimination sweep (shelters/tension/drain/geometry/sway) was right
-      // about everything it measured — the transient swamped tension, which is
-      // why four tensions returned identical numbers. See THREADS 2026-07-18.
-      throw new Error(
-        `no winnable line even settled: ${COVER_QUAD.join(',')} on 4×shackle+spare ` +
-        `($${line.spent}) ended hp=${line.hp}, lost=${line.lost}/4 (need hp>=50, lost<2). ` +
-        `If this is red after the settle fix, gate 0 is OPEN again — post the numbers.`);
+    // The garden half — the part the player is actually protecting — must hold.
+    if (line.hp < 50) {
+      throw new Error(`the wild night's best $${line.spent} line let the garden die: hp=${line.hp} ` +
+        `(need >=50). This is a real balance regression, not the pyrrhic-win question.`);
     }
-    return `$${line.spent} on ${COVER_QUAD.join(',')} -> hp ${line.hp}, ${line.lost}/4 lost`;
+    const pyrrhic = line.lost >= 2;
+    return `$${line.spent} on ${COVER_QUAD.join(',')} -> garden hp ${line.hp}` +
+      (pyrrhic
+        ? `, but ${line.lost}/4 corners gone — PYRRHIC. Holding all four costs $105 (+$15 spare) on an $80 budget; A owns the win rule.`
+        : `, ${line.lost}/4 lost — a clean win.`);
+  });
+
+  /**
+   * D's settled-at-entry guard (SPRINT8 §Lane D). The suite must enter the storm with the yard in
+   * the state a player hands it: rigged, breathing on the calm day, corners loaded by nothing worse
+   * than their own tension. It does not decide storm_02's verdict — measured, it doesn't — but a
+   * harness silently measuring the attach transient is how three of them disagreed for two sprints,
+   * and the transient IS worth 2.7× on tree corners in the moment it exists.
+   */
+  t.test('harness: the yard is SETTLED when the storm starts', () => {
+    const runs = [['line', line], ['cheap', cheap], ['gentle', gentle]].filter(([, r]) => r);
+    for (const [name, r] of runs) {
+      if (!(r.entryPeak < 1.0)) {
+        throw new Error(
+          `${name} entered the storm carrying ${r.entryPeak.toFixed(2)} kN — that is an attach ` +
+          'transient, not a rig. Settle on the calm day with a running clock, as main.js does.');
+      }
+    }
+    return `entry loads: ${runs.map(([n, r]) => `${n} ${r.entryPeak.toFixed(2)} kN`).join(' · ')}`;
   });
 
   t.test('balance: storm_02 punishes a cheap rig on the same quad', () => {

web/world/js/tests/weather.selftest.js

@@ -281,6 +281,80 @@ export function weatherCases(storms) {
     assert(Math.abs(luvS - luvB) < 1e-9, 'upwind side is being sheltered — shadow is pointing the wrong way');
   });
 
+  // ---- 8b. venturi (SPRINT9 site_02 — the corner block funnels the southerly) ----
+  test('venturi speeds the wind up when it blows along the gap, not across it', () => {
+    const def = storms.storm_02_wildnight;
+    // a funnel whose axis runs NE–SW (0.9 rad ≈ 51°), at the yard centre
+    const AXIS = 0.9;
+    const bare = createWindField(def);
+    const funnel = createWindField(def).setVenturi([{ x: 0, z: 0, axis: AXIS, gain: 1.5, radius: 5, sharp: 3 }]);
+
+    // when the wind blows ALONG the axis, the throat should scream
+    const dt = 1 / 60;
+    let alongBoost = 1, crossBoost = 1, alongT = 0, crossT = 0;
+    for (let t = 0; t <= def.duration; t += dt) {
+      const d = bare.dirAt(t);
+      // alignment of the wind with the funnel axis, |dot|
+      const align = Math.abs(Math.cos(d) * Math.cos(AXIS) + Math.sin(d) * Math.sin(AXIS));
+      const boost = funnel.speedAt(0, 0, t) / bare.speedAt(0, 0, t);
+      if (align > 0.98 && boost > alongBoost) { alongBoost = boost; alongT = t; }
+      if (align < 0.15 && boost < crossBoost) { crossBoost = boost; crossT = t; }
+    }
+    metrics['venturi.alignedBoost'] = +alongBoost.toFixed(3);
+    metrics['venturi.crosswindBoost'] = +crossBoost.toFixed(3);
+    assert(alongBoost > 1.35, `a dead-on wind only boosted ${alongBoost.toFixed(2)}× at t=${alongT.toFixed(1)} — funnel too weak`);
+    assert(crossBoost < 1.03, `a crosswind still boosted ${crossBoost.toFixed(2)}× at t=${crossT.toFixed(1)} — a funnel shouldn't fire across its axis`);
+    // never slows the wind (a venturi accelerates, it doesn't shelter)
+    assert(alongBoost >= 1 && crossBoost >= 1, 'venturi reduced the wind somewhere — it can only speed it up');
+  });
+
+  test('venturi only reaches inside its radius, and downdraft rides it', () => {
+    const def = storms.storm_02_wildnight;
+    const f = createWindField(def).setVenturi([{ x: 0, z: 0, axis: 0.9, gain: 1.5, radius: 5, sharp: 3 }]);
+    const bare = createWindField(def);
+    // far outside the throat: untouched
+    assert(Math.abs(f.speedAt(20, 0, 40) - bare.speedAt(20, 0, 40)) < 1e-9, 'venturi reached 20 m away');
+    // the vertical downdraft is a fraction of local speed, so it funnels too
+    const out = { x: 0, y: 0, z: 0 }, outBare = { x: 0, y: 0, z: 0 };
+    let maxRatio = 0;
+    for (let t = 0; t <= def.duration; t += 1 / 60) {
+      f.vecAt(0, 0, t, out); bare.vecAt(0, 0, t, outBare);
+      if (outBare.y < -0.1) maxRatio = Math.max(maxRatio, out.y / outBare.y);   // both negative
+    }
+    assert(maxRatio > 1.3, `funnel didn't strengthen the downdraft (max ${maxRatio.toFixed(2)}×) — it should ride local speed`);
+  });
+
+  test('an empty venturi list is a perfect no-op (backyard_01 is untouched)', () => {
+    const def = storms.storm_02_wildnight;
+    const bare = createWindField(def);
+    const set = createWindField(def).setVenturi([]);
+    for (const p of PROBES) {
+      for (const t of [10, 40, 60, 75]) {
+        assert(bare.speedAt(p.x, p.z, t) === set.speedAt(p.x, p.z, t),
+          `setVenturi([]) changed the wind at (${p.x},${p.z}) t=${t}`);
+      }
+    }
+  });
+
+  test('venturi keeps the wind continuous — no frame-to-frame snap', () => {
+    // a discontinuity in the funnel would be an impulse straight into a corner;
+    // both axes matter — a standing sail (time) and a swinging wind (alignment).
+    const def = storms.storm_02_wildnight;
+    const f = createWindField(def).setVenturi([{ x: 0, z: 0, axis: 0.9, gain: 1.6, radius: 5, sharp: 3 }]);
+    const a = { x: 0, y: 0, z: 0 }, b = { x: 0, y: 0, z: 0 };
+    let worst = 0, worstT = 0;
+    // sit right in the throat through the whole storm, including the change
+    f.vecAt(0.5, 0.5, 0, a);
+    for (let t = 1 / 60; t <= def.duration; t += 1 / 60) {
+      f.vecAt(0.5, 0.5, t, b);
+      const jump = Math.hypot(b.x - a.x, b.y - a.y, b.z - a.z);
+      if (jump > worst) { worst = jump; worstT = t; }
+      a.x = b.x; a.y = b.y; a.z = b.z;
+    }
+    metrics['venturi.maxTemporalJump'] = +worst.toFixed(3);
+    assert(worst < 1.5, `venturi jumped ${worst.toFixed(2)} m/s in one frame at t=${worstT.toFixed(1)}`);
+  });
+
   // ---- 9. vertical structure (SPRINT3 decision 8: fraction of TOTAL) ----
   // Cloth pressure goes with dot(wind, normal). A flat panel's normal points at
   // the sky, so in a purely horizontal wind that dot is ~0 and "lie it flat and

web/world/js/weather.core.js

@@ -252,6 +252,7 @@ export function createWindField(def, opts = {}) {
     : [];
 
   let shelters = [];
+  let venturi = [];
 
   /** Spatially-uniform part: base curve + every gust envelope live at t. */
   function uniformSpeed(t) {
@@ -278,12 +279,13 @@ export function createWindField(def, opts = {}) {
     return sampleAngleCurve(def.dirCurve, t) + wAmp * Math.sin(t * wRate);
   }
 
-  /** Local horizontal wind speed (m/s) — base+gusts, spatial noise, tree shadow.
-   *  The one place the local-speed maths lives; speedAt/vecAt/verticalAt share it. */
+  /** Local horizontal wind speed (m/s) — base+gusts, spatial noise, tree shadow,
+   *  site venturi. The one place the local-speed maths lives; speedAt/vecAt/
+   *  verticalAt share it, so the downdraft rides the funnel too. */
   function localHoriz(x, z, t) {
     const uni = uniformSpeed(t);
     const d = dirAt(t);
-    const s = uni * spatialFactor(x, z, t) * shelterFactor(x, z, Math.cos(d), Math.sin(d));
+    const s = uni * localFactor(x, z, t, Math.cos(d), Math.sin(d));
     return s > 0 ? s : 0;
   }
 
@@ -377,6 +379,38 @@ export function createWindField(def, opts = {}) {
     return f;
   }
 
+  /**
+   * A venturi is a shelter's opposite: a gap between buildings SPEEDS the wind up
+   * when it blows along the gap's axis (SPRINT9 site_02, the corner block funnels
+   * the southerly). Where a tree shadow depends on being downwind of the tree,
+   * a venturi depends on the wind being ALIGNED with a fixed axis the SITE owns —
+   * so it fires only when the storm's direction swings to match, which is the
+   * whole drama: the corner block is calm until the southerly comes through, then
+   * it screams. Multiplier ≥ 1, and inert (empty list) on any site that has no
+   * funnel, so backyard_01 is untouched.
+   */
+  function venturiFactor(x, z, dirX, dirZ) {
+    let f = 1;
+    for (let i = 0; i < venturi.length; i++) {
+      const v = venturi[i];
+      const rx = x - v.x, rz = z - v.z;
+      const dist = Math.hypot(rx, rz);
+      if (dist >= v.radius) continue;
+      // how well the wind lines up with the gap's axis. |dot| because a gap
+      // funnels either way through it; ^sharp so only a well-aligned wind counts.
+      let align = Math.abs(dirX * v.axisX + dirZ * v.axisZ);
+      align = Math.pow(align, v.sharp);
+      const radial = 1 - smoothstep(v.radius * 0.4, v.radius, dist);   // full in the throat, fades out
+      f *= 1 + (v.gain - 1) * align * radial;
+    }
+    return f;
+  }
+
+  /** Every spatial speed multiplier at a point, given the wind direction. */
+  function localFactor(x, z, t, dirX, dirZ) {
+    return spatialFactor(x, z, t) * shelterFactor(x, z, dirX, dirZ) * venturiFactor(x, z, dirX, dirZ);
+  }
+
   const field = {
     def,
     seed,
@@ -399,6 +433,32 @@ export function createWindField(def, opts = {}) {
     },
     get shelters() { return shelters; },
 
+    /**
+     * A site's wind funnels (SPRINT9 site_02). Lane A calls this from the site
+     * JSON after building the yard, the same way it calls setSheltersFromTrees.
+     * Unset = no funnels, so backyard_01 is untouched. Each zone:
+     *   { x, z }        centre of the throat, metres
+     *   axis            direction the gap runs, RADIANS in the XZ plane
+     *   gain            peak speed multiplier when the wind is dead-on (>1)
+     *   radius          how far the acceleration reaches, metres
+     *   sharp           alignment falloff exponent — higher = only a wind almost
+     *                   exactly along the axis funnels (default 3)
+     */
+    setVenturi(list) {
+      venturi = (list || []).map((v) => {
+        const axis = v.axis ?? 0;
+        return {
+          x: v.x, z: v.z,
+          axisX: Math.cos(axis), axisZ: Math.sin(axis),
+          gain: Math.max(1, v.gain ?? 1.4),
+          radius: v.radius ?? 4,
+          sharp: Math.max(1, v.sharp ?? 3),
+        };
+      });
+      return field;
+    },
+    get venturi() { return venturi; },
+
     /**
      * Scalar wind speed (m/s) at a point — HORIZONTAL only, which is what an
      * anemometer reads and what the HUD, rain and grass want. The gust downdraft

web/world/js/weather.js

@@ -136,6 +136,15 @@ export function createWind(def, opts = {}) {
       })));
     },
 
+    /**
+     * A site's wind funnels (SPRINT9 site_02). Lane A: call with the site JSON's
+     * `wind.venturi` after building the yard. Empty/absent = no funnels, so
+     * backyard_01 reads exactly as it always has.
+     * @param {Array<{x,z,axis,gain,radius,sharp}>} list
+     */
+    setVenturi(list) { field.setVenturi(list); return wind; },
+    get venturi() { return field.venturi; },
+
     /** Storm events fired in (a,b] — poll with (t-dt, t). Deterministic. */
     eventsBetween(a, b) { return field.eventsBetween(a, b); },
 

web/world/js/week.js

@@ -0,0 +1,222 @@
+/**
+ * SHADES — the week. Lane A owns this file.
+ *
+ * Five nights, one yard, one wallet. This is deliberately a thin wrapper around
+ * the phase machine rather than a new system: main.js already knows how to run
+ * forecast → prep → storm → aftermath, and the week's whole job is to answer
+ * three questions between rounds — which storm is tonight, how much money do you
+ * have, and is it over.
+ *
+ * Zero imports beyond contracts, and no THREE: the money and the ladder of
+ * nights are pure data, so they're testable at fixed cost with no browser. The
+ * only thing that touches the screen is main.js reading these numbers.
+ */
+
+import { START_BUDGET, HARDWARE } from './contracts.js';
+
+/**
+ * The ladder. Escalating, and each rung introduces one new idea rather than just
+ * more wind — that's Lane C's authoring, not my ordering:
+ *   1 Sea Breeze       gust 10.5, no hail   — the tutorial: nothing can hurt you
+ *   2 Southerly Buster gust 20.0, hail      — the change, and hail, arrive
+ *   3 Early Buster     gust 20.0, hail      — same teeth, change comes EARLY
+ *   4 Wild Night       gust 30.0, hail      — the one the whole repo tuned for
+ *   5 Ice Night        gust 28.5, hail      — less wind, more ice
+ * Night 3 is the trap: it looks like night 2 on the forecast card and isn't.
+ */
+export const NIGHTS = [
+  'storm_01_gentle',
+  'storm_03_southerly',
+  'storm_03b_earlybuster',
+  'storm_02_wildnight',
+  'storm_02b_icenight',
+];
+
+/**
+ * The economy, in one place because it is the thing most likely to need tuning
+ * once somebody actually plays five nights in a row.
+ *
+ * Shape (SPRINT8 §gate 1): pay = fee by severity + garden bonus + intact
+ * hardware refund − collateral. Two of those needed a judgement call and both
+ * are the difference between a week with stakes and a week you cannot lose:
+ *
+ *  - **A lost night pays a fraction of the fee, not zero and not all of it.**
+ *    Zero is unrecoverable and reads as punishment; full pay means failure costs
+ *    only the broken shackle, and the bank only ever climbs. DESIGN.md's warranty
+ *    callout is the source: you turn up, you're just not getting paid for it.
+ *  - **Hardware comes back at half.** Full refund makes gear effectively free —
+ *    the only sink left is breakage, the bank grows every night, and "broke =
+ *    game over" becomes unreachable. Half is also the honest number: a shackle
+ *    that rode out a gale has been fatigued, its pin worked loose, and DESIGN.md
+ *    already says flogging unscrews unmoused pins. You can re-use it; you can't
+ *    call it new.
+ */
+export const PAY = {
+  /**
+   * Client's fee for the job, scaled off the storm's worst gust.
+   *
+   * The constants are set by the shape of the week, not by taste — measured by
+   * playing all five nights at fixed skill. A fee has to be worth roughly
+   * two-thirds of a good rig ($75): any smaller and one bad night is instant
+   * game over (at `8 + gust` a disaster night paid $13 against a $75 rig and
+   * ended the week on night ONE, which is a punishment, not a difficulty); any
+   * larger and the bank runs away and night five is trivially affordable.
+   * At `25 + 1.6·gust` a disaster leaves you at ~$26 — alive, but rigging the
+   * next night on carabiners, which is the death spiral doing its job.
+   */
+  feeFor: (gustPeak) => Math.round(25 + gustPeak * 1.6),
+  /** A lost night still pays this share — you turned up, it just went wrong. */
+  lostNightShare: 0.35,
+  /** Garden bonus at hp=100. Scales linearly; this is the main earner. */
+  gardenBonusMax: 45,
+  /** What surviving hardware is worth back. Fatigued, not new. */
+  refundShare: 0.5,
+};
+
+/**
+ * Below this you cannot rig four corners at all — four carabiners is the floor.
+ *
+ * ⚠️ MEASURED, OPEN, AND FOR A PLAYTEST TO SETTLE — not a guess, and written
+ * here because the numbers are only visible once you run five nights:
+ *
+ *  1. **A competent week runs away with the money.** Holding 4/4 at hp 70 every
+ *     night takes the bank 80 → 116 → 167 → 218 → 285 → 350. By night three you
+ *     can already afford four rated shackles ($120) and the wild night stops
+ *     being a decision. The fee is the lever; it is deliberately NOT tuned down
+ *     yet, because the fix might equally be that later nights should cost more
+ *     to rig (a bigger sail, a second bed) — that's Sprint 9's content question,
+ *     not a constant I should quietly pick tonight.
+ *  2. **A floor-scraping week may never actually go broke.** At $20 a cheap rig
+ *     earns back roughly what it costs, so the bank can sit just above this line
+ *     indefinitely, losing every garden. The grade fixes what the END CARD says
+ *     about that (see gradeFor) but not whether 'gameover' is reachable at all
+ *     from a slow bleed rather than one disaster.
+ *
+ * I could not settle either from the harness: my own bad-player model handed
+ * back a fixed $30 of intact hardware no matter what it spent, which flattered
+ * the bottom of the curve and is exactly the class of mistake this repo has
+ * caught me making all project. Both need a human playing five nights.
+ */
+export const BROKE_BELOW = HARDWARE[0].cost * 4;
+
+/**
+ * How the week is remembered, by gardens actually held.
+ *
+ * SPRINT8 gave Lane A the win wording, and this is the ruling: the end card is
+ * the last thing SHADES says to a player, so it does not get to lie the way the
+ * aftermath verdict used to. Three grades, and E's copy carries two of them —
+ * their primary for a clean week, their own alternate for a scraped one. The
+ * third is mine, because E never wrote words for "you stayed solvent while the
+ * client's garden died four times", and until this was measured nobody knew the
+ * game could even produce that ending.
+ *
+ * @param {number} held gardens saved, 0..5
+ */
+export function gradeFor(held) {
+  if (held >= 5) return 'clean';
+  if (held >= 3) return 'scraped';
+  return 'solvent';
+}
+
+/** Worst gust a storm def can throw — the severity signal the fee reads. */
+export function gustPeakOf(def) {
+  const base = Math.max(...def.baseCurve.map((p) => p[1]));
+  const g = def.gusts ?? {};
+  return base + (g.powBase ?? 0) + (g.powRamp ?? 0);
+}
+
+/**
+ * @typedef {object} Settlement
+ * @property {number} fee        client's payment for the job
+ * @property {number} bonus      garden bonus
+ * @property {number} refund     intact hardware recovered, at half
+ * @property {number} collateral what your failure broke of theirs
+ * @property {number} pay        fee + bonus + refund − collateral
+ * @property {number} bankBefore
+ * @property {number} bankAfter
+ * @property {'continue'|'win'|'gameover'} outcome
+ */
+
+/**
+ * @param {object} [opts]
+ * @param {number} [opts.bank=START_BUDGET]
+ */
+export function createWeek(opts = {}) {
+  const startBank = opts.bank ?? START_BUDGET;
+  let index = 0;          // 0-based into NIGHTS
+  let bank = startBank;
+  let done = false;
+  /** @type {Settlement[]} */
+  const log = [];
+
+  const week = {
+    /** 1-based, for humans. "Night 3 of 5". */
+    get night() { return index + 1; },
+    get nights() { return NIGHTS.length; },
+    get stormKey() { return NIGHTS[index]; },
+    get bank() { return bank; },
+    get isFinalNight() { return index === NIGHTS.length - 1; },
+    get over() { return done; },
+    get log() { return log; },
+
+    reset() {
+      index = 0; bank = startBank; done = false; log.length = 0;
+      return week;
+    },
+
+    /**
+     * Settle the night just played and move the ladder on.
+     *
+     * @param {object} run   main.js's scoreRun() result
+     * @param {object} def   tonight's storm def (for severity)
+     * @param {number} spent what prep actually cost out of the bank
+     * @returns {Settlement}
+     */
+    settle(run, def, spent) {
+      const bankBefore = bank;
+      const fullFee = PAY.feeFor(gustPeakOf(def));
+      const fee = run.win ? fullFee : Math.round(fullFee * PAY.lostNightShare);
+      const bonus = Math.round((Math.max(0, run.hp) / 100) * PAY.gardenBonusMax);
+
+      // Only hardware still on an unbroken corner comes home, and at half.
+      const intact = (run.intactHardwareValue ?? 0);
+      const refund = Math.round(intact * PAY.refundShare);
+
+      const collateral = (run.collateral ?? []).reduce((s, c) => s + c.cost, 0);
+      const pay = fee + bonus + refund - collateral;
+
+      bank = Math.max(0, bankBefore - spent + pay);
+
+      const held = log.filter((n) => n.won).length + (run.win ? 1 : 0);
+
+      // Outcome is decided AFTER the money moves: you can win the last night and
+      // still be broke, and the week should say you finished it.
+      //
+      // Reaching night five is NOT winning, and the first draft of this said it
+      // was. Measured: a player who rigs $20 of carabiners every night loses
+      // four gardens out of five, never dips under the broke line because a
+      // cheap rig barely costs anything, and got handed "THE WEEK HELD —
+      // everything's still where you put it" over four dead gardens. Outlasting
+      // the week isn't surviving it. So the WORDS scale with what you actually
+      // held (see grade); the outcome only says whether you're still trading.
+      let outcome;
+      if (week.isFinalNight) outcome = 'win';
+      else if (bank < BROKE_BELOW) outcome = 'gameover';
+      else outcome = 'continue';
+      done = outcome !== 'continue';
+
+      const s = { fee, fullFee, bonus, refund, collateral, pay, spent,
+        bankBefore, bankAfter: bank, outcome, night: week.night, held,
+        grade: gradeFor(held), stormKey: week.stormKey, won: !!run.win };
+      log.push(s);
+      return s;
+    },
+
+    /** Move to the next night. No-op once the week is done. */
+    advance() {
+      if (!done && index < NIGHTS.length - 1) index++;
+      return week;
+    },
+  };
+  return week;
+}