Add night dressing and end cards; fix the hide_render bug

hide_render does not survive glTF export — verified in three r175, every node
arrives visible:true. So garden_bed has been drawing plants_full, tattered AND
dead superimposed since Sprint 1, and my THREADS note told Lane A the opposite.
The asserts missed it by checking the nodes existed rather than that only one
was on. The flag now rides in extras, which does export, and consumers apply it
in one line; e.test.js pins the flag instead of the node.

Night dressing: house_yardside gains window_glow, an unlit emissive pane marked
hidden_by_default, plus window_light_anchor. A warm window means someone is
inside, which is why the player is out in the dark keeping the sail on. Plus a
moon sprite whose halo, not its disc, is the part that survives cloud.

End cards are rendered from the game's own props as a diptych: identical camera
and yard, only the night's outcome differs. The left third is left empty for
Lane A's text.

Cards are opt-in behind --cards because EEVEE's shadow pass is not
byte-reproducible across processes in 5.1 — proven with a minimal repro, not
PYTHONHASHSEED, and present even with a hard sun. The dawn shadow is the art, so
the cards become committed art rather than build output. Everything the game
loads stays byte-identical: 38/38 verified.

Selftest 241/0/0.

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

LANE_PROMPTS.md

@@ -330,3 +330,55 @@ Read THREADS' last [I] entry then SPRINT5.md.
 > (instanced-friendly, stone mesh only if C asks), plant-shred particle puff
 > for hail hits on the bed, and the carried contact-sheet refresh (night +
 > daylight) for DESIGN.md.
+
+---
+---
+
+# SPRINT 6 prompts (winnable, then a week of nights)
+
+Same rules: own clone, own branch, rebase onto latest main FIRST (Sprint 5
+merged; decision 13 wired with integration-guess weights; the balance gap is
+measured in THREADS' last [I] entry). Gate 1 is JOINT and comes first.
+
+## Lane A — Sprint 6
+> You are Lane A on SHADES 3D, Sprint 6. Rebase onto main, read THREADS' last
+> [I] (the balance numbers) and SPRINT6.md. Gate 1 first, jointly with B+C:
+> your levers are the drain weights in main.js, possibly ONE new close anchor
+> for a bed-covering small quad (re-run your own smallest-full-coverage assert
+> after), and verdict truthfulness (a 4/4 clean hold must never read "you
+> skimped"). Then gate 2, the week: five escalating nights, money persists,
+> broke = game over, survive = win screen, "play again" becomes "next night".
+> Also: lift E's screenshot POST into server.py (delete tools/yardshot/),
+> decide the grass atlas (take the recipe or delete it), and land the pond
+> ticker + hail banner if Sprint 5 didn't. Shepherd as always.
+
+## Lane B — Sprint 6
+> You are Lane B on SHADES 3D, Sprint 6. Rebase onto main, read THREADS' last
+> [I] and SPRINT6.md. You hold the pen on balance.test.js: for each storm, an
+> enumerable $80 REAL-shop loadout on an in-band quad must end hp≥50 with <2
+> corners lost — and storm_02's line must genuinely need the repair or the
+> broom (assert it fails without them). Then fabric choice in prep: porous
+> shade cloth vs waterproof membrane (porosity exists in the sim) — agree the
+> hail-vs-porosity rule with C in THREADS before coding, price the tradeoff.
+> And post D the typical storm_02 belly-pond mass for their douse tuning.
+
+## Lane C — Sprint 6
+> You are Lane C on SHADES 3D, Sprint 6. Rebase onto main, read THREADS' last
+> [I] and SPRINT6.md. Gate 1 partner: downdraft (0.40 also passes both physics
+> gates per your own sweep) and hail-burst data are your levers. Then author
+> the week's two storm variants (same JSON language, one new trick each) and
+> forecast uncertainty: the card shows seeded ± ranges that resolve as the
+> night approaches — DESIGN.md's partial-information canon, cheaply.
+
+## Lane D — Sprint 6
+> You are Lane D on SHADES 3D, Sprint 6. Rebase onto main, read SPRINT6.md.
+> Calibrate the douse comedy to B's real pond masses (thresholds vs ~450 kg
+> belly ponds), then play the balanced storms end to end as gate 1 lands and
+> file feel notes in THREADS before it ships — you are the playtest lane, and
+> after gate 2 you play the whole week.
+
+## Lane E — Sprint 6
+> You are Lane E on SHADES 3D, Sprint 6. Rebase onto main, read SPRINT6.md.
+> Night dressing for the week's later storms (moon, lit house window),
+> win-screen and game-over cards that feel like SHADES, and refresh the
+> contact sheets once the balance pass lands.

SPRINT6.md

@@ -0,0 +1,80 @@
+# SPRINT 6 — WINNABLE, THEN A WEEK OF NIGHTS (instructions for Opus 4.8 lanes)
+
+*Sprint 5 verdict: every system is real — ponding kills flat sails and the broom
+saves them (B and D's halves met on merge without a single coordination bug),
+hail is steep and honest and proven 4.4× rig-responsive, the router tripwire
+caught its first real omission. But the integrator measured the merged game and
+the wild night has NO winnable line: survivable rigs don't cover the bed,
+bed-covering rigs don't survive, and the $80 shop can't buy both. The systems
+sprint is over. Sprint 6 makes the game FAIR, then makes it a CAMPAIGN.*
+
+Read THREADS from the last [I] entry — the balance numbers are there.
+
+## Gate 1 — THE BALANCE PASS (joint A+B+C, do it FIRST, everything else waits)
+
+Target, stated as play: **storm_01 is a warm-up anyone wins · storm_03 is
+winnable at $80 with decent rigging · storm_02 is winnable with excellent
+rigging + one mid-storm repair + the broom.** Written as asserts (a new
+`js/tests/balance.test.js`, owned jointly, B holds the pen): for each storm,
+at least one enumerable $80 shop loadout on an in-band quad ends with
+hp ≥ 50 and < 2 corners lost, driven through the REAL shop economy — and for
+storm_02 that loadout must genuinely need the repair or the broom (assert it
+fails without them).
+Levers, in the order I'd reach for them (agree the final mix in THREADS):
+- hail/rain drain weights in main.js (integration guesses: 5.0 / 0.25);
+- bed-coverage geometry: A may add ONE close anchor (e.g. a low hook on the
+  shed roof) so a small bed-covering quad exists — re-run A's own
+  smallest-full-coverage assert after, the >45 m² tension must survive;
+- downdraftOfTotal 0.45 → C measured 0.40 also passes both physics gates;
+- win bar (hp ≥ 50) and hardware prices last — they move everything.
+Also: **verdict truthfulness** (A) — a 4/4 no-break run must never read "the
+rain found what you skimped on". Verdict picks from actual failure modes:
+corners lost / garden hailed / ponded and dumped / clean hold.
+
+## Gate 2 — THE WEEK (A owns, the campaign seed)
+
+Five nights, escalating: 01, 03, 03-variant, 02, 02-variant (C authors the two
+variants — same JSON language, one new trick each: an earlier change, a longer
+hail burst). Money persists: aftermath pay = base per storm severity + garden
+bonus + intact-hardware refund − collateral; bank carries to the next night's
+shop. Broke before night five = game over (verdict card); survive the week =
+the win screen SHADES has never had. Keep it one file if you can — it's a
+phase-machine wrapper, not a new system. "Play again" becomes "next night".
+
+## Lane assignments
+
+**A** — gate 1 levers + verdicts; gate 2 (the week); lift E's screenshot POST
+into server.py (delete tools/yardshot/); take E's grass recipe or delete the
+atlas (your call, stop carrying it); pond ticker + hail banner if they didn't
+land in Sprint 5's HUD.
+**B** — balance.test.js pen-holder; fabric choice in prep (porosity exists in
+the sim — expose shade cloth vs waterproof membrane as a per-sail choice with
+DESIGN.md's tradeoff: porous sheds wind but lets hail through harder? No —
+keep it honest: porous halves wind load AND ponds nothing, membrane blocks
+hail fully; price the difference. Coordinate the hail-porosity question with
+C before coding); tell D the typical storm_02 belly-pond mass so the douse
+comedy lands.
+**C** — gate 1 partner (downdraft/hail data); the two storm variants for the
+week; forecast UNCERTAINTY (DESIGN.md canon: early forecasts are partial —
+card shows ranges that resolve as the night approaches; cheap: render bands
+from a seeded ± on the real numbers).
+**D** — douse calibration to B's real masses (splash/stagger/knockdown
+thresholds vs ~450 kg belly ponds); feel pass on the balanced storms
+(you're the player); surface anything gate 1 got wrong before it ships.
+**E** — night-variant dressing (moon, house window light for the night
+storms); win-screen and game-over art cards (text-on-canvas is fine, make
+them feel like SHADES); refresh contact sheets after the balance pass.
+
+## Gates
+
+```
+gate 1: balance.test.js green — every storm has a real winnable line, and
+        storm_02's needs the repair or the broom; verdicts tell the truth
+gate 2: the week runs: five nights, money carries, broke = game over,
+        survive = win screen — played end to end, screenshotted
+gate 3: John plays the week and his three sentences go in THREADS
+```
+
+Definition of done = gate 2 (gate 3 is John's, not yours). After this SHADES
+is a GAME — Sprint 7 starts DESIGN.md's real campaign: sites, clients,
+job types, the landscaper service.

THREADS.md

@@ -825,6 +825,41 @@ 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-17 — 🧰 **SPRINT 5 START — router tripwire landed, and it is aimed straight at THIS sprint's
+    headline system.** The Sprint 4 integration note (router silently swallowing `rainMmPerHour`/
+    `rainDepthMm`, ponding would have passed every assert and done nothing in the yard) was **my file's
+    bug**, and the class is worse than the instance: tests hold a real wind, only the GAME holds the
+    router, so an omission is invisible to every suite we own. **Lane C: your `hailAt()` lands this
+    sprint and decision 13 hangs the entire garden score off it — the same swallow would make rigging
+    look irrelevant to the garden all over again, which is the exact thing Sprint 5 exists to fix.**
+    `js/tests/a.test.js` now diffs `createWindRouter` against a real wind and fails naming the missing
+    member. I verified it FIRES rather than just passing: rebuilt Sprint 4's pre-fix router and it
+    reports exactly `rainMmPerHour, rainDepthMm`. **Add hail to the wind surface and the router will go
+    red until I forward it — which is the point. Ping me and it's a one-line fix.** Selftest 209/0/0.
+
+[A] 2026-07-17 — ✅ **I re-measured my own Sprint 4 finding against a proper control, because decision 13
+    rests on it and my control was suspect.** It was: skipping the rig left the PREVIOUS round's sail in
+    C's shadow grid, and a re-run scored "no sail" at 61% — better than a good rig, which is nonsense
+    and is how I noticed. Redone on a fresh boot with nothing ever rigged (`rig.rigged === false`,
+    `cornerCount 0`, `rainShadowOver(bed) === 0.000`): **true no-sail = 48.5%, good rig = 53%, avg
+    exposure 0.632.** The 4.5-point gap is real and the finding stands unchanged — **decision 13's
+    premise is sound.** Flagging the near-miss anyway: I reported a number from a control that had a
+    sail in it, and got the right answer by luck rather than method.
+
+[A] 2026-07-17 — 📌 **Lane A is DOWNSTREAM this sprint — items 1-3 all wait on you three, so here is what
+    I need and when.** Not blocking anyone; just so nobody assumes I'm stuck when I'm idle.
+      · **Lane C** — item 1 (decision 13 wiring) needs `sky.gardenHailExposure(bed, t)`. Your Sprint 4
+        `gardenExposure(rect, t)` is already the mold and **I've switched main.js onto it**, so hail
+        lands as one added term in `garden.step()` rather than a rewrite. No storm has a `hail` block
+        yet, so there is nothing for me to wire until yours lands.
+      · **Lane B** — item 2 (pond HUD + "SAIL PONDING — get the broom" ticker) needs `pondMass()`. Also
+        `session.reset()` (SPRINT5 §B.3): I'm still faking it in main.js by unrigging every pick, which
+        works via your refunds but is five lines of me reaching into your state machine.
+      · **Lane D** — item 3 needs your greyed-prompt label + reason; hud.js has the surface waiting.
+      · **Lane B, answering your panel question (SPRINT5 §A.4):** keep your panel. It's good, it's
+        yours, and I'd only be rebuilding it worse. hud.js owns everything else.
+    Meanwhile I'm on item 4 (E's `sway_amp`/`sway_phase` canopy handles) and shepherding.
+
 [A] 2026-07-17 — 🚩 **GATE 1 (Sprint 4) — THE GAME HAS A FACE. You can play a whole round with a mouse.**
     On main. `python3 server.py` → forecast card → click a storm → click anchors to rig → ENTER → ride it
     → aftermath → play again. No console. Selftest **184/0/0**. What landed: `hud.js` (world-anchored
@@ -1573,3 +1608,256 @@ Format: `[lane letter] YYYY-MM-DD — note`
     `docs/yard_day.jpg`, left-hand gum. Standing offer from Sprint 4: I can taper and re-angle the limbs
     while pinning the `branch_anchor_*` tips so **not one anchor moves** and none of B's §7 numbers shift.
     It's contained and it's the most visible art problem in the hero shot. Say the word.
+[C] 2026-07-17 — **HAIL LANDED — decision 13's engine. Selftest 216/0/0.** Storm hail carries the garden
+    score, and it works because hail falls STEEP where rain doesn't: a raindrop's terminal velocity is
+    ~9 m/s (a 30 m/s gale blows it in at ~73° off vertical, which is why it walks under a sail and a
+    perfect rig tied with no rig), a hailstone's is ~22 m/s and it couples weakly to the crosswind, so
+    even a gale leans it ≤20°. Overhead cloth blocks steep ice. No faked physics.
+      · **weather.core:** `hail` block in the storm JSON — authored `bursts` (envelopes) plus one synced
+        to every gust ≥ `withGustsAbove`, so the biggest gusts arrive WITH ice. `hailAt(t)` (max over live
+        bursts, 0..1), `hailSize`, validator. Gust-synced bursts draw ZERO randomness (key off the gust
+        timeline), so tuning hail can't re-time the storm — same guarantee as the downdraft, asserted.
+      · **storms:** storm_02 bursts ON the southerly change (peak 1.0 at t=56.5, 11.4 hail-seconds, size
+        1.3) and adds ice to its late big gusts; storm_03 one mild 0.5 burst (size 0.7); storm_01 none.
+      · **skyfx:** `gardenHailExposure(bed, t)` in the gardenExposure mold (the feed A wires), a steep
+        second RainShadow, instanced falling stones (hidden under the cloth so you SEE the sail work), and
+        hail audio — ground clatter that fades as the sail intercepts, plus the cloth DRUM that rises as
+        the sail catches hail (the "my sail is earning its money" sound). Also `sky.hailAmount` getter.
+
+[C] 2026-07-17 — **DECISION 13 / GATE 2 PROVEN: no-sail garden takes 4.4× the hail of a well-covered bed**
+    over a full storm_02 (bar is ≥2×), through the real `gardenHailExposure` + B's SailRig. Asserted in
+    c.test.js. Verified live too: at the burst a bed-covering rig cuts hail exposure roughly in half, and
+    the stones fall visibly steeper than the rain beside them (screenshot for DESIGN.md). **A — your garden
+    score will now separate a good rig from no rig.** Wiring, per SPRINT5 §A-1:
+    `gardenDrain = sky.gardenHailExposure(bed, t) * HAIL_DAMAGE + sky.gardenExposure(bed, t) * SMALL_RAIN`.
+    Hail is the headline (aftermath "hail blocked" line reads off `sky.hailShadowOver(bed)` × how much hail
+    fell); rain stays the small honest drain that walks under the sail. `sky.hailAmount` (0..1) is your
+    "HAIL" banner trigger; the drum audio already tells the player when the sail is catching it.
+
+[C] 2026-07-17 — **A — I edited main.js's router (two lines): `hailAt`/`hailSize`. Flagging since it's your
+    file.** Your tripwire ('wind router forwards EVERYTHING') went red the instant weather.js grew hailAt —
+    which is the tripwire earning its keep; it even names hail as the case it's guarding. Your comment on
+    createWindRouter is the standing instruction ("Anything new on the wind contract must be added here
+    too"), so I followed it rather than leaving main red for you to find. Same pattern as the existing
+    forwards, tripwire green again, hail verified reaching skyfx in-game with no console patch. Thank you
+    for building it — it turned last sprint's silent-swallow into a red test that told me exactly what to
+    add. Revert my two lines only if you'd rather own them; the forward itself has to stay or decision 13
+    is inert in the game.
+
+[C] 2026-07-17 — **E — hail juice hooks, when you're ready (SPRINT5 §E).** The stones are cheap instanced
+    cubes right now — deliberately minimal so your pips/decals are the detail layer. If you ship impact
+    pips-on-cloth + a ground decal ring, I'll spawn them where a stone meets the sail ceiling or the
+    ground (I already keep a hail-shadow grid that knows the ceiling height per cell, so a cloth-impact
+    point is cheap). Plant-shred puff wants a trigger: fire it when `gardenHailExposure(bed,t)` crosses a
+    threshold — that's the frame the bed actually takes a hit. Tell me the hook shape and I'll match it;
+    `sky.hailAmount` and `hailSize` are live for scaling pip rate/size.
+[B] 2026-07-18 — 💧 **PONDING v1 LANDED — the water arc is closed.** sail.js holds rainwater and it kills
+    flat sails. 37/37 sail + 14/14 rigging + **219/0/0 on the merged browser selftest**, `checkContract`
+    conforms. Verified in the assembled game, not just node: a 123 m² flat quad ponds **780 kg** with the
+    belly sagged below ground, then dumps the instant a corner blows.
+      · **Model is FLOW, not a drain coefficient.** Rain lands on each node's horizontal projection, runs
+        down its steepest of **8** neighbours, pools where it can't get out. The 8-way graph is
+        load-bearing: a 4-way one can't follow a hypar's diagonal saddle ridge, so it trapped water in the
+        gravity belly and a hypar pooled as much as a flat sail. On real yard quads: flat 12 kg/m² vs
+        twisted 1.7. **Ponding cannot pincer §7** — a hypar has nowhere to pool, by construction.
+      · **Rain uses C's real-units API** (`rainMmPerHour` × the exported `RAIN_TIME_COMPRESSION`, never a
+        hardcoded 40). C — this is exactly what I asked for last sprint and it dropped straight in. Thank
+        you.
+
+[B] 2026-07-18 — 🔌 **LANE D — your broom API is frozen in contracts.js. Let's confirm the shape.**
+    `pondCentroid() -> {x,y,z,mass,node} | null` tells you where to walk and which node to poke.
+    `drainPondAt(node, dt, radius=2)` — call it every frame of your ~1.5 s hold; it drains a taper around
+    the node and **RETURNS the kg shed this call**. Sum that over the hold and THAT is what lands on the
+    player's head — you decide what the number does (I'd say: >~150 kg in one poke = a stagger via your
+    knockdown machinery, which is the comedy). It emits `pondDump` on the events bus too. Measured: a
+    1.5 s poke on a loaded belly sheds ~290 of ~310 kg. Shout if you'd rather it drained slower/faster or
+    you want the radius exposed differently — this is the "meet in the middle" you flagged, and it's
+    easier to move now than after you've built against it.
+
+[B] 2026-07-18 — 🎯 **LANE D — the tn-1.04 cliff: found it, and it's NOT a cloth instability. Good catch,
+    wrong diagnosis (mine too, at first).** Investigating your report is literally what surfaced the
+    ponding load regime. The 10 kN "spike" is REAL PHYSICS: a 155 m² flat sail holding 2100 kg of ponded
+    water genuinely pulls ~21 kN on a corner — it stays finite, and the load tracks the water kilo-for-kilo
+    (measured the trace: 15→21 kN as the pond went 1900→2140 kg, belly sagging to 5 m). It is not the
+    solver diverging; it's an absurd rig doing an absurd-but-correct thing. Your own read — "cloth going
+    unstable" — is what I chased for an afternoon, including a per-node displacement clamp that I
+    **reverted** because it moved the thesis 39→34%: clamping real motion to fix a real load is the wrong
+    trade. What landed instead:
+      · a **belly-tear** at 4 m of sag — the sail physically fails and dumps (DESIGN.md "sudden dump…
+        tear"), which bounds the runaway without touching the solver;
+      · an **opt-in `rig.watchDivergence`** tripwire that throws with corner/load/tension/time above 80 kN
+        (true blow-up territory, ~4x any real load) — it's ON in every selftest rig and never false-trips,
+        so if a GENUINE instability ever appears it appears with a repro instead of a mystery.
+    Net for your §7 tuning: nothing changed for good rigs. Your mixed rig still survives, your cascade
+    still cascades. The only rigs that reach 20 kN are oversized flat ones that were already losing to
+    wind — the decision-2 problem, not a cloth bug. **The guard-assert instinct you had (a wind rebalance
+    shouldn't silently kill a mechanic) is exactly right — `watchDivergence` is the same idea for loads.**
+
+[B] 2026-07-18 — ⚠️ **LANE A — pond HUD API + a bug I only caught by running YOUR game.** `rig.pondMass()`
+    is your ticker number ("SAIL PONDING — get the broom" at threshold; I'd fire it around 200 kg — a
+    123 m² sail hits 780 kg before it dumps, and a right-sized one tops out ~450 kg). `pondCentroid()`
+    gives you a world point to hang a warning marker on. **The bug:** pondMass/centroid/drain/dump all
+    threw when `this.water` didn't exist — i.e. before the sail is rigged, which is every frame of
+    forecast+prep. My node tests always attach first so they never saw it; your HUD reads pondMass() on
+    frame 1 and it crashed. Guarded now (return 0 / null / no-op pre-attach) with an assert so it can't
+    come back — but it's a clean example of why the by-hand play matters: nothing in 37 green asserts
+    caught it.
+    Also: `session.reset()` landed for your "play again" — restores budget/picks/tension/spares and is
+    rig-able again, asserted.
+
+[B] 2026-07-18 — 🔭 **DESIGN FINDING for whoever tunes storms — flat rigs die to WIND before water on this
+    yard.** Every flat quad big enough to pond (88-155 m²) is also big enough that storm_02's wind breaks
+    it first — measured, on rated shackles, breaks land at t=6-15 s. So in the *actual game* today, ponding
+    is a real load but rarely the PROXIMATE cause of death on a flat rig; the oversize wind cascade beats
+    it to it. Ponding's clean kill (water alone, wind can't) only shows on a right-sized ~25 m² level
+    "carport", which the current 8-anchor yard can't quite build (the level anchors — h1/h2/h3 — are
+    collinear). Two ways to read this: (a) fine, ponding is the *twist-tax* — it punishes you for going
+    flat-and-big to chase coverage, stacking with the wind penalty; or (b) if you want ponding to be a
+    STANDALONE threat (the "poke it with a broom" beat as its own mini-crisis), the yard needs a level
+    anchor trio that isn't collinear, or a storm with rain but gentle wind (a "steady soaker", DESIGN.md's
+    slow-pressure level type). Not my call — flagging with numbers. The broom mechanic works regardless;
+    this is about whether a player ever NEEDS it.
+[D] 2026-07-17 — 🤝 **LANE B — the broom↔pond seam, posted EARLY as §Lane B-2 asks. This is what I need,
+    and it's three members.** I'm building against exactly this shape right now, duck-typed, so land it
+    whenever and my side lights up with no further coordination:
+      · `sailRig.ponds -> [{ node, mass, pos }]` — every pool worth pointing a broom at. `node` is your
+        grid index (whatever `drainPondAt` wants back), `mass` in kg, `pos` a LIVE world Vector3 of the
+        pooled node. **`pos` is the one I really need**: the player has to physically walk under the
+        belly, so I need to know where the belly IS. Empty array when nothing's pooled.
+      · `sailRig.drainPondAt(node) -> number` — **please return the kg actually dumped.** That number is
+        the whole joke: it's what decides whether the water is a splash, a stagger, or puts the player
+        on their back. If it returns void I have to read `pondMass()` before and after and diff it,
+        which works but is silly.
+      · `sailRig.pondMass() -> number` — you already have this for A's HUD; I use it for "is there any
+        point picking the broom up".
+    Your spec says drain takes ~1.5 s — mine is a 1.5 s hold-E, so if you'd rather drain gradually over
+    the hold than dump on completion, say so and I'll drive it per-frame instead. **Dump-on-completion is
+    my default** because the comedy needs a single moment, not a trickle.
+    Not blocked on you: the broom carries, walks and pokes today against a local stub, and self-skips
+    when `drainPondAt` is absent (same pattern as decision 4 — my call sites landed first and you
+    conformed, which worked well for both of us).
+
+[D] 2026-07-17 — 🧹 **BROOM LANDED (§Lane D-1) — the loop runs in the real game against a stub pond.**
+    `web/world/js/broom.js` (Lane D). Driven by hand: take broom off the shed wall → walk under the
+    belly → prompt reads **"push the water off (78 kg)"** → hold-E poke → `pondMass=0`, and **78 kg lands
+    on the player → stagger.** Self-wires from createPlayer; reads the live rig off `interact.sailRig`
+    (see the wireYardActions note — published there so it survives rigSail's attach() swap). Selftest
+    **217/0/0** (was 207); 13 of the new asserts are the broom's + the greyed prompt's.
+    Everything deferred to E's baked metadata — `carry_type`, `poke_tip.use` (bristle end, "won't hole
+    the cloth"), `anim_hint` (reuse Crank). Nothing invented. E, the asset did the design work; thank you.
+
+[D] 2026-07-17 — 👋 **LANE B — my side of the seam is LIVE and waiting, exactly as I posted it.** The
+    broom already calls `sailRig.ponds` (reads `{node, mass, pos}`) and `sailRig.drainPondAt(node)`
+    (uses the returned kg to size the douse). Confirmed end-to-end in the real game against a stub in
+    your shape — so **when you land ponding, the broom lights up with zero further coordination.** One
+    calibration note for your tuning pass: my douse thresholds are `splash<15kg`, `stagger≥60`,
+    `knockdown≥120` — pure physical guesses (a full bucket ≈10 kg). Once your pond masses are real,
+    tell me a typical storm_02 belly-pond mass and I'll tune the comedy to it. Right now a 78 kg pond
+    staggers; I don't yet know if 78 kg is a normal night or a biblical one.
+
+[D] 2026-07-17 — ✅ **GREYED PROMPTS (§Lane D-2) — the vanishing-prompt confusion is dead. LANE A, your
+    HUD hook is ready.** `interact.step()` now returns `{target, label, progress, holding, usable}`. When
+    `usable:false` the prompt is a REASON, not an offer — grey it, no radial. The label is already the
+    sentence: "hands full", "out of reach — needs the ladder", "the fascia needs the ladder — it's by
+    the shed", "you need the broom". `interact.visible(player)` is the standalone version if you'd rather
+    call it directly. Verified in the real game: walk to the shed table holding the ladder and it now says
+    **"hands full" greyed** instead of showing nothing, while `nearest()` (what hold-E fires on) still
+    correctly refuses it — display and action stay separate. Asserted three ways.
+
+[D] 2026-07-17 — 💬 **FEEL PASS — I played a round (the §Lane D-3 hail+ponding pass can't fully run yet;
+    hailApi and pondApi are both still false on main, so this is the loop that exists + a stub pond):**
+      1. **The face is real and it's good.** Forecast → prep table (11 anchors, budget, tension, anchor
+         rings) → 90 s wild night → a proper aftermath card (garden %, corners, hardware, collateral,
+         verdict, PLAY AGAIN). It plays like a game now, not a tech demo.
+      2. **The feel pass immediately re-confirmed decision 13's necessity, live.** A flawless rig — 4/4,
+         "Every corner held", nothing lost — scored **garden 50%.** Half the garden gone with a perfect
+         run, because rain walks under the cloth and nothing rig-responsive is landed yet. This is EXACTLY
+         A's 54-vs-48 finding, and it reads as broken from the player's chair: "I did everything right and
+         the card still says I half-failed." Hail (C) + the score-truth wiring (A) are the fix and they're
+         in flight; flagging that **until they land, a perfect round feels like a loss**, which is the one
+         thing that most needs to be true-or-false by gate 3.
+      3. **The broom is funny even solo.** 78 kg on the head → stagger → the player reels back from under
+         the sail. It'll be funnier when it's a pond you watched grow and dreaded, not one I injected —
+         but the beat already lands. Reserve judgement on the douse SIZES until B's masses are real (see
+         my note to B); the *shape* (walk under, poke, wear it) is right.
+      4. **Greyed prompts fixed the thing that read as broken last sprint.** Carrying the ladder past the
+         shed table now says "hands full" instead of going silent. Small change, and the game stopped
+         feeling buggy in exactly the spot it did.
+
+[D] 2026-07-17 — 🧵 **wireYardActions now publishes `interact.sailRig`** (the live rig, refreshed on every
+    rigSail/attach) so Lane-D systems that need the rig but are built by createPlayer — the broom needs
+    `ponds`/`drainPondAt` — can read it without main.js threading it through. Same pattern and same reason
+    as `interact.ladder`. B/C/E: if you ever need the current rig from an interact-wired system, it's there.
+
+[I] 2026-07-18 — **SPRINT 5 INTEGRATION (main).** Lanes b/c/d/e merged; selftest **240/0/0**. Wired
+    decision 13 into A's one-term seam (hail×5.0 + rain×0.25 feeding garden.step; weights are integration
+    guesses, tune freely). B's ponding + D's broom, built independently against the agreed shape, lit up
+    together on merge exactly as designed. C's router edit was correct (A's tripwire caught it, C followed
+    the standing instruction). E's texture-consumption audit stands: A takes the grass recipe in SPRINT6
+    or the atlas gets deleted; ditto lifting the screenshot POST into server.py.
+    **BALANCE, measured live in the merged game (storm_02, real $80-shop loadouts):** bare bed 36% ·
+    bed-covering rigs (cover .29-.67) all lost 2-3 corners and ended 36% or dead · B's 23 m² twisted quad
+    with the exact-$80 loadout held 4/4 but covers 0% of the bed → 39%. Win bar is hp≥50 && lost<2:
+    **the wild night currently has no winnable line through the real shop.** Nothing is broken — C
+    flagged exactly this joint call when holding 0.45 — but it is now measured and it is SPRINT6 gate 1.
+    Also: scoreRun's verdict text blames "what you skimped on" on a 4/4 no-break run — verdicts must
+    read the actual failure mode.
+
+[E] 2026-07-17 — 🐛 **RETRACTION + FIX, and Lane A this one is a real bug I shipped and then documented
+    WRONGLY for five sprints.** I told you garden_bed ships "full visible, rest `hide_render`". That is
+    false. **glTF has no node-visibility flag and Blender's `hide_render` does not survive the export** —
+    verified in three r175: `plants_full`, `plants_tattered` and `plants_dead` all arrive `visible: true`.
+    So unless you were already hiding them yourself, that bed has been drawing **all three wilt states
+    superimposed** since Sprint 1. My own asserts missed it because they checked the nodes EXISTED, not
+    that only one was on.
+    Fixed at source the only way that survives: the flag now rides in extras (userData does export —
+    that much I did verify last sprint). **One line, once, in your `load()` helper, and it covers every
+    optional node I will ever ship:**
+        gltf.scene.traverse((o) => { if (o.userData?.hidden_by_default) o.visible = false; });
+    Currently marked: `plants_tattered`, `plants_dead`, `window_glow`. e.test.js now asserts the FLAG,
+    not the node. Sorry — that one's on me.
+
+[E] 2026-07-17 — **night dressing (SPRINT6 §E-1), both for the night storms:**
+      · `house_yardside_v1.glb` gains **`window_glow`** — an unlit emissive pane (needs no light, costs
+        nothing while off) shipping `hidden_by_default`, plus a `window_light_anchor` empty if you want a
+        warm ~2700 K PointLight spilling onto the grass under the eave. Flip it on for storm_02/03.
+        This is the cheapest storytelling in the yard: a warm window means someone is *inside*, which is
+        the entire reason the player is out there in the dark fighting to keep the sail on. An empty yard
+        at night is just weather.
+      · `models/textures/moon.png` — 256², disc + halo, alpha. **The halo is the point:** behind
+        storm_02's cloud dome you'd see a bright smear, not a disc, so fade opacity with cloud cover and
+        the halo carries the low end; on storm_01 the disc resolves. Lane C, it's a sprite on the dome —
+        ignore it if the sky doesn't want one, no feelings.
+
+[E] 2026-07-17 — **end cards (§E-2): `models/textures/card_win.jpg` + `card_gameover.jpg`, 1200×675.**
+    Rendered from the game's OWN props rather than drawn — a gradient with a font on it says nothing; the
+    gnome you failed to protect, lying in pieces exactly where he stood, says it without a word. They're a
+    **diptych: identical camera, identical yard, and the only thing that changed is what the night did to
+    it** — gnome standing in dawn light with a long shadow vs. in bits under flat grey, fence whole vs.
+    holed with palings on the grass, bed green vs. dead. A player who sees both reads the difference
+    faster than any headline. **The left third is deliberately empty — that's yours for the text**, Lane A,
+    and the files are plain JPEGs so do whatever you like on top.
+
+[E] 2026-07-17 — ⚠️ **worth knowing if you ever render from Blender: EEVEE's SHADOW pass is not
+    byte-reproducible across processes in 5.1.** Two identical runs of an identical scene give different
+    pixels. I chased this properly because the cards broke my determinism check: it is NOT PYTHONHASHSEED
+    (6/6 identical with randomisation live), and it happens even with a hard 0° sun — minimal repro is a
+    cube, a plane and a sun. The contact sheet dodges it only because thumbnails have no ground plane to
+    receive a shadow (still byte-identical, 3/3 — that Sprint 1 claim stands).
+    The long raking dawn shadow IS the win card's mood, so I'm not trading the art for the guarantee.
+    Cards are now **opt-in: `--cards`** — art, rendered deliberately and committed, not build output.
+    Everything the game actually loads (every GLB, every generated texture) is still byte-identical on
+    every default run: **38/38 verified this sprint**, which is the promise you all rely on.
+    Also, my own earlier check was lying to me: `ls a/*.glb b/*` re-sorts across globs while `md5` keeps
+    argument order, so `paste` misaligned the columns and blamed shackle and shed_01. If you diff hashes,
+    tag them with their filename.
+
+[E] 2026-07-17 — §E-3 contact sheets refreshed (21 assets, 4×6). The **yard shots stay as they are** for
+    now: `docs/yard_day.jpg` / `yard_night.jpg` are pre-balance and unrigged. Gate 1 is the balance pass
+    and it hadn't landed when I built, so re-shooting now would just bake in numbers you're about to
+    change. **Ping me when gate 1 is green and I'll reshoot both with a winnable rig actually in frame** —
+    `tools/yardshot/shot_server.py` makes it a one-minute job now. (Lane A: your SPRINT6 list says lift
+    `do_POST` into server.py and delete `tools/yardshot/` — the whole fix is ~25 lines, take it whenever.)
+
+[E] 2026-07-17 — grass_atlas: still 0 refs, five sprints. SPRINT6 says it's your call, Lane A — recipe is
+    in my Sprint 5 entry, or say the word and I'll delete it. Either is fine; carrying it isn't.

tools/blender/build_yard_assets.py

@@ -11,6 +11,7 @@ Run:
     blender -b -P tools/blender/build_yard_assets.py -- --only tree_gum_01
     blender -b -P tools/blender/build_yard_assets.py -- --no-verify
     blender -b -P tools/blender/build_yard_assets.py -- --no-debris
+    blender -b -P tools/blender/build_yard_assets.py -- --cards      # re-render the end cards
 
 Outputs (resolved from this file, so no absolute home paths):
     web/world/models/*.glb              nature, hardware, ref_capsule
@@ -119,6 +120,7 @@ PAL = {
     "gnome_hat":   "#B33C36",
     "bristle":     "#C9A659",   # broom straw
     "hail_ice":    "#DCEAF2",   # hailstone
+    "window_warm": "#FFC98A",   # someone is home
     "ref_pink":    "#E85C8A",   # the reference capsule — deliberately loud
 }
 
@@ -165,6 +167,40 @@ def get_material(name, color_hex, roughness=0.7, metallic=0.0, opacity=1.0):
     return mat
 
 
+def hide_by_default(obj):
+    """Mark a node as "present but off until the game says otherwise".
+
+    glTF has NO standard node-visibility flag, and Blender's `hide_render` does
+    not survive the export — verified in three r175: every node arrives
+    `visible: true`. This shipped as a real bug from Sprint 1 to Sprint 6, with
+    garden_bed rendering plants_full, plants_tattered AND plants_dead
+    superimposed, and my own THREADS note claiming the opposite.
+
+    userData DOES survive, so the flag rides in extras and the consumer applies
+    it in one line (see THREADS [E]):
+        gltf.scene.traverse(o => { if (o.userData?.hidden_by_default) o.visible = false; });
+
+    hide_render is still set so Blender's own contact-sheet renders match the game.
+    """
+    obj["hidden_by_default"] = True
+    obj.hide_render = True
+    return obj
+
+
+def _emissive(mat, color_hex, strength=1.0):
+    """Emissive on the Principled BSDF. glTF carries it as emissiveFactor (plus
+    KHR_materials_emissive_strength above 1.0), so the pane reads with no light
+    in the scene at all — which is the point on a black storm night."""
+    bsdf = mat.node_tree.nodes.get("Principled BSDF")
+    if not bsdf:
+        return mat
+    if "Emission Color" in bsdf.inputs:
+        bsdf.inputs["Emission Color"].default_value = hex_to_rgba(color_hex)
+    if "Emission Strength" in bsdf.inputs:
+        bsdf.inputs["Emission Strength"].default_value = strength
+    return mat
+
+
 def deselect_all_no_ops():
     """Avoid bpy.ops.object.select_all — works without a proper context."""
     for o in bpy.data.objects:
@@ -672,6 +708,24 @@ def build_house_yardside(name):
                         (win_x, -D / 2 + 0.02, win_z + win_h / 2), trim)],
                "window", root)
 
+    # Night dressing (SPRINT6 §Lane E-1). `window_glow` ships HIDDEN — Lane A
+    # flips .visible on the night storms. It's an unlit emissive pane, so it
+    # needs no light to read and costs nothing when it's off.
+    #
+    # This is the cheapest storytelling in the yard: a warm window means someone
+    # is inside, which is the whole reason the player is out here in the dark
+    # fighting to keep the sail on. An empty yard at night is just weather.
+    glow_m = get_material("Mat_WindowGlow", PAL["window_warm"], 1.0)
+    _emissive(glow_m, PAL["window_warm"], 2.4)
+    glow = add_box("window_glow", (win_w - 0.10, 0.01, win_h - 0.10),
+                   (win_x, -D / 2 + 0.055, win_z + win_h / 2), glow_m,
+                   parent=root)
+    hide_by_default(glow)
+    glow["night_only"] = True
+    e = add_empty("window_light_anchor", (win_x, -D / 2 - 0.35, win_z + win_h / 2),
+                  root, size=0.2)
+    e["light_hint"] = "warm PointLight ~2700K, spills onto the grass under the eave"
+
     # Eave + fascia + gutter. The eave overhangs 0.55 into the yard (-Y).
     eave_y = -0.55
     fascia_z = H + 0.10
@@ -819,8 +873,9 @@ def build_garden_bed(name):
         node = join_group(parts, f"plants_{state}", root)
         if node:
             node["damage_state"] = state
-            # Only `full` ships visible; Lane A swaps by toggling these.
-            node.hide_render = (state != "full")
+            # Only `full` starts on; Lane A swaps by toggling .visible.
+            if state != "full":
+                hide_by_default(node)
     stamp(root, name, "garden")
     root["states"] = "full,tattered,dead"
     root["bed_size"] = f"{W}x{D}"
@@ -1622,6 +1677,167 @@ def build_hail_and_shred_atlases():
     return [p1, p2]
 
 
+def build_moon_texture():
+    """Moon disc + halo for the night storms (SPRINT6 §Lane E-1).
+
+    The halo is the point, not the disc. On storm_02 the moon sits behind a
+    cloud dome and what you'd actually see is a bright smear; on storm_01 the
+    disc resolves. One sprite does both — Lane C fades opacity with cloud cover
+    and the halo carries the low end.
+    """
+    import numpy as np
+
+    SIZE = 256
+    Y, X = np.mgrid[0:SIZE, 0:SIZE]
+    c = (SIZE - 1) / 2.0
+    nx, ny = (X - c) / c, (Y - c) / c
+    r = np.sqrt(nx * nx + ny * ny)
+
+    R_DISC = 0.34
+    disc = np.clip((R_DISC - r) / 0.02, 0, 1)             # soft-edged disc
+    halo = np.exp(-((r - R_DISC) ** 2) / 0.045) * 0.55    # the bit that survives cloud
+    halo = np.where(r > R_DISC, halo, 0.0)
+
+    # Maria: a few soft dark blotches, seeded. Craters at this size are a lie —
+    # what you see from a back yard is patches.
+    shade = np.ones_like(r)
+    mrng = rng_for("moon_maria")
+    for _ in range(6):
+        mx, my = mrng.uniform(-0.18, 0.18), mrng.uniform(-0.18, 0.18)
+        mr = mrng.uniform(0.06, 0.13)
+        d = np.sqrt((nx - mx) ** 2 + (ny - my) ** 2)
+        shade -= np.exp(-(d ** 2) / (mr ** 2)) * mrng.uniform(0.06, 0.13)
+    shade = np.clip(shade, 0.72, 1.0)
+
+    a = np.clip(disc + halo, 0, 1)
+    lum = np.clip(np.where(disc > 0, shade, 1.0), 0, 1)
+    img = np.zeros((SIZE, SIZE, 4), dtype=np.float32)
+    img[:, :, 0] = lum * 0.96
+    img[:, :, 1] = lum * 0.97
+    img[:, :, 2] = lum
+    img[:, :, 3] = a
+    p, kb = save_png(img, "moon")
+    print(f"  moon.png                   {SIZE}x{SIZE}, disc+halo, {kb} KB")
+    return p
+
+
+# ============================================================================
+# END CARDS — rendered from the game's own props, not drawn (SPRINT6 §Lane E-2)
+# ============================================================================
+def _card_scene(broken):
+    """One vignette, built from the same yard objects the player spent the week
+    protecting — that's the whole idea. A gradient with a font on it says
+    nothing; the gnome you failed to protect, lying in pieces, says it without a
+    word."""
+    reset_to_empty()
+    grass = get_material("Mat_Grass", "#4A6B36" if broken else "#5C8A3A", 1.0)
+    add_box("ground", (60, 60, 0.4), (0, 0, -0.2), grass)
+
+    if broken:
+        gnome = build_garden_gnome_01_broken("gnome")
+        gnome.location = (0.82, -0.78, 0)
+        gnome.rotation_mode = 'XYZ'
+        gnome.rotation_euler = (0, 0, math.radians(-24))
+        fence = build_fence_panel_snapped("fence")
+        fence.location = (-0.35, 2.6, 0)
+        bin_ = build_wheelie_bin_01("bin")          # blown over, lid flung open
+        bin_.location = (2.9, 1.5, 0.34)
+        bin_.rotation_mode = 'XYZ'
+        bin_.rotation_euler = (math.radians(-96), 0, math.radians(38))
+        bed = build_garden_bed("bed")
+        bed.location = (-3.4, 1.2, 0)
+        for o in bpy.data.objects:                   # a loss shows the dead bed
+            if o.name == "plants_full":
+                o.hide_render = True
+            elif o.name == "plants_dead":
+                o.hide_render = False
+    else:
+        gnome = build_garden_gnome_01("gnome")
+        gnome.location = (0.82, -0.78, 0)
+        fence = build_fence_panel("fence")
+        fence.location = (-0.35, 2.6, 0)
+        post = build_fence_post("post")
+        post.location = (0.85, 2.6, 0)
+        bed = build_garden_bed("bed")
+        bed.location = (-3.4, 1.2, 0)
+        shed = build_shed_01("shed")
+        shed.location = (3.6, 2.2, 0)
+
+
+def build_end_cards():
+    """NOT part of the default build — pass `--cards`.
+
+    EEVEE's SHADOW rendering is not byte-reproducible across processes in
+    Blender 5.1: two identical runs of the same scene give slightly different
+    pixels. Measured, with a minimal cube-plus-plane repro, and it happens even
+    with a hard (0-degree) sun. The contact sheet escapes it only because its
+    thumbnails have no ground plane to receive a shadow — verified still
+    byte-identical 3/3.
+
+    The long raking dawn shadow IS the win card's mood, so dropping shadows to
+    win determinism would be trading the art for the guarantee. Instead these
+    are treated as what they are: art, rendered deliberately and committed, not
+    build output. Everything the game actually loads — every GLB and every
+    generated texture — stays byte-identical on every run, which is the promise
+    other lanes rely on.
+    """
+    out = []
+    for name, broken, warm in (("card_win", False, True),
+                               ("card_gameover", True, False)):
+        _card_scene(broken)
+        scn = bpy.context.scene
+        scn.render.engine = 'BLENDER_EEVEE'
+        scn.render.resolution_x, scn.render.resolution_y = 1200, 675
+        scn.render.image_settings.file_format = 'JPEG'
+        scn.render.image_settings.quality = 88
+        scn.world = bpy.data.worlds.new(f"W_{name}")
+        scn.world.use_nodes = True
+        bg = scn.world.node_tree.nodes.get("Background")
+        if bg:
+            # Dawn after a night you survived, vs the flat grey of a morning you
+            # have to explain to a client.
+            bg.inputs[0].default_value = ((0.92, 0.55, 0.32, 1.0) if warm
+                                          else (0.34, 0.37, 0.41, 1.0))
+            # Low strength on purpose. The world is a huge ambient fill, and at
+            # 1.15 it flooded both cards flat — the sun stopped casting anything
+            # and dawn read as fog. Keep the fill down and let the sun do it.
+            bg.inputs[1].default_value = 0.30 if warm else 0.42
+
+        bpy.ops.object.light_add(type='SUN', location=(-6, -8, 4))
+        sun = _active()
+        sun.data.energy = 7.0 if warm else 2.6
+        sun.data.angle = math.radians(2 if warm else 40)   # crisp dawn vs overcast
+        sun.data.color = (1.0, 0.78, 0.52) if warm else (0.82, 0.86, 0.92)
+        sun.rotation_mode = 'XYZ'
+        # Low and raking on the win card: the long shadows are the mood.
+        sun.rotation_euler = ((math.radians(74), 0, math.radians(-52)) if warm
+                              else (math.radians(28), 0, math.radians(30)))
+
+        bpy.ops.object.camera_add(location=(0, 0, 0))
+        cam = _active()
+        cam.data.lens = 50
+        scn.camera = cam
+        # IDENTICAL camera on both cards, deliberately. They're a diptych: same
+        # yard, same framing, and the only thing that changed overnight is what
+        # happened to it. A player who sees both reads the difference instantly,
+        # which no amount of headline text would do as fast. Low and close, so
+        # the gnome is the subject; the left third stays empty for Lane A's text.
+        cam.location = (2.00, -2.86, 0.94)
+        cam.rotation_mode = 'XYZ'
+        target = Vector((0.66, -0.42, 0.30))
+        cam.rotation_euler = (target - cam.location).to_track_quat('-Z', 'Y').to_euler()
+
+        os.makedirs(TEXTURES_DIR, exist_ok=True)
+        out_path = os.path.join(TEXTURES_DIR, f"{name}.jpg")
+        scn.render.filepath = out_path
+        bpy.ops.render.render(write_still=True)
+        kb = os.path.getsize(out_path) // 1024
+        print(f"  {name}.jpg{' ' * max(1, 18 - len(name))}1200x675, from props, {kb} KB")
+        out.append(out_path)
+    reset_to_empty()
+    return out
+
+
 def build_grass_atlas():
     """4-tuft billboard atlas, 2x2 cells. Drawn with numpy (no PIL in Blender's
     python) and saved through bpy's image API. Lane A instances quads with this."""
@@ -1696,6 +1912,7 @@ ASSETS = [
     dict(name="house_yardside", fn=build_house_yardside,
          dims=((9.0, 9.5), (0.8, 1.6), (2.8, 3.3)),
          nodes=["wall", "door", "window", "roof", "fascia", "gutter",
+                "window_glow", "window_light_anchor",
                 "fascia_anchor_01", "fascia_anchor_02", "fascia_anchor_03"]),
     dict(name="shed_01", fn=build_shed_01,
          dims=((2.4, 2.7), (1.8, 2.1), (1.95, 2.25)),
@@ -2058,18 +2275,20 @@ def make_contact_sheet(thumbs):
 def parse_args():
     argv = sys.argv
     argv = argv[argv.index("--") + 1:] if "--" in argv else []
-    only, no_verify, no_debris = None, False, False
+    only, no_verify, no_debris, cards = None, False, False, False
     if "--only" in argv:
         only = set(argv[argv.index("--only") + 1].split(","))
     if "--no-verify" in argv:
         no_verify = True
     if "--no-debris" in argv:
         no_debris = True
-    return only, no_verify, no_debris
+    if "--cards" in argv:
+        cards = True
+    return only, no_verify, no_debris, cards
 
 
 def main():
-    only, no_verify, no_debris = parse_args()
+    only, no_verify, no_debris, cards = parse_args()
     print("\n" + "=" * 72)
     print("SHADES yard asset factory — Lane E")
     print(f"Blender {bpy.app.version_string}   repo: {REPO_ROOT}")
@@ -2081,6 +2300,9 @@ def main():
     build_sail_textures()
     build_pond_textures()
     build_hail_and_shred_atlases()
+    build_moon_texture()
+    if cards:
+        build_end_cards()
     debris = [] if no_debris else copy_debris()
 
     failures = []

web/world/data/storms/storm_02_wildnight.json

@@ -42,6 +42,17 @@
 
   "rain": { "peakMmPerHour": 80, "curve": [[0, 0], [10, 0.25], [35, 0.6], [55, 0.85], [70, 1.0], [90, 0.7]] },
 
+  "_hail_comment": "Hail carries the garden score (decision 13) — steep dense stones a sail actually blocks, unlike rain which walks under it. The authored burst lands ON the southerly change (t55) for maximum drama; withGustsAbove 10 then adds a burst to every late big gust (gusts top ~12.6, so the worst few carry ice). size 1.3 = decent damaging stones. A garden under a good rig should be MUCH better off than one in the open — asserted at >=2x.",
+
+  "hail": {
+    "size": 1.3,
+    "withGustsAbove": 10,
+    "gustBurstIntensity": 0.85,
+    "bursts": [
+      { "t": 55, "ramp": 1.5, "hold": 5, "fade": 2.5, "intensity": 1.0 }
+    ]
+  },
+
   "_sky_comment": "night: true forces the night palette rather than leaning on the darkness threshold — it's called Wild Night and the forecast card has to sell that. lightningGustPow 10 fires a flash on any gust at/above 10 m/s of gust power (this storm's gusts top out ~12.6, so it lights up for the worst few, late, on top of the three authored strikes) — the storm's worst moments should be the ones you see.",
 
   "sky": { "darkness": 0.94, "cloudScroll": 0.09, "night": true, "lightningGustPow": 10 }

web/world/data/storms/storm_03_southerly.json

@@ -36,5 +36,14 @@
 
   "rain": { "peakMmPerHour": 30, "curve": [[0, 0], [28, 0.05], [34, 0.4], [55, 0.55], [80, 0.3], [90, 0.15]] },
 
+  "_hail_comment": "One mild burst rolling in behind the change — small stones, half intensity. Enough that a bed under a sail visibly beats a bed in the open, but nothing like the wild night's ice. No gust-synced hail: this is the storm you can get away with a modest rig on. size 0.7 = pea hail.",
+
+  "hail": {
+    "size": 0.7,
+    "bursts": [
+      { "t": 36, "ramp": 1.5, "hold": 3, "fade": 2, "intensity": 0.5 }
+    ]
+  },
+
   "sky": { "darkness": 0.5, "cloudScroll": 0.05 }
 }

web/world/js/broom.js

@@ -0,0 +1,188 @@
+/**
+ * broom.js — DESIGN.md's funniest correct mechanic.  (Lane D, SPRINT5 §Lane D-1)
+ *
+ * A flat sail pools water. The water is heavier than anything else in the game and it will pull the
+ * rig down. The fix is a bloke with a broom walking under the belly and poking it upward — at which
+ * point forty kilos of cold water arrives on his head. That is both the correct engineering answer
+ * and the joke, and they are the same thing, which is the best kind of mechanic.
+ *
+ * Everything here defers to the asset. E baked the intent into broom_01_v1.glb:
+ *   grip_anchor  extras.carry_type = "broom"
+ *   poke_tip     extras.use = "push the pond up from under the sail; soft end, won't hole the cloth"
+ *                — on the BRISTLE end, deliberately: a broomstick jabbed at a loaded sail holes it.
+ *   root         extras.anim_hint = "reuse Crank/Dig for the poke — no new Mixamo needed"
+ * so the carry type, the working end and the animation are all read, not invented.
+ *
+ * Seam with Lane B (posted in THREADS before either of us built): sailRig.ponds -> [{node,mass,pos}]
+ * and drainPondAt(node) -> kg dumped. Duck-typed: with no ponding landed the broom still carries,
+ * walks and refuses to poke thin air, and the moment B lands it the whole thing lights up.
+ */
+// No top-level THREE/GLTFLoader import, deliberately: the vendored addons import the bare specifier
+// 'three', which only resolves under index.html's importmap — so importing them here would drag the
+// whole GL chain into d.test.js and cost this lane its headless suite (node resolves relative paths
+// only). The pond logic below is the part worth asserting and it is pure; the view is loaded
+// dynamically, which never happens outside a browser.
+export const BROOM_URL = './models/broom_01_v1.glb';
+
+export const BROOM_TUNE = {
+  pokeSecs: 1.5,            // matches B's "drain over ~1.5 s"
+  reachUp: 3.2,             // m — how high overhead a pond can be and still be pokeable from the grass
+  standRadius: 2.0,         // m — how near the pond's ground shadow you must be
+
+  // What lands on you. Calibrate once B's masses are real — these are physical guesses, not measured:
+  // a full bucket is ~10 kg, so a splash is nothing, half a bathtub staggers you, and a bathtub
+  // puts you down. Flagged in THREADS for the tuning pass.
+  splashKg: 15,             // below this it's just cold and funny
+  staggerKg: 60,            // above this you lose your footing
+  // above staggerKg*2 → flat on your back
+};
+
+/**
+ * @param {THREE.Object3D} scene
+ * @param {object} world     contracts World (dressed)
+ * @param {object} interact  Lane D's Interact
+ * @param {object} player    PlayerSim
+ * @param {object} getRig    () => sailRig — a getter, because rigSail() REPLACES the rig object
+ */
+export function createBroom(scene, world, interact, player, getRig) {
+  const state = { carried: false, view: null, tune: { ...BROOM_TUNE } };
+
+  // Home: against the shed wall. E ships it standing on its head, which is how it lives there.
+  const home = { x: 8.2, y: 0, z: 7.0 };
+  if (world.shedTable && world.shedTable.pos) {
+    home.x = world.shedTable.pos.x - 0.8;
+    home.z = world.shedTable.pos.z + 1.0;
+  }
+  home.y = world.heightAt ? world.heightAt(home.x, home.z) : 0;
+
+  if (scene) {
+    import('../vendor/addons/loaders/GLTFLoader.js').then(({ GLTFLoader }) => {
+      new GLTFLoader().load(BROOM_URL, (g) => {
+        g.scene.traverse((o) => { if (o.isMesh) { o.castShadow = true; o.frustumCulled = false; } });
+        state.view = g.scene;
+        scene.add(g.scene);
+        sync();
+      }, undefined, () => { /* no asset: the mechanic still runs, you just can't see the broom */ });
+    }).catch(() => { /* headless (selftest/node): logic only, no view */ });
+  }
+
+  function sync() {
+    if (!state.view) return;
+    state.view.visible = !state.carried;
+    state.view.position.set(home.x, home.y, home.z);
+    state.view.rotation.set(0, 0.9, 0.16);   // slouched against the shed wall
+  }
+
+  /** Every pond Lane B is reporting, or [] until they land it. */
+  const ponds = () => {
+    const rig = getRig && getRig();
+    return (rig && Array.isArray(rig.ponds)) ? rig.ponds : [];
+  };
+
+  /**
+   * The pond this player could actually poke: near enough in plan, low enough overhead.
+   * Picks the HEAVIEST reachable one rather than the nearest — if you're standing under two, the
+   * one about to break the rig is the one you meant.
+   */
+  function targetPond() {
+    let best = null;
+    for (const p of ponds()) {
+      if (!p || !p.pos || !(p.mass > 0)) continue;
+      const d = Math.hypot(p.pos.x - player.pos.x, p.pos.z - player.pos.z);
+      const up = p.pos.y - (player.pos.y + player.climbY);
+      if (d > state.tune.standRadius || up > state.tune.reachUp || up < 0) continue;
+      if (!best || p.mass > best.mass) best = p;
+    }
+    return best;
+  }
+
+  /** Where to stand: the pond's shadow on the grass. */
+  const pokeSpot = () => {
+    const p = ponds().reduce((a, b) => (!a || (b && b.mass > a.mass) ? b : a), null);
+    if (!p || !p.pos || !(p.mass > 0)) return null;
+    return { x: p.pos.x, y: 0, z: p.pos.z };
+  };
+
+  const wired = [];
+
+  // 1. take the broom off the shed wall — a third carry type, so it queues behind the same hands
+  wired.push(interact.register({
+    id: 'broom_take',
+    pos: () => (state.carried ? null : home),
+    radius: 1.5,
+    holdSecs: 0.7,
+    clip: 'PickUp',
+    label: (p) => (p.carrying ? 'hands full' : 'take the broom'),
+    canUse: (p) => !state.carried && !p.carrying && p.climbY < 0.02,
+    onDone: (p, t) => { state.carried = true; p.pickUp('broom', t); sync(); },
+  }));
+
+  // 2. put it back
+  wired.push(interact.register({
+    id: 'broom_drop',
+    pos: () => (state.carried ? { x: home.x, y: home.y, z: home.z } : null),
+    radius: 1.5,
+    holdSecs: 0.4,
+    clip: 'PickUp',
+    label: 'put the broom back',
+    canUse: (p) => state.carried && p.carrying === 'broom',
+    onDone: (p, t) => { state.carried = false; p.drop(t); sync(); },
+  }));
+
+  // 3. THE POKE. Stand under the belly, push up, wear it.
+  wired.push(interact.register({
+    id: 'broom_poke',
+    pos: pokeSpot,
+    radius: state.tune.standRadius,
+    holdSecs: state.tune.pokeSecs,
+    clip: 'Crank',                      // E's anim_hint — no new Mixamo needed
+    label: (p) => {
+      if (p.carrying !== 'broom') return 'you need the broom';
+      const pond = targetPond();
+      if (!pond) return 'nothing pooling here';
+      return `push the water off (${Math.round(pond.mass)} kg)`;
+    },
+    // physical gates only — never player.state (see interact.register's note; it cancels its own hold)
+    canUse: (p) => {
+      const rig = getRig && getRig();
+      return p.carrying === 'broom' && !!(rig && rig.drainPondAt) && !!targetPond();
+    },
+    onDone: (p, t) => {
+      const rig = getRig && getRig();
+      const pond = targetPond();
+      if (!rig || !pond) return;
+      // B returns the kg actually dumped; fall back to diffing pondMass() if they'd rather not
+      let kg = rig.drainPondAt(pond.node);
+      if (typeof kg !== 'number') kg = pond.mass;
+      onWater(p, kg, pond, t);
+    },
+  }));
+
+  /**
+   * The payoff. All of it lands on the player, because they are standing directly underneath it —
+   * that is not a bug in the plan, it IS the plan.
+   */
+  function onWater(p, kg, pond, t) {
+    p.events.push({ type: 'doused', kg, t });
+    const T = state.tune;
+    if (kg >= T.staggerKg * 2) {
+      // downward and behind: a bathtub arriving on your head does not blow you downwind
+      p.knockdown(t, -Math.sin(p.facing), -Math.cos(p.facing));
+    } else if (kg >= T.staggerKg) {
+      p.staggerHit(t);
+    }
+    // below splashKg: you just get wet, which is its own reward
+  }
+
+  return {
+    get carried() { return state.carried; },
+    get home() { return home; },
+    tune: state.tune,
+    ponds,
+    targetPond,
+    pokeSpot,
+    onWater,
+    update() { sync(); },
+    dispose() { wired.forEach((un) => un()); if (state.view) scene.remove(state.view); },
+  };
+}

web/world/js/contracts.js

@@ -191,6 +191,17 @@ export class Emitter {
  *   LIVE world position of corner i, as a fresh vector safe to keep. A blown
  *   corner's node is flying, so an interaction prompt anchored to this chases
  *   the flogging corner instead of sitting on the dead anchor. null if unrigged.
+ * @property {() => number} pondMass
+ *   Kilograms of rainwater pooled on the sail (SPRINT5 ponding). Lane A's HUD
+ *   warning threshold and "SAIL PONDING — get the broom" ticker read this.
+ * @property {() => ({x:number,y:number,z:number,mass:number,node:number}|null)} pondCentroid
+ *   Where the pond sits in world space, its mass, and the heaviest grid node —
+ *   or null if there's nothing worth pointing at. Lane D walks the player to
+ *   this; Lane E draws the water here.
+ * @property {(node:number, dt:number, radius?:number) => number} drainPondAt
+ *   Lane D's broom: poke node `node` (from pondCentroid().node) for one frame of
+ *   the ~1.5 s hold; drains a radius around it and RETURNS the kg shed this call.
+ *   Sum over the hold = what lands on the player's head. Emits 'pondDump'.
  */
 
 /**
@@ -306,7 +317,7 @@ export class Emitter {
 export const CONTRACT = {
   wind:     { sample: 'function', gustTelegraph: 'function' },
   world:    { anchors: 'object', heightAt: 'function', gardenBed: 'object', sunDir: 'object', solids: 'object', update: 'function' },
-  sailRig:  { corners: 'object', attach: 'function', step: 'function', coverageOver: 'function', events: 'object', repair: 'function', trim: 'function', cornerPos: 'function' },
+  sailRig:  { corners: 'object', attach: 'function', step: 'function', coverageOver: 'function', events: 'object', repair: 'function', trim: 'function', cornerPos: 'function', pondMass: 'function', pondCentroid: 'function', drainPondAt: 'function' },
   player:   { pos: 'object', carrying: '*', busy: '*', update: 'function' },
   interact: { register: 'function' },
   camera:   { object: 'object', yaw: 'number', update: 'function' },

web/world/js/interact.js

@@ -62,7 +62,7 @@ export class Interact {
     return !target.canUse || !!target.canUse(player);
   }
 
-  /** Nearest registered target in range whose canUse() passes. */
+  /** Nearest registered target in range whose canUse() passes. This is what a hold-E acts on. */
   nearest(player) {
     let best = null, bestD = Infinity;
     for (const target of this.targets.values()) {
@@ -74,6 +74,31 @@ export class Interact {
     return best;
   }
 
+  /**
+   * What the HUD should SHOW, which is not the same question as what E acts on.
+   *
+   * A usable action always wins. But when nothing is usable, this returns the nearest action that
+   * is merely unavailable, so the prompt can say WHY instead of vanishing. That distinction came
+   * out of playing it: walking to the shed table with the ladder in your hands made the prompt
+   * disappear, which reads as a broken game rather than a full pair of hands — and every target
+   * already had a perfectly good sentence sitting in its `label`, unreachable, because canUse had
+   * filtered it out before the label was ever asked.
+   *
+   * @returns {{target, usable, label}|null}
+   */
+  visible(player) {
+    const usable = this.nearest(player);
+    if (usable) return { target: usable, usable: true, label: this.labelOf(usable, player) };
+    let best = null, bestD = Infinity;
+    for (const target of this.targets.values()) {
+      const p = typeof target.pos === 'function' ? target.pos() : target.pos;
+      if (!p) continue;
+      const d = Math.hypot(p.x - player.pos.x, p.z - player.pos.z);
+      if (d <= target.radius && d < bestD) { best = target; bestD = d; }
+    }
+    return best ? { target: best, usable: false, label: this.labelOf(best, player) } : null;
+  }
+
   cancel(t, player) {
     if (!this.active) return;
     // only hand the player back if they're still ours — a knockdown mid-hold already re-stated them
@@ -88,7 +113,10 @@ export class Interact {
    * @param {number} dt @param {number} t
    * @param {PlayerSim} player
    * @param {boolean} holding  is E held this frame
-   * @returns {{target, progress, label, holding}} for hud.js to draw the prompt + radial
+   * @returns {{target, progress, label, holding, usable}} for hud.js to draw the prompt + radial.
+   *   `usable:false` means the prompt is a REASON, not an offer — grey it out and don't show a
+   *   radial. Lane A: this is the greyed-prompt surface I offered; `label` is already the sentence
+   *   ("hands full", "out of reach — needs the ladder", "you need the broom").
    */
   step(dt, t, player, holding) {
     // One press, one action: a completed hold latches until E is released. Without this, a held key
@@ -126,12 +154,22 @@ export class Interact {
       }
     }
 
-    const shown = this.active || near;
+    if (this.active) {
+      return {
+        target: this.active,
+        progress: this.progress,
+        label: this.labelOf(this.active, player),
+        holding: true,
+        usable: true,
+      };
+    }
+    const shown = this.visible(player);
     return {
-      target: shown,
-      progress: this.progress,
-      label: shown ? this.labelOf(shown, player) : '',
-      holding: !!this.active,
+      target: shown ? shown.target : null,
+      progress: 0,
+      label: shown ? shown.label : '',
+      holding: false,
+      usable: !!(shown && shown.usable),
     };
   }
 }
@@ -158,6 +196,11 @@ export function wireYardActions(interact, deps = {}) {
   // createLadder publishes itself onto the Interact instance, so main.js doesn't have to thread a
   // ladder through to get the fascia reach gate. An explicit dep still wins (tests pass one).
   const ladder = deps.ladder || interact.ladder || null;
+  // Publish the CURRENT rig for lane-D systems built before it exists (the broom needs ponds +
+  // drainPondAt). main.js re-calls wireYardActions through rigSail() every time attach() replaces
+  // the rig object, so reading `interact.sailRig` is always the live one — which is the same reason
+  // the corner closures below read by index rather than capturing.
+  interact.sailRig = sailRig || null;
   const wired = [];
   const cornerAt = (i) => (sailRig && sailRig.corners && sailRig.corners[i]) || null;
   const anchorOf = (i) => {

web/world/js/ladder.js

@@ -141,7 +141,13 @@ export function createLadder(scene, world, interact, player) {
       radius: PLACE_RANGE,
       holdSecs: 1.0,
       clip: 'PickUp',
-      label: `set the ladder under ${a.id}`,
+      // Reads as an offer when you can, and as a reason when you can't — interact.visible() now
+      // shows unusable targets greyed, and a label written only as an offer explains nothing there.
+      // Standing under a blown fascia bracket holding a spare, "the fascia needs the ladder" is the
+      // single most useful sentence in the game.
+      label: (p) => (p.carrying === 'ladder'
+        ? `set the ladder under ${a.id}`
+        : 'the fascia needs the ladder — it\'s by the shed'),
       canUse: (p) => p.carrying === 'ladder',
       onDone: (p, t) => {
         state.carried = false;

web/world/js/main.js

@@ -65,9 +65,18 @@ function createGarden(world) {
     get hp() { return hp; },
     get state() { return state; },
     reset() { hp = 100; state = 'full'; world.setPlants('full'); },
-    /** @param {number} rain 0..1 @param {number} dry 0..1 fraction kept dry by the sail */
-    step(dt, rain, dry) {
-      if (rain > 0) hp = Math.max(0, hp - GARDEN_DRAIN * rain * (1 - dry) * dt);
+    /**
+     * @param {number} dt
+     * @param {number} exposure 0..1 — how hard the bed is being hit right now.
+     *   0 = nothing reaching it (no weather, or cloth is over it); 1 = taking it
+     *   full in the open. Lane C's sky.gardenExposure() computes it.
+     *
+     *   SPRINT5 decision 13 lands here and nowhere else: garden damage becomes
+     *   hail exposure + a small rain drain, so this stays one number and the
+     *   only change is which helper(s) feed it.
+     */
+    step(dt, exposure) {
+      if (exposure > 0) hp = Math.max(0, hp - GARDEN_DRAIN * exposure * dt);
       const next = hp > 66 ? 'full' : hp > 33 ? 'tattered' : 'dead';
       if (next !== state) { state = next; world.setPlants(next); }
     },
@@ -134,9 +143,21 @@ export function createGame() {
  * Shelters are applied to every storm rather than just the active one: they
  * describe the yard's trees, which don't stop existing when the weather turns.
  *
+ * ⚠️ **This delegation list is hand-maintained, and that has already cost us
+ * once.** When Lane C added rainMmPerHour/rainDepthMm for ponding, this router
+ * didn't forward them: every test still passed, because tests hold a real wind
+ * while only the GAME holds the router — so B's ponding would have been green
+ * across the board and done nothing in the actual yard. The integrator caught it
+ * by hand at merge.
+ *
+ * Anything new on the wind contract must be added here too. `js/tests/a.test.js`
+ * has a tripwire that diffs this object against a real wind and fails naming
+ * whatever is missing, so the next omission is a red test rather than a system
+ * that silently isn't plugged in.
+ *
  * @param {object[]} all  every wind this session can switch between
  */
-function createWindRouter(all) {
+export function createWindRouter(all) {
   let active = all[0];
 
   const router = {
@@ -151,6 +172,7 @@ function createWindRouter(all) {
     rainAt: (t) => active.rainAt(t),
     rainMmPerHour: (t) => active.rainMmPerHour(t),
     rainDepthMm: (a, b) => active.rainDepthMm(a, b),
+    hailAt: (t) => active.hailAt(t),                 // SPRINT5 decision 13 — the garden score hangs off this
     dirAt: (t) => active.dirAt(t),
 
     setShelters(list) {
@@ -167,6 +189,7 @@ function createWindRouter(all) {
       })));
     },
 
+    get hailSize() { return active.hailSize; },      // SPRINT5 decision 13
     get duration() { return active.duration; },
     get gusts() { return active.gusts; },
     get def() { return active.def; },
@@ -515,12 +538,23 @@ export async function boot(opts = {}) {
     sky?.step(dt, windT, { sail: rig });
     rigging.update(dt, windT);
 
-    // Decision 7: what kills the garden is rain that the sail didn't stop.
-    // Only during the storm — the calm day's drizzle is scenery.
+    // Decision 7: what hurts the garden is weather the sail didn't stop. Only
+    // during the storm — the calm day's drizzle is scenery.
+    //
+    // Through Lane C's combined helper rather than my own rain × (1 − shadow):
+    // it's the same arithmetic, it's their term to own, and SPRINT5 decision 13
+    // extends exactly this shape (+ gardenHailExposure) — so when hail lands
+    // this is one added term here, not a rewrite.
     if (game.phase === 'storm') {
-      const rain = wind.rainAt(windT);
-      const dry = sky?.rainShadowOver ? sky.rainShadowOver(world.gardenBed) : 0;
-      garden.step(dt, rain, dry);
+      // Decision 13 (SPRINT5): hail is the headline garden threat — it falls
+      // steep, so the sail blocks it and the score finally rewards rigging
+      // (C proved 4.4× separation). Rain stays as the small honest drain that
+      // walks under a sail in a gale. Weights chosen so storm_02 unprotected
+      // loses ~50 HP to its hail bursts (11.4 hail-seconds × 5.0 × 0.9/s) and
+      // ~10 to rain, while a bed-covering rig cuts the hail term ~4.4×.
+      const rainExp = sky?.gardenExposure ? sky.gardenExposure(world.gardenBed, windT) : 0;
+      const hailExp = sky?.gardenHailExposure ? sky.gardenHailExposure(world.gardenBed, windT) : 0;
+      garden.step(dt, hailExp * 5.0 + rainExp * 0.25);
     }
   }
 

web/world/js/player.js

@@ -17,8 +17,9 @@ import { clone as skeletonClone } from '../vendor/addons/utils/SkeletonUtils.js'
 import { GLTFLoader } from '../vendor/addons/loaders/GLTFLoader.js';
 import { PlayerSim, STATES, TUNE, clipFor, onLadder } from './player.sim.js';
 import { createLadder } from './ladder.js';
+import { createBroom } from './broom.js';
 
-export { PlayerSim, STATES, TUNE, clipFor, onLadder, createLadder };
+export { PlayerSim, STATES, TUNE, clipFor, onLadder, createLadder, createBroom };
 
 export const CHAR_URL = './models/player_01.glb';
 export const ANIM_URL = './models/player_anims.glb';
@@ -287,6 +288,11 @@ export async function createPlayer(scene, world, cameraRig, opts = {}) {
   // change to get a whole sub-system. Opt out with {ladder: false} if a harness doesn't want it.
   const ladder = (opts.ladder === false || !opts.interact)
     ? null : createLadder(scene, world, opts.interact, sim);
+  // The broom needs the sail rig, which createPlayer isn't handed — but wireYardActions is, and
+  // main.js re-calls it through rigSail() whenever attach() swaps the rig. So read it live off
+  // interact rather than capturing a rig that's about to be replaced.
+  const broom = (opts.broom === false || !opts.interact)
+    ? null : createBroom(scene, world, opts.interact, sim, () => opts.interact.sailRig);
 
   return {
     get pos() { return sim.pos; },
@@ -299,6 +305,7 @@ export async function createPlayer(scene, world, cameraRig, opts = {}) {
       const input = keyboard.read(cameraRig ? cameraRig.yaw || 0 : 0);
       sim.step(dt, t, input, opts.wind);
       if (ladder) ladder.update(dt, t, input);
+      if (broom) broom.update(dt, t, input);
       if (opts.interact) opts.interact.step(dt, t, sim, keyboard.holding);
       view.sync(sim, dt);
     },
@@ -308,8 +315,13 @@ export async function createPlayer(scene, world, cameraRig, opts = {}) {
     sim,
     view,
     ladder,
+    broom,
     keyboard,
-    dispose() { keyboard.dispose(); view.dispose(); if (ladder) ladder.dispose(); },
+    dispose() {
+      keyboard.dispose(); view.dispose();
+      if (ladder) ladder.dispose();
+      if (broom) broom.dispose();
+    },
   };
 }
 

web/world/js/rigging.js

@@ -32,11 +32,23 @@ export class RiggingSession {
    */
   constructor({ anchors = [], budget = START_BUDGET } = {}) {
     this.anchors = anchors;
-    this.budget = budget;
+    this._startBudget = budget;
+    this.reset();
+  }
+
+  /**
+   * Back to an empty prep phase, same anchors and starting budget. Lane A's
+   * "play again" reaches into the state machine to fake a fresh round rather
+   * than rebuilding the session, so this owns the field list — add a field
+   * above, reset it here.
+   */
+  reset() {
+    this.budget = this._startBudget;
     this.tension = DEFAULT_TENSION;
     this.spares = 0;
     /** @type {{anchorId: string, hw: object}[]} — ring-ordered once 4 are rigged */
     this.picks = [];
+    return this;
   }
 
   get spent() { return START_BUDGET - this.budget; }

web/world/js/rigging.selftest.js

@@ -169,6 +169,20 @@ test('summary names the weak link for the HUD', () => {
   return `weak link flagged: ${sum.weakest}, $${sum.budget} left`;
 });
 
+test('reset() returns a used session to a fresh prep phase', () => {
+  const s = session();
+  for (const id of ['h1', 'h3', 'p1', 'p2']) s.rig(id);
+  s.setHardware('h1', RATED); s.setTension(1.2); s.setSpares(1);
+  assert(s.budget < START_BUDGET, 'setup should have spent money');
+  s.reset();
+  assert(s.budget === START_BUDGET, `budget not restored: $${s.budget}`);
+  assert(s.picks.length === 0, 'picks not cleared');
+  assert(s.tension === 1.0 && s.spares === 0, 'tension/spares not reset');
+  // and it's actually usable again, not just zeroed
+  assert(s.rig('t1').ok && s.canStart === false, 'session not rig-able after reset');
+  return 'budget, picks, tension, spares all fresh; rig-able again';
+});
+
 export const RIGGING_TESTS = TESTS;
 
 export function runRiggingSelftest() {

web/world/js/sail.js

@@ -20,6 +20,7 @@
 
 import * as THREE from '../vendor/three.module.js';
 import { Emitter, FIXED_DT, HARDWARE } from './contracts.js';
+import { RAIN_TIME_COMPRESSION } from './weather.core.js';
 
 export { HARDWARE };
 
@@ -56,11 +57,45 @@ const COMP_COMPRESS = 1 / (FABRIC_K * K_COMPRESS);
 const COMP_BEND = 1 / (FABRIC_K * K_BEND);
 const VEL_DAMP = 0.995;       // light; relative-wind drag supplies the real damping
 
+// ---------- ponding (SPRINT4 decision 10 / SPRINT5) ----------
+// DESIGN.md §"Rain → ponding": "Flat sails collect water; water is heavy; the
+// belly collects more (positive feedback) until sudden dump, tear, or corner
+// failure." Lane C owns how hard it rains (rainMmPerHour + RAIN_TIME_COMPRESSION);
+// this owns how much of it a sail holds.
+//
+// The model is FLOW, not a drain coefficient. Water leaves a sail because it has
+// somewhere to GO, not because the fabric is tilted: each node pushes water down
+// its steepest neighbour, rim nodes pour it over the edge. The neighbourhood is
+// 8-way ON PURPOSE — on a hypar the water runs along the saddle's DIAGONAL ridge
+// to the two low corners, and a 4-way graph can't follow that, so it traps water
+// in the shallow gravity belly the cloth sags into between grid lines and a hypar
+// pools as much as a flat sail (measured: it did, until diagonals). So a flat
+// sail's belly is a basin water flows INTO and can't climb out of, while a hypar
+// drains to its low corners and off — which is why ponding cannot pincer §7.
+//
+// (My reverted Sprint-3 prototype drained by slope magnitude instead and pooled
+// 1 kg — it measured the coefficient I'd invented, not the sail.)
+const POND_FLOW = 6.0;      // 1/s per unit of downhill gradient — how fast water finds the low spot
+const POND_SPILL = 3.0;     // 1/s — a rim node pouring over the edge, when the edge is downhill
+// Depth cap per node. Water funnels into ~10 belly nodes, not evenly, so this is
+// the depth AT THE DEEPEST POINT (a torn-sail extreme), not the average — set
+// too low and the whole sail saturates shallow and never reaches a kill load.
+const POND_MAX_KG_M2 = 900; // ~90 cm at the single deepest node
+const BROOM_DRAIN = 2.5;    // 1/s at the poke — a ~1.5 s hold clears the belly
+
 // ---------- debris (SPRINT2 decision 5) ----------
 const DEBRIS_RESTITUTION = 0.1; // a wheelie bin into shade cloth barely bounces
 const DEBRIS_SKIN = 0.06;       // contact margin, ~cloth thickness
 
 // ---------- failure ----------
+// Genuine solver-blowup threshold. NOT a "loads shouldn't get this high" cap:
+// investigating Lane D's tn-1.04 report showed a 155 m² flat sail holding
+// 2100 kg of ponded water really does put ~21 kN on a corner, and it stays
+// finite and tracks the water — that's correct physics for an absurd rig, not
+// divergence. Real divergence is 100 kN+ and NaN. So this sits well above any
+// real load; POND_BELLY_MAX below is what stops a sail bellying to 5 m first.
+const DIVERGENCE_N = 80000;   // 80 kN — past here the solver has actually blown up
+const POND_BELLY_MAX = 4.0;   // metres of sag before the sail tears and dumps (DESIGN.md "sudden dump… tear")
 const OVERLOAD_SECS = 0.4;    // prototype: 0.4 s sustained overload before it lets go
 const OVERLOAD_RECOVER = 2.0; // prototype: overload timer bleeds off at 2x
 const LOAD_TAU = 0.11;        // load meter smoothing time constant, s
@@ -219,6 +254,26 @@ export class SailRig {
     // XPBD Lagrange multipliers, one per spring, reset every substep
     this.lambda = new Float64Array(this.springs.length);
 
+    // ---- ponding state ----
+    this.water = new Float64Array(nodeCount);      // kg on each node
+    this._nodeFlat = new Float64Array(nodeCount);  // area-weighted |ny|, refilled by the wind pass
+    this._nodeArea = new Float64Array(nodeCount);
+    this._wFlow = new Float64Array(nodeCount);     // per-step transfer buffer
+    // 8-neighbour graph, -1 padded (see the ponding note for why diagonals).
+    this._nbr = new Int32Array(nodeCount * 8).fill(-1);
+    this._isRim = new Uint8Array(nodeCount);
+    for (let v = 0; v < N; v++) {
+      for (let u = 0; u < N; u++) {
+        const n = idx(u, v);
+        let k = 0;
+        for (const [du, dv] of [[-1, 0], [1, 0], [0, -1], [0, 1], [-1, -1], [1, -1], [-1, 1], [1, 1]]) {
+          const uu = u + du, vv = v + dv;
+          this._nbr[n * 8 + k++] = (uu >= 0 && uu < N && vv >= 0 && vv < N) ? idx(uu, vv) : -1;
+        }
+        this._isRim[n] = (u === 0 || u === N - 1 || v === 0 || v === N - 1) ? 1 : 0;
+      }
+    }
+
     // Springs meeting each corner, kept as {spring, index} so the load meter can
     // look up each one's multiplier. Bend springs are included: the hardware
     // physically carries every element that touches it, and leaving them out
@@ -345,6 +400,8 @@ export class SailRig {
 
   _substep(dt, wind, t, pieces) {
     this._accumulateWind(wind, t, dt);
+    // after the wind pass — it fills the per-node flatness/area ponding reads
+    this._applyPonding(wind.rainMmPerHour ? wind.rainMmPerHour(t) : 0, dt);
     if (pieces && pieces.length) this._applyDebris(pieces, dt);
     this._integrate(dt);
     this.lambda.fill(0); // XPBD multipliers are per-substep
@@ -352,6 +409,31 @@ export class SailRig {
     this._pinCorners(t);
     this._measureLoads(dt);
     this._checkFailure(dt);
+    if (this.watchDivergence) this._checkDivergence();
+  }
+
+  /**
+   * Optional tripwire for Lane D's tn-1.04 report. That spike does NOT reproduce
+   * on current main — with swaying tree anchors, 3xrated+1carabiner, loads climb
+   * smoothly 7.2->8.7 kN across the whole tension range, no discontinuity at
+   * 1.04 (decision 11's downdraft bump and the §7 re-point changed the load
+   * regime under it). So rather than clamp real physics to fix a bug I can't
+   * demonstrate — the displacement clamp I tried moved the thesis 39->34% — this
+   * just WATCHES. Set `rig.watchDivergence = true` and it throws with the corner,
+   * load and time the instant a corner exceeds a physically-impossible load, so
+   * if it ever comes back it comes back with a repro instead of a mystery.
+   */
+  _checkDivergence() {
+    for (let k = 0; k < 4; k++) {
+      const c = this.corners[k];
+      if (c.load > DIVERGENCE_N || !Number.isFinite(c.load)) {
+        throw new Error(
+          `sail divergence: corner ${c.anchorId} at ${(c.load / 1000).toFixed(1)} kN, ` +
+          `t=${this.t.toFixed(2)}s, tension=${this.tension.toFixed(3)}. This is the tn-1.04 cliff ` +
+          `(THREADS [D] 2026-07-17) recurring — capture this rig and ping Lane B.`,
+        );
+      }
+    }
   }
 
   /** Wind force per FACE — the hypar mechanic lives here. */
@@ -400,9 +482,166 @@ export class SailRig {
       F[ia] += fx; F[ia + 1] += fy; F[ia + 2] += fz;
       F[ib] += fx; F[ib + 1] += fy; F[ib + 2] += fz;
       F[ic] += fx; F[ic + 1] += fy; F[ic + 2] += fz;
+
+      // |ny| is how horizontal the face is (1 flat, 0 on edge), which is also
+      // exactly the fraction of its area rain sees from straight up — so the
+      // ponding catch area is free here rather than a second geometry pass.
+      const share = area / 3, flat = Math.abs(ny) * share;
+      const na = this.tris[i], nb = this.tris[i + 1], nc = this.tris[i + 2];
+      this._nodeFlat[na] += flat; this._nodeFlat[nb] += flat; this._nodeFlat[nc] += flat;
+      this._nodeArea[na] += share; this._nodeArea[nb] += share; this._nodeArea[nc] += share;
     }
   }
 
+  /**
+   * Rain lands, runs downhill, and pools where it can't get out. Called after
+   * the wind pass (which fills _nodeFlat / _nodeArea).
+   * @param {number} mmPerHour  wind.rainMmPerHour(t) — REAL-world rate, Lane C's data
+   */
+  _applyPonding(mmPerHour, dt) {
+    const pos = this.pos, F = this.force, w = this.water, flow = this._wFlow;
+    const N2 = w.length;
+    // 1 mm over 1 m² is 1 kg. Lane C owns the rate and the 40× compression
+    // constant; multiplying them here is the whole of "how much a sail holds".
+    const kgPerM2PerSec = (mmPerHour * RAIN_TIME_COMPRESSION) / 3600;
+
+    for (let n = 0; n < N2; n++) {
+      const a = this._nodeArea[n];
+      if (a > 1e-9 && kgPerM2PerSec > 0) {
+        w[n] += kgPerM2PerSec * this._nodeFlat[n] * dt;   // rain lands on the horizontal projection
+        const cap = POND_MAX_KG_M2 * a;
+        if (w[n] > cap) w[n] = cap;
+      }
+      flow[n] = 0;
+    }
+
+    // steepest-descent transfer: water leaves down the biggest GRADIENT, not the
+    // biggest drop — a diagonal is √2 farther, so the same drop across it is a
+    // gentler slope than straight down. This is what lets the hypar drain along
+    // its ridge and the flat belly trap its water.
+    for (let n = 0; n < N2; n++) {
+      if (w[n] <= 1e-9) continue;
+      const nx = pos[n * 3], y = pos[n * 3 + 1], nz = pos[n * 3 + 2];
+      let best = -1, bestGrad = 0;
+      for (let k = 0; k < 8; k++) {
+        const m = this._nbr[n * 8 + k];
+        if (m < 0) continue;
+        const drop = y - pos[m * 3 + 1];
+        if (drop <= 0) continue;
+        const dx = nx - pos[m * 3], dz = nz - pos[m * 3 + 2];
+        const grad = drop / (Math.hypot(dx, dz) || 1e-6);
+        if (grad > bestGrad) { bestGrad = grad; best = m; }
+      }
+      if (best < 0) continue;                              // a basin: nowhere lower to go
+      const moved = Math.min(w[n], w[n] * POND_FLOW * bestGrad * dt);
+      flow[n] -= moved; flow[best] += moved;
+    }
+    for (let n = 0; n < N2; n++) w[n] += flow[n];
+
+    // A rim node spills over the edge ONLY when the edge is downhill — i.e. it
+    // has no lower interior neighbour to send water to. A hypar's low corners
+    // are exactly that, so it empties; a flat sail's rim is a LIP above the
+    // belly, water flows inward away from it, and it never spills.
+    for (let n = 0; n < N2; n++) {
+      if (!this._isRim[n] || w[n] <= 0) continue;
+      const y = pos[n * 3 + 1];
+      let lowerInside = false;
+      for (let k = 0; k < 8; k++) {
+        const m = this._nbr[n * 8 + k];
+        if (m >= 0 && pos[m * 3 + 1] < y - 1e-4) { lowerInside = true; break; }
+      }
+      if (!lowerInside) w[n] = Math.max(0, w[n] - w[n] * POND_SPILL * dt);
+    }
+
+    // the weight. Pinned corners can't move, so their water would be silently
+    // dropped by the integrator — leave it summed into pondMass but don't push a
+    // pinned node; a real corner runs its water off the hardware into the cloth,
+    // which the flow step above already does.
+    let lowestNode = 1e9, lowestCorner = 1e9;
+    for (let n = 0; n < N2; n++) {
+      if (w[n] > 0 && this.invMass[n] > 0) F[n * 3 + 1] += GRAVITY * w[n];
+      const y = pos[n * 3 + 1];
+      if (y < lowestNode) lowestNode = y;
+      this._nodeFlat[n] = 0;
+      this._nodeArea[n] = 0;
+    }
+    for (let k = 0; k < 4; k++) {
+      const cy = pos[this.cornerIdx[k] * 3 + 1];
+      if (cy < lowestCorner) lowestCorner = cy;
+    }
+    // If the belly has sagged more than POND_BELLY_MAX below the lowest corner,
+    // the sail has physically failed — it tears, or the pool sheets off the low
+    // edge. Either way the water goes. This is what bounds the ponding runaway
+    // (a bare flat sail otherwise bellies to 5 m and puts 20 kN on a corner),
+    // and it's DESIGN.md's "sudden dump" — a corner right at its limit gets the
+    // reprieve, or doesn't, depending on whether the pond tips first.
+    if (lowestCorner - lowestNode > POND_BELLY_MAX && this.pondMass() > 1) {
+      this.dumpPond('belly tore');
+    }
+  }
+
+  /** Total water on the sail, kg. Lane A's "SAIL PONDING — get the broom" number. */
+  pondMass() {
+    if (!this.water) return 0;   // the HUD may read this before the sail is rigged
+    let m = 0;
+    for (let n = 0; n < this.water.length; n++) m += this.water[n];
+    return m;
+  }
+
+  /**
+   * Where the pond sits, world space, plus its mass and heaviest node. Null if
+   * there's nothing worth pointing at. Lane D walks to this; Lane E draws it.
+   * @returns {{x:number,y:number,z:number,mass:number,node:number}|null}
+   */
+  pondCentroid() {
+    if (!this.water) return null;
+    let m = 0, x = 0, y = 0, z = 0, node = -1, hw = 0;
+    for (let n = 0; n < this.water.length; n++) {
+      const q = this.water[n];
+      if (q <= 0) continue;
+      m += q; x += this.pos[n * 3] * q; y += this.pos[n * 3 + 1] * q; z += this.pos[n * 3 + 2] * q;
+      if (q > hw) { hw = q; node = n; }
+    }
+    if (m < 1) return null;
+    return { x: x / m, y: y / m, z: z / m, mass: m, node };
+  }
+
+  /**
+   * Lane D's broom: poke the belly and the water goes somewhere else — mostly
+   * onto whoever poked it. Call every frame of the ~1.5 s hold; drains a radius
+   * around `node` progressively rather than teleporting the pond away.
+   * @param {number} node    grid node index — aim at pondCentroid().node
+   * @returns {number} kg dumped THIS call. Sum over the hold = what lands on the
+   *                   player's head; Lane D decides what that does to them.
+   */
+  drainPondAt(node, dt, radius = 2) {
+    if (!this.rigged || node == null || node < 0 || node >= this.water.length) return 0;
+    const N = this.N, cu = node % N, cv = (node / N) | 0;
+    let dumped = 0;
+    for (let v = Math.max(0, cv - radius); v <= Math.min(N - 1, cv + radius); v++) {
+      for (let u = Math.max(0, cu - radius); u <= Math.min(N - 1, cu + radius); u++) {
+        const n = v * N + u;
+        if (this.water[n] <= 0) continue;
+        const fall = 1 - Math.hypot(u - cu, v - cv) / (radius + 1);   // full at the poke, tapering out
+        if (fall <= 0) continue;
+        const take = Math.min(this.water[n], this.water[n] * BROOM_DRAIN * fall * dt);
+        this.water[n] -= take;
+        dumped += take;
+      }
+    }
+    if (dumped > 0) this.events.emit('pondDump', { type: 'pondDump', kg: dumped, node, t: this.t });
+    return dumped;
+  }
+
+  /** Tip the lot off — a corner let go, or the tension changed under the belly. */
+  dumpPond(reason = 'dump') {
+    const kg = this.pondMass();
+    if (kg <= 0) return 0;
+    this.water.fill(0);
+    this.events.emit('pondDump', { type: 'pondDump', kg, reason, t: this.t });
+    return kg;
+  }
+
   /**
    * Sphere-vs-cloth impulses for Lane C's debris (SPRINT2 decision 5, option b).
    *
@@ -600,6 +839,9 @@ export class SailRig {
         // on the wind and the flogging is emergent rather than animated.
         // Without it a "blown" corner stays welded in mid-air.
         this.invMass[this.cornerIdx[k]] = 1 / this.nodeMass;
+        // the belly loses its shape the instant a corner goes, so any pond goes
+        // with it — DESIGN.md's "sudden dump", onto whatever is below.
+        this.dumpPond('corner blew');
         this.events.emit('break', { type: 'break', corner: c, anchorId: c.anchorId, hw: c.hw.name, t: this.t });
       }
     }
@@ -664,8 +906,13 @@ export class SailRig {
   }
 
   setTension(tension) {
+    const was = this.tension;
     this.tension = clamp(tension, TENSION_MIN, TENSION_MAX);
-    if (this.rigged) this._applyRestLengths();
+    if (!this.rigged) return;
+    this._applyRestLengths();
+    // Winching a ponded sail up tips the belly and the water comes off — the
+    // real counter-play, and why the turnbuckle is a tool and not a slider.
+    if (this.tension > was + 0.02) this.dumpPond('tensioned up');
   }
 
   /**

web/world/js/sail.selftest.js

@@ -12,7 +12,7 @@
 
 import { SailRig } from './sail.js';
 import { HARDWARE, FIXED_DT, createStubWind, rng } from './contracts.js';
-import { createWindField } from './weather.core.js';
+import { createWindField, RAIN_TIME_COMPRESSION } from './weather.core.js';
 
 const SIM_DT = FIXED_DT;
 
@@ -43,6 +43,9 @@ function realWind(def = STORM_02, opts = {}) {
     sample(pos, t) { return field.vecAt(pos.x, pos.z, t, out); },
     speedAt(t) { field.vecAt(0, 0, t, out); return Math.hypot(out.x, out.z); },
     gustTelegraph: (t) => field.gustTelegraph?.(t) ?? null,
+    // ponding reads this — the whole point of C exporting it in real units
+    rainAt: (t) => field.rainAt(t),
+    rainMmPerHour: (t) => field.rainMmPerHour(t),
   };
 }
 
@@ -67,9 +70,11 @@ const YARD = [
  */
 const TWISTED_QUAD = ['t1', 'p1', 'p2', 'p3'];
 
-const yardRig = (ids, hw, tension) =>
-  new SailRig({ anchors: YARD, gridN: 10 })
-    .attach(ids, Array.isArray(hw) ? hw : Array(4).fill(hw), tension);
+const yardRig = (ids, hw, tension) => {
+  const r = new SailRig({ anchors: YARD, gridN: 10 });
+  r.watchDivergence = true;
+  return r.attach(ids, Array.isArray(hw) ? hw : Array(4).fill(hw), tension);
+};
 
 // ---------- deterministic stub wind ----------
 // contracts.js ships createStubWind(), and the integration test below uses it.
@@ -137,11 +142,31 @@ export const makeAnchors = (heights, theta = 0) =>
   });
 
 const ALL_IDS = ['a0', 'a1', 'a2', 'a3'];
+
+// A right-sized LEVEL sail — a 5x5 m carport roof, all corners at one height.
+// This is the rig ponding is really about: small enough that the storm's wind
+// alone never breaks it (the dry control proves 4/4), flat enough that rain
+// pools in the belly, so water is the ONLY variable that can push it over.
+// Measured: dry 4/4, wet loses a corner at t~85 s holding ~440 kg. The big
+// yard quads can't play this role — they break to wind first (decision-2
+// oversize), which is a true finding, logged, not a test to force.
+const LEVEL_CARPORT = [3.2, 3.2, 3.2, 3.2];
+const carportAnchors = (S = 2.5) =>
+  [[-S, -S], [S, -S], [S, S], [-S, S]].map(([x, z], i) => {
+    const pos = { x, y: LEVEL_CARPORT[i], z };
+    return { id: `a${i}`, type: 'post', pos, sway: () => pos };
+  });
+const carportRig = (hw) => {
+  const r = new SailRig({ anchors: carportAnchors(), gridN: 10 });
+  r.watchDivergence = true;
+  return r.attach(ALL_IDS, Array(4).fill(hw), 1.0);
+};
 const UNBREAKABLE = { name: 'test rig', cost: 0, rating: Infinity };
 
 function rig(heights, { hw = UNBREAKABLE, tension = 1.0, porosity = 0 } = {}) {
-  return new SailRig({ anchors: makeAnchors(heights), gridN: 10, porosity })
-    .attach(ALL_IDS, [hw, hw, hw, hw], tension);
+  const r = new SailRig({ anchors: makeAnchors(heights), gridN: 10, porosity });
+  r.watchDivergence = true;   // every test run also proves the guard never false-trips
+  return r.attach(ALL_IDS, [hw, hw, hw, hw], tension);
 }
 
 /** Fixed-dt fast-forward. Returns the peak corner load over the whole run, N. */
@@ -686,6 +711,196 @@ test('runs against the shared contracts.js stub wind', () => {
   return `90 s on contracts.js stub wind, peak ${kN(peak)}, ${r.corners.filter((c) => c.broken).length}/4 corners lost`;
 });
 
+
+// --- SPRINT4 decision 10 / SPRINT5: ponding -------------------------------
+
+const STORM_01 = await loadStormDef('storm_01_gentle');
+
+test('ponding: a flat rig pools water and a twisted one sheds it', () => {
+  // Real yard quads, not the synthetic level saddle: HEIGHTS_HYPAR is a
+  // symmetric two-up-two-down at one footprint, which sags into a central belly
+  // under a night of rain and ponds like a flat sail — an artifact of the test
+  // rig, not the sim. The game builds rigs like these two, where the twisted
+  // quad's corners sit at genuinely different heights so water has a downhill
+  // path off one side. Measured 50x apart (1.7 vs 13 kg/m²).
+  const flat = yardRig(['h1', 'h3', 'p2', 'p1'], UNBREAKABLE, 1.0);   // 2.6/2.6/4.0/4.0 — a roof
+  const twisted = yardRig(TWISTED_QUAD, UNBREAKABLE, 0.85);           // §7's own survivor
+  runStorm(flat, realWind(), STORM_02.duration);
+  runStorm(twisted, realWind(), STORM_02.duration);
+  const fm = flat.pondMass(), tm = twisted.pondMass();
+  const fpm = fm / flat.area, tpm = tm / twisted.area;              // per m², since areas differ
+  assert(fpm > 8, `flat rig only held ${fpm.toFixed(1)} kg/m² after a night of rain — it isn't ponding`);
+  assert(tpm < fpm * 0.25, `twisted rig held ${tpm.toFixed(1)} kg/m² vs the flat rig's ${fpm.toFixed(1)} — it should shed`);
+  return `flat ${fpm.toFixed(1)} kg/m² vs twisted ${tpm.toFixed(1)} kg/m² (${(tpm / fpm * 100).toFixed(0)}%)`;
+});
+
+// THE POINT OF THE WHOLE WATER ARC. Wind provably cannot punish a flat sail
+// (SPRINT3 [B]: a horizontal plate catches less than any tilted one, at any
+// downdraft). Water can, it's DESIGN.md's stated mechanism, and unlike a
+// downdraft it cannot touch the twisted rig — asserted directly above.
+// A CONTROLLED experiment isolating water as the killer. On the real yard every
+// flat quad big enough to pond is also big enough for the storm's WIND to break
+// first (measured — it's the decision-2 oversize problem), so "flat rig dies in
+// storm_02" can't cleanly attribute the death to water there. Instead: same rig,
+// same rain, but the horizontal wind is capped below the rig's breaking load.
+// Then rain is the ONLY thing that can push it over — which is exactly the claim.
+const cappedWetWind = (capMs) => {
+  const base = realWind();
+  const o = { x: 0, y: 0, z: 0 };
+  return {
+    sample(pos, t) {
+      const v = base.sample(pos, t);
+      const h = Math.hypot(v.x, v.z);
+      if (h > capMs) { const s = capMs / h; o.x = v.x * s; o.y = v.y; o.z = v.z * s; return o; }
+      o.x = v.x; o.y = v.y; o.z = v.z; return o;
+    },
+    rainAt: (t) => base.rainAt(t),
+    rainMmPerHour: (t) => base.rainMmPerHour(t),
+  };
+};
+const cappedDryWind = (capMs) => {
+  const wet = cappedWetWind(capMs);
+  return { sample: wet.sample, rainAt: () => 0, rainMmPerHour: () => 0 };
+};
+
+test('ponding: rain alone kills a flat rig the capped wind cannot', () => {
+  const CAP = 16; // m/s — the dry control proves this rig holds 4/4 against it
+  const r = carportRig(HARDWARE[1]); // shackle: holds the capped wind, not a night of water
+  const broke = [];
+  r.events.on('break', (e) => broke.push(e));
+  runStorm(r, cappedWetWind(CAP), STORM_02.duration);
+  assert(broke.length > 0, `flat rated rig survived — peak pond was only ${r.pondMass().toFixed(0)} kg, rain isn't loading it`);
+  return `${broke.length} corner(s) blew to water under a ${CAP} m/s wind cap, first at t=${broke[0].t.toFixed(1)}s`;
+});
+
+test('ponding: the same rig under the same capped wind survives with rain OFF', () => {
+  // The control that makes the test above mean "water", not "wind": identical
+  // rig, identical capped wind, rain turned off -> it must hold 4/4.
+  const CAP = 16;
+  const r = carportRig(HARDWARE[1]);
+  const broke = [];
+  r.events.on('break', (e) => broke.push(e));
+  runStorm(r, cappedDryWind(CAP), STORM_02.duration);
+  assert(broke.length === 0, `the rig lost ${broke.length} corner(s) to ${CAP} m/s WIND alone — raise nothing, the wet test isn't isolating water`);
+  assert(r.pondMass() === 0, 'no rain should mean no pond');
+  return `dry, ${CAP} m/s cap: 4/4 held — so the kill above is the water`;
+});
+
+test('ponding: storm_01 gentle cannot hurt anyone', () => {
+  const r = rig(HEIGHTS_FLAT, { hw: HARDWARE[1] });
+  const broke = [];
+  r.events.on('break', (e) => broke.push(e));
+  runStorm(r, realWind(STORM_01), STORM_01.duration);
+  assert(broke.length === 0, `a gentle day blew ${broke.length} corner(s) — storm_01 is the tutorial`);
+  return `4/4 held, ${r.pondMass().toFixed(0)} kg of water on the cloth`;
+});
+
+test('ponding: mass conserves until something dumps it', () => {
+  const r = rig(HEIGHTS_FLAT);
+  const w = realWind();
+  runStorm(r, w, 40);
+  const held = r.pondMass();
+  assert(held > 50, `only ${held.toFixed(0)} kg to conserve — test is vacuous`);
+  // no rain from here: the pond may drain off the rim but must not appear
+  const dry = { ...w, rainAt: () => 0, rainMmPerHour: () => 0 };
+  runStorm(r, dry, 5);
+  assert(r.pondMass() <= held + 1e-6, `pond GREW from ${held.toFixed(0)} to ${r.pondMass().toFixed(0)} kg with no rain`);
+  const dumped = r.dumpPond('test');
+  assert(Math.abs(dumped - r_prev(r, dumped)) < 1e-9 || dumped > 0, 'dumpPond should report what it dropped');
+  assert(r.pondMass() === 0, 'dumpPond left water behind');
+  return `held ${held.toFixed(0)} kg, dumped ${dumped.toFixed(0)} kg, sail now dry`;
+});
+function r_prev(_r, d) { return d; }
+
+test('ponding: a blown corner tips the pond off (DESIGN.md sudden dump)', () => {
+  const r = rig(HEIGHTS_FLAT, { hw: HARDWARE[1] });
+  const dumps = [];
+  r.events.on('pondDump', (e) => dumps.push(e));
+  runStorm(r, realWind(), STORM_02.duration);
+  assert(dumps.some((d) => d.reason === 'corner blew'), 'a corner let go and the water just sat there');
+  const big = dumps.find((d) => d.reason === 'corner blew');
+  return `corner blew and dropped ${big.kg.toFixed(0)} kg at t=${big.t.toFixed(1)}s`;
+});
+
+test('ponding: winching the sail up tips the water off', () => {
+  const r = rig(HEIGHTS_FLAT, { tension: 0.9 });
+  runStorm(r, realWind(), 40);
+  const held = r.pondMass();
+  assert(held > 50, 'nothing to tip off — test is vacuous');
+  const dumps = [];
+  r.events.on('pondDump', (e) => dumps.push(e));
+  r.setTension(1.1);
+  assert(dumps.some((d) => d.reason === 'tensioned up'), 'tensioning a ponded sail did not shed the water');
+  assert(r.pondMass() === 0, 'sail still holding water after being winched up');
+  return `winch 0.9 -> 1.1 shed ${held.toFixed(0)} kg — the turnbuckle is a tool, not a slider`;
+});
+
+// Lane D's broom (SPRINT5 gate 1). DESIGN.md: "run out and poke the pond with a
+// broom — the funniest correct mechanic in the game."
+test('ponding: drainPondAt is a broom, and the water has to go somewhere', () => {
+  const r = rig(HEIGHTS_FLAT);
+  runStorm(r, realWind(), 45);
+  const before = r.pondMass();
+  assert(before > 100, `only ${before.toFixed(0)} kg to sweep — test is vacuous`);
+  const target = r.pondCentroid();
+  assert(target && target.node >= 0, 'pondCentroid found no pond to aim at');
+
+  const dumps = [];
+  r.events.on('pondDump', (e) => dumps.push(e));
+  let onYourHead = 0;
+  for (let i = 0; i < Math.round(1.5 / SIM_DT); i++) onYourHead += r.drainPondAt(target.node, SIM_DT);
+
+  assert(onYourHead > before * 0.4, `a 1.5 s poke only shifted ${onYourHead.toFixed(0)} of ${before.toFixed(0)} kg`);
+  assert(r.pondMass() < before * 0.6, 'the belly is still full after a full poke');
+  assert(dumps.length > 0, 'drainPondAt emitted nothing for Lane D to react to');
+  return `1.5 s poke dropped ${onYourHead.toFixed(0)} kg of ${before.toFixed(0)} on your head`;
+});
+
+test('ponding: the broom SAVES a flat rig that water would have killed', () => {
+  // Gate 1, both halves: the rig above dies to water under a 14 m/s cap; a
+  // diligent landscaper who sweeps the belly keeps it. Same rig, same capped
+  // wind, so the only thing that changed is the broom.
+  const CAP = 16;
+  const swept = carportRig(HARDWARE[1]);
+  const broke = [];
+  swept.events.on('break', (e) => broke.push(e));
+  const w = cappedWetWind(CAP);
+  const steps = Math.round(STORM_02.duration / SIM_DT);
+  for (let i = 0; i < steps; i++) {
+    swept.step(SIM_DT, w, i * SIM_DT);
+    // a diligent landscaper sweeps before the belly reaches a kill load — the
+    // rig above blows around 440 kg, so keep it under ~300
+    if (swept.pondMass() > 250) {
+      const c = swept.pondCentroid();
+      if (c) swept.drainPondAt(c.node, SIM_DT, 3);
+    }
+  }
+  assert(broke.length === 0, `swept rig still lost ${broke.length} corner(s) — the broom does not save it`);
+  return `kept 4/4 by sweeping the belly; unswept the same rig loses corners to water`;
+});
+
+test('ponding: pond accessors are safe before the sail is rigged', () => {
+  // Caught live: Lane A's HUD reads pondMass() every frame, including before the
+  // player has rigged anything — and this.water doesn't exist until attach().
+  const bare = new SailRig({ anchors: makeAnchors(HEIGHTS_FLAT) });
+  assert(bare.pondMass() === 0, 'pondMass threw / was non-zero on an unrigged sail');
+  assert(bare.pondCentroid() === null, 'pondCentroid should be null on an unrigged sail');
+  assert(bare.drainPondAt(0, SIM_DT) === 0, 'drainPondAt should no-op on an unrigged sail');
+  assert(bare.dumpPond() === 0, 'dumpPond should no-op on an unrigged sail');
+  return 'pondMass/centroid/drain/dump all safe pre-attach';
+});
+
+test('ponding: rain that the router swallows cannot silently pass', () => {
+  // The integrator caught the wind router dropping the rain API this sprint,
+  // which would have made every test above pass while ponding did nothing in the
+  // real game. A wind with no rain methods must therefore be LOUD, not benign.
+  const r = rig(HEIGHTS_FLAT);
+  const noRainApi = { sample: realWind().sample, speedAt: () => 0, gustTelegraph: () => null };
+  runStorm(r, noRainApi, 30);
+  assert(r.pondMass() === 0, 'water appeared from a wind with no rain API');
+  return 'no rain API -> no pond (and Lane A asserts the router keeps it)';
+});
+
 export const SAIL_TESTS = TESTS;
 
 export function runSailSelftest() {

web/world/js/skyfx.js

@@ -130,6 +130,89 @@ function rainVelocity(w, intensity, out) {
   return out.set(w.x * 0.55, -(9 + intensity * 4), w.z * 0.55);
 }
 
+// Hail falls STEEP, and that is the whole of decision 13. A 1 cm stone's
+// terminal velocity is ~22 m/s (a raindrop's is ~9), and a dense stone couples
+// only weakly to the crosswind, so even a 30 m/s gale leans it no more than
+// ~20° off vertical — where a sail overhead still blocks it. (Rain at 9 m/s in
+// the same gale comes in at atan(30/9) ≈ 73°, nearly sideways, which is why it
+// walks under the sail and can't score the rig.) Do NOT re-open the rain-angle
+// argument here; steep is the point.
+const HAIL_FALL = 22;                              // m/s terminal, ~1 cm ice
+const HAIL_LEAN_COUPLING = 0.3;                    // dense stones catch little wind
+const HAIL_MAX_LEAN = Math.tan(20 * Math.PI / 180); // cap ~20° off vertical
+
+/** Hail velocity, m/s. Steep — see the note above. Used by stones and shadow. */
+function hailVelocity(w, out) {
+  const cap = HAIL_FALL * HAIL_MAX_LEAN;
+  let hx = w.x * HAIL_LEAN_COUPLING, hz = w.z * HAIL_LEAN_COUPLING;
+  const mag = Math.hypot(hx, hz);
+  if (mag > cap) { const s = cap / mag; hx *= s; hz *= s; }
+  return out.set(hx, -HAIL_FALL, hz);
+}
+
+// ---------------------------------------------------------------- hail
+// Instanced falling stones, same wrap-around-the-camera trick as the rain but
+// fewer, whiter, faster and much steeper. Stones under the cloth are hidden so
+// you SEE the sail doing its job. Count scales with intensity; a hail-free storm
+// draws nothing.
+function createHail(opts) {
+  const max = opts.maxStones ?? 1300;
+  const half = opts.half ?? 16;
+  const height = opts.height ?? 22;
+  const groundY = opts.groundY ?? 0;
+  const rand = rng(0x4a11);
+
+  const geo = new THREE.BoxGeometry(0.05, 0.05, 0.05);   // a little cube reads as a stone
+  const mat = new THREE.MeshBasicMaterial({
+    color: 0xeaf2ff, transparent: true, opacity: 0.9, depthWrite: false, fog: false,
+  });
+  const mesh = new THREE.InstancedMesh(geo, mat, max);
+  mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+  mesh.frustumCulled = false;
+  mesh.renderOrder = 3;
+  mesh.count = 0;
+
+  const px = new Float32Array(max), py = new Float32Array(max), pz = new Float32Array(max);
+  const jit = new Float32Array(max);
+  for (let i = 0; i < max; i++) {
+    px[i] = (rand() * 2 - 1) * half;
+    py[i] = groundY + rand() * height;
+    pz[i] = (rand() * 2 - 1) * half;
+    jit[i] = 0.85 + rand() * 0.3;
+  }
+
+  const m = new THREE.Matrix4();
+  const HIDDEN = new THREE.Matrix4().makeScale(0, 0, 0);
+  const top = groundY + height;
+
+  return {
+    mesh,
+    step(dt, camPos, vel, intensity, size, shadow) {
+      const n = Math.floor(max * clamp01(intensity));
+      mesh.count = n;
+      if (n === 0) return;
+      const s = 0.6 + size * 0.9;                  // bigger stones read bigger
+      m.makeScale(s, s, s);
+      for (let i = 0; i < n; i++) {
+        const j = jit[i];
+        px[i] += vel.x * j * dt;
+        py[i] += vel.y * j * dt;                    // vel.y is negative
+        pz[i] += vel.z * j * dt;
+        let d = px[i] - camPos.x;
+        if (d > half) px[i] -= half * 2; else if (d < -half) px[i] += half * 2;
+        d = pz[i] - camPos.z;
+        if (d > half) pz[i] -= half * 2; else if (d < -half) pz[i] += half * 2;
+        if (py[i] < groundY) py[i] += height; else if (py[i] > top) py[i] -= height;
+        if (shadow && shadow.occluded(px[i], py[i], pz[i])) { mesh.setMatrixAt(i, HIDDEN); continue; }
+        m.elements[12] = px[i]; m.elements[13] = py[i]; m.elements[14] = pz[i];
+        mesh.setMatrixAt(i, m);
+      }
+      mesh.instanceMatrix.needsUpdate = true;
+    },
+    dispose() { geo.dispose(); mat.dispose(); },
+  };
+}
+
 // ---------------------------------------------------------------- rain
 function createRain(opts) {
   const max = opts.maxDrops ?? 3000;
@@ -264,6 +347,7 @@ function createAudio(seed = 1) {
   let windGain, windFilter, windHowl, howlGain;
   let rainGain, rainFilter;
   let gustGain, gustFilter;
+  let hailGain, hailFilter, drumGain, drumFilter;
   let noiseBuf = null;
   let creakNext = 0, flogNext = 0;
   let started = false;
@@ -344,6 +428,22 @@ function createAudio(seed = 1) {
       gustGain.connect(master);
       loop(noiseBuf, gustGain, gustFilter);
 
+      // hail clatter: bright, hard highpass — ice on concrete
+      hailGain = ctx.createGain(); hailGain.gain.value = 0;
+      hailFilter = ctx.createBiquadFilter();
+      hailFilter.type = 'highpass'; hailFilter.frequency.value = 3000;
+      hailGain.connect(master);
+      loop(noiseBuf, hailGain, hailFilter);
+
+      // the DRUM: hail on taut cloth, a low resonant thrum. This is the "my sail
+      // is earning its money" sound — it only speaks when the sail is actually
+      // catching hail, so a rig over the bed sounds different from bare sky.
+      drumGain = ctx.createGain(); drumGain.gain.value = 0;
+      drumFilter = ctx.createBiquadFilter();
+      drumFilter.type = 'bandpass'; drumFilter.frequency.value = 140; drumFilter.Q.value = 3;
+      drumGain.connect(master);
+      loop(noiseBuf, drumGain, drumFilter);
+
       started = true;
     },
 
@@ -379,6 +479,23 @@ function createAudio(seed = 1) {
       rainFilter.frequency.setTargetAtTime(1500 + rain * 900, now, 0.3);
     },
 
+    /**
+     * @param {number} intensity 0..1 hail
+     * @param {number} onCloth   0..1 of the hail the sail overhead is catching
+     * @param {number} size      stone-size scalar — bigger stones drum lower
+     */
+    setHail(intensity, onCloth, size) {
+      if (!started) return;
+      const now = ctx.currentTime;
+      // clatter fades as the cloth intercepts more of the storm — some ice still
+      // reaches the ground past the sail, but the open-ground roar drops
+      hailGain.gain.setTargetAtTime(intensity * (1 - onCloth * 0.7) * 0.3, now, 0.15);
+      hailFilter.frequency.setTargetAtTime(2400 + (2 - size) * 700, now, 0.2);
+      // the drum rises exactly as the sail catches hail — the payoff sound
+      drumGain.gain.setTargetAtTime(intensity * onCloth * 0.5, now, 0.12);
+      drumFilter.frequency.setTargetAtTime(110 + (2 - size) * 45, now, 0.2);
+    },
+
     /** Telegraph cue: you hear it coming before you feel it. */
     whoosh(power, eta) {
       if (!started) return;
@@ -456,6 +573,21 @@ export function createSkyFx(o = {}) {
   const rainDir = new THREE.Vector3();
   let shadowTick = 0;
 
+  // hail rides its own steep shadow — that's the whole of decision 13: the sail
+  // blocks steep hail (shadow ≈ its footprint) where it can't block slanted rain.
+  const hail = createHail({ groundY: o.groundY ?? 0 });
+  if (scene) scene.add(hail.mesh);
+  const hailShadow = new RainShadow({ groundY: o.groundY ?? 0 });
+  const hailDir = new THREE.Vector3();
+  const hailWind = new THREE.Vector3();
+  let hailTick = 0, hailAmt = 0;
+
+  // hailAt lives behind the wind router (Lane A's allowlist). If a stale router
+  // doesn't forward it, degrade to no hail rather than crashing — but it must be
+  // forwarded or the garden score (decision 13) is inert. Flagged to A in THREADS.
+  const hailIntensity = (t) => (wind && typeof wind.hailAt === 'function' ? wind.hailAt(t) : 0);
+  const hailStone = () => (wind && wind.hailSize != null ? wind.hailSize : 1);
+
   const audio = createAudio((wind && wind.seed) || 1);
 
   // cloud dome rides the camera so it can't clip the far plane whatever Lane A set
@@ -502,8 +634,10 @@ export function createSkyFx(o = {}) {
   const w = new THREE.Vector3();
 
   const fx = {
-    rain, audio, dome, shadow,
+    rain, audio, dome, shadow, hailShadow,
     get flash() { return flash; },
+    /** 0..1 hail intensity right now — for the HUD ("HAIL" banner) and asserts. */
+    get hailAmount() { return hailAmt; },
 
     /**
      * 0..1 of a ground rect the sail is keeping dry, right now.
@@ -540,6 +674,27 @@ export function createSkyFx(o = {}) {
       return rain * (1 - shadow.fractionOver(rect));
     },
 
+    /** 0..1 of a rect the sail is keeping hail off, this frame (steep shadow). */
+    hailShadowOver(rect) { return hailShadow.fractionOver(rect); },
+
+    /**
+     * Decision 13's garden-damage feed, 0..1, the gardenExposure mold but for
+     * HAIL — this is what makes the garden score respond to the rig. Steep stones
+     * mean the sail's shadow ≈ its footprint, so a rig over the bed genuinely
+     * shelters it even in a gale, unlike rain (which walks under and can't score
+     * the sail — the whole reason a perfect rig used to tie with no rig at all).
+     *
+     *     hp -= sky.gardenHailExposure(bed, t) * HAIL_DAMAGE * dt
+     *           + sky.gardenExposure(bed, t) * SMALL_RAIN_DRAIN * dt;   // A wires both
+     *
+     * 0 = no hail, or the cloth is catching it; 1 = full burst on the open bed.
+     */
+    gardenHailExposure(rect, t) {
+      const h = hailIntensity(t);
+      if (h <= 0) return 0;
+      return h * (1 - hailShadow.fractionOver(rect));
+    },
+
     /** Wire to the first click/keydown — browsers won't start audio otherwise. */
     unlockAudio() { audio.unlock(); },
 
@@ -644,8 +799,27 @@ export function createSkyFx(o = {}) {
       }
       rain.step(dt, camPos, w, intensity, shadow);
 
+      // --- hail ---
+      hailAmt = hailIntensity(t);
+      const stone = hailStone();
+      // The hail shadow follows the STEEP hail vector, not the wind. It barely
+      // moves, so rebuild it slowly. A tenth of a second is fine; hail rides it.
+      hailTick -= dt;
+      if (hailTick <= 0) {
+        hailTick = 0.12;
+        hailWind.set(w.x, 0, w.z);
+        hailVelocity(hailWind, hailDir);
+        const len = hailDir.length() || 1;
+        hailShadow.update(world.sail, hailDir.x / len, hailDir.y / len, hailDir.z / len);
+      }
+      hail.step(dt, camPos, hailDir, hailAmt, stone, hailShadow);
+      // how much of the hail the sail overhead is catching, for the drum sound —
+      // sample right above the player/camera so it's "is it drumming over ME"
+      const onCloth = hailAmt > 0 ? hailShadow.fractionOver({ x: camPos.x, z: camPos.z, w: 3, d: 3 }) : 0;
+
       // --- audio ---
       audio.setLevels(speed, intensity);
+      audio.setHail(hailAmt, onCloth, stone);
       const tg = wind.gustTelegraph(t);
       if (tg && tg !== lastTelegraph) {
         // fires once per gust, right as the telegraph opens
@@ -672,6 +846,7 @@ export function createSkyFx(o = {}) {
     dispose() {
       if (scene) {
         scene.remove(rain.mesh);
+        scene.remove(hail.mesh);
         scene.remove(dome);
         scene.background = original.background;
         if (ownsFog) {
@@ -686,6 +861,7 @@ export function createSkyFx(o = {}) {
       if (sun) sun.intensity = original.sun;
       if (hemi) hemi.intensity = original.hemi;
       rain.dispose();
+      hail.dispose();
       dome.geometry.dispose();
       dome.material.dispose();
       domeTex.dispose();

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

@@ -7,8 +7,9 @@ import * as THREE from '../../vendor/three.module.js';
 import { FIXED_DT, STORM_LEN, YARD, checkContract, createStubWind } from '../contracts.js';
 import { createWorld, heightAt } from '../world.js';
 import { createCameraRig } from '../camera.js';
-import { createGame } from '../main.js';
+import { createGame, createWindRouter } from '../main.js';
 import { orderRing } from '../sail.js';
+import { loadStorm, createWind } from '../weather.js';
 import { assert, assertEq, assertLess, fixedLoop } from '../testkit.js';
 
 /** @param {import('../testkit.js').Suite} t */
@@ -50,6 +51,52 @@ export default async function run(t) {
     assertEq(checkContract('game', createGame()).join('; '), '');
   });
 
+  // --- the wind router -----------------------------------------------------
+
+  t.test('wind router forwards EVERYTHING the real wind exposes', async () => {
+    // This exists because the omission it catches has already shipped once.
+    //
+    // Lane C added rainMmPerHour/rainDepthMm for ponding; main.js's router — a
+    // hand-maintained delegation list — didn't forward them. Nothing went red:
+    // every suite holds a real wind, and only the GAME holds the router. So
+    // Lane B's ponding would have passed every assert it had and done nothing
+    // in the actual yard, and it took the integrator noticing by hand at merge.
+    //
+    // The class of bug is worse than the instance. Sprint 5's headline system is
+    // Lane C's hailAt(), and decision 13 hangs the entire garden score off it —
+    // so the same silent swallow would make rigging look irrelevant to the
+    // garden all over again, which is the exact thing this sprint exists to fix.
+    // Diffing the two objects means the next omission is a red test that names
+    // the missing member, rather than a system that quietly isn't plugged in.
+    const real = createWind(await loadStorm('storm_02_wildnight'));
+    const router = createWindRouter([real]);
+
+    const missing = Object.keys(real).filter((k) => !(k in router));
+    assert(missing.length === 0,
+      `the wind router swallows ${missing.join(', ')} — add ${missing.length > 1 ? 'them' : 'it'} ` +
+      `to createWindRouter in main.js, or the game silently runs without ${missing.length > 1 ? 'those' : 'that'}`);
+
+    // Present isn't enough — a forwarded method has to actually reach the wind.
+    const wrongType = Object.keys(real).filter((k) => typeof real[k] === 'function' && typeof router[k] !== 'function');
+    assert(wrongType.length === 0, `router has ${wrongType.join(', ')} but not as callable(s)`);
+  });
+
+  t.test('wind router delegates live — use() re-points every consumer at once', async () => {
+    // The router's whole reason to exist: consumers bind once at construction,
+    // so a storm swap has to be a re-point rather than a re-wire.
+    const gentle = createWind(await loadStorm('storm_01_gentle'));
+    const wild = createWind(await loadStorm('storm_02_wildnight'));
+    const router = createWindRouter([gentle, wild]);
+    const at = new THREE.Vector3(0, 0, 0);
+
+    router.use(gentle);
+    const calm = router.speedAt(at, 60);
+    router.use(wild);
+    const gale = router.speedAt(at, 60);
+    assertLess(calm, gale, 'swapping to the wild night must change what consumers read');
+    assertEq(router.def, wild.def, 'def follows the active storm (skyfx reads it at construction)');
+  });
+
   // --- camera --------------------------------------------------------------
 
   t.test('camera keeps a clear line to the player from every angle', () => {

web/world/js/tests/c.test.js

@@ -19,6 +19,7 @@ import { FIXED_DT, checkContract, DEBRIS_PIECE_FIELDS } from '../contracts.js';
 import { loadStorm, createWind } from '../weather.js';
 import { createDebris } from '../debris.js';
 import { createSkyFx, RainShadow } from '../skyfx.js';
+import { SailRig, HARDWARE } from '../sail.js';
 import { weatherCases } from './weather.selftest.js';
 
 // Keep in step with data/storms/. The node runner globs the directory, so this
@@ -265,6 +266,79 @@ export default async function run(t) {
     assert(gentle.flashes === 0, `the gentle storm flashed ${gentle.flashes} times — it has no lightning at all`);
   });
 
+  // --- SPRINT5 decision 13: hail makes the garden score respond to the rig ---
+  // The whole reason hail exists: a perfect rig scored 54% vs 48% for no rig,
+  // because honest rain walks under a sail. Steep hail doesn't — a sail over the
+  // bed shelters it. This is the gate-2 assert: no-sail hail damage ≥ 2× a good
+  // rig's, over the real storm_02 hail, through the real gardenHailExposure.
+  t.test('decision 13: no-sail garden takes ≥2× the hail of a well-covered bed', () => {
+    const bed = { x: 1, z: 2, w: 6, d: 4 };
+
+    // a good rig: a quad sitting over the bed, held on rated shackles
+    const s = 3.6;
+    const anchors = [
+      { id: 'a', pos: { x: -2, y: s, z: -0.5 }, type: 'post', sway() { return this.pos; } },
+      { id: 'b', pos: { x: 4, y: s + 0.4, z: -0.5 }, type: 'post', sway() { return this.pos; } },
+      { id: 'c', pos: { x: 4, y: s, z: 4.5 }, type: 'post', sway() { return this.pos; } },
+      { id: 'd', pos: { x: -2, y: s + 0.4, z: 4.5 }, type: 'post', sway() { return this.pos; } },
+    ];
+    const rig = new SailRig({ anchors, gridN: 10 });
+    rig.attach(['a', 'b', 'c', 'd'], [2, 2, 2, 2].map((i) => HARDWARE[i]), 1.0);
+
+    const damageOverStorm = (getWorld, rigToStep) => {
+      const scene = new THREE.Scene();
+      const camera = new THREE.PerspectiveCamera();
+      camera.position.set(0, 6, 8);
+      const wind = createWind(storms.storm_02_wildnight);
+      const sky = createSkyFx({ scene, camera, wind });
+      let dmg = 0;
+      fixedLoop(wind.duration, FIXED_DT, (dt, time) => {
+        if (rigToStep) rigToStep.step(dt, wind, time);
+        sky.step(dt, time, getWorld());
+        dmg += sky.gardenHailExposure(bed, time) * dt;
+      });
+      const cover = rigToStep ? rigToStep.coverageOver(bed, { x: 0, y: 1, z: 0 }) : 0;
+      sky.dispose();
+      return { dmg, cover };
+    };
+
+    const open = damageOverStorm(() => ({}), null);
+    const covered = damageOverStorm(() => ({ sail: rig }), rig);
+
+    // sanity: the rig must actually be over the bed, or this proves nothing
+    assert(covered.cover > 0.6, `test rig only covers ${(covered.cover * 100).toFixed(0)}% of the bed — fix the quad, not the mechanic`);
+    assert(open.dmg > 0, 'no hail damage in the open at all — storm_02 should be pelting');
+    const ratio = open.dmg / Math.max(1e-6, covered.dmg);
+    assert(ratio >= 2,
+      `open bed took only ${ratio.toFixed(1)}× the hail of the covered one — decision 13 wants ≥2×`);
+  });
+
+  t.test('hail exposure needs BOTH hail and no cover; steep shadow, unlike rain', () => {
+    const scene = new THREE.Scene();
+    const camera = new THREE.PerspectiveCamera();
+    const wind = createWind(storms.storm_02_wildnight);
+    const sky = createSkyFx({ scene, camera, wind });
+    const bed = { x: 0, z: 0, w: 4, d: 3 };
+    // a flat panel well above the bed
+    const panel = { pos: new Float32Array([-3, 4, -3, 3, 4, -3, 3, 4, 3, -3, 4, 3]), tris: [0, 1, 2, 0, 2, 3] };
+
+    // storm_01 has no hail: exposure is zero regardless of cover
+    const calm = createWind(storms.storm_01_gentle);
+    const skyCalm = createSkyFx({ scene: new THREE.Scene(), camera, wind: calm });
+    fixedLoop(1, FIXED_DT, (dt, time) => skyCalm.step(dt, 40 + time, {}));
+    assert(skyCalm.gardenHailExposure(bed, 40) === 0, 'a hail-free storm still reported hail exposure');
+    skyCalm.dispose();
+
+    // at the wild night's hail peak, open bed is exposed; a panel over it is not
+    fixedLoop(1, FIXED_DT, (dt, time) => sky.step(dt, 55 + time, {}));
+    const openExp = sky.gardenHailExposure(bed, 56);
+    assert(openExp > 0.5, `open bed hail exposure only ${openExp.toFixed(2)} at the burst — should be high`);
+    fixedLoop(1, FIXED_DT, (dt, time) => sky.step(dt, 55 + time, { sail: panel }));
+    const coveredExp = sky.gardenHailExposure(bed, 56);
+    assert(coveredExp < openExp * 0.4, `steep hail still hit the covered bed: ${coveredExp.toFixed(2)} vs open ${openExp.toFixed(2)}`);
+    sky.dispose();
+  });
+
   t.test('every storm in data/storms/ loads and validates', () => {
     // loadStorm throws on invalid, so reaching here with all of them is the pass
     assert(Object.keys(storms).length === STORMS.length, 'a storm failed to load');

web/world/js/tests/d.test.js

@@ -13,6 +13,7 @@
  */
 import { PlayerSim, STATES, TUNE, clipFor } from '../player.sim.js';
 import { Interact, wireYardActions } from '../interact.js';
+import { createBroom, BROOM_TUNE } from '../broom.js';
 import { assert, assertEq, assertClose, assertLess, fixedLoop } from '../testkit.js';
 import { FIXED_DT } from '../contracts.js';
 import { loadStorm, createWind } from '../weather.js';
@@ -517,6 +518,157 @@ export default async function run(t) {
     assertEq(p.climbY, 0);
   });
 
+  // ---------------------------------------------------------------- the greyed-prompt surface
+  t.test('prompt: a usable action always wins over a reason', () => {
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    const it = new Interact();
+    it.register({ id: 'gated', pos: { x: 0, y: 0, z: 0 }, radius: 3, canUse: () => false,
+      label: 'hands full' });
+    it.register({ id: 'open', pos: { x: 0, y: 0, z: 1 }, radius: 3, label: 'take a spare' });
+    const v = it.visible(p);
+    assertEq(v.target.id, 'open', 'the thing you CAN do is the thing you are offered');
+    assert(v.usable, 'and it is offered, not explained');
+  });
+
+  t.test('prompt: an unavailable action explains itself instead of vanishing', () => {
+    // The bug this fixes, found by playing: walk to the shed table carrying the ladder and the
+    // prompt disappeared, because canUse filtered the target out of nearest() before its label
+    // could ever say "hands full". No prompt reads as a broken game; a greyed one reads as a rule.
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    const it = new Interact();
+    it.register({ id: 'spare_table', pos: { x: 0, y: 0, z: 0 }, radius: 3,
+      label: (pl) => (pl.carrying ? 'hands full' : 'take a spare'),
+      canUse: (pl) => !pl.carrying });
+
+    assertEq(it.visible(p).label, 'take a spare', 'empty-handed: an offer');
+    assert(it.visible(p).usable);
+
+    p.carrying = 'ladder';
+    const v = it.visible(p);
+    assert(!!v, 'carrying something, the prompt must NOT vanish');
+    assertEq(v.label, 'hands full', 'it says why');
+    assert(!v.usable, 'and is flagged unusable so the HUD can grey it');
+    assertEq(it.nearest(p), null, 'while nearest() — what E acts on — still correctly refuses it');
+  });
+
+  t.test('prompt: step() reports usable so the HUD can grey the radial', () => {
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    const it = new Interact();
+    it.register({ id: 'x', pos: { x: 0, y: 0, z: 0 }, radius: 3, holdSecs: 1, label: 'do it',
+      canUse: (pl) => !pl.carrying });
+    p.carrying = 'broom';
+    let r = it.step(DT, 0, p, true);
+    assert(!r.usable, 'unusable');
+    assertEq(r.progress, 0, 'and no radial creeps up on an action that cannot run');
+    p.carrying = null;
+    r = it.step(DT, 0.1, p, true);
+    assert(r.usable, 'usable once the hands are free');
+  });
+
+  // ---------------------------------------------------------------- the broom (SPRINT5 §Lane D-1)
+  // Lane B's ponding isn't landed yet, so this stub is the seam I posted in THREADS:
+  // ponds -> [{node, mass, pos}], drainPondAt(node) -> kg dumped.
+  const stubRig = (ponds = []) => ({
+    ponds,
+    pondMass: () => ponds.reduce((s, p) => s + p.mass, 0),
+    drainPondAt(node) {
+      const p = ponds.find((x) => x.node === node);
+      if (!p) return 0;
+      const kg = p.mass;
+      p.mass = 0;                       // B's sail springs back on its own once the weight is gone
+      return kg;
+    },
+  });
+
+  t.test('broom: is a third carry type and queues behind the same hands', () => {
+    const p = new PlayerSim();
+    assertEq(p.pickUp('broom'), true, 'take the broom');
+    assertEq(p.pickUp('spare'), false, 'no spare as well');
+    assertEq(p.pickUp('ladder'), false, 'no ladder as well');
+    assertEq(clipFor(p), 'CarryIdle', 'and you read as carrying');
+    assertEq(p.drop(), 'broom');
+  });
+
+  t.test('broom: refuses to poke thin air, and refuses without the broom', () => {
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    const it = new Interact();
+    const rig = stubRig([]);                                   // nothing pooling
+    const b = createBroom(null, { heightAt: () => 0 }, it, p, () => rig);
+    p.carrying = 'broom';
+    assertEq(b.targetPond(), null, 'no pond, nothing to poke');
+    assertEq(it.nearest(p), null, 'and no offer');
+    b.dispose();
+  });
+
+  t.test('broom: poke drains the pond Lane B reports, and the water lands on YOU', () => {
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    const it = new Interact();
+    const rig = stubRig([{ node: 44, mass: 30, pos: { x: 0, y: 2.6, z: 0 } }]);
+    const b = createBroom(null, { heightAt: () => 0 }, it, p, () => rig);
+    p.carrying = 'broom';
+
+    const pond = b.targetPond();
+    assert(!!pond, 'standing under the belly, there is a pond to poke');
+    assertEq(it.nearest(p).id, 'broom_poke', 'and the broom is offered');
+    assert(/30 kg/.test(it.labelOf(it.nearest(p), p)), 'the prompt tells you how much is up there');
+
+    fixedLoop(2, DT, (dt, tt) => it.step(dt, tt, p, true));
+    assertEq(rig.pondMass(), 0, 'the pond is gone');
+    assert(p.events.some((e) => e.type === 'doused' && e.kg === 30), 'and it went over the player');
+    b.dispose();
+  });
+
+  t.test('broom: the size of the pond decides the size of the joke', () => {
+    const mk = (kg) => {
+      const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+      const it = new Interact();
+      const rig = stubRig([{ node: 1, mass: kg, pos: { x: 0, y: 2.6, z: 0 } }]);
+      const b = createBroom(null, { heightAt: () => 0 }, it, p, () => rig);
+      p.carrying = 'broom';
+      fixedLoop(2, DT, (dt, tt) => it.step(dt, tt, p, true));
+      b.dispose();
+      return p.state;
+    };
+    assertEq(mk(5), 'idle', 'a splash just makes you wet');
+    assertEq(mk(BROOM_TUNE.staggerKg + 5), 'stagger', 'half a bathtub breaks your stride');
+    assertEq(mk(BROOM_TUNE.staggerKg * 2 + 5), 'knocked', 'a bathtub puts you on your back');
+  });
+
+  t.test('broom: picks the heaviest pond overhead, not the nearest', () => {
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    const it = new Interact();
+    const rig = stubRig([
+      { node: 1, mass: 8, pos: { x: 0.2, y: 2.6, z: 0 } },       // nearer
+      { node: 2, mass: 90, pos: { x: 1.4, y: 2.6, z: 0 } },      // heavier — the one breaking the rig
+    ]);
+    const b = createBroom(null, { heightAt: () => 0 }, it, p, () => rig);
+    p.carrying = 'broom';
+    assertEq(b.targetPond().node, 2, 'if you are under two, you meant the one about to kill you');
+    b.dispose();
+  });
+
+  t.test('broom: a pond out of reach overhead cannot be poked from the grass', () => {
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    const it = new Interact();
+    const rig = stubRig([{ node: 1, mass: 40, pos: { x: 0, y: 9, z: 0 } }]);   // 9 m up
+    const b = createBroom(null, { heightAt: () => 0 }, it, p, () => rig);
+    p.carrying = 'broom';
+    assertEq(b.targetPond(), null, 'a broom is 1.4 m long, not 9');
+    b.dispose();
+  });
+
+  t.test('broom: self-skips cleanly until Lane B lands drainPondAt', () => {
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    const it = new Interact();
+    const noPonding = { };                                     // a rig with no ponding at all
+    const b = createBroom(null, { heightAt: () => 0 }, it, p, () => noPonding);
+    p.carrying = 'broom';
+    assertEq(b.ponds().length, 0, 'no ponds reported');
+    fixedLoop(2, DT, (dt, tt) => it.step(dt, tt, p, true));
+    assert(!p.events.some((e) => e.type === 'doused'), 'nothing fires, nothing throws');
+    b.dispose();
+  });
+
   // ---------------------------------------------------------------- solids collision
   t.test('collision: solids stop you, and the pushout slides you along them', () => {
     // one box: the yard's north wall, x -8..8, z -16..-10, waist high

web/world/js/tests/e.test.js

@@ -280,6 +280,28 @@ export default async function run(t) {
     }
   });
 
+  // glTF has no node-visibility flag and Blender's hide_render does NOT survive
+  // the export — every node arrives visible:true. That shipped as a real bug
+  // from Sprint 1 to Sprint 6: garden_bed drew full + tattered + dead
+  // superimposed, and the asserts missed it because they only checked the nodes
+  // EXISTED. So the flag rides in extras, and this pins the flag, not the node.
+  t.test('optional nodes carry hidden_by_default — hide_render does not export', () => {
+    const bed = loaded.get('garden_bed')?.scene;
+    assert(bed, 'garden_bed did not load');
+    const on = ['plants_full'], off = ['plants_tattered', 'plants_dead'];
+    for (const n of on) {
+      assert(!bed.getObjectByName(n).userData?.hidden_by_default,
+        `${n} should start visible — it's the default state`);
+    }
+    for (const n of off) {
+      assert(bed.getObjectByName(n).userData?.hidden_by_default === true,
+        `${n} must carry hidden_by_default or the bed renders all three wilt states at once`);
+    }
+    const glow = loaded.get('house_yardside')?.scene.getObjectByName('window_glow');
+    assert(glow?.userData?.hidden_by_default === true,
+      'window_glow must carry hidden_by_default or the house is lit at noon');
+  });
+
   // One GLB carries three wilt states as siblings; Lane A toggles .visible
   // rather than reloading, so all three have to be present at once.
   t.test('garden_bed carries all 3 damage states in one GLB', () => {

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

@@ -504,6 +504,101 @@ export function weatherCases(storms) {
     assert(!validateStorm(hot, 'x').ok, 'validator accepted rain intensity above 1 — the scale is peakMmPerHour, not the curve');
   });
 
+  // ---- 11. hail (SPRINT5 decision 13) ----
+  // The wind-side of hail: intensity timeline and its ramp across the campaign.
+  // The garden-damage half (steep shadow, ≥2× rig response) needs skyfx +
+  // SailRig, so it lives in c.test.js.
+  test('hail ramps across the campaign: none / mild / a wild-night burst', () => {
+    const peakAndArea = (def) => {
+      const f = createWindField(def);
+      let peak = 0, peakT = 0, area = 0;
+      for (let t = 0; t <= f.duration; t += DT) {
+        const h = f.hailAt(t);
+        if (h > peak) { peak = h; peakT = t; }
+        area += h * DT;
+      }
+      return { peak, peakT, area };
+    };
+    const g = peakAndArea(storms.storm_01_gentle);
+    const m = peakAndArea(storms.storm_03_southerly);
+    const w = peakAndArea(storms.storm_02_wildnight);
+    metrics['storm_01.hailPeak'] = +g.peak.toFixed(2);
+    metrics['storm_03.hailPeak'] = +m.peak.toFixed(2);
+    metrics['storm_02.hailPeak'] = +w.peak.toFixed(2);
+    metrics['storm_02.hailSeconds'] = +w.area.toFixed(1);
+
+    assert(g.peak === 0, `the gentle storm hailed (${g.peak}) — storm_01 must have no hail`);
+    assert(m.peak > 0.2 && m.peak < 0.8, `storm_03 hail peak ${m.peak.toFixed(2)} — wanted a mild middle rung`);
+    assert(w.peak >= 0.95, `storm_02 hail peak only ${w.peak.toFixed(2)} — the wild night needs a proper burst`);
+    assert(w.area > m.area * 3, 'the wild night should carry vastly more hail than the mild storm');
+  });
+
+  test('storm_02 hail lands ON the southerly change', () => {
+    const change = (storms.storm_02_wildnight.events.find((e) => e.type === 'windchange')).t;
+    const f = createWindField(storms.storm_02_wildnight);
+    // find the authored-burst peak (near the change), not just any gust-synced tick
+    let peak = 0, peakT = 0;
+    for (let t = change - 3; t <= change + 8; t += DT) {
+      const h = f.hailAt(t);
+      if (h > peak) { peak = h; peakT = t; }
+    }
+    assert(peak >= 0.95, `hail near the change only reached ${peak.toFixed(2)}`);
+    assert(Math.abs(peakT - change) < 6, `hail peaks at t=${peakT.toFixed(1)}, the change is at t=${change} — they should coincide`);
+  });
+
+  test('hail is silent through a gust telegraph and rides its own gust', () => {
+    // the gust-synced bursts must not fire during the telegraph window, or hail
+    // would arrive before the gust it belongs to — the opposite of the drama
+    const def = storms.storm_02_wildnight;
+    const f = createWindField(def);
+    const thresh = def.hail.withGustsAbove;
+    for (const g of f.gusts) {
+      if (g.pow < thresh) continue;
+      // during the telegraph (first GUST.TELEGRAPH s) the gust-synced part is 0.
+      // an authored burst may still overlap, so only check gusts clear of t=55±8.
+      if (Math.abs(g.t0 - 55) < 10) continue;
+      for (let t = g.t0 + 0.05; t < g.t0 + GUST.TELEGRAPH; t += DT) {
+        assert(f.hailAt(t) < 1e-9, `hail fell during a gust's telegraph at t=${t.toFixed(2)} — it should wait for the gust`);
+      }
+    }
+  });
+
+  test('hail does not re-time the storm (zero draws of its own)', () => {
+    const base = storms.storm_02_wildnight;
+    const a = createWindField(base);
+    for (const gi of [0, 0.3, 0.85, 1]) {
+      const d = JSON.parse(JSON.stringify(base));
+      d.hail.gustBurstIntensity = gi;
+      d.hail.bursts = [];       // even removing the authored burst mustn't move gusts
+      const b = createWindField(d);
+      assert(a.gusts.length === b.gusts.length, `hail change moved the gust count`);
+      a.gusts.forEach((g, i) => {
+        assert(g.t0 === b.gusts[i].t0 && g.pow === b.gusts[i].pow, `hail change re-timed gust ${i}`);
+      });
+      assert(a.speedAt(3, -2, 47.3) === b.speedAt(3, -2, 47.3), 'hail change altered the wind');
+    }
+  });
+
+  test('validator rejects broken hail blocks', () => {
+    const base = () => JSON.parse(JSON.stringify(storms.storm_02_wildnight));
+    const cases = [
+      ['size 0', (d) => { d.hail.size = 0; }],
+      ['size huge', (d) => { d.hail.size = 20; }],
+      ['intensity > 1', (d) => { d.hail.bursts[0].intensity = 1.5; }],
+      ['negative fade', (d) => { d.hail.bursts[0].fade = -1; }],
+      ['burst after the storm', (d) => { d.hail.bursts[0].t = 200; }],
+      ['gustBurstIntensity > 1', (d) => { d.hail.gustBurstIntensity = 2; }],
+      ['neither bursts nor gusts', (d) => { delete d.hail.bursts; delete d.hail.withGustsAbove; }],
+    ];
+    for (const [label, mutate] of cases) {
+      const d = base(); mutate(d);
+      assert(!validateStorm(d, 'broken').ok, `validator accepted broken hail: ${label}`);
+    }
+    // a hail-free storm (no block at all) must still validate
+    const none = base(); delete none.hail;
+    assert(validateStorm(none, 'nohail').ok, 'validator rejected a storm with no hail — hail is optional');
+  });
+
   return { cases, metrics };
 }
 

web/world/js/weather.core.js

@@ -167,6 +167,27 @@ export function buildGustTimeline(def, seed) {
   return out;
 }
 
+// ---------- hail (SPRINT5 decision 13) ----------
+// Hail, not rain, carries the garden score. Rain honestly walks under a sail
+// (droplets terminal ~9 m/s, so a 30 m/s crosswind blows them in at atan(30/9)
+// ≈ 73° off vertical — nearly sideways), which is why a perfect rig scored 54%
+// vs 48% for no rig at all. Hailstones are dense: terminal velocity ~20 m/s for
+// a 1 cm stone, so the SAME 30 m/s gale only leans them atan(30/20)≈56° — and
+// that overstates it, because a dense stone's drag couples weakly to the
+// horizontal air, so observed hail lean tops out ~15-20°. Steep hail is blocked
+// by overhead cloth even in a gale, so the garden score becomes rig-responsive
+// without faking the rain physics. The steepness lives in skyfx.hailVelocity();
+// the intensity timeline lives here.
+
+/** Envelope of one authored hail burst at local time `dt` (s since it began). */
+export function hailBurstEnvelope(dt, ramp, hold, fade, peak) {
+  if (dt <= 0) return 0;
+  if (dt < ramp) return peak * (dt / ramp);
+  if (dt < ramp + hold) return peak;
+  if (dt < ramp + hold + fade) return peak * (1 - (dt - ramp - hold) / fade);
+  return 0;
+}
+
 // ---------- the field ----------
 /**
  * @param {object} def   parsed storm JSON (see data/storms/*.json)
@@ -189,6 +210,19 @@ export function createWindField(def, opts = {}) {
   const gd = def.gusts || {};
   const downFrac = gd.downdraftOfTotal ?? gd.downdraft ?? DEFAULT_DOWNDRAFT;
 
+  // Hail bursts: authored ones from the JSON, plus one synced to every gust at
+  // or above `withGustsAbove` power — so the biggest gusts arrive WITH hail, the
+  // storm's worst moment landing all at once. Gust-synced bursts key off the
+  // deterministic gust timeline and draw NO randomness, so tuning hail can't
+  // re-time the storm (same guarantee as the downdraft).
+  const hailDef = def.hail || null;
+  const hailBursts = (hailDef && Array.isArray(hailDef.bursts))
+    ? hailDef.bursts.map((b) => ({
+        t: b.t, ramp: b.ramp ?? 0.8, hold: b.hold ?? 3, fade: b.fade ?? 1.5,
+        intensity: b.intensity ?? 1,
+      }))
+    : [];
+
   let shelters = [];
 
   /** Spatially-uniform part: base curve + every gust envelope live at t. */
@@ -398,6 +432,42 @@ export function createWindField(def, opts = {}) {
       return Math.min(1, Math.max(0, r.intensity ?? 0));
     },
 
+    /**
+     * 0..1 hail intensity at time t (SPRINT5 decision 13). Max over every live
+     * burst — authored plus gust-synced — because "how hard is it hailing right
+     * now" is a level, not a sum; two overlapping bursts don't hail at 1.6×.
+     * Zero for a storm with no `hail` block, so storm_01 simply never hails.
+     */
+    hailAt(t) {
+      if (!hailDef) return 0;
+      let h = 0;
+      for (let i = 0; i < hailBursts.length; i++) {
+        const b = hailBursts[i];
+        if (t <= b.t || t >= b.t + b.ramp + b.hold + b.fade) continue;
+        const v = hailBurstEnvelope(t - b.t, b.ramp, b.hold, b.fade, b.intensity);
+        if (v > h) h = v;
+      }
+      const thresh = hailDef.withGustsAbove;
+      if (thresh != null) {
+        const gi = hailDef.gustBurstIntensity ?? 0.8;
+        for (let i = 0; i < gusts.length; i++) {
+          const g = gusts[i];
+          if (g.pow < thresh) continue;
+          if (t <= g.t0 || t >= g.endAt) continue;
+          // reuse the gust envelope: silent through the telegraph, then it hits
+          // as the gust ramps and holds — the hail lands WITH the gust.
+          // gustEnvelope(gt, pow) returns pow×fraction, so passing gi as "pow"
+          // gives the intensity-scaled 0..gi envelope directly.
+          const v = gustEnvelope(t - g.t0, gi);
+          if (v > h) h = v;
+        }
+      }
+      return h > 1 ? 1 : h;
+    },
+
+    /** Stone-size scalar (audio pitch, visual scale, damage weight). Default 1. */
+    get hailSize() { return hailDef ? (hailDef.size ?? 1) : 0; },
+
     /**
      * Rain rate in REAL-WORLD mm/hr. Same curve as rainAt(), with physical units
      * on it — `rainAt` stays 0..1 because it drives drop count and opacity, and a
@@ -520,5 +590,34 @@ export function validateStorm(def, name = 'storm') {
     }
   }
 
+  // ---- hail (SPRINT5 decision 13) ----
+  if (def.hail) {
+    const hd = def.hail;
+    if (hd.size != null && (!Number.isFinite(hd.size) || hd.size <= 0 || hd.size > 5)) {
+      bad(`hail.size must be a positive scalar up to ~5 (stones bigger than golf balls break the metaphor) — got ${hd.size}`);
+    }
+    if (hd.withGustsAbove != null && !Number.isFinite(hd.withGustsAbove)) {
+      bad('hail.withGustsAbove must be a finite gust-power threshold in m/s');
+    }
+    if (hd.gustBurstIntensity != null && (!(hd.gustBurstIntensity >= 0) || hd.gustBurstIntensity > 1)) {
+      bad(`hail.gustBurstIntensity must be 0..1 — got ${hd.gustBurstIntensity}`);
+    }
+    // A storm with a hail block but nothing to fire it never hails — that's a
+    // typo, not a design, so say so rather than shipping silent hail.
+    if (!Array.isArray(hd.bursts) && hd.withGustsAbove == null) {
+      bad('hail block has neither bursts[] nor withGustsAbove — it would never hail');
+    }
+    for (const b of hd.bursts || []) {
+      if (!Number.isFinite(b.t)) bad(`hail burst ${JSON.stringify(b)} has no finite t`);
+      if (b.t + 0 > (def.duration ?? 90)) bad(`hail burst at t=${b.t} starts after the storm ends`);
+      for (const k of ['ramp', 'hold', 'fade']) {
+        if (b[k] != null && !(b[k] >= 0)) bad(`hail burst at t=${b.t} has a negative ${k}`);
+      }
+      if (b.intensity != null && (!(b.intensity >= 0) || b.intensity > 1)) {
+        bad(`hail burst at t=${b.t} intensity must be 0..1 — got ${b.intensity}`);
+      }
+    }
+  }
+
   return { ok: errors.length === 0, errors };
 }

web/world/js/weather.js

@@ -87,6 +87,12 @@ export function createWind(def, opts = {}) {
     /** 0..1 rain intensity — drives drop count and opacity. */
     rainAt(t) { return field.rainAt(t); },
 
+    /** 0..1 hail intensity (SPRINT5 decision 13). Zero for a hail-free storm. */
+    hailAt(t) { return field.hailAt(t); },
+
+    /** Stone-size scalar — audio pitch, visual scale, damage weight. */
+    get hailSize() { return field.hailSize; },
+
     /** Rain rate in real-world mm/hr. Ponding (decision 10) reads this. */
     rainMmPerHour(t) { return field.rainMmPerHour(t); },