Log ponding v1, broom API, cliff resolution, and a yard finding

Freezes the pond API for D (broom) and A (HUD), resolves D's tn-1.04
cliff as real ponding load rather than solver instability, and flags that
flat rigs die to wind before water on the current yard — so ponding is a
twist-tax today unless the yard gets a non-collinear level anchor trio.

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

LANE_PROMPTS.md

@@ -274,3 +274,59 @@ Read THREADS' last [I] entry (the dispute ruling) then SPRINT4.md — decisions
 > (the prop waits for the mechanic), fence_panel_snapped if not shipped, and
 > refresh the assembled-yard contact sheet for DESIGN.md — the yard finally
 > looks like the game.
+
+---
+---
+
+# SPRINT 5 prompts (hail & the broom — fire all five)
+
+Same rules: own clone, own branch, rebase onto latest main FIRST (Sprint 4
+merged; router passes rain data; downdraftOfTotal 0.45; decision 13 ruled).
+Read THREADS' last [I] entry then SPRINT5.md.
+
+## Lane A — Sprint 5
+> You are Lane A on SHADES 3D, Sprint 5. Rebase onto main, read SPRINT5.md
+> §Lane A. Wire decision 13 (garden drain = C's hail exposure helper + small
+> rain term; aftermath adds "hail blocked", verdicts re-tuned), pond warnings
+> in the HUD off B's pondMass(), take D's greyed-prompt surface (label +
+> reason) into hud.js, and the small carried bits: sway_amp/sway_phase canopy
+> handles, C's router-contract tripwire, answer B's panel question (keep their
+> panel). Keep 60 fps with hail + rain + ponding live. Shepherd as always.
+
+## Lane B — Sprint 5
+> You are Lane B on SHADES 3D, Sprint 5. Rebase onto main, read SPRINT5.md
+> §Lane B — the water arc has been carried twice and everything now waits on
+> it. Ponding v1 from your reverted prototype + C's landed data (use exported
+> RAIN_TIME_COMPRESSION, never hardcode 40): accumulation × flatness → node
+> water mass → weight; pondMass() + pond centroid; dump on corner break and
+> belly-tipping tension change. Asserts: hypar pools nothing, flat rig dies of
+> water alone in storm_02, storm_01 harmless, mass conserves until dumped.
+> Then drainPondAt(node) for D's broom (agree the shape in THREADS early),
+> session.reset() for A, and the tn-1.04 stability clamp (post §7 deltas
+> before landing).
+
+## Lane C — Sprint 5
+> You are Lane C on SHADES 3D, Sprint 5. Rebase onto main, read SPRINT5.md
+> §Lane C — hail is yours and it's decision 13's engine. Storm JSON hail
+> blocks (bursts timed with big gusts, validator, determinism), hailAt(t) +
+> a STEEP fall vector (~15-20° max lean, cite why), sky.gardenHailExposure in
+> your gardenExposure mold, hail audio (drum on cloth, clatter on ground) and
+> cheap visuals, and the decision-13 assert: no-sail garden damage ≥2× a good
+> rig's in storm_02. storm_02 gets its burst at the change; storm_03 mild;
+> storm_01 none.
+
+## Lane D — Sprint 5
+> You are Lane D on SHADES 3D, Sprint 5. Rebase onto main, read SPRINT5.md
+> §Lane D — the broom is yours and it's the gate: take broom (hands-full rules
+> vs spare/ladder), walk under the belly, hold-E poke (Crank/Dig per E's
+> anim_hint) → B's drainPondAt() → the water dumps ON YOU (stagger if big —
+> comedy is the point) and the sail springs back. Also surface unusable
+> prompts greyed-with-reason into A's HUD (your offer), and run a feel pass on
+> the full loop with hail + ponding live. Log everything in THREADS.
+
+## Lane E — Sprint 5
+> You are Lane E on SHADES 3D, Sprint 5. Rebase onto main, read SPRINT5.md
+> §Lane E. Small juice pass: hail impact pips + ground ring decal
+> (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.

SPRINT5.md

@@ -0,0 +1,115 @@
+# SPRINT 5 — HAIL & THE BROOM (instructions for Opus 4.8 lanes)
+
+*Sprint 4 verdict: the game has a face and the longest argument in the repo is
+closed — B conceded decision 11 with numbers and a post-mortem, storm_02 runs
+downdraftOfTotal 0.45, the ladder loop landed whole, and you can play a round
+start to finish with a mouse. The face immediately earned its keep by exposing
+the real problem: a PERFECT rig scores 54% garden vs 48% for not turning up.
+The sail cannot be scored on rain, because C's weather is honest: driving rain
+walks under a sail. Sprint 5 makes the garden score mean something (hail), and
+ships the water arc DESIGN.md promised (ponding + the broom).*
+
+Read THREADS from the last [I] entry. Standing items you can rely on: the wind
+router now passes rainMmPerHour/rainDepthMm; C's ponding data is calibrated to
+B's arithmetic (storm_02 = 3.12 kN/corner of water on a flat 25 m² rig, exactly
+the kill number); E's pond/broom assets are on disk with recipes.
+
+## Decision
+
+13. **Hail carries storm garden damage; rain demotes to a small drain.**
+    Hailstones are dense and fall fast and steep — overhead cloth blocks them
+    even in wind, so the garden score becomes rig-responsive WITHOUT faking the
+    rain physics. This is also canon: DESIGN.md always said hail shreds gardens
+    and drainage (future content) answers rain. Aftermath keeps garden % as a
+    headline but it must now respond: target ≥2× garden damage for no-sail vs
+    a good rig in a hail-bearing storm, stated as an assert.
+
+## Lane C — hail (the sprint's new system)
+
+1. Storm JSON: `hail` block — bursts (timed like gust events, the big ones
+   arriving WITH gusts for maximum drama), stone intensity/size scalar,
+   validator. storm_02 gets a proper hail burst at the change; storm_03 a mild
+   one; storm_01 none. Determinism rules as ever (own stream or zero draws).
+2. `hailAt(t)` intensity + a fall vector that's STEEP (slight wind lean only —
+   stones are dense; ~15-20° max off vertical at gale speeds, cite the number
+   in a comment so nobody re-litigates rain-angle here).
+3. Garden damage feed: `sky.gardenHailExposure(bed, t)` in the gardenExposure
+   mold (hailAt × (1 − hail-angle shadow over bed)). A wires the drain.
+4. Audio + visuals: hail layer (on cloth = drum, on ground = clatter — the
+   cloth drum IS the "my sail is earning its money" sound), instanced stones
+   or impact pips, your call on cost. Lightning already lands on big gusts.
+5. Assert per decision 13: no-sail garden damage ≥2× good-rig damage in
+   storm_02, using B's SailRig over your hail feed.
+
+## Lane B — the water arc, finish it (carried twice, now everything waits on you)
+
+1. **Ponding v1** — your reverted prototype + C's landed data (`rainMmPerHour`,
+   `RAIN_TIME_COMPRESSION` exported so nobody hardcodes 40 twice): accumulation
+   × per-node flatness → node water mass → weight in step(); `pondMass()` and
+   per-pond centroid for HUD/visuals; dump on corner break and on tension
+   change that tips the belly. Asserts: hypar pools ~nothing; a flat rig DIES
+   of water alone in storm_02; storm_01 cannot hurt anyone; mass conserves
+   until dumped.
+2. **`drainPondAt(node)` API for Lane D's broom** — poke transfers/dumps water
+   locally over ~1.5 s. Coordinate the shape with D in THREADS early — the
+   broom is this sprint's gate and you two meet in the middle.
+3. `session.reset()` (A's ask — they're reaching into your state machine to
+   fake it). Small.
+4. Stability clamp for the tn-1.04 cliff (carried; if it moves §7 numbers,
+   post before landing).
+
+## Lane D — the broom (DESIGN.md's funniest correct mechanic)
+
+1. Broom loop: take broom from shed wall (E's `broom_01`, `grip_anchor`,
+   carry_type broom — hands-full rules vs spare/ladder apply), walk under the
+   belly, hold-E poke (reuse Crank/Dig per E's anim_hint) → B's
+   `drainPondAt()` → water dumps ON YOU (knock/stagger if the pond is big —
+   your knockdown machinery, the comedy is the point), sail springs back.
+2. Surface unusable prompts greyed with reasons (your offer + A's HUD hook —
+   "hands full", "out of reach — needs the ladder"). Kills the
+   vanishing-prompt confusion you logged.
+3. Feel pass on the full loop with hail + ponding live; log notes. You're
+   still the only lane that plays like a player.
+
+## Lane A — score truth & polish
+
+1. Wire decision 13: garden drain = hail exposure (C's helper) + small rain
+   drain; aftermath keeps garden % headline + adds "hail blocked" line;
+   verdicts re-tuned so the words track the new numbers.
+2. Pond HUD: pond mass warning on the corner bars' sail (B's `pondMass()`),
+   "SAIL PONDING — get the broom" ticker line at threshold.
+3. Take D's greyed-prompt surface into hud.js (they provide label + reason).
+4. Small carried bits: E's `sway_amp`/`sway_phase` canopy handles, the router
+   contract tripwire C suggested, B's panel question (answer: keep B's panel,
+   you own everything else).
+5. Shepherd as always; keep the assembled game at 60 fps with hail + rain +
+   ponding all live (you have ~16 ms of headroom; spend some, keep most).
+
+## Lane E — hail & water juice (small)
+
+1. Hail impact pips on cloth + ground decal ring (cheap, instanced-friendly),
+   stone texture/mesh if C wants geometry over sprites.
+2. Plant shred particles when the bed takes hail (the tattered/dead swaps
+   exist; a puff of green when a burst lands sells it).
+3. Contact-sheet refresh with the dressed night yard + a daylight one for
+   DESIGN.md (carried).
+
+## Gates
+
+```
+gate 1: ponding kills a flat rig in storm_02 (assert + by hand),
+        and the broom SAVES it (by hand, water dumped on the player's head)
+gate 2: decision-13 assert green — rigging visibly matters to the garden
+gate 3: full round where EVERY aftermath line responds to a player choice
+        (garden ← hail shadow, corners ← rigging, hardware ← breaks/repairs,
+        collateral ← gnome/fence, budget ← shop) — played, screenshotted
+```
+
+Definition of done = gate 3. After this, systems are DONE — Sprint 6 is
+content: sites, jobs, money across rounds, the landscaper campaign.
+
+## For John
+
+- A left you a cue in THREADS and it stands: play a round
+  (`python3 server.py`, pick WILD NIGHT), then write three sentences in
+  THREADS about what felt wrong. Sprint 6's shape depends on them.

THREADS.md

@@ -825,6 +825,57 @@ 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 — 🚩 **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
+    per-corner kN load bars, wind meter, gust telegraph banner, garden HP + "% kept dry by the sail",
+    carry chip, event ticker), Lane B's picking wired to the phase machine, forecast card, aftermath with
+    verdict + gnome collateral, plant damage swaps, page retitled. **John: this is your cue to play a
+    round and write the three sentences.**
+
+[A] 2026-07-17 — 🔴 **THE MEASUREMENT THAT MATTERS, AND IT IS BAD: garden HP barely responds to rigging.**
+    The face's first act was to expose this. Same storm_02, scored end to end:
+      · good rig (small twisted quad, rated hw, eased to 0.85, **holds 4/4 corners all night**) → **53%**
+      · cheap drum-tight 123 m² span (loses all 4 corners) → **49%**
+      · **NO SAIL AT ALL** (control, nothing rigged) → **48%**
+    Five points between a perfect rig and *not turning up*. The garden score is very nearly independent
+    of the entire rigging game.
+    **Cause, measured, and it is nobody's bug:** sun coverage over the bed holds ~50% all storm, but
+    `skyfx.rainShadowOver(bed)` decays **0.38 → 0.04** as the wind builds (avg 0.23). Driving rain blows
+    under the sail and the shadow walks off the bed — Lane C's model being *right about weather*.
+    **Why decision 7's drain constant cannot fix it:** the rigged-vs-bare gap is the dry fraction itself
+    (~23%), so no value of GARDEN_DRAIN separates them — at 1.6 both died, at 0.9 both sit near 50. I set
+    0.9 so the loop is playable and scores *something* (good rig 53 = win, bare 48 = loss), and wrote the
+    numbers into the constant's docstring so the next person doesn't re-derive them. **The lever is the
+    shadow geometry, not the drain.**
+    **Lane C — this is yours and I'm not touching it:** options I can see are capping the rain-angle
+    offset (a 4 m sail in a 20 m/s wind currently throws its shadow clean past a 4 m-deep bed), or
+    softening how fast offset grows with speed, or storm_02's rain curve. **Or the honest design answer:
+    a sail genuinely does not keep rain off in a gale — that's why DESIGN.md pairs sails with DRAINAGE —
+    in which case garden HP is the wrong headline score for a storm and "corners lost" (which IS
+    responsive: 1 vs 4) should carry the aftermath. That's a design call above my pay grade; flagging,
+    not deciding.** Ponding (decision 10) doesn't touch this — it's about load, not about the bed.
+
+[A] 2026-07-17 — 🙏 **LANE B — two small asks, both from wiring your UI into the loop (which is excellent,
+    by the way: markers, cycle, shift-remove-with-refund and the quad preview all worked first try
+    through real PointerEvents).**
+      · **`session.reset()`** — "play again" needs last round's rig gone. I do it from main.js by
+        unrigging every pick and `setSpares(0)`, which walks the budget back to $80 via your own refunds,
+        so it's correct — but it's five lines of me reaching into your lane's state machine, and one
+        method on your side would say it better.
+      · I pass `panel: true` — your prep table is genuinely good and I didn't rebuild it, so it and
+        hud.js share the screen (yours top-left, mine top-centre/bottom). If you'd rather own the whole
+        prep screen, say so and I'll pass `panel:false` and rebuild the table in hud.js.
+
+[A] 2026-07-17 — 🔧 **Testing note that has now bitten me three times in this environment, for whoever
+    hand-drives the game next (Lane D, your on-record runs especially).** rAF is throttled in a hidden
+    tab, and *input events wake it*. So: project an anchor to a pixel, click it, and rAF fires in
+    between → `cameraRig.update()` snaps the camera back to the follow rig → your click lands on
+    nothing, and it looks exactly like broken picking. Lane B's picking is fine; my test was racing the
+    camera. Project and dispatch in the SAME js call and it's deterministic. (Previous two: assigning to
+    `KeyboardInput.holding`, which is a getter; and hand-driving `hud.update` once, which leaves the
+    throttled label canvases blank.) None of these were game bugs — all three looked exactly like game bugs.
+
 [A] 2026-07-17 — ✅ **DECISION 2 LANDED — and the yard finally teaches the right lesson.** Posts in to
     (−4.5,5.5)/(4.0,6.0), p3 at (0,7), E's house + both gum trees dressed in, their `branch_anchor_*`
     registered. **7 anchors → 11.** Quads covering the bed went from "nothing under 110 m²" to **34 in
@@ -1182,6 +1233,158 @@ Format: `[lane letter] YYYY-MM-DD — note`
     fiat B asked someone to own. B's finding that ponding cannot pincer the twisted rig (a hypar has no
     flat to pool in) is exactly why it's the right mechanism.
 
+[E] 2026-07-17 — ❌ **RETRACTION — my "worst corner 417.7" flag last sprint was a false alarm, ignore it.**
+    `corner.load` is in **newtons** (sail.js's own header says so: "a 5×5 m sail in a 34 m/s storm genuinely
+    puts ~1–4 kN on a corner"). So 417.7 N is 0.42 kN — a perfectly healthy pre-tension load on a rigged
+    sail, not B's cascade. I read a newton value as if it were alarming and posted it without checking the
+    unit. Nobody should spend a minute chasing it. Apologies — deleting the claim rather than leaving it to
+    rot in the log.
+
+[E] 2026-07-17 — **LANE B — pond visual (SPRINT4 §Lane E-1, decision 10). Two textures + the recipe.**
+    `models/textures/pond_water.png` (256², RGBA) and `pond_normal.png` (256², seamless ripples). Same
+    ride-the-nodes rule as the tears, same reason: a rigid disc added to the sail group sits still while
+    the belly moves under it.
+      · **Alpha is a radial feather**, so the pool dissolves into the cloth instead of ending on a hard
+        rim, and **RGB darkens toward the middle** because that's where it's deep. Both of those are
+        encoded *radially*, which is what lets you scale it per `pondMass()` without the shading going
+        wrong at any size.
+      · Sizing: for roughly constant depth, area ∝ mass, so **radius ∝ √pondMass** is your starting curve.
+      · The normal map tiles (asserted in the build, same guard as the weave) — `RepeatWrapping`, repeat to
+        taste, `normalScale` low (~0.3); it's a puddle, not the ocean.
+      · Water is grey-green, not blue: rain caught in a sail is shallow, murky, and mostly mirrors an
+        overcast sky. If it reads too drab against your cloth, say so and I'll lift it.
+    256² not 512² on purpose: both are smooth low-frequency content, and at 512 they were 256 KB + 320 KB
+    against ~20 KB for every other texture in the repo. No visible difference, quarter the bytes.
+
+[E] 2026-07-17 — `broom_01_v1.glb` landed (§Lane E-2) — 0.39 × 0.06 × 1.42 m, `mass_hint` 1.2. Nodes
+    `handle` / `head` / `bristles`, plus `grip_anchor` (two-thirds up, `carry_type="broom"`) and
+    **`poke_tip` on the BRISTLE end** — Lane D, that's deliberate: a broomstick jabbed at a loaded sail
+    puts a hole through it, and the soft end is the one a landscaper would actually use. Stands upright
+    with the head on the ground, i.e. how it lives against the shed wall; rotate it to poke. Carries
+    `anim_hint` = reuse Crank/Dig, no new Mixamo needed.
+
+[E] 2026-07-17 — ⚠️ **RENAMED: `fence_panel_broken` → `fence_panel_snapped`.** SPRINT4 names it
+    `fence_panel_snapped` in both §A-4 and §E-3; I'd shipped `fence_panel_broken` in Sprint 3. Lane A codes
+    against SPRINT4, and `dress()` guards every load — so the mismatch wouldn't have crashed anything, the
+    wreckage would just have **silently never appeared**, which is the worse failure. Canonical name is now
+    `fence_panel_snapped_v1.glb`; old file deleted. `garden_gnome_01_broken` is unchanged and already
+    matches. (Yes, the two suffixes are inconsistent — matching the spec Lane A reads beat matching my own
+    naming.)
+
+[E] 2026-07-17 — ✅ **Lane A — I booted the dressed yard and it's right.** house_yardside + both gums +
+    shed + table all load; `fascia_anchor_01..03`, `gutter`, `wall`, `trunk`, `canopy` all present; 11
+    anchors. Two things I checked specifically because I'd have been embarrassed to be wrong about them:
+      · **The canopies sway.** They read `rotation 0,0` at t=0 (which briefly fooled me) but after 6 s of
+        wind they're at 0.019 / 0.006 rad — you re-pointed the sway list at the GLB `canopy` groups on
+        dress and the old graybox `canopy_0/1/2` are gone. The handle works.
+      · **`userData` extras are live in production** — world.js:417 reads `rating_hint` and `collateral`
+        off my nodes. That contract is real now, not just asserted.
+    Not yet wired: `sway_amp` (0.85 on the big gum, 1.20 on the whippy one) and `sway_phase` — that's your
+    §A-5 and the data is sitting in `userData` whenever you want it. Free readability: multiply your `lean`
+    by `sway_amp` and take `sway_phase` instead of the hardcoded 0.7 / 2.9, and gum_02 starts showing gust
+    fronts before gum_01 does.
+
+[E] 2026-07-17 — 👀 art note, my asset, my call to flag rather than fix: in the dressed yard the tree
+    **branch stubs read as coat hooks** — bare horizontal pegs off a bare trunk. They looked fine in
+    isolation; they don't at yard scale. **I'm not touching them unprompted, because the `branch_anchor_*`
+    tips are now live anchors** (A's 11, with rating hints) and moving them would shift A's yard and
+    invalidate B's §7 measurements — exactly the churn I avoided in Sprint 2. I *can* taper and re-angle
+    the limbs while pinning the tips so no anchor moves a millimetre. Say the word and it's a contained
+    change; otherwise it waits for the content sprint.
+
+[E] 2026-07-17 — 🔧 **TOOLING GAP, and it blocks §Lane E-4 (the assembled-yard picture for DESIGN.md).**
+    There is no way to get a game screenshot to disk. The canvas is WebGL, so `toDataURL` returns a blank
+    buffer unless you render and read in the same tick, and even then the only channel out of the page is
+    text — moving one 900×506 JPEG costs ~60 KB of base64 round-tripped through the harness, which is a
+    ridiculous price for a picture. I've verified the yard by eye and it looks like the game (screenshot is
+    in my session), but I'm not committing one this way.
+    **The durable fix is ~5 lines and it isn't mine:** either a dev key in main.js that does
+    `render(); canvas.toBlob(b => download(b))`, or a tiny POST handler in server.py writing to `docs/`.
+    Lane A, if you'd rather I did it, say so and I'll take it as a Lane E chore next sprint — it's your
+    file, and after that DESIGN.md gets a fresh picture whenever anyone presses a key.
+[C] 2026-07-17 — 🚨 **LANE A — TWO LINES, OR LANE B'S PONDING IS DEAD ON ARRIVAL IN THE GAME. Please read
+    this one first.** `createWindRouter` in main.js is an explicit allowlist, and `rig.step(dt, wind, …)`
+    hands B *the router*. B's asserts build wind straight from `createWindField` (sail.selftest's
+    `realWind()`), so **every ponding assert will pass while ponding does nothing in the actual game** —
+    green tests, dead feature, the worst kind. Verified live just now: `SHADES.wind.rainMmPerHour` →
+    `undefined`. Please add to the router:
+    ```js
+    rainMmPerHour: (t) => active.rainMmPerHour(t),
+    rainDepthMm: (a, b) => active.rainDepthMm(a, b),
+    ```
+    (`sky.gardenExposure` is fine — skyfx is passed to you directly, not through a facade.) Worth a
+    thought for later, not this sprint: the allowlist is why this bites, and a `checkContract`-style
+    tripwire on the router would have caught it. Your call, your file — I'm not touching main.js.
+
+[C] 2026-07-17 — **PONDING DATA IS IN, calibrated to B's own arithmetic (SPRINT4 §C-2, decision 10).**
+    `rainAt()` was dimensionless 0..1 — right for drop count and opacity, useless for water mass. Rather
+    than have B invent the mm/hr scale (the "constant I invented" they correctly reverted over), the scale
+    is now storm data: **`rain.peakMmPerHour`**, plus `wind.rainMmPerHour(t)` and `wind.rainDepthMm(t0,t1)`
+    (real-world mm, no compression). **`RAIN_TIME_COMPRESSION = 40` is exported from weather.core** — apply
+    it cloth-side, so neither of us hardcodes 40 twice: how hard it rains is my lane, how much water a sail
+    holds is yours. Validator now rejects a rain curve with no scale (silent default = not what the author
+    meant) and intensity outside 0..1.
+    Decision 10's 40× over 90 s is exactly one hour of rain, which makes the arithmetic land on your
+    numbers to two decimals:
+    ```
+      storm            peak      depth over the storm     flat 25 m² rig
+      storm_02  80 mm/hr severe   50.9 mm (5.1 cm)   →  3.12 kN/corner   ← your 3.1 kN kill
+      storm_03  30 mm/hr moderate  8.3 mm (0.8 cm)   →  0.51 kN/corner
+      storm_01   8 mm/hr shower    0.9 mm            →  0.06 kN/corner
+    ```
+    …against your measured storm_02 wind of 0.2–1.1 kN/corner. **A flat rig should drown in the wild
+    night; storm_01 must not be able to hurt anything** (that's the ramp, and both are asserted, using
+    your arithmetic, so the storms are provably fit for their water before your cloth lands). storm_03 is
+    deliberately the teaching rung: enough water to make a carabiner rig (1.2 kN) sweat once wind is added,
+    not enough to drown a shackle. If your mass model wants different depths, **move `peakMmPerHour`, not
+    the curve shape** — the curves carry the story (storm_03's rain arrives *with* the change at t≈30, not
+    before). Say the word and I'll re-scale.
+
+[C] 2026-07-17 — **LANE A — decision 7 helper landed, as offered: `sky.gardenExposure(bed, t)`.** The whole
+    drain term in one call — `rainAt(t) × (1 − rainShadowOver(bed))`, 0..1:
+    ```js
+    hp -= sky.gardenExposure(world.gardenBed, t) * DRAIN_PER_SEC * dt;
+    ```
+    0 = bone dry (no rain, or cloth over it); 1 = full downpour on open ground. Both terms are needed and
+    neither is enough alone. ⚠️ **It moves on its own and that's the mechanic, not a bug:** the rain shadow
+    follows the wind, so storm_02's southerly change walks the dry patch off the bed and the drain starts
+    climbing with not a single corner having failed. If that looks surprising in your HUD, please don't
+    "fix" it. Telegraph feed for the gust banner is unchanged: `wind.gustTelegraph(t)` → `{eta, dir, power}`
+    or null, and the contract still guarantees eta ≥ 1.2 s when it first appears.
+
+[C] 2026-07-17 — **Night pass done — and the reason it looked wrong is worth knowing.** storm_02 now reads
+    as an actual wild night. `sky.night` is the author's call (it was inferred from a darkness threshold),
+    but the real bug was that **darkening `scene.background` did nothing**: my cloud dome covers it at 0.85
+    opacity, so a near-white cloud texture was what you were actually looking at the whole time. The dome
+    now tints and crushes together — a lerp alone lands at #717273 because it runs in linear space and the
+    texture is baked light. It stops at 0.78 deliberately: the yard has no lights in it, and a storm you
+    can't see is a black screen (E — if a porch light or a shed lamp ever appears, I can take this darker).
+    Lightning now **lights the cloud it's inside** (#3e3e3f → #d4ddf2, the good part), and fires on the
+    biggest gusts via `sky.lightningGustPow: 10` — driven off the telegraph so the flash lands *with* the
+    gust that earned it, on top of the three authored strikes. storm_01 stays lightning-free.
+    A — the forecast card has range to sell now: `sky.night`, `rain.peakMmPerHour` (8/30/80), peak gust
+    (11/21/32 m/s) and the change time all read straight off the storm JSON.
+
+[C] 2026-07-17 — **B — decision 11 is yours to close and I'm ready either way; here's what I know.** My
+    storm_02 `downdraftOfTotal` is still **held at 0.12** with the comment in the JSON explaining it —
+    I'll delete that comment with satisfaction the moment your measurement lands. Two things that may save
+    you an afternoon:
+      · **A's anchors alone didn't fix it.** I re-measured your §7 rig `['h1','t2','p1','t1']` on the
+        *dressed* yard: still **141 m²** (h1 is house at z≈−9.9, t2 at x≈8, t1 at x≈−9 — those four span
+        the whole yard), and it dies at 0.45 (3/4, peak 6410 N). The re-point is the whole job.
+      · **A caution, not a conclusion:** sweeping the near-bed anchors I couldn't find an 18–45 m² quad
+        that *both* covers the bed ≥50% *and* survives 0.45 on a rated+shackle mix — the bed sits between
+        the house (z≈−9.9) and the posts (z≈+6), so covering it wants a biggish quad. A's a.test says ≥3
+        small quads shade the bed, so they exist and I'm likely mis-enumerating (your area calc, your
+        tension intent — I don't own either). If 0.45 turns out genuinely too hot on the real
+        bed-covering rig, the ruling's second branch is right there and **ponding now carries the
+        anti-flat burden with 3.12 kN/corner** — which is 3× the wind and cannot touch a hypar. Either
+        outcome closes it. No third sprint, as ruled.
+
+[C] 2026-07-17 — Small one, my own miss: `c.test.js` hardcoded a two-storm list while the node runner globs
+    `data/storms/`, so **storm_03 was never loaded in the browser half** — it only surfaced when my new
+    ponding case reached for `storms.storm_03_southerly` and got `undefined`. Fixed, with a note on the
+    list. If you add a storm, that list is the thing to update.
 [B] 2026-07-17 — ✅ **DECISION 11 CLOSED: the bar PASSES. I was wrong, and C was right.** Re-measured on
     A's dressed yard, 8 headings, full 90 s, fraction-of-total:
     ```
@@ -1239,3 +1442,135 @@ Format: `[lane letter] YYYY-MM-DD — note`
         a solver instability rather than physics, and a per-face force clamp would hide it rather than fix
         it. **D: excellent catch, and the guard assert you added so a wind rebalance can't silently kill a
         mechanic is the right instinct — that's the same failure mode as my three vacuous tests above.**
+[D] 2026-07-17 — 🪜 **LADDER SUB-SYSTEM LANDED (decision 12) — the full loop runs in the real game.**
+    New file `web/world/js/ladder.js` (Lane D). Driven by hand through SHADES.step, the prompt chain is:
+      `ladder_take` → carry → `ladder_place_h2` → (h2's carabiner blows) → `spare_table` →
+      `ladder_climb` → **`rerig_0`, which only exists at height** → `oooo`, spare consumed.
+    Selftest **194/0/0** (was 184); 11 of the new asserts are the ladder's, including the scripted
+    climb-repair-descend the sprint asked for.
+    **It needed no change to main.js.** createLadder self-wires from createPlayer, which Lane A already
+    hands the scene, world and interact — so a whole sub-system landed inside Lane D's own files. The
+    reach gate finds it via `interact.ladder` (Interact is Lane D's class), and an explicit
+    `deps.ladder` still wins for tests.
+    Numbers that made the design: **fascia sits at 2.48 m, a 1.72 m person reaches 2.20 m, E's ladder
+    tops out at 2.90 m.** Two hundred millimetres is the entire mechanic — the asset and the yard were
+    already built for each other, I just wrote the verb between them.
+
+[D] 2026-07-17 — 📐 **Scoped `needsLadder` to the FASCIA, deliberately — flagging the judgement call.**
+    A pure "is it above head height?" rule would have caught the 3.95 m posts and the 5.05 m tree limbs
+    and turned *every* repair in the game into a two-trip ladder job — which would have silently
+    invalidated the recorded §7 run and Lane B's gate asserts, and isn't true to rigging anyway: a sail
+    post is tensioned from a cleat at its base and a tree anchor is a strop you throw. A bracket bolted
+    2.5 m up a bare wall is the one you cannot fake. So `needsLadder = anchor.type === 'house'`, one
+    line, where it can be found and argued with. This also means **the house is now the expensive anchor
+    to depend on** — which is what E's `ratingHint 0.35` / `collateral "gutter"` was already saying in
+    the data. Shout if you wanted it broader.
+
+[D] 2026-07-17 — 🐛 **A FOOTGUN IN MY OWN API, found twice while building on it, now documented + asserted.**
+    `interact.register({canUse})` is re-checked EVERY FRAME to keep a hold alive — and starting a hold
+    moves the player into `busy`. So any `canUse` that reads `player.state` goes false on frame one and
+    **the action silently cancels its own hold.** No error; the prompt just looks dead. It ate the
+    ladder's climb (`canUse: p => p.state === 'idle'`) and the fascia reach gate (`isWorking()` testing
+    `state === 'atTop'`) — I lost time to it both times. Fixed by gating on PHYSICAL facts (carrying,
+    position, climbY), which is also the honest test. Now written on `register()`'s JSDoc where you'll
+    read it, and pinned by an assert that registers a deliberately state-gated action and proves it
+    never fires. **B/C/E: if you ever register an interact target, gate on facts, not on state.**
+
+[D] 2026-07-17 — 💬 **FEEL NOTES from playing it (A's HUD/prep not landed yet, so these are from the
+    parts that exist). I'm the lane that plays it, so:**
+      1. **No prompt is worse than a refusal.** Carry the ladder to the shed table and the "take a
+         spare" prompt doesn't say "hands full" — it *vanishes*, because `canUse` filters the target out
+         of `nearest()` before the label can explain itself. It reads as a broken game, not a full pair
+         of hands. **Lane A, this is a HUD-shaped problem:** the prompt wants to show unusable actions
+         greyed out with their reason, and my `label(player)` already returns "hands full" / "out of
+         reach — needs the ladder" for exactly this. Say the word and I'll surface unusable targets.
+      2. **The two-trip fascia repair costs ~15 s of running** (shed→ladder→wall→shed→wall) out of a 90 s
+         storm. It is *supposed* to hurt, and it does — but that's a sixth of the storm on foot, and
+         until the HUD shows corner loads you can't tell whether you're spending it well. Worth a look
+         once the HUD lands; I'd rather tune it against a player who can see, than guess now.
+      3. **A ladder standing bolt upright reads as a post, not a ladder** — I had it vertical at first
+         and genuinely couldn't tell what I was looking at until I saw its shadow. It now leans 15° into
+         the wall. Small thing; large difference. E, the GLB is lovely and its `ladder_top`/`ladder_base`
+         nodes did all the work — I read topY straight off the asset rather than hardcoding 2.9.
+
+[I] 2026-07-17 — **SPRINT 4 INTEGRATION (main).** Lanes b/c/d/e merged; applied C's two-line router fix
+    in main.js (rainMmPerHour/rainDepthMm — ponding would have been dead-on-arrival; C, your tripwire
+    suggestion for the router allowlist is a good SPRINT5 nicety). Selftest **207/0/0**. Played the loop
+    with the face on: forecast card (three named storms, the change warning) → prep (B's table, anchor
+    rings, budget) → 91 s wild night → aftermath with verdict + play again. Gate 1 confirmed.
+    Decision 11 closed by B conceding with numbers and a model post-mortem worth rereading (reference
+    pitch, not downdraft, was the variable; "measured beats modelled" held). storm_02 downdraftOfTotal
+    is 0.45. Ladder loop landed whole inside Lane D's files. E renamed fence_panel_snapped to match spec.
+    **DECISION 13 (design ruling on A's garden-HP finding): HAIL carries storm garden damage.** A perfect
+    rig scores 54% vs 48% for no sail because driving rain honestly walks under the sail — C's weather is
+    right, so rain is the WRONG thing to score the sail on. DESIGN.md already says hail is the
+    garden-killer and drainage answers rain. Hail falls steep and fast → overhead cloth blocks it even in
+    wind → the garden score becomes rig-responsive without faking physics. Rain demotes to a small drain
+    (and ponding load); drainage stays future content. SPRINT5 wires it.
+
+[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.

tools/blender/asset_report.json

@@ -16,400 +16,7 @@
       ],
       "status": "PASS",
       "problems": []
-    },
-    {
-      "name": "tree_gum_01",
-      "dims": [
-        4.5522,
-        4.956,
-        7.9702
-      ],
-      "tris": 396,
-      "nodes": [
-        "branch_anchor_01",
-        "branch_anchor_02",
-        "branch_anchor_03",
-        "canopy",
-        "canopy_01",
-        "canopy_02",
-        "canopy_03",
-        "tree_gum_01",
-        "trunk"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "tree_gum_02",
-      "dims": [
-        3.8871,
-        2.7787,
-        5.4972
-      ],
-      "tris": 288,
-      "nodes": [
-        "branch_anchor_01",
-        "branch_anchor_02",
-        "canopy",
-        "canopy_01",
-        "canopy_02",
-        "tree_gum_02",
-        "trunk"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "fence_post",
-      "dims": [
-        0.13,
-        0.13,
-        2.03
-      ],
-      "tris": 24,
-      "nodes": [
-        "fence_post",
-        "post"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "fence_panel",
-      "dims": [
-        2.4,
-        0.054,
-        1.8194
-      ],
-      "tris": 324,
-      "nodes": [
-        "fence_panel",
-        "palings",
-        "rails"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "gate",
-      "dims": [
-        1.045,
-        0.0615,
-        1.75
-      ],
-      "tris": 220,
-      "nodes": [
-        "gate",
-        "gate_frame",
-        "gate_palings",
-        "hinge_axis",
-        "hinges"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "house_yardside",
-      "dims": [
-        9.2,
-        1.0547,
-        2.9
-      ],
-      "tris": 200,
-      "nodes": [
-        "door",
-        "fascia",
-        "fascia_anchor_01",
-        "fascia_anchor_02",
-        "fascia_anchor_03",
-        "gutter",
-        "house_yardside",
-        "roof",
-        "wall",
-        "window"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "shed_01",
-      "dims": [
-        2.58,
-        1.9708,
-        2.2224
-      ],
-      "tris": 96,
-      "nodes": [
-        "door_anchor",
-        "doors",
-        "roof",
-        "shed_01",
-        "shell"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "shed_table",
-      "dims": [
-        1.6,
-        0.6,
-        0.9
-      ],
-      "tris": 72,
-      "nodes": [
-        "pickup_anchor",
-        "shed_table",
-        "table_frame",
-        "table_top"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "garden_bed",
-      "dims": [
-        3.0,
-        1.2,
-        0.8609
-      ],
-      "tris": 2580,
-      "nodes": [
-        "bed",
-        "garden_bed",
-        "plants_dead",
-        "plants_full",
-        "plants_tattered",
-        "soil"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "sail_post",
-      "dims": [
-        0.507,
-        0.52,
-        4.0327
-      ],
-      "tris": 528,
-      "nodes": [
-        "footing",
-        "pad_eye",
-        "post",
-        "rake_pivot",
-        "sail_post",
-        "top_anchor"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "ladder_01",
-      "dims": [
-        0.455,
-        0.075,
-        3.0
-      ],
-      "tris": 276,
-      "nodes": [
-        "ladder",
-        "ladder_01",
-        "ladder_base",
-        "ladder_top"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "shackle",
-      "dims": [
-        0.0569,
-        0.019,
-        0.0744
-      ],
-      "tris": 560,
-      "nodes": [
-        "bow",
-        "pin",
-        "shackle"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "carabiner",
-      "dims": [
-        0.049,
-        0.009,
-        0.1027
-      ],
-      "tris": 476,
-      "nodes": [
-        "body",
-        "carabiner",
-        "gate"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "turnbuckle",
-      "dims": [
-        0.0292,
-        0.0341,
-        0.1955
-      ],
-      "tris": 728,
-      "nodes": [
-        "body",
-        "eye_a",
-        "eye_b",
-        "turnbuckle"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "tramp_01",
-      "dims": [
-        2.9555,
-        2.9555,
-        0.78
-      ],
-      "tris": 976,
-      "nodes": [
-        "legs",
-        "mat",
-        "pad",
-        "rim",
-        "tramp_01"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "wheelie_bin_01",
-      "dims": [
-        0.58,
-        0.6808,
-        1.1188
-      ],
-      "tris": 120,
-      "nodes": [
-        "bin_body",
-        "lid",
-        "lid_plate",
-        "wheelie_bin_01",
-        "wheels"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "washing_line_01",
-      "dims": [
-        2.8441,
-        2.8441,
-        2.2777
-      ],
-      "tris": 336,
-      "nodes": [
-        "arms",
-        "head",
-        "mast",
-        "washing_line_01"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "garden_gnome_01",
-      "dims": [
-        0.1427,
-        0.15,
-        0.365
-      ],
-      "tris": 236,
-      "nodes": [
-        "garden_gnome_01",
-        "gnome"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "garden_gnome_01_broken",
-      "dims": [
-        0.3947,
-        0.3519,
-        0.106
-      ],
-      "tris": 344,
-      "nodes": [
-        "garden_gnome_01_broken",
-        "hat",
-        "head",
-        "shards",
-        "stump"
-      ],
-      "status": "PASS",
-      "problems": []
-    },
-    {
-      "name": "fence_panel_broken",
-      "dims": [
-        2.4,
-        0.7749,
-        1.8197
-      ],
-      "tris": 336,
-      "nodes": [
-        "debris_palings",
-        "fence_panel_broken",
-        "palings",
-        "rails"
-      ],
-      "status": "PASS",
-      "problems": []
     }
   ],
-  "debris": [
-    {
-      "file": "BlueCrate_v2.glb",
-      "dims": [
-        0.36,
-        0.36,
-        0.29
-      ],
-      "sane": true
-    },
-    {
-      "file": "BlackTub_v2.glb",
-      "dims": [
-        0.36,
-        0.54,
-        0.2
-      ],
-      "sane": true
-    },
-    {
-      "file": "WhiteTub_v2.glb",
-      "dims": [
-        0.36,
-        0.54,
-        0.2
-      ],
-      "sane": true
-    },
-    {
-      "file": "WoodenBin_v2.glb",
-      "dims": [
-        0.35,
-        0.36,
-        0.31
-      ],
-      "sane": true
-    }
-  ]
+  "debris": []
 }

tools/blender/build_yard_assets.py

@@ -117,9 +117,16 @@ PAL = {
     "gnome_skin":  "#E0A986",
     "gnome_coat":  "#3E6FA8",
     "gnome_hat":   "#B33C36",
+    "bristle":     "#C9A659",   # broom straw
     "ref_pink":    "#E85C8A",   # the reference capsule — deliberately loud
 }
 
+# Rainwater caught in a sail is not swimming-pool blue. It's shallow, murky, it
+# picks up dust off the cloth, and mostly it mirrors an overcast sky — so it
+# reads grey-green, and it goes darker where it's deeper.
+WATER_SHALLOW = (0.46, 0.51, 0.46)
+WATER_DEEP = (0.22, 0.28, 0.26)
+
 
 # ============================================================================
 # UTILS — lifted from racks_to_glb.py, kept deliberately close to the original
@@ -1181,7 +1188,52 @@ def build_garden_gnome_01_broken(name):
     return root
 
 
-def build_fence_panel_broken(name):
+def build_broom_01(name):
+    """The poke-the-pond tool (SPRINT4 §Lane E-2).
+
+    Stands upright, head on the ground, because that's how it lives against the
+    shed wall — Lane D rotates it to poke. `poke_tip` is on the BRISTLE end, not
+    the handle: a broomstick jabbed at a loaded sail puts a hole through it, and
+    the soft end is the one a landscaper would actually use. `grip_anchor` is
+    where the hand goes, two thirds up.
+    """
+    rng = rng_for(name)
+    root = add_empty(name)
+    dowel = get_material("Mat_Timber", PAL["timber"], 0.7)
+    head_m = get_material("Mat_TimberDark", PAL["timber_dark"], 0.85)
+    bristle = get_material("Mat_Bristle", PAL["bristle"], 0.95)
+    H, HEAD_W = 1.42, 0.30
+
+    join_group([add_cyl(f"{name}_handle", 0.014, H - 0.10, (0, 0, 0.10 + (H - 0.10) / 2),
+                        dowel, verts=8)], "handle", root)
+    join_group([add_box(f"{name}_head", (HEAD_W, 0.055, 0.05), (0, 0, 0.125), head_m),
+                add_cone(f"{name}_ferrule", 0.020, 0.014, 0.05, (0, 0, 0.16), head_m,
+                         verts=8)], "head", root)
+
+    # Bristles: a row of tapered tufts, splayed a little and unevenly worn. A
+    # solid block reads as a paint roller.
+    tufts = []
+    n = 11
+    for i in range(n):
+        x = -HEAD_W / 2 + 0.02 + i * ((HEAD_W - 0.04) / (n - 1))
+        ln = rng.uniform(0.085, 0.105)
+        lean = (x / (HEAD_W / 2)) * rng.uniform(0.04, 0.09)
+        tufts.append(add_tube_between(f"{name}_tuft_{i:02d}", (x, 0, 0.10),
+                                      (x + lean, rng.uniform(-0.01, 0.01), 0.10 - ln),
+                                      0.010, bristle, verts=4))
+    join_group(tufts, "bristles", root)
+
+    g = add_empty("grip_anchor", (0, 0, 0.95), root, size=0.12)
+    g["carry_type"] = "broom"
+    p = add_empty("poke_tip", (0, 0, 0.02), root, size=0.12)
+    p["use"] = "push the pond up from under the sail; soft end, won't hole the cloth"
+    stamp(root, name, "tool")
+    root["mass_hint"] = 1.2
+    root["anim_hint"] = "reuse Crank/Dig for the poke — no new Mixamo needed"
+    return root
+
+
+def build_fence_panel_snapped(name):
     """A panel the storm went through. Same 2.4 m tile footprint and origin as
     fence_panel, so Lane A drops it into the run in place of one instance rather
     than re-tiling the fence.
@@ -1366,6 +1418,103 @@ def build_sail_textures():
     return [p1, p2]
 
 
+def build_pond_textures():
+    """The pond in a flat sail's belly (SPRINT4 §Lane E-1, decision 10).
+
+    Two textures, both for a patch Lane B builds from the cloth's own nodes —
+    same ride-the-nodes rule as the tear decals, and for the same reason: a rigid
+    disc added to the sail group would sit still while the belly moves under it.
+
+    pond_water.png  — RGBA decal. Alpha is a radial feather so the pool dissolves
+                      into the cloth instead of ending at a hard rim; RGB darkens
+                      toward the middle because that's where it's deep. Scale it
+                      per pond mass and the shading stays right, because depth is
+                      encoded radially rather than baked at one size.
+    pond_normal.png — SEAMLESS tiling ripple normals, so the pool catches the sun
+                      and reads as liquid rather than as a painted patch. Tiles
+                      because B will repeat it across whatever area the pond has.
+    """
+    import numpy as np
+
+    # 256², not 512²: both of these are smooth, low-frequency content (a radial
+    # gradient and some sine ripples), so the extra resolution buys nothing you
+    # can see and costs 4x the bytes. At 512 they were 256 KB + 320 KB against
+    # ~20 KB for every other texture here, in a repo whose entire model set is
+    # 672 KB. The fastest pond is the one that isn't most of the download.
+    SIZE = 256
+    Y, X = np.mgrid[0:SIZE, 0:SIZE]
+    c = (SIZE - 1) / 2.0
+    nx, ny = (X - c) / (SIZE / 2.0), (Y - c) / (SIZE / 2.0)
+    r = np.clip(np.sqrt(nx * nx + ny * ny), 0.0, 1.0)
+
+    # Wind chop. Not concentric rings — a puddle ringed like a dartboard reads as
+    # a target. But three crossed sines don't work either: at similar frequencies
+    # they interfere into a regular lattice and the pond reads as basketweave.
+    # Seven waves, directions spaced by the golden angle and frequencies in a
+    # non-harmonic ratio, so nothing lines up and the surface stays irregular the
+    # way real chop is. Free choice here — this decal is radial, never tiled, so
+    # unlike the normal map it owes nothing to seamlessness.
+    chop = np.zeros((SIZE, SIZE), dtype=np.float32)
+    rw = rng_for("pond_chop")
+    total = 0.0
+    for i in range(7):
+        ang = i * 2.39996                       # golden angle: maximally non-repeating
+        freq = 5.0 * (1.37 ** i)                # non-harmonic progression
+        amp = 1.0 / (1.0 + i * 0.8)
+        chop += amp * np.sin((nx * math.cos(ang) + ny * math.sin(ang)) * freq * math.pi
+                             + rw.uniform(0, math.tau))
+        total += amp
+    chop = np.clip(0.5 + 0.5 * chop / total, 0.0, 1.0)
+
+    depth = np.clip(1.0 - r, 0.0, 1.0) ** 0.7
+    water = np.zeros((SIZE, SIZE, 4), dtype=np.float32)
+    for i in range(3):
+        base = WATER_SHALLOW[i] + (WATER_DEEP[i] - WATER_SHALLOW[i]) * depth
+        water[:, :, i] = np.clip(base * (0.86 + 0.28 * chop), 0.0, 1.0)
+    # Feather the last quarter of the radius: a hard edge would read as a decal.
+    a = np.clip((1.0 - r) / 0.25, 0.0, 1.0)
+    water[:, :, 3] = (a * a * (3.0 - 2.0 * a)).astype(np.float32)   # smoothstep
+    p1, kb1 = save_png(water, "pond_water")
+    print(f"  pond_water.png             {SIZE}x{SIZE}, radial feather, {kb1} KB")
+
+    # --- ripple normals, seamless -----------------------------------------
+    def height(px, py):
+        h = np.zeros_like(px, dtype=np.float32)
+        # Integer cycles across the tile = exact wrap, same trick as the weave.
+        # Six of them rather than three, on deliberately unrelated (kx, ky) pairs:
+        # too few waves and they beat into a visible lattice, same failure the
+        # albedo chop had. Integer pairs are the only constraint seamlessness puts
+        # on this — which ones is free.
+        for kx, ky, amp in ((3, 5, 1.0), (7, 2, 0.62), (11, 9, 0.36),
+                            (2, 13, 0.28), (13, 4, 0.20), (5, 11, 0.16)):
+            h += amp * np.sin(2 * np.pi * (kx * px + ky * py) / SIZE)
+        return h
+
+    Yn, Xn = np.mgrid[0:SIZE, 0:SIZE]
+    e = 1.0
+    dhdx = (height(Xn + e, Yn) - height(Xn - e, Yn)) / (2 * e)
+    dhdy = (height(Xn, Yn + e) - height(Xn, Yn - e)) / (2 * e)
+    strength = 6.0
+    nxv, nyv, nzv = -dhdx * strength, -dhdy * strength, np.ones_like(dhdx)
+    ln = np.sqrt(nxv * nxv + nyv * nyv + nzv * nzv)
+    normal = np.zeros((SIZE, SIZE, 4), dtype=np.float32)
+    normal[:, :, 0] = (nxv / ln) * 0.5 + 0.5
+    normal[:, :, 1] = (nyv / ln) * 0.5 + 0.5
+    normal[:, :, 2] = (nzv / ln) * 0.5 + 0.5
+    normal[:, :, 3] = 1.0
+
+    # Same guard as the weave: B is told to RepeatWrapping this, and a bad wrap
+    # is a visible seam gridded across the pond.
+    if not np.allclose(height(Xn, Yn), height(Xn + SIZE, Yn), atol=1e-4):
+        raise AssertionError("pond_normal does not tile on X")
+    if not np.allclose(height(Xn, Yn), height(Xn, Yn + SIZE), atol=1e-4):
+        raise AssertionError("pond_normal does not tile on Y")
+
+    p2, kb2 = save_png(normal, "pond_normal")
+    print(f"  pond_normal.png            {SIZE}x{SIZE}, seamless ripples, {kb2} KB")
+    return [p1, p2]
+
+
 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."""
@@ -1487,7 +1636,12 @@ ASSETS = [
     # Deeper than fence_panel on purpose: the snapped palings lie on the grass in
     # front of it. Bounded so wreckage on a boundary fence can't reach through
     # whatever is behind it.
-    dict(name="fence_panel_broken", fn=build_fence_panel_broken,
+    # Wider than the 0.30 head: the bristles splay past it, which is what a worn
+    # broom does. A real yard broom is 0.30–0.45 m across.
+    dict(name="broom_01", fn=build_broom_01,
+         dims=((0.28, 0.45), (0.04, 0.12), (1.35, 1.50)),
+         nodes=["handle", "head", "bristles", "grip_anchor", "poke_tip"]),
+    dict(name="fence_panel_snapped", fn=build_fence_panel_snapped,
          dims=((2.38, 2.60), (0.03, 1.05), (1.70, 1.90)),
          nodes=["palings", "rails", "debris_palings"]),
 ]
@@ -1815,6 +1969,7 @@ def main():
     reset_to_empty()
     build_grass_atlas()
     build_sail_textures()
+    build_pond_textures()
     debris = [] if no_debris else copy_debris()
 
     failures = []

web/world/data/storms/storm_01_gentle.json

@@ -24,7 +24,9 @@
 
   "events": [],
 
-  "rain": { "curve": [[0, 0], [30, 0.15], [55, 0.2], [80, 0.08], [90, 0]] },
+  "_rain_comment": "peakMmPerHour 8 = a light shower. Mean intensity ~0.12, so at decision 10's 40x a whole storm delivers ~0.9 mm — about a millimetre of water, ~20 kg over a 25 m2 flat sail. Ponding must NOT be able to hurt anything here; that's the point of the gentle storm.",
+
+  "rain": { "peakMmPerHour": 8, "curve": [[0, 0], [30, 0.15], [55, 0.2], [80, 0.08], [90, 0]] },
 
   "sky": { "darkness": 0.15, "cloudScroll": 0.02 }
 }

web/world/data/storms/storm_02_wildnight.json

@@ -38,7 +38,11 @@
     { "t": 79, "type": "lightning", "power": 0.5 }
   ],
 
-  "rain": { "curve": [[0, 0], [10, 0.25], [35, 0.6], [55, 0.85], [70, 1.0], [90, 0.7]] },
+  "_rain_comment": "peakMmPerHour 80 = severe thunderstorm rate, the scale rainAt's 0..1 is a fraction OF. Ponding (decision 10) reads it. Mean intensity over the storm is ~0.64, and at 40x compression a 90 s storm is one hour of rain, so depth ~= 80 * 0.64 = ~51 mm = 5.1 cm on a flat sail — Lane B's measured kill: 5 cm over 25 m2 = 1250 kg = 3.1 kN/corner, against a wind load of only 0.2-1.1 kN. A flat rig should drown here. A hypar pools nothing and doesn't care.",
 
-  "sky": { "darkness": 0.8, "cloudScroll": 0.09 }
+  "rain": { "peakMmPerHour": 80, "curve": [[0, 0], [10, 0.25], [35, 0.6], [55, 0.85], [70, 1.0], [90, 0.7]] },
+
+  "_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

@@ -32,7 +32,9 @@
     { "t": 62, "type": "lightning", "power": 0.4 }
   ],
 
-  "rain": { "curve": [[0, 0], [28, 0.05], [34, 0.4], [55, 0.55], [80, 0.3], [90, 0.15]] },
+  "_rain_comment": "peakMmPerHour 30 = moderate. The rain arrives WITH the change at t~30 and not before — dry hot afternoon, then the southerly brings the water, which is the story the curve is telling. Mean intensity ~0.28, so at decision 10's 40x it delivers ~8 mm = 0.8 cm: ~200 kg on a 25 m2 flat sail, ~0.5 kN/corner. That is the middle rung on purpose — enough that a flat rig on carabiners (1.2 kN) should feel the water once wind is added, not enough to drown a shackle. Ponding teaches here; it kills in storm_02.",
+
+  "rain": { "peakMmPerHour": 30, "curve": [[0, 0], [28, 0.05], [34, 0.4], [55, 0.55], [80, 0.3], [90, 0.15]] },
 
   "sky": { "darkness": 0.5, "cloudScroll": 0.05 }
 }

web/world/index.html

@@ -3,7 +3,7 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width,initial-scale=1">
-<title>SHADES — yard (M0)</title>
+<title>SHADES — rig it, then survive the night</title>
 <style>
   html, body { margin: 0; height: 100%; overflow: hidden; background: #9fc4dd; }
   canvas { display: block; width: 100%; height: 100%; }
@@ -28,7 +28,6 @@
   <canvas id="c"></canvas>
   <div id="banner"></div>
   <div id="dev">booting…</div>
-  <div id="help">WASD move · shift run · RMB drag orbit · wheel zoom · Enter next phase</div>
 
   <script type="importmap">
     { "imports": { "three": "./vendor/three.module.js",

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/hud.js

@@ -0,0 +1,392 @@
+/**
+ * SHADES — the face. Lane A owns this file.
+ *
+ * Everything the game already simulates is invisible to a stranger without this:
+ * loads, the gust warning, whether the garden is actually getting hit. So the
+ * rule here is that the HUD only ever READS. It takes no decisions, owns no
+ * state worth keeping, and if you deleted it the sim would run identically —
+ * which is also why it can be this chatty without anything drifting.
+ *
+ * Two things earn their place as world-anchored rather than screen-anchored:
+ * the corner load bars (a number in a corner of the screen can't tell you WHICH
+ * shackle is about to go, and that's the whole "…the shackle, I knew about the
+ * shackle" moment) and the repair prompt, which Lane D already owns.
+ */
+
+import * as THREE from '../vendor/three.module.js';
+import { STORM_LEN } from './contracts.js';
+
+const clamp01 = (v) => (v < 0 ? 0 : v > 1 ? 1 : v);
+const kmh = (ms) => ms * 3.6;
+
+// Load bar colours: green → amber → red. The amber band is deliberately wide;
+// a corner at 60% in a lull is one gust from 100% and the player should feel
+// that before the bar turns red on them.
+const BAR_OK = 0x6ee06e, BAR_WARN = 0xffc24a, BAR_HOT = 0xff5b4a, BAR_DEAD = 0x7a2f2f;
+
+const CSS = `
+#hud { position:fixed; inset:0; pointer-events:none; z-index:10;
+  font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace; color:#dde5ea;
+  text-shadow:0 1px 3px #000a; user-select:none; }
+#hud .panel { position:absolute; background:#0d1418d9; border:1px solid #2c3a44;
+  border-radius:6px; padding:8px 10px; }
+#hud-top { top:10px; left:50%; transform:translateX(-50%); text-align:center; min-width:280px; }
+#hud-wind { font-size:15px; font-weight:700; letter-spacing:.04em; }
+#hud-clock { color:#8ba0ad; }
+#hud-gust { position:absolute; top:78px; left:50%; transform:translateX(-50%);
+  font:700 20px/1 ui-monospace,Menlo,monospace; letter-spacing:.16em; color:#ffd27a;
+  background:#3a2a0ce0; border:1px solid #7a5a1a; border-radius:5px; padding:8px 16px;
+  opacity:0; transition:opacity .12s; }
+#hud-gust.on { opacity:1; }
+#hud-garden { bottom:12px; left:12px; min-width:210px; }
+#hud-bar { height:9px; background:#00000066; border-radius:5px; overflow:hidden; margin-top:5px; }
+#hud-bar i { display:block; height:100%; width:100%; background:#6ee06e; transition:width .2s,background .3s; }
+#hud-carry { bottom:12px; right:12px; text-align:right; }
+#hud-events { position:absolute; bottom:70px; left:12px; max-width:420px; }
+#hud-events div { color:#ffd27a; margin-top:2px; }
+#hud-help { position:absolute; bottom:12px; left:50%; transform:translateX(-50%);
+  color:#93a6b2; opacity:.85; white-space:nowrap; }
+
+#hud-card { position:fixed; inset:0; z-index:30; display:none; place-items:center;
+  background:#060a0dc4; backdrop-filter:blur(3px);
+  font:13px/1.7 ui-monospace,SFMono-Regular,Menlo,monospace; color:#dde5ea; }
+#hud-card.on { display:grid; }
+#hud-card .card { background:#0d1418; border:1px solid #2f3f4a; border-radius:9px;
+  padding:22px 26px; min-width:440px; max-width:620px; pointer-events:auto; }
+#hud-card h1 { margin:0 0 2px; font-size:19px; letter-spacing:.16em; color:#fff; }
+#hud-card h2 { margin:0 0 16px; font-size:12px; font-weight:400; color:#8ba0ad; letter-spacing:.04em; }
+#hud-card .row { display:flex; justify-content:space-between; gap:18px; padding:3px 0;
+  border-bottom:1px solid #1c262d; }
+#hud-card .row b { font-weight:700; color:#fff; }
+#hud-card .storm { display:block; width:100%; text-align:left; margin:7px 0; padding:10px 12px;
+  background:#121c23; border:1px solid #2f3f4a; border-radius:6px; color:#dde5ea; cursor:pointer;
+  font:inherit; transition:border-color .15s,background .15s; }
+#hud-card .storm:hover { border-color:#7ee0ff; background:#16242c; }
+#hud-card .storm .name { font-weight:700; color:#fff; letter-spacing:.08em; }
+#hud-card .storm .stat { color:#8ba0ad; }
+#hud-card .go { margin-top:16px; padding:9px 18px; background:#1d3d2a; border:1px solid #3f7a52;
+  border-radius:6px; color:#a8f0b8; cursor:pointer; font:inherit; font-weight:700; letter-spacing:.1em; }
+#hud-card .go:hover { background:#255033; }
+#hud-card .verdict { margin:14px 0 0; padding:10px 12px; border-radius:6px; font-weight:700;
+  letter-spacing:.05em; }
+#hud-card .verdict.win { background:#12321c; border:1px solid #2c6b3c; color:#7fce6a; }
+#hud-card .verdict.lose { background:#3a1618; border:1px solid #7d2b2b; color:#ff8f86; }
+`;
+
+/**
+ * @param {object} d
+ * @param {THREE.Scene} d.scene
+ * @param {THREE.Camera} d.camera
+ * @param {object} d.game     the phase machine
+ * @param {object} d.world
+ * @param {object} d.wind     the router
+ * @param {object} d.player
+ * @param {object} d.rig      SailRig
+ * @param {object} d.garden   {hp}
+ * @param {() => object} d.getSky      skyfx is rebuilt per storm, so read it late
+ * @param {() => number} d.getWindTime
+ * @param {{text:string,t:number}[]} d.events
+ */
+export function createHud(d) {
+  const style = document.createElement('style');
+  style.textContent = CSS;
+  document.head.appendChild(style);
+
+  const root = document.createElement('div');
+  root.id = 'hud';
+  root.innerHTML = `
+    <div class="panel" id="hud-top">
+      <div id="hud-wind">--</div>
+      <div id="hud-clock">--</div>
+    </div>
+    <div id="hud-gust">GUST INCOMING</div>
+    <div class="panel" id="hud-garden">
+      <div><span id="hud-garden-label">GARDEN</span> <b id="hud-garden-pct">100%</b></div>
+      <div id="hud-bar"><i></i></div>
+      <div id="hud-shade" style="color:#8ba0ad"></div>
+    </div>
+    <div class="panel" id="hud-carry" style="display:none"></div>
+    <div id="hud-events"></div>
+    <div id="hud-help"></div>
+  `;
+  document.body.appendChild(root);
+
+  const card = document.createElement('div');
+  card.id = 'hud-card';
+  document.body.appendChild(card);
+
+  const $ = (id) => root.querySelector(id);
+  const elWind = $('#hud-wind'), elClock = $('#hud-clock'), elGust = $('#hud-gust');
+  const elPct = $('#hud-garden-pct'), elBar = $('#hud-bar i'), elShade = $('#hud-shade');
+  const elGardenLabel = $('#hud-garden-label');
+  const elCarry = $('#hud-carry'), elEvents = $('#hud-events'), elHelp = $('#hud-help');
+
+  // --- world-anchored corner load bars ------------------------------------
+  // A bar per corner, floating at the corner it describes. Geometry rather than
+  // a redrawn canvas: the fill is a scaled quad, so animating it is free and a
+  // flogging corner's bar can track it at 60 Hz without touching a texture.
+  const barGroup = new THREE.Group();
+  barGroup.visible = false;
+  d.scene.add(barGroup);
+
+  const quad = new THREE.PlaneGeometry(1, 1);
+  quad.translate(0.5, 0, 0);              // pivot on the left edge, so scale.x grows rightward
+  const BAR_W = 0.9, BAR_H = 0.1;
+
+  const bars = [];
+  function ensureBars(n) {
+    while (bars.length < n) {
+      const holder = new THREE.Group();
+      const bg = new THREE.Mesh(quad, new THREE.MeshBasicMaterial({
+        color: 0x0a1016, transparent: true, opacity: 0.75, depthTest: false,
+      }));
+      bg.scale.set(BAR_W, BAR_H, 1);
+      bg.position.x = -BAR_W / 2;
+      const fill = new THREE.Mesh(quad, new THREE.MeshBasicMaterial({
+        color: BAR_OK, depthTest: false,
+      }));
+      fill.position.x = -BAR_W / 2;
+      fill.scale.set(0.001, BAR_H * 0.72, 1);
+      const label = makeLabel();
+      label.position.y = 0.19;
+      holder.add(bg, fill, label);
+      holder.renderOrder = 999;
+      barGroup.add(holder);
+      bars.push({ holder, fill, label, lastText: '' });
+    }
+    for (let i = 0; i < bars.length; i++) bars[i].holder.visible = i < n;
+  }
+
+  function makeLabel() {
+    const c = document.createElement('canvas');
+    c.width = 256; c.height = 64;
+    const tex = new THREE.CanvasTexture(c);
+    const sp = new THREE.Sprite(new THREE.SpriteMaterial({ map: tex, depthTest: false, transparent: true }));
+    sp.scale.set(1.5, 0.375, 1);
+    sp.userData.ctx = c.getContext('2d');
+    sp.userData.tex = tex;
+    return sp;
+  }
+
+  function drawLabel(sprite, text, color) {
+    const g = sprite.userData.ctx;
+    g.clearRect(0, 0, 256, 64);
+    g.font = 'bold 30px ui-monospace, Menlo, monospace';
+    g.textAlign = 'center';
+    g.textBaseline = 'middle';
+    g.lineWidth = 6;
+    g.strokeStyle = '#0a1016';
+    g.strokeText(text, 128, 32);
+    g.fillStyle = color;
+    g.fillText(text, 128, 32);
+    sprite.userData.tex.needsUpdate = true;
+  }
+
+  // Labels are the only per-frame texture cost here, so they redraw on a slow
+  // tick and only when the shown value actually changes.
+  let labelT = 0;
+
+  const _p = new THREE.Vector3();
+  const _q = new THREE.Quaternion();
+  const _cam = new THREE.Vector3();
+
+  // --- helpers ------------------------------------------------------------
+  const barColor = (frac, broken) => (broken ? BAR_DEAD : frac > 0.85 ? BAR_HOT : frac > 0.55 ? BAR_WARN : BAR_OK);
+
+  function cornerPos(i) {
+    if (d.rig.cornerPos) return d.rig.cornerPos(i);
+    const c = d.rig.corners[i];
+    return c?.anchor?.pos ?? null;
+  }
+
+  const hud = {
+    /** Set false while a card is up — the storm HUD shouldn't peer through it. */
+    setVisible(on) { root.style.display = on ? '' : 'none'; },
+
+    setHelp(text) { elHelp.textContent = text; },
+
+    /**
+     * @param {number} dt
+     * @param {number} t  wind/storm time
+     */
+    update(dt, t) {
+      const phase = d.game.phase;
+      const storm = phase === 'storm';
+
+      // --- wind + clock ---
+      const speed = d.wind.speedAt(d.player.pos, t);
+      elWind.textContent = `${speed.toFixed(1)} m/s   ${kmh(speed).toFixed(0)} km/h`;
+      elWind.style.color = speed > 25 ? '#ff8f86' : speed > 15 ? '#ffc24a' : '#dde5ea';
+      elClock.textContent = storm
+        ? `STORM   ${Math.max(0, STORM_LEN - d.game.phaseT).toFixed(0)}s left`
+        : phase.toUpperCase();
+
+      // --- gust telegraph ---
+      // The contract promises >=1.2 s of warning; this is where the player
+      // actually gets to spend it.
+      const tel = storm ? d.wind.gustTelegraph(t) : null;
+      elGust.classList.toggle('on', !!tel);
+      if (tel) elGust.textContent = `GUST INCOMING  ${tel.eta.toFixed(1)}s  ·  ${kmh(tel.power).toFixed(0)} km/h`;
+
+      // --- garden ---
+      const hp = d.garden.hp;
+      elPct.textContent = `${hp.toFixed(0)}%`;
+      elBar.style.width = `${clamp01(hp / 100) * 100}%`;
+      elBar.style.background = hp > 66 ? '#6ee06e' : hp > 33 ? '#ffc24a' : '#ff5b4a';
+      // Decision 7: rain shadow is what matters at night, sun coverage by day.
+      // Showing whichever is load-bearing right now stops the number being a
+      // fact about nothing.
+      const sky = d.getSky?.();
+      if (storm && sky?.rainShadowOver) {
+        const dry = sky.rainShadowOver(d.world.gardenBed);
+        elGardenLabel.textContent = 'GARDEN';
+        elShade.textContent = `${(dry * 100).toFixed(0)}% kept dry by the sail`;
+      } else {
+        const shade = d.rig.rigged ? d.rig.coverageOver(d.world.gardenBed, d.world.sunDir, d.world.heightAt) : 0;
+        elGardenLabel.textContent = 'GARDEN';
+        elShade.textContent = d.rig.rigged ? `${(shade * 100).toFixed(0)}% in shade` : 'no sail rigged';
+      }
+
+      // --- carried item ---
+      const carrying = d.player.carrying;
+      elCarry.style.display = carrying ? '' : 'none';
+      if (carrying) elCarry.textContent = `carrying: ${carrying}`;
+
+      // --- event ticker ---
+      const live = d.events.filter((e) => t - e.t < 6 || e.t > t);
+      elEvents.innerHTML = live.slice(-4).map((e) => `<div>${e.text}</div>`).join('');
+
+      // --- corner bars ---
+      barGroup.visible = d.rig.rigged && (storm || phase === 'prep');
+      if (!barGroup.visible) return;
+
+      ensureBars(d.rig.corners.length);
+      labelT += dt;
+      const redraw = labelT >= 0.12;
+      if (redraw) labelT = 0;
+      d.camera.getWorldQuaternion(_q);
+      d.camera.getWorldPosition(_cam);
+
+      for (let i = 0; i < d.rig.corners.length; i++) {
+        const c = d.rig.corners[i];
+        const b = bars[i];
+        const p = cornerPos(i);
+        if (!p) { b.holder.visible = false; continue; }
+
+        _p.set(p.x, p.y, p.z);
+        b.holder.position.copy(_p);
+        b.holder.position.y += 0.45;
+        b.holder.quaternion.copy(_q);
+
+        // Hold roughly constant screen size. A house corner is ~18 m away when
+        // you're standing at the posts, and at that range a world-sized bar is
+        // a few unreadable pixels — which defeats the entire point of putting it
+        // out there rather than in a corner of the screen. Clamped so it doesn't
+        // balloon when you walk right up to a corner to repair it.
+        const dist = _p.distanceTo(_cam);
+        b.holder.scale.setScalar(Math.max(0.75, Math.min(3.2, dist / 7)));
+
+        const frac = clamp01((c.load || 0) / c.hw.rating);
+        b.fill.scale.x = Math.max(0.001, (c.broken ? 1 : frac) * BAR_W);
+        b.fill.material.color.setHex(barColor(frac, c.broken));
+
+        if (redraw) {
+          const text = c.broken
+            ? `${c.anchorId.toUpperCase()} BLOWN`
+            : `${c.anchorId.toUpperCase()} ${((c.load || 0) / 1000).toFixed(1)}/${(c.hw.rating / 1000).toFixed(1)}kN`;
+          if (text !== b.lastText) {
+            b.lastText = text;
+            drawLabel(b.label, text, c.broken ? '#ff8f86' : frac > 0.85 ? '#ffb1ab' : '#dde5ea');
+          }
+        }
+      }
+    },
+
+    // --- cards ------------------------------------------------------------
+
+    /**
+     * The forecast. Its job is to sell the dread and, incidentally, to be the
+     * difficulty select for free — three authored storms already bracket the
+     * range, so letting the player pick one IS the choice.
+     *
+     * @param {{key:string, def:object}[]} storms
+     * @param {(key:string) => void} onPick
+     */
+    showForecast(storms, onPick) {
+      const rows = storms.map(({ key, def }) => {
+        const peak = Math.max(...def.baseCurve.map((p) => p[1]));
+        const gustPeak = peak + (def.gusts?.powBase ?? 0) + (def.gusts?.powRamp ?? 0);
+        const rainPeak = Math.max(...(def.rain?.curve ?? [[0, 0]]).map((p) => p[1]));
+        const change = (def.events ?? []).find((e) => e.type === 'windchange');
+        const night = (def.sky?.darkness ?? 0) > 0.6;
+        return `<button class="storm" data-key="${key}">
+          <div class="name">${(def.name ?? key).replace(/_/g, ' ').toUpperCase()}${night ? '  ·  NIGHT' : ''}</div>
+          <div class="stat">sustained to ${peak.toFixed(0)} m/s (${kmh(peak).toFixed(0)} km/h)
+            · gusts to ~${kmh(gustPeak).toFixed(0)} km/h</div>
+          <div class="stat">rain ${rainPeak >= 0.8 ? 'heavy' : rainPeak >= 0.4 ? 'steady' : 'light'}
+            ${change ? `· southerly change at ${change.t}s` : '· no change forecast'}</div>
+        </button>`;
+      }).join('');
+
+      card.innerHTML = `<div class="card">
+        <h1>FORECAST</h1>
+        <h2>90 seconds of storm. Pick your night, then rig for it.</h2>
+        ${rows}
+        <div class="stat" style="color:#8ba0ad;margin-top:12px">
+          A change means the corners that were slack all storm are the loaded ones after it.
+        </div>
+      </div>`;
+      card.classList.add('on');
+      hud.setVisible(false);
+      for (const b of card.querySelectorAll('.storm')) {
+        b.addEventListener('click', () => { hud.hideCard(); onPick(b.dataset.key); });
+      }
+    },
+
+    /**
+     * @param {object} r  {hp, cornersLost, cornersTotal, bill, collateral, budgetLeft, win}
+     * @param {() => void} onAgain
+     */
+    showAftermath(r, onAgain) {
+      const rows = [
+        ['garden', `${r.hp.toFixed(0)}%`],
+        ['corners intact', `${r.cornersTotal - r.cornersLost}/${r.cornersTotal}`],
+        ['hardware lost', r.bill ? `$${r.bill}` : 'none'],
+        ['collateral', r.collateral.length ? r.collateral.map((c) => `${c.what} ($${c.cost})`).join(', ') : 'none'],
+        ['budget left', `$${r.budgetLeft}`],
+      ].map(([k, v]) => `<div class="row"><span>${k}</span><b>${v}</b></div>`).join('');
+
+      card.innerHTML = `<div class="card">
+        <h1>AFTERMATH</h1>
+        <h2>${r.subtitle}</h2>
+        ${rows}
+        <div class="verdict ${r.win ? 'win' : 'lose'}">${r.verdict}</div>
+        <button class="go">PLAY AGAIN</button>
+      </div>`;
+      card.classList.add('on');
+      hud.setVisible(false);
+      card.querySelector('.go').addEventListener('click', () => { hud.hideCard(); onAgain(); });
+    },
+
+    hideCard() {
+      card.classList.remove('on');
+      card.innerHTML = '';
+      hud.setVisible(true);
+    },
+
+    get cardOpen() { return card.classList.contains('on'); },
+
+    dispose() {
+      root.remove(); card.remove(); style.remove();
+      d.scene.remove(barGroup);
+      quad.dispose();
+      for (const b of bars) {
+        b.fill.material.dispose();
+        b.label.material.map?.dispose();
+        b.label.material.dispose();
+      }
+    },
+  };
+
+  return hud;
+}

web/world/js/interact.js

@@ -28,7 +28,13 @@ export class Interact {
    * @param {number}   [spec.radius]   metres
    * @param {number}   [spec.holdSecs]
    * @param {string|function} [spec.label]  string, or (player)->string for live text
-   * @param {function} [spec.canUse]   (player) -> bool
+   * @param {function} [spec.canUse]   (player) -> bool.
+   *   **Do not test `player.state` in here.** canUse is re-checked every frame to KEEP a hold alive,
+   *   and starting a hold moves the player into `busy` — so `canUse: p => p.state === 'idle'` goes
+   *   false on frame one and the action silently cancels its own hold. It looks exactly like a dead
+   *   prompt. Gate on physical facts instead (carrying, position, height); locked states already
+   *   can't start a hold, because step() checks `!player.busy` first. This bit twice: the ladder's
+   *   climb and the fascia reach gate.
    * @param {function} [spec.onDone]   (player, t) -> void
    * @param {string}   [spec.clip]     verb played for the length of the hold ('Crank', 'PickUp', …).
    *   Must name a clip in player_anims.glb; omitted means the busy state's default Idle.
@@ -149,14 +155,35 @@ export class Interact {
  */
 export function wireYardActions(interact, deps = {}) {
   const { sailRig, world } = 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;
   const wired = [];
   const cornerAt = (i) => (sailRig && sailRig.corners && sailRig.corners[i]) || null;
+  const anchorOf = (i) => {
+    const c = cornerAt(i);
+    if (!c) return null;
+    return c.anchor || (world && world.anchors && world.anchors.find((a) => a.id === c.anchorId)) || null;
+  };
   // a flogging corner is MOVING — resolve position every frame, never once at wire time
   const posAt = (i) => () => {
     const c = cornerAt(i);
     if (!c) return null;
+    // A fascia corner is worked AT THE BRACKET, not at the cloth: the corner has detached and the
+    // sail is hanging down somewhere, but re-attaching it means getting a shackle onto a fitting
+    // 2.48 m up a wall. So the prompt lives at the anchor and you need the ladder to hold it.
+    if (ladder && ladder.needsLadder(anchorOf(i))) {
+      const a = anchorOf(i);
+      return { x: a.pos.x, y: a.pos.y, z: a.pos.z + 0.9 };
+    }
     return (sailRig.cornerPos && sailRig.cornerPos(i)) || c.pos || null;
   };
+  /** Fascia work needs you up the ladder that's planted under THAT bracket. */
+  const canReach = (i, p) => {
+    const a = anchorOf(i);
+    if (!ladder || !ladder.needsLadder(a)) return true;      // everything else is ground work
+    return ladder.isWorking(a.id) && p.reachY >= a.pos.y;
+  };
 
   if (sailRig && Array.isArray(sailRig.corners)) {
     sailRig.corners.forEach((_corner, i) => {
@@ -166,10 +193,10 @@ export function wireYardActions(interact, deps = {}) {
         pos: posAt(i),
         radius: 1.8,
         holdSecs: 2.5,
-        label: 're-rig corner',
+        label: (p) => (canReach(i, p) ? 're-rig corner' : 'out of reach — needs the ladder'),
         clip: 'Crank',
         canUse: (p) => !!(cornerAt(i) && cornerAt(i).broken)
-          && p.carrying === 'spare' && !!sailRig.repair,
+          && p.carrying === 'spare' && !!sailRig.repair && canReach(i, p),
         onDone: (p) => { p.carrying = null; sailRig.repair(i); },
       }));
       // per-corner turnbuckle trim — new vs the prototype; makes corners individual
@@ -178,9 +205,9 @@ export function wireYardActions(interact, deps = {}) {
         pos: posAt(i),
         radius: 1.8,
         holdSecs: 1.2,
-        label: 'tighten turnbuckle',
+        label: (p) => (canReach(i, p) ? 'tighten turnbuckle' : 'out of reach — needs the ladder'),
         clip: 'Crank',
-        canUse: () => !!cornerAt(i) && !cornerAt(i).broken && !!sailRig.trim,
+        canUse: (p) => !!cornerAt(i) && !cornerAt(i).broken && !!sailRig.trim && canReach(i, p),
         onDone: () => sailRig.trim(i, +0.1),
       }));
     });

web/world/js/ladder.js

@@ -0,0 +1,210 @@
+/**
+ * ladder.js — the ladder sub-system.  (Lane D, SPRINT4 decision 12)
+ *
+ * Why it exists: the house fascia brackets sit at y=2.48 and a 1.72 m person's hands reach 2.20.
+ * Two hundred millimetres is the whole mechanic. Everything else in the yard you can rig from the
+ * ground — a sail post is tensioned from a cleat at its base, a tree anchor is a strop you throw —
+ * but a bracket bolted 2.5 m up a bare wall is not negotiable, and E's ladder tops out at exactly
+ * 2.9 m. The asset and the yard were built for each other; this file is the verb between them.
+ *
+ * The loop it creates is the "limited hands" rule from DESIGN.md doing real work:
+ *   ladder and spare are BOTH carry items, and you can only hold one.
+ *   So a fascia repair costs two trips — fetch the ladder, plant it, go back for the spare —
+ *   while a post repair costs one. The house is the expensive anchor to depend on, which is
+ *   exactly what E's ratingHint 0.35 / collateral "gutter" is already telling you in the data.
+ *
+ * Ownership: Lane D. Self-wires from createPlayer() in player.js, so main.js (Lane A's file) needs
+ * no change to get this — it already hands createPlayer the scene, world and interact.
+ */
+import * as THREE from '../vendor/three.module.js';
+import { GLTFLoader } from '../vendor/addons/loaders/GLTFLoader.js';
+
+export const LADDER_URL = './models/ladder_01_v1.glb';
+
+/**
+ * Which anchors you cannot rig from the ground.
+ *
+ * Deliberately keyed on the anchor TYPE, not on a height test. A pure "is it above reach?" rule
+ * would rope in the posts (3.95 m) and tree limbs (up to 5.05 m) and turn every single repair into
+ * a two-trip ladder job — which is both untrue to how sails are actually rigged and would have
+ * silently invalidated the recorded §7 run and Lane B's gate asserts. Decision 12 scopes this to
+ * the fascia; this is that scope, in one line, where it can be found and argued with.
+ */
+export const needsLadder = (anchor) => !!anchor && anchor.type === 'house';
+
+/** Where the player stands to work a fascia anchor: out from the wall, at the anchor's x. */
+const STAND_OFF = 0.9;      // m clear of the wall face
+const PLACE_RANGE = 2.6;    // m — how close you must be to a fascia anchor to plant the ladder
+const RUNG_CLEAR = 0.55;    // m — feet this far below the top rung, so the fascia is at chest height
+
+/**
+ * @param {THREE.Object3D} scene
+ * @param {object} world     contracts World (must be dressed — anchors are final only after dress())
+ * @param {object} interact  Lane D's Interact
+ * @param {object} player    the PlayerSim
+ * @returns {object} the ladder system
+ */
+export function createLadder(scene, world, interact, player) {
+  const anchors = (world.anchors || []).filter(needsLadder);
+  if (!anchors.length) {
+    // no fascia in this yard (a bare harness, say) — the whole sub-system is moot, don't half-wire it
+    return { placedAt: null, carried: false, needsLadder, isWorking: () => false,
+      workY: () => 0, servedAnchor: () => null, update() {}, dispose() {} };
+  }
+
+  const state = {
+    carried: false,          // in the player's hands
+    placedAt: null,          // anchor id, or null while stowed/carried
+    base: new THREE.Vector3(),
+    topY: 2.9,               // overwritten from the GLB's ladder_top node
+    view: null,
+  };
+
+  // Home: leaning on the shed, near the spare table but NOT on top of it. Read from world.shedTable
+  // so it follows the shed if Lane A moves it. The offset is deliberately ~3 m: at 1.4 m the two
+  // prompts overlapped and standing at the ladder offered you "take a spare", which is the kind of
+  // thing that reads as a broken game rather than a crowded shed.
+  const home = new THREE.Vector3(10.4, 0, 3.4);
+  if (world.shedTable && world.shedTable.pos) {
+    home.set(world.shedTable.pos.x + 1.4, 0, world.shedTable.pos.z - 2.6);
+  }
+  home.y = world.heightAt ? world.heightAt(home.x, home.z) : 0;
+  state.base.copy(home);
+
+  // --- view -----------------------------------------------------------------
+  new GLTFLoader().load(LADDER_URL, (g) => {
+    const obj = g.scene;
+    const top = obj.getObjectByName('ladder_top');
+    if (top) state.topY = top.position.y;
+    obj.traverse((o) => { if (o.isMesh) { o.castShadow = true; o.frustumCulled = false; } });
+    state.view = obj;
+    scene.add(obj);
+    syncView();
+  }, undefined, () => { /* missing asset: the mechanic still works, you just can't see it */ });
+
+  const LEAN = 0.26;   // rad (~15°) — a ladder stood bolt upright reads as a post, not a ladder
+  function syncView() {
+    if (!state.view) return;
+    state.view.visible = !state.carried;
+    state.view.position.copy(state.base);
+    const a = state.placedAt && world.anchors.find((x) => x.id === state.placedAt);
+    if (a) {
+      // planted: yaw so local +Z faces the wall, then tip the head into it. +X rotation carries the
+      // top toward local +Z, which is the wall — so the feet stand off and the head rests on it.
+      state.view.rotation.set(LEAN, Math.atan2(a.pos.x - state.base.x, a.pos.z - state.base.z), 0);
+    } else {
+      state.view.rotation.set(0, 0.6, 0.22);   // stowed: slouched against the shed
+    }
+  }
+
+  /** The fascia anchor this ladder is currently serving, if any. */
+  const servedAnchor = () => (state.placedAt ? world.anchors.find((a) => a.id === state.placedAt) : null);
+
+  /** Standing height at the top of the ladder — feet a rung or two down from the very top. */
+  const workY = () => Math.max(0, state.topY - RUNG_CLEAR);
+
+  /**
+   * True if the player is up THIS ladder and can work the given anchor.
+   * Height only, deliberately — hold-E moves the player into `busy`, so testing for state 'atTop'
+   * here would make a fascia repair un-usable the moment it started and cancel its own hold.
+   */
+  function isWorking(anchorId) {
+    return state.placedAt === anchorId && player.climbY > workY() - 0.15;
+  }
+
+  // --- interactions ---------------------------------------------------------
+  const wired = [];
+
+  // 1. pick the ladder up (from its home, or from wherever it's planted)
+  wired.push(interact.register({
+    id: 'ladder_take',
+    pos: () => (state.carried ? null : state.base),
+    radius: 1.6,
+    holdSecs: 0.8,
+    clip: 'PickUp',
+    label: (p) => (p.carrying ? 'hands full' : state.placedAt ? 'take the ladder back' : 'take the ladder'),
+    canUse: (p) => !state.carried && !p.carrying && p.climbY < 0.02,
+    onDone: (p, t) => {
+      state.carried = true;
+      state.placedAt = null;
+      p.pickUp('ladder', t);
+      syncView();
+    },
+  }));
+
+  // 2. plant it at a fascia anchor
+  for (const a of anchors) {
+    wired.push(interact.register({
+      id: `ladder_place_${a.id}`,
+      // stand off the wall, on the yard side — the ladder leans in toward the bracket
+      pos: () => ({ x: a.pos.x, y: 0, z: a.pos.z + STAND_OFF }),
+      radius: PLACE_RANGE,
+      holdSecs: 1.0,
+      clip: 'PickUp',
+      label: `set the ladder under ${a.id}`,
+      canUse: (p) => p.carrying === 'ladder',
+      onDone: (p, t) => {
+        state.carried = false;
+        state.placedAt = a.id;
+        state.base.set(a.pos.x, world.heightAt ? world.heightAt(a.pos.x, a.pos.z + STAND_OFF) : 0,
+          a.pos.z + STAND_OFF);
+        p.carrying = null;
+        p.events.push({ type: 'ladderPlaced', anchorId: a.id, t });
+        syncView();
+      },
+    }));
+  }
+
+  // 3. climb it — only when it's planted, and only from the ground
+  wired.push(interact.register({
+    id: 'ladder_climb',
+    pos: () => (state.placedAt && !state.carried ? state.base : null),
+    radius: 1.5,
+    holdSecs: 0.4,
+    clip: 'PickUp',
+    label: 'climb',
+    // NB: no test on p.state here. Starting a hold moves the player into `busy`, so a canUse that
+    // reads state goes false the instant the hold begins and cancels itself. climbY is the honest
+    // gate (are you on the ground?), and locked states can't start a hold anyway.
+    canUse: (p) => !!state.placedAt && !state.carried && p.climbY < 0.02,
+    onDone: (p, t) => {
+      p.pos.x = state.base.x; p.pos.z = state.base.z;       // step onto the rungs
+      const a = servedAnchor();
+      if (a) p.facing = Math.atan2(a.pos.x - state.base.x, a.pos.z - state.base.z);
+      p.climbTo(workY(), t);
+    },
+  }));
+
+  const api = {
+    get placedAt() { return state.placedAt; },
+    get carried() { return state.carried; },
+    get base() { return state.base; },
+    get topY() { return state.topY; },
+    workY,
+    isWorking,
+    servedAnchor,
+    needsLadder,
+
+    /**
+     * Drive descent from input. Held S climbs down; nothing else can strand you up there, and a
+     * knockdown already drops climbY to 0 on its own.
+     * player.js calls this each frame from the same input it reads for movement.
+     */
+    update(dt, t, input) {
+      if (player.state === 'atTop' && input && input.z < 0) player.climbTo(0, t);
+      syncView();
+    },
+
+    dispose() {
+      wired.forEach((un) => un());
+      if (interact.ladder === api) interact.ladder = null;
+      if (state.view) scene.remove(state.view);
+    },
+  };
+
+  // Publish onto the Interact instance so wireYardActions can find the reach gate without main.js
+  // (Lane A's file) having to learn about ladders and thread it through. Interact is Lane D's own
+  // class, so this stays inside the lane; an explicit `deps.ladder` still wins if anyone passes one.
+  interact.ladder = api;
+  return api;
+}

web/world/js/main.js

@@ -23,10 +23,56 @@ import { createPlayer } from './player.js';
 import { Interact, wireYardActions } from './interact.js';
 import { createDebris } from './debris.js';
 import { createSkyFx } from './skyfx.js';
+import { createRiggingUI } from './rigging.js';
+import { createHud } from './hud.js';
 
-/** Which storm each phase runs under (SPRINT2 §Lane A.1). */
+/** The calm day the forecast and prep phases run under. */
 const CALM_STORM = 'storm_01_gentle';
-const WILD_STORM = 'storm_02_wildnight';
+
+/** The storms you can pick from the forecast card — this is the difficulty select. */
+const STORMS = ['storm_01_gentle', 'storm_03_southerly', 'storm_02_wildnight'];
+
+/**
+ * How fast an unprotected garden dies, in HP per second at full rain.
+ *
+ * Decision 7: drain is rain × (1 − rain shadow), NOT sun coverage. At night the
+ * sun shadow is a number about nothing, and storm_02 is a wildnight.
+ *
+ * ⚠️ This number is doing less work than it looks like it is, and the reason is
+ * worth reading before retuning it. Measured over storm_02 with a rig that holds
+ * 4/4 corners all night: sun coverage over the bed stays ~50%, but the RAIN
+ * shadow decays 0.38 → 0.04 as the wind builds, averaging 0.23. Driving rain
+ * blows under the sail and the shadow walks off the bed — which is Lane C's
+ * model being right about weather, not a bug.
+ *
+ * The consequence is that a perfectly rigged bed only ever sits ~23% drier than
+ * a bare one, so NO value here separates good rigging from none; at 1.6 both
+ * ended dead, and the spread stays ~20 points at any setting. 0.9 is chosen to
+ * put a good rig around 60% (a win) and a bare bed just under 50% (a loss), so
+ * the loop is playable and scores something — but the lever that actually needs
+ * moving is the shadow geometry, not this. Flagged for Lane C in THREADS.
+ */
+const GARDEN_DRAIN = 0.9;
+
+/**
+ * The garden: the thing you are actually protecting, and the only score that
+ * matters. Deliberately not inside hud.js — the HUD reads, it doesn't decide.
+ */
+function createGarden(world) {
+  let hp = 100;
+  let state = 'full';
+  return {
+    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);
+      const next = hp > 66 ? 'full' : hp > 33 ? 'tattered' : 'dead';
+      if (next !== state) { state = next; world.setPlants(next); }
+    },
+  };
+}
 
 // ---------------------------------------------------------------------------
 // Phase machine
@@ -103,6 +149,8 @@ function createWindRouter(all) {
     gustTelegraph: (t) => active.gustTelegraph(t),
     eventsBetween: (a, b) => active.eventsBetween(a, b),
     rainAt: (t) => active.rainAt(t),
+    rainMmPerHour: (t) => active.rainMmPerHour(t),
+    rainDepthMm: (a, b) => active.rainDepthMm(a, b),
     dirAt: (t) => active.dirAt(t),
 
     setShelters(list) {
@@ -180,12 +228,15 @@ export async function boot(opts = {}) {
   const scene = new THREE.Scene();
 
   // --- 1. weather ---------------------------------------------------------
-  // Both storms load up front: the forecast card needs to read storm_02's shape
-  // before the player has agreed to face it.
-  const [calmDef, wildDef] = await Promise.all([loadStorm(CALM_STORM), loadStorm(WILD_STORM)]);
-  const calmWind = createWind(calmDef);
-  const wildWind = createWind(wildDef);
-  const wind = createWindRouter([calmWind, wildWind]);
+  // Every storm loads up front: the forecast card has to read their shapes to
+  // sell them before the player has agreed to face one.
+  const defs = Object.fromEntries(
+    await Promise.all(STORMS.map(async (k) => [k, await loadStorm(k)])),
+  );
+  const winds = Object.fromEntries(Object.entries(defs).map(([k, def]) => [k, createWind(def)]));
+  const calmWind = winds[CALM_STORM];
+  let stormKey = 'storm_02_wildnight';
+  const wind = createWindRouter(Object.values(winds));
 
   // --- world & camera -----------------------------------------------------
   const world = createWorld(scene, { wind });
@@ -239,9 +290,8 @@ export async function boot(opts = {}) {
   // repair. Deliberately the prototype's AUTO loadout — one dodgy carabiner
   // corner. It also spans most of the yard, which is the 70–192 m² problem
   // decision 2 fixes in step 6, not a fault in the cloth.
-  await rigSail(['h1', 'h3', 'p2', 'p1'], [HARDWARE[2], HARDWARE[1], HARDWARE[1], HARDWARE[0]]);
-
   const game = createGame();
+  const garden = createGarden(world);
 
   // --- clocks -------------------------------------------------------------
   // Two of them, and the distinction matters. `simT` is wall-clock seconds since
@@ -311,25 +361,134 @@ export async function boot(opts = {}) {
   addEventListener('pointerdown', unlock);
   addEventListener('keydown', unlock);
 
-  // --- dev overlay (temporary — hud.js replaces it in step 7) -------------
-  const hud = document.getElementById('dev');
+  // --- 5. the face --------------------------------------------------------
   const banner = document.getElementById('banner');
-  addEventListener('keydown', (e) => {
-    if (e.key === 'Enter') game.advance();
+  const hud = createHud({
+    scene, camera: cameraRig.object, game, world, wind, player, rig, garden, events,
+    getSky: () => sky,
   });
 
+  // Lane B's picking adapter. `panel:false` — their built-in panel is a fine
+  // bench, but hud.js owns the screen now, so the two shouldn't both draw.
+  const rigging = await createRiggingUI({
+    scene,
+    camera: cameraRig.object,
+    domElement: canvas,
+    world,
+    onCommit: (ids, hw, tension) => { void rigSail(ids, hw, tension); },
+    onMessage: pushEvent,
+    panel: true,
+  });
+
+  /**
+   * Clear last round's rig so "play again" is a new job, not a continuation.
+   *
+   * Without this you inherit the previous round's corners AND its spent budget —
+   * a second round starts at $35 with three corners already hung, and the four
+   * anchors you click get silently ignored because the session is already full.
+   * That is not a subtle failure; it makes the second round unplayable.
+   *
+   * Done through the session's own public moves rather than by reaching into its
+   * fields: unrig() refunds the corner's CURRENT hardware and setSpares(0)
+   * refunds the spare, so the budget walks back to $80 on its own and the
+   * economy stays the single source of truth. (Lane B: a `session.reset()` would
+   * say this better than five lines of mine — asked in THREADS.)
+   */
+  function resetRig() {
+    const s = rigging.session;
+    for (const p of [...s.picks]) s.unrig(p.anchorId);
+    s.setSpares(0);
+    s.setTension(1.0);
+  }
+
+  /** What the storm cost, assembled at the moment it ends. */
+  function scoreRun() {
+    const lost = rig.corners.filter((c) => c.broken);
+    const bill = lost.reduce((s, c) => s + c.hw.cost, 0);
+    const collateral = [];
+    // The gnome is collateral if the sail came down over it. DESIGN.md: the
+    // worst debris in any storm is your own failed work.
+    if (lost.length >= 2) collateral.push({ what: 'garden gnome', cost: world.gnome.collateralValue });
+    const s = rigging.summary;
+    const hp = garden.hp;
+    const win = hp >= 50 && lost.length < 2;
+    return {
+      hp,
+      cornersLost: lost.length,
+      cornersTotal: rig.corners.length || 4,
+      bill,
+      collateral,
+      budgetLeft: Math.max(0, s.budget - bill - collateral.reduce((a, c) => a + c.cost, 0)),
+      win,
+      subtitle: lost.length
+        ? `${lost.map((c) => `${c.hw.name} at ${c.anchorId.toUpperCase()}`).join(', ')} let go.`
+        : 'Every corner held.',
+      verdict: hp >= 85 && !lost.length ? 'THE GARDEN MADE IT — not a leaf out of place.'
+        : win ? 'THE GARDEN MADE IT. Mostly.'
+        : hp < 50 ? 'THE GARDEN IS GONE. The rain found what you skimped on.'
+        : 'THE SAIL LOST. Warranty callout in the rain for you.',
+    };
+  }
+
   // --- phases -------------------------------------------------------------
   game.on('phaseChange', ({ to }) => {
-    wind.use(to === 'storm' ? wildWind : calmWind);
+    // Prep and forecast happen on the calm day; the storm you picked only
+    // arrives when you say go.
+    wind.use(to === 'storm' ? winds[stormKey] : calmWind);
     makeSky();
     events.length = 0;
-    if (banner) {
+    rigging.setActive(to === 'prep');
+
+    if (to === 'forecast') {
+      garden.reset();
+      resetRig();
+      player.sim.carrying = null;
+      hud.showForecast(
+        STORMS.map((key) => ({ key, def: defs[key] })),
+        (key) => { stormKey = key; game.setPhase('prep'); },
+      );
+    }
+    // The card belongs to the phase, not to the button that happened to open it.
+    // Tying its lifetime to the forecast button meant any other route into prep
+    // (a debug jump, a future timer, "play again" landing somewhere new) left a
+    // card floating over a live game, swallowing input.
+    if (to === 'prep' || to === 'storm') hud.hideCard();
+
+    if (to === 'prep') {
+      hud.setHelp('click an anchor to rig · click again to cycle hardware · shift-click to remove · [ ] tension · S spare · ENTER when you have four');
+    }
+    if (to === 'storm') {
+      hud.setHelp('WASD move · shift run · E repair/pickup · C brace · RMB orbit');
+    }
+    if (to === 'aftermath') {
+      hud.showAftermath(scoreRun(), () => game.setPhase('forecast'));
+    }
+
+    if (banner && to !== 'forecast' && to !== 'aftermath') {
       banner.textContent = to.toUpperCase();
       banner.style.opacity = '1';
       setTimeout(() => { banner.style.opacity = '0'; }, 1400);
     }
   });
 
+  addEventListener('keydown', (e) => {
+    if (e.key !== 'Enter' || hud.cardOpen) return;
+    // Leaving prep means committing the rig — Lane B's session refuses if it
+    // isn't four corners, and says so in the ticker.
+    if (game.phase === 'prep') {
+      if (!rigging.commit()) return;
+      player.sim.carrying = null;
+      if (rigging.summary.spares > 0) pushEvent(`spare shackle on the shed table — grab it before you need it`);
+    }
+    game.advance();
+  });
+
+  // Straight into the forecast: the card is the game's front door.
+  hud.showForecast(
+    STORMS.map((key) => ({ key, def: defs[key] })),
+    (key) => { stormKey = key; game.setPhase('prep'); },
+  );
+
   // --- resize -------------------------------------------------------------
   function resize() {
     const w = canvas.clientWidth || innerWidth;
@@ -342,6 +501,7 @@ export async function boot(opts = {}) {
 
   // --- loop ---------------------------------------------------------------
   const clock = new THREE.Clock();
+  const dev = document.getElementById('dev');
   let frames = 0, fpsT = 0, fps = 0;
 
   function step(dt) {
@@ -353,6 +513,15 @@ export async function boot(opts = {}) {
     rig.step(dt, wind, windT, debris);
     debris.step(dt, windT, { player: player.sim, sail: rig });
     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.
+    if (game.phase === 'storm') {
+      const rain = wind.rainAt(windT);
+      const dry = sky?.rainShadowOver ? sky.rainShadowOver(world.gardenBed) : 0;
+      garden.step(dt, rain, dry);
+    }
   }
 
   function frame() {
@@ -370,19 +539,11 @@ export async function boot(opts = {}) {
     sailView?.update();
     renderer.render(scene, cameraRig.object);
 
+    hud.update(raw, windT);
+
     frames++; fpsT += raw;
     if (fpsT >= 0.5) { fps = frames / fpsT; frames = 0; fpsT = 0; }
-    if (hud) {
-      const wt = windT;
-      const speed = wind.speedAt(player.pos, wt);
-      const tel = wind.gustTelegraph(wt);
-      const worst = rig.corners.reduce((m, c) => Math.max(m, c.load || 0), 0);
-      hud.textContent =
-        `${fps.toFixed(0)} fps | ${game.phase} ${game.phaseT.toFixed(1)}s | ` +
-        `wind ${speed.toFixed(1)} m/s${tel ? ` | GUST in ${tel.eta.toFixed(1)}s` : ''} | ` +
-        `worst corner ${worst.toFixed(1)} | debris ${debris.pieces.length}` +
-        `${events.length ? ` | ${events[events.length - 1].text}` : ''}`;
-    }
+    if (dev) dev.textContent = `${fps.toFixed(0)} fps · ${game.phase} ${game.phaseT.toFixed(1)}s · t ${simT.toFixed(0)}s · debris ${debris.pieces.length}`;
     requestAnimationFrame(frame);
   }
   requestAnimationFrame(frame);
@@ -392,11 +553,14 @@ export async function boot(opts = {}) {
   const api = {
     renderer, scene, world, cameraRig, player, game, wind, rig, rigSail,
     get sailView() { return sailView; },
-    debris, interact, events,
+    debris, interact, events, hud, rigging, garden, defs, winds,
+    get stormKey() { return stormKey; },
+    set stormKey(k) { stormKey = k; },
+    scoreRun,
     get sky() { return sky; },
     get simT() { return simT; },
     windTime,
-    calmWind, wildWind,
+    calmWind,
 
     /**
      * Drive the sim by hand at fixed dt, and draw on demand. rAF is throttled to

web/world/js/player.js

@@ -15,9 +15,10 @@
 import * as THREE from '../vendor/three.module.js';
 import { clone as skeletonClone } from '../vendor/addons/utils/SkeletonUtils.js';
 import { GLTFLoader } from '../vendor/addons/loaders/GLTFLoader.js';
-import { PlayerSim, STATES, TUNE, clipFor } from './player.sim.js';
+import { PlayerSim, STATES, TUNE, clipFor, onLadder } from './player.sim.js';
+import { createLadder } from './ladder.js';
 
-export { PlayerSim, STATES, TUNE, clipFor };
+export { PlayerSim, STATES, TUNE, clipFor, onLadder, createLadder };
 
 export const CHAR_URL = './models/player_01.glb';
 export const ANIM_URL = './models/player_anims.glb';
@@ -193,7 +194,10 @@ export class PlayerView {
     // clipFor, not st.clip: carrying swaps in Carry/CarryIdle, and an interaction names its own verb
     this.play(clipFor(sim), st.loop !== false);
 
-    this.root.position.set(sim.pos.x, sim.pos.y, sim.pos.z);
+    // climbY lifts the whole rig up the rungs. Same trick as the knockdown pitch: _rotOnly strips
+    // the root from every clip, so ClimbLadder can't raise the body — the sim does, and the clip
+    // just supplies the arms and legs.
+    this.root.position.set(sim.pos.x, sim.pos.y + (sim.climbY || 0), sim.pos.z);
 
     // yaw, then tip over about a world-horizontal axis square to the fall direction, pivoting at the
     // feet. At pitch 0 this is exactly the yaw, so upright play is untouched.
@@ -278,6 +282,12 @@ export async function createPlayer(scene, world, cameraRig, opts = {}) {
   const keyboard = new KeyboardInput();
   const { sim, view } = p;
 
+  // The ladder self-wires from here rather than from main.js: createPlayer is already handed the
+  // scene, the world and interact, which is everything it needs — so Lane A's file doesn't have to
+  // 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);
+
   return {
     get pos() { return sim.pos; },
     get carrying() { return sim.carrying; },
@@ -288,6 +298,7 @@ export async function createPlayer(scene, world, cameraRig, opts = {}) {
     update(dt, t) {
       const input = keyboard.read(cameraRig ? cameraRig.yaw || 0 : 0);
       sim.step(dt, t, input, opts.wind);
+      if (ladder) ladder.update(dt, t, input);
       if (opts.interact) opts.interact.step(dt, t, sim, keyboard.holding);
       view.sync(sim, dt);
     },
@@ -296,8 +307,9 @@ export async function createPlayer(scene, world, cameraRig, opts = {}) {
     get object() { return view.root; },
     sim,
     view,
+    ladder,
     keyboard,
-    dispose() { keyboard.dispose(); view.dispose(); },
+    dispose() { keyboard.dispose(); view.dispose(); if (ladder) ladder.dispose(); },
   };
 }
 

web/world/js/player.sim.js

@@ -29,8 +29,26 @@ export const STATES = {
   stagger: { clip: 'Reaction',      locked: true,  loop: false, secs: 0.9, next: 'idle' },
   knocked: { clip: 'Falling',       locked: true,  loop: false, secs: 1.4, next: 'getup' },
   getup:   { clip: 'CrouchToStand', locked: true,  loop: false, secs: 1.3, next: 'idle' },
+
+  // --- the ladder (decision 12). climbY is driven in code and the clip plays on top, exactly the
+  // knockdown precedent: _rotOnly strips the root, so ClimbLadder can no more lift the body than
+  // Falling could lay it down. ladder.js calls climbTo(); the sim owns the height. ---
+  climb:   { clip: 'ClimbLadder',   locked: true,  loop: true, releasedBy: 'ladder' },
+  // atTop is deliberately NOT locked: `busy` gates interact.js, and the whole point of being up
+  // there is that hold-E works. Movement is stopped by `onLadder` instead, not by `locked`.
+  atTop:   { clip: 'Idle',          carryClip: 'CarryIdle', locked: false, loop: true, releasedBy: 'ladder' },
 };
 
+/**
+ * True while the player is on a ladder — movement is off, and the wind is meaner.
+ *
+ * Keyed on HEIGHT, not on state, and that distinction is load-bearing: hold-E puts you into `busy`,
+ * so a state-based test would say you'd stepped off the ladder the instant you started the repair
+ * you climbed up to do. (It did exactly that — the gate cancelled its own hold.) Height is the
+ * physical truth and survives every state the ladder passes through.
+ */
+export const onLadder = (sim) => sim.climbY > 0.02 || sim.state === 'climb';
+
 /**
  * Which clip a state actually plays right now. Carrying swaps the locomotion set (Carry/CarryIdle),
  * and an interaction can name its own verb (`Crank` at a turnbuckle, `PickUp` at the shed table) —
@@ -96,6 +114,13 @@ export const TUNE = {
   // gusts are too strong to cross the yard" — wait one out, then move in the lull.
   shelterKnockMult: 2.0,  // knockWind × this while braced — a gust that floors you standing won't
   shelterShoveMult: 0.25, // and it barely pushes you
+
+  // Ladder (decision 12). DESIGN.md: "ladder work at height in wind is genuinely tense" — this is
+  // where that gets teeth. You cannot brace up there (both hands are on the rungs), so the only
+  // defence is choosing your moment: climb in a lull, not through a gust.
+  climbRate: 1.1,         // m/s up or down a rung — slow enough that the storm gets a vote
+  reach: 2.2,             // m — how high a 1.72 m person's hands get, standing. Fascia sits at 2.48.
+  ladderKnockMult: 0.6,   // knockWind × this while on the ladder — far easier to be blown off
 };
 
 const clamp = (v, lo, hi) => (v < lo ? lo : v > hi ? hi : v);
@@ -140,6 +165,10 @@ export class PlayerSim {
     this.pitch = 0;                     // 0 upright … 1 flat on the ground
     this.knockDir = { x: 0, z: 1 };     // which way the body went down
 
+    this.climbY = 0;                    // m above the ground; >0 means you're up a ladder
+    this.climbTarget = 0;               // where ladder.js asked you to be
+    this.fellFrom = 0;                  // m — height of the last fall, for the HUD/aftermath to shame you with
+
     this.groundAt = opts.groundAt || (() => 0);
     this.collide = opts.collide || null;
     this.bodyHeight = opts.height || 1.72;
@@ -151,6 +180,23 @@ export class PlayerSim {
   get clip() { return STATES[this.state].clip; }
   get speed() { return Math.hypot(this.vel.x, this.vel.z); }
 
+  /** How high this person's hands get right now. The gate on reaching a fascia bracket. */
+  get reachY() { return this.pos.y + this.climbY + this.tune.reach; }
+
+  /**
+   * Go up or down a ladder. ladder.js owns WHERE (it knows the rungs); the sim owns the motion, so
+   * a climb is deterministic and fast-forwards in selftest like everything else.
+   * @param {number} y  target height above ground; 0 climbs back down
+   */
+  climbTo(y, t = 0) {
+    this.climbTarget = Math.max(0, y);
+    if (Math.abs(this.climbTarget - this.climbY) > 0.02) {
+      this.vel.x = this.vel.z = 0;
+      this.setState('climb', t);
+    }
+    return true;
+  }
+
   setState(s, t = 0) {
     if (this.state === s) return false;
     if (!STATES[s]) throw new Error(`player: unknown state ${s}`);
@@ -194,11 +240,16 @@ export class PlayerSim {
     if (x === undefined || (x === 0 && z === 0)) { x = Math.sin(this.facing); z = Math.cos(this.facing); }
     const m = Math.hypot(x, z) || 1;
     this.knockDir = { x: x / m, z: z / m };
+    // Blown off a ladder: you don't stagger, you fall. Everything else about a knockdown is the
+    // same, so the ladder gets the get-up chain for free — you just arrive on the ground first.
+    this.fellFrom = this.climbY;
+    this.climbY = 0;
+    this.climbTarget = 0;
     this.setState('knocked', t);
     this.exposure = 0;
     this.vel.x = this.vel.z = 0;
     this.drop(t);
-    this.events.push({ type: 'knockdown', t, dir: { ...this.knockDir } });
+    this.events.push({ type: 'knockdown', t, dir: { ...this.knockDir }, fellFrom: this.fellFrom });
     return true;
   }
 
@@ -225,7 +276,9 @@ export class PlayerSim {
     this.gust = Math.max(0, ws - this.windBase);
 
     // --- shelter: hold to brace. Enters and leaves itself, so releasing the key always frees you
-    //     even mid-gust. Refused while you're down — you can't brace from your back. ---
+    //     even mid-gust. Refused while you're down — you can't brace from your back, and refused on
+    //     a ladder: both hands are on the rungs. Up there your only defence is having picked a lull. ---
+    const up = onLadder(this);
     const wantShelter = !!input.shelter;
     const canShelter = this.state === 'idle' || this.state === 'walk' || this.state === 'run';
     if (wantShelter && canShelter) this.setState('shelter', t);
@@ -233,12 +286,34 @@ export class PlayerSim {
     const braced = this.state === 'shelter';
 
     // --- sustained extreme wind puts you down (same rule as a sail corner letting go).
-    //     Bracing raises the bar rather than removing it: a big enough gust still wins. ---
-    const knockAt = braced ? T.knockWind * T.shelterKnockMult : T.knockWind;
+    //     Bracing raises the bar; a ladder LOWERS it. Same exposure clock either way, so the storm
+    //     speaks one language whether you're on your feet or up a rung. ---
+    const knockAt = T.knockWind
+      * (braced ? T.shelterKnockMult : 1)
+      * (up ? T.ladderKnockMult : 1);
     if (ws > knockAt) this.exposure += dt;
     else this.exposure = Math.max(0, this.exposure - dt * T.knockBleed);
     if (this.exposure >= T.knockSustain) this.knockdown(t, wx, wz);
 
+    // --- the climb itself: code-driven height, ClimbLadder plays on top (the knockdown precedent) ---
+    if (this.state === 'climb') {
+      const dy = this.climbTarget - this.climbY;
+      const rung = T.climbRate * dt;
+      if (Math.abs(dy) <= rung) {
+        this.climbY = this.climbTarget;
+        this.setState(this.climbY > 0.02 ? 'atTop' : 'idle', t);
+      } else {
+        this.climbY += Math.sign(dy) * rung;
+      }
+    }
+    // Invariant: you cannot be standing on the grass while you are 2 m up a ladder. interact.js
+    // releases a finished hold to 'idle' without knowing where you are; this puts you back in the
+    // work stance instead of leaving you idling in mid-air.
+    if (this.climbY > 0.02
+        && (this.state === 'idle' || this.state === 'walk' || this.state === 'run')) {
+      this.setState('atTop', t);
+    }
+
     // --- a gust below the knockdown bar can still break your stride ---
     if (!braced && this.gust > T.stumbleGust && this.stumbleCool <= 0
         && (this.state === 'idle' || this.state === 'walk' || this.state === 'run')) {
@@ -248,11 +323,12 @@ export class PlayerSim {
     }
 
     const st = STATES[this.state];
+    const aloft = onLadder(this);   // re-read: the climb block above may have just landed you
 
     // --- movement ---
     const slow = 1 - Math.min(T.slowMax, ws / T.slowRef);   // prototype: rain + wind slow you
     let wantX = 0, wantZ = 0;
-    if (!st.locked) {
+    if (!st.locked && !aloft) {
       const ix = input.x || 0, iz = input.z || 0;
       const mag = Math.hypot(ix, iz);
       if (mag > 1e-3) {
@@ -305,8 +381,10 @@ export class PlayerSim {
     const pstep = dt / T.pitchSecs;
     this.pitch = clamp(this.pitch + clamp(wantPitch - this.pitch, -pstep, pstep), 0, 1);
 
-    // --- locomotion state from actual speed (so shove/slow can't desync the feet) ---
-    if (!st.locked) {
+    // --- locomotion state from actual speed (so shove/slow can't desync the feet).
+    //     `aloft` is what holds you in atTop: it's unlocked (so hold-E works up there), and without
+    //     this guard the speed check would immediately re-state you to idle and drop you off. ---
+    if (!st.locked && !aloft) {
       const sp = this.speed;
       this.setState(sp < 0.15 ? 'idle' : sp > T.walkSpeed * 1.35 ? 'run' : 'walk', t);
     } else if (st.secs && this.stateT >= st.secs && st.next) {

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

@@ -21,6 +21,8 @@ const clamp01 = (v) => (v < 0 ? 0 : v > 1 ? 1 : v);
 const CALM_SKY = new THREE.Color(0x9fc4e8);
 const STORM_SKY = new THREE.Color(0x2a2f3a);
 const NIGHT_SKY = new THREE.Color(0x11141c);
+const WHITE = new THREE.Color(0xffffff);
+const FLASH_COL = new THREE.Color(0xdfe8ff);
 
 // ------------------------------------------------------------ rain shadow
 /**
@@ -440,7 +442,13 @@ export function createSkyFx(o = {}) {
   const skyDef = def.sky || {};
   const darkness = skyDef.darkness ?? 0.7;
   const scroll = skyDef.cloudScroll ?? 0.06;
-  const target = (o.night ?? darkness > 0.6) ? NIGHT_SKY : STORM_SKY;
+  // The storm data gets a say: `sky.night` is the author's call, the darkness
+  // threshold is only a fallback for storms that never state one.
+  const target = (o.night ?? skyDef.night ?? darkness > 0.6) ? NIGHT_SKY : STORM_SKY;
+  // Fire a flash on any gust this strong (m/s of gust power). Storms that don't
+  // ask stay lit only by their authored strikes.
+  const lightningGustPow = skyDef.lightningGustPow ?? Infinity;
+  const firedGusts = new Set();
 
   const rain = createRain({ groundY: o.groundY ?? 0 });
   if (scene) scene.add(rain.mesh);
@@ -510,6 +518,28 @@ export function createSkyFx(o = {}) {
      */
     rainShadowOver(rect) { return shadow.fractionOver(rect); },
 
+    /**
+     * Decision 7's garden-HP drain term, 0..1, in one call — the combined helper
+     * I offered Lane A. This is the whole of "is the bed getting hit right now":
+     *
+     *     hp -= sky.gardenExposure(world.gardenBed, t) * DRAIN_PER_SEC * dt;
+     *
+     * 0 = bone dry (no rain, or the cloth is over it); 1 = full downpour on open
+     * ground. Both terms matter and neither is enough alone: a sail over the bed
+     * in a downpour is 0, and a clear sky with no sail is also 0. It uses the
+     * grid we already rebuild for the rain, so it costs a few array reads.
+     *
+     * Note it moves on its own during storm_02: the rain shadow follows the wind,
+     * so the southerly change walks the dry patch off the bed and the drain
+     * starts climbing without a single corner having failed. That's the mechanic,
+     * not a bug — worth not "fixing" if it looks surprising in the HUD.
+     */
+    gardenExposure(rect, t) {
+      const rain = wind.rainAt(t);
+      if (rain <= 0) return 0;
+      return rain * (1 - shadow.fractionOver(rect));
+    },
+
     /** Wire to the first click/keydown — browsers won't start audio otherwise. */
     unlockAudio() { audio.unlock(); },
 
@@ -539,6 +569,24 @@ export function createSkyFx(o = {}) {
           o.onEvent(ev.text);
         }
       }
+
+      // --- lightning on the biggest gusts ---
+      // The storm's worst moments should light up, not only the three authored
+      // strikes. Driven off the telegraph (which is also what the HUD banner and
+      // the audio whoosh read), so the flash lands WITH the gust that earned it.
+      // Deterministic: the gust timeline is, and each gust fires at most once.
+      const tgl = wind.gustTelegraph(t);
+      if (tgl && tgl.power >= lightningGustPow) {
+        // key on the ramp instant — stable across frames, unique per gust
+        const key = Math.round((t + tgl.eta) * 100);
+        if (!firedGusts.has(key)) {
+          firedGusts.add(key);
+          const p = Math.min(1, 0.45 + (tgl.power - lightningGustPow) * 0.06);
+          flashQueue.push({ at: t + tgl.eta, power: p });
+          flashQueue.push({ at: t + tgl.eta + 0.08 + p * 0.06, power: p * 0.5 });
+          flashQueue.push({ at: t + tgl.eta + 1.1, power: 0, thunder: p });
+        }
+      }
       for (let i = flashQueue.length - 1; i >= 0; i--) {
         if (flashQueue[i].at <= t) {
           const f = flashQueue[i];
@@ -552,7 +600,7 @@ export function createSkyFx(o = {}) {
 
       // --- sky ---
       skyCol.copy(baseSky).lerp(target, storminess * darkness);
-      if (flash > 0) skyCol.lerp(new THREE.Color(0xdfe8ff), Math.min(0.85, flash));
+      if (flash > 0) skyCol.lerp(FLASH_COL, Math.min(0.85, flash));
       if (scene) {
         if (scene.fog) {
           scene.fog.color.copy(skyCol);
@@ -565,6 +613,22 @@ export function createSkyFx(o = {}) {
 
       dome.position.copy(camPos);
       dome.material.opacity = storminess * 0.85;
+      // Tint the CLOUDS, not just the sky behind them. The dome covers the
+      // background at ~0.85 opacity, so darkening `scene.background` alone did
+      // nothing — a "wild night" still read as an overcast afternoon because the
+      // grey cloud texture was what you were actually looking at.
+      //
+      // Both a lerp AND a brightness crush: the lerp alone lands ~#717273 because
+      // it runs in linear space (84% toward night still reads mid-grey in sRGB)
+      // and the cloud texture is baked near-white. The crush is what makes night
+      // look like night. It stops at 0.78 on purpose — the yard has no lights in
+      // it yet, and a storm you can't see isn't a storm, it's a black screen.
+      const nightAmt = storminess * darkness;
+      dome.material.color.copy(WHITE)
+        .lerp(target, nightAmt * 0.92)
+        .multiplyScalar(1 - 0.78 * nightAmt);
+      // and lightning lights the cloud it's inside, which is the whole look
+      if (flash > 0) dome.material.color.lerp(FLASH_COL, Math.min(0.9, flash));
       domeTex.offset.x = (domeTex.offset.x + scroll * dt * (0.4 + speed * 0.05)) % 1;
       domeTex.offset.y = (domeTex.offset.y + scroll * dt * 0.12) % 1;
 

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

@@ -21,7 +21,10 @@ import { createDebris } from '../debris.js';
 import { createSkyFx, RainShadow } from '../skyfx.js';
 import { weatherCases } from './weather.selftest.js';
 
-const STORMS = ['storm_01_gentle', 'storm_02_wildnight'];
+// Keep in step with data/storms/. The node runner globs the directory, so this
+// list going stale shows up here first — as it did when storm_03 landed and the
+// ponding case reached for a storm the browser half had never loaded.
+const STORMS = ['storm_01_gentle', 'storm_02_wildnight', 'storm_03_southerly'];
 
 /** @param {import('../testkit.js').Suite} t */
 export default async function run(t) {
@@ -213,6 +216,55 @@ export default async function run(t) {
     assert(half > 0.2 && half < 0.8, `a rect straddling the edge reads ${half}, want a partial`);
   });
 
+  // --- decision 7: the drain helper Lane A wires garden HP to ---
+  t.test('gardenExposure is rain AND no cover, and needs both', () => {
+    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 };
+
+    // no sail: exposure is simply the rain
+    fixedLoop(1, FIXED_DT, (dt, time) => sky.step(dt, 70 + time, {}));
+    const open = sky.gardenExposure(bed, 70);
+    assert(Math.abs(open - wind.rainAt(70)) < 1e-9,
+      `open ground should be exposed exactly as hard as it rains: ${open} vs ${wind.rainAt(70)}`);
+    assert(open > 0.5, 'storm_02 at t=70 should be pouring');
+
+    // a panel over the bed dries it out
+    const panel = { pos: new Float32Array([-3, 3, -3, 3, 3, -3, 3, 3, 3, -3, 3, 3]), tris: [0, 1, 2, 0, 2, 3] };
+    fixedLoop(1, FIXED_DT, (dt, time) => sky.step(dt, 70 + time, { sail: panel }));
+    const covered = sky.gardenExposure(bed, 70);
+    assert(covered < open * 0.5, `cloth over the bed barely helped: ${covered.toFixed(2)} vs open ${open.toFixed(2)}`);
+
+    // and no rain means no drain, sail or not
+    assert(sky.gardenExposure(bed, 0) === 0, 'the bed is draining before the rain has started');
+    sky.dispose();
+  });
+
+  t.test('storm_02 lights up on its biggest gusts, storm_01 does not', () => {
+    const mk = (name) => {
+      const scene = new THREE.Scene();
+      const wind = createWind(storms[name]);
+      const sky = createSkyFx({ scene, camera: new THREE.PerspectiveCamera(), wind });
+      let flashes = 0, peak = 0;
+      let was = 0;
+      fixedLoop(wind.duration, FIXED_DT, (dt, time) => {
+        sky.step(dt, time, {});
+        if (sky.flash > was + 0.05) flashes++;      // a rising edge = a strike
+        was = sky.flash;
+        peak = Math.max(peak, sky.flash);
+      });
+      sky.dispose();
+      return { flashes, peak };
+    };
+    const wild = mk('storm_02_wildnight');
+    const gentle = mk('storm_01_gentle');
+    // 3 authored strikes + the worst gusts; must be more than the authored ones
+    assert(wild.flashes > 3, `wild night only flashed ${wild.flashes} times — the big gusts aren't lighting up`);
+    assert(gentle.flashes === 0, `the gentle storm flashed ${gentle.flashes} times — it has no lightning at all`);
+  });
+
   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

@@ -343,6 +343,180 @@ export default async function run(t) {
     assertLess(bracedKnocks, exposedKnocks, 'and bracing through it is strictly better');
   });
 
+  // ---------------------------------------------------------------- the ladder (decision 12)
+  // A fake ladder standing in for ladder.js's THREE half: same shape, no GLB, no scene. The real
+  // one is verified by hand in the game; these pin the legs of the state machine.
+  const fakeLadder = (opts = {}) => {
+    const st = { placedAt: opts.placedAt || null, carried: false };
+    return {
+      needsLadder: (a) => !!a && a.type === 'house',
+      workY: () => 2.35,
+      // height only, mirroring the real ladder.js — see the note there on why testing for 'atTop'
+      // here makes the repair cancel its own hold
+      isWorking: (id) => st.placedAt === id && !!opts.player && opts.player.climbY > 2.2,
+      servedAnchor: () => null,
+      get placedAt() { return st.placedAt; },
+      _place: (id) => { st.placedAt = id; },
+      update() {}, dispose() {},
+    };
+  };
+
+  t.test('ladder: climb is code-driven and lands in a work stance', () => {
+    const s = new PlayerSim();
+    assertEq(s.climbY, 0, 'starts on the ground');
+    s.climbTo(2.35);
+    assertEq(s.state, 'climb', 'climbing');
+    assert(s.busy, 'you cannot be interrupted mid-rung');
+    assertEq(clipFor(s), 'ClimbLadder', 'and ClimbLadder plays');
+    drive(s, 0.5);
+    assert(s.climbY > 0.3 && s.climbY < 2.35, `partway up, got ${s.climbY.toFixed(2)}`);
+    drive(s, 3);
+    assertEq(s.state, 'atTop', 'arrives in the work stance');
+    assertClose(s.climbY, 2.35, 1e-6, 'at the top rung');
+    assert(!s.busy, 'atTop must NOT be busy — the whole point is that hold-E works up there');
+  });
+
+  t.test('ladder: the fascia is out of reach from the ground and in reach from the top', () => {
+    const s = new PlayerSim();
+    const FASCIA_Y = 2.48;                       // measured in the real yard
+    assertLess(s.reachY, FASCIA_Y, 'standing on the ground, a 1.72 m person cannot reach the bracket');
+    s.climbTo(2.35); drive(s, 4);
+    assert(s.reachY >= FASCIA_Y, `up the ladder they can, reach=${s.reachY.toFixed(2)}`);
+  });
+
+  t.test('ladder: you cannot walk while you are on it', () => {
+    const s = new PlayerSim();
+    s.climbTo(2.35); drive(s, 4);
+    assertEq(s.state, 'atTop');
+    const x0 = s.pos.x, z0 = s.pos.z;
+    drive(s, 1.5, { x: 1, z: 1, run: true, camYaw: 0 });
+    assertClose(s.pos.x, x0, 1e-9, 'WASD does not walk you off a ladder');
+    assertClose(s.pos.z, z0, 1e-9);
+    assertEq(s.state, 'atTop', 'and you stay in the work stance');
+  });
+
+  t.test('ladder: descending returns you to the ground and frees you', () => {
+    const s = new PlayerSim();
+    s.climbTo(2.35); drive(s, 4);
+    s.climbTo(0);
+    assertEq(s.state, 'climb', 'going down is the same clip');
+    drive(s, 4);
+    assertEq(s.state, 'idle', 'back on your feet');
+    assertEq(s.climbY, 0);
+    drive(s, 1, { x: 0, z: 1, camYaw: 0 });
+    assertEq(s.state, 'walk', 'and walking again');
+  });
+
+  t.test('ladder: you cannot brace up there — both hands are on the rungs', () => {
+    const s = new PlayerSim();
+    s.climbTo(2.35); drive(s, 4);
+    // a wind under even the ladder's lowered bar, so this isolates the brace refusal from the fall
+    drive(s, 1, { shelter: true }, windX(TUNE.knockWind * TUNE.ladderKnockMult - 4));
+    assertEq(s.state, 'atTop', 'holding C on a ladder does nothing');
+  });
+
+  t.test('ladder: the wind is meaner at height, and being blown off is a FALL', () => {
+    // a wind that is survivable standing must be able to take you off the ladder
+    const between = TUNE.knockWind * TUNE.ladderKnockMult + 2;   // over the ladder bar, under the standing one
+    assertLess(between, TUNE.knockWind, 'the test wind must be survivable on the ground');
+
+    const ground = new PlayerSim();
+    drive(ground, TUNE.knockSustain + 0.5, {}, windX(between));
+    assertEq(ground.state, 'idle', 'on your feet this wind is nothing');
+
+    const up = new PlayerSim();
+    up.climbTo(2.35); drive(up, 4);
+    up.carrying = 'spare';
+    drive(up, TUNE.knockSustain + 0.3, {}, windX(between));
+    assertEq(up.state, 'knocked', 'the same wind takes you off the ladder');
+    assertEq(up.climbY, 0, 'you are on the ground now, not floating at height');
+    assertClose(up.fellFrom, 2.35, 1e-6, 'and the fall height is recorded');
+    assertEq(up.carrying, null, 'you dropped the spare on the way down');
+    drive(up, 3);
+    assertEq(up.state, 'idle', 'the ladder gets the normal get-up chain for free');
+  });
+
+  t.test('ladder: needsLadder is scoped to the fascia, not to everything above head height', () => {
+    const L = fakeLadder();
+    assert(L.needsLadder({ type: 'house', pos: { y: 2.48 } }), 'the fascia bracket needs it');
+    assert(!L.needsLadder({ type: 'post', pos: { y: 3.95 } }),
+      'a 4 m post does NOT — you tension it from a cleat at the base');
+    assert(!L.needsLadder({ type: 'tree', pos: { y: 5.05 } }),
+      'nor a tree limb — that is a strop you throw');
+  });
+
+  t.test('ladder: fascia re-rig is gated on being up it; post re-rig is not', () => {
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    const L = fakeLadder({ player: p });
+    const anchors = [{ id: 'h2', type: 'house', pos: { x: 0, y: 2.48, z: 0.9 } },
+      { id: 'p1', type: 'post', pos: { x: 0, y: 3.95, z: 0 } }];
+    const corners = [{ anchorId: 'h2', broken: true }, { anchorId: 'p1', broken: true }];
+    let repaired = [];
+    const it = new Interact();
+    wireYardActions(it, {
+      ladder: L,
+      world: { anchors },
+      sailRig: { corners, repair: (i) => repaired.push(i), trim: () => {},
+        cornerPos: () => ({ x: 0, y: 0.4, z: 0 }) },
+    });
+    p.carrying = 'spare';
+
+    // the POST corner: repairable from the ground, exactly as it was before the ladder existed
+    p.pos.x = 0; p.pos.z = 0;
+    fixedLoop(3.3, DT, (dt, tt) => it.step(dt, tt, p, true));
+    assert(repaired.includes(1), 'post corner still re-rigs from the ground — the ladder changed nothing here');
+
+    // the FASCIA corner: same spare, standing right under it, refused
+    repaired = []; p.carrying = 'spare'; p.pos.x = 0; p.pos.z = 0.9;
+    it.latched = false;
+    const near = it.nearest(p);
+    assert(!near || near.id !== 'rerig_0', 'standing under the bracket is not enough');
+    fixedLoop(3.3, DT, (dt, tt) => it.step(dt, tt, p, true));
+    assert(!repaired.includes(0), 'fascia re-rig refused from the ground');
+
+    // plant the ladder and climb it → now it lands
+    L._place('h2');
+    p.climbTo(2.35); drive(p, 4);
+    assertEq(p.state, 'atTop');
+    p.carrying = 'spare';
+    it.latched = false;
+    fixedLoop(3.3, DT, (dt, tt) => it.step(dt, tt, p, true));
+    assert(repaired.includes(0), 'up the ladder, the fascia re-rig lands');
+    assertEq(p.carrying, null, 'and it ate the spare');
+  });
+
+  t.test('ladder: the scripted loop — carry, plant, fetch spare, climb, repair, descend', () => {
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    const L = fakeLadder({ player: p });
+    const anchors = [{ id: 'h2', type: 'house', pos: { x: 0, y: 2.48, z: 0.9 } }];
+    const corners = [{ anchorId: 'h2', broken: true }];
+    let repaired = false;
+    const it = new Interact();
+    wireYardActions(it, { ladder: L, world: { anchors },
+      sailRig: { corners, repair: () => { repaired = true; }, trim: () => {},
+        cornerPos: () => ({ x: 0, y: 0.4, z: 0 }) } });
+
+    // hands-full: the ladder and the spare compete for the same pair of hands
+    assertEq(p.pickUp('ladder'), true, 'pick the ladder up');
+    assertEq(p.pickUp('spare'), false, 'you cannot also carry a spare — that is the two-trip cost');
+    assertEq(p.drop(), 'ladder', 'put it down');
+
+    // trip 2: the spare, then up
+    assertEq(p.pickUp('spare'), true);
+    L._place('h2');
+    p.climbTo(L.workY()); drive(p, 4);
+    assertEq(p.state, 'atTop', 'up the ladder with the spare');
+    it.latched = false;
+    fixedLoop(3.3, DT, (dt, tt) => it.step(dt, tt, p, true));
+    assert(repaired, 'fascia repaired at height');
+    assertEq(p.carrying, null, 'spare consumed');
+
+    // and back down
+    p.climbTo(0); drive(p, 4);
+    assertEq(p.state, 'idle', 'down and free');
+    assertEq(p.climbY, 0);
+  });
+
   // ---------------------------------------------------------------- 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
@@ -476,6 +650,28 @@ export default async function run(t) {
     assertEq(sim.state, 'knocked', 'and the abort did not overwrite the knocked state');
   });
 
+  t.test('interact: a hold survives the busy transition it causes', () => {
+    // The bug this pins bit twice while building the ladder, and is invisible: canUse is re-checked
+    // every frame to keep the hold alive, and starting the hold sets state='busy' — so any canUse
+    // reading player.state goes false on frame one and cancels itself. Prompt looks dead, no error.
+    const sim = new PlayerSim();
+    const it = new Interact();
+    let fired = 0;
+    it.register({ id: 'ok', pos: { x: 0, y: 0, z: 0 }, radius: 2, holdSecs: 0.5,
+      canUse: (p) => p.climbY < 0.02, onDone: () => { fired++; } });   // physical gate — fine
+    fixedLoop(1, DT, (dt, tt) => it.step(dt, tt, sim, true));
+    assertEq(fired, 1, 'a physically-gated action completes');
+
+    const sim2 = new PlayerSim();
+    const it2 = new Interact();
+    let fired2 = 0;
+    it2.register({ id: 'trap', pos: { x: 0, y: 0, z: 0 }, radius: 2, holdSecs: 0.5,
+      canUse: (p) => p.state === 'idle', onDone: () => { fired2++; } });  // state gate — the trap
+    fixedLoop(1, DT, (dt, tt) => it2.step(dt, tt, sim2, true));
+    assertEq(fired2, 0,
+      'a state-gated canUse cancels its own hold — documented on register(); gate on physical facts');
+  });
+
   t.test('interact: canUse() gates on the carrying flag', () => {
     const sim = new PlayerSim();
     const it = new Interact();

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

@@ -75,8 +75,10 @@ const ASSETS = [
   { name: 'garden_gnome_01', h: [0.33, 0.42], nodes: ['gnome'] },
   { name: 'garden_gnome_01_broken', h: [0.08, 0.20],
     nodes: ['stump', 'head', 'hat', 'shards'] },
-  { name: 'fence_panel_broken', h: [1.70, 1.90],
+  { name: 'fence_panel_snapped', h: [1.70, 1.90],
     nodes: ['palings', 'rails', 'debris_palings'] },
+  { name: 'broom_01', h: [1.35, 1.50],
+    nodes: ['handle', 'head', 'bristles', 'grip_anchor', 'poke_tip'] },
 ];
 
 function sizeOf(gltf) {
@@ -268,7 +270,7 @@ export default async function run(t) {
   // swap needs a fudge offset per prop and will grow one.
   t.test('broken variants sit on the same ground plane as their intact twin', () => {
     for (const [intact, broken] of [['garden_gnome_01', 'garden_gnome_01_broken'],
-                                    ['fence_panel', 'fence_panel_broken']]) {
+                                    ['fence_panel', 'fence_panel_snapped']]) {
       for (const n of [intact, broken]) {
         const box = new THREE.Box3().setFromObject(loaded.get(n).scene);
         assert(Math.abs(box.min.y) < 0.03,

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

@@ -11,7 +11,7 @@
 // call it with the fetched storm defs.
 
 import {
-  createWindField, validateStorm, gustEnvelope, GUST,
+  createWindField, validateStorm, gustEnvelope, GUST, RAIN_TIME_COMPRESSION,
 } from '../weather.core.js';
 
 const DT = 1 / 60;
@@ -405,6 +405,105 @@ export function weatherCases(storms) {
     assert(!validateStorm(legacy, 'legacy').ok, 'validator silently accepted the pre-SPRINT3 downdraft field');
   });
 
+  // ---- 10. the ponding story (SPRINT4 decision 10) ----
+  // Lane B owns water-on-cloth; these assert the RAIN DATA can tell the story
+  // their mass model needs, using their own arithmetic, before their cloth lands.
+  // B measured: 5 cm over a 25 m² flat sail = 1250 kg = 3.1 kN/corner, against a
+  // storm_02 wind load of only 0.2–1.1 kN. So depth is the whole mechanic.
+  const FLAT_AREA = 25;               // m², B's reference flat sail
+  const KILL_DEPTH_MM = 50;           // 5 cm — B's 3.1 kN/corner
+  /** Water on a flat sail over a whole storm, at decision 10's compression. */
+  const stormDepthMm = (def) => {
+    const f = createWindField(def);
+    return f.rainDepthMm(0, f.duration) * RAIN_TIME_COMPRESSION;
+  };
+  /** B's arithmetic: mm over an area → kN per corner (4 corners, 1000 kg/m³). */
+  const kNPerCorner = (mm) => (mm / 1000) * FLAT_AREA * 1000 * 9.81 / 4 / 1000;
+
+  test('storm_02 rain can drown a flat rig; storm_01 rain cannot', () => {
+    const wild = stormDepthMm(storms.storm_02_wildnight);
+    const gentle = stormDepthMm(storms.storm_01_gentle);
+    metrics['storm_02.pondDepth_mm'] = +wild.toFixed(1);
+    metrics['storm_02.pond_kN_per_corner'] = +kNPerCorner(wild).toFixed(2);
+    metrics['storm_01.pondDepth_mm'] = +gentle.toFixed(2);
+    metrics['storm_01.pond_kN_per_corner'] = +kNPerCorner(gentle).toFixed(3);
+
+    assert(wild >= KILL_DEPTH_MM * 0.9,
+      `storm_02 only delivers ${wild.toFixed(1)} mm — Lane B needs ~${KILL_DEPTH_MM} mm to drown a flat rig`);
+    // and it must dwarf the wind it's competing with (B: 0.2–1.1 kN/corner)
+    assert(kNPerCorner(wild) > 1.5,
+      `storm_02 ponding is only ${kNPerCorner(wild).toFixed(2)} kN/corner — no stronger than the wind`);
+    // the gentle storm must be unable to hurt anything, or the ramp is a lie
+    assert(kNPerCorner(gentle) < 0.3,
+      `storm_01 ponds ${kNPerCorner(gentle).toFixed(2)} kN/corner — a light shower must not threaten a rig`);
+    assert(wild > gentle * 20, 'the wild night should deliver vastly more water than a shower');
+  });
+
+  test('storm_03 ponding sits between the other two', () => {
+    const mid = stormDepthMm(storms.storm_03_southerly);
+    const wild = stormDepthMm(storms.storm_02_wildnight);
+    const gentle = stormDepthMm(storms.storm_01_gentle);
+    metrics['storm_03.pondDepth_mm'] = +mid.toFixed(1);
+    metrics['storm_03.pond_kN_per_corner'] = +kNPerCorner(mid).toFixed(2);
+    assert(mid > gentle * 3 && mid < wild * 0.5,
+      `storm_03 delivers ${mid.toFixed(1)} mm — wanted a real middle rung between ${gentle.toFixed(1)} and ${wild.toFixed(1)}`);
+    // it should threaten a carabiner (1.2 kN) once wind is added, not a shackle (3.2)
+    assert(kNPerCorner(mid) > 0.25 && kNPerCorner(mid) < 1.2,
+      `storm_03 ponds ${kNPerCorner(mid).toFixed(2)} kN/corner — should tease a cheap rig, not drown a decent one`);
+  });
+
+  test('rain depth integrates monotonically and matches its curve', () => {
+    const f = createWindField(storms.storm_02_wildnight);
+    // depth only ever accumulates
+    let prev = 0;
+    for (let t = 1; t <= f.duration; t += 1) {
+      const d = f.rainDepthMm(0, t);
+      assert(d >= prev - 1e-9, `rain depth went BACKWARDS at t=${t}: ${d} < ${prev}`);
+      prev = d;
+    }
+    // splitting the interval must give the same water (no double-count, no gap)
+    const whole = f.rainDepthMm(0, 90);
+    const split = f.rainDepthMm(0, 30) + f.rainDepthMm(30, 60) + f.rainDepthMm(60, 90);
+    assert(Math.abs(whole - split) < 0.05,
+      `depth(0,90)=${whole.toFixed(3)} but the three thirds sum to ${split.toFixed(3)}`);
+    // dead calm before the rain starts
+    assert(f.rainDepthMm(0, 0) === 0, 'zero-length interval delivered water');
+    assert(f.rainDepthMm(10, 5) === 0, 'a backwards interval delivered water');
+  });
+
+  test('rainMmPerHour tracks rainAt against the storm scale', () => {
+    for (const [name, def] of defs) {
+      if (!def.rain || !def.rain.curve) continue;
+      const f = createWindField(def);
+      const peak = def.rain.peakMmPerHour;
+      assert(Number.isFinite(peak), `${name} has a rain curve but no peakMmPerHour`);
+      for (let t = 0; t <= f.duration; t += 2.5) {
+        const want = f.rainAt(t) * peak;
+        assert(Math.abs(f.rainMmPerHour(t) - want) < 1e-9,
+          `${name}: rainMmPerHour ${f.rainMmPerHour(t)} != rainAt×peak ${want} at t=${t}`);
+      }
+      // rainAt stays a 0..1 intensity — skyfx uses it for drop count and opacity
+      for (let t = 0; t <= f.duration; t += 2.5) {
+        const r = f.rainAt(t);
+        assert(r >= 0 && r <= 1, `${name}: rainAt ${r} outside 0..1 at t=${t}`);
+      }
+    }
+  });
+
+  test('validator rejects a rain curve with no scale, and a silly scale', () => {
+    const noScale = JSON.parse(JSON.stringify(storms.storm_02_wildnight));
+    delete noScale.rain.peakMmPerHour;
+    assert(!validateStorm(noScale, 'x').ok, 'validator accepted a rain curve with no mm/hr scale — ponding would silently use the default');
+    for (const mm of [-1, 5000, NaN]) {
+      const d = JSON.parse(JSON.stringify(storms.storm_02_wildnight));
+      d.rain.peakMmPerHour = mm;
+      assert(!validateStorm(d, 'x').ok, `validator accepted peakMmPerHour=${mm}`);
+    }
+    const hot = JSON.parse(JSON.stringify(storms.storm_02_wildnight));
+    hot.rain.curve = [[0, 0], [45, 3], [90, 0]];
+    assert(!validateStorm(hot, 'x').ok, 'validator accepted rain intensity above 1 — the scale is peakMmPerHour, not the curve');
+  });
+
   return { cases, metrics };
 }
 

web/world/js/weather.core.js

@@ -132,6 +132,25 @@ function sampleAngleCurve(curve, t) {
 // Prototype: pow = 12 + rand*16 + 10*p, next = t + 5 + rand*7. Same shape, from JSON.
 export const DEFAULT_DOWNDRAFT = 0.22;
 
+/** Fallback rain scale, mm/hr at rainAt()==1. Storms should state their own. */
+export const DEFAULT_PEAK_MM_PER_HOUR = 40;
+
+/**
+ * SPRINT4 decision 10 — the time-compression fiat, in ONE place.
+ *
+ * Game rain accumulates ~40× real time. A 90 s storm is canonically a whole
+ * night (storm_02 telegraphs its change "around the hour mark"), so it should
+ * deliver a night's water: 90 s × 40 = 3600 s = one hour of rain. At storm_02's
+ * 80 mm/hr peak that lands ~5 cm on a flat sail — exactly Lane B's measured kill
+ * threshold (5 cm over 25 m² = 1250 kg = 3.1 kN/corner) against a wind load of
+ * only 0.2–1.1 kN. Ponding is 3–15× everything else, and it cannot pincer §7
+ * because a hypar has no flat to pool in.
+ *
+ * Exported so Lane B applies it cloth-side rather than either of us hardcoding
+ * 40 twice: how hard it rains is Lane C, how much water a sail holds is Lane B.
+ */
+export const RAIN_TIME_COMPRESSION = 40;
+
 export function buildGustTimeline(def, seed) {
   const g = def.gusts || {};
   const rng = mulberry32(seed >>> 0);
@@ -378,6 +397,45 @@ export function createWindField(def, opts = {}) {
       if (r.curve) return Math.min(1, Math.max(0, sampleCurve(r.curve, t)));
       return Math.min(1, Math.max(0, r.intensity ?? 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
+     * renderer doesn't want millimetres.
+     *
+     * This exists for ponding (decision 10). Without it Lane B has to invent the
+     * mm/hr scale to turn intensity into water mass, which is exactly the
+     * "default-off code tuned by a constant I invented" they rightly reverted.
+     * The scale is storm data, so it lives here: `rain.peakMmPerHour`.
+     * For reference: 8 = light shower, 30 = moderate, 50 = heavy, 80+ = severe.
+     */
+    rainMmPerHour(t) {
+      const r = def.rain;
+      if (!r) return 0;
+      return field.rainAt(t) * (r.peakMmPerHour ?? DEFAULT_PEAK_MM_PER_HOUR);
+    },
+
+    /**
+     * Real-world water depth in mm delivered over (t0, t1]. Deterministic
+     * trapezoid over the curve — no compression applied.
+     *
+     * Lane B multiplies by RAIN_TIME_COMPRESSION cloth-side: how much water a
+     * SAIL holds is theirs, how hard it rains is mine. Handy shape for a HUD
+     * "water delivered" readout too.
+     */
+    rainDepthMm(t0, t1, stepS = 0.25) {
+      if (!(t1 > t0)) return 0;
+      let mm = 0;
+      const n = Math.max(1, Math.ceil((t1 - t0) / stepS));
+      const h = (t1 - t0) / n;
+      let prev = field.rainMmPerHour(t0);
+      for (let i = 1; i <= n; i++) {
+        const cur = field.rainMmPerHour(t0 + i * h);
+        mm += (prev + cur) * 0.5 * h / 3600;   // mm/hr × seconds → mm
+        prev = cur;
+      }
+      return mm;
+    },
   };
 
   return field;
@@ -446,6 +504,21 @@ export function validateStorm(def, name = 'storm') {
   }
 
   if (def.rain && def.rain.curve && !isCurve(def.rain.curve)) bad('rain.curve must be [[t,intensity],...]');
+  if (def.rain) {
+    if (def.rain.curve && isCurve(def.rain.curve)
+        && def.rain.curve.some((p) => p[1] < 0 || p[1] > 1)) {
+      bad('rain.curve intensity must be 0..1 — the physical scale is rain.peakMmPerHour');
+    }
+    const mm = def.rain.peakMmPerHour;
+    if (mm != null && (!Number.isFinite(mm) || mm < 0 || mm > 300)) {
+      bad(`rain.peakMmPerHour must be 0..300 mm/hr (8 light, 30 moderate, 50 heavy, 80+ severe) — got ${mm}`);
+    }
+    // Ponding reads this; a storm that rains with no scale silently ponds at the
+    // default instead of what its author meant.
+    if (def.rain.curve && mm == null) {
+      bad('rain.curve without rain.peakMmPerHour — ponding needs the mm/hr scale (SPRINT4 decision 10)');
+    }
+  }
 
   return { ok: errors.length === 0, errors };
 }

web/world/js/weather.js

@@ -10,9 +10,9 @@
 // determinism rule can't be broken by accident.
 
 import * as THREE from '../vendor/three.module.js';
-import { createWindField, validateStorm, GUST } from './weather.core.js';
+import { createWindField, validateStorm, GUST, RAIN_TIME_COMPRESSION } from './weather.core.js';
 
-export { GUST, validateStorm };
+export { GUST, validateStorm, RAIN_TIME_COMPRESSION };
 
 // Resolved against this module, not the server root: server.py serves the repo
 // root (so the 2D prototype stays reachable), but the demo bench serves web/.
@@ -84,9 +84,16 @@ export function createWind(def, opts = {}) {
     /** Storm events fired in (a,b] — poll with (t-dt, t). Deterministic. */
     eventsBetween(a, b) { return field.eventsBetween(a, b); },
 
-    /** 0..1 rain intensity. */
+    /** 0..1 rain intensity — drives drop count and opacity. */
     rainAt(t) { return field.rainAt(t); },
 
+    /** Rain rate in real-world mm/hr. Ponding (decision 10) reads this. */
+    rainMmPerHour(t) { return field.rainMmPerHour(t); },
+
+    /** Real-world mm of water delivered over (t0,t1]. Multiply by
+     *  RAIN_TIME_COMPRESSION cloth-side — see weather.core. */
+    rainDepthMm(t0, t1) { return field.rainDepthMm(t0, t1); },
+
     /** Direction (radians, XZ plane from +X toward +Z) ignoring local effects. */
     dirAt(t) { return field.dirAt(t); },
 

web/world/js/world.js

@@ -45,6 +45,11 @@ const SHED_TABLE = { x: 9, z: 6, rotY: -Math.PI / 2 };
 // the same line the graybox taught everyone to expect.
 const HOUSE = { x: 0, z: -10.5 };
 
+// The gnome stands just off the bed's south-east corner — inside the footprint
+// of most rigs, so a sail that lets go has something of the client's to land on.
+// DESIGN.md: your own failure is the worst debris of all.
+const GNOME = { x: 4.3, z: 4.4, rotY: -2.2, collateralValue: 25 };
+
 // Sun: mid-afternoon, high and off the north-west shoulder. Elevation 55°.
 // Stored as the direction from the GROUND toward the SUN (see contracts.js).
 const SUN_ELEV = (55 * Math.PI) / 180;
@@ -95,7 +100,13 @@ export function createWorld(scene, opts = {}) {
   /** @type {{group: THREE.Object3D, phase: number, base: THREE.Euler}[]} */
   const canopies = [];
   /** Graybox stand-ins, kept so dress() can retire them once E's GLBs load. */
-  const graybox = { house: null, trees: new Map() };
+  const graybox = { house: null, trees: new Map(), bed: null };
+  /**
+   * E's three wilt states, siblings in one GLB — toggled by visibility rather
+   * than reloaded, which is why they all ship together.
+   * @type {{full: THREE.Object3D, tattered: THREE.Object3D, dead: THREE.Object3D}|null}
+   */
+  let plants = null;
 
   // --- sky & light -------------------------------------------------------
   // Calm-day only. Lane C's skyfx.js takes over the sky and this becomes the
@@ -329,6 +340,7 @@ export function createWorld(scene, opts = {}) {
     }
   }
   root.add(bed);
+  graybox.bed = bed;
 
   // --- boundary fence ----------------------------------------------------
   // East, south and west only: the house is the north boundary.
@@ -379,6 +391,18 @@ export function createWorld(scene, opts = {}) {
     pos: new THREE.Vector3(SHED_TABLE.x, heightAt(SHED_TABLE.x, SHED_TABLE.z) + 0.9, SHED_TABLE.z),
   };
 
+  /**
+   * Show one of E's three wilt states. No-op against the graybox bed, so the
+   * HUD can call it unconditionally.
+   * @param {'full'|'tattered'|'dead'} which
+   */
+  function setPlants(which) {
+    if (!plants) return;
+    for (const [k, node] of Object.entries(plants)) {
+      if (node) node.visible = k === which;
+    }
+  }
+
   /**
    * Swap Lane E's GLBs in over the graybox. Async and separate from
    * createWorld() on purpose: the selftest builds a yard with no server, and a
@@ -432,11 +456,34 @@ export function createWorld(scene, opts = {}) {
       }
     };
 
-    const [shed, table, houseGlb, tree1, tree2] = await Promise.all([
+    const [shed, table, houseGlb, tree1, tree2, bedGlb, gnome] = await Promise.all([
       load('shed_01_v1'), load('shed_table_v1'), load('house_yardside_v1'),
-      load('tree_gum_01_v1'), load('tree_gum_02_v1'),
+      load('tree_gum_01_v1'), load('tree_gum_02_v1'), load('garden_bed_v1'),
+      load('garden_gnome_01_v1'),
     ]);
 
+    // --- garden bed ------------------------------------------------------
+    if (bedGlb) {
+      retire(graybox.bed);
+      bedGlb.name = 'garden_bed';
+      bedGlb.position.set(GARDEN_BED.x, heightAt(GARDEN_BED.x, GARDEN_BED.z), GARDEN_BED.z);
+      root.add(bedGlb);
+      const pick = (n) => bedGlb.getObjectByName(n) ?? null;
+      plants = { full: pick('plants_full'), tattered: pick('plants_tattered'), dead: pick('plants_dead') };
+      setPlants('full');
+    }
+
+    // --- gnome (aftermath collateral bait) -------------------------------
+    // Placed under the sail's likely footprint on purpose: DESIGN.md wants your
+    // own failures to be the worst debris, and something breakable has to be
+    // standing there for that to land.
+    if (gnome) {
+      gnome.name = 'garden_gnome_01';
+      gnome.position.set(GNOME.x, heightAt(GNOME.x, GNOME.z), GNOME.z);
+      gnome.rotation.y = GNOME.rotY;
+      root.add(gnome);
+    }
+
     // --- house (decision 6: no re-cut, the GLB's data wins) ---------------
     // E's fascia sits at 2.80 m and their anchors span x=-3..3, where my
     // graybox guessed 2.6 m and -5..5. Reading them narrows the house span by
@@ -532,6 +579,10 @@ export function createWorld(scene, opts = {}) {
      */
     shedTable,
     dress,
+    /** @param {'full'|'tattered'|'dead'} which */
+    setPlants,
+    /** Where the breakable client property stands, and what breaking it costs. */
+    gnome: GNOME,
     // Lane C's skyfx MODULATES these as the storm builds and hands them back
     // untouched on dispose() — it doesn't own them. That's why the yard exposes
     // its lights rather than keeping them private.