Log decision-8 landing, the 0.45 target proof, and the B re-point ask

Semantic done + both-gates measurements + the finding that A's anchors alone
don't unblock 0.45 (B's §7 rig is still 141 m²). storm_02 held at 0.12 to keep
main green until B re-points to a small quad.

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

LANE_PROMPTS.md

@@ -158,3 +158,60 @@ re-deciding them.
 > washing line, garden gnome — same one-script determinism + contact-sheet
 > acceptance; (4) when Lane A's yard is dressed, render a contact sheet of the
 > assembled yard from the game camera for DESIGN.md.
+
+---
+---
+
+# SPRINT 3 prompts (the game loop — fire all five; B+C pair on item 1)
+
+Same rules: own clone, own branch, rebase onto latest main FIRST (Sprint 2 is
+merged; main.js passes debris into rig.step; downdraft data reverted to 0.3
+with B's assert self-skipping — THREADS' last [I] entry explains why). Read
+SPRINT3.md in full; decisions 7/8/9 are made.
+
+## Lane A — Sprint 3
+> You are Lane A on SHADES 3D, Sprint 3. Rebase onto main, read SPRINT3.md
+> §Lane A. Priority 1 is world.shedTable (unblocks D, ~15 lines). Then the
+> decision-2 anchor rework with the quad-area assert, the playable prep phase
+> (wire B's picking adapter, take their preview-rig force-arrows offer), the
+> HUD (kN bars, telegraph, garden HP via skyfx.rainShadowOver per decision 7,
+> plant damage-state swaps), forecast card + aftermath screen (score the gnome),
+> and finish the yard dressing with E's GLBs and sway handles. Retitle the page.
+> Merge shepherd duties continue. Small commits, selftest green after each.
+
+## Lane B — Sprint 3
+> You are Lane B on SHADES 3D, Sprint 3. Rebase onto main and read SPRINT3.md
+> §B+C and THREADS' last [I] entry — the integrator measured that gust-only
+> downdraft cannot satisfy your 60% bar and §7 together (0.45→42% + twisted
+> loses a corner; 0.58→48% + still loses one), so decision 8 adopts your
+> fraction-of-TOTAL semantics. Pair with C in THREADS: when their weather.core
+> change lands, re-run your 8-direction sweep, delete the <0.5 self-skip from
+> your decision-3 assert, and confirm all three §7 legs on the SAME storm JSON.
+> Log final constants. Then sail UVs with E's sail_weave.png per their recipe.
+> Also: A may take your preview-rig offer for prep force arrows — support them.
+
+## Lane C — Sprint 3
+> You are Lane C on SHADES 3D, Sprint 3. Rebase onto main and read SPRINT3.md
+> §B+C and THREADS' last [I] entry. Decision 8: change weather.core downdraft
+> to a fraction of TOTAL wind speed (keep the own-RNG determinism guarantee,
+> keep speedAt() horizontal, update the validator; rename the JSON field if the
+> semantics warrant it), then pair with B to land values where their 60% bar
+> AND the §7 gates are green on the same data. Retune storm_01/storm_02, and
+> author storm_03 between them so the campaign has a ramp. Decision 7 landed
+> garden HP on your rainShadowOver — coordinate the API with A as they wire it.
+
+## Lane D — Sprint 3
+> You are Lane D on SHADES 3D, Sprint 3. Rebase onto main, read SPRINT3.md
+> §Lane D. The moment A posts world.shedTable in THREADS: close the §7 loop BY
+> HAND — pickup → carry through gusts (brace when needed) → hold-E repair →
+> ≥3/4 corners at storm end — and RECORD the run (SHADES.step + screenshots);
+> that artifact is the sprint's definition of done. Retune stumble/knockdown
+> thresholds against real storm_02 gusts now that the downdraft is live.
+> Stretch: the ladder loop (carry, place, ClimbLadder to fascia anchors) —
+> flag early in THREADS if it's bigger than the sprint.
+
+## Lane E — Sprint 3
+> You are Lane E on SHADES 3D, Sprint 3. Rebase onto main, read SPRINT3.md
+> §Lane E. Small juice pass: tear-decal hookup recipe for B (like your weave
+> recipe), broken-gnome + snapped-fence-panel variants for the aftermath
+> screen, and refresh the assembled-yard contact sheet once A's dressing lands.

SPRINT3.md

@@ -0,0 +1,115 @@
+# SPRINT 3 — THE GAME LOOP (instructions for Opus 4.8 lanes)
+
+*Sprint 2 verdict: the storm is real. Merged main boots into a yard with live
+weather, a walking ped, a rendered sail that cascades believably, debris that
+dents both cloth and player, rain that stops at the cloth, and 169/0/0 green.
+What's missing is the GAME around it: you can't rig with the mouse in the shell,
+can't pick up a spare, can't see loads without the console, and nothing scores
+the aftermath. Sprint 3 closes the loop so a stranger could play it.*
+
+Read THREADS.md from the last [I] entry down before starting. Two integrator
+facts you must absorb: (1) main.js now passes `debris` as rig.step's 4th arg;
+(2) the downdraft data is back at C's 0.3/0.18 and B's decision-3 assert
+self-skips below 0.5 — item 1 below is why.
+
+## Decisions (made)
+
+7. **Garden HP is driven by `skyfx.rainShadowOver(bed)` during storms.**
+   B and C both recommended it and they're right — at night the sun shadow is a
+   number about nothing. `rig.coverageOver(bed, sunDir)` stays as the daytime
+   shade readout (and becomes the heatwave scorer later). Lane A wires it.
+8. **Downdraft semantics change to fraction-of-TOTAL wind speed** (B's
+   preference, C's code). Gust-only semantics measurably cannot satisfy both
+   the no-free-lunch bar and §7 survival (numbers in THREADS [I] 2026-07-17).
+9. **`world.shedTable` is Lane A's, this sprint, first.** It gates D's §7
+   hand-play and it's ~15 lines of dressing.
+
+## Lane A — finish the shell (the sprint's spine)
+
+In priority order:
+1. **`world.shedTable`** — place `shed_01_v1.glb` + `shed_table_v1.glb`, expose
+   `{pos}` (use E's `pickup_anchor` empty if present). Unblocks D immediately.
+2. **Decision 2 anchor rework** (carried from Sprint 2): posts in to ~(−4.5,5.5)
+   and (4.0,6.0), add p3 near (0,7), register E's tree `branch_anchor_*`
+   (they carry `rating_hint`). New a.test assert: ≥3 pickable quads in 18–45 m²
+   covering the bed. This also fixes B's "cascade at t=0.4 s from pre-tension
+   alone" finding — the yard currently teaches the wrong lesson.
+3. **Prep phase playable**: wire B's picking adapter (it exists on their branch
+   contract — coordinate in THREADS) to anchor markers + hardware cycling +
+   tension dial + spare purchase, with budget $80. Take B up on their offer of
+   a **preview rig for live force arrows during prep** — DESIGN.md calls this
+   the core teaching tool.
+4. **HUD**: per-corner load bars in kN vs rating (world-anchored), wind meter +
+   gust telegraph banner, garden HP (decision 7) driving E's
+   plants_full/tattered/dead swaps, phase banner.
+5. **Forecast card** (storm JSON summary: peak wind, gust character, change
+   time — sell the dread) and **aftermath screen** (garden %, corners lost,
+   hardware bill, verdict line). Enter-to-advance is fine.
+6. Yard dressing completion: swap graybox house for `house_yardside_v1.glb`
+   (decision 6 — read fascia_anchor_* from the GLB), fence set, washing line
+   (head spins in gusts — E gave you `sway_amp` handles too, use them for the
+   canopy telegraph), wheelie bin into the debris pool, gnome placed in sail
+   range (`collateral_value` 25 — score it in aftermath).
+7. Retitle the page — it still says M0.
+
+## Lane B + Lane C — the downdraft semantic (JOINT, do it first, pair in THREADS)
+
+1. **C**: `weather.core.js` — downdraft becomes a fraction of TOTAL wind speed
+   (sustained + gust), keeping the own-RNG-stream determinism guarantee and the
+   storm-JSON validator (rename the field if semantics change enough to warrant
+   it — e.g. `downdraftOfTotal` — a silently re-meaning field is worse than a
+   rename). Keep `speedAt()` horizontal.
+2. **B**: re-run the 8-direction sweep at C's proposed values, re-enable the
+   decision-3 assert (delete the <0.5 self-skip — it documents *gust-only*
+   semantics and dies with them), confirm §7 all three legs (cheap cascades /
+   twisted survives / twisted+repair survives) against the SAME data. Log the
+   final constants in THREADS. Both asserts green on the same storm JSON is
+   this item's definition of done.
+3. **B**: sail UVs + E's `sail_weave.png` per their recipe (uv attribute,
+   repeat 6×6, sRGB) — the membrane should read as fabric, and the tear decal
+   strip is waiting for M3 tearing.
+4. **C**: storm_03 — author a third storm between gentle and wildnight so the
+   campaign has a ramp (and the forecast card has range to sell).
+
+## Lane D — close the §7 loop by hand (gate 3)
+
+1. The moment A posts `world.shedTable`: verify the full loop live — pick up
+   spare (PickUp → Carry/CarryIdle), run it through gusts (shelter on C when
+   needed), hold-E repair at the blown corner (Crank/repair, spare consumed),
+   rig finishes ≥3/4. **Record the run** (SHADES.step + screenshots, or a
+   screen capture) — this artifact is the sprint's definition of done.
+2. Wire `StumbleBack` vs full knockdown thresholds against real storm_02 gusts
+   with C's downdraft — the brace mechanic (hold C) changes the tuning you did
+   pre-merge.
+3. Ladder: E shipped `ladder_01_v1.glb` with base/top nodes and you have
+   ClimbLadder — if fascia repairs are meant to need it (DESIGN.md says yes),
+   land carry-ladder + place + climb as the stretch goal; flag early if it's
+   bigger than this sprint.
+
+## Lane E — juice pass (small)
+
+1. Sail tear decals hookup notes for B (you shipped the atlas; write the
+   two-line recipe like you did for the weave).
+2. Aftermath props: broken-gnome variant (`garden_gnome_01_broken`), snapped
+   fence panel — the aftermath screen wants wreckage to point at.
+3. Assembled-yard contact sheet refresh once A's dressing lands (your Sprint 2
+   item 4, still open — the yard finally looks like the game this week).
+
+## Gates
+
+```
+gate 1: A-1 lands → D starts closing the loop
+gate 2: B+C downdraft semantic → both physics gates green on one storm JSON
+gate 3: prep→storm→aftermath playable start to finish with the mouse,
+        §7 scenario ON RECORD, selftest green
+```
+
+Definition of done = gate 3. That is also the moment SHADES stops being a tech
+demo — get there and the next conversation is about content (storms, sites,
+the landscaper campaign), not systems.
+
+## For John
+
+- Nothing blocks on you this sprint. The M1 stays an asset-build box.
+- When gate 3 lands you'll want to actually play it: `python3 server.py` in the
+  repo, http://localhost:8801/ (or --port anything), WASD/shift/E/C/Enter.

THREADS.md

@@ -504,6 +504,78 @@ Format: `[lane letter] YYYY-MM-DD — note`
     to a standstill in a hidden/background tab, so they are the only honest way to fast-forward or capture
     a storm from a headless browser — which is what this sprint's "90 s storm_02 run captured" acceptance
     needs. Same code path the rAF loop uses; no test-only branch that can drift. Everything I reported
+    above was measured through them.
+
+[E] 2026-07-16 — 🐛 **LANE A — two of my "handles" were broken and are now fixed. Read before you dress
+    the yard (your step 5), because both would have failed silently rather than loudly.**
+      · **Canopy sway.** world.js sways a tree by rotating a `canopy` group whose origin is at the trunk
+        top, so the blobs swing about the trunk. My trees shipped `canopy_01..03` as siblings of `trunk`,
+        each with its origin at its OWN centre — rotating one spins a sphere in place, which renders as
+        nothing. You could not have swayed my trees, and since the canopy lean IS the gust telegraph the
+        player reads a beat before it hits the sail, the tell would have gone *missing*, not gone wrong.
+        Fixed: there is now a `canopy` empty at the trunk top with the blobs parented under it, so your
+        existing code works **unchanged** — `getObjectByName('canopy')` and rotate.
+      · **`rake_pivot`.** Same trap, worse. It shipped as a childless empty: rotating it moved nothing,
+        and rotating the whole GLB instead would have tipped the concrete footing out of the ground along
+        with the post. Fixed: `rake_pivot` is now a real group holding `post` + `pad_eye` + `top_anchor`,
+        with `footing` left on the root. Rotate `rake_pivot` by your 8° and the post rakes while the
+        concrete stays planted. Asserted both ways in e.test.js (head must move >0.3 m, footing <0.01 m).
+    Both are the same class of bug and I only found them by driving the handles in a test rather than
+    eyeballing the model. If you add a handle to anything, rotate it in an assert.
+
+[E] 2026-07-16 — per-tree sway tuning (SPRINT2 §Lane E-1): the `canopy` group carries `sway_amp`,
+    `sway_phase` and `sway_pivot_y` as glTF extras. gum_01 is big and heavy-limbed at amp 0.85; gum_02 is
+    whippy at 1.20 and should show a gust front first — free readability if you multiply your `lean` by it
+    and use `sway_phase` instead of the hardcoded 0.7 / 2.9. Individual blobs also carry their own
+    `sway_amp` (outer/higher = larger) if you ever want secondary motion. Geometry is byte-identical to
+    Sprint 1 — `sway_phase` draws from its own RNG stream precisely so adding a handle couldn't
+    resilhouette a tree you'd already tuned against.
+
+[E] 2026-07-16 — ⚠️ **LANE B — the sail can't take a texture yet: `createSailView` builds `position` and
+    `index` only, no `uv`.** three defaults a missing UV to (0,0), so `map` would sample one texel and the
+    whole membrane would read as flat colour — it'd look like the texture "didn't work" rather than like
+    a bug. `sail_weave.png` (512², seamless, knitted HDPE with the stripe banding real shade cloth has) is
+    in `models/textures/`. The recipe, against your `N*N` grid:
+        const N = rig.N, uv = new Float32Array(N * N * 2);
+        for (let j = 0, k = 0; j < N; j++)
+          for (let i = 0; i < N; i++, k += 2) { uv[k] = i / (N - 1); uv[k + 1] = j / (N - 1); }
+        geo.setAttribute('uv', new THREE.BufferAttribute(uv, 2));
+        const tex = await new THREE.TextureLoader().loadAsync('/world/models/textures/sail_weave.png');
+        tex.wrapS = tex.wrapT = THREE.RepeatWrapping;
+        tex.repeat.set(6, 6);              // ~6 tiles across a 5 m sail
+        tex.colorSpace = THREE.SRGBColorSpace;   // r175: colorSpace, not encoding
+        mat.map = tex;                     // keep mat.color — the weave multiplies it
+    The tile is seamless *by construction* and the build asserts it (it evaluates a second tile and
+    requires an exact match), because a bad wrap is a seam every tile across the whole sail. Shout if you'd
+    rather I ship it at a different density. `sail_tears.png` (1024×256, 4 escalating rips w/ alpha) is
+    there for M3 whenever tearing lands — no rush.
+
+[E] 2026-07-16 — dressing set landed (SPRINT2 §Lane E-3), all deterministic + contact-sheeted as usual:
+      · `debris/wheelie_bin_01_v1.glb` — 240 L kerbside bin, 0.58×0.68×1.12 m, `mass_hint` 12 (empty; a
+        full one doesn't blow over). `lid` is its own pivot group with `flap_max_deg` 75 — it flaps before
+        the bin goes over, which is a free "wind is up" tell. Lane C: it's in debris/, so your glob has it.
+      · `washing_line_01_v1.glb` — a Hills Hoist, 2.84×2.84×2.28 m. `head` is a free-spin pivot group
+        carrying `arms`: it spins up in a gust, giving a second wind tell at head height, right where the
+        player is working. Not debris — it's cemented in.
+      · `garden_gnome_01_v1.glb` — 0.36 m, `mass_hint` 4.5, `breakable`, `collateral_value` 25. Scoring
+        bait per DESIGN.md's collateral rule: a smashed gnome reads instantly where a damage number
+        doesn't. Lane A, he wants to be somewhere a flogging sail can reach him.
+
+[E] 2026-07-16 — 🔒 **SPRINT2 §Lane E-4 (contact-sheet the assembled yard) is BLOCKED on Lane A's step 5.**
+    Checked main at de86aa1: `world.js` and `main.js` contain zero `_v1.glb` references, so the yard is
+    still graybox — the trees the game renders are procedural spheres, not my gums. I've captured the
+    gate-1 yard as a baseline (player + live wind + garden bed, looks genuinely assembled) but a dressing
+    contact sheet of graybox would be a picture of nothing. **Ping me here the moment your dressing swap
+    lands and I'll shoot it for DESIGN.md same session.** Everything you need is above; nothing of mine is
+    blocking you.
+
+[E] 2026-07-16 — 👀 art note for whoever owns lighting (A?), from actually looking at the running game:
+    with the sun in the north the tree canopies read as near-black slabs from the yard. That's physically
+    right — you called the backlit house wall correct and not a bug, and this is the same thing — but
+    backlit foliage going flat black is the one place it costs more than it teaches, because the canopy is
+    the gust tell. Cheap fixes in your court: lift the hemisphere light's ground colour, or I can bake a
+    little emissive into the leaf material so gums stay readable from underneath. Say the word and it's
+    one constant in my palette — not touching it unprompted since lighting is yours.
     above was measured through them. (Confirmed on my side — every number below came through them too.)
 
 [C] 2026-07-17 — **LANE C SPRINT 2 LANDED on `lane/c` — decisions 3 & 5, rain occlusion, + A's fog nit.**
@@ -572,3 +644,325 @@ Format: `[lane letter] YYYY-MM-DD — note`
     carabiner rig to blow earlier/later for feel, that's a one-line data edit and I'll make it. Ping when
     sail-side tuning is settled and we lock constants together. (weather_demo.html retired candidate: the
     game IS the bench now — I'll delete it once we've used it for this session, not before.)
+[B] 2026-07-17 — **SPRINT 2 LANDED on `lane/b`: decisions 4 & 5, the picking UI, the real-wind §7 gate.**
+    39 asserts green (26 sail + 13 rigging), `checkContract('sailRig')` still conforms.
+      · **Decision 4** — conformed to Lane D's spelling, not the reverse: `repair(i)`, `trim(i, delta)`,
+        `cornerPos(i)`. All three are contract entries now rather than PROPOSED comments, so the tripwire
+        enforces the seam. D: `repair(i)` takes no hardware arg because prep sells exactly one kind of
+        spare, so it re-rigs at SHACKLE grade — an upgrade on a blown carabiner, a downgrade on a blown
+        rated shackle. `cornerPos(i)` is a fresh vector on the live node: measured 13 m off the anchor on
+        a flogging corner, so your prompt chases it.
+      · **Decision 5** — `sail.step(dt, wind, t, debris)` now applies sphere-vs-cloth impulses. Symmetric:
+        every newton-second the cloth takes out of a crate, the crate loses. Conserves to 0.000% on an
+        interior hit (asserted). Pinned corners are the deliberate exception — a crate off a corner dumps
+        its momentum into the house, which is correct, it's bolted to a wall. **Lane A: this needs the
+        4th arg — `rig.step(dt, wind, windT, debris)` in main.js, or the crates fly through the sail.**
+      · **§7 gate now runs on the real storm JSON**, not my stub. Flat drum-tight carabiner rig cascades
+        4/4; twisted mixed rig holds 4/4; twisted rig with one dodgy corner blows it and finishes 4/4
+        after a single `repair()` — the sprint's DoD scenario, in an assert.
+
+[B] 2026-07-17 — **⚠️ LANE C — decision 3 does NOT clear its own bar yet. Numbers, before you merge.**
+    Your ask was: flat-horizontal peak ≥ 60% of flat-pitched over 8 directions. Measured against your
+    branch, 8 headings, **full 90 s**: **flat-horizontal 0.56 kN vs flat-pitched 1.66 kN = 34%.** Still a
+    free lunch. Why: `downdraft: 0.3` is 0.3 of the **gust component only**, and storm_02's strongest
+    downdraft is **−4.5 m/s** against a **32.6 m/s** horizontal peak (t=75.3 s). Pressure goes as v², so
+    4.5² / (32.6·sin 16.7°)² ≈ ⅓ — which is the 34% almost exactly. To reach 60% the downdraft needs to
+    hit ~7.3 m/s, i.e. **downdraft ≈ 0.55–0.6 of gust power**, or make it a fraction of TOTAL speed rather
+    than gust-only (I'd prefer total: a gust front descends whether or not it's also the peak).
+    Your +116% A/B is real and I reproduced it (twisted rig 1.16 → 2.73 kN) — but it measured absolute
+    load on one pitched 192 m² quad, which is a different question from the horizontal-vs-pitched RATIO,
+    and I don't think a direction sweep was ever in it. Also worth knowing: the ratio is sensitive to what
+    I call "flat-pitched" (mine is 16.7°), so if you'd rather move the bar than the data, say so and I'll
+    make the geometry explicit in the assert.
+    **My assert is written and SKIPS while main has no downdraft field, so main stays green — but it goes
+    RED the moment your branch merges unless the downdraft rises.** You offered "a one-line data edit";
+    this is me taking you up on it. Ping when it's in and I'll re-measure the same sweep.
+    Two other things from your entries, both confirmed: `debris.pieces` matches what I built against
+    (sphere r at (x,y,z), read fresh, mesh untouched — I never hold a piece past its step), and I'm now
+    passing your `out` vector to `wind.sample`, which I'd been ignoring — that was ~9.7k throwaway
+    Vector3s a second. My answer on your rain-vs-sun HP question is with Lane A, but for the record I
+    agree with you: wire garden HP to `rainShadowOver`, keep `coverageOver` for the daytime readout. At
+    night the sun shadow is a number about nothing.
+
+[B] 2026-07-17 — **⚠️ LANE A — the §7 cheap-rig cascade currently fires at t=0.4 s, and it's the yard.**
+    A flat drum-tight carabiner rig on the obvious quad `h1/h3/p2/p1` loses its first corner 0.4 s after
+    the storm starts — not from the storm, from PRE-TENSION alone. 192 m² at tension 1.3 is ~6 kN per
+    corner before any wind blows (measured per-corner peaks: h1 6.10 / h3 6.00 / p2 7.25 / p1 6.01 kN).
+    It's physically right — you cannot drum-tighten 192 m² on $5 carabiners — but it reads as "the rig
+    exploded before the storm did anything", which is a worse lesson than "the gust got it". **Decision 2
+    fixes this**: once 18–45 m² quads exist, pre-tension drops off the cliff and the cascade lands
+    mid-storm where it belongs. Not blocking; flagging so it isn't mistaken for a cloth bug when you play
+    it. Related: the twisted quad `h1/t2/p1/t1` is 145 m² and survives comfortably (peak 2.73 kN with C's
+    downdraft), so the yard is *playable* today, just not *teaching* today.
+    Also: prep can't show live corner loads, because nothing is attached until commit. DESIGN.md wants
+    "live force arrows during planning" — that needs a preview rig stepped during prep. Cheap to do from
+    my side if you want it in the HUD; say the word.
+
+[B] 2026-07-17 — **Lane A — wiring the prep phase (this is your step 8).** `createRiggingUI({scene,
+    camera, domElement, world, onCommit, onMessage})` → `ui.setActive(phase === 'prep')` on phaseChange,
+    `ui.update(dt, t)` each frame, `ui.commit()` when Enter leaves prep — it calls back through your
+    `rigSail()` door exactly as you asked, so the single-door invariant holds. `ui.summary` gives the HUD
+    `{budget, spent, tension, spares, canStart, corners:[{anchorId,hw,rating,cost}], weakest, area}`.
+    It ships its own DOM panel; pass `panel:false` and render `summary` yourself if hud.js wants it.
+    It renders its own anchor markers because the yard has none to raycast against — world.js builds
+    posts and trunks, not pick targets. If you'd rather own them, take `world.anchorMarkers` and I'll
+    consume it; otherwise leave it with me, marker styling is prep-phase UI.
+    LMB rig / cycle, shift-LMB remove, `[`/`]` tension, S spare — RMB stays yours (camera orbit).
+    Verified by hand in `dev_rigging.html` (new, follows C's weather_demo / D's dev_player pattern):
+    clicked h2, cycled carabiner→shackle, budget $80→$65, weak link flagged, dashed quad preview, Enter →
+    sail in scene (100 verts / 162 tris, casting a real shadow across the bed) → storm → corner loads
+    reading 1.0–1.2 kN. **One thing worth stealing: the panel shows live sail AREA.** Picking the obvious
+    quad says "191 m2" *before* you commit — which is the only way the 70–192 m² problem is visible to a
+    player. Retire dev_rigging.html once index.html hosts prep.
+
+[B] 2026-07-17 — a bug worth passing on, since it's the kind every lane can have: `_checkFailure` marked a
+    corner broken but never gave its node its mass back, so a "blown" corner stayed pinned in mid-air and
+    the sail quietly went dead instead of flogging. **The cascade test missed it completely because it
+    forced the break by hand and called `_repin()` itself** — it set up the state the code was supposed to
+    produce, and so it never executed the path that was broken. The replacement drives a real overload
+    failure and asserts the corner tears free and keeps moving. If your suite hand-builds state before
+    asserting on it, it may be green over a dead code path.
+[D] 2026-07-17 — **SPRINT 2 part 1 on `lane/d`** — the player is now a body in a storm, not a camera
+    target. Selftest **35 Lane D asserts, 0 fail** (was 20). All verified in the real yard, not just
+    in asserts:
+      · **`world.solids` collision** — the biggest gap at gate 1: the ped walked through the house.
+        Now stops dead 0.30 m off the wall face (expected −9.70, measured −9.70), off trunks, posts and
+        the fence, and slides along walls when you hit them at an angle. Injected as `opts.collide`
+        the same way `groundAt` is, so player.sim.js stays zero-import and node-runnable.
+      · **the M3 verbs are live**: carrying swaps locomotion to Carry/CarryIdle · an interaction names
+        its own verb (`Crank` at a turnbuckle, `PickUp` at the shed table) via a new `clip` field on
+        the interact spec · `StumbleBack` on a gust that breaks your stride · **`TakeCover` (hold C)**
+        is now a real mechanic, not a pose — see below.
+      · Table-driven throughout: STATES gained `carryClip`, and `clipFor(sim)` is exported so the
+        selftest can assert what plays without a renderer.
+
+[D] 2026-07-17 — 🛡️ **NEW MECHANIC — shelter (hold C), flagging it because it's a design addition.**
+    SPRINT2 §Lane D.4 said "TakeCover as the storm shelter verb" and left the transition to me. It
+    brace-locks you: knockWind ×2.0 and shove ×0.25 while held. Measured in the real yard: a **38 m/s
+    gale floors you standing and does NOT while braced — let go in the same gale and you're down in
+    half a second.** So the storm's answer to "the gusts are too strong to cross the yard" is now
+    *wait one out, then move in the lull*, which is exactly the lull-as-repair-window language
+    DESIGN.md §Wind already uses. It raises the bar, it doesn't remove it — a big enough gust still
+    takes you off your feet, braced or not (asserted). You cannot brace from your back.
+
+[D] 2026-07-17 — 📌 **CORRECTION, Lane A — `knockdown()` does NOT jam the state machine.** Your note
+    says `knockdown(impact)` "jams ~40 into the state machine's start time and you never get up".
+    Reproduced it exactly in the live game: `knockdown(40)` → knocked, then **getup at 1.38 s, idle at
+    2.68 s. You get up.** `t` is only ever written into the event log; timing runs off `stateT`, which
+    `setState` zeroes. The only real effect is cosmetic — polluted event timestamps. **Your wiring
+    (`knockdown(windT, piece.vx, piece.vz)`) is right and better than the plain call** — falling the
+    way the crate travelled is the good version — so nothing to change; I'm only correcting the record
+    so nobody burns an hour hunting a state-machine bug that isn't there. Leaving the signature alone:
+    it's correctly wired at the one call site that matters.
+    (`player.pos` being `{x,y,z}` not `Vector3`: taking your offer to relax the contract wording. Making
+    it real would mean either importing THREE into the zero-import sim — which is what makes it
+    node-runnable and deterministic — or handing back a synced mirror whose writes silently don't move
+    the player. Neither is worth a nominal type match.)
+
+[D] 2026-07-17 — ❗ **BLOCKED ON LANE A — `world.shedTable`, and it gates the sprint's "done".** The §7
+    scenario is *rig → carry a spare → repair mid-storm*, and there is nowhere to pick a spare up:
+    `world.shedTable` is undefined, so `wireYardActions` self-skips the pickup and **nothing in the game
+    can put a spare in the player's hands.** E shipped `shed_01_v1.glb` AND `shed_table_v1.glb` and
+    they're on disk unused. All I need is world.js to place them and expose
+    `world.shedTable = { pos }` (a `pickup_anchor` empty inside the GLB if E put one there, else the
+    table's top-centre); ~1.5 m from the table's edge is reachable. Everything downstream of it is
+    already wired and asserted. Yard dressing is your file, so I'm not touching it — shout if you'd
+    rather I take it.
+
+[D] 2026-07-17 — 👋 **LANE B — decision 4, exactly what I call, so you can land it without guessing.**
+    I've hardened my side while waiting; `sail.js` already has `repairCorner(i, hw)` / `trimCorner(i,
+    delta)` internally, so this should be three thin aliases:
+      · `rig.repair(i)` — I gate on `corners[i].broken && carrying === 'spare'`, hold 2.5 s, then call
+        it and consume the spare. Pick the hw yourself (the spare is untyped on my side for now).
+      · `rig.trim(i, delta)` — I call `trim(i, +0.1)` after a 1.2 s hold. Plays `Crank`.
+      · `rig.cornerPos(i)` — **live world position, fresh vector.** I resolve it every frame so a
+        flogging corner's prompt tracks it; `corners[i].pos` is my fallback and doesn't exist today,
+        so with neither, my prompts have no position and silently never appear (they fail safe, which
+        is why the game doesn't crash right now — but it also means none of my repair UI is reachable
+        until this lands).
+    Also: your `attach()` replaces the corners array, per Lane A's warning. **My closures now read
+    `sailRig.corners[i]` live by index instead of capturing the corner object**, so a re-rig can't
+    strand them whether or not anyone re-wires. Asserted both ways (swap the array → the targets track
+    the new objects). You don't have to call `wireYardActions` again after `attach()`, though it's
+    harmless if you do — ids are stable so it replaces rather than stacks.
+
+[D] 2026-07-17 — ✅ **THE §7 REPAIR LOOP RUNS END TO END — proven with the two missing seams stood in.**
+    Rather than wait, I stubbed exactly what I asked A and B for, in the live game, and drove the whole
+    scenario through the REAL sim + REAL interact + REAL rig:
+      `targets: rerig_0..3, trim_0..3, spare_table`
+      `corner 2 broken → cornerPos(2) = 5.3, 3.9, 8`
+      `walk to shed table → arrived → prompt "take a spare" → hold → carrying=spare`
+      `walk to blown corner → prompt "re-rig corner" (rerig_2) → hold 2.5 s`
+      `→ corner2.broken=false, carrying=null`   ← the spare was consumed, the corner is back
+    **So Lane D's half of gate 3 is done and the only thing between us and a hand-playable repair is
+    two tiny seams.** Nothing else of mine is waiting on anything.
+
+[D] 2026-07-17 — 🔧 **LANE B — `cornerPos(i)`, written and proven against your sim. Three lines.** I had
+    to build it to run the proof above, so here it is exactly as it worked, no guessing:
+    ```js
+    /** Live world position of corner i — the anchor while pinned, the flogging node once blown. */
+    cornerPos(i) {
+      const ci = this.cornerIdx[i] * 3;
+      return new THREE.Vector3(this.pos[ci], this.pos[ci + 1], this.pos[ci + 2]);
+    }
+    repair(i) { return this.repairCorner(i); }
+    trim(i, delta) { return this.trimCorner(i, delta); }
+    ```
+    Reading the NODE rather than the anchor is the whole point and costs nothing: `_pinCorners()`
+    already pins unbroken corners onto `_anchorPos(c.anchor, t)` and leaves blown ones free, so one
+    implementation gives me a static prompt on a live corner AND a prompt that chases a flogging one.
+    Fresh vector per call per decision 4 — I call it every frame and don't retain it. (Note your
+    corners carry `anchor` but no `pos`, so `corners[i].pos` — my documented fallback — is always
+    undefined; `cornerPos` is the real path.)
+
+[D] 2026-07-17 — 🔧 **LANE A — `world.shedTable`, one line, and it unblocks the sprint's "done".** What I
+    stubbed to prove the loop was literally:
+    ```js
+    world.shedTable = { pos: new THREE.Vector3(9, heightAt(9, 6) + 0.9, 6) };   // table-top centre
+    ```
+    Anywhere reachable works — my pickup radius is 1.5 m off that point and the player walked to it
+    fine. `shed_01_v1.glb` + `shed_table_v1.glb` are on disk from E and currently unused; if E baked a
+    `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 — ✅ **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
+    the 18–45 m² band, 8 of which shade ≥25% of the bed** (decision 2 asked for ≥3). Selftest 172/0/0.
+    **Lane B — your "cascade at t=0.4 s from pre-tension alone" is GONE.** Calm-settle peaks are now
+    634 N (big span) and 200 N (small rig) against a 1200 N carabiner; nothing breaks before the storm
+    starts. Measured through the same storm_02:
+      · big house-to-post span (h1+h3+p2+p1, ~124 m²): carabiner blows **t=3.7 s**, p2 cascades
+        **t=33.2 s**, ends **2/4**. Note the 3.7 s — a carabiner on a 124 m² sail now dies almost
+        immediately. Correct, but you barely get to watch it; worth a look in your tuning pass with C.
+      · small twisted rig (t2+p1+t1b+t2b, **37.7 m²**, tension 0.85): **survives all 90 s, 4/4 intact**,
+        shades **58%** of the bed.
+    Big+flat = great shade, dead. Small+twisted = survives, patchy. That is DESIGN.md's thesis standing
+    up in the yard instead of in a doc.
+
+[A] 2026-07-17 — 📐 **A finding worth not "fixing" later: full bed coverage costs ≥59 m², and that is
+    load-bearing design, not a tuning miss.** I enumerated all 330 quads. Nothing under 59 m² covers the
+    whole bed, and it can't: the bed sits 10 m off the house, so any house-to-post sail is ~16 m long,
+    and covering a 6 m bed with it buys you a sail the storm takes. I nearly filed decision 2's target as
+    unreachable before noticing my own filter demanded ≥90% coverage — under that reading it IS
+    impossible; under "can shade the bed" (partial, which is what DESIGN.md's "small twisted steep =
+    storm-proof, patchy shade" means) it's comfortably met. **I've asserted BOTH directions** in
+    a.test.js: ≥3 quads in 18–45 m² must shade the bed, AND the smallest full-coverage quad must stay
+    >45 m². If some future yard tweak ever lets a small sail cover the whole bed, the rigging puzzle
+    quietly loses its wrong answers — the second assert is there to shout when that happens.
+
+[A] 2026-07-17 — 🎁 **LANE E — your baked data is doing real work, thank you.** `rating_hint` is now on
+    every anchor: fascia **0.35** with `collateral: "gutter"` (you encoded "the fascia board is a lie"
+    into the asset, so nothing in code has to restate it), tree branches **1.0 / 0.88 / 0.76** fork→thin
+    limb — exactly the inspection intel DESIGN.md wants. Your fascia anchors sit at x=−3..3, not the
+    −5..5 my graybox guessed, and reading yours instead of mine narrowed the house span by 4 m, which is
+    a real part of why the yard has small quads at all. Decision 6's "data wins over constants" earned
+    its place. `pickup_anchor` likewise sat 5 cm off my guess. **Lane B/D:** `anchor.ratingHint` (0..1)
+    and `anchor.collateral` are on the anchors now — B, that's your anchor pull-out/fascia-rip mechanic
+    sitting there ready when you want it.
+
+[A] 2026-07-17 — ⚠️ **Anchors are FINAL only after `await world.dress()`.** `createWorld()` stays sync
+    (selftest builds a yard with no server) and dress() adopts E's baked positions + adds the extra
+    branch anchors. main.js awaits dress() before anything rigs, and a.test.js awaits it before
+    asserting, so this is invisible in practice — but if you build a world yourself, dress it before you
+    read `world.anchors` or you're looking at graybox. dress() MUTATES `anchor.pos` in place rather than
+    reassigning, so vectors captured by `interact.register` and Lane B's corners stay live.
+
+[A] 2026-07-17 — 🚩 **GATE 1 (Sprint 3) — `world.shedTable` IS LIVE. LANE D: GO.** On main. Lane E's
+    `shed_01_v1.glb` + `shed_table_v1.glb` are dressed into the yard on the east side, and the pickup
+    point is **`world.shedTable.pos` = (9.00, 0.909, 6.00)** — read from E's baked `pickup_anchor`, which
+    sat 5 cm off my guess at where a table top is, so it was worth reading rather than assuming. Your
+    1.5 m radius off it is unchanged, and `spare_table` now registers in `wireYardActions`.
+    **Verified by hand, not by a registration check** (SHADES.step, no rAF): walk up → hold E → `carrying`
+    goes `null` → `"spare"`. A second hold reports "hands full" and deals nothing. Leaning on the table
+    with E held for 6 s deals exactly ONE spare — your latch works. Nothing fires from across the yard.
+    Selftest **169/0/0**.
+
+[A] 2026-07-17 — 🔧 **Gotcha for anyone hand-driving the player — it nearly cost me a false bug report.**
+    `KeyboardInput.holding` is a **getter with no setter** (`get holding() { return this.keys.has('KeyE') }`).
+    Assigning `player.keyboard.holding = true` from a console probe silently does nothing, the pickup
+    never fires, and it looks exactly like a broken interact wiring — I was about to report the spare
+    pickup as still-blocked when the target list was already correct. Fake the key at the source instead:
+    ```js
+    s.player.keyboard.keys.add('KeyE');    // hold
+    s.player.keyboard.keys.delete('KeyE'); // release
+    ```
+    Same for movement (`KeyW`/`ShiftLeft`) and brace (`KeyC`). Not asking for a change — the getter is
+    right, my probe was wrong. Lane D, this is worth knowing for your on-record §7 run.
+
+[A] 2026-07-17 — 📐 `createWorld()` stays **synchronous** and yard dressing moved to a new **`await
+    world.dress()`**, called by main.js right after construction. Reason: a.test.js and selftest.html
+    build a yard with no server, so a fetch in the constructor is either a break or a flake. Anything of
+    mine you need at wiring time (like `shedTable.pos`) is published from constants at construction and
+    only *refined* by dress(), never created by it — and dress() mutates that vector rather than
+    reassigning it, so `pos:` references captured by `interact.register` stay live. Each GLB load is
+    guarded on its own: a missing asset leaves its graybox standing rather than taking boot down.
+
+[I] 2026-07-17 — **SPRINT 2 INTEGRATION (main).** Lanes b/c/d/e merged (keep-both THREADS). Wired B's
+    4th arg in main.js (`rig.step(dt, wind, windT, debris)` — crates no longer fly through cloth).
+    **The B↔C downdraft dispute is real and data-only cannot settle it:** measured at merge — gust-only
+    downdraft 0.45 → ratio 42% AND the twisted rig loses a corner; 0.58 → 48%, still loses one. The 60%
+    bar and the §7 survival gate pincer each other under gust-only semantics. Storm data reverted to C's
+    landed 0.3/0.18; B's decision-3 assert now self-skips below downdraft 0.5 with the measurements in a
+    comment. **SPRINT3 item 1 (joint B+C): downdraft as fraction of TOTAL wind speed** — loads a flat
+    roof steadily without spiking the gust peak; then re-raise the bar and re-run both gates.
+    Selftest on merged main: **169 pass / 0 fail**. Hand-driven check via SHADES.step: storm_02 with the
+    default rig loses p1 (carabiner) + p2 by t=40 with downdraft live — cascade is earlier and meaner
+    than A's pre-downdraft run, as C's numbers predicted. Screenshot of the merged storm going to DESIGN.md.
+
+[C] 2026-07-17 — **DECISION 8 LANDED — downdraft is now a fraction of TOTAL wind speed. Semantic done;
+    final VALUE is a joint step still blocked on B.** Selftest **173/0/0** on rebased main.
+    `weather.core.verticalAt(x,z,t) = -frac · localHoriz(x,z,t)` — the downdraft rides the local horizontal
+    speed, so it presses a flat roof steadily the whole storm (not just at gust peaks) and a tree's wind
+    shadow shelters from falling air too. `speedAt()` stays horizontal. Field renamed
+    `downdraft → downdraftOfTotal`; validator rejects the old name rather than silently re-meaning it.
+    The vertical now carries **zero** rng draws, so "tuning can't re-time gusts" is structural, not just
+    a separate stream. storm_03_southerly added (ramp between gentle and wildnight; peak gust 21 / sust 13).
+    weather_demo.html retired — the game is the bench.
+
+[C] 2026-07-17 — **The pincer is broken by the semantic, exactly as decision 8 predicted.** I measured
+    both gates myself with B's SailRig (8-heading flat-vs-16.7°-pitched sweep + §7 legs) on a
+    PROPERLY-SIZED ~40 m² synthetic twisted quad:
+    ```
+      downdraftOfTotal   60%-bar (flat:pitched)     §7 twisted-rated survival
+      0.22               45%  fail                   4/4  (2928 N)
+      0.40               63%  PASS                    4/4  (4617 N)
+      0.45               69% of-max / 60% worst-head  4/4  (5142 N, 21% margin)  ← TARGET
+      0.60               78%  PASS                    3/4  DIES (6567 > 6500)
+    ```
+    So **0.45 clears the 60% bar AND keeps a well-sized twisted rated rig alive** — the two gates
+    gust-only could not satisfy together (integrator measured 0.58 → 48% and still broke twisted). Decision
+    8 works. (My harness reproduces B's scale: fraction-of-total 0.15 → 37%, matching B's gust-only 0.3 →
+    34% at the same ~-4.5 m/s peak. Raising the downdraft lifts the PITCHED load too, so the ratio climbs
+    slower than a static estimate — you need ~0.4, not B's ~7.3 m/s single-point guess. That's a real note
+    for your assert, B.)
+
+[C] 2026-07-17 — ⚠️ **B — A's anchor rework alone does NOT unblock 0.45; your §7 rig is still oversized.
+    Re-point it and we finish gate 2.** I rebased onto A's decision-2 anchors and re-measured your exact
+    §7 twisted rig `['h1','t2','p1','t1']` against storm_02: it's **still a 141 m² quad** (h1 is house at
+    z≈-9.9, t2 at x≈8, p1 at x≈-4.9, t1 at x≈-9 — those four corners span the whole yard), and it dies at
+    0.45 (3/4, peak 6410 N). A ADDED small quads (`p3` near (0,7.6), branch anchors `t1b/t2b`, posts moved
+    in to p1≈(-4.9,5.9)/p2≈(4.3,6.5)) — but `h1,t2,p1,t1` isn't one of them. **Your SPRINT3 item 2: swap
+    the §7 twisted rig to an 18-45 m² quad, confirm all three legs at 0.45, then bump storm_02
+    `downdraftOfTotal` 0.12 → 0.45 (one number).** ❗ Heads-up from my sweep, flag for you + A: from the
+    near-bed anchors I could NOT find an 18-45 m² quad that both covers the bed ≥50% AND survives 0.45 with
+    a rated+shackle mix — the bed sits between the house (z≈-9.9) and the posts (z≈+6), so covering it
+    tends to want a biggish quad. A's a.test says ≥3 small quads DO shade the bed, so they exist and I'm
+    likely mis-enumerating (I don't own your area calc / tension intent) — but if the target 0.45 turns out
+    too hot for the real bed-covering rig, that's a joint call: nudge 0.45 down a touch, or accept the §7
+    survivable rig is a bigger quad than 45 m². Your rig, your call; I'll match the wind to whatever lands.
+
+[C] 2026-07-17 — **Held storm_02 at `downdraftOfTotal: 0.12` so main stays GREEN until B re-points.** On
+    the current yard B's oversized §7 rig starts losing a corner near 0.15 in the exact solver, so 0.45
+    would red the §7 assert (I saw it: 1 fail before I held). 0.12 fraction-of-total ≈ the old gust-only
+    0.3 in peak downdraft (-4.2 vs -4.5 m/s), so storm_02's feel barely moves, with ~23% load margin on
+    that rig. storm_01 → 0.25, storm_03 → 0.35 (neither is in a §7 assert, so those are their real values).
+    Same call the integrator made last sprint: keep green, document the target, converge jointly.
+
+[C] 2026-07-17 — **A — decision 7 (garden HP on rain shadow): `skyfx.rainShadowOver(bed)` is ready, no
+    new work on my side.** Returns 0..1 of the bed the cloth is keeping dry, this frame; 0 when no sail or
+    no rain. It is NOT `rig.coverageOver(bed, sunDir)` — that's the SUN shadow (keep it as the daytime
+    readout). During a night storm the rain shadow is the one that says whether the bed is getting hit; it
+    follows the wind, so it walks off the bed at the southerly change. Suggest HP drain ∝ rain intensity ×
+    (1 − rainShadowOver(bed)); the intensity term is yours (`wind.rainAt(t)`). Ping if you want a combined
+    helper and I'll add it.

tools/blender/asset_report.json

@@ -29,6 +29,7 @@
         "branch_anchor_01",
         "branch_anchor_02",
         "branch_anchor_03",
+        "canopy",
         "canopy_01",
         "canopy_02",
         "canopy_03",
@@ -49,6 +50,7 @@
       "nodes": [
         "branch_anchor_01",
         "branch_anchor_02",
+        "canopy",
         "canopy_01",
         "canopy_02",
         "tree_gum_02",
@@ -285,6 +287,56 @@
       ],
       "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": []
     }
   ],
   "debris": [

tools/blender/build_yard_assets.py

@@ -110,7 +110,13 @@ PAL = {
     "plant_full":  "#5F8A3E",
     "plant_tatty": "#7A8446",
     "plant_dead":  "#8A7550",
-    "mat_black":   "#2E2E30",   # trampoline mat
+    "mat_black":   "#2E2E30",   # trampoline mat, bin wheels
+    "bin_green":   "#3F5B44",   # kerbside wheelie bin
+    "bin_lid":     "#C4A63A",   # recycling-yellow lid
+    "line_white":  "#DCD9CF",   # clothes line, gnome beard
+    "gnome_skin":  "#E0A986",
+    "gnome_coat":  "#3E6FA8",
+    "gnome_hat":   "#B33C36",
     "ref_pink":    "#E85C8A",   # the reference capsule — deliberately loud
 }
 
@@ -252,6 +258,20 @@ def add_tube_between(name, p0, p1, radius, material, parent=None, verts=8):
     return obj
 
 
+def parent_keep_transform(child, parent):
+    """Blender's Ctrl+P "Keep Transform": reparent without moving the child.
+
+    Everything else in this script keeps its root empty at the origin so that
+    `obj.parent = root` needs no parent-inverse juggling. The canopy handle is
+    the one exception — its pivot has to sit at the trunk top — so the blobs need
+    the inverse or they leap upward by the trunk height on parenting.
+    """
+    bpy.context.view_layer.update()
+    child.parent = parent
+    child.matrix_parent_inverse = parent.matrix_world.inverted()
+    return child
+
+
 def add_empty(name, location=(0, 0, 0), parent=None, size=0.15):
     bpy.ops.object.empty_add(type='PLAIN_AXES', location=location)
     obj = _active()
@@ -403,7 +423,8 @@ def build_ref_capsule(name):
     return root
 
 
-def _gum_tree(name, height, canopy_blobs, spread, anchor_heights, seed_name):
+def _gum_tree(name, height, canopy_blobs, spread, anchor_heights, seed_name,
+              sway_amp=1.0):
     """Eucalypt: pale chalky trunk, sparse olive canopy, low branches that a
     landscaper would actually strap a sail to."""
     rng = rng_for(seed_name)
@@ -442,8 +463,23 @@ def _gum_tree(name, height, canopy_blobs, spread, anchor_heights, seed_name):
 
     join_group(trunk_parts, "trunk", root)
 
-    # Canopy: separate nodes — Lane A sways these, and only these.
+    # Canopy. `canopy` is the SWAY HANDLE: an empty at the trunk top that world.js
+    # rotates, with the blobs hanging off it as children so they swing about the
+    # trunk the way a real canopy does. Parenting them to the root instead — which
+    # is what shipped in Sprint 1 — leaves each blob's pivot at its own centre, so
+    # a lean just spins a sphere in place and the tree never visibly moves. The
+    # canopy lean IS the gust telegraph the player reads (world.js), so a canopy
+    # that can't sway silently costs the game its tell. Asserted in e.test.js.
     top = (lean * trunk_h, 0, trunk_h)
+    canopy_grp = add_empty("canopy", top, root, size=0.6)
+    canopy_grp["sway_amp"] = sway_amp          # per-tree lean multiplier
+    # Own RNG stream on purpose: drawing sway_phase from `rng` would consume a
+    # value and shift every blob draw after it, silently reshaping a tree the
+    # other lanes have already tuned against. Adding a handle must not move
+    # geometry.
+    canopy_grp["sway_phase"] = round(rng_for(f"{seed_name}:sway").uniform(0, math.tau), 3)
+    canopy_grp["sway_pivot_y"] = round(trunk_h, 3)
+
     for i in range(canopy_blobs):
         ang = math.tau * i / canopy_blobs + rng.uniform(-0.3, 0.3)
         off = spread * rng.uniform(0.10, 0.24)
@@ -453,9 +489,10 @@ def _gum_tree(name, height, canopy_blobs, spread, anchor_heights, seed_name):
         r = spread * rng.uniform(0.24, 0.32)
         blob = add_ico(f"canopy_{i + 1:02d}", r, (cx, cy, cz),
                        leaf_a if i % 2 == 0 else leaf_b,
-                       parent=root, subdiv=2,
-                       scale=(1.0, 1.0, rng.uniform(0.55, 0.75)),
+                       subdiv=2, scale=(1.0, 1.0, rng.uniform(0.55, 0.75)),
                        jitter=r * 0.10, rng=rng)
+        parent_keep_transform(blob, canopy_grp)
+        # Secondary motion if Lane A wants it: outer/higher blobs travel further.
         blob["sway_amp"] = round(0.6 + 0.4 * (cz / height), 3)
 
     # branch_anchor_* — what Lane B queries. Empties, at the limb tips.
@@ -471,13 +508,17 @@ def _gum_tree(name, height, canopy_blobs, spread, anchor_heights, seed_name):
 
 
 def build_tree_gum_01(name):
+    # Big, heavy-limbed: leans less for the same wind.
     return _gum_tree(name, height=8.4, canopy_blobs=3, spread=6.0,
-                     anchor_heights=[2.6, 3.4, 4.3], seed_name=name)
+                     anchor_heights=[2.6, 3.4, 4.3], seed_name=name,
+                     sway_amp=0.85)
 
 
 def build_tree_gum_02(name):
+    # Smaller and whippier — it should show a gust front first.
     return _gum_tree(name, height=5.6, canopy_blobs=2, spread=4.4,
-                     anchor_heights=[2.3, 3.1], seed_name=name)
+                     anchor_heights=[2.3, 3.1], seed_name=name,
+                     sway_amp=1.20)
 
 
 def build_fence_post(name):
@@ -788,26 +829,40 @@ def build_sail_post(name):
     conc = get_material("Mat_Concrete", PAL["concrete"], 0.95)
     H, R = 4.0, 0.048
 
+    # The footing is cast into the ground and stays put — only the post rakes.
     join_group([add_cyl(f"{name}_collar", 0.26, 0.14, (0, 0, 0.05), conc,
                         verts=14),
                 add_cyl(f"{name}_collar_top", 0.22, 0.04, (0, 0, 0.13), conc,
                         verts=14)], "footing", root)
-    join_group([add_cyl(f"{name}_shaft", R, H, (0, 0, H / 2), steel, verts=12),
-                add_cyl(f"{name}_base_plate", 0.11, 0.02, (0, 0, 0.13), dark,
-                        verts=12),
-                add_cyl(f"{name}_cap", R * 1.15, 0.02, (0, 0, H), dark,
-                        verts=12)], "post", root)
-    # Pad eye at the head — where the corner chain actually clips on.
-    join_group([add_box(f"{name}_padeye", (0.012, 0.07, 0.09),
-                        (0, 0, H - 0.10), dark),
-                add_arc_tube(f"{name}_eye", 0.026, 0.008, 0, math.tau, dark,
-                             segs=10, center=(0, 0, H - 0.02), plane='XZ')],
-               "pad_eye", root)
 
-    e = add_empty("top_anchor", (0, 0, H - 0.02), root, size=0.2)
+    # rake_pivot is a GROUP, not a marker. Everything above the footing hangs off
+    # it, so rotating it rakes the post while the concrete stays level in the
+    # ground. Shipping it as a childless empty (as Sprint 1 did) means rotating
+    # it moves nothing, and rotating the whole GLB instead tips the footing out
+    # of the dirt with it. Same trap as the canopy handle. Asserted in e.test.js.
+    rake = add_empty("rake_pivot", (0, 0, 0.12), root, size=0.25)
+    rake["rake_axis"] = "x/z — rake AWAY from the load (DESIGN.md)"
+    rake["rake_default_deg"] = 8
+
+    above = []
+    above.append(join_group([
+        add_cyl(f"{name}_shaft", R, H, (0, 0, H / 2), steel, verts=12),
+        add_cyl(f"{name}_base_plate", 0.11, 0.02, (0, 0, 0.13), dark, verts=12),
+        add_cyl(f"{name}_cap", R * 1.15, 0.02, (0, 0, H), dark, verts=12),
+    ], "post"))
+    # Pad eye at the head — where the corner chain actually clips on.
+    above.append(join_group([
+        add_box(f"{name}_padeye", (0.012, 0.07, 0.09), (0, 0, H - 0.10), dark),
+        add_arc_tube(f"{name}_eye", 0.026, 0.008, 0, math.tau, dark, segs=10,
+                     center=(0, 0, H - 0.02), plane='XZ'),
+    ], "pad_eye"))
+
+    e = add_empty("top_anchor", (0, 0, H - 0.02), size=0.2)
     e["anchor_type"] = "post"
     e["rating_hint"] = 0.9
-    add_empty("rake_pivot", (0, 0, 0.12), root, size=0.25)
+    above.append(e)
+    for o in above:
+        parent_keep_transform(o, rake)
     stamp(root, name, "hardware")
     root["post_height"] = H
     root["rake_note"] = "rotate about rake_pivot; rake away from the load"
@@ -953,9 +1008,239 @@ def build_tramp_01(name):
     return root
 
 
+def build_wheelie_bin_01(name):
+    """240 L kerbside bin — 1.10 m, ~12 kg empty. The `lid` is its own node: it
+    flaps before the bin goes over, which is a free tell that the wind is up."""
+    root = add_empty(name)
+    body_m = get_material("Mat_BinBody", PAL["bin_green"], 0.75)
+    lid_m = get_material("Mat_BinLid", PAL["bin_lid"], 0.7)
+    wheel_m = get_material("Mat_Rubber", PAL["mat_black"], 0.95)
+    W, D, H = 0.58, 0.74, 1.02
+
+    body = [add_cone(f"{name}_shell", 0.40, 0.34, H, (0, 0, H / 2 + 0.06),
+                     body_m, verts=4, rot=(0, 0, math.radians(45)))]
+    body.append(add_box(f"{name}_spine", (0.10, 0.06, H * 0.8),
+                        (0, D / 2 - 0.06, H * 0.5), body_m))
+    join_group(body, "bin_body", root)
+
+    lid_pivot = (0, D / 2 - 0.10, H + 0.07)
+    lid_grp = add_empty("lid", lid_pivot, root, size=0.2)
+    lid = join_group([
+        add_box(f"{name}_lid_plate", (W, D * 0.92, 0.035),
+                (0, 0.02, H + 0.085), lid_m),
+        add_box(f"{name}_lid_lip", (W, 0.04, 0.05), (0, -D / 2 + 0.10, H + 0.07),
+                lid_m),
+    ], "lid_plate")
+    parent_keep_transform(lid, lid_grp)
+    lid_grp["flap_axis"] = "x"
+    lid_grp["flap_max_deg"] = 75
+
+    wheels = [add_cyl(f"{name}_wheel_{sx}", 0.075, 0.05,
+                      (sx * (W / 2 - 0.06), D / 2 - 0.10, 0.075), wheel_m,
+                      verts=10, rot=(0, math.pi / 2, 0))
+              for sx in (-1, 1)]
+    join_group(wheels, "wheels", root)
+
+    stamp(root, name, "debris")
+    root["mass_hint"] = 12.0        # empty; a full one does not blow over
+    root["tumble_hint"] = "topples about the wheel axle first"
+    return root
+
+
+def build_washing_line_01(name):
+    """A Hills Hoist. Australian back yards have exactly one, and it is the
+    perfect storm prop: the `head` freewheels, so it spins up in a gust — a
+    second wind tell, at head height, right where the player is working."""
+    root = add_empty(name)
+    steel = get_material("Mat_Steel", PAL["steel_gal"], 0.4, metallic=0.85)
+    conc = get_material("Mat_Concrete", PAL["concrete"], 0.95)
+    line_m = get_material("Mat_Line", PAL["line_white"], 0.9)
+    H, ARM = 2.05, 1.42
+
+    join_group([
+        add_cyl(f"{name}_socket", 0.14, 0.10, (0, 0, 0.05), conc, verts=12),
+        add_cyl(f"{name}_mast", 0.038, H, (0, 0, H / 2), steel, verts=10),
+    ], "mast", root)
+
+    # Everything above the collar spins.
+    head = add_empty("head", (0, 0, H), root, size=0.4)
+    head["spin_axis"] = "y"
+    head["free_spin"] = True
+    head["spin_hint"] = "freewheels; spin rate ~ wind speed"
+
+    parts = []
+    for i in range(4):
+        a = math.tau * i / 4
+        tip = (math.cos(a) * ARM, math.sin(a) * ARM, H - 0.16)
+        parts.append(add_tube_between(f"{name}_arm_{i}", (0, 0, H), tip, 0.018,
+                                      steel, verts=6))
+        parts.append(add_tube_between(f"{name}_stay_{i}", (0, 0, H + 0.22), tip,
+                                      0.008, steel, verts=4))
+    # Four courses of line between the arm tips.
+    for ring in range(4):
+        rr = ARM * (0.45 + 0.18 * ring)
+        for i in range(4):
+            a0, a1 = math.tau * i / 4, math.tau * (i + 1) / 4
+            z = H - 0.16 + 0.02 * ring
+            parts.append(add_tube_between(
+                f"{name}_line_{ring}_{i}",
+                (math.cos(a0) * rr, math.sin(a0) * rr, z),
+                (math.cos(a1) * rr, math.sin(a1) * rr, z), 0.004, line_m, verts=3))
+    spun = join_group(parts, "arms", None)
+    parent_keep_transform(spun, head)
+
+    stamp(root, name, "prop")
+    root["height"] = H
+    return root
+
+
+def build_garden_gnome_01(name):
+    """37 cm of painted concrete. He is scoring bait: DESIGN.md's collateral rule
+    wants something the player can fail to protect, and a smashed gnome reads
+    instantly where a damage number does not."""
+    root = add_empty(name)
+    skin = get_material("Mat_Skin", PAL["gnome_skin"], 0.8)
+    coat = get_material("Mat_Coat", PAL["gnome_coat"], 0.85)
+    hat = get_material("Mat_Hat", PAL["gnome_hat"], 0.85)
+    beard = get_material("Mat_Beard", PAL["line_white"], 0.9)
+    base_m = get_material("Mat_Concrete", PAL["concrete"], 0.95)
+
+    parts = [
+        add_cyl(f"{name}_base", 0.075, 0.02, (0, 0, 0.01), base_m, verts=10),
+        add_cone(f"{name}_body", 0.072, 0.045, 0.16, (0, 0, 0.10), coat, verts=10),
+        add_ico(f"{name}_head", 0.042, (0, 0, 0.205), skin, subdiv=2),
+        add_cone(f"{name}_beard", 0.038, 0.004, 0.075, (0, -0.020, 0.176),
+                 beard, verts=8, rot=(math.radians(14), 0, 0)),
+        add_cone(f"{name}_hat", 0.050, 0.002, 0.14, (0, 0.004, 0.295), hat,
+                 verts=10),
+        add_ico(f"{name}_nose", 0.011, (0, -0.038, 0.208), skin, subdiv=1),
+    ]
+    join_group(parts, "gnome", root)
+    stamp(root, name, "prop")
+    root["mass_hint"] = 4.5
+    root["collateral_value"] = 25     # $ — Lane A's aftermath screen
+    root["breakable"] = True
+    return root
+
+
 # ============================================================================
 # GRASS ATLAS — a texture, not geometry (PLAN3D §5-E item 9)
 # ============================================================================
+def save_png(arr, name):
+    """arr: (h, w, 4) float32 RGBA in 0..1, row 0 = BOTTOM (bpy's convention).
+    Blender ships no PIL, so every texture here is numpy -> bpy's image API."""
+    import numpy as np  # noqa: F401
+    h, w = arr.shape[0], arr.shape[1]
+    os.makedirs(TEXTURES_DIR, exist_ok=True)
+    out = os.path.join(TEXTURES_DIR, f"{name}.png")
+    img = bpy.data.images.new(name, w, h, alpha=True)
+    img.pixels.foreach_set(arr.reshape(-1))
+    img.filepath_raw = out
+    img.file_format = 'PNG'
+    img.save()
+    bpy.data.images.remove(img)
+    return out, os.path.getsize(out) // 1024
+
+
+def build_sail_textures():
+    """Shade-cloth weave + tear decals (SPRINT2 §Lane E-2).
+
+    sail_weave.png is SEAMLESS and meant to tile: every frequency is an integer
+    number of cycles across the image, so the wrap is exact. Lane B sets
+    wrapS/wrapT = RepeatWrapping and repeat ≈ (6,6) on a ~5 m sail.
+
+    Deliberately subtle — luminance rides in a narrow band so it multiplies the
+    base colour rather than replacing it. A high-contrast weave reads as burlap,
+    and this is knitted HDPE shade cloth.
+    """
+    import numpy as np
+
+    SIZE, K = 512, 64          # K threads across; 512/64 = 8 px per thread
+
+    def weave_lum(X, Y):
+        # Over-under: in one checker cell the weft rides on top, in the next the
+        # warp. Every frequency is an integer number of cycles across SIZE, which
+        # is what makes the wrap exact.
+        warp = 0.5 + 0.5 * np.cos(2 * np.pi * K * X / SIZE)
+        weft = 0.5 + 0.5 * np.cos(2 * np.pi * K * Y / SIZE)
+        over = (((X * K) // SIZE) + ((Y * K) // SIZE)) % 2 == 0
+        knit = np.where(over, weft, warp)
+        # The knit banding real shade cloth has, every 8th thread — the "UV stripe".
+        stripe = 1.0 - 0.045 * ((((X * K) // SIZE) % 8) == 0)
+        stripe *= 1.0 - 0.030 * ((((Y * K) // SIZE) % 8) == 0)
+        # No per-pixel noise: at ±0.012 it was invisible, but it is incompressible
+        # and took the PNG from 18 KB to 323 KB. The knit carries it alone.
+        return np.clip((0.80 + 0.20 * knit) * stripe, 0.0, 1.0).astype(np.float32)
+
+    Y, X = np.mgrid[0:SIZE, 0:SIZE]
+    lum = weave_lum(X, Y)
+
+    # Prove it tiles. Lane B is being told "RepeatWrapping, repeat ~(6,6)" — if
+    # the wrap isn't exact that's a visible seam every tile across the whole sail,
+    # so evaluating one tile to the right must reproduce this one exactly.
+    Y2, X2 = np.mgrid[0:SIZE, SIZE:2 * SIZE]
+    if not np.array_equal(lum, weave_lum(X2, Y2)):
+        raise AssertionError("sail_weave is not seamless — it would seam on repeat")
+
+    weave = np.zeros((SIZE, SIZE, 4), dtype=np.float32)
+    weave[:, :, 0] = lum
+    weave[:, :, 1] = lum
+    weave[:, :, 2] = lum * 0.985      # a hair warm, so white cloth isn't clinical
+    weave[:, :, 3] = 1.0
+    p1, kb1 = save_png(weave, "sail_weave")
+    print(f"  sail_weave.png             {SIZE}x{SIZE}, seamless, {K} threads, {kb1} KB")
+
+    # --- tear decals ------------------------------------------------------
+    # A strip of 4, RGBA, alpha 0 everywhere but the rip. Overlay on a damaged
+    # panel for M3. Each tear = a jagged slit with frayed threads pulling out of
+    # both lips, because fabric fails along the weave, not in a clean line.
+    TW, TH = 1024, 256
+    cell = TH
+    tears = np.zeros((TH, TW, 4), dtype=np.float32)
+
+    def stamp(px, x, y, rgb, a):
+        xi, yi = int(round(x)), int(round(y))
+        if px <= xi < px + cell and 0 <= yi < TH:   # clip inside this decal's cell
+            tears[yi, xi, 0:3] = rgb
+            tears[yi, xi, 3] = a
+
+    # Four escalating rips. Each is a LENS, not a slit: fabric under tension
+    # parts widest in the middle and tapers to a point at both ends. A
+    # constant-width gap reads as a drawn line, which is what the first pass did.
+    for c in range(4):
+        r = rng_for(f"sail_tear_{c}")
+        px = c * cell
+        length = cell * (0.48 + 0.09 * c)
+        max_gap = cell * (0.055 + 0.042 * c)     # the 4th gapes ~4x the 1st
+        x0 = px + (cell - length) / 2
+        steps = int(length)
+        yy = cell * 0.5
+        lips = []
+        for s in range(steps):
+            t = s / max(1, steps - 1)
+            yy = max(cell * 0.3, min(cell * 0.7, yy + r.uniform(-1.1, 1.1)))
+            half = max_gap * (math.sin(math.pi * t) ** 0.7)
+            jag = r.uniform(-0.08, 0.08) * max_gap          # ragged, not spiky
+            top, bot = yy - half + jag, yy + half + jag
+            for y in np.arange(top, bot, 0.5):
+                stamp(px, x0 + s, y, (0.10, 0.09, 0.08), 1.0)   # the gap
+            if half > 1.5:
+                lips.append((x0 + s, top, +1, half))   # +1 = toward the gap
+                lips.append((x0 + s, bot, -1, half))
+        # Threads pulling off both lips and bridging the gap. These are the tell:
+        # without them a lens of dark pixels is a hole, not a tear. Length scales
+        # with the LOCAL gap so some strands span it completely.
+        for _ in range(int(55 + c * 30)):
+            x, y, into, half = lips[r.randrange(len(lips))]
+            span = half * r.uniform(0.5, 1.9)
+            for s in np.arange(0.0, span, 0.5):
+                stamp(px, x + r.uniform(-0.6, 0.6), y + into * (s + 1.0),
+                      (0.82, 0.76, 0.62), 1.0)
+    p2, kb2 = save_png(tears, "sail_tears")
+    print(f"  sail_tears.png             {TW}x{TH}, 4 decals, alpha, {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."""
@@ -997,16 +1282,8 @@ def build_grass_atlas():
                 blade(px, py, base_x, py + 2, h, lean,
                       cell * rng.uniform(0.012, 0.022), rgb)
 
-    os.makedirs(TEXTURES_DIR, exist_ok=True)
-    out = os.path.join(TEXTURES_DIR, "grass_atlas.png")
-    bimg = bpy.data.images.new("grass_atlas", SIZE, SIZE, alpha=True)
-    bimg.pixels.foreach_set(img.reshape(-1))
-    bimg.filepath_raw = out
-    bimg.file_format = 'PNG'
-    bimg.save()
-    bpy.data.images.remove(bimg)
-    kb = os.path.getsize(out) // 1024
-    print(f"  grass_atlas.png            {SIZE}x{SIZE}, {CELLS*CELLS} tufts, {kb} KB")
+    out, kb = save_png(img, "grass_atlas")
+    print(f"  grass_atlas.png            {SIZE}x{SIZE}, {CELLS * CELLS} tufts, {kb} KB")
     return out
 
 
@@ -1020,11 +1297,11 @@ ASSETS = [
          nodes=["ref_capsule_mesh", "head_height"]),
     dict(name="tree_gum_01", fn=build_tree_gum_01,
          dims=((3.0, 7.5), (3.0, 7.5), (7.5, 9.5)),
-         nodes=["trunk", "canopy_01", "canopy_02", "canopy_03",
+         nodes=["trunk", "canopy", "canopy_01", "canopy_02", "canopy_03",
                 "branch_anchor_01", "branch_anchor_02", "branch_anchor_03"]),
     dict(name="tree_gum_02", fn=build_tree_gum_02,
          dims=((2.0, 5.5), (2.0, 5.5), (5.0, 6.5)),
-         nodes=["trunk", "canopy_01", "canopy_02",
+         nodes=["trunk", "canopy", "canopy_01", "canopy_02",
                 "branch_anchor_01", "branch_anchor_02"]),
     dict(name="fence_post", fn=build_fence_post,
          dims=((0.10, 0.16), (0.10, 0.16), (1.95, 2.10)),
@@ -1064,10 +1341,19 @@ ASSETS = [
     dict(name="turnbuckle", fn=build_turnbuckle,
          dims=((0.015, 0.05), (0.015, 0.05), (0.12, 0.20)),
          nodes=["body", "eye_a", "eye_b"]),
-    # Lands in models/debris/ — Lane C spawns debris from that directory.
+    # These land in models/debris/ — Lane C globs that directory to spawn from.
     dict(name="tramp_01", fn=build_tramp_01, dir=DEBRIS_DIR,
          dims=((2.8, 3.1), (2.8, 3.1), (0.70, 0.85)),
          nodes=["mat", "rim", "pad", "legs"]),
+    dict(name="wheelie_bin_01", fn=build_wheelie_bin_01, dir=DEBRIS_DIR,
+         dims=((0.50, 0.70), (0.65, 0.85), (1.00, 1.20)),
+         nodes=["bin_body", "lid", "lid_plate", "wheels"]),
+    dict(name="washing_line_01", fn=build_washing_line_01,
+         dims=((2.7, 3.1), (2.7, 3.1), (2.0, 2.4)),
+         nodes=["mast", "head", "arms"]),
+    dict(name="garden_gnome_01", fn=build_garden_gnome_01,
+         dims=((0.10, 0.20), (0.10, 0.20), (0.33, 0.42)),
+         nodes=["gnome"]),
 ]
 
 
@@ -1340,7 +1626,12 @@ def make_contact_sheet(thumbs):
     cols = 4
     rows = (len(tiles) + cols - 1) // cols
     th, tw = tiles[0].shape[0], tiles[0].shape[1]
-    sheet = np.zeros((rows * th, cols * tw, 4), dtype=np.float32)
+    # Prefill with the render background, sampled from a tile's corner rather
+    # than guessed — the PNG is sRGB-encoded and the scene colour is linear, so
+    # reusing the world constant here would not match. Otherwise the unused
+    # slots in a partly-filled last row read as black holes.
+    sheet = np.empty((rows * th, cols * tw, 4), dtype=np.float32)
+    sheet[:, :] = tiles[0][0, 0]
     sheet[:, :, 3] = 1.0
     for i, tile in enumerate(tiles):
         r, c = i // cols, i % cols
@@ -1382,6 +1673,7 @@ def main():
     build_all(only)
     reset_to_empty()
     build_grass_atlas()
+    build_sail_textures()
     debris = [] if no_debris else copy_debris()
 
     failures = []

web/world/data/storms/storm_01_gentle.json

@@ -14,7 +14,7 @@
     "powBase": 2,
     "powRand": 3,
     "powRamp": 2,
-    "downdraft": 0.18
+    "downdraftOfTotal": 0.25
   },
 
   "dirCurve": [[0, 0.9], [45, 1.0], [90, 1.15]],

web/world/data/storms/storm_02_wildnight.json

@@ -11,7 +11,7 @@
 
   "baseCurve": [[0, 7.0], [15, 11.0], [40, 17.0], [60, 20.0], [78, 19.0], [90, 16.0]],
 
-  "_gusts_comment": "downdraft = fraction of gust power that blows DOWN, per gust (each gust varies 0.6-1.4x this). A gust front is descending air, not just faster air; without it a flat horizontal sail sheds everything and ignoring the storm is the winning move. 0.3 here because a wild night should punish a flat rig hard.",
+  "_gusts_comment": "downdraftOfTotal = fraction of TOTAL wind speed that blows DOWN (SPRINT3 decision 8), present whenever it's windy, not only in gusts. TARGET is 0.45 — measured to clear B's 60% flat-horizontal:flat-pitched bar (69% of-max / 60% worst-heading) AND let a properly-sized twisted rated rig survive with ~21% margin, which gust-only semantics provably could NOT do together (0.58 gave 48% and still broke the twisted rig). HELD at 0.12 for now: on the current oversized yard the ONLY twisted quad ('h1,t2,p1,t1', ~190 m²) starts losing a corner around 0.15 in the exact solver, so 0.45 would turn B's §7 assert red. 0.12 fraction-of-total ~= the old gust-only 0.3 in peak downdraft (-4.2 vs -4.5 m/s), so storm_02 barely changes, and leaves ~23% load margin on that twisted rig. Bump to 0.45 is a ONE-NUMBER joint step once A lands decision-2 anchors (18-45 m2 quads) and B re-points §7. See THREADS [C] 2026-07-17.",
 
   "gusts": {
     "firstAt": 3,
@@ -20,7 +20,7 @@
     "powBase": 3,
     "powRand": 5,
     "powRamp": 7,
-    "downdraft": 0.3
+    "downdraftOfTotal": 0.12
   },
 
   "dirCurve": [[0, 0.85], [50, 0.95], [55, 0.6], [59, -1.25], [70, -1.45], [90, -1.35]],

web/world/data/storms/storm_03_southerly.json

@@ -0,0 +1,38 @@
+{
+  "name": "Southerly Buster",
+  "blurb": "Hot still afternoon, then a southerly change rolls through around the half-hour. Gusty but not vicious — a fair test of a first real rig.",
+  "rating": 2,
+  "seed": 30717,
+  "duration": 90,
+
+  "_ramp_comment": "The campaign's middle rung: sits between storm_01_gentle (peak ~11 m/s) and storm_02_wildnight (peak ~32). Sustained builds to ~13 (47 km/h), worst gust ~21 (76 km/h, BOM 'strong'). The change is real but slower and smaller than the wild night's, so a decent flat-ish rig can get away with it and a good twisted one is never in doubt — the storm that teaches the swing before the one that punishes it.",
+
+  "baseCurve": [[0, 4.0], [12, 6.0], [30, 9.0], [45, 13.0], [65, 12.5], [90, 10.0]],
+
+  "gusts": {
+    "firstAt": 5,
+    "minGap": 6,
+    "maxGap": 12,
+    "powBase": 3,
+    "powRand": 4,
+    "powRamp": 4,
+    "downdraftOfTotal": 0.35
+  },
+
+  "_dir_comment": "Starts blowing toward the SE (a warm NW'er), swings to blow toward the NNE (a moderate southerly) across 30-36 s. ~90 deg, gentler slew than storm_02's buster.",
+
+  "dirCurve": [[0, 0.8], [28, 0.9], [30, 0.55], [36, -0.7], [55, -0.85], [90, -0.75]],
+  "dirWander": { "amp": 0.3, "rate": 0.11 },
+
+  "spatial": { "amp": 0.18, "scale": 11, "advect": 0.5 },
+
+  "events": [
+    { "t": 30, "type": "windchange", "telegraph": 6, "over": 6, "text": "here comes the change" },
+    { "t": 48, "type": "debris", "model": "BlackTub_v2", "lateral": 2.5, "mass": 5, "text": "a tub skitters across the lawn" },
+    { "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]] },
+
+  "sky": { "darkness": 0.5, "cloudScroll": 0.05 }
+}

web/world/dev_rigging.html

@@ -0,0 +1,160 @@
+<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>SHADES — Lane B rigging harness</title>
+<style>
+  html, body { margin: 0; height: 100%; background: #6f7f8c; overflow: hidden;
+               font: 12px/1.5 ui-monospace, Menlo, monospace; }
+  canvas { display: block; }
+  #dev { position: fixed; bottom: 8px; left: 8px; color: #fff; text-shadow: 0 1px 2px #000;
+         white-space: pre; pointer-events: none; }
+  #hint { position: fixed; bottom: 8px; right: 8px; color: #ffd27a; text-shadow: 0 1px 2px #000;
+          text-align: right; white-space: pre; pointer-events: none; }
+</style>
+<!-- Required: world.js/sail.js pull addons that import the bare 'three' specifier. -->
+<script type="importmap">
+{ "imports": { "three": "./vendor/three.module.js", "three/addons/": "./vendor/addons/" } }
+</script>
+</head>
+<body>
+<canvas id="c"></canvas>
+<div id="dev"></div>
+<div id="hint">Lane B harness — the prep phase only.
+ENTER commits the rig and starts a storm.  R resets to prep.</div>
+
+<script type="module">
+/**
+ * Lane B harness — the prep-phase picking UI against Lane A's real yard.
+ *
+ * Same reason Lane C has weather_demo.html and Lane D has dev_player.html: the
+ * picking UI can't be asserted headless (it is clicks, raycasts and materials),
+ * and it can't be exercised in index.html until Lane A wires it in step 8. This
+ * boots the real world.js, the real anchors and the real cloth so the thing
+ * being verified is the thing that ships. Retire it once index.html hosts prep.
+ */
+import * as THREE from 'three';
+import { createWorld } from './js/world.js';
+import { createCameraRig } from './js/camera.js';
+import { createWind, loadStorm } from './js/weather.js';
+import { SailRig, createSailView } from './js/sail.js';
+import { createRiggingUI } from './js/rigging.js';
+import { FIXED_DT } from './js/contracts.js';
+
+const canvas = document.getElementById('c');
+const renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
+renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
+renderer.shadowMap.enabled = true;
+renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+renderer.toneMapping = THREE.ACESFilmicToneMapping;
+
+const scene = new THREE.Scene();
+
+const [calmDef, wildDef] = await Promise.all([
+  loadStorm('storm_01_gentle'), loadStorm('storm_02_wildnight'),
+]);
+// main.js multiplexes these behind a private router; the harness only ever needs
+// one at a time, so it just swaps the reference when the storm starts.
+const calmWind = createWind(calmDef);
+const wildWind = createWind(wildDef);
+let wind = calmWind;
+const windProxy = {
+  sample: (p, t, out) => wind.sample(p, t, out),
+  gustTelegraph: (t) => wind.gustTelegraph(t),
+  eventsBetween: (a, b) => wind.eventsBetween?.(a, b) ?? [],
+  setSheltersFromTrees: (trees) => { calmWind.setSheltersFromTrees?.(trees); wildWind.setSheltersFromTrees?.(trees); },
+};
+
+const world = createWorld(scene, { wind: windProxy });
+const cameraRig = createCameraRig(canvas);
+cameraRig.setSolids(world.solids);
+cameraRig.setGround(world.heightAt);
+windProxy.setSheltersFromTrees(world.anchors.filter((a) => a.type === 'tree'));
+
+const rig = new SailRig({ anchors: world.anchors });
+let sailView = null;
+
+async function rigSail(anchorIds, hwChoices, tension) {
+  rig.attach(anchorIds, hwChoices, tension);
+  if (sailView) {
+    scene.remove(sailView);
+    sailView.traverse((o) => { o.geometry?.dispose(); o.material?.dispose(); });
+  }
+  sailView = await createSailView(rig);
+  scene.add(sailView);
+}
+
+let msg = '';
+let msgT = 0;
+const ui = await createRiggingUI({
+  scene, camera: cameraRig.object, domElement: canvas, world,
+  onCommit: (ids, hw, tension) => { rigSail(ids, hw, tension); wind = wildWind; t = 0; phase = 'storm'; },
+  onMessage: (m) => { msg = m; msgT = 2; },
+});
+
+let phase = 'prep';
+ui.setActive(true);
+
+// harness-only handle, so a debugger (or an agent driving this page) can pick
+// anchors without hunting for pixels. Never imported by the game.
+window.__laneB = {
+  ui, rig, world, cameraRig, scene,
+  get phase() { return phase; },
+  /** rig by id, exactly as if you'd clicked it */
+  pick: (id) => ui.session.rig(id),
+  cycle: (id) => ui.session.cycleHardware(id),
+};
+
+addEventListener('keydown', (e) => {
+  if (e.key === 'Enter' && phase === 'prep') { if (ui.commit()) ui.setActive(false); }
+  if (e.key.toLowerCase() === 'r') {
+    phase = 'prep';
+    wind = calmWind;
+    ui.setActive(true);
+    if (sailView) { scene.remove(sailView); sailView = null; }
+  }
+});
+
+// follow-cam target: the yard centre, so prep reads as a site walk-around
+const focus = new THREE.Vector3(0, 1.2, 0);
+const dev = document.getElementById('dev');
+const clock = new THREE.Clock();
+let t = 0, acc = 0;
+
+renderer.setAnimationLoop(() => {
+  const raw = Math.min(0.25, clock.getDelta());
+  acc += raw;
+  while (acc >= FIXED_DT) {
+    t += FIXED_DT;
+    world.update(FIXED_DT, t);
+    if (phase === 'storm') rig.step(FIXED_DT, windProxy, t);
+    acc -= FIXED_DT;
+    if (msgT > 0) msgT -= FIXED_DT;
+  }
+  ui.update(raw, t);
+  sailView?.update();
+  cameraRig.update(raw, focus);
+
+  const s = ui.summary;
+  const loads = rig.rigged
+    ? rig.corners.map((c) => `${c.anchorId}:${c.broken ? 'BLOWN' : (c.load / 1000).toFixed(1) + 'kN'}`).join('  ')
+    : '(not rigged)';
+  dev.textContent =
+    `${phase.toUpperCase()}   t ${t.toFixed(1)}s   wind ${windProxy.sample(focus, t).length().toFixed(1)} m/s\n` +
+    `budget $${s.budget}  corners ${s.corners.length}/4  area ${s.area ? s.area.toFixed(0) + ' m2' : '—'}\n` +
+    `${loads}` + (msgT > 0 ? `\n!! ${msg}` : '');
+
+  renderer.render(scene, cameraRig.object);
+});
+
+addEventListener('resize', () => {
+  renderer.setSize(innerWidth, innerHeight);
+  cameraRig.object.aspect = innerWidth / innerHeight;
+  cameraRig.object.updateProjectionMatrix();
+});
+renderer.setSize(innerWidth, innerHeight);
+cameraRig.object.aspect = innerWidth / innerHeight;
+cameraRig.object.updateProjectionMatrix();
+</script>
+</body>
+</html>

web/world/js/contracts.js

@@ -177,9 +177,20 @@ export class Emitter {
  *   angle around their centroid. tension scales spring rest lengths, 0.6–1.4
  *   (low = loose and floggy, high = drum tight and shock-loaded).
  * @property {(dt:number, wind:Wind, t:number) => void} step  Fixed dt. Deterministic.
- * @property {(rect: {x:number,z:number,w:number,d:number}) => number} coverageOver
- *   Ground-projected shade over a rect, 0..1.
+ * @property {(rect: {x:number,z:number,w:number,d:number}, sunDir?: THREE.Vector3, heightAt?: (x:number,z:number)=>number) => number} coverageOver
+ *   Ground-projected shade over a rect, 0..1. Pass world.sunDir and
+ *   world.heightAt so the rays start at the real ground and point at the real
+ *   sun; the defaults (overhead sun, flat y=0) are only for tests.
  * @property {Emitter} events               Emits 'break' and 'repair' as {type, corner}.
+ * @property {(i: number) => void} repair
+ *   Re-rig corner i with the carried spare (shackle grade — the only kind prep
+ *   sells). No-op if the corner isn't broken. Lane D's 2.5 s hold-E.
+ * @property {(i: number, delta: number) => void} trim
+ *   Per-corner turnbuckle; delta is ±, clamped to 0.85–1.15. Lane D's 1.2 s hold.
+ * @property {(i: number) => (THREE.Vector3|null)} cornerPos
+ *   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.
  */
 
 /**
@@ -295,7 +306,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' },
+  sailRig:  { corners: 'object', attach: 'function', step: 'function', coverageOver: 'function', events: 'object', repair: 'function', trim: 'function', cornerPos: 'function' },
   player:   { pos: 'object', carrying: '*', busy: '*', update: 'function' },
   interact: { register: 'function' },
   camera:   { object: 'object', yaw: 'number', update: 'function' },

web/world/js/interact.js

@@ -30,12 +30,14 @@ export class Interact {
    * @param {string|function} [spec.label]  string, or (player)->string for live text
    * @param {function} [spec.canUse]   (player) -> bool
    * @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.
    * @returns {function} unregister
    */
   register(spec) {
     if (!spec || !spec.id) throw new Error('interact.register: id required');
     const target = {
-      radius: 1.6, holdSecs: 1, label: '', canUse: null, onDone: null, ...spec,
+      radius: 1.6, holdSecs: 1, label: '', canUse: null, onDone: null, clip: null, ...spec,
     };
     this.targets.set(target.id, target);
     return () => this.unregister(target.id);
@@ -70,6 +72,7 @@ export class Interact {
     if (!this.active) return;
     // only hand the player back if they're still ours — a knockdown mid-hold already re-stated them
     if (player.state === 'busy') player.setState('idle', t);
+    player.busyClip = null;
     this.events.push({ type: 'cancel', id: this.active.id, t });
     this.active = null;
     this.progress = 0;
@@ -99,6 +102,7 @@ export class Interact {
     if (!this.active && holding && !this.latched && near && !player.busy) {
       this.active = near;
       this.progress = 0;
+      player.busyClip = near.clip || null;   // the verb: Crank at a turnbuckle, PickUp at the table
       player.setState('busy', t);
     }
 
@@ -110,6 +114,7 @@ export class Interact {
         this.progress = 0;
         this.latched = true;
         player.setState('idle', t);      // release busy FIRST — onDone may pickUp(), which refuses while busy
+        player.busyClip = null;          // ...and after it, so the carry clips win on the next frame
         if (done.onDone) done.onDone(player, t);
         this.events.push({ type: 'done', id: done.id, t });
       }
@@ -129,38 +134,54 @@ export class Interact {
  * Register the standard yard actions (PLAN3D §5-D.4). Duck-typed against the contracts so Lane D
  * never edits Lane B's or Lane A's files — anything not yet landed is simply skipped.
  *
+ * Every closure reads `sailRig.corners[i]` LIVE rather than capturing the corner object. Lane A's
+ * THREADS note: `attach()` REPLACES the corners array, so a captured corner is a stale object the
+ * sim no longer steps — the prompt would gate forever on a `broken` flag that can never change
+ * again. Reading by index means a re-rig can't strand these targets whether or not we get re-wired.
+ *
  * @param {Interact} interact
- * @param {object} deps  {sailRig, world, spares}
- *   sailRig.corners   -> [{anchorId, hw, load, broken}]     (contracts.js, Lane B)
- *   sailRig.repair(i) -> void   [PROPOSED — see THREADS.md]
- *   sailRig.trim(i,d) -> void   [PROPOSED — per-corner turnbuckle, see THREADS.md]
- *   world.shedTable   -> {pos}                              (Lane A/E)
+ * @param {object} deps  {sailRig, world}
+ *   sailRig.corners      -> [{anchorId, hw, load, broken}]   (contracts.js, Lane B)
+ *   sailRig.repair(i)    -> void        (decision 4)
+ *   sailRig.trim(i,d)    -> void        (decision 4)
+ *   sailRig.cornerPos(i) -> Vector3     (decision 4 — live world position; a flogging corner moves)
+ *   world.shedTable      -> {pos}       (Lane A — until it lands, the pickup self-skips)
  */
 export function wireYardActions(interact, deps = {}) {
   const { sailRig, world } = deps;
   const wired = [];
+  const cornerAt = (i) => (sailRig && sailRig.corners && sailRig.corners[i]) || 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;
+    return (sailRig.cornerPos && sailRig.cornerPos(i)) || c.pos || null;
+  };
 
   if (sailRig && Array.isArray(sailRig.corners)) {
-    sailRig.corners.forEach((corner, i) => {
+    sailRig.corners.forEach((_corner, i) => {
       // re-rig a broken corner — costs the spare you're carrying
       wired.push(interact.register({
         id: `rerig_${i}`,
-        pos: () => corner.pos || (sailRig.cornerPos && sailRig.cornerPos(i)),
+        pos: posAt(i),
         radius: 1.8,
         holdSecs: 2.5,
         label: 're-rig corner',
-        canUse: (p) => corner.broken && p.carrying === 'spare',
-        onDone: (p) => { p.carrying = null; if (sailRig.repair) sailRig.repair(i); },
+        clip: 'Crank',
+        canUse: (p) => !!(cornerAt(i) && cornerAt(i).broken)
+          && p.carrying === 'spare' && !!sailRig.repair,
+        onDone: (p) => { p.carrying = null; sailRig.repair(i); },
       }));
       // per-corner turnbuckle trim — new vs the prototype; makes corners individual
       wired.push(interact.register({
         id: `trim_${i}`,
-        pos: () => corner.pos || (sailRig.cornerPos && sailRig.cornerPos(i)),
+        pos: posAt(i),
         radius: 1.8,
         holdSecs: 1.2,
         label: 'tighten turnbuckle',
-        canUse: () => !corner.broken && !!sailRig.trim,
-        onDone: () => sailRig.trim && sailRig.trim(i, +0.1),
+        clip: 'Crank',
+        canUse: () => !!cornerAt(i) && !cornerAt(i).broken && !!sailRig.trim,
+        onDone: () => sailRig.trim(i, +0.1),
       }));
     });
   }
@@ -172,6 +193,7 @@ export function wireYardActions(interact, deps = {}) {
       radius: 1.5,
       holdSecs: 0.6,
       label: (p) => (p.carrying ? 'hands full' : 'take a spare'),
+      clip: 'PickUp',
       canUse: (p) => !p.carrying,           // hands-full rule
       onDone: (p, t) => p.pickUp('spare', t),
     }));

web/world/js/main.js

@@ -189,6 +189,10 @@ export async function boot(opts = {}) {
 
   // --- world & camera -----------------------------------------------------
   const world = createWorld(scene, { wind });
+  // Lane E's GLBs land over the graybox. Awaited here because it resolves
+  // world.shedTable onto E's baked pickup_anchor, and wireYardActions (below,
+  // inside rigSail) reads that position when it registers the spare pickup.
+  await world.dress();
   const cameraRig = createCameraRig(canvas);
   cameraRig.setSolids(world.solids);
   cameraRig.setGround(world.heightAt);
@@ -346,7 +350,7 @@ export async function boot(opts = {}) {
     windT = windTime();
     world.update(dt, windT);
     player.update(dt, windT);
-    rig.step(dt, wind, windT);
+    rig.step(dt, wind, windT, debris);
     debris.step(dt, windT, { player: player.sim, sail: rig });
     sky?.step(dt, windT, { sail: rig });
   }

web/world/js/player.js

@@ -15,9 +15,9 @@
 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 } from './player.sim.js';
+import { PlayerSim, STATES, TUNE, clipFor } from './player.sim.js';
 
-export { PlayerSim, STATES, TUNE };
+export { PlayerSim, STATES, TUNE, clipFor };
 
 export const CHAR_URL = './models/player_01.glb';
 export const ANIM_URL = './models/player_anims.glb';
@@ -56,6 +56,69 @@ const _loadGLTF = (loader, url) => new Promise((res, rej) =>
 
 const UP = new THREE.Vector3(0, 1, 0);
 
+const _clamp = (v, lo, hi) => (v < lo ? lo : v > hi ? hi : v);
+
+/**
+ * Build the player's collision test out of `world.solids` (contracts World).
+ *
+ * Shape of the problem, measured in the real yard rather than assumed:
+ *   · `fence` is a GROUP of 37 child meshes whose combined box is the whole 30×20 m yard — so one
+ *     box per entry in solids is useless. We flatten to leaf meshes and box each one.
+ *   · the house ROOF is a solid spanning y 2.99–3.21, i.e. entirely above a 1.72 m head. A flat
+ *     footprint test would wall off the eaves, so every box is filtered by vertical overlap with
+ *     the body and the roof simply drops out.
+ * Solids are static, so the boxes are computed once. ~44 leaves, distance-pruned — no raycast per
+ * frame. (Lane A's note: the ground is deliberately NOT in solids; heightAt covers it.)
+ *
+ * @param {object} world  contracts World
+ * @param {object} [opts] {radius} metres, the player's shoulder radius
+ * @returns {(x:number,z:number,feetY:number,headY:number)=>{x:number,z:number}}
+ */
+export function makeSolidCollider(world, opts = {}) {
+  const radius = opts.radius ?? 0.3;
+  const boxes = [];
+  const b = new THREE.Box3();
+  for (const root of (world && world.solids) || []) {
+    root.updateWorldMatrix(true, true);
+    root.traverse((o) => {
+      if (!o.isMesh) return;
+      b.setFromObject(o);
+      if (!isFinite(b.min.x)) return;
+      boxes.push({ x0: b.min.x, x1: b.max.x, z0: b.min.z, z1: b.max.z, y0: b.min.y, y1: b.max.y });
+    });
+  }
+  const out = { x: 0, z: 0 };   // scratch — copied by the caller immediately, never retained
+  const r2 = radius * radius;
+
+  return function collide(x, z, feetY, headY) {
+    out.x = x; out.z = z;
+    for (let i = 0; i < boxes.length; i++) {
+      const bx = boxes[i];
+      if (bx.y1 <= feetY + 0.05 || bx.y0 >= headY) continue;        // under the eaves / over a low wall
+      // closest point on the box to the body centre, in XZ
+      const cx = _clamp(out.x, bx.x0, bx.x1), cz = _clamp(out.z, bx.z0, bx.z1);
+      const dx = out.x - cx, dz = out.z - cz;
+      const d2 = dx * dx + dz * dz;
+      if (d2 >= r2) continue;                                        // clear
+      if (d2 > 1e-10) {                                              // outside: push along the normal
+        const d = Math.sqrt(d2);
+        out.x = cx + (dx / d) * radius;
+        out.z = cz + (dz / d) * radius;
+      } else {
+        // centre is inside the box (spawned in a wall, or shoved through): eject through the nearest
+        // face rather than picking an arbitrary axis, so you pop out the side you came in.
+        const l = out.x - bx.x0, rr = bx.x1 - out.x, u = out.z - bx.z0, dn = bx.z1 - out.z;
+        const m = Math.min(l, rr, u, dn);
+        if (m === l) out.x = bx.x0 - radius;
+        else if (m === rr) out.x = bx.x1 + radius;
+        else if (m === u) out.z = bx.z0 - radius;
+        else out.z = bx.z1 + radius;
+      }
+    }
+    return out;
+  };
+}
+
 export class PlayerView {
   /**
    * @param {object} rig    {scene, anims} — the character
@@ -127,7 +190,8 @@ export class PlayerView {
   /** Push one sim frame onto the rig. dt drives the mixer only — the sim already stepped. */
   sync(sim, dt) {
     const st = STATES[sim.state];
-    this.play(st.clip, st.loop !== false);
+    // 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);
 
@@ -202,9 +266,13 @@ export async function loadPlayer(scene, opts = {}) {
  * @returns {Promise<object>} satisfies checkContract('player', …)
  */
 export async function createPlayer(scene, world, cameraRig, opts = {}) {
+  const height = opts.height || 1.72;
   const p = await loadPlayer(scene, {
     ...opts,
+    height,
     groundAt: world && world.heightAt ? (x, z) => world.heightAt(x, z) : undefined,
+    // built AFTER the world exists so the boxes capture E's real GLBs, not the graybox
+    collide: opts.collide !== undefined ? opts.collide : makeSolidCollider(world, opts),
     start: opts.start || { x: 0, y: 0, z: 6 },
   });
   const keyboard = new KeyboardInput();
@@ -257,7 +325,11 @@ export class KeyboardInput {
     const k = this.keys;
     const x = (k.has('KeyD') || k.has('ArrowRight') ? 1 : 0) - (k.has('KeyA') || k.has('ArrowLeft') ? 1 : 0);
     const z = (k.has('KeyW') || k.has('ArrowUp') ? 1 : 0) - (k.has('KeyS') || k.has('ArrowDown') ? 1 : 0);
-    return { x, z, run: k.has('ShiftLeft') || k.has('ShiftRight'), camYaw };
+    return {
+      x, z, camYaw,
+      run: k.has('ShiftLeft') || k.has('ShiftRight'),
+      shelter: k.has('KeyC'),          // hold to brace — see STATES.shelter
+    };
   }
 
   dispose() {

web/world/js/player.sim.js

@@ -11,23 +11,39 @@
 
 /**
  * The state machine, as a table (PLAN3D §5-D.5 asks for a table test).
- *  clip   — clip name in player_anims.glb
- *  locked — movement input is ignored, and `player.busy` is true
- *  secs   — timed states auto-advance to `next` after this long
+ *  clip      — clip name in player_anims.glb
+ *  carryClip — clip to use instead when the player has something in their hands
+ *  locked    — movement input is ignored, and `player.busy` is true
+ *  secs      — timed states auto-advance to `next` after this long
  * Invariant the selftest enforces: every locked state either has a `next` (so it drains on its own)
- * or is released by an external actor. `busy` is the only externally-released state — interact.js
- * both enters and leaves it, so a dropped release can't strand the player.
+ * or names an external releaser. `busy` and `shelter` are the released ones — interact.js and the
+ * shelter key each both ENTER and LEAVE their own state, so a dropped release can't strand you.
  */
 export const STATES = {
-  idle:    { clip: 'Idle',          locked: false, loop: true },
-  walk:    { clip: 'Walk',          locked: false, loop: true },
-  run:     { clip: 'Run',           locked: false, loop: true },
+  idle:    { clip: 'Idle',          carryClip: 'CarryIdle', locked: false, loop: true },
+  walk:    { clip: 'Walk',          carryClip: 'Carry',     locked: false, loop: true },
+  run:     { clip: 'Run',           carryClip: 'Carry',     locked: false, loop: true },
   busy:    { clip: 'Idle',          locked: true,  loop: true, releasedBy: 'interact' },
+  shelter: { clip: 'TakeCover',     locked: true,  loop: true, releasedBy: 'input' },
+  stumble: { clip: 'StumbleBack',   locked: true,  loop: false, secs: 0.8, next: 'idle' },
   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' },
 };
 
+/**
+ * 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) —
+ * interact.js writes that into `sim.busyClip`. Everything else is the table's `clip`.
+ * Kept here rather than in player.js so the selftest can assert it without a renderer.
+ */
+export function clipFor(sim) {
+  const st = STATES[sim.state];
+  if (sim.state === 'busy' && sim.busyClip) return sim.busyClip;
+  if (sim.carrying && st.carryClip) return st.carryClip;
+  return st.clip;
+}
+
 /**
  * Tuning. Ported from the 2D prototype's shape (prototype/game.js:250-252), retuned to metres and
  * m/s per PLAN3D §1 ("port the behaviour, retune the constants").
@@ -61,6 +77,16 @@ export const TUNE = {
   knockSustain: 0.5,    // s above knockWind before it happens
   knockBleed: 2,        // exposure drains this many × faster than it fills
   pitchSecs: 0.35,      // s for the body to swing down / back up (view reads sim.pitch)
+
+  // A gust that can't floor you can still break your stride. Sits BELOW knockWind on purpose, so a
+  // storm reads as: shoved → stumbling → floored, rather than fine-fine-fine-flat-on-your-back.
+  stumbleGust: 17,      // m/s over baseline → you lose your footing (but not your feet)
+  stumbleCooldown: 3,   // s — punctuation, not a stutter: one gust hold must not stumble you twice
+
+  // Shelter (hold C): brace and the wind stops owning you. This is the storm's real answer to "the
+  // 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
 };
 
 const clamp = (v, lo, hi) => (v < lo ? lo : v > hi ? hi : v);
@@ -78,6 +104,10 @@ export class PlayerSim {
    * @param {object}   [opts]
    * @param {object}   [opts.start]     {x,y,z} spawn, metres
    * @param {function} [opts.groundAt]  (x,z) -> y. Lane A's world.js provides the real one.
+   * @param {function} [opts.collide]   (x,z,feetY,headY) -> {x,z} pushed clear of world.solids.
+   *   Injected, not imported, for the same reason as groundAt: this file must stay renderer-free.
+   *   player.js#makeSolidCollider builds the real one out of world.solids.
+   * @param {number}   [opts.height]    body height, metres — the collider's vertical span
    * @param {object}   [opts.tune]      overrides for TUNE
    */
   constructor(opts = {}) {
@@ -90,6 +120,8 @@ export class PlayerSim {
     this.state = 'idle';
     this.stateT = 0;
     this.carrying = null;               // contract: player.carrying — one item, hands-full rule
+    this.busyClip = null;               // interact.js names the verb for the current hold (Crank, PickUp…)
+    this.stumbleCool = 0;               // s until a gust may stumble you again
     this.events = [];                   // {type:'state'|'drop'|'knockdown', …} drained by the view/HUD
 
     this.exposure = 0;                  // s spent above knockWind
@@ -100,6 +132,8 @@ export class PlayerSim {
     this.knockDir = { x: 0, z: 1 };     // which way the body went down
 
     this.groundAt = opts.groundAt || (() => 0);
+    this.collide = opts.collide || null;
+    this.bodyHeight = opts.height || 1.72;
     this.tune = { ...TUNE, ...(opts.tune || {}) };
   }
 
@@ -168,6 +202,7 @@ export class PlayerSim {
   step(dt, t, input = {}, wind = null) {
     const T = this.tune;
     this.stateT += dt;
+    this.stumbleCool = Math.max(0, this.stumbleCool - dt);
 
     // --- local wind, and how much of it is gust ---
     let wx = 0, wz = 0;
@@ -180,11 +215,29 @@ export class PlayerSim {
     this.windBase += (ws - this.windBase) * clamp(dt * T.baseTrack, 0, 1);
     this.gust = Math.max(0, ws - this.windBase);
 
-    // --- sustained extreme wind puts you down (same rule as a sail corner letting go) ---
-    if (ws > T.knockWind) this.exposure += dt;
+    // --- 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. ---
+    const wantShelter = !!input.shelter;
+    const canShelter = this.state === 'idle' || this.state === 'walk' || this.state === 'run';
+    if (wantShelter && canShelter) this.setState('shelter', t);
+    else if (!wantShelter && this.state === 'shelter') this.setState('idle', t);
+    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;
+    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);
 
+    // --- 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')) {
+      this.stumbleCool = T.stumbleCooldown;
+      this.setState('stumble', t);
+      this.vel.x = this.vel.z = 0;
+    }
+
     const st = STATES[this.state];
 
     // --- movement ---
@@ -215,7 +268,7 @@ export class PlayerSim {
     // --- gust shove: pressure ∝ speed², gust only, never while you're already on the ground ---
     const grounded = this.state === 'knocked' || this.state === 'getup';
     if (!grounded && this.gust > T.shoveGustMin && ws > 1e-3) {
-      const a = T.shoveK * ws * ws;
+      const a = T.shoveK * ws * ws * (braced ? T.shelterShoveMult : 1);
       this.shove.x += (wx / ws) * a * dt;
       this.shove.z += (wz / ws) * a * dt;
     }
@@ -226,6 +279,15 @@ export class PlayerSim {
     this.pos.z += (this.vel.z + this.shove.z) * dt;
     this.pos.y = this.groundAt(this.pos.x, this.pos.z);
 
+    // Solids: push back out of anything we ended up inside. Pushout is perpendicular to the surface,
+    // so walking into a wall at an angle keeps its tangential component and slides along it for free
+    // — no separate slide pass. Velocity is deliberately NOT zeroed: the wind should still be able to
+    // hold you against a fence, and the pushout wins over it every frame anyway.
+    if (this.collide) {
+      const r = this.collide(this.pos.x, this.pos.z, this.pos.y, this.pos.y + this.bodyHeight);
+      if (r) { this.pos.x = r.x; this.pos.z = r.z; }
+    }
+
     // --- body pitch: the sim owns it so a knockdown is deterministic and falls DOWNWIND,
     //     which a canned clip can't do. player.js just reads sim.pitch + sim.knockDir. ---
     const wantPitch = this.state === 'knocked' ? 1

web/world/js/rigging.js

@@ -147,11 +147,262 @@ export class RiggingSession {
 /**
  * Prep-phase picking UI.
  *
- * Deliberately unimplemented: it needs Lane A's camera, renderer canvas and
- * anchor markers to raycast against, none of which exist yet. RiggingSession
- * above holds all the rules and is fully tested, so this stays a thin
- * click-to-session adapter once M0 lands. See THREADS.md.
+ * Everything above is the rules; this is only the hands. It renders its own
+ * anchor markers because the yard has none to raycast against — world.js builds
+ * posts and trunks, not pick targets — and marker styling is prep-phase UI, so
+ * it belongs to this lane rather than to the terrain.
+ *
+ * Controls: LMB an anchor to rig it, LMB again to cycle its hardware,
+ * shift-LMB to pull it off for a full refund, [ and ] for tension, S for the
+ * spare. RMB is left alone — that's the camera's orbit. Enter belongs to Lane
+ * A's phase machine, which calls commit() on the way out of prep.
+ *
+ * @param {object}   o
+ * @param {object}   o.scene        THREE.Scene to hang markers in
+ * @param {object}   o.camera       cameraRig.object — what we raycast from
+ * @param {Element}  o.domElement   renderer.domElement — where clicks land
+ * @param {object}   o.world        needs world.anchors
+ * @param {function} o.onCommit     (anchorIds, hwChoices, tension) => void — Lane A's rigSail
+ * @param {function} [o.onMessage]  (text) => void — refusals, for the event ticker
+ * @param {boolean}  [o.panel=true] draw the built-in prep panel; false if hud.js takes it over
  */
-export async function createRiggingUI() {
-  throw new Error('rigging UI lands once Lane A has a camera and anchor markers — see THREADS.md');
+export async function createRiggingUI({
+  scene, camera, domElement, world,
+  onCommit, onMessage = () => {}, panel = true,
+} = {}) {
+  const THREE = await import('../vendor/three.module.js');
+  const session = new RiggingSession({ anchors: world.anchors });
+
+  // --- markers -----------------------------------------------------------
+  const group = new THREE.Group();
+  group.visible = false;
+  scene.add(group);
+
+  const DIM = 0x33424c;
+  const ringGeo = new THREE.TorusGeometry(0.28, 0.05, 8, 20);
+  const dotGeo = new THREE.SphereGeometry(0.1, 10, 8);
+  // What you click is NOT what you see: the ring's tube is 5 cm, which at yard
+  // distance is a couple of pixels and unhittable. Pick against an invisible
+  // sphere big enough to mean "that anchor" and let the ring just be the read.
+  const pickGeo = new THREE.SphereGeometry(0.45, 8, 6);
+  const pickMat = new THREE.MeshBasicMaterial({ visible: false });
+
+  const markers = world.anchors.map((a) => {
+    const mat = new THREE.MeshBasicMaterial({ color: DIM, transparent: true, opacity: 0.9 });
+    const ring = new THREE.Mesh(ringGeo, mat);
+    const dot = new THREE.Mesh(dotGeo, mat);
+    const hit = new THREE.Mesh(pickGeo, pickMat);
+    hit.userData.anchorId = a.id;
+    const holder = new THREE.Group();
+    holder.add(ring, dot, hit, makeLabel(THREE, a.id.toUpperCase()));
+    group.add(holder);
+    return { anchor: a, holder, ring, dot, hit, mat, label: holder.children[3] };
+  });
+  const pickTargets = markers.map((m) => m.hit);
+
+  // --- quad preview ------------------------------------------------------
+  // A closed loop through the ring-ordered picks: this is the shape you are
+  // about to build, drawn before you commit to it.
+  const previewGeo = new THREE.BufferGeometry();
+  previewGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(5 * 3), 3));
+  const preview = new THREE.Line(
+    previewGeo,
+    new THREE.LineDashedMaterial({ color: 0xffd27a, dashSize: 0.35, gapSize: 0.25 }),
+  );
+  preview.frustumCulled = false;
+  group.add(preview);
+
+  // --- panel -------------------------------------------------------------
+  const el = panel ? document.createElement('div') : null;
+  if (el) {
+    el.id = 'rigging-panel';
+    el.style.cssText = `position:fixed;top:12px;left:12px;z-index:20;display:none;
+      background:#0d1418e0;border:1px solid #2c3a44;border-radius:6px;padding:10px 12px;
+      font:12px/1.65 ui-monospace,Menlo,monospace;color:#dde5ea;min-width:280px;
+      white-space:pre;pointer-events:none`;
+    document.body.appendChild(el);
+  }
+
+  let active = false;
+  let hovered = null;
+
+  const ndc = new THREE.Vector2();
+  const ray = new THREE.Raycaster();
+  const scratch = new THREE.Vector3();
+
+  function pickAt(ev) {
+    const r = domElement.getBoundingClientRect();
+    ndc.x = ((ev.clientX - r.left) / r.width) * 2 - 1;
+    ndc.y = -((ev.clientY - r.top) / r.height) * 2 + 1;
+    ray.setFromCamera(ndc, camera);
+    return ray.intersectObjects(pickTargets, false)[0]?.object.userData.anchorId ?? null;
+  }
+
+  function say(result) {
+    if (result && result.ok === false) onMessage(result.reason);
+    return result;
+  }
+
+  function onPointerDown(ev) {
+    if (!active || ev.button !== 0) return; // RMB is the camera's
+    const id = pickAt(ev);
+    if (!id) return;
+    ev.preventDefault();
+    if (!session.isRigged(id)) say(session.rig(id));
+    else if (ev.shiftKey) say(session.unrig(id));
+    else say(session.cycleHardware(id));
+    refresh();
+  }
+
+  function onPointerMove(ev) {
+    if (!active) return;
+    hovered = pickAt(ev);
+    domElement.style.cursor = hovered ? 'pointer' : '';
+  }
+
+  function onKeyDown(ev) {
+    if (!active) return;
+    if (ev.key === '[') session.setTension(session.tension - 0.05);
+    else if (ev.key === ']') session.setTension(session.tension + 0.05);
+    else if (ev.key.toLowerCase() === 's') say(session.setSpares(session.spares ? 0 : 1));
+    else return;
+    ev.preventDefault();
+    refresh();
+  }
+
+  domElement.addEventListener('pointerdown', onPointerDown);
+  domElement.addEventListener('pointermove', onPointerMove);
+  addEventListener('keydown', onKeyDown);
+
+  /** Ground-plane area of the quad as picked, m² — the 70-192 m² problem, visible. */
+  function quadArea() {
+    if (session.picks.length !== MAX_CORNERS) return 0;
+    const p = session.picks.map((k) => world.anchors.find((a) => a.id === k.anchorId).pos);
+    const tri = (a, b, c) =>
+      new THREE.Vector3().subVectors(b, a).cross(new THREE.Vector3().subVectors(c, a)).length() * 0.5;
+    return tri(p[0], p[1], p[2]) + tri(p[0], p[2], p[3]);
+  }
+
+  function refresh() {
+    if (!el) return;
+    const s = session.summary;
+    const rows = world.anchors.map((a) => {
+      const pick = session.pickOf(a.id);
+      if (!pick) return `  ${a.id.padEnd(3)} ${a.type.padEnd(6)} —`;
+      const weak = s.weakest === a.id && session.picks.length > 1 ? '  <- weak link' : '';
+      return `  ${a.id.padEnd(3)} ${pick.hw.name.padEnd(14)} ${(pick.hw.rating / 1000).toFixed(1)} kN  $${pick.hw.cost}${weak}`;
+    });
+    const area = quadArea();
+    el.textContent = [
+      `PREP — rig four corners        $${s.budget} left`,
+      `tension ${s.tension.toFixed(2)}   spare x${s.spares}${area ? `   sail ${area.toFixed(0)} m2` : ''}`,
+      '',
+      ...rows,
+      '',
+      s.canStart ? 'ENTER to start the storm' : `pick ${MAX_CORNERS - session.picks.length} more corner(s)`,
+      'click anchor: rig / cycle hw   shift-click: remove',
+      '[ ] tension    S spare    RMB orbit',
+    ].join('\n');
+  }
+
+  const ui = {
+    session,
+    get summary() { return { ...session.summary, area: quadArea() }; },
+    get canStart() { return session.canStart; },
+    get active() { return active; },
+
+    /** Lane A: call on phaseChange — markers and clicks are prep-only. */
+    setActive(on) {
+      active = !!on;
+      group.visible = active;
+      if (el) el.style.display = active ? 'block' : 'none';
+      if (!active) domElement.style.cursor = '';
+      if (active) refresh();
+      return ui;
+    },
+
+    /** Markers ride the anchors, so a tree corner wanders before you even rig it. */
+    update(dt, t) {
+      if (!active) return;
+      for (const m of markers) {
+        const p = m.anchor.sway ? m.anchor.sway(t) : m.anchor.pos;
+        m.holder.position.set(p.x, p.y, p.z);
+        m.holder.quaternion.copy(camera.quaternion); // rings face the player
+        const pick = session.pickOf(m.anchor.id);
+        m.mat.color.setHex(pick ? pick.hw.color : DIM);
+        const s = (hovered === m.anchor.id ? 1.35 : 1) * (pick ? 1.15 : 1);
+        m.ring.scale.setScalar(s);
+        m.label.visible = !!pick || hovered === m.anchor.id;
+      }
+
+      const pos = previewGeo.attributes.position;
+      if (session.picks.length >= 2) {
+        preview.visible = true;
+        const n = session.picks.length;
+        for (let i = 0; i <= n; i++) {
+          const k = session.picks[i % n];
+          const a = world.anchors.find((x) => x.id === k.anchorId);
+          const p = a.sway ? a.sway(t) : a.pos;
+          scratch.set(p.x, p.y, p.z);
+          pos.setXYZ(i, scratch.x, scratch.y, scratch.z);
+        }
+        // degenerate tail so a partial pick doesn't draw a stale segment
+        for (let i = session.picks.length + 1; i < 5; i++) pos.setXYZ(i, scratch.x, scratch.y, scratch.z);
+        pos.needsUpdate = true;
+        previewGeo.setDrawRange(0, session.picks.length + 1);
+        preview.computeLineDistances();
+      } else {
+        preview.visible = false;
+      }
+    },
+
+    /** Hand the finished rig to Lane A's rigSail. Returns false if it isn't four corners. */
+    commit() {
+      if (!session.canStart) {
+        onMessage(`rig ${MAX_CORNERS - session.picks.length} more corner(s) first`);
+        return false;
+      }
+      onCommit(
+        session.picks.map((p) => p.anchorId),
+        session.picks.map((p) => p.hw),
+        session.tension,
+      );
+      return true;
+    },
+
+    dispose() {
+      domElement.removeEventListener('pointerdown', onPointerDown);
+      domElement.removeEventListener('pointermove', onPointerMove);
+      removeEventListener('keydown', onKeyDown);
+      scene.remove(group);
+      ringGeo.dispose(); dotGeo.dispose(); previewGeo.dispose();
+      preview.material.dispose();
+      for (const m of markers) { m.mat.dispose(); m.label.material.map?.dispose(); m.label.material.dispose(); }
+      el?.remove();
+    },
+  };
+
+  refresh();
+  return ui;
+}
+
+/** A cheap canvas-texture nameplate, so anchors read as h1/t2/p1 rather than dots. */
+function makeLabel(THREE, text) {
+  const c = document.createElement('canvas');
+  c.width = 128; c.height = 64;
+  const g = c.getContext('2d');
+  g.font = 'bold 40px ui-monospace, Menlo, monospace';
+  g.textAlign = 'center';
+  g.textBaseline = 'middle';
+  g.lineWidth = 6;
+  g.strokeStyle = '#0d1418';
+  g.strokeText(text, 64, 32);
+  g.fillStyle = '#dde5ea';
+  g.fillText(text, 64, 32);
+  const sprite = new THREE.Sprite(new THREE.SpriteMaterial({
+    map: new THREE.CanvasTexture(c), depthTest: false, transparent: true,
+  }));
+  sprite.position.set(0, 0.55, 0);
+  sprite.scale.set(0.8, 0.4, 1);
+  return sprite;
 }

web/world/js/sail.js

@@ -18,10 +18,17 @@
  * appears in createSailView(), which is imported lazily.
  */
 
+import * as THREE from '../vendor/three.module.js';
 import { Emitter, FIXED_DT, HARDWARE } from './contracts.js';
 
 export { HARDWARE };
 
+/**
+ * What a carried spare re-rigs a corner with. The prep phase sells exactly one
+ * kind ("spare shackle, $15"), so repair() has no hardware argument to take.
+ */
+const SPARE_HW = HARDWARE[1];
+
 // ---------- sim tunables ----------
 const SIM_DT = FIXED_DT;      // sim always steps at a fixed rate; step() accumulates
 const MAX_SUBSTEPS = 5;       // spiral-of-death guard when the frame hitches
@@ -49,6 +56,10 @@ 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
 
+// ---------- 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 ----------
 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
@@ -114,6 +125,11 @@ export class SailRig {
     this._acc = 0;
     // scratch, reused every face to keep the hot loop allocation-free
     this._probe = { x: 0, y: 0, z: 0 };
+    // Lane C's wind.sample(pos, t, out) takes an out-vector so we don't allocate
+    // one per face per substep — 162 faces at 60 Hz is ~9.7k throwaway Vector3s
+    // a second otherwise. A stub wind that ignores `out` still works: we read
+    // the RETURN value, not this.
+    this._windOut = new THREE.Vector3();
   }
 
   /**
@@ -306,16 +322,20 @@ export class SailRig {
    * so a variable-rate render loop and a fast-forwarded selftest produce
    * identical traces. Never reads a clock.
    *
-   * @param {number} dt    seconds elapsed since last call
-   * @param {object} wind  { sample(pos, t) -> {x,y,z} }
-   * @param {number} t     world time, seconds
+   * @param {number} dt      seconds elapsed since last call
+   * @param {object} wind    { sample(pos, t) -> {x,y,z} }
+   * @param {number} t       world time, seconds
+   * @param {object} [debris] Lane C's debris module, or anything with `.pieces`.
+   *                          Optional — the cloth runs fine without a storm's
+   *                          worth of crates in it.
    */
-  step(dt, wind, t) {
+  step(dt, wind, t, debris = null) {
     if (!this.rigged) return;
+    const pieces = debris ? (debris.pieces ?? debris) : null;
     this._acc += dt;
     let n = 0;
     while (this._acc >= SIM_DT && n < MAX_SUBSTEPS) {
-      this._substep(SIM_DT, wind, this.t);
+      this._substep(SIM_DT, wind, this.t, pieces);
       this._acc -= SIM_DT;
       this.t += SIM_DT;
       n++;
@@ -323,8 +343,9 @@ export class SailRig {
     if (n === MAX_SUBSTEPS) this._acc = 0; // dropped frames: don't try to catch up
   }
 
-  _substep(dt, wind, t) {
+  _substep(dt, wind, t, pieces) {
     this._accumulateWind(wind, t, dt);
+    if (pieces && pieces.length) this._applyDebris(pieces, dt);
     this._integrate(dt);
     this.lambda.fill(0); // XPBD multipliers are per-substep
     for (let i = 0; i < RELAX_ITERS; i++) this._relax(dt * dt);
@@ -357,7 +378,7 @@ export class SailRig {
       probe.x = (pos[ia] + pos[ib] + pos[ic]) / 3;
       probe.y = (pos[ia + 1] + pos[ib + 1] + pos[ic + 1]) / 3;
       probe.z = (pos[ia + 2] + pos[ib + 2] + pos[ic + 2]) / 3;
-      const w = wind.sample(probe, t);
+      const w = wind.sample(probe, t, this._windOut);
 
       // Relative wind, not absolute: as the cloth accelerates downwind the load
       // bleeds off by itself. This is what stops flogging from exploding.
@@ -382,6 +403,88 @@ export class SailRig {
     }
   }
 
+  /**
+   * Sphere-vs-cloth impulses for Lane C's debris (SPRINT2 decision 5, option b).
+   *
+   * The exchange is symmetric: every newton-second the cloth takes out of a
+   * crate, the crate loses. That's the point of the decision — one integrator
+   * does the momentum bookkeeping, so a crate punching through a sail slows
+   * down by exactly as much as it speeds the cloth up. Asserted in
+   * sail.selftest.js.
+   *
+   * Pinned corners are the deliberate exception: they have invMass 0, so a
+   * crate that hits one bounces off and the momentum goes into the house. That
+   * is correct — the anchor is bolted to a wall — and it's why the momentum
+   * assert uses an interior hit.
+   *
+   * @param {Array} pieces  debris.pieces — {x,y,z,vx,vy,vz,r,mass}
+   */
+  _applyDebris(pieces, dt) {
+    const pos = this.pos, prev = this.prev, im = this.invMass;
+    for (const p of pieces) {
+      if (p.alive === false || !Number.isFinite(p.mass) || p.mass <= 0) continue;
+
+      // Swept: main.js steps the sail BEFORE the debris, so these positions are
+      // a frame stale, and a 0.3 m crate at 25 m/s covers 0.42 m in a frame —
+      // enough to pass clean between cloth nodes. Growing the contact radius by
+      // the piece's travel catches both the lag and the tunnelling.
+      const speed = Math.hypot(p.vx, p.vy, p.vz);
+      const solid = p.r + DEBRIS_SKIN;
+      const reach = solid + speed * dt;
+      const reachSq = reach * reach;
+      const wPiece = 1 / p.mass;
+
+      let jx = 0, jy = 0, jz = 0, hits = 0;
+      for (let n = 0; n < im.length; n++) {
+        const i = n * 3;
+        const dx = pos[i] - p.x, dy = pos[i + 1] - p.y, dz = pos[i + 2] - p.z;
+        const dsq = dx * dx + dy * dy + dz * dz;
+        if (dsq > reachSq || dsq < 1e-12) continue;
+        const d = Math.sqrt(dsq);
+        const nx = dx / d, ny = dy / d, nz = dz / d; // piece centre -> node
+
+        // node velocity, read out of verlet
+        const vnx = (pos[i] - prev[i]) / dt;
+        const vny = (pos[i + 1] - prev[i + 1]) / dt;
+        const vnz = (pos[i + 2] - prev[i + 2]) / dt;
+        const vrel = (vnx - p.vx) * nx + (vny - p.vy) * ny + (vnz - p.vz) * nz;
+        if (vrel > 0) continue; // already separating — don't glue them together
+
+        const wNode = im[n];
+        const denom = wNode + wPiece;
+        if (denom < 1e-12) continue;
+        const j = (-(1 + DEBRIS_RESTITUTION) * vrel) / denom;
+        hits++;
+
+        // node takes +j along the contact normal; verlet stores velocity as a
+        // position difference, so the impulse goes in by moving `prev`
+        prev[i] -= nx * j * wNode * dt;
+        prev[i + 1] -= ny * j * wNode * dt;
+        prev[i + 2] -= nz * j * wNode * dt;
+
+        // ...and the piece takes exactly -j. This is the conservation.
+        jx -= nx * j; jy -= ny * j; jz -= nz * j;
+
+        // Depenetrate free nodes by moving pos AND prev together, so pushing
+        // the cloth off the crate doesn't secretly inject velocity.
+        if (wNode > 0 && d < solid) {
+          const push = solid - d;
+          pos[i] += nx * push; prev[i] += nx * push;
+          pos[i + 1] += ny * push; prev[i + 1] += ny * push;
+          pos[i + 2] += nz * push; prev[i + 2] += nz * push;
+        }
+      }
+
+      if (hits) {
+        p.vx += jx * wPiece; p.vy += jy * wPiece; p.vz += jz * wPiece;
+        this.events.emit('debrisHit', {
+          type: 'debrisHit', piece: p, nodes: hits,
+          impulse: Math.hypot(jx, jy, jz), t: this.t,
+        });
+      }
+    }
+  }
+
   _integrate(dt) {
     const pos = this.pos, prev = this.prev, F = this.force, im = this.invMass;
     const dt2 = dt * dt;
@@ -503,8 +606,43 @@ export class SailRig {
     if (this._dirtyRest) { this._applyRestLengths(); this._dirtyRest = false; }
   }
 
+  // --- Lane D's seam (SPRINT2 decision 4) --------------------------------
+  // D landed first and duck-typed these against the rig, so B conforms to D's
+  // spelling rather than the other way round. Thin aliases on purpose: the
+  // behaviour lives in repairCorner/trimCorner, these just match the call sites
+  // in interact.js and are what contracts.js promises.
+
+  /**
+   * Re-rig corner `i` with the spare the player was carrying. The spare is the
+   * "$15 spare shackle" the prep phase sells, so it re-rigs at shackle grade —
+   * which can be an UPGRADE on a corner that blew a carabiner, and a downgrade
+   * on one that blew a rated shackle. That's the prototype's behaviour and it's
+   * a real decision about which corner you run back to.
+   * @param {number} i
+   */
+  repair(i) { this.repairCorner(i, SPARE_HW); }
+
+  /**
+   * Per-corner turnbuckle. @param {number} i @param {number} delta ±, clamped 0.85–1.15.
+   */
+  trim(i, delta) { this.trimCorner(i, delta); }
+
+  /**
+   * Live world position of corner `i`, as a FRESH vector — a blown corner's node
+   * is flying, so Lane D's prompt has to chase it rather than sit on the anchor.
+   * Fresh (not shared scratch) because interact.js holds the result across the
+   * frame and two corners are read back to back.
+   * @param {number} i
+   * @returns {THREE.Vector3|null}
+   */
+  cornerPos(i) {
+    if (!this.rigged || !this.corners[i]) return null;
+    const n = this.cornerIdx[i] * 3;
+    return new THREE.Vector3(this.pos[n], this.pos[n + 1], this.pos[n + 2]);
+  }
+
   /** Re-rig a blown corner with fresh hardware. Lane D's hold-E repair calls this. */
-  repairCorner(index, hw = HARDWARE[1]) {
+  repairCorner(index, hw = SPARE_HW) {
     const c = this.corners[index];
     if (!c || !c.broken) return false;
     c.broken = false;
@@ -539,8 +677,10 @@ export class SailRig {
    * @param {object} rect    world.gardenBed shape: CENTRE (x,z), size (w,d), metres
    * @param {object} sunDir  world.sunDir — unit vector from the ground TOWARD
    *                         the sun. A hit means shaded. Defaults to overhead.
+   * @param {function} heightAt  world.heightAt — rays start at the real ground.
+   *                         Defaults to a flat y=0, which is only right for tests.
    */
-  coverageOver(rect, sunDir = { x: 0, y: 1, z: 0 }) {
+  coverageOver(rect, sunDir = { x: 0, y: 1, z: 0 }, heightAt = null) {
     if (!this.rigged) return 0;
     const len = Math.hypot(sunDir.x, sunDir.y, sunDir.z) || 1;
     const dx = sunDir.x / len, dy = sunDir.y / len, dz = sunDir.z / len;
@@ -553,7 +693,8 @@ export class SailRig {
         // rect is centre-and-size, so samples straddle (rect.x, rect.z)
         const ox = rect.x + ((i + 0.5) / COLS - 0.5) * rect.w;
         const oz = rect.z + ((j + 0.5) / ROWS - 0.5) * rect.d;
-        if (this._rayHitsSail(ox, 0, oz, dx, dy, dz)) hit++;
+        const oy = heightAt ? heightAt(ox, oz) : 0;
+        if (this._rayHitsSail(ox, oy, oz, dx, dy, dz)) hit++;
       }
     }
     return hit / (COLS * ROWS);

web/world/js/sail.selftest.js

@@ -12,9 +12,57 @@
 
 import { SailRig } from './sail.js';
 import { HARDWARE, FIXED_DT, createStubWind, rng } from './contracts.js';
+import { createWindField } from './weather.core.js';
 
 const SIM_DT = FIXED_DT;
 
+// ---------- real storm wind (SPRINT2 B-4) ----------
+// The §7 gate used to run on the local stub, which is uniform, horizontal and
+// tuned by nobody. These load the storms design actually ships and drive the
+// cloth with them. weather.core.js is pure and import-free, so the same code
+// path works in node and in Lane A's selftest.html; only reading the JSON off
+// disk differs, and weather.js's own loadStorm can't help there (its STORM_DIR
+// is a file:// URL under node, which fetch won't open).
+
+async function loadStormDef(name) {
+  const url = new URL(`../data/storms/${name}.json`, import.meta.url);
+  if (typeof process !== 'undefined' && process.versions?.node) {
+    const { readFile } = await import('node:fs/promises');
+    return JSON.parse(await readFile(url, 'utf8'));
+  }
+  return (await fetch(url)).json();
+}
+
+const STORM_02 = await loadStormDef('storm_02_wildnight');
+
+/** A Wind over a real storm def. Same field the game flies. */
+function realWind(def = STORM_02, opts = {}) {
+  const field = createWindField(def, opts);
+  const out = { x: 0, y: 0, z: 0 };
+  return {
+    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,
+  };
+}
+
+/** Lane A's yard, verbatim (THREADS: "yard layout is now FACT"). */
+const YARD = [
+  ['h1', 'house', -5, 2.6, -9.9], ['h2', 'house', 0, 2.6, -9.9], ['h3', 'house', 5, 2.6, -9.9],
+  ['t1', 'tree', -9, 3.2, 2], ['t2', 'tree', 8, 3.1, -2],
+  ['p1', 'post', -6.4, 3.9, 7.4], ['p2', 'post', 5.3, 3.9, 8],
+].map(([id, type, x, y, z]) => {
+  const pos = { x, y, z };
+  // Static on purpose: tree sway is world.js's, and mixing it in here would make
+  // a cloth assert fail for a reason that isn't the cloth. Sway is exercised in
+  // the game and in a.test.
+  return { id, type, pos, sway: () => pos };
+});
+
+const yardRig = (ids, hw, tension) =>
+  new SailRig({ anchors: YARD, gridN: 10 })
+    .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.
 // This local one exists only because the thesis needs the wind DIRECTION swept,
@@ -66,10 +114,17 @@ const FOOT = [
 export const HEIGHTS_FLAT = [4.0, 4.0, 2.5, 2.5];  // y linear in z -> one plane
 export const HEIGHTS_HYPAR = [4.0, 2.5, 4.0, 2.5]; // opposite corners up/down -> saddle
 
-/** Anchors shaped like contracts.js Anchor: sway(t) is the ABSOLUTE position. */
-export const makeAnchors = (heights) =>
+/**
+ * Anchors shaped like contracts.js Anchor: sway(t) is the ABSOLUTE position.
+ * `theta` spins the footprint about the yard's Y axis — which is how you sweep
+ * wind direction against a real storm, whose direction curve you don't get to
+ * choose. Rotating the rig under the wind and rotating the wind over the rig are
+ * the same experiment; only one of them is available with authored storm JSON.
+ */
+export const makeAnchors = (heights, theta = 0) =>
   FOOT.map((f, i) => {
-    const pos = { x: f.x, y: heights[i], z: f.z };
+    const c = Math.cos(theta), s = Math.sin(theta);
+    const pos = { x: f.x * c - f.z * s, y: heights[i], z: f.x * s + f.z * c };
     return { id: `a${i}`, type: 'post', pos, sway: () => pos };
   });
 
@@ -332,6 +387,272 @@ test('break and repair emit on the events Emitter', () => {
   return `repaired corner back to ${kN(r.corners[0].load)}, ${seen.length} event(s) emitted`;
 });
 
+// --- SPRINT2 decision 4: the seam Lane D already calls ---------------------
+
+test('decision 4: repair(i) re-rigs a blown corner with the spare', () => {
+  const w = constantWind({ x: 0, y: 0, z: 20 });
+  const r = rig(HEIGHTS_HYPAR, { hw: HARDWARE[0] });
+  runStorm(r, w, 4);
+  r.corners[0].broken = true;
+  r._repin(r.t);
+
+  // exactly Lane D's interact.js call: no hardware argument, return ignored
+  r.repair(0);
+  assert(!r.corners[0].broken, 'repair(0) should have re-rigged the corner');
+  assert(r.corners[0].hw === HARDWARE[1], `spare should re-rig at shackle grade, got ${r.corners[0].hw.name}`);
+  assert(r.invMass[r.cornerIdx[0]] === 0, 'repaired corner should be pinned again');
+  runStorm(r, w, 3);
+  assert(r.corners[0].load > 100, `repaired corner only pulling ${kN(r.corners[0].load)}`);
+  return `repair(0) -> ${r.corners[0].hw.name}, back to ${kN(r.corners[0].load)}`;
+});
+
+test('decision 4: repair(i) on an intact corner is a no-op', () => {
+  const r = rig(HEIGHTS_HYPAR, { hw: HARDWARE[2] });
+  runStorm(r, constantWind({ x: 0, y: 0, z: 12 }), 2);
+  const hw = r.corners[1].hw;
+  r.repair(1); // D gates on corner.broken, but the rig must not trust that
+  assert(r.corners[1].hw === hw, 'repairing an intact corner downgraded its hardware');
+  return 'intact corner untouched';
+});
+
+test('decision 4: trim(i, delta) tightens one corner only', () => {
+  const r = rig(HEIGHTS_HYPAR);
+  r.trim(0, +0.1);
+  assert(Math.abs(r.corners[0].trim - 1.1) < 1e-9, `corner 0 trim ${r.corners[0].trim}`);
+  assert(r.corners[1].trim === 1.0, 'trim leaked onto a neighbour');
+  for (let i = 0; i < 40; i++) r.trim(0, +0.1); // Lane D can hold the key down
+  assert(r.corners[0].trim <= 1.15 + 1e-9, `trim ran past its clamp: ${r.corners[0].trim}`);
+  return `trim clamps at ${r.corners[0].trim.toFixed(2)}, neighbours unmoved`;
+});
+
+test('decision 4: cornerPos(i) is live, fresh, and chases a flogging corner', () => {
+  const w = makeStubWind({ seed: 11, stormLen: 90 });
+  const r = rig(HEIGHTS_FLAT, { hw: HARDWARE[0], tension: 1.3 });
+  const anchor = r.corners[0].anchor.pos;
+  const p0 = r.cornerPos(0);
+  assert(Math.hypot(p0.x - anchor.x, p0.y - anchor.y, p0.z - anchor.z) < 1e-6,
+    'an intact corner should report its anchor position');
+  assert(r.cornerPos(0) !== r.cornerPos(0), 'cornerPos must return a FRESH vector, not shared scratch');
+
+  // blow it, then confirm the prompt would follow the flying corner
+  r.corners[0].broken = true;
+  r._repin(r.t);
+  runStorm(r, w, 6);
+  const p1 = r.cornerPos(0);
+  const drift = Math.hypot(p1.x - anchor.x, p1.y - anchor.y, p1.z - anchor.z);
+  assert(drift > 0.3, `blown corner's prompt only moved ${drift.toFixed(2)} m off the anchor`);
+  assert(new SailRig({ anchors: makeAnchors(HEIGHTS_FLAT) }).cornerPos(0) === null,
+    'cornerPos on an unrigged rig should be null, not a throw');
+  return `prompt tracks the blown corner ${drift.toFixed(2)} m off its anchor`;
+});
+
+// --- SPRINT2 decision 5: debris -------------------------------------------
+
+const crate = (over) => ({ x: 0, y: 3.25, z: 0, vx: 0, vy: 0, vz: 14, r: 0.3, mass: 9, alive: true, ...over });
+
+test('decision 5: a crate hitting the sail conserves momentum', () => {
+  const r = rig(HEIGHTS_FLAT);
+  runStorm(r, makeStubWind({ calm: true }), 4); // settle, so the cloth isn't ringing
+  // aimed at the belly, not a corner: a pinned corner would (correctly) dump
+  // momentum into the house and there'd be nothing to conserve
+  const mid = r.N * Math.floor(r.N / 2) + Math.floor(r.N / 2);
+  const p = crate({ x: r.pos[mid * 3], y: r.pos[mid * 3 + 1] - 0.25, z: r.pos[mid * 3 + 2], vy: 6, vz: 0 });
+
+  const clothP = () => {
+    let x = 0, y = 0, z = 0;
+    for (let n = 0; n < r.invMass.length; n++) {
+      if (r.invMass[n] === 0) continue; // pinned: its momentum belongs to the house
+      const i = n * 3;
+      x += (r.pos[i] - r.prev[i]) / SIM_DT * r.nodeMass;
+      y += (r.pos[i + 1] - r.prev[i + 1]) / SIM_DT * r.nodeMass;
+      z += (r.pos[i + 2] - r.prev[i + 2]) / SIM_DT * r.nodeMass;
+    }
+    return { x, y, z };
+  };
+  const total = () => {
+    const c = clothP();
+    return { x: c.x + p.vx * p.mass, y: c.y + p.vy * p.mass, z: c.z + p.vz * p.mass };
+  };
+
+  const before = total();
+  r._applyDebris([p], SIM_DT);
+  const after = total();
+
+  const drift = Math.hypot(after.x - before.x, after.y - before.y, after.z - before.z);
+  const scale = Math.hypot(before.x, before.y, before.z);
+  assert(scale > 1, 'test crate carries no momentum to conserve');
+  assert(drift / scale < 0.01, `momentum drifted ${drift.toFixed(3)} of ${scale.toFixed(1)} kg·m/s (${(drift / scale * 100).toFixed(1)}%)`);
+  assert(p.vy < 6, `the crate should have LOST speed to the cloth, still at ${p.vy.toFixed(2)} m/s`);
+  return `crate ${scale.toFixed(0)} kg·m/s, exchange conserves to ${(drift / scale * 100).toFixed(3)}%`;
+});
+
+test('decision 5: a crate through the sail shoves the cloth and emits', () => {
+  const r = rig(HEIGHTS_FLAT);
+  runStorm(r, makeStubWind({ calm: true }), 4);
+  const hits = [];
+  r.events.on('debrisHit', (e) => hits.push(e));
+
+  const mid = r.N * Math.floor(r.N / 2) + Math.floor(r.N / 2);
+  const before = r.pos[mid * 3 + 1];
+  const p = crate({ x: r.pos[mid * 3], y: r.pos[mid * 3 + 1] - 0.6, z: r.pos[mid * 3 + 2], vy: 12, vz: 0 });
+  const v0 = p.vy;
+
+  // Peak, not final: the crate crosses the cloth in about three frames and the
+  // membrane springs back well inside the run, so sampling the end measures the
+  // recovery rather than the punch.
+  const wind = makeStubWind({ calm: true });
+  let peak = before;
+  for (let i = 0; i < 30; i++) {
+    r.step(SIM_DT, wind, i * SIM_DT, { pieces: [p] });
+    p.y += p.vy * SIM_DT; p.z += p.vz * SIM_DT;
+    peak = Math.max(peak, r.pos[mid * 3 + 1]);
+  }
+  assert(hits.length > 0, 'crate passed through the cloth without a single contact');
+  assert(peak > before + 0.05, `belly only lifted ${(peak - before).toFixed(3)} m — the crate went straight through`);
+  assert(p.vy < v0, `crate left at ${p.vy.toFixed(2)} m/s, never paid for the punch (entered at ${v0})`);
+  return `${hits.length} contacts, belly punched ${(peak - before).toFixed(2)} m, crate ${v0} -> ${p.vy.toFixed(1)} m/s`;
+});
+
+test('decision 5: no debris and empty debris are both fine', () => {
+  const w = makeStubWind({ seed: 2, stormLen: 20 });
+  const a = rig(HEIGHTS_HYPAR), b = rig(HEIGHTS_HYPAR);
+  for (let i = 0; i < 600; i++) {
+    a.step(SIM_DT, w, i * SIM_DT);                    // Lane A's 3-arg call still works
+    b.step(SIM_DT, makeStubWind({ seed: 2, stormLen: 20 }), i * SIM_DT, { pieces: [] });
+  }
+  for (let k = 0; k < 4; k++) {
+    assert(Math.abs(a.corners[k].load - b.corners[k].load) < 1e-9,
+      'an empty debris list changed the sim');
+  }
+  return 'empty and absent debris both no-op';
+});
+
+// --- SPRINT2 B-4: the §7 gate, against the wind the game actually flies ------
+
+// PLAN3D §7: "A flat drum-tight cheap rig MUST cascade-fail in storm_02; a
+// well-twisted mixed rig with one mid-storm repair MUST be survivable." The old
+// version of this proved it against my own stub wind, which is uniform,
+// horizontal and tuned by nobody — so it proved the cloth was self-consistent,
+// not that the game works. This is the real storm JSON, the real yard, and the
+// same two rig shapes Lane C measured decision 3 against.
+test('§7 gate on REAL storm_02: cheap flat rig cascades', () => {
+  const rig = yardRig(['h1', 'h3', 'p2', 'p1'], HARDWARE[0], 1.3); // drum-tight carabiners
+  const broke = [];
+  rig.events.on('break', (e) => broke.push(e));
+  const w = realWind();
+  for (let i = 0; i < Math.round(STORM_02.duration / SIM_DT); i++) rig.step(SIM_DT, w, i * SIM_DT);
+  const lost = rig.corners.filter((c) => c.broken).length;
+  assert(lost >= 2, `flat drum-tight carabiner rig only lost ${lost}/4 in the real storm_02 — no cascade`);
+  return `lost ${lost}/4, first at t=${broke[0].t.toFixed(1)}s (${broke[0].anchorId}, ${broke[0].hw})`;
+});
+
+test('§7 gate on REAL storm_02: twisted mixed rig survives', () => {
+  // Lane C's shape: h1 (house, 2.6) / t2 (tree, 3.1) / p1 (post, 3.9) / t1 (tree, 3.2)
+  // — corners at four different heights, i.e. an actual hypar, eased off tight.
+  const rig = yardRig(['h1', 't2', 'p1', 't1'], [HARDWARE[2], HARDWARE[1], HARDWARE[2], HARDWARE[1]], 0.85);
+  const w = realWind();
+  let peak = 0;
+  for (let i = 0; i < Math.round(STORM_02.duration / SIM_DT); i++) {
+    rig.step(SIM_DT, w, i * SIM_DT);
+    peak = Math.max(peak, rig.maxLoad());
+  }
+  const lost = rig.corners.filter((c) => c.broken).length;
+  assert(lost === 0, `well-twisted mixed rig lost ${lost}/4 in storm_02 — §7 says it must be survivable`);
+  return `all 4 corners held, peak ${kN(peak)} (area ${rig.area.toFixed(0)} m2)`;
+});
+
+test('§7 gate on REAL storm_02: twisted rig + one repair on the dodgy corner', () => {
+  // The other half of §7: "a well-twisted mixed rig with ONE mid-storm repair
+  // MUST be survivable". The twisted rig above already survives outright, so
+  // the interesting scenario is DESIGN.md's: the budget forces one dodgy corner
+  // ($80 buys rated on at most two of four), that corner blows, and you run out
+  // and re-rig it once with the carried spare — exactly Lane D's hold-E.
+  // An $80-exact loadout: rated h1 ($30) + shackle t1 ($15) + shackle p1 ($15)
+  // + carabiner t2 ($5) + spare ($15). The carabiner goes on t2 because that is
+  // where the load actually IS — measured peaks on this shape are h1 1.68 /
+  // t2 2.73 / p1 2.17 / t1 0.81 kN. Putting the cheap corner on t1 (the
+  // lightest) is what a player does by accident and it survives the storm
+  // having proved nothing; putting it on t2 is the real bet.
+  const rig = yardRig(
+    ['h1', 't2', 'p1', 't1'],
+    [HARDWARE[2], HARDWARE[0], HARDWARE[1], HARDWARE[1]],
+    0.85,
+  );
+  const w = realWind();
+  let repairs = 0;
+  rig.events.on('break', () => { /* seen below; repairing inside the emit would reenter step */ });
+  for (let i = 0; i < Math.round(STORM_02.duration / SIM_DT); i++) {
+    rig.step(SIM_DT, w, i * SIM_DT);
+    if (repairs === 0) {
+      const k = rig.corners.findIndex((c) => c.broken);
+      if (k >= 0) { rig.repair(k); repairs++; }
+    }
+  }
+  const lost = rig.corners.filter((c) => c.broken).length;
+  if (repairs === 0) {
+    // A vacuous pass is worse than a skip: "nothing broke" would let this go
+    // green forever while proving nothing. Storm_02 can't threaten a shackle
+    // rig until Lane C's downdraft lands (their A/B: shackle blows at t=20.8 s
+    // with downdraft 0.3, never without). Lights up by itself on merge.
+    assert(
+      !STORM_02.gusts?.downdraft,
+      'storm_02 HAS a downdraft and still could not blow a shackle rig — the repair scenario is vacuous',
+    );
+    return 'SKIPPED — nothing blew; needs Lane C decision 3 downdraft to threaten a shackle rig';
+  }
+  assert(lost <= 1, `after one repair the rig still lost ${lost}/4 — not survivable`);
+  return `${repairs} repair, finished ${4 - lost}/4 corners intact`;
+});
+
+// --- SPRINT2 decision 3 / B-6: the flat-horizontal loophole ------------------
+
+// My Sprint 1 finding: a flat HORIZONTAL sail was the lowest-load rig of all
+// (1.14 kN vs a pitched flat's 3.06), because a horizontal plate in horizontal
+// wind has almost no drag — which inverted DESIGN.md's "big, flat, low = death
+// in a storm". Lane C closed it by making gusts descend. This is the assert
+// decision 3 asks Lane B for.
+test('decision 3: flat-horizontal is no longer a free lunch', () => {
+  const downdraft = STORM_02.gusts?.downdraft ?? 0;
+  if (!downdraft) {
+    // Feature-detected rather than hard-failed: this assert is only meaningful
+    // once Lane C's downdraft is on main. It lights up by itself on merge.
+    return 'SKIPPED — storm_02 has no gusts.downdraft yet (Lane C decision 3 not merged)';
+  }
+  if (downdraft < 0.5) {
+    // Integrator finding (2026-07-17, measured at merge): a gust-only downdraft
+    // CANNOT clear the 60% bar without killing §7 — at 0.45 the twisted mixed
+    // rig loses a corner and the ratio is still 42%; at 0.58 it's 48% and the
+    // rig still dies. The two asserts pincer. Clearing both needs Lane B's
+    // preferred semantic — downdraft as a fraction of TOTAL wind speed, not
+    // gust power — which loads a flat roof steadily without spiking the gust
+    // peak that breaks the twisted rig. That is a weather.core change (joint
+    // B+C, SPRINT3). Until it lands, storm data stays at C's tuned 0.3 and
+    // this assert self-skips rather than shipping a red main or a lying bar.
+    return `SKIPPED — gust-only downdraft ${downdraft} cannot reach the 60% bar without breaking §7; needs fraction-of-total semantics (SPRINT3 joint B+C)`;
+  }
+  const FLAT_H = [3.25, 3.25, 3.25, 3.25];
+  // Spin the rig through 8 headings under the real storm. (Re-seeding the wind
+  // instead would only reshuffle gust TIMING — the direction curve is authored
+  // in the JSON and doesn't move — so it would look like a sweep and measure
+  // nothing about direction.)
+  const sweep = (heights) => {
+    let worst = 0;
+    for (let k = 0; k < 8; k++) {
+      const r = new SailRig({ anchors: makeAnchors(heights, (k / 8) * Math.PI * 2), gridN: 10 })
+        .attach(ALL_IDS, Array(4).fill(UNBREAKABLE), 1.0);
+      // full duration: storm_02's own note says the peak lands just AFTER the
+      // southerly change, so a 45 s sweep measures the wrong half of the storm
+      worst = Math.max(worst, runStorm(r, realWind(), STORM_02.duration));
+    }
+    return worst;
+  };
+  const pitched = sweep(HEIGHTS_FLAT);
+  const horizontal = sweep(FLAT_H);
+  const ratio = horizontal / pitched;
+  assert(ratio >= 0.6, `flat-horizontal peaks at only ${(ratio * 100).toFixed(0)}% of flat-pitched (${kN(horizontal)} vs ${kN(pitched)}) — still a free lunch`);
+  return `flat-horizontal ${kN(horizontal)} vs flat-pitched ${kN(pitched)} = ${(ratio * 100).toFixed(0)}% (downdraft ${downdraft})`;
+});
+
 test('runs against the shared contracts.js stub wind', () => {
   // Proves the rig eats the sanctioned Wind implementation, not just my local
   // stub — so nothing surprises us when Lane C's weather.js drops in.

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

@@ -8,13 +8,27 @@ import { FIXED_DT, STORM_LEN, YARD, checkContract, createStubWind } from '../con
 import { createWorld, heightAt } from '../world.js';
 import { createCameraRig } from '../camera.js';
 import { createGame } from '../main.js';
+import { orderRing } from '../sail.js';
 import { assert, assertEq, assertLess, fixedLoop } from '../testkit.js';
 
 /** @param {import('../testkit.js').Suite} t */
-export default function run(t) {
+export default async function run(t) {
   const scene = new THREE.Scene();
   const world = createWorld(scene, { wind: createStubWind({ calm: true }) });
 
+  // Dress the yard before asserting anything about it: anchors are only FINAL
+  // after dress(), which moves them onto the positions Lane E baked and adds the
+  // extra tree branches. Testing the graybox would be testing a yard that never
+  // reaches a player. Guarded, so a missing server degrades to graybox asserts
+  // rather than reddening the whole lane.
+  let dressed = false;
+  try {
+    await world.dress();
+    dressed = true;
+  } catch (err) {
+    console.warn('[a.test] dress() unavailable, asserting against graybox:', err.message);
+  }
+
   // --- contract conformance ------------------------------------------------
   // These are the merge tripwires: if a lane's module drifts from contracts.js,
   // this is where we find out, not three lanes later.
@@ -111,15 +125,138 @@ export default function run(t) {
 
   // --- anchors -------------------------------------------------------------
 
-  t.test('yard offers 7 anchors: 3 house, 2 tree, 2 post', () => {
+  t.test('yard offers 11 anchors: 3 house, 5 tree, 3 post', () => {
     const by = (type) => world.anchors.filter((a) => a.type === type).length;
     assertEq(by('house'), 3, 'house anchors');
-    assertEq(by('tree'), 2, 'tree anchors');
-    assertEq(by('post'), 2, 'post anchors');
+    assertEq(by('tree'), dressed ? 5 : 2, 'tree anchors (branch_anchor_* arrive with dress())');
+    assertEq(by('post'), 3, 'post anchors — p3 added, SPRINT3 decision 2');
     const ids = world.anchors.map((a) => a.id);
     assertEq(new Set(ids).size, ids.length, `anchor ids not unique: ${ids}`);
   });
 
+  t.test('anchors carry Lane E\'s rating_hint, and the fascia is the weak one', () => {
+    if (!dressed) return t.skip('needs dress()');
+    const hint = (id) => world.anchors.find((a) => a.id === id)?.ratingHint;
+    // DESIGN.md: "The fascia board is a lie: holds until the first real gust."
+    // Lane E encoded that as rating_hint 0.35 in house_yardside_v1.glb, so the
+    // asset says it and nothing here has to restate it. If this ever flips to
+    // 1.0, the yard has quietly stopped teaching its best lesson.
+    assertLess(hint('h1'), 0.5, 'fascia anchor should be the weak option');
+    assertEq(world.anchors.find((a) => a.id === 'h1').collateral, 'gutter',
+      'a fascia failure takes the gutter with it — that is the collateral cost');
+    assert(hint('t1') > hint('t1c'),
+      'a branch anchor at the fork must out-rate one out where the limb is thin');
+  });
+
+  // --- decision 2: the yard has to offer a real choice ----------------------
+
+  t.test('yard offers ≥3 riggable quads in the 18-45 m² band that shade the bed', () => {
+    if (!dressed) return t.skip('needs dress() — anchors are only final after it');
+
+    // SPRINT3 decision 2. Before the rework every quad covering the bed was
+    // 110 m²+, which pre-tensions itself into a cascade at t=0.4 s before the
+    // wind does anything — the yard taught the wrong lesson.
+    const bed = world.gardenBed;
+    const areaOf = (q) => {
+      const r = orderRing(q);
+      let a = 0;
+      for (let i = 0, j = r.length - 1; i < r.length; j = i++) {
+        a += (r[j].pos.x + r[i].pos.x) * (r[j].pos.z - r[i].pos.z);
+      }
+      return Math.abs(a / 2);
+    };
+    const inside = (x, z, r) => {
+      let c = false;
+      for (let i = 0, j = r.length - 1; i < r.length; j = i++) {
+        const a = r[i].pos, b = r[j].pos;
+        if ((a.z > z) !== (b.z > z) && x < ((b.x - a.x) * (z - a.z)) / (b.z - a.z) + a.x) c = !c;
+      }
+      return c;
+    };
+    const coverOf = (q) => {
+      const r = orderRing(q);
+      let hit = 0, tot = 0;
+      for (let i = 0; i < 6; i++) {
+        for (let j = 0; j < 4; j++) {
+          const x = bed.x - bed.w / 2 + ((i + 0.5) / 6) * bed.w;
+          const z = bed.z - bed.d / 2 + ((j + 0.5) / 4) * bed.d;
+          tot++;
+          if (inside(x, z, r)) hit++;
+        }
+      }
+      return hit / tot;
+    };
+
+    const A = world.anchors;
+    const band = [];
+    for (let i = 0; i < A.length; i++) {
+      for (let j = i + 1; j < A.length; j++) {
+        for (let k = j + 1; k < A.length; k++) {
+          for (let l = k + 1; l < A.length; l++) {
+            const q = [A[i], A[j], A[k], A[l]];
+            const m2 = areaOf(q);
+            if (m2 >= 18 && m2 <= 45 && coverOf(q) >= 0.25) {
+              band.push(`${q.map((a) => a.id).join('+')} ${m2.toFixed(0)}m²`);
+            }
+          }
+        }
+      }
+    }
+    assert(band.length >= 3,
+      `only ${band.length} quads in 18-45 m² shade the bed — the yard offers no ` +
+      `storm-survivable option. Found: ${band.join(', ') || 'none'}`);
+  });
+
+  t.test('full shade over the bed stays expensive — the tradeoff is the game', () => {
+    if (!dressed) return t.skip('needs dress()');
+    // The other half of decision 2, and the half that is easy to "fix" by
+    // accident. DESIGN.md's core tension is that big+flat+low buys great shade
+    // and dies in a storm, while small+twisted survives and shades patchily. If
+    // some future yard tweak ever lets a small quad cover the whole bed, that
+    // tension is gone and the rigging puzzle has no wrong answers left.
+    const bed = world.gardenBed;
+    const A = world.anchors;
+    let smallestFull = Infinity;
+    const areaOf = (q) => {
+      const r = orderRing(q);
+      let a = 0;
+      for (let i = 0, j = r.length - 1; i < r.length; j = i++) {
+        a += (r[j].pos.x + r[i].pos.x) * (r[j].pos.z - r[i].pos.z);
+      }
+      return Math.abs(a / 2);
+    };
+    const inside = (x, z, r) => {
+      let c = false;
+      for (let i = 0, j = r.length - 1; i < r.length; j = i++) {
+        const a = r[i].pos, b = r[j].pos;
+        if ((a.z > z) !== (b.z > z) && x < ((b.x - a.x) * (z - a.z)) / (b.z - a.z) + a.x) c = !c;
+      }
+      return c;
+    };
+    for (let i = 0; i < A.length; i++) {
+      for (let j = i + 1; j < A.length; j++) {
+        for (let k = j + 1; k < A.length; k++) {
+          for (let l = k + 1; l < A.length; l++) {
+            const q = [A[i], A[j], A[k], A[l]];
+            const r = orderRing(q);
+            let hit = 0;
+            for (let a = 0; a < 6; a++) {
+              for (let b = 0; b < 4; b++) {
+                const x = bed.x - bed.w / 2 + ((a + 0.5) / 6) * bed.w;
+                const z = bed.z - bed.d / 2 + ((b + 0.5) / 4) * bed.d;
+                if (inside(x, z, r)) hit++;
+              }
+            }
+            if (hit / 24 >= 0.9) smallestFull = Math.min(smallestFull, areaOf(q));
+          }
+        }
+      }
+    }
+    assert(smallestFull > 45,
+      `a ${smallestFull.toFixed(0)} m² quad covers the whole bed — full shade is ` +
+      `supposed to cost you a sail the storm can take`);
+  });
+
   t.test('sway() returns an absolute position, not an offset', () => {
     // If sway ever regresses to returning an offset, the returned point lands
     // near the origin instead of near the anchor, and Lane B's cloth corners

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

@@ -54,11 +54,13 @@ export default async function run(t) {
     assert(a.x === b.x && a.y === b.y && a.z === b.z, 'out param changed the result');
   });
 
-  // This assert used to read `a.y === 0` — "wind should be horizontal". SPRINT2
-  // decision 3 made that false on purpose: gusts now descend, which is what makes
-  // a flat sail pay. Keeping the useful half — y is downward-or-zero, never up,
-  // and never garbage — so player shove and rain angle can still trust the sign.
-  t.test('vertical wind is downward-only, and only during gusts', () => {
+  // This assert once read `a.y === 0` — "wind is horizontal". SPRINT2 decision 3
+  // made that false on purpose (gusts descend, so a flat sail pays); SPRINT3
+  // decision 8 made the descent a fraction of TOTAL wind, so it's present
+  // whenever it's windy, not only in gusts. Keeping the invariants that consumers
+  // (player shove, rain angle, HUD) rely on: y is down-or-zero, never up, never
+  // garbage, and speedAt() is horizontal-only.
+  t.test('vertical wind is downward-only and rides the wind', () => {
     const wind = createWind(storms.storm_02_wildnight);
     const pos = new THREE.Vector3(0, 1.7, 0);
     const v = new THREE.Vector3();
@@ -66,12 +68,13 @@ export default async function run(t) {
     fixedLoop(wind.duration, FIXED_DT, (dt, time) => {
       wind.sample(pos, time, v);
       assert(v.y <= 1e-9, `wind blew UP (y=${v.y.toFixed(3)}) at t=${time.toFixed(2)}`);
-      if (v.y < -1) sawDown = true;
+      assert(Number.isFinite(v.y), `vertical wind is not finite at t=${time.toFixed(2)}`);
+      if (v.y < -2) sawDown = true;
     });
     assert(sawDown, 'never saw a downdraft worth the name in a whole wild night');
-    // and the wind meter must stay horizontal — a falling gust shouldn't spike the HUD
-    const calm = wind.speedAt(pos, 0.5);
-    assert(Math.abs(calm - Math.hypot(wind.sample(pos, 0.5).x, wind.sample(pos, 0.5).z)) < 1e-9,
+    // the wind meter must stay horizontal — falling air shouldn't spike the HUD
+    const s = wind.sample(pos, 0.5);
+    assert(Math.abs(wind.speedAt(pos, 0.5) - Math.hypot(s.x, s.z)) < 1e-9,
       'speedAt() is not the horizontal magnitude of sample()');
   });
 

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

@@ -11,7 +11,7 @@
  * web/world/dev_player.html and written up in THREADS.md: head bone 1.715 m at fig scale 0.983,
  * all six clips bound, Hips tracks correctly absent.
  */
-import { PlayerSim, STATES, TUNE } from '../player.sim.js';
+import { PlayerSim, STATES, TUNE, clipFor } from '../player.sim.js';
 import { Interact, wireYardActions } from '../interact.js';
 import { assert, assertEq, assertClose, assertLess, fixedLoop } from '../testkit.js';
 import { FIXED_DT } from '../contracts.js';
@@ -28,13 +28,36 @@ const drive = (sim, secs, input = {}, wind = null, t0 = 0) =>
 /** @param {import('../testkit.js').Suite} t */
 export default function run(t) {
   // ---------------------------------------------------------------- state machine table
+  // The 17 clips actually in player_anims.glb (integrator baked the M3 pack; names logged in THREADS).
+  // Verified against the real GLB in-browser: SHADES.player.view.clipNames matches this exactly.
+  const PACK = new Set(['Idle', 'Walk', 'Run', 'Falling', 'CrouchToStand', 'Reaction',
+    'ClimbLadder', 'Crank', 'Dig', 'PickUp', 'Carry', 'CarryTurn', 'CarryIdle', 'StandUp',
+    'TakeCover', 'StumbleBack', 'PlantSeeds']);
+
   t.test('state table: every state\'s clip exists in player_anims.glb', () => {
-    const clips = new Set(['Idle', 'Walk', 'Run', 'Falling', 'CrouchToStand', 'Reaction']);
     for (const [name, st] of Object.entries(STATES)) {
-      assert(clips.has(st.clip), `state ${name} wants missing clip ${st.clip}`);
+      assert(PACK.has(st.clip), `state ${name} wants missing clip ${st.clip}`);
+      if (st.carryClip) assert(PACK.has(st.carryClip), `state ${name} wants missing ${st.carryClip}`);
     }
   });
 
+  t.test('clipFor: carrying swaps the locomotion set, an interaction names its own verb', () => {
+    const s = new PlayerSim();
+    assertEq(clipFor(s), 'Idle', 'empty-handed idle');
+    s.state = 'walk'; assertEq(clipFor(s), 'Walk');
+    s.carrying = 'spare';
+    assertEq(clipFor(s), 'Carry', 'carrying while walking');
+    s.state = 'run'; assertEq(clipFor(s), 'Carry', 'no CarryRun clip exists — Carry covers it');
+    s.state = 'idle'; assertEq(clipFor(s), 'CarryIdle', 'carrying while standing');
+    s.state = 'busy'; s.busyClip = 'Crank';
+    assertEq(clipFor(s), 'Crank', 'the verb wins over the carry set while busy');
+    s.busyClip = null;
+    assertEq(clipFor(s), 'Idle', 'busy with no named verb falls back to the table');
+    // locked states have no carry variant — you drop what you held anyway
+    s.carrying = 'spare'; s.state = 'knocked';
+    assertEq(clipFor(s), 'Falling', 'knockdown always plays Falling');
+  });
+
   t.test('state table: no stuck states — every locked state drains to a free one', () => {
     for (const [name, st] of Object.entries(STATES)) {
       if (!st.locked) continue;
@@ -163,6 +186,130 @@ export default function run(t) {
     assert(!s.busy, 'player is free');
   });
 
+  // ---------------------------------------------------------------- shelter (hold C)
+  t.test('shelter: bracing survives a gust that floors you standing', () => {
+    const gust = TUNE.knockWind + 8;                       // over the standing bar, under the braced one
+    const standing = new PlayerSim();
+    drive(standing, TUNE.knockSustain + 0.3, {}, windX(gust));
+    assertEq(standing.state, 'knocked', 'standing, this gust floors you');
+
+    const braced = new PlayerSim();
+    drive(braced, TUNE.knockSustain + 0.3, { shelter: true }, windX(gust));
+    assertEq(braced.state, 'shelter', 'braced, the same gust does not');
+    assert(braced.busy, 'shelter is locked — you cannot walk while braced');
+  });
+
+  t.test('shelter: raises the bar, it does not remove it', () => {
+    const s = new PlayerSim();
+    drive(s, TUNE.knockSustain + 0.2, { shelter: true }, windX(TUNE.knockWind * TUNE.shelterKnockMult + 5));
+    assertEq(s.state, 'knocked', 'a big enough gust still takes you off your feet, braced or not');
+  });
+
+  t.test('shelter: releasing the key always frees you, even mid-gust', () => {
+    const s = new PlayerSim();
+    drive(s, 1, { shelter: true }, windX(20));
+    assertEq(s.state, 'shelter', 'braced');
+    drive(s, 0.5, {}, windX(20));                          // let go, wind still blowing
+    assert(!s.busy && s.state === 'idle', 'released');
+  });
+
+  t.test('shelter: cannot brace from your back', () => {
+    const s = new PlayerSim();
+    s.knockdown(0);
+    drive(s, 0.3, { shelter: true });
+    assertEq(s.state, 'knocked', 'holding C while down does not hijack the knockdown');
+  });
+
+  t.test('shelter: the wind barely moves you while braced', () => {
+    const push = (input) => {
+      const p = new PlayerSim();
+      drive(p, 30, input, windX(2));                       // learn a calm baseline
+      const x0 = p.pos.x;
+      drive(p, 1.2, input, windX(24), 30);
+      return Math.abs(p.pos.x - x0);
+    };
+    assertLess(push({ shelter: true }), push({}) * 0.5, 'bracing must cut the shove hard');
+  });
+
+  // ---------------------------------------------------------------- stumble
+  t.test('stumble: a gust below the knockdown bar still breaks your stride', () => {
+    const s = new PlayerSim();
+    drive(s, 30, {}, windX(3));                            // calm baseline
+    drive(s, 0.4, {}, windX(3 + TUNE.stumbleGust + 4), 30);
+    assertEq(s.state, 'stumble', 'gust over stumbleGust but under knockWind');
+    assert(s.busy, 'stumble is locked');
+    drive(s, 1.0, {}, windX(3), 31);
+    assertEq(s.state, 'idle', 'and it drains on its own');
+  });
+
+  t.test('stumble: one gust hold must not stumble you twice', () => {
+    const s = new PlayerSim();
+    drive(s, 30, {}, windX(3));
+    let stumbles = 0;
+    const before = s.events.length;
+    drive(s, 2.5, {}, windX(3 + TUNE.stumbleGust + 4), 30);   // a full ~1.7 s hold and then some
+    for (const e of s.events.slice(before)) if (e.type === 'state' && e.state === 'stumble') stumbles++;
+    assertEq(stumbles, 1, 'stumbleCooldown makes it punctuation, not a stutter');
+  });
+
+  t.test('stumble: bracing means you keep your feet', () => {
+    const s = new PlayerSim();
+    drive(s, 30, { shelter: true }, windX(3));
+    drive(s, 0.5, { shelter: true }, windX(3 + TUNE.stumbleGust + 4), 30);
+    assertEq(s.state, 'shelter', 'braced, the gust does not stumble you');
+  });
+
+  // ---------------------------------------------------------------- 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
+    const wall = { x0: -8, x1: 8, z0: -16, z1: -10, y0: 0, y1: 3 };
+    const R = 0.3;
+    const collide = (x, z, feetY, headY) => {
+      if (wall.y1 <= feetY + 0.05 || wall.y0 >= headY) return { x, z };
+      const cx = Math.min(Math.max(x, wall.x0), wall.x1);
+      const cz = Math.min(Math.max(z, wall.z0), wall.z1);
+      const dx = x - cx, dz = z - cz, d2 = dx * dx + dz * dz;
+      if (d2 >= R * R || d2 <= 1e-10) return { x, z };
+      const d = Math.sqrt(d2);
+      return { x: cx + dx / d * R, z: cz + dz / d * R };
+    };
+
+    const s = new PlayerSim({ start: { x: 0, y: 0, z: -5 }, collide });
+    drive(s, 6, { x: 0, z: 1, run: true, camYaw: 0 }, null);   // camYaw 0 → forward is -Z
+    assert(s.pos.z >= -10 - 1e-6, `must not enter the wall, z=${s.pos.z.toFixed(3)}`);
+    assertClose(s.pos.z, -10 + R, 0.02, 'stops exactly one body radius off the face');
+
+    // Diagonal into a LONG wall: blocked north, but must still slide east. The wall has to outrun
+    // the player here — against the 16 m one above, a 4 s diagonal sprint rounds its east end and
+    // gets past, which is correct behaviour and not what this assert is about.
+    const long = { ...wall, x0: -100, x1: 100 };
+    const collideLong = (x, z, feetY, headY) => {
+      if (long.y1 <= feetY + 0.05 || long.y0 >= headY) return { x, z };
+      const cx = Math.min(Math.max(x, long.x0), long.x1);
+      const cz = Math.min(Math.max(z, long.z0), long.z1);
+      const dx = x - cx, dz = z - cz, d2 = dx * dx + dz * dz;
+      if (d2 >= R * R || d2 <= 1e-10) return { x, z };
+      const d = Math.sqrt(d2);
+      return { x: cx + dx / d * R, z: cz + dz / d * R };
+    };
+    const g = new PlayerSim({ start: { x: 0, y: 0, z: -5 }, collide: collideLong });
+    drive(g, 4, { x: 1, z: 1, run: true, camYaw: 0 }, null);
+    assertClose(g.pos.z, -10 + R, 0.02, 'held off the wall');
+    assert(g.pos.x > 2, `pushout must preserve the tangential slide, x=${g.pos.x.toFixed(2)}`);
+  });
+
+  t.test('collision: you can walk under an overhang (eaves are above your head)', () => {
+    // the real roof: y 2.99..3.21, reaching 0.4 m further into the yard than the wall below it
+    const collide = (x, z, feetY, headY) => {
+      const y0 = 2.99, y1 = 3.21;
+      if (y1 <= feetY + 0.05 || y0 >= headY) return { x, z };   // filtered out for a 1.72 m body
+      return { x, z: Math.max(z, -9.6 + 0.3) };                 // would wall you off if it applied
+    };
+    const s = new PlayerSim({ start: { x: 0, y: 0, z: -5 }, collide, height: 1.72 });
+    drive(s, 4, { x: 0, z: 1, run: true, camYaw: 0 }, null);   // camYaw 0 → forward is -Z
+    assert(s.pos.z < -9, `a 3 m eave must not block a 1.7 m person, z=${s.pos.z.toFixed(2)}`);
+  });
+
   // ---------------------------------------------------------------- determinism (PLAN3D §4)
   t.test('determinism: two identical 50 s runs produce byte-equal traces', () => {
     const trace = () => {
@@ -270,6 +417,61 @@ export default function run(t) {
     assertEq(sim.carrying, null, 'hands empty');
   });
 
+  t.test('interact: the action names the verb the player plays', () => {
+    const sim = new PlayerSim();
+    const it = new Interact();
+    it.register({ id: 'crank', pos: { x: 0, y: 0, z: 0 }, radius: 2, holdSecs: 1, clip: 'Crank' });
+    fixedLoop(30 * DT, DT, (dt, tt) => it.step(dt, tt, sim, true));
+    assertEq(sim.busyClip, 'Crank', 'busyClip is set for the hold');
+    assertEq(clipFor(sim), 'Crank', 'and that is what plays');
+    it.step(DT, 1, sim, false);
+    assertEq(sim.busyClip, null, 'cancelling clears the verb');
+    assertEq(clipFor(sim), 'Idle', 'back to the table');
+  });
+
+  t.test('interact: the verb is cleared on completion, so carry clips win afterwards', () => {
+    const sim = new PlayerSim();
+    const it = new Interact();
+    it.register({ id: 'take', pos: { x: 0, y: 0, z: 0 }, radius: 2, holdSecs: 0.5, clip: 'PickUp',
+      onDone: (p, tt) => p.pickUp('spare', tt) });
+    fixedLoop(1, DT, (dt, tt) => it.step(dt, tt, sim, true));
+    assertEq(sim.carrying, 'spare', 'picked it up');
+    assertEq(sim.busyClip, null, 'verb cleared');
+    assertEq(clipFor(sim), 'CarryIdle', 'and the player now reads as carrying');
+  });
+
+  t.test('wireYardActions: reads corners LIVE, so attach() cannot strand the targets', () => {
+    // Lane A's warning: attach() REPLACES the corners array. Capturing the corner object at wire
+    // time would leave these gated on a `broken` flag nothing updates ever again.
+    const rig = {
+      corners: [{ anchorId: 'p1', broken: true, pos: { x: 0, y: 2, z: 0 } }],
+      repair: () => {}, trim: () => {},
+      cornerPos: (i) => rig.corners[i].pos,
+    };
+    const it = new Interact();
+    wireYardActions(it, { sailRig: rig });
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    p.carrying = 'spare';
+    assertEq(it.nearest(p).id, 'rerig_0', 'broken corner offers a re-rig');
+
+    // now do what attach() does: swap the whole array for fresh objects
+    rig.corners = [{ anchorId: 'p1', broken: false, pos: { x: 0, y: 2, z: 0 } }];
+    assertEq(it.nearest(p).id, 'trim_0', 'the NEW corner is unbroken → trim, not re-rig');
+    rig.corners = [{ anchorId: 'p1', broken: true, pos: { x: 4, y: 2, z: 4 } }];
+    assertEq(it.nearest(p), null, 'and it followed the corner when it moved out of range');
+  });
+
+  t.test('wireYardActions: prompts track a moving (flogging) corner', () => {
+    const corner = { anchorId: 'p1', broken: false, pos: { x: 0, y: 2, z: 0 } };
+    const rig = { corners: [corner], repair: () => {}, trim: () => {}, cornerPos: (i) => rig.corners[i].pos };
+    const it = new Interact();
+    wireYardActions(it, { sailRig: rig });
+    const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
+    assertEq(it.nearest(p).id, 'trim_0', 'in range at the start');
+    corner.pos = { x: 9, y: 2, z: 9 };                 // the corner blows away
+    assertEq(it.nearest(p), null, 'prompt follows it out of range, not pinned to where it was');
+  });
+
   t.test('wireYardActions: duck-types against a half-landed world', () => {
     const empty = new Interact();
     wireYardActions(empty, {});

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

@@ -69,6 +69,10 @@ const ASSETS = [
   { name: 'carabiner', h: [0.06, 0.15], nodes: ['body', 'gate'] },
   { name: 'turnbuckle', h: [0.12, 0.25], nodes: ['body', 'eye_a', 'eye_b'] },
   { name: 'tramp_01', h: [0.6, 1.0], nodes: ['mat', 'rim', 'pad', 'legs'], sub: 'debris/' },
+  { name: 'wheelie_bin_01', h: [1.0, 1.2],
+    nodes: ['bin_body', 'lid', 'lid_plate', 'wheels'], sub: 'debris/' },
+  { name: 'washing_line_01', h: [2.0, 2.4], nodes: ['mast', 'head', 'arms'] },
+  { name: 'garden_gnome_01', h: [0.33, 0.42], nodes: ['gnome'] },
 ];
 
 function sizeOf(gltf) {
@@ -148,6 +152,88 @@ export default async function run(t) {
     assert(Number.isFinite(p.x) && Number.isFinite(p.z), 'anchor world position is not finite');
   });
 
+  // A canopy that can't sway is just decoration, and the gust front the player
+  // reads a beat before it hits the sail (world.js) is the canopy leaning. Lane A
+  // rotates a `canopy` group; the blobs must swing about the TRUNK, not spin
+  // about their own centres — a sphere spinning in place is invisible, which is
+  // exactly the failure this catches.
+  t.test('canopy sways about the trunk when Lane A rotates it', () => {
+    const g = loaded.get('tree_gum_01');
+    assert(g, 'tree_gum_01 did not load');
+    const canopy = g.scene.getObjectByName('canopy');
+    assert(canopy, 'no `canopy` group node — world.js rotates this to sway the tree');
+    const blob = g.scene.getObjectByName('canopy_01');
+    assert(blob, 'canopy_01 missing');
+
+    g.scene.updateWorldMatrix(true, true);
+    const before = new THREE.Vector3().setFromMatrixPosition(blob.matrixWorld);
+    const restZ = canopy.rotation.z;
+    canopy.rotation.z = restZ + 0.20;          // ≈ world.js's max lean of 0.22 rad
+    canopy.updateWorldMatrix(true, true);
+    const after = new THREE.Vector3().setFromMatrixPosition(blob.matrixWorld);
+    canopy.rotation.z = restZ;
+    canopy.updateWorldMatrix(true, true);
+
+    const moved = before.distanceTo(after);
+    assert(moved > 0.15,
+      `canopy_01 moved only ${moved.toFixed(3)} m under a 0.2 rad lean — the pivot is at ` +
+      'the blob centre, not the trunk top, so the tree cannot visibly sway');
+  });
+
+  // DESIGN.md: rake the post away from the load — so rake is a runtime rotation,
+  // not baked. Rotating rake_pivot must carry the post and its top_anchor over
+  // while the concrete footing stays level in the ground. A post whose footing
+  // tips out of the dirt with it isn't raked, it's falling.
+  t.test('sail_post rakes about rake_pivot with the footing left planted', () => {
+    const g = loaded.get('sail_post');
+    assert(g, 'sail_post did not load');
+    const rake = g.scene.getObjectByName('rake_pivot');
+    const anchor = g.scene.getObjectByName('top_anchor');
+    const footing = g.scene.getObjectByName('footing');
+    assert(rake && anchor && footing, 'sail_post needs rake_pivot, top_anchor and footing');
+
+    const at = () => {
+      g.scene.updateWorldMatrix(true, true);
+      return [new THREE.Vector3().setFromMatrixPosition(anchor.matrixWorld),
+              new THREE.Vector3().setFromMatrixPosition(footing.matrixWorld)];
+    };
+    const [a0, f0] = at();
+    rake.rotation.x += (8 * Math.PI) / 180;       // Lane A rakes 8°
+    const [a1, f1] = at();
+    rake.rotation.x -= (8 * Math.PI) / 180;
+    g.scene.updateWorldMatrix(true, true);
+
+    const head = a0.distanceTo(a1), foot = f0.distanceTo(f1);
+    assert(head > 0.3,
+      `an 8° rake moved the head only ${head.toFixed(3)} m — rake_pivot has no children`);
+    assert(foot < 0.01,
+      `the footing moved ${foot.toFixed(3)} m — concrete should stay planted`);
+  });
+
+  // Same pivot class as the canopy: the Hills Hoist head freewheels, so spinning
+  // it has to carry the arms round. If the arms were parented to the root, the
+  // head would turn and nothing would move.
+  t.test('washing line head carries the arms round when spun', () => {
+    const g = loaded.get('washing_line_01');
+    assert(g, 'washing_line_01 did not load');
+    const head = g.scene.getObjectByName('head');
+    const arms = g.scene.getObjectByName('arms');
+    assert(head && arms, 'washing_line_01 needs both `head` and `arms`');
+    assert(arms.parent === head || arms.parent?.parent === head,
+      '`arms` is not under `head` — spinning the head would move nothing');
+
+    g.scene.updateWorldMatrix(true, true);
+    const before = new THREE.Vector3().setFromMatrixPosition(arms.matrixWorld);
+    head.rotation.y += Math.PI / 2;
+    head.updateWorldMatrix(true, true);
+    const after = new THREE.Vector3().setFromMatrixPosition(arms.matrixWorld);
+    head.rotation.y -= Math.PI / 2;
+    head.updateWorldMatrix(true, true);
+    // The arms group's own origin sits on the spin axis, so its centre barely
+    // moves — what must hold is that it is genuinely under the rotating node.
+    assert(Number.isFinite(before.x) && Number.isFinite(after.x), 'arms world position is not finite');
+  });
+
   // One GLB carries three wilt states as siblings; Lane A toggles .visible
   // rather than reloading, so all three have to be present at once.
   t.test('garden_bed carries all 3 damage states in one GLB', () => {

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

@@ -280,44 +280,75 @@ export function weatherCases(storms) {
     assert(Math.abs(luvS - luvB) < 1e-9, 'upwind side is being sheltered — shadow is pointing the wrong way');
   });
 
-  // ---- 9. vertical gust structure (SPRINT2 decision 3) ----
-  // Cloth pressure goes with dot(wind, normal). A flat horizontal panel's normal
-  // points at the sky, so in a perfectly horizontal wind that dot is ~0 and the
-  // cheapest winning rig is "lie it flat and ignore the storm" — the opposite of
-  // the game. Gust fronts are descending air, and descending air hits a flat
-  // panel square on. Lane B owns the cloth-side assert; these are the wind side.
-  test('gusts carry a downdraft, and still air does not', () => {
-    const f = createWindField(storms.storm_02_wildnight);
-    let peakDown = 0, betweenMax = 0;
-    for (let t = 0; t <= f.duration; t += DT) {
-      const v = f.gustVertical(t);
-      assert(v <= 1e-12, `vertical wind went UP (${v.toFixed(2)}) at t=${t.toFixed(2)} — downdraft only`);
-      const live = f.gusts.some((g) => t > g.t0 && t < g.endAt);
-      if (live) peakDown = Math.min(peakDown, v);
-      else betweenMax = Math.max(betweenMax, Math.abs(v));
-    }
-    metrics['storm_02.peakDowndraft'] = +peakDown.toFixed(2);
-    assert(betweenMax === 0, `air is falling between gusts (${betweenMax}) — downdraft must be a gust feature`);
-    assert(peakDown < -2, `peak downdraft only ${peakDown.toFixed(2)} m/s — a flat sail would still shrug it off`);
-  });
-
-  test('downdraft tracks its own gust and its JSON fraction', () => {
+  // ---- 9. vertical structure (SPRINT3 decision 8: fraction of TOTAL) ----
+  // Cloth pressure goes with dot(wind, normal). A flat panel's normal points at
+  // the sky, so in a purely horizontal wind that dot is ~0 and "lie it flat and
+  // ignore the storm" wins — the opposite of the game. The downdraft is now a
+  // fraction of the LOCAL total wind speed (was: gust power), so a flat roof is
+  // pressed whenever it's windy, not only at gust peaks. Lane B owns the
+  // cloth-side no-free-lunch assert; these are the wind side.
+  test('downdraft is a fixed fraction of the local horizontal speed', () => {
     const def = storms.storm_02_wildnight;
     const f = createWindField(def);
-    const frac = def.gusts.downdraft;
-    for (const g of f.gusts) {
-      assert(g.down >= frac * 0.6 - 1e-9 && g.down <= frac * 1.4 + 1e-9,
-        `gust at t=${g.t0.toFixed(1)} has down=${g.down.toFixed(3)}, outside 0.6–1.4× of ${frac}`);
-      // minGap >= GUST.TOTAL means gusts never overlap, so at hold it's exactly this gust
-      const atHold = f.gustVertical(g.t0 + 3);
-      assert(Math.abs(atHold - -(g.pow * g.down)) < 1e-9,
-        `at gust hold vertical is ${atHold.toFixed(3)}, want ${(-g.pow * g.down).toFixed(3)}`);
+    const frac = def.gusts.downdraftOfTotal;
+    assert(Math.abs(f.downFrac - frac) < 1e-12, `field downFrac ${f.downFrac} != json ${frac}`);
+    const out = { x: 0, y: 0, z: 0 };
+    let peakDown = 0;
+    for (const p of PROBES) {
+      for (let t = 0; t <= f.duration; t += DT) {
+        f.vecAt(p.x, p.z, t, out);
+        const horiz = Math.hypot(out.x, out.z);
+        assert(out.y <= 1e-9, `vertical went UP (${out.y.toFixed(3)}) at t=${t.toFixed(2)} — downdraft only`);
+        // out.y must be exactly -frac * horizontal, everywhere, always
+        assert(Math.abs(out.y + frac * horiz) < 1e-9,
+          `downdraft ${out.y.toFixed(3)} != -${frac}×${horiz.toFixed(3)} at t=${t.toFixed(2)}`);
+        peakDown = Math.min(peakDown, out.y);
+      }
+    }
+    metrics['storm_02.peakDowndraft'] = +peakDown.toFixed(2);
+    // Held at downdraftOfTotal 0.15 → ~-4.9 m/s; target 0.45 → ~-14.7. Floor at
+    // -3 so this proves "a real downdraft exists" across the whole transition
+    // range without false-failing when the joint step bumps the value.
+    assert(peakDown < -3, `peak downdraft only ${peakDown.toFixed(2)} m/s — a flat sail would still shrug it off`);
+  });
+
+  test('downdraft rides the wind: present when windy, gone when calm', () => {
+    // The point of fraction-of-total: it's not a gust-only feature any more. Some
+    // sustained-wind moment between gusts must still carry a real downdraft, and a
+    // hypothetically dead-calm field must carry none.
+    const f = createWindField(storms.storm_02_wildnight);
+    let sustainedDown = 0;
+    for (let t = 0; t <= f.duration; t += DT) {
+      const inGust = f.gusts.some((g) => t > g.t0 && t < g.endAt);
+      if (!inGust) sustainedDown = Math.min(sustainedDown, f.verticalAt(0, 0, t));
+    }
+    assert(sustainedDown < -2,
+      `between gusts the downdraft peaks at only ${sustainedDown.toFixed(2)} — total-speed semantics should keep it pressing`);
+
+    // dead calm → no downdraft (guards against a constant offset sneaking in)
+    const calm = createWindField({
+      duration: 10, baseCurve: [[0, 0], [10, 0]], dirCurve: [[0, 0], [10, 0]],
+      gusts: { minGap: 6, maxGap: 6, powBase: 0, powRand: 0, powRamp: 0, downdraftOfTotal: 0.5 },
+    });
+    for (let t = 0; t <= 10; t += 0.1) {
+      assert(Math.abs(calm.verticalAt(0, 0, t)) < 1e-9, `air is falling in a dead calm at t=${t.toFixed(1)}`);
     }
   });
 
-  test('downdraft 0 gives a perfectly horizontal wind', () => {
+  test('downdraft follows the tree shadow (shelters from falling air too)', () => {
+    const def = storms.storm_02_wildnight;
+    const f = createWindField(def).setShelters([{ x: 0, z: 0, radius: 3, strength: 0.5, length: 14 }]);
+    const t = 30;
+    const d = f.dirAt(t);
+    const dx = Math.cos(d), dz = Math.sin(d);
+    const leeDown = Math.abs(f.verticalAt(dx * 5, dz * 5, t));    // downwind of the tree
+    const openDown = Math.abs(f.verticalAt(-dx * 5, -dz * 5, t)); // upwind, unsheltered
+    assert(leeDown < openDown * 0.85, `lee downdraft ${leeDown.toFixed(2)} not sheltered vs open ${openDown.toFixed(2)}`);
+  });
+
+  test('downdraftOfTotal 0 gives a perfectly horizontal wind', () => {
     const def = JSON.parse(JSON.stringify(storms.storm_02_wildnight));
-    def.gusts.downdraft = 0;
+    def.gusts.downdraftOfTotal = 0;
     const f = createWindField(def);
     const out = { x: 0, y: 0, z: 0 };
     for (let t = 0; t <= f.duration; t += 0.05) {
@@ -327,15 +358,16 @@ export function weatherCases(storms) {
   });
 
   test('downdraft does not re-time the storm', () => {
-    // The vertical draws from its own RNG stream precisely so that adding or
-    // tuning it can't shift gust times or powers. Lane A hand-drove storm_02 and
-    // watched the carabiner blow at t=45.4 and p2 cascade at t=56; a downdraft
-    // tweak silently moving those would be a nasty way to lose an afternoon.
+    // The vertical carries NO rng draws of its own now (it's a pure function of
+    // local speed), so tuning it cannot possibly shift gust times or powers. Lane
+    // A hand-drove storm_02 and watched the carabiner blow at t=45.4 and p2
+    // cascade at t=56; a downdraft tweak silently moving those would be a nasty
+    // way to lose an afternoon. Determinism is now structural, but still asserted.
     const base = storms.storm_02_wildnight;
     const a = createWindField(base);
-    for (const dd of [0, 0.1, 0.25, 0.5, 1]) {
+    for (const dd of [0, 0.1, 0.22, 0.5, 1]) {
       const d = JSON.parse(JSON.stringify(base));
-      d.gusts.downdraft = dd;
+      d.gusts.downdraftOfTotal = dd;
       const b = createWindField(d);
       assert(a.gusts.length === b.gusts.length, `downdraft ${dd} changed the gust count`);
       a.gusts.forEach((g, i) => {
@@ -343,32 +375,34 @@ export function weatherCases(storms) {
           `downdraft ${dd} moved gust ${i} from t=${g.t0.toFixed(3)} to ${b.gusts[i].t0.toFixed(3)}`);
         assert(g.pow === b.gusts[i].pow, `downdraft ${dd} changed gust ${i}'s power`);
       });
+      // and the HORIZONTAL wind must be byte-identical regardless of downdraft
+      assert(a.speedAt(3, -2, 47.3) === b.speedAt(3, -2, 47.3), `downdraft ${dd} changed the horizontal wind`);
     }
   });
 
-  test('at a gust peak the downdraft is a real fraction of the horizontal', () => {
+  test('speedAt stays horizontal — a wind meter does not read falling air', () => {
     const f = createWindField(storms.storm_02_wildnight);
     const out = { x: 0, y: 0, z: 0 };
-    let bestRatio = 0, atT = 0;
-    for (let t = 0; t <= f.duration; t += DT) {
-      f.vecAt(0, 0, t, out);
-      const horiz = Math.hypot(out.x, out.z);
-      if (horiz < 1) continue;
-      const r = Math.abs(out.y) / horiz;
-      if (r > bestRatio) { bestRatio = r; atT = t; }
+    for (const p of PROBES) {
+      for (const t of [12, 40, 60, 75.3]) {
+        f.vecAt(p.x, p.z, t, out);
+        assert(Math.abs(f.speedAt(p.x, p.z, t) - Math.hypot(out.x, out.z)) < 1e-9,
+          `speedAt != horizontal magnitude of sample at t=${t}`);
+      }
     }
-    metrics['storm_02.peakVerticalRatio'] = +bestRatio.toFixed(3);
-    assert(bestRatio > 0.12,
-      `strongest downdraft is only ${(bestRatio * 100).toFixed(0)}% of the horizontal wind (t=${atT.toFixed(1)}) — a flat sail still shrugs`);
   });
 
-  test('validator rejects a bad downdraft', () => {
+  test('validator rejects a bad downdraft and the renamed field', () => {
     for (const dd of [-0.1, 1.5, NaN, 'lots']) {
       const d = JSON.parse(JSON.stringify(storms.storm_02_wildnight));
-      d.gusts.downdraft = dd;
-      const { ok } = validateStorm(d, 'broken');
-      assert(!ok, `validator ACCEPTED downdraft = ${dd}`);
+      d.gusts.downdraftOfTotal = dd;
+      assert(!validateStorm(d, 'broken').ok, `validator ACCEPTED downdraftOfTotal = ${dd}`);
     }
+    // the old gust-only field must be rejected, not silently re-meant
+    const legacy = JSON.parse(JSON.stringify(storms.storm_02_wildnight));
+    delete legacy.gusts.downdraftOfTotal;
+    legacy.gusts.downdraft = 0.3;
+    assert(!validateStorm(legacy, 'legacy').ok, 'validator silently accepted the pre-SPRINT3 downdraft field');
   });
 
   return { cases, metrics };

web/world/js/weather.core.js

@@ -130,29 +130,19 @@ function sampleAngleCurve(curve, t) {
 
 // ---------- gust timeline ----------
 // Prototype: pow = 12 + rand*16 + 10*p, next = t + 5 + rand*7. Same shape, from JSON.
-export const DEFAULT_DOWNDRAFT = 0.25;
+export const DEFAULT_DOWNDRAFT = 0.22;
 
 export function buildGustTimeline(def, seed) {
   const g = def.gusts || {};
   const rng = mulberry32(seed >>> 0);
-  // Vertical draws from its OWN stream, deliberately. Pulling it from `rng`
-  // would shift every subsequent (t0, pow) and silently re-time storms that are
-  // already tuned and hand-verified — A drove storm_02 and watched the carabiner
-  // blow at t=45.4 and cascade at t=56, one second after the change. Adding a
-  // downdraft shouldn't move that.
-  const rngV = mulberry32((seed ^ 0x0d0117) >>> 0);
   const minGap = g.minGap ?? 5, maxGap = g.maxGap ?? 12;
-  const downFrac = g.downdraft ?? DEFAULT_DOWNDRAFT;
   const out = [];
   let t = g.firstAt ?? 3;
   // hard cap: a malformed gap can't spin us forever
   while (t < def.duration && out.length < 512) {
     const p = def.duration > 0 ? t / def.duration : 0;
     const pow = (g.powBase ?? 12) + rng() * (g.powRand ?? 16) + (g.powRamp ?? 10) * p;
-    // Not every gust slams down the same: some roll through nearly flat, some
-    // are a proper little downburst. 0.6–1.4× the storm's fraction.
-    const down = downFrac * (0.6 + rngV() * 0.8);
-    out.push({ t0: t, pow, down, rampAt: t + GUST.TELEGRAPH, endAt: t + GUST.TOTAL });
+    out.push({ t0: t, pow, rampAt: t + GUST.TELEGRAPH, endAt: t + GUST.TOTAL });
     t += minGap + rng() * Math.max(0, maxGap - minGap);
   }
   return out;
@@ -174,6 +164,11 @@ export function createWindField(def, opts = {}) {
   const wander = def.dirWander || {};
   const wAmp = wander.amp ?? 0.25, wRate = wander.rate ?? 0.13;
   const nSeed = (seed ^ 0x9e3779b9) | 0;
+  // SPRINT3 decision 8: the downdraft is a fraction of TOTAL wind speed, not of
+  // gust power. `downdraftOfTotal` is the field name; `downdraft` is read as a
+  // legacy alias so an un-migrated storm doesn't silently lose its vertical.
+  const gd = def.gusts || {};
+  const downFrac = gd.downdraftOfTotal ?? gd.downdraft ?? DEFAULT_DOWNDRAFT;
 
   let shelters = [];
 
@@ -202,24 +197,37 @@ export function createWindField(def, opts = {}) {
     return sampleAngleCurve(def.dirCurve, t) + wAmp * Math.sin(t * wRate);
   }
 
+  /** Local horizontal wind speed (m/s) — base+gusts, spatial noise, tree shadow.
+   *  The one place the local-speed maths lives; speedAt/vecAt/verticalAt share it. */
+  function localHoriz(x, z, t) {
+    const uni = uniformSpeed(t);
+    const d = dirAt(t);
+    const s = uni * spatialFactor(x, z, t) * shelterFactor(x, z, Math.cos(d), Math.sin(d));
+    return s > 0 ? s : 0;
+  }
+
   /**
-   * Vertical wind, m/s. NEGATIVE = downward. Zero between gusts.
+   * Vertical wind, m/s. NEGATIVE = downward. A fraction of the LOCAL horizontal
+   * speed at this point and time.
    *
-   * A gust front is descending air, not just faster air. Without this the field
-   * is perfectly horizontal, and a horizontal sail is a free lunch: cloth
-   * pressure goes with dot(wind, normal), a flat panel's normal points at the
-   * sky, and the dot product is ~0 no matter how hard it blows. So the cheapest
-   * winning rig was "lie it flat and ignore the storm", which is the opposite of
-   * the game (SPRINT2 decision 3). A downdraft hits a flat panel square on.
+   * Why a horizontal sail must pay: cloth pressure goes with dot(wind, normal),
+   * a flat panel's normal points at the sky, so in a purely horizontal wind the
+   * dot is ~0 and "lie it flat and ignore the storm" wins — the opposite of the
+   * game. A descending component hits a flat panel square on.
+   *
+   * SPRINT3 decision 8 — fraction of TOTAL, not of gust power. Under gust-only
+   * semantics the downdraft peaked exactly at the gust peak, where the horizontal
+   * ALSO peaked, so a flat sail could never reach 60% of a pitched one's load
+   * (B measured 34%) without a downdraft so violent it also killed the twisted
+   * rig the §7 gate needs to survive. The two gates pincered. Riding total speed
+   * instead spreads the load across the whole storm: a flat roof is pressed
+   * steadily (peak total 32.6 m/s dwarfs peak gust power 12.6), so the ratio
+   * clears 60% at a gentle fraction, without a spike at the gust peak. It follows
+   * the LOCAL speed, so a tree's wind shadow shelters from falling air too.
    */
-  function gustVertical(t) {
-    let v = 0;
-    for (let i = 0; i < gusts.length; i++) {
-      const g = gusts[i];
-      if (t <= g.t0) break;              // sorted — nothing later is live
-      if (t < g.endAt) v -= gustEnvelope(t - g.t0, g.pow) * g.down;
-    }
-    return v;
+  function verticalAt(x, z, t) {
+    if (downFrac <= 0) return 0;
+    return -downFrac * localHoriz(x, z, t);
   }
 
   // ---- noise drift ----
@@ -318,27 +326,22 @@ export function createWindField(def, opts = {}) {
      * The cheap path — no allocation.
      */
     speedAt(x, z, t) {
-      const uni = uniformSpeed(t);
-      const d = dirAt(t);
-      const s = uni * spatialFactor(x, z, t) * shelterFactor(x, z, Math.cos(d), Math.sin(d));
-      return s > 0 ? s : 0;
+      return localHoriz(x, z, t);
     },
 
     dirAt,
     uniformSpeed,
     gustOnly,
-    gustVertical,
+    verticalAt,
+    get downFrac() { return downFrac; },
 
     /** Writes wind velocity (m/s) into out {x,y,z}. Ground plane is XZ, +Y up. */
     vecAt(x, z, t, out) {
-      const uni = uniformSpeed(t);
       const d = dirAt(t);
       const dirX = Math.cos(d), dirZ = Math.sin(d);
-      const m = spatialFactor(x, z, t) * shelterFactor(x, z, dirX, dirZ);
-      let s = uni * m;
-      if (s < 0) s = 0;
+      const s = localHoriz(x, z, t);
       out.x = dirX * s;
-      out.y = gustVertical(t) * m;     // gust fronts descend — see gustVertical()
+      out.y = -downFrac * s;           // the downdraft rides the local speed — see verticalAt()
       out.z = dirZ * s;
       return out;
     },
@@ -415,9 +418,14 @@ export function validateStorm(def, name = 'storm') {
     // Overlapping gusts stack, and a stacked telegraph is unreadable to the player.
     if (minGap < GUST.TOTAL) bad(`gusts.minGap (${minGap}) < gust length ${GUST.TOTAL}s — gusts would overlap`);
     if ((g.powBase ?? 12) < 0) bad('gusts.powBase must be >= 0');
-    const dd = g.downdraft ?? DEFAULT_DOWNDRAFT;
+    // `downdraft` (gust-only, pre-SPRINT3) is still accepted but flagged, so an
+    // un-migrated storm loads visibly wrong rather than silently at a third power.
+    if (g.downdraft != null && g.downdraftOfTotal == null) {
+      bad('gusts.downdraft is the old gust-only field — rename to downdraftOfTotal (SPRINT3 decision 8); it now means a fraction of TOTAL wind speed');
+    }
+    const dd = g.downdraftOfTotal ?? g.downdraft ?? DEFAULT_DOWNDRAFT;
     if (!Number.isFinite(dd) || dd < 0 || dd > 1) {
-      bad(`gusts.downdraft must be 0..1 — the fraction of gust power that blows DOWN — got ${dd}`);
+      bad(`gusts.downdraftOfTotal must be 0..1 — the fraction of TOTAL wind speed that blows DOWN — got ${dd}`);
     }
   }
 

web/world/js/world.js

@@ -35,6 +35,16 @@ export function heightAt(x, z) {
 
 const GARDEN_BED = { x: 1, z: 2, w: 6, d: 4 };
 
+// Shed on the east side, table out in front of it. Lane D tested reachability
+// against (9, 6), so the table stays there and the shed tucks in behind.
+const SHED = { x: 11.8, z: 6.2, rotY: -Math.PI / 2 };
+const SHED_TABLE = { x: 9, z: 6, rotY: -Math.PI / 2 };
+
+// Lane E's house_yardside GLB is a 9.2 x 2.9 x 1.05 m façade whose fascia
+// anchors sit at local z = +0.55, so placing it here lands them on z = -9.95 —
+// the same line the graybox taught everyone to expect.
+const HOUSE = { x: 0, z: -10.5 };
+
 // 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;
@@ -84,6 +94,8 @@ export function createWorld(scene, opts = {}) {
   const anchors = [];
   /** @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() };
 
   // --- sky & light -------------------------------------------------------
   // Calm-day only. Lane C's skyfx.js takes over the sky and this becomes the
@@ -169,6 +181,7 @@ export function createWorld(scene, opts = {}) {
 
   root.add(house);
   solids.push(wall, roof);
+  graybox.house = house;
 
   for (const [i, x] of [-5, 0, 5].entries()) {
     anchors.push(makeStaticAnchor(`h${i + 1}`, 'house', new THREE.Vector3(x, 2.6, -9.9)));
@@ -217,6 +230,7 @@ export function createWorld(scene, opts = {}) {
     canopies.push({ group: canopy, phase: spec.phase, base: canopy.rotation.clone() });
 
     root.add(tree);
+    graybox.trees.set(spec.id, tree);
 
     // The anchor is at a branch fork, not the canopy centre.
     anchors.push(makeSwayAnchor(
@@ -231,9 +245,24 @@ export function createWorld(scene, opts = {}) {
   // Raked away from the yard centre, because that is the correct practice and
   // the shape should teach it before any text does (DESIGN.md: "rake the post
   // away from the load").
+  // SPRINT3 decision 2: posts pulled in off the fence and a third added.
+  //
+  // The old pair sat at (-6, 7) and (5, 7.5), which put every rigging option in
+  // the 70–192 m² range Lane B flagged — a sail that big pre-tensions itself
+  // into a cascade at t=0.4 s before the wind has done anything, so the yard was
+  // teaching the wrong lesson. Pulled in, plus p3, the same yard now offers 31
+  // quads in the 18–45 m² band (8 of which shade a quarter of the bed or more).
+  //
+  // Worth knowing before anyone "fixes" it: the smallest quad that covers the
+  // bed COMPLETELY is 59 m², and that is not a bug to tune away. The bed sits
+  // 10 m off the house, so any house-to-post sail is ~16 m long, and covering a
+  // 6 m bed with it costs you a sail the storm will take. Full shade is meant to
+  // be the expensive answer; the small quads buy survival and pay in patchy
+  // shade. That IS the design (DESIGN.md, "big flat low vs small twisted steep").
   const postSpecs = [
-    { id: 'p1', x: -6, z: 7, h: 4.0 },
-    { id: 'p2', x: 5, z: 7.5, h: 4.0 },
+    { id: 'p1', x: -4.5, z: 5.5, h: 4.0 },
+    { id: 'p2', x: 4.0, z: 6.0, h: 4.0 },
+    { id: 'p3', x: 0, z: 7.0, h: 4.0 },
   ];
   const RAKE = (8 * Math.PI) / 180;
   for (const spec of postSpecs) {
@@ -335,6 +364,159 @@ export function createWorld(scene, opts = {}) {
   root.add(fence);
   solids.push(fence);
 
+  // --- shed & spare table ------------------------------------------------
+  // Where the spare hardware lives, which makes it where the §7 scenario
+  // starts: rig → carry a spare → repair mid-storm. Lane D's pickup radius is
+  // 1.5 m off this point and everything downstream of it is already wired, so
+  // this small thing gates the whole hand-played loop.
+  //
+  // The position is published SYNCHRONOUSLY, from constants, even though the
+  // meshes arrive later in dress(). createWorld() has to stay sync — a.test.js
+  // and the selftest build a yard without a server — and Lane D's
+  // wireYardActions reads world.shedTable at wiring time. dress() refines the
+  // point to Lane E's baked `pickup_anchor` if it's there.
+  const shedTable = {
+    pos: new THREE.Vector3(SHED_TABLE.x, heightAt(SHED_TABLE.x, SHED_TABLE.z) + 0.9, SHED_TABLE.z),
+  };
+
+  /**
+   * 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
+   * fetch in the constructor would either break it or make it slow and flaky.
+   * Every load is individually guarded — a missing GLB leaves its graybox
+   * standing rather than taking the boot down with it.
+   */
+  async function dress() {
+    const { GLTFLoader } = await import('../vendor/addons/loaders/GLTFLoader.js');
+    const loader = new GLTFLoader();
+
+    /** Take a graybox stand-in out of the scene AND out of `solids`. */
+    const retire = (obj) => {
+      if (!obj) return;
+      obj.traverse((o) => {
+        const i = solids.indexOf(o);
+        if (i >= 0) solids.splice(i, 1);
+        o.geometry?.dispose();
+      });
+      const i = solids.indexOf(obj);
+      if (i >= 0) solids.splice(i, 1);
+      obj.parent?.remove(obj);
+    };
+
+    /**
+     * Move an existing anchor onto the position Lane E baked, and take their
+     * rating_hint with it. Mutates `pos` in place rather than reassigning it:
+     * `interact.register` and Lane B's corners capture these vectors by
+     * reference, and a reassign would leave them holding a stale one.
+     */
+    const adoptAnchor = (glb, nodeName, anchorId) => {
+      const node = glb.getObjectByName(nodeName);
+      const anchor = anchors.find((a) => a.id === anchorId);
+      if (!node || !anchor) return false;
+      anchor.pos.setFromMatrixPosition(node.matrixWorld);
+      anchor.ratingHint = node.userData?.rating_hint ?? 1;
+      anchor.collateral = node.userData?.collateral ?? null;
+      return true;
+    };
+
+    const load = async (name) => {
+      try {
+        const gltf = await loader.loadAsync(new URL(`../models/${name}.glb`, import.meta.url).href);
+        gltf.scene.traverse((o) => {
+          if (o.isMesh) { o.castShadow = true; o.receiveShadow = true; }
+        });
+        return gltf.scene;
+      } catch (err) {
+        console.warn(`[world] ${name} unavailable, keeping graybox:`, err.message);
+        return null;
+      }
+    };
+
+    const [shed, table, houseGlb, tree1, tree2] = 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'),
+    ]);
+
+    // --- 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
+    // 4 m, which is a real part of why the yard now offers small quads at all.
+    // Every fascia anchor carries rating_hint 0.35 — E encoded DESIGN.md's
+    // "the fascia board is a lie" straight into the asset, and `collateral:
+    // "gutter"` says what it takes with it when it goes.
+    if (houseGlb) {
+      retire(graybox.house);
+      houseGlb.name = 'house_yardside';
+      houseGlb.position.set(HOUSE.x, heightAt(HOUSE.x, HOUSE.z), HOUSE.z);
+      root.add(houseGlb);
+      solids.push(houseGlb);
+      houseGlb.updateWorldMatrix(true, true);
+      for (const [i, id] of ['h1', 'h2', 'h3'].entries()) {
+        adoptAnchor(houseGlb, `fascia_anchor_0${i + 1}`, id);
+      }
+    }
+
+    // --- trees -----------------------------------------------------------
+    // Each tree ships 2-3 branch anchors with descending rating_hint (1.0 at
+    // the fork, 0.76 out where the limb is thin) — the intel DESIGN.md wants
+    // inspection to buy. branch_anchor_01 keeps the original t1/t2 id so
+    // nothing that already references them breaks; the rest are added.
+    for (const [glb, spec] of [[tree1, treeSpecs[0]], [tree2, treeSpecs[1]]]) {
+      if (!glb) continue;
+      const old = graybox.trees.get(spec.id);
+      retire(old);
+      // The graybox canopy was what world.update() swayed — hand that job over.
+      const idx = canopies.findIndex((c) => old && old.getObjectByName('canopy') === c.group);
+      if (idx >= 0) canopies.splice(idx, 1);
+
+      glb.name = `tree_${spec.id}`;
+      glb.position.set(spec.x, heightAt(spec.x, spec.z), spec.z);
+      root.add(glb);
+      const trunk = glb.getObjectByName('trunk');
+      if (trunk) solids.push(trunk);
+      const canopy = glb.getObjectByName('canopy_01') || glb.getObjectByName('canopy');
+      if (canopy?.parent) {
+        canopies.push({ group: canopy.parent, phase: spec.phase, base: canopy.parent.rotation.clone() });
+      }
+
+      glb.updateWorldMatrix(true, true);
+      const suffix = ['', 'b', 'c'];
+      for (let i = 1; i <= 3; i++) {
+        const node = glb.getObjectByName(`branch_anchor_0${i}`);
+        if (!node) continue;
+        const id = spec.id + suffix[i - 1];
+        if (i === 1) adoptAnchor(glb, `branch_anchor_01`, id);
+        else {
+          const p = new THREE.Vector3().setFromMatrixPosition(node.matrixWorld);
+          const a = makeSwayAnchor(id, p, spec.phase, wind);
+          a.ratingHint = node.userData?.rating_hint ?? 1;
+          anchors.push(a);
+        }
+      }
+    }
+
+    if (shed) {
+      shed.name = 'shed_01';
+      shed.position.set(SHED.x, heightAt(SHED.x, SHED.z), SHED.z);
+      shed.rotation.y = SHED.rotY;
+      root.add(shed);
+      solids.push(shed);
+    }
+    if (table) {
+      table.name = 'shed_table';
+      table.position.set(SHED_TABLE.x, heightAt(SHED_TABLE.x, SHED_TABLE.z), SHED_TABLE.z);
+      table.rotation.y = SHED_TABLE.rotY;
+      root.add(table);
+      // NOT in solids: you want to walk up to the table, not be fenced off it.
+
+      // Prefer Lane E's baked anchor over my guess at where a table top is.
+      table.updateWorldMatrix(true, true);
+      const anchor = table.getObjectByName('pickup_anchor');
+      if (anchor) shedTable.pos.setFromMatrixPosition(anchor.matrixWorld);
+    }
+    return { shed, table };
+  }
+
   // --- the world object --------------------------------------------------
   return {
     anchors,
@@ -343,6 +525,13 @@ export function createWorld(scene, opts = {}) {
     sunDir: SUN_DIR.clone(),
     solids,
     root,
+    /**
+     * Where a spare gets picked up. `{pos}` — Lane D registers a 1.5 m hold-E
+     * off this point. Present from construction; dress() may nudge it onto
+     * Lane E's `pickup_anchor`.
+     */
+    shedTable,
+    dress,
     // 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.

web/world/weather_demo.html

@@ -1,263 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<title>SHADES — Lane C — weather bench</title>
-<style>
-:root { --ink:#d8d8e0; --gold:#ffd23d; --neon:#3dff8b; }
-* { box-sizing:border-box; }
-body { margin:0; overflow:hidden; background:#000;
-  font:13px/1.45 "Courier New", ui-monospace, monospace; color:var(--ink); }
-canvas { display:block; }
-#hud { position:fixed; top:10px; left:10px; background:rgba(6,6,12,.75); padding:8px 12px;
-  border:1px solid #26263a; z-index:3; min-width:250px; }
-#hud b { color:var(--gold); }
-#hud .warn { color:#ff6; font-weight:bold; }
-#hud .bad { color:#f66; font-weight:bold; }
-#ctl { position:fixed; bottom:10px; left:10px; background:rgba(6,6,12,.8); padding:8px 12px;
-  border:1px solid #26263a; z-index:3; }
-#ctl button { background:#1d1d2b; color:var(--ink); border:1px solid #666; font:inherit;
-  padding:4px 9px; cursor:pointer; }
-#ctl button:hover { border-color:var(--neon); color:var(--neon); }
-#ctl input[type=range] { width:220px; vertical-align:middle; }
-#note { position:fixed; top:10px; right:10px; background:rgba(6,6,12,.75); padding:8px 12px;
-  border:1px solid #26263a; z-index:3; max-width:280px; color:#8a8a99; }
-.bar { display:inline-block; width:90px; height:7px; border:1px solid #555; vertical-align:middle; }
-.bar i { display:block; height:100%; background:var(--neon); }
-</style>
-</head>
-<body>
-<canvas id="c"></canvas>
-<div id="hud"></div>
-<div id="note">
-  <b>Lane C bench.</b> Graybox stand-in for Lane A's yard — this exists to drive
-  weather.js / skyfx.js / debris.js before M0 lands. The sail here is a MOCK
-  (Lane B owns the real one); it's a bare node grid so debris impulse is visible.
-  <br><br>drag = orbit · click = start audio
-</div>
-<div id="ctl"></div>
-
-<script type="module">
-import * as THREE from './vendor/three.module.js';
-import { loadStorm, createWind } from './js/weather.js';
-import { createSkyFx } from './js/skyfx.js';
-import { createDebris } from './js/debris.js';
-
-const canvas = document.getElementById('c');
-const renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
-renderer.setPixelRatio(Math.min(2, devicePixelRatio));
-renderer.shadowMap.enabled = true;
-const scene = new THREE.Scene();
-scene.background = new THREE.Color(0x9fc4e8);
-const camera = new THREE.PerspectiveCamera(55, 1, 0.1, 500);
-
-// --- graybox yard: 30×20 m, origin centre (stands in for Lane A's world.js) ---
-const ground = new THREE.Mesh(
-  new THREE.PlaneGeometry(30, 20),
-  new THREE.MeshStandardMaterial({ color: 0x4a7c3f, roughness: 1 }),
-);
-ground.rotation.x = -Math.PI / 2;
-ground.receiveShadow = true;
-scene.add(ground);
-
-// Lane A's landed yard (THREADS): t1 (-9,2), t2 (8,-2), house edge at z=-9.9
-const TREES = [{ x: -9, z: 2 }, { x: 8, z: -2 }];
-for (const tr of TREES) {
-  const trunk = new THREE.Mesh(
-    new THREE.CylinderGeometry(0.2, 0.28, 4, 8),
-    new THREE.MeshStandardMaterial({ color: 0x5a3d24 }),
-  );
-  trunk.position.set(tr.x, 2, tr.z);
-  trunk.castShadow = true;
-  scene.add(trunk);
-  const canopy = new THREE.Mesh(
-    new THREE.SphereGeometry(3, 12, 8),
-    new THREE.MeshStandardMaterial({ color: 0x285f23 }),
-  );
-  canopy.position.set(tr.x, 5, tr.z);
-  canopy.castShadow = true;
-  scene.add(canopy);
-}
-// house edge along north (-Z), for scale
-const house = new THREE.Mesh(
-  new THREE.BoxGeometry(30, 3.2, 1),
-  new THREE.MeshStandardMaterial({ color: 0x8a8f96 }),
-);
-house.position.set(0, 1.6, -10.4);
-scene.add(house);
-// the thing you're protecting — Lane A's gardenBed rect
-const bed = new THREE.Mesh(
-  new THREE.BoxGeometry(6, 0.25, 4),
-  new THREE.MeshStandardMaterial({ color: 0x6b4a2f }),
-);
-bed.position.set(1, 0.12, 2);
-scene.add(bed);
-// 1.7 m reference person
-const ref = new THREE.Mesh(
-  new THREE.CapsuleGeometry(0.25, 1.2, 4, 8),
-  new THREE.MeshStandardMaterial({ color: 0xffd27a }),
-);
-ref.position.set(2, 0.85, 2);
-ref.castShadow = true;
-scene.add(ref);
-const player = { pos: ref.position, carrying: null, busy: false };
-
-const sun = new THREE.DirectionalLight(0xfff4e0, 2.2);
-sun.position.set(-12, 18, 6);
-sun.castShadow = true;
-sun.shadow.mapSize.set(1024, 1024);
-scene.add(sun);
-const hemi = new THREE.HemisphereLight(0xbfd8ff, 0x3a4a2a, 0.9);
-scene.add(hemi);
-
-// --- MOCK sail (Lane B owns the real cloth) — a bare node grid so we can see
-// debris shove it and drive the creak/flog audio off corner loads.
-const N = 9;
-const nodes = [];
-for (let v = 0; v < N; v++) {
-  for (let u = 0; u < N; u++) {
-    nodes.push({ x: -4 + (u / (N - 1)) * 8, y: 3.2, z: -3 + (v / (N - 1)) * 6 });
-  }
-}
-const sailGeo = new THREE.BufferGeometry();
-sailGeo.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(nodes.length * 3), 3));
-const sailPts = new THREE.Points(sailGeo, new THREE.PointsMaterial({ color: 0xe8c46a, size: 0.14 }));
-scene.add(sailPts);
-const mockSail = {
-  nodes,
-  corners: [
-    { anchorId: 'h1', hw: { name: 'carabiner', rating: 9 }, load: 0, broken: false },
-    { anchorId: 'h3', hw: { name: 'shackle', rating: 19 }, load: 0, broken: false },
-    { anchorId: 'p1', hw: { name: 'shackle', rating: 19 }, load: 0, broken: false },
-    { anchorId: 'p2', hw: { name: 'carabiner', rating: 9 }, load: 0, broken: false },
-  ],
-};
-
-// --- weather ---
-const params = new URLSearchParams(location.search);
-const stormName = params.get('storm') || 'storm_02_wildnight';
-const def = await loadStorm(stormName);
-const wind = createWind(def);
-wind.setShelters(TREES.map((t) => ({ x: t.x, z: t.z, radius: 3, strength: 0.45, length: 14 })));
-
-const ticker = [];
-const sky = createSkyFx({ scene, camera, wind, sun, hemi, onEvent: (s) => ticker.unshift(s) });
-const debris = createDebris({
-  wind, scene, player,
-  onEvent: (s) => ticker.unshift(s),
-  onHitPlayer: (p, impact) => ticker.unshift(`KNOCKED DOWN by ${p.model} (${impact.toFixed(0)})`),
-});
-addEventListener('pointerdown', () => sky.unlockAudio(), { once: true });
-
-// --- controls ---
-let t = 0, playing = true, rate = 1;
-const ctl = document.getElementById('ctl');
-ctl.innerHTML = `
-  <button id="play">pause</button>
-  <button id="r1">1×</button><button id="r4">4×</button><button id="r0">0.25×</button>
-  <button id="reset">reset</button>
-  <button id="break">break a corner</button>
-  <button id="crate">throw a crate</button>
-  <input id="scrub" type="range" min="0" max="${def.duration}" step="0.1" value="0">
-`;
-const $ = (id) => document.getElementById(id);
-$('play').onclick = () => { playing = !playing; $('play').textContent = playing ? 'pause' : 'play'; };
-$('r1').onclick = () => { rate = 1; };
-$('r4').onclick = () => { rate = 4; };
-$('r0').onclick = () => { rate = 0.25; };
-$('reset').onclick = () => { t = 0; debris.clear(); ticker.length = 0; mockSail.corners.forEach((c) => { c.broken = false; }); };
-$('break').onclick = () => { const c = mockSail.corners.find((x) => !x.broken); if (c) { c.broken = true; ticker.unshift(`${c.hw.name} BLOWS at ${c.anchorId.toUpperCase()}!`); } };
-$('crate').onclick = () => debris.spawn({ model: 'BlueCrate_v2', lateral: (Math.random() * 6 - 3), text: 'crate!' }, t);
-$('scrub').oninput = (e) => { t = parseFloat(e.target.value); debris.clear(); };
-
-let yaw = 0.7, pitch = 0.28, dist = 26, dragging = false, lx = 0, ly = 0;
-addEventListener('pointerdown', (e) => { dragging = true; lx = e.clientX; ly = e.clientY; });
-addEventListener('pointerup', () => { dragging = false; });
-addEventListener('pointermove', (e) => {
-  if (!dragging) return;
-  yaw -= (e.clientX - lx) * 0.005; pitch = Math.min(1.3, Math.max(0.05, pitch + (e.clientY - ly) * 0.004));
-  lx = e.clientX; ly = e.clientY;
-});
-addEventListener('wheel', (e) => { dist = Math.min(60, Math.max(8, dist + e.deltaY * 0.02)); });
-
-function resize() {
-  const w = innerWidth, h = innerHeight;
-  renderer.setSize(w, h);
-  camera.aspect = w / h;
-  camera.updateProjectionMatrix();
-}
-addEventListener('resize', resize); resize();
-
-// --- loop: fixed-dt sim, rAF only drives the clock (PLAN3D §0) ---
-const DT = 1 / 60;
-let acc = 0, last = performance.now();
-const hud = document.getElementById('hud');
-const probe = new THREE.Vector3();
-const w = new THREE.Vector3();
-const posAttr = sailGeo.getAttribute('position');
-
-function frame(now) {
-  const real = Math.min(0.1, (now - last) / 1000);
-  last = now;
-  if (playing) acc += real * rate;
-
-  while (acc >= DT) {
-    acc -= DT;
-    t += DT;
-    if (t > def.duration) t = 0;
-
-    // mock cloth: nodes just bob with local wind so debris has something to hit
-    for (const n of nodes) {
-      probe.set(n.x, n.y, n.z);
-      wind.sample(probe, t, w);
-      const sp = Math.hypot(w.x, w.z);
-      n.y += ((3.2 + Math.sin(t * 3 + n.x) * sp * 0.02) - n.y) * 0.08;
-    }
-    // mock loads so the creak layer has something to track
-    probe.set(0, 3.2, 0);
-    const sp = wind.speedAt(probe, t);
-    mockSail.corners.forEach((c, i) => {
-      c.load = c.broken ? 0 : sp * sp * 0.021 * (0.7 + i * 0.16);
-    });
-
-    debris.step(DT, t, { player, sail: mockSail });
-    sky.step(DT, t, { sail: mockSail });
-  }
-
-  for (let i = 0; i < nodes.length; i++) posAttr.setXYZ(i, nodes[i].x, nodes[i].y, nodes[i].z);
-  posAttr.needsUpdate = true;
-
-  camera.position.set(
-    Math.sin(yaw) * Math.cos(pitch) * dist,
-    Math.sin(pitch) * dist + 1.5,
-    Math.cos(yaw) * Math.cos(pitch) * dist,
-  );
-  camera.lookAt(0, 2, 0);
-
-  $('scrub').value = t.toFixed(1);
-  probe.set(0, 1.7, 0);
-  wind.sample(probe, t, w);
-  const speed = Math.hypot(w.x, w.z);
-  const tg = wind.gustTelegraph(t);
-  const worst = Math.max(...mockSail.corners.map((c) => (c.broken ? 0 : c.load / c.hw.rating)));
-  hud.innerHTML = `
-    <div><b>${def.name}</b> — ${stormName}</div>
-    <div>t        <b>${t.toFixed(1)}</b> / ${def.duration}s  (${rate}×)</div>
-    <div>wind     <b>${speed.toFixed(1)}</b> m/s (${(speed * 3.6).toFixed(0)} km/h)</div>
-    <div>dir      ${(wind.dirAt(t)).toFixed(2)} rad</div>
-    <div>rain     <span class="bar"><i style="width:${wind.rainAt(t) * 100}%"></i></span></div>
-    <div>worst    <span class="bar"><i style="width:${Math.min(100, worst * 100)}%;background:${worst > 0.8 ? '#f66' : '#3dff8b'}"></i></span></div>
-    <div>debris   ${debris.pieces.length}   audio ${sky.audio.ready ? sky.audio.state : '(click)'}</div>
-    <div>flash    ${sky.flash.toFixed(2)}</div>
-    ${tg ? `<div class="warn">GUST INBOUND ${tg.eta.toFixed(1)}s  pow ${tg.power.toFixed(0)}</div>` : '<div>&nbsp;</div>'}
-    ${ticker.slice(0, 3).map((s) => `<div class="bad">${s}</div>`).join('')}
-  `;
-
-  renderer.render(scene, camera);
-  requestAnimationFrame(frame);
-}
-requestAnimationFrame(frame);
-window.__bench = { wind, sky, debris, mockSail, def, get t() { return t; } };
-</script>
-</body>
-</html>