THREADS: SPRINT10 Lane B — answer C (porosity wired+proven), flag dress-source site JSON to A, tree offer to E

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

LANE_PROMPTS.md

@@ -523,3 +523,48 @@ THREADS' last [I] entry then SPRINT9.md.
 > carport — anchor-poor on purpose; its personality is "nowhere to tie off".
 > Deterministic factory, contact sheet, and pyrrhic-ending card support when
 > A rules.
+
+---
+---
+
+# SPRINT 10 prompts (sites are data)
+
+Same rules: own clone, own branch, rebase onto latest main FIRST. Read
+THREADS' last [I] entry then SPRINT10.md. Gate 1 is A's, uninterrupted —
+everyone else's site work is already on disk waiting for it.
+
+## Lane A — Sprint 10
+> You are Lane A on SHADES 3D, Sprint 10. Rebase onto main, read SPRINT10.md.
+> ONE headline, from day one: extract the yard into data/sites/backyard_01.json
+> (world.js builds from data; byte-identical yard proven by the existing
+> anchor tripwires and quad-band asserts), then author site_02_corner_block
+> from the pieces already waiting (E's carport GLB, C's venturi schema — give
+> C their two gap coordinates, D's work:"cloth"|"bracket" anchor field). The
+> week gains a site per night; night 3 moves to the corner block. Nothing
+> else until this lands.
+
+## Lane B — Sprint 10
+> You are Lane B on SHADES 3D, Sprint 10. Rebase onto main, read SPRINT10.md.
+> Build tools/site_audit/ from your quad/coverage/afford sweep — one command,
+> any site JSON, reports the winnable lines or names the blocking corner.
+> Run it on site_02 the moment A's JSON exists; if there's no $80 line, tell
+> E to move the tree (their standing offer). Answer C's porosity-into-
+> gardenHailExposure question in THREADS.
+
+## Lane C — Sprint 10
+> You are Lane C on SHADES 3D, Sprint 10. Rebase onto main, read SPRINT10.md.
+> Wire venturi from A's site JSON when it lands; decide the week's storm/site
+> pairing so the corner block teaches the venturi (southerly on night 3?);
+> land the porosity/gardenHailExposure one-liner if B says yes.
+
+## Lane D — Sprint 10
+> You are Lane D on SHADES 3D, Sprint 10. Rebase onto main, read SPRINT10.md.
+> Land needsLadder on A's work-field (mechanism, not type — your own audit),
+> then play site_02 cold and log feel notes. The carport traps should read
+> tempting, not buggy.
+
+## Lane E — Sprint 10
+> You are Lane E on SHADES 3D, Sprint 10. Rebase onto main, read SPRINT10.md.
+> Support site_02 as it lands: dressing adjustments, contact sheets, and a
+> carport-collateral aftermath line/card if the trap earns one. If B's audit
+> says the site has no winnable line, moving the tree is yours.

SPRINT10.md

@@ -0,0 +1,62 @@
+# SPRINT 10 — SITES ARE DATA (instructions for Opus 4.8 lanes)
+
+*Sprint 9 closed the balance book: the wild night has a CLEAN $80 win (porous
+cloth · dd 0.40 · the four-post quad), fabric is a real choice that decides
+one corner's life, the pyrrhic ending has a rule, a verdict and a card, and
+the settled-at-entry guard finally measures the thing the words mean — with a
+proof that it can fail. Three retractions were filed this sprint, all
+graceful, all measured. The engineering culture is the co-star now.*
+
+*What did NOT land, for the second sprint running, is A's site extraction —
+the week ate Sprint 8, the pyrrhic ruling ate Sprint 9. Every other lane's
+site work is DONE and waiting: E's carport trap, C's venturi, D's ladder-seam
+spec, B's audit sweep. Sprint 10 has one headline and it's A's, uninterrupted.*
+
+Read THREADS from the last [I] entry.
+
+## Gate 1 — SITE EXTRACTION (A, from day one, nothing else first)
+
+`data/sites/backyard_01.json`: anchors, bed, house line, trees, posts, shed,
+gnome, dressing list — world.js BUILDS FROM DATA, byte-identical yard as the
+assert of success (E's tripwires already pin the anchor positions; a.test's
+quad-band asserts must pass unchanged). Then `site_02_corner_block.json`:
+E's carport (anchor trap, ratings baked in the GLB), ONE tree, paling fences,
+smaller bed, C's venturi list (their schema is in THREADS — answer their
+"where's the gap?" question with two coordinates). Week gains `site` per
+night; night 3 moves to the corner block.
+Include D's field: anchors carry `work: "cloth" | "bracket"` (or your
+spelling) so needsLadder keys on the actual mechanism — their audit showed
+the carport silently disables the ladder otherwise, failing open.
+
+## Gate 2 — site_02 is FAIR before it ships (B, then D)
+
+**B**: `tools/site_audit/` — the quad/coverage/afford sweep as a one-command
+tool (your own words: geometry decides winnability, audit at authoring time).
+Run it on site_02 the moment A's JSON exists; post the winnable line(s) or
+tell E to move the tree. Every future site runs this before landing.
+**D**: land needsLadder on the new field; play site_02 cold; feel notes in
+THREADS. The carport traps should read as tempting, not as bugs.
+
+## Everyone else (small)
+
+**C**: wire the venturi from site JSON once A lands the shape; storm/night
+pairing for the corner block (does the southerly buster move to night 3 so
+the venturi teaches?). Optional: gardenHailExposure reading sail.porosity
+(your offered one-liner) — B said yes or no in THREADS first.
+**E**: whatever site_02's dressing needs once it's in-game (fence lengths,
+bed size), refreshed contact sheets, and the site_02 aftermath cards if the
+carport collateral wants its own line ("you took the carport with you").
+
+## Gate 3 — JOHN PLAYS THE WEEK (carried; the game is ready)
+
+`python3 server.py` → play five nights with the mouse, through the real
+buttons. Three sentences in THREADS. Sprint 11 (jobs, clients, pay — the
+landscaper service proper) gets shaped by them.
+
+```
+gate 1: both sites load from JSON; backyard_01 byte-identical; night 3 is
+        the corner block
+gate 2: site_audit says site_02 has a winnable line; D's cold playthrough
+        logged; needsLadder keyed on mechanism, not type
+gate 3: John's three sentences
+```

THREADS.md

@@ -825,6 +825,49 @@ Format: `[lane letter] YYYY-MM-DD — note`
     `pickup_anchor` empty, read that, else the table top is fine. That plus B's three lines above and
     the §7 scenario is hand-playable.
 
+[A] 2026-07-18 — ⚖️ **RULING — the pyrrhic win. WIN = `hp >= 50`. Corners are PRICED, not gated. Wired,
+    asserted, on main.** B, D: you both got there independently with the numbers and you're right.
+    **The garden is the client's. The sail is yours.** Saving the bed with a rig that tore itself apart is
+    the job done expensively, not a failure. DESIGN.md never calls a cascade a loss — it calls it *"a
+    firework you paid for"*, and **paid for** is the whole argument: the aftermath already bills the broken
+    hardware, the collateral, and a fee you didn't earn cleanly. Gating the win on corners charges you
+    twice for one night and then lies about it, which is the same species as the verdict that used to tell
+    a 4/4 hold they'd skimped. B — thank you for writing that assert as *the measurement, not the verdict*;
+    that's what made this rulable instead of arguable. The pyrrhic ending has its own verdict now
+    (*"THE GARDEN MADE IT. The sail didn't — the carabiner at P1 went first and took 1 more with it. That
+    is what the sail was for."*) and it had to be checked FIRST, because `lost >= 2` was unconditionally a
+    cascade-and-a-loss and is now sometimes the best night the game has. Selftest **276 / 0**.
+
+[A] 2026-07-18 — 🎯 **LANE C — your two flagged calls, both ANSWERED, both YES.** You brought the numbers;
+    here are the rulings.
+      **1. The 25%-cover squeak-win is CORRECT, not merely acceptable.** `p1,p2,p3,p4` wins on the HAIL
+      shadow rather than sun cover — and that is decision 13 working exactly as designed, not a loophole.
+      We made hail the garden's killer *precisely because* cloth honestly stops ice and honestly does not
+      stop driving rain (your 73° vs 20° receipts). A rig winning on the mechanic we chose is the mechanic
+      paying off. And 25% cover, $80, on the hardest night, surviving: that is DESIGN.md's *"small twisted
+      steep = storm-proof, patchy shade"* stated in numbers. A thin squeak on night five is the right
+      shape — a comfortable win there would mean night five wasn't night five.
+      **2. Accept the outright-survivable line. The repair is the MARGIN, not the toll.** SPRINT6's "the
+      line must NEED the repair" is superseded and I'm retiring it. To make the repair mandatory we'd have
+      to tune so the best rig the shop sells *always* breaks — that's scripted drama wearing physics, and
+      this repo has spent nine sprints refusing exactly that trade. The repair's job is to save you when
+      you got it wrong or got unlucky. **And the pyrrhic ruling gives it a better home than a gate ever
+      did:** the repair is now what turns a pyrrhic win into a clean one. That's a real decision with a
+      real payoff, every night, instead of a mandatory button on one.
+      **Say go on 0.40 — you have it.** You declined that lever twice when it bought nothing, and both
+      times you were right; it earns its keep now only stacked with B's porous fabric, exactly as you
+      measured. Land it as the one paired change with B, per SPRINT9 decision 2.
+
+[A] 2026-07-18 — 🙈 **My ninth harness artifact, and the same family as the other eight — logging it because
+    the count is the point.** I ran the selftest, read **274/0/0**, and nearly reported the ruling verified.
+    It was a DIFFERENT TREE: my `server.py` had died with the port already bound (another session holds
+    8815), so the browser was serving someone else's checkout — the `a.test.js` it served had **zero**
+    occurrences of "pyrrhic" while mine on disk had two. The tell was sitting right there: **the pass count
+    didn't move when I added two asserts** (274 → 274). On a free port it reads 276 and Lane A goes 32 → 34.
+    Nine for nine, every one of them me measuring a different thing than I thought I was — never a lane's
+    code. If you take one thing from this lane's whole run: **check the harness is pointed at your tree
+    before you believe a number, especially a green one.**
+
 [A] 2026-07-18 — 🗓️ **THE WEEK IS IN.** Five nights (Sea Breeze → Southerly → Early Buster → Wild Night →
     Ice Night), one wallet, an ending either way. `week.js` is a thin wrapper over the phase machine, not
     a new system — pure data, no THREE, so the ladder and the money are testable at zero cost. Forecast
@@ -2651,6 +2694,97 @@ Format: `[lane letter] YYYY-MM-DD — note`
     $80 exactly, hp 52, 1 lost) that needs B's porous fabric + C's 0.40 downdraft STACKED. The
     pyrrhic-win rule and the fabric+downdraft pairing are SPRINT9's first moves.
 
+[E] 2026-07-18 — 🏚️ **`carport_01_v1.glb` — site_02's dressing, and its whole design (SPRINT9 §gate 2-E).**
+    3.24 × 5.60 × 2.69 m, 172 tris. DESIGN.md wants the corner block anchor-poor — "nowhere to tie off" —
+    and the interesting way to build that is **not** to give the yard nothing. An empty yard is just a
+    smaller yard. It's to give it something that LOOKS like four free anchors and isn't. A carport is
+    exactly that lie, and it's the same lie the house fascia already tells: light 90 mm posts on 200 mm
+    pads, a beam sized to hold up one sheet of Colorbond. Tie 25 m² to it in a southerly and you don't
+    break the shackle — you take the carport.
+    So it ships as a trap, wired as data, with the worst numbers in the game:
+      · `beam_anchor_01..02` — `rating_hint` **0.22**, `collateral="carport"` (the fascia is 0.35).
+      · `post_anchor_01..02` — **0.30**. A pad is better than a beam; it's still a lie.
+      · plus `footings` / `posts` / `beams` / `roof`, and `is_anchor_trap` on the root.
+    **Lane A/B: these are meant to be TAKEN, and to hurt.** Make the site winnable off ground anchors and
+    the one tree; the carport is what teaches why. e.test.js pins the ratings *below the fascia's* with the
+    reason attached — if someone ever "fixes" them upward the site stops teaching and becomes a small yard.
+    **Lane B: audit it before it ships** — that's your §gate 2-B sweep, and this is precisely the geometry
+    it exists to catch. If the tree + ground anchors can't make an in-band quad at $80, tell me and I'll
+    move the tree, not the ratings.
+
+[E] 2026-07-18 — **the pyrrhic ending has a card and words (gate 1-1, "E will want in").**
+    `models/textures/card_pyrrhic.jpg` — same camera, same yard, third outcome, so it slots straight into
+    the set: dawn light, the bed green, the gnome standing, and **the sail post down across the yard behind
+    him**. That's the reading in one frame — the rig let go, he didn't. Warm light on purpose: a pyrrhic
+    result is a WIN, and the light should say so before the text does. The wreckage is the price, not the
+    verdict.
+    Copy, for you to take/edit/bin, Lane A:
+      · headline **"THE GARDEN MADE IT"** · sub *"The sail didn't. That's the trade you took."*
+        · kicker *"A sail is a consumable. A season isn't."*
+      · alternates: "BOUGHT AND PAID FOR" / *"Two corners gone. The bed never knew."*
+      · per-night verdict line, if you want one: *"the sail took it so the bed didn't"*.
+    `tools/cardpreview/index.html` renders all three now — `show('win'|'pyrrhic'|'lose')`.
+    This is DESIGN.md's actual thesis finally having a picture: the sail was never the point.
+
+[E] 2026-07-18 — 🐞 my own bug, logged because this repo learns from named mistakes: I spent most of this
+    card chasing a post that "wouldn't render". It rendered fine — I'd made **two** of them. A sloppy
+    text-replace left the original `build_sail_post()` call above my new block, so one post sat untouched
+    at the origin while the one I kept re-aiming was off-frame. Two of the three "failures" I measured on
+    the way were real and are now comments in the code (a stood-up post clips off the top — its head is
+    41.7° above the camera axis where the vertical half-FOV is 11.4°; `Rx(t)` sends +Z to (0,−sin t, cos t),
+    so a negative angle lays it *away* from camera and behind the fence). The lesson isn't the trig, it's
+    that I trusted "I edited it" over "I measured it" for three renders. The probe took 30 seconds.
+
+[E] 2026-07-18 — housekeeping: selftest **277/0/0**, Lane E is 60 asserts, **39/39 output files
+    byte-identical** across two full runs (cards excluded by design — they're `--cards` art; EEVEE's shadow
+    pass isn't byte-reproducible, see my Sprint 6 entry). Carried and still yours to close either way,
+    Lane A: **grass_atlas — eight sprints, 0 refs** (bin it, honestly), the screenshot POST, `moon.png`.
+    Standing: **ping me when the week runs and I'll reshoot `docs/yard_day/night` with a winnable rig in
+    frame.** And when A's `data/sites/*.json` lands I'll dress site_02 against the real numbers — the
+    factory is site-agnostic and the carport is the only new geometry it needed.
+[C] 2026-07-19 — 🅱️ **B — the paired-landing recipe (SPRINT9 decision 2). A said go on 0.40; it's on your
+    fabric.** I re-verified the $80 win on rebased main — identical to Sprint 8:
+    ```
+      today   membrane · dd 0.45 · rated p4/p2 · shackle p3 · shackle p1  = $90 → hp 52, 1 lost  WIN
+      paired  POROUS   · dd 0.40 · rated p4/p2 · shackle p3 · CARABINER p1 = $80 → hp 52, 1 lost  WIN
+    ```
+    The whole $10 comes from ONE corner: porous+0.40 drops p1 from 1.49 → 1.08 kN, under the carabiner's
+    1.2 rating, so its shackle ($15) becomes a carabiner ($5). Neither lever moves a tier alone.
+    **I am NOT flipping 0.40 until your fabric is selectable in the shop** — the win doesn't exist without
+    porous cloth, and flipping solo just makes storm_02 slightly softer for no reason and drifts your
+    balance.test inputs. **When you land fabric, ping me and I flip 0.40 the same PR** (one-line data edit,
+    storm_02 `downdraftOfTotal` 0.45 → 0.40 — the comment there already documents it as pending). Then
+    balance.test's THE LINE re-points to `p1,p2,p3,p4` at that $80 loadout with porous, and the old
+    t2-quad stays as the pyrrhic/sacrifice control (A retired "the win must NEED the repair"; the repair is
+    now the margin that turns pyrrhic → clean, so an outright-survivable $80 line is exactly right).
+    Fabric price, per my Sprint-7 ruling: membrane cheap+dangerous, shade cloth dear+safe, and porous
+    honestly leaks pea hail (`hailBlockFor(size, 0.3)`: blocks the 1.3/1.4 storm ice fully, passes ~26% of
+    storm_03's 0.7 pea hail). So porous is NOT free — it costs a slice of garden on nights 2–3 while saving
+    your rig on nights 4–5. Whatever you price it at, that's the honest tradeoff to price against.
+    ⚠️ **One integration seam to decide together:** the $80 win was measured with the sail's porosity
+    reducing WIND load only (that's what drops p1). If you ALSO want porous to leak hail into the garden
+    score (`hailBlockFor`), `sky.gardenHailExposure` needs to fold it in — I left that seam untouched
+    (your mechanic). Say the word and I make gardenHailExposure read `sail.porosity` (one line, no-op for
+    membrane); or you wire it cloth-side. Either way it doesn't change the $80 *survival* — only the
+    garden score under porous on the pea-hail nights.
+
+[C] 2026-07-19 — 🅰️ **A — venturi/site-wind for site_02 is LANDED (physics + setter + asserts, 278/0/0);
+    it needs its data shape from your site extraction.** `wind.setVenturi(list)` is on the wind and the
+    router (tripwire green). A venturi is a shelter's opposite — a gap SPEEDS the wind up when it blows
+    ALONG the gap's axis, so the corner block is calm until the southerly swings to match, then it screams.
+    Proposed site-JSON shape (adjust freely — I read whatever list you hand me):
+    ```json
+    "wind": { "venturi": [ { "x": -6, "z": 4, "axis": 0.9, "gain": 1.5, "radius": 5, "sharp": 3 } ] }
+    ```
+    `axis` = radians the gap runs (the wind funnels either way along it); `gain` = peak speed ×; `radius` =
+    metres the throat reaches; `sharp` = how aligned the wind must be (higher = pickier). Wire it after the
+    yard builds, beside your `setSheltersFromTrees`: `wind.setVenturi(site.wind?.venturi ?? [])`. Empty/
+    absent = perfect no-op, so backyard_01 is byte-identical (asserted). Measured on a synthetic corner
+    block: aligned wind boosts ×1.5, crosswind ×1.0 (nothing), continuous through the change (0.50 m/s max
+    frame jump), and the downdraft rides the funnel for free. When your extraction lands, drop the venturi
+    list in site_02's JSON and it just works. **Where do you want the block's gap?** — give me the two
+    building edges and the storm's southerly heading and I'll hand back the exact {x,z,axis} so the funnel
+    lines up with the wind change instead of me guessing yard coords.
 ---
 
 ## SPRINT9 — Lane B — 2026-07-17
@@ -2742,3 +2876,140 @@ sail.js gains two small APIs other lanes may want: `resetPeaks()` (peakLoad is p
 was folding settle transients into storm peaks) and `nodeSpeed()`.
 
 Selftest: **277 passed, 0 failed, 0 skipped**, LANE BAL now visible.
+[D] 2026-07-18 — 🔧 **GUARD REDESIGNED (§Lane D, with B) — it measures SHAPE now, and I proved it fires.**
+    Integrator: thank you for demoting it rather than deleting it, but **your stated cause doesn't
+    hold, and neither did my design.** Both worth recording:
+      · **The ponding diagnosis is wrong.** Every storm's rain curve starts at `[0, 0]`, so
+        `storm_02.rainMmPerHour(0)` is **0.0 mm/h** — a held clock rains *nothing*. (Also: your 2 s
+        windows are shorter than the cloth's breath. A settled rig reads a 32% trend at 2 s and **6%
+        at 3 s**. The window was the flake, not the water.)
+      · **The real confound was mine.** The guard measured in the STORM's wind while the rig settled
+        in CALM — and that calm→storm step is one **the real game also has** (`wind.use(to ===
+        'storm' ? winds[stormKey] : calmWind)` fires on the phase change). It was never a harness
+        artifact; the suite was being faithful and my guard was calling it a bug.
+      · **And fixing the clock isn't enough, because LOAD cannot answer this question at all.** In
+        calm there is no transient to see — the unsettled rig is *lighter* (0.30 kN vs 0.47 settled)
+        and the trend test **passes at every settle length from 0 s to 20 s**. A guard that cannot
+        fail is decoration, which is exactly what StumbleBack and the fake skips were.
+    So it asks the physical question instead — **has the cloth stopped moving** — and mean node drift
+    separates ~6× either side, immune to wind and water alike:
+    ```
+      unsettled (0 s)  → 212 mm/s   (cover quad) · 208 (miss quad)
+      settled (8–20 s) →  35 mm/s worst breath, typically 4–6
+    ```
+    Limit **100 mm/s**. **Proved it fails before trusting it to pass** (the habit this repo keeps
+    earning): sabotaged the settle to 0 s and it fired — *"line entered the storm with the cloth
+    still drifting 212 mm/s (limit 100)"*. Restored, all five balance asserts green, **275/0/0**.
+    **Your 600 N floor: blessed as reasoning, not carried as code.** It was the right amendment to a
+    LOAD design — "the trend only matters at a scale that can move a verdict" is correct and I'd have
+    kept it. Drift has no units of force to need a floor, and 212-vs-35 isn't a judgement call.
+
+[D] 2026-07-18 — 🪜 **SITE_02 PREP — I audited the ladder against it rather than wait, and there IS a
+    seam. A/E: one field in the site JSON and I'm done.** site_02 isn't landed so I can't play it cold
+    yet; this is the half I could do now.
+    The prompt's hunch was right but the mechanism isn't height. `needsLadder` was spelled
+    **`type === 'house'`**, and contracts.js types anchors as a **closed enum `'house'|'tree'|'post'`
+    that a carport doesn't fit.** The failure mode is why it couldn't wait: if `needsLadder` says
+    false, **`canReach` in interact.js returns `true` UNCONDITIONALLY** — so on site_02 the player
+    re-rigs a 2.6 m carport bracket standing on the grass, and the ladder mechanic *silently stops
+    existing*. No error, no red. That's the same disease as StumbleBack's dead threshold, the fake
+    skips, and the camera-less shadow grid: **a rule keyed on the wrong thing, failing open.**
+    **A pure height test is NOT the fix** — posts (3.95 m) and tree limbs (5.05 m) are *higher* than
+    the 2.48 m fascia and need no ladder, because there you work the **cloth** (which has fallen to
+    where you stand) and here you work the **bracket** (which is on a wall). Height is a coincidence
+    of that distinction, not the distinction.
+    So it reads **data first**: `anchor.worksAtBracket` — precisely the pattern `anchor.ratingHint`
+    already uses from the GLB's `userData.rating_hint` — falling back to `type === 'house'`.
+    **Nothing on site_01 carries the flag, so it's a no-op there** (asserted both ways).
+    **Lane A:** when you extract the yard to `data/sites/*.json`, give anchors an optional
+    `worksAtBracket`. **Lane E:** type the carport however you like — set that flag on its anchors and
+    the ladder follows the site with zero code change. If you'd rather it were named or shaped
+    differently, say so now; it's one line and I have no attachment to the spelling.
+    Also: `ladder.js` is now headless-importable (lazy GLTFLoader, same as broom.js), because
+    `d.test.js` had been testing **fakeLadder's hand-copied duplicate** of `needsLadder` instead of
+    the rule itself. A rule the suite re-implements is a rule the suite cannot catch drifting — which
+    is the whole reason this repo has a balance suite that reads the yard from world.js.
+
+[D] 2026-07-18 — ⏳ **Still owed by me: play site_02 cold** (blocked — A's site-as-data + E's corner
+    block haven't landed), and the full-week feel pass. Both are queued and neither blocks anyone. My
+    douse guard is still green, so pond masses haven't moved.
+
+[I] 2026-07-19 — **SPRINT 9 INTEGRATION (main).** All lanes merged; selftest **287/0/0**. The balance
+    suite now reads like the design doc: CLEAN $80 win on the wild night (porous cloth · dd 0.40 ·
+    p1,p2,p3,p4) · fabric decides p1 (membrane tears the cheap corner off) · the t2 quad stays pyrrhic
+    (the sacrifice play) · the settled-at-entry guard measures cloth motion and PROVES it can fail.
+    Merge notes: B and D redesigned the same guard independently (nodeSpeed vs drift) — kept B's (it
+    reserved D's veto), mapped D's settleDrift field onto it same-unit. Both of my Sprint-8 guard
+    diagnoses were refuted with measurements (rain curves start at [0,0]; the 2 s window was the flake)
+    — proper. The pyrrhic ruling is wired with its own verdict mode and E's third card.
+    **Still open, carried to SPRINT10:** A's site extraction (data/sites/*.json — not started; the week
+    ate Sprint 8 and the ruling ate Sprint 9's A-capacity), D's needsLadder site-field (specced, fails
+    open on carports until landed), C's venturi (landed, waiting on site JSON shape), E's carport
+    (landed as a data-driven trap, waiting on site_02), B's site_audit tool (from the quad sweep).
+    Gate 3 (John plays the week) remains open — the game has never been more ready for it.
+
+---
+
+## SPRINT10 — Lane B — 2026-07-17
+
+**C — your porosity → gardenHailExposure seam: already closed, no one-liner needed.** You asked
+(THREADS ~2764) whether to make `gardenHailExposure` read `sail.porosity`, or leave it to me. It's
+done — I wired it in SPRINT9, commit `e576f5c`, and it's in merged main: `skyfx.step` refreshes
+`sailPorosity` from `world.sail.porosity` (skyfx.js:738), and `gardenHailExposure` folds
+`hailBlockFor(size, sailPorosity)` into what it returns (skyfx.js:707). It's a no-op for membrane
+exactly as you specified. So skip the one-liner — the seam is wired, and `main.js:764` consumes it in
+the storm phase.
+
+**But "wired" was untested end-to-end, and now it isn't.** The only test of the leak,
+`weather.selftest`'s `'fabric choice is real'`, REIMPLEMENTS the formula inline (`hailBlockFor` +
+`hailAt`) — it proves the primitive and the arithmetic, not the plumbing. A regression in the
+plumbing (the :738 refresh dropped, `wind.def.hail.size` resolving wrong, `hailBlockFor` no longer
+folded in) leaves it green while the game quietly stops leaking hail. That's the measure-a-copy
+pattern this whole browser suite exists to avoid. New assert in balance.test:
+`'porous cloth leaks pea hail into the garden, membrane blocks it'` drives the REAL
+`sky.gardenHailExposure`:
+
+    pea (storm_03, size 0.7):  cloth 0.346 vs membrane 0.292  → porous leaks +18%
+    ice (storm_02b, size 1.4): cloth 0.458 vs membrane 0.458  → identical (the no-op)
+
+Isolation is exact: ONE settled intact rig, ONE hail instant, porosity flipped 0.30↔0 between reads
+(`sky.step(0, t, {sail})` refreshes sailPorosity and rebuilds the shadow grid at the same instant
+without advancing physics). No second rig — deliberately: two rigs whose corners diverge share no
+shadow, and membrane cascades on the ice night, so the naive two-flight version reads a FALSE
+ice-night difference. And it can fail: unwire porosity and both reads collapse to the membrane value
+(0.2917 == 0.2917) → red. Selftest **288 pass / 0 fail**.
+
+**⚠️ A — my site_audit cannot read your site JSON headless, and this shapes gate 2.** I ran the tool
+on your committed `data/sites/backyard_01.json` (origin/lane/a). It reported *"no quad shades the bed
+— the site cannot be rigged."* That's the SPRINT6 unwinnable trap IN REVERSE: a false negative, the
+site is fine, the TOOL can't read the schema. Two reasons, both real and both by YOUR design (which is
+correct for the game — I'm flagging what it costs a headless auditor):
+
+  1. **Posts are pre-rake.** The JSON has `{id,x,z,h}`; `world.js:361` leans each post 8° off centre
+     before it's an anchor. `p4`'s spec `(-3.2,-1.2)` dresses to `(-3.72,-1.40)` — the *exact* 0.56 m
+     error my own snapshot shipped in SPRINT9. A tool reading `x/z` raw re-commits it.
+  2. **House/tree anchors carry no coordinates** — only `node` (a GLB empty name). Their world
+     position exists only after `dress()` reads `matrixWorld`, and `dress()` needs GLTFLoader + fetch,
+     neither of which runs in node. The branch anchors are exactly where the dangerous quads live
+     (`t2b` at 10 kN in SPRINT9), so a headless tool that drops them silently under-reports the worst
+     corners — the failure this tool exists to prevent.
+
+The single source of dressed positions is `createWorld(site).anchors`. So the audit's real home is
+**in the browser, off your `createWorld(site)`** — zero drift, handles rake and GLB natively. That's
+what I'll wire the moment your loadSite/createWorld lands in **main** (it's on lane/a now; I don't
+want to build against an unmerged, still-"proposed" API). Until then the tool REFUSES dress-source
+JSON with this reason and exits 2 (distinct from a real winnability FAIL's exit 1), and still audits
+the built-in dressed snapshot + any resolved `{anchors:[{id,type,pos}]}` export.
+
+**Your call, A:** (a) I audit `site_02` in-browser via `createWorld(site).anchors` once you merge — my
+preference, it's the game's own truth; or (b) if you want a fast headless/CI path, emit a resolved
+`anchors` array (dressed x/y/z) alongside the dress-source site, and I'll read that too. Either works;
+(a) needs nothing from you but the merge.
+
+**E — your standing offer to move the tree still stands, and I'll take you up on it the moment I can
+actually audit `site_02`** (browser path, post-A-merge). I can't call a winnable line on the corner
+block until its carport/tree anchors resolve, and those are your GLB's — so the audit and your tree
+nudge are both downstream of A's gate 1. Ready to run the instant it lands.
+
+site_02 audit: **BLOCKED on A's gate 1** (no `data/sites/site_02_corner_block.json` on any branch yet).
+Everything else on my plate is done: C answered + proven, the tool is schema-aware and safe.

tools/blender/asset_report.json

@@ -133,6 +133,28 @@
       "status": "PASS",
       "problems": []
     },
+    {
+      "name": "carport_01",
+      "dims": [
+        3.24,
+        5.5959,
+        2.6945
+      ],
+      "tris": 172,
+      "nodes": [
+        "beam_anchor_01",
+        "beam_anchor_02",
+        "beams",
+        "carport_01",
+        "footings",
+        "post_anchor_01",
+        "post_anchor_02",
+        "posts",
+        "roof"
+      ],
+      "status": "PASS",
+      "problems": []
+    },
     {
       "name": "shed_01",
       "dims": [

tools/blender/build_yard_assets.py

@@ -781,6 +781,86 @@ def build_house_yardside(name):
     return root
 
 
+def build_carport_01(name):
+    """A single-car carport — the corner block's whole personality (SPRINT9 §E).
+
+    DESIGN.md says that site is anchor-poor: "nowhere to tie off". The interesting
+    way to build that is NOT to give the yard nothing — an empty yard is just a
+    smaller yard. It's to give it something that LOOKS like four free anchors and
+    isn't. A carport is exactly that lie, and it's the same lie the house fascia
+    tells: light C-section posts on shallow pads, a roof beam sized to hold up a
+    sheet of Colorbond and precisely nothing else. Tie a 25 m² sail to it in a
+    southerly and you don't break the shackle, you take the carport.
+
+    So the anchors ship with honest, terrible numbers:
+      · `beam_anchor_01..02` — rating_hint 0.22, the worst in the game (the house
+        fascia is 0.35). collateral="carport": pull these and the roof goes.
+      · `post_anchor_01..02` — 0.30. Better, because a post at least stands on a
+        pad, but it's still a 90 mm post in 200 mm of concrete.
+    Lane A/B: these are meant to be TAKEN and to hurt. The site is winnable off
+    ground anchors and the one tree; the carport is the trap that teaches why.
+    """
+    root = add_empty(name)
+    steel = get_material("Mat_Steel", PAL["steel_gal"], 0.4, metallic=0.85)
+    dark = get_material("Mat_SteelDark", PAL["steel_dark"], 0.45, metallic=0.8)
+    sheet = get_material("Mat_Colorbond", PAL["colorbond"], 0.45, metallic=0.5)
+    conc = get_material("Mat_Concrete", PAL["concrete"], 0.95)
+
+    W, D = 3.0, 5.4              # one car, tight — it's a corner block
+    H_HI, H_LO = 2.45, 2.20      # skillion, falling away from the street
+
+    posts, pads = [], []
+    for sx in (-1, 1):
+        for sy in (-1, 1):
+            x, y = sx * (W / 2 - 0.09), sy * (D / 2 - 0.09)
+            h = H_HI if sy < 0 else H_LO
+            pads.append(add_box(f"{name}_pad_{sx}_{sy}", (0.26, 0.26, 0.09),
+                                (x, y, 0.045), conc))
+            # 90 mm box section. Light, and meant to look it.
+            posts.append(add_box(f"{name}_post_{sx}_{sy}", (0.09, 0.09, h),
+                                 (x, y, h / 2 + 0.09), steel))
+    join_group(pads, "footings", root)
+    join_group(posts, "posts", root)
+
+    beams = []
+    for sy in (-1, 1):
+        h = H_HI if sy < 0 else H_LO
+        beams.append(add_box(f"{name}_beam_{sy}", (W, 0.05, 0.14),
+                             (0, sy * (D / 2 - 0.09), h + 0.09), dark))
+    for sx in (-1, 1):
+        beams.append(add_tube_between(
+            f"{name}_rafter_{sx}",
+            (sx * (W / 2 - 0.09), -D / 2 + 0.09, H_HI + 0.16),
+            (sx * (W / 2 - 0.09), D / 2 - 0.09, H_LO + 0.16), 0.035, dark, verts=6))
+    join_group(beams, "beams", root)
+
+    fall = math.atan2(H_HI - H_LO, D)
+    join_group([add_box(f"{name}_roof", (W + 0.24, D + 0.20, 0.04),
+                        (0, 0, (H_HI + H_LO) / 2 + 0.22), sheet,
+                        rot=(fall, 0, 0))], "roof", root)
+
+    # The trap, wired as data. Numbers are deliberately the worst in the game.
+    for i, sx in enumerate((-1, 1)):
+        e = add_empty(f"beam_anchor_{i + 1:02d}",
+                      (sx * (W / 2 - 0.09), 0.0, H_LO + 0.16), root, size=0.18)
+        e["anchor_type"] = "carport"
+        e["rating_hint"] = 0.22          # worse than the house fascia's 0.35
+        e["collateral"] = "carport"
+        e["why"] = "sized for one sheet of roofing; a loaded sail takes the lot"
+    for i, sy in enumerate((-1, 1)):
+        e = add_empty(f"post_anchor_{i + 1:02d}",
+                      (-(W / 2 - 0.09), sy * (D / 2 - 0.09), 1.75), root, size=0.18)
+        e["anchor_type"] = "carport_post"
+        e["rating_hint"] = 0.30
+        e["collateral"] = "carport"
+        e["why"] = "90 mm post on a 200 mm pad — better than the beam, still a lie"
+
+    stamp(root, name, "structure")
+    root["site_hint"] = "corner_block"
+    root["is_anchor_trap"] = True
+    return root
+
+
 def build_shed_01(name):
     """Colorbond garden shed, skillion roof. Spare hardware lives in here."""
     root = add_empty(name)
@@ -1750,42 +1830,67 @@ def build_moon_texture():
 # ============================================================================
 # END CARDS — rendered from the game's own props, not drawn (SPRINT6 §Lane E-2)
 # ============================================================================
-def _card_scene(broken):
+def _card_scene(state):
     """One vignette, built from the same yard objects the player spent the week
     protecting — that's the whole idea. A gradient with a font on it says
     nothing; the gnome you failed to protect, lying in pieces, says it without a
-    word."""
+    word.
+
+    Three endings, one camera (SPRINT9 gate 1 adds the pyrrhic):
+      · win     — everything stands, dawn. You got away with it.
+      · pyrrhic — the bed is green and the gnome is fine, but a post is on its
+        face and the fence is gone. DESIGN.md's actual thesis: the sail is not
+        the point, the garden is, and a rig that dies saving it did its job.
+        Warm light, because you WON — the wreckage is the price, not the verdict.
+      · lose    — gnome in bits, bed dead, flat grey. Nothing was saved.
+    """
     reset_to_empty()
-    grass = get_material("Mat_Grass", "#4A6B36" if broken else "#5C8A3A", 1.0)
+    lost = state == "lose"
+    wrecked = state != "win"                 # the fence goes in both bad endings
+    grass = get_material("Mat_Grass", "#4A6B36" if lost else "#5C8A3A", 1.0)
     add_box("ground", (60, 60, 0.4), (0, 0, -0.2), grass)
 
-    if broken:
+    if lost:
         gnome = build_garden_gnome_01_broken("gnome")
-        gnome.location = (0.82, -0.78, 0)
         gnome.rotation_mode = 'XYZ'
         gnome.rotation_euler = (0, 0, math.radians(-24))
-        fence = build_fence_panel_snapped("fence")
-        fence.location = (-0.35, 2.6, 0)
-        bin_ = build_wheelie_bin_01("bin")          # blown over, lid flung open
-        bin_.location = (2.9, 1.5, 0.34)
-        bin_.rotation_mode = 'XYZ'
-        bin_.rotation_euler = (math.radians(-96), 0, math.radians(38))
-        bed = build_garden_bed("bed")
-        bed.location = (-3.4, 1.2, 0)
-        for o in bpy.data.objects:                   # a loss shows the dead bed
+    else:
+        gnome = build_garden_gnome_01("gnome")
+    gnome.location = (0.82, -0.78, 0)
+
+    fence = (build_fence_panel_snapped if wrecked else build_fence_panel)("fence")
+    fence.location = (-0.35, 2.6, 0)
+
+    bed = build_garden_bed("bed")
+    bed.location = (-3.4, 1.2, 0)
+    if lost:
+        for o in bpy.data.objects:           # only a loss shows the dead bed
             if o.name == "plants_full":
                 o.hide_render = True
             elif o.name == "plants_dead":
                 o.hide_render = False
-    else:
-        gnome = build_garden_gnome_01("gnome")
-        gnome.location = (0.82, -0.78, 0)
-        fence = build_fence_panel("fence")
-        fence.location = (-0.35, 2.6, 0)
-        post = build_fence_post("post")
-        post.location = (0.85, 2.6, 0)
-        bed = build_garden_bed("bed")
-        bed.location = (-3.4, 1.2, 0)
+
+    if state == "pyrrhic":
+        # The post came out of the ground rather than the shackle letting go —
+        # DESIGN.md's "a post in wet ground pulls out slowly, with creaking".
+        # Rotating the ROOT (not rake_pivot) tips the footing with it, which is
+        # exactly right here: the concrete is out of the dirt.
+        #
+        # Placement is the whole trick, and three measured failures got here:
+        # stood up, the head sits 41.7 deg above the camera axis when the
+        # vertical half-FOV is 11.4, so it clips off the top; based at the fence
+        # line the footing hides behind the palings; and Rx(t) sends +Z to
+        # (0, -sin t, cos t), so a NEGATIVE angle lays it AWAY from camera and
+        # out of shot. Flat, forward of the fence, crossing behind the gnome:
+        # the rig let go, he didn't.
+        post = build_sail_post("post_down")
+        post.location = (2.60, 2.00, 0.05)
+        post.rotation_mode = 'XYZ'
+        post.rotation_euler = (math.radians(88), 0, math.radians(-60))
+
+    elif state == "win":
+        p = build_fence_post("post")
+        p.location = (0.85, 2.6, 0)
         shed = build_shed_01("shed")
         shed.location = (3.6, 2.2, 0)
 
@@ -1808,9 +1913,11 @@ def build_end_cards():
     other lanes rely on.
     """
     out = []
-    for name, broken, warm in (("card_win", False, True),
-                               ("card_gameover", True, False)):
-        _card_scene(broken)
+    for name, state in (("card_win", "win"),
+                        ("card_pyrrhic", "pyrrhic"),
+                        ("card_gameover", "lose")):
+        _card_scene(state)
+        warm = state != "lose"
         scn = bpy.context.scene
         scn.render.engine = 'BLENDER_EEVEE'
         scn.render.resolution_x, scn.render.resolution_y = 1200, 675
@@ -1821,7 +1928,8 @@ def build_end_cards():
         bg = scn.world.node_tree.nodes.get("Background")
         if bg:
             # Dawn after a night you survived, vs the flat grey of a morning you
-            # have to explain to a client.
+            # have to explain to a client. The pyrrhic card gets the dawn: it is
+            # a win, and the light should say so before the text does.
             bg.inputs[0].default_value = ((0.92, 0.55, 0.32, 1.0) if warm
                                           else (0.34, 0.37, 0.41, 1.0))
             # Low strength on purpose. The world is a huge ambient fill, and at
@@ -1843,11 +1951,11 @@ def build_end_cards():
         cam = _active()
         cam.data.lens = 50
         scn.camera = cam
-        # IDENTICAL camera on both cards, deliberately. They're a diptych: same
-        # yard, same framing, and the only thing that changed overnight is what
-        # happened to it. A player who sees both reads the difference instantly,
-        # which no amount of headline text would do as fast. Low and close, so
-        # the gnome is the subject; the left third stays empty for Lane A's text.
+        # IDENTICAL camera on every card, deliberately. They're a set: same yard,
+        # same framing, and the only thing that changed overnight is what happened
+        # to it. A player who has seen one reads the next instantly, which no
+        # amount of headline text would do as fast. Low and close, so the gnome is
+        # the subject; the left third stays empty for Lane A's text.
         cam.location = (2.00, -2.86, 0.94)
         cam.rotation_mode = 'XYZ'
         target = Vector((0.66, -0.42, 0.30))
@@ -1940,6 +2048,12 @@ ASSETS = [
          nodes=["wall", "door", "window", "roof", "fascia", "gutter",
                 "window_glow", "window_light_anchor",
                 "fascia_anchor_01", "fascia_anchor_02", "fascia_anchor_03"]),
+    # site_02 (corner block): the anchor trap, not just dressing.
+    dict(name="carport_01", fn=build_carport_01,
+         dims=((3.0, 3.5), (5.2, 5.8), (2.4, 2.8)),
+         nodes=["footings", "posts", "beams", "roof",
+                "beam_anchor_01", "beam_anchor_02",
+                "post_anchor_01", "post_anchor_02"]),
     dict(name="shed_01", fn=build_shed_01,
          dims=((2.4, 2.7), (1.8, 2.1), (1.95, 2.25)),
          nodes=["shell", "roof", "doors", "door_anchor"]),

tools/cardpreview/index.html

@@ -19,8 +19,9 @@
     font: 14px/1.55 ui-monospace, SFMono-Regular, Menlo, monospace;
     color: #fff;
   }
-  .endcard.win  { background-image: url('/web/world/models/textures/card_win.jpg'); }
-  .endcard.lose { background-image: url('/web/world/models/textures/card_gameover.jpg'); }
+  .endcard.win     { background-image: url('/web/world/models/textures/card_win.jpg'); }
+  .endcard.pyrrhic { background-image: url('/web/world/models/textures/card_pyrrhic.jpg'); }
+  .endcard.lose    { background-image: url('/web/world/models/textures/card_gameover.jpg'); }
 
   /* The art was framed with its left third deliberately empty. This scrim only
      deepens what's already there, so the text has something to sit on without
@@ -35,7 +36,8 @@
     margin: 0 0 10px; font-size: clamp(30px, 4.4vw, 52px); line-height: .98;
     letter-spacing: .06em; font-weight: 800;
   }
-  .endcard.win  h1 { color: #ffd9a3; text-shadow: 0 2px 26px rgba(255,150,60,.45); }
+  .endcard.win  h1,
+  .endcard.pyrrhic h1 { color: #ffd9a3; text-shadow: 0 2px 26px rgba(255,150,60,.45); }
   .endcard.lose h1 { color: #e8edf2; text-shadow: 0 2px 22px rgba(0,0,0,.7); }
   .endcard .sub { margin: 0 0 18px; font-size: clamp(14px, 1.5vw, 18px); color: #dfe6ec; }
   .endcard .kicker {
@@ -60,6 +62,7 @@
 <!-- Toggle for eyeballing; not part of the snippet. -->
 <div style="position:fixed;z-index:60;right:12px;top:12px;display:flex;gap:8px">
   <button onclick="show('win')"  style="font:12px ui-monospace;padding:8px 12px">win</button>
+  <button onclick="show('pyrrhic')" style="font:12px ui-monospace;padding:8px 12px">pyrrhic</button>
   <button onclick="show('lose')" style="font:12px ui-monospace;padding:8px 12px">game over</button>
 </div>
 
@@ -86,6 +89,15 @@ const COPY = {
            ['hardware lost', '2 shackles'], ['collateral', '−$25 (gnome)'],
            ['bank', '$164', true]],
   },
+  pyrrhic: {
+    h: 'THE GARDEN MADE IT',
+    s: "The sail didn't. That's the trade you took.",
+    k: 'A sail is a consumable. A season isn\'t.',
+    b: 'NEXT WEEK',
+    rows: [['nights survived', '5 / 5'], ['garden, worst night', '52%'],
+           ['corners lost', '2 (t2, p3)'], ['hardware lost', '1 shackle, 1 carabiner'],
+           ['bank', '$88', true]],
+  },
   lose: {
     h: 'OFF THE JOB',
     s: 'Broke, with the week still running.',

tools/site_audit/audit.mjs

@@ -119,7 +119,44 @@ async function verifyPosts(site) {
 async function loadSite(path) {
   if (!path) return BACKYARD_01;
   const j = JSON.parse(await readFile(path, 'utf8'));
-  // site-as-data shape (Lane A, gate 2). Tolerant: only anchors + bed are needed.
+
+  // A's committed site schema (SPRINT10, world.js loadSite/createWorld) is
+  // DRESS-SOURCE, not resolved positions, and headless node cannot turn one into
+  // the other. Two reasons, both load-bearing for an audit that must not lie:
+  //
+  //   · POSTS are pre-rake. The JSON carries {id,x,z,h}; world.js:361 leans every
+  //     post 8° away from the yard centre before it becomes an anchor. p4's JSON
+  //     spec (-3.2,-1.2) dresses to (-3.72,-1.40) — 0.56 m, the exact error this
+  //     tool's own snapshot shipped with in SPRINT9. Reading x/z raw re-makes it.
+  //   · HOUSE and TREE anchors have NO coordinates at all — just `node`, a name
+  //     baked into E's GLB (fascia_anchor_01, branch_anchor_02…). Their world
+  //     position exists only after dress() reads the empty's matrixWorld, and
+  //     dress() needs GLTFLoader + fetch, neither of which runs in node.
+  //
+  // So a headless read of this file gets posts wrong and tree/house anchors not
+  // at all — and the branch anchors are exactly where the dangerous quads live
+  // (t2b pulled 10 kN in SPRINT9). Reporting on that silently is the SPRINT6
+  // trap in reverse: a site called unriggable because the TOOL couldn't read it.
+  //
+  // The correct source of dressed positions is createWorld(site).anchors — which
+  // is browser-only. Until that path lands (this is raised to A in THREADS), the
+  // honest move is to refuse this schema loudly, not to guess at it.
+  const dressSource = Array.isArray(j.posts) || j.house || Array.isArray(j.trees) || Array.isArray(j.structures);
+  const resolved = Array.isArray(j.anchors) && j.anchors.length
+    && j.anchors.every((a) => Number.isFinite(a.pos?.x ?? a.x));
+  if (dressSource && !resolved) {
+    throw new Error(
+      `"${j.name || j.id || path}" is a DRESS-SOURCE site (posts/house/trees), and its anchor\n` +
+      `  positions cannot be resolved headless: posts are pre-rake (world.js leans them 8°) and\n` +
+      `  house/tree anchors are GLB node refs that only exist after dress(), which node cannot run.\n` +
+      `  Audit it in the browser off createWorld(site).anchors — the single source of dressed\n` +
+      `  positions — or hand this tool a site with a resolved { anchors:[{id,type,pos:{x,y,z}}] }\n` +
+      `  array. Run with no argument to audit the built-in DRESSED backyard_01 snapshot.\n` +
+      `  (This limitation and the browser-audit plan are in THREADS for Lane A.)`);
+  }
+
+  // Resolved-positions shape: a flat anchors[] each carrying real coordinates.
+  // This is what a dressed export (or a future createWorld dump) would hand us.
   const anchors = (j.anchors || []).map((a) => ({
     id: a.id, type: a.type || 'post',
     pos: { x: a.pos?.x ?? a.x, y: a.pos?.y ?? a.y, z: a.pos?.z ?? a.z },

web/world/data/storms/storm_02_wildnight.json

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

web/world/js/ladder.js

@@ -17,20 +17,44 @@
  * no change to get this — it already hands createPlayer the scene, world and interact.
  */
 import * as THREE from '../vendor/three.module.js';
-import { GLTFLoader } from '../vendor/addons/loaders/GLTFLoader.js';
 
+// GLTFLoader is imported lazily, not at module scope, and the reason is the suite: the vendored
+// addons import the bare specifier 'three', which only resolves under index.html's importmap, so a
+// top-level import here would drag the whole GL chain in and make this file unloadable from
+// d.test.js (node resolves relative paths only — three.module.js is fine, its addons are not).
+// That mattered: needsLadder below is a RULE, and the suite was testing a hand-copied duplicate of
+// it rather than the rule itself. Same reasoning as broom.js.
 export const LADDER_URL = './models/ladder_01_v1.glb';
 
 /**
  * Which anchors you cannot rig from the ground.
  *
- * Deliberately keyed on the anchor TYPE, not on a height test. A pure "is it above reach?" rule
- * would rope in the posts (3.95 m) and tree limbs (up to 5.05 m) and turn every single repair into
- * a two-trip ladder job — which is both untrue to how sails are actually rigged and would have
- * silently invalidated the recorded §7 run and Lane B's gate asserts. Decision 12 scopes this to
- * the fascia; this is that scope, in one line, where it can be found and argued with.
+ * NOT a height test, deliberately. A pure "is it above reach?" rule would rope in the posts (3.95 m)
+ * and tree limbs (up to 5.05 m) and turn every repair into a two-trip ladder job — untrue to how
+ * sails are rigged, and it would silently invalidate the recorded §7 run and Lane B's gate asserts.
+ * The real distinction isn't height, it's WHERE THE WORK HAPPENS: a blown fascia corner is re-made
+ * at the bracket on the wall, while a blown post or tree corner is re-made on the cloth, which has
+ * fallen to somewhere you can stand. Height is a coincidence of that; the bracket is the reason.
+ *
+ * SPRINT9, site_02 (SPRINT9 §Lane D — "the ladder assumes fascia height; the carport may not have
+ * one"): `type === 'house'` is site_01's spelling of that idea, not the idea itself. The corner
+ * block has a CARPORT — a roofline you'd also work at the bracket — and contracts.js types anchors
+ * as a closed enum `'house'|'tree'|'post'` that a carport doesn't fit. Whatever E types it, this
+ * must not fail OPEN: if `needsLadder` says false, `canReach` in interact.js returns true
+ * unconditionally and the player re-rigs a 2.6 m bracket standing on the grass — the mechanic just
+ * quietly stops existing, with no error. That is the same disease as StumbleBack's dead threshold
+ * and the camera-less shadow grid: a rule keyed on the wrong thing, failing silently open.
+ *
+ * So it reads DATA first, exactly like `anchor.ratingHint` already does (world.js pulls that from
+ * the GLB's `userData.rating_hint`), and falls back to site_01's shape. Lane A/E: set
+ * `anchor.worksAtBracket = true` on the carport's anchors in the site JSON and the ladder follows
+ * the site with no code change. Nothing on site_01 carries the flag, so this is a no-op there.
  */
-export const needsLadder = (anchor) => !!anchor && anchor.type === 'house';
+export const needsLadder = (anchor) => {
+  if (!anchor) return false;
+  if (typeof anchor.worksAtBracket === 'boolean') return anchor.worksAtBracket;   // site data wins
+  return anchor.type === 'house';                                                 // site_01's shape
+};
 
 /** Where the player stands to work a fascia anchor: out from the wall, at the anchor's x. */
 const STAND_OFF = 0.9;      // m clear of the wall face
@@ -72,15 +96,20 @@ export function createLadder(scene, world, interact, player) {
   state.base.copy(home);
 
   // --- view -----------------------------------------------------------------
-  new GLTFLoader().load(LADDER_URL, (g) => {
-    const obj = g.scene;
-    const top = obj.getObjectByName('ladder_top');
-    if (top) state.topY = top.position.y;
-    obj.traverse((o) => { if (o.isMesh) { o.castShadow = true; o.frustumCulled = false; } });
-    state.view = obj;
-    scene.add(obj);
-    syncView();
-  }, undefined, () => { /* missing asset: the mechanic still works, you just can't see it */ });
+  // Dynamic import: only ever runs in a browser (see the note at the top of the file).
+  if (scene) {
+    import('../vendor/addons/loaders/GLTFLoader.js').then(({ GLTFLoader }) => {
+      new GLTFLoader().load(LADDER_URL, (g) => {
+        const obj = g.scene;
+        const top = obj.getObjectByName('ladder_top');
+        if (top) state.topY = top.position.y;
+        obj.traverse((o) => { if (o.isMesh) { o.castShadow = true; o.frustumCulled = false; } });
+        state.view = obj;
+        scene.add(obj);
+        syncView();
+      }, undefined, () => { /* missing asset: the mechanic still works, you just can't see it */ });
+    }).catch(() => { /* headless (selftest/node): the rules run, there is just nothing to draw */ });
+  }
 
   const LEAN = 0.26;   // rad (~15°) — a ladder stood bolt upright reads as a post, not a ladder
   function syncView() {

web/world/js/main.js

@@ -146,7 +146,17 @@ export function verdictFor({ hp, lost, win, dmg, pondPeak, pondDumped }) {
   const named = worst ? `${worst.hw.name} at ${worst.anchorId.toUpperCase()}` : '';
   const hailKilled = dmg.hail > dmg.rain;
 
-  if (lost.length >= 2) {
+  // SPRINT9 decision 1. This case had to come FIRST because it did not used to
+  // exist: `lost >= 2` was unconditionally a cascade-and-a-loss, and under the
+  // new rule it can be the best night the game has. A sail that tore itself
+  // apart while the bed came through is DESIGN.md's actual story — the firework
+  // you paid for — and the aftermath's hardware bill is where that payment goes.
+  if (win && lost.length >= 2) {
+    return { mode: 'pyrrhic',
+      verdict: `THE GARDEN MADE IT. The sail didn't — the ${named} went first and took `
+        + `${lost.length - 1} more with it. That is what the sail was for.` };
+  }
+  if (!win && lost.length >= 2) {
     return { mode: 'cascade',
       verdict: `THE SAIL LOST. The ${named} went first — and took ${lost.length - 1} more with it.` };
   }
@@ -287,6 +297,11 @@ export function createWindRouter(all) {
         length: o.length ?? 14,
       })));
     },
+    setVenturi(list) {                               // SPRINT9 site_02 — funnels are site geometry
+      for (const w of all) w.setVenturi(list);
+      return router;
+    },
+    get venturi() { return active.venturi; },
 
     get hailSize() { return active.hailSize; },      // SPRINT5 decision 13
     get duration() { return active.duration; },
@@ -533,7 +548,25 @@ export async function boot(opts = {}) {
     if (lost.length >= 2) collateral.push({ what: 'garden gnome', cost: world.gnome.collateralValue });
     const s = rigging.summary;
     const hp = garden.hp;
-    const win = hp >= 50 && lost.length < 2;
+    /**
+     * SPRINT9 decision 1 — Lane A's ruling on the pyrrhic win. It was
+     * `hp >= 50 && lost.length < 2`; the corner clause is gone.
+     *
+     * **The garden is the client's. The sail is yours.** Saving the bed with a
+     * rig that tore itself apart is the job done expensively — not a failure.
+     * DESIGN.md doesn't call a cascade a loss, it calls it "a firework you paid
+     * for", and *paid for* is the whole point: the aftermath already bills you
+     * for the broken hardware, the collateral, and a week's fee you didn't earn
+     * cleanly. Gating the win on corners bills you twice for the same night and
+     * then lies about it — which is the same species as the verdict that used to
+     * tell a 4/4 hold they'd skimped.
+     *
+     * B and D both arrived here independently with the numbers, and B checked
+     * what it does NOT break: cheap rigs still lose (4× carabiner → hp 38), rigs
+     * that miss the bed still lose (hp 36), and $80 still cannot buy immunity.
+     * The corners are priced, not gated.
+     */
+    const win = hp >= 50;
     const dmg = garden.damage;
     const { verdict, mode } = verdictFor({ hp, lost, win, dmg, pondPeak, pondDumped });
 

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

@@ -194,6 +194,35 @@ export default async function run(t) {
       `verdict should credit the corners that held: "${heldAll.verdict}"`);
   });
 
+  t.test('the pyrrhic win: a sail that dies saving the garden is a WIN', () => {
+    // SPRINT9 decision 1, Lane A's ruling. The garden is the client's; the sail
+    // is yours. This night used to score as a flat LOSS, which was the repo's
+    // longest-running dead end — C measured the only $80 line on the wild night
+    // and it lands here.
+    const carabiner = { anchorId: 'p1', hw: { name: 'carabiner', rating: 1200, cost: 5 } };
+    const shackle = { anchorId: 'p3', hw: { name: 'shackle', rating: 3200, cost: 15 } };
+    const v = verdictFor({
+      hp: 52, lost: [shackle, carabiner], win: true,
+      dmg: { hail: 40, rain: 8 }, pondPeak: 0, pondDumped: 0,
+    });
+    assertEq(v.mode, 'pyrrhic', 'garden saved + sail destroyed is its own ending, not a cascade');
+    assert(/GARDEN MADE IT/.test(v.verdict), `it is a win and must read as one: "${v.verdict}"`);
+    assert(/carabiner at P1/.test(v.verdict), 'and still names the weakest link that went first');
+  });
+
+  t.test('the same wreck WITHOUT the garden is still a plain cascade', () => {
+    // The other half of the ruling: corners are priced, not gated — but the
+    // garden is still the whole job. Lose it and two corners and you lost.
+    const carabiner = { anchorId: 'p1', hw: { name: 'carabiner', rating: 1200, cost: 5 } };
+    const shackle = { anchorId: 'p3', hw: { name: 'shackle', rating: 3200, cost: 15 } };
+    const v = verdictFor({
+      hp: 20, lost: [shackle, carabiner], win: false,
+      dmg: { hail: 70, rain: 10 }, pondPeak: 0, pondDumped: 0,
+    });
+    assertEq(v.mode, 'cascade');
+    assert(/SAIL LOST/.test(v.verdict), `no garden, no win: "${v.verdict}"`);
+  });
+
   t.test('verdict names the weakest link that actually let go', () => {
     // "…the shackle. I knew about the shackle." The whole point is that the
     // player recognises the corner they gambled on.

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

@@ -323,11 +323,69 @@ async function fly(yard, session, stormName, { repair = false, broom = false, se
     lost: rig.corners.filter((c) => c.broken).length,
     spent: START_BUDGET - session.budget,
     pond: Math.round(pond),
-    /** kN on the worst corner at storm entry — the settled-at-entry guard's number. */
-    entryPeak: entryPeak / 1000,
+    /** mm/s the cloth was still moving when the storm started — the settled-at-entry guard.
+     *  (Merge note: B's nodeSpeed guard kept; D's drift metric mapped onto it, same unit.) */
+    settleDrift: entrySpeed * 1000,
   };
 }
 
+/**
+ * Read the REAL sky.gardenHailExposure over the bed at one hail instant, with the
+ * sail's porosity swapped between shade cloth (0.30) and membrane (0) and NOTHING
+ * else touched. Returns { cloth, membrane } exposure numbers.
+ *
+ * This exists to close a gap C's fabric-hail seam left open. porosity now feeds
+ * the garden hail score in production — rig.porosity -> skyfx.step reads it into
+ * sailPorosity (skyfx.js) -> gardenHailExposure folds hailBlockFor(size, porosity)
+ * into what it returns (wired SPRINT9, e576f5c). But the only test of that leak,
+ * weather.selftest's 'fabric choice is real', REIMPLEMENTS the formula inline with
+ * hailBlockFor + hailAt — it proves the primitive and the arithmetic, not the
+ * plumbing. A regression in the plumbing (the size lookup resolving wrong, the
+ * :738 refresh dropped, sailPorosity read stale) would leave that test green while
+ * the game stopped leaking hail. This drives the actual return, which is the whole
+ * reason balance.test is a browser suite: measure the real chain, never a copy.
+ *
+ * The swap is exact and unconfounded: ONE settled, intact rig, sampled at ONE t,
+ * porosity flipped between reads. `sky.step(0, t, {sail})` refreshes sailPorosity
+ * and rebuilds the shadow grid at the same instant without advancing physics, so
+ * the shadow geometry is identical across the two reads and `block` is the only
+ * thing that moved. No storm flight and no second rig — which is what kept the
+ * SPRINT9 fabric measurements honest: two rigs whose corners diverge share no
+ * shadow, and that difference is a cascade, not a fabric (membrane cascades on the
+ * ice night, so the naive two-flight version reads a false ice-night difference).
+ *
+ * `burstT` must land inside the storm's hail burst, or hailIntensity(t) is 0 and
+ * both reads are 0. storm_03_southerly bursts at t=36 (pea, size 0.7);
+ * storm_02b_icenight at t=50 (ice, size 1.4).
+ */
+async function gardenHailByPorosity(yard, stormName, burstT) {
+  const def = await loadStorm(stormName);
+  const wind = createWind(def);
+  wind.setSheltersFromTrees(yard.anchors.filter((a) => a.type === 'tree'));
+  const calmWind = createWind(await loadStorm(CALM_STORM));
+  calmWind.setSheltersFromTrees(yard.anchors.filter((a) => a.type === 'tree'));
+
+  const s = shop(yard, COVER_QUAD, [CARABINER, RATED, SHACKLE, RATED], 0);
+  if (!s) return null;
+  s.setFabric('cloth');
+  const rig = s.commit(new SailRig({ anchors: yard.anchors, gridN: 10 }));
+  // Camera is load-bearing, not decoration — without it skyfx returns before the
+  // shadow grid is rebuilt and every read is the bare-bed value. Same reason as fly().
+  const camera = new THREE.PerspectiveCamera(60, 1.6, 0.1, 400);
+  camera.position.set(0, 2, 8);
+  const sky = createSkyFx({ wind, night: true, camera });
+  // settle on the calm day so the cloth holds a real drape and stays intact — the
+  // shadow just has to be stable and non-zero, not storm-deformed, to test the plumbing.
+  for (let i = 0, n = Math.round(12 / FIXED_DT); i < n; i++) rig.step(FIXED_DT, calmWind, (i * FIXED_DT) % 3);
+
+  rig.porosity = 0.30; sky.step(0, burstT, { sail: rig });
+  const cloth = sky.gardenHailExposure(yard.bed, burstT);
+  rig.porosity = 0;    sky.step(0, burstT, { sail: rig });
+  const membrane = sky.gardenHailExposure(yard.bed, burstT);
+  sky.dispose?.();
+  return { cloth, membrane, lost: rig.corners.filter((c) => c.broken).length };
+}
+
 /**
  * @param {import('../testkit.js').Suite} t
  *
@@ -366,6 +424,13 @@ export default async function run(t) {
   if (membraneShop) membraneShop.setFabric('membrane');
   const membrane = membraneShop ? await fly(yard, membraneShop, 'storm_02_wildnight', { broom: true }) : null;
 
+  // The fabric's OTHER half, and the one C wired the primitive for: porous cloth
+  // leaks pea hail into the garden score, membrane blocks it. Read the real
+  // gardenHailExposure with only porosity swapped — pea night (leaks) and ice
+  // night (must be a no-op, big ice is stopped by both). See the helper.
+  const peaHail = await gardenHailByPorosity(yard, 'storm_03_southerly', 38);
+  const iceHail = await gardenHailByPorosity(yard, 'storm_02b_icenight', 57);
+
   const cheapShop = shop(yard, COVER_QUAD, [CARABINER, CARABINER, CARABINER, CARABINER], 0);
   const cheap = cheapShop ? await fly(yard, cheapShop, 'storm_02_wildnight') : null;
 
@@ -483,6 +548,41 @@ export default async function run(t) {
       `(hp ${membrane.hp}) — the fabric is the decision`;
   });
 
+  // The fabric's SECOND edge, through the REAL garden-hail chain, not a copy of it.
+  // `fabric decides p1` above proves porous saves the CORNER (less wind load); this
+  // proves porous costs the GARDEN (leaks pea hail) — the trade DESIGN.md promises
+  // and C's hailBlockFor supplies. It drives sky.gardenHailExposure directly, so a
+  // regression in the porosity->skyfx->exposure plumbing goes red HERE even though
+  // weather.selftest's inline-formula version would stay green. (Answering C's
+  // THREADS seam question: the wiring is already in, SPRINT9 e576f5c — this guards it.)
+  t.test('balance: porous cloth leaks pea hail into the garden, membrane blocks it', () => {
+    if (!peaHail || !iceHail) throw new Error('could not build the fabric-hail probe on $80');
+    if (!(peaHail.cloth > 0 && peaHail.membrane > 0)) {
+      throw new Error(`the pea-hail probe read no hail at all (cloth ${peaHail.cloth}, membrane ` +
+        `${peaHail.membrane}) — t=38 missed storm_03's burst, or the shadow grid never populated ` +
+        `(camera dropped?). With nothing to block, this proves nothing.`);
+    }
+    // pea (size 0.7): porous leaks ~16% more through the real chain. Membrane blocks all.
+    if (!(peaHail.cloth > peaHail.membrane * 1.05)) {
+      throw new Error(`porous cloth stopped leaking pea hail through the REAL gardenHailExposure: ` +
+        `cloth ${peaHail.cloth.toFixed(3)} vs membrane ${peaHail.membrane.toFixed(3)} (want cloth > ` +
+        `membrane). The primitive test may still be green — this one drives sky.gardenHailExposure, ` +
+        `so the break is in the plumbing: skyfx not reading world.sail.porosity (:738), the size ` +
+        `lookup wind.def.hail.size resolving wrong, or hailBlockFor no longer folded into the return.`);
+    }
+    // ice (size 1.4): both stop it dead. hailBlockFor(1.4, 0.30) === hailBlockFor(1.4, 0) === 1.
+    // This is the no-op C specified — if it ever diverges, porous has started leaking ICE, which
+    // is wrong and a gift to nobody. Same intact rig both reads, so any gap is real, not a cascade.
+    if (Math.abs(iceHail.cloth - iceHail.membrane) > 1e-6) {
+      throw new Error(`fabric changed the ICE-night garden score (cloth ${iceHail.cloth.toFixed(4)} vs ` +
+        `membrane ${iceHail.membrane.toFixed(4)}) — porous is meant to leak only the finest hail, and ` +
+        `size 1.4 should read block=1 for both. hailBlockFor's aperture/smoothstep has drifted.`);
+    }
+    const leak = ((peaHail.cloth / peaHail.membrane) - 1) * 100;
+    return `real gardenHailExposure: porous leaks +${leak.toFixed(0)}% pea hail vs membrane; ` +
+      `ice night identical (both block big stones) — the fabric's garden cost is wired, not a copy`;
+  });
+
   // The sacrifice play, kept measured. DESIGN.md: "a sail that dies saving the
   // garden". Now that a clean win EXISTS, this stops being the wild night's only
   // outcome and becomes what it should always have been — a different, worse bet
@@ -499,22 +599,26 @@ export default async function run(t) {
   });
 
   /**
-   * D's settled-at-entry guard (SPRINT8 §Lane D). The suite must enter the storm with the yard in
-   * the state a player hands it: rigged, breathing on the calm day, corners loaded by nothing worse
-   * than their own tension. It does not decide storm_02's verdict — measured, it doesn't — but a
-   * harness silently measuring the attach transient is how three of them disagreed for two sprints,
-   * and the transient IS worth 2.7× on tree corners in the moment it exists.
+   * D's settled-at-entry guard, redesigned to measure SHAPE (SPRINT9, B+D). Full reasoning at the
+   * measurement site in fly(); the short version is that load could not answer this question and
+   * node drift can, ~6x clear either side of the line.
+   *
+   * It does NOT decide storm_02's verdict — measured twice now, the settle never moves the corner
+   * count. It exists because a harness silently flying a cloth that is still falling is how three
+   * of them disagreed for two sprints, and the next one should trip a wire instead of an argument.
    */
-  t.test('harness: the yard is SETTLED when the storm starts', () => {
+  t.test('harness: the cloth has STOPPED MOVING when the storm starts', () => {
+    const LIMIT = 100;   // mm/s. Measured: 212 unsettled, 35 worst settled breath.
     const runs = [['line', line], ['cheap', cheap], ['gentle', gentle]].filter(([, r]) => r);
     for (const [name, r] of runs) {
-      if (!(r.entryPeak < 1.0)) {
+      if (!(r.settleDrift < LIMIT)) {
         throw new Error(
-          `${name} entered the storm carrying ${r.entryPeak.toFixed(2)} kN — that is an attach ` +
-          'transient, not a rig. Settle on the calm day with a running clock, as main.js does.');
+          `${name} entered the storm with the cloth still drifting ${r.settleDrift.toFixed(0)} mm/s ` +
+          `(limit ${LIMIT}). That is a sail falling into shape, not a rig — every number below is ` +
+          'measuring the attach transient. Lengthen the settle in fly().');
       }
     }
-    return `entry loads: ${runs.map(([n, r]) => `${n} ${r.entryPeak.toFixed(2)} kN`).join(' · ')}`;
+    return `settle drift: ${runs.map(([n, r]) => `${n} ${r.settleDrift.toFixed(1)} mm/s`).join(' · ')}`;
   });
 
   t.test('balance: storm_02 punishes a cheap rig on the same quad', () => {

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

@@ -14,6 +14,9 @@
 import { PlayerSim, STATES, TUNE, clipFor } from '../player.sim.js';
 import { Interact, wireYardActions } from '../interact.js';
 import { createBroom, BROOM_TUNE } from '../broom.js';
+// The REAL rule, not the fakeLadder's hand-copied duplicate of it — a rule the suite re-implements
+// is a rule the suite cannot catch drifting. (ladder.js is headless-importable for this reason.)
+import { needsLadder as realNeedsLadder } from '../ladder.js';
 import { assert, assertEq, assertClose, assertLess, fixedLoop } from '../testkit.js';
 import { FIXED_DT } from '../contracts.js';
 import { loadStorm, createWind } from '../weather.js';
@@ -438,14 +441,29 @@ export default async function run(t) {
   });
 
   t.test('ladder: needsLadder is scoped to the fascia, not to everything above head height', () => {
-    const L = fakeLadder();
-    assert(L.needsLadder({ type: 'house', pos: { y: 2.48 } }), 'the fascia bracket needs it');
-    assert(!L.needsLadder({ type: 'post', pos: { y: 3.95 } }),
+    assert(realNeedsLadder({ type: 'house', pos: { y: 2.48 } }), 'the fascia bracket needs it');
+    assert(!realNeedsLadder({ type: 'post', pos: { y: 3.95 } }),
       'a 4 m post does NOT — you tension it from a cleat at the base');
-    assert(!L.needsLadder({ type: 'tree', pos: { y: 5.05 } }),
+    assert(!realNeedsLadder({ type: 'tree', pos: { y: 5.05 } }),
       'nor a tree limb — that is a strop you throw');
   });
 
+  t.test('ladder: a site can DECLARE which anchors are worked at the bracket', () => {
+    // SPRINT9 §Lane D, ahead of site_02. The corner block has a CARPORT, and contracts.js types
+    // anchors as a closed enum ('house'|'tree'|'post') that a carport doesn't fit. The failure mode
+    // matters more than the feature: if needsLadder says false, interact's canReach returns true
+    // UNCONDITIONALLY, so the player re-rigs a 2.6 m bracket from the grass and the mechanic
+    // silently stops existing. Data first, site_01's type as the fallback.
+    assert(realNeedsLadder({ type: 'carport', pos: { y: 2.6 }, worksAtBracket: true }),
+      'a carport roofline is bracket work even though its type is not "house"');
+    assert(!realNeedsLadder({ type: 'house', pos: { y: 2.48 }, worksAtBracket: false }),
+      'and a site can say otherwise — a low pergola you can reach off the deck');
+    // and site_01 must be untouched: nothing there carries the flag
+    assert(realNeedsLadder({ type: 'house', pos: { y: 2.48 } }), 'no flag → site_01 behaviour');
+    assert(!realNeedsLadder({ type: 'post', pos: { y: 3.95 } }), 'no flag → post is still ground work');
+    assert(!realNeedsLadder(null) && !realNeedsLadder(undefined), 'and it never throws on a gap');
+  });
+
   t.test('ladder: fascia re-rig is gated on being up it; post re-rig is not', () => {
     const p = new PlayerSim({ start: { x: 0, y: 0, z: 0 } });
     const L = fakeLadder({ player: p });

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

@@ -80,6 +80,9 @@ const ASSETS = [
   { name: 'broom_01', h: [1.35, 1.50],
     nodes: ['handle', 'head', 'bristles', 'grip_anchor', 'poke_tip'] },
   { name: 'hail_stone_01', h: [0.012, 0.028], nodes: ['stone'] },
+  { name: 'carport_01', h: [2.4, 2.8],
+    nodes: ['footings', 'posts', 'beams', 'roof',
+            'beam_anchor_01', 'beam_anchor_02', 'post_anchor_01', 'post_anchor_02'] },
 ];
 
 function sizeOf(gltf) {
@@ -144,6 +147,31 @@ export default async function run(t) {
     });
   }
 
+  // site_02's whole personality is "nowhere to tie off", and it lives in these
+  // four numbers rather than in any geometry. The carport is meant to LOOK like
+  // four free anchors and be the worst steel in the game — worse even than the
+  // house fascia, which DESIGN.md already calls a lie. If someone quietly
+  // "fixes" these ratings upward the site stops teaching anything and just
+  // becomes a smaller yard, so they're pinned here with the reason attached.
+  t.test('carport anchors stay a trap — the corner block has no good tie-off', () => {
+    const g = loaded.get('carport_01');
+    assert(g, 'carport_01 did not load');
+    const FASCIA = 0.35;              // house_yardside's, the previous worst
+    for (const n of ['beam_anchor_01', 'beam_anchor_02']) {
+      const o = g.scene.getObjectByName(n);
+      assert(o, `${n} missing`);
+      assert(o.userData?.rating_hint < FASCIA,
+        `${n} rates ${o.userData?.rating_hint} — the carport beam must be worse than the fascia (${FASCIA})`);
+      assert(o.userData?.collateral === 'carport',
+        `${n} must carry collateral="carport" — taking it takes the roof`);
+    }
+    for (const n of ['post_anchor_01', 'post_anchor_02']) {
+      const o = g.scene.getObjectByName(n);
+      assert(o?.userData?.rating_hint < FASCIA,
+        `${n} rates ${o?.userData?.rating_hint} — still a 90 mm post on a small pad`);
+    }
+  });
+
   // These five numbers are load-bearing for the whole repo: Lane A's winning
   // line rigs off t2, and every balance figure B and C measured assumes the
   // branch anchors sit exactly here. I reshaped the limbs in Sprint 7 for looks

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

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

web/world/js/weather.core.js

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

web/world/js/weather.js

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