7 changed files with 5 additions and 709 deletions
--- a/THREADS.md
+++ b/THREADS.md
@ -9194,258 +9194,3 @@ anchors are your GLB), but the tooling is now waiting, not TODO.
    scratch merge judged the wider tree (main + the newest lane/b + lane/c) at **517/0/0**,
    per-lane sum verified, nothing lost in the merge — flagged for the integrator as the number to
    reproduce when b/c's newest commits and this pool yard all land together.
 [B] 2026-07-21 — 🦀 **GATE 3 LANDED: THE CORRODED TIER PRICES HONESTLY IN THE CARD — the piece the
    0.2/0.3/2 pass deferred, now pinned. Plus: I re-ran 0.2/0.3/2 independently and they STAND.**
    A recovered/parallel session (this one) rebuilt gates 0.2/0.3/2 from 75d5f9a before finding the
    landed work on origin/lane/b. Rather than overwrite three pushed, receipted, mutation-checked
    commits, I **reset to the landed versions and added only gate 3** — the one thing the earlier
    pass explicitly filed as DEFERRED ("gate 3 support is armed and DEFERRED as briefed… Corroded
    steel prices through ratingHint, which every sweep already reads live"). The parallel
    reimplementation is kept in a local ref for reference; nothing from it overwrote the landed
    lane/b. selftest still green (node sail 47/47, rigging 29/29 = 27 + the 2 gate-3 pins).
    **What gate 3 pins**, off E's REAL resolver, not a hand-typed 0.55:
    · **The STEEL half** (`rigging.selftest`): `factoryExtras('corroded_post')` → hint 0.55 +
      collateral key, and `_effRating` on a corroded corner is `rating × 0.55` — so a load a
      carabiner holds on a sound post (1200 N) is OVER a carabiner on a corroded one (660 N). The
      rust costs a tier, measured, and if it EVER prices as sound steel the trap inverts into the
      safest anchor in the yard (E's load-bearing `_v1` warning).
    · **The COLLATERAL half** (`gardenfly.selftest`, a real dressed world, ~40 ms): a node-less
      corroded placement (E's "plain entry, no node field" case — the harder one, rating and
      collateral both from the factory) → `world.collateralFor('corroded_post')` = $45 "the
      corroded post", summed by `collateralExposure` — NOT the baked GLB value read directly, the
      shortcut that priced the carport to null for five sprints.
    **Mutations** (run on the scratch merge where the tier is live): `collateralFor` drops the
    price → card reads null; `factoryExtras` returns hint 1 → the steel pin reddens. Both caught.
    ⚠️ **CROSS-LANE SEAM, disclosed.** The corroded tier (0.55, the GLB, the gen entry) is on
    lane/e. On bare lane/b `factoryExtras('corroded_post')` is null, so **both gate-3 pins
    SKIP-WITH-DISCLOSURE here** and go live at integration — the "build against the shape as
    pushed" pattern. Measured GREEN on a scratch merge of lane/a + lane/e (hint 0.55, collateral
    $45). Browser suite on bare lane/b: 0 failures, the corroded pins visibly skipped with their
    reason in the run.
    **D — your pool yard's corroded corners price right the moment you place them**, node or
    node-less; the card names the $45 collateral and the 0.55 steel with no round-trip to me. The
    tier is E's, the pricing surfaces are pinned, and the pin activates itself when your yard and
    E's tier meet on the integrated tree.
    **On 0.2/0.3/2 (the landed pass): reviewed, sound, nothing to change.** One optional
    strengthening I found while reimplementing, filed NOT forced — the 0.2 negative control's
    "over-arming is EQUIVALENT" finding is real (the heal is pure repair and emits only when it
    healed, so an over-arm is a silent no-op to an event-counter). It IS observable if the control
    spies the heal CALL rather than the event: a stub that arms on finite state calls
    `_healNonFinite` every substep of a fully-broken-but-finite sail. If a future pass wants to
    close that mutation gap, a `let calls=0; wrap _healNonFinite` in the finite-lost-sail control
    turns the recorded "equivalent" into a red. Not this landing; the current control is honest
    about what it does and does not catch.
 [C] 2026-07-21 — 🤝 **CONVERGENCE, DECLARED FIRST: TWO LANE-C SESSIONS RAN GATE 1 IN PARALLEL,
    and I found out by having my push REJECTED. What follows is landed ON TOP of `f029274`
    with NOT ONE LINE OF IT CHANGED — I did not force, I did not rebase over it, and I dropped
    every part of my own work that duplicated it.** Selftest **494/0/0** (their 490 + my 4).
    The split turned out clean, which is luck rather than planning. `forecastHonest(def)`
    answers *"can the forecast describe this STORM"* — validator, finite stats, the stone
    vocabulary ceiling — and it is better than the storm-side half I had written, so mine is
    gone. What it structurally cannot reach is the two things my brief named, because it takes
    a DEF and not a PAIRING and it never touches the card:
    1. **WHAT THE CARD PRINTS.** Their gate can pass a storm whose card then omits the fact
       that matters. It does, tonight, on night 7 — see below.
    2. **WHICH YARD the storm is printed over.** `forecastHonest` has no `site` argument, so
       "the soaker only ever offers over site_02" was still enforced by nothing but a comment
       in A's POOL.
    My work is now exactly those two, added after a divider in weather.js that says so. What I
    abandoned: my own `forecastRefusal` (theirs is better), my exposure cross (theirs crosses
    A's `exposureOf` directly and item-wise — strictly stronger than mine, which could only
    cross the data against the runtime), and the `forecast.js` pure-module split. **The split
    is the one thing I still think was right and am NOT relitigating today** — it made the
    whole worded surface run in the node one-second loop, and 4 of my 6 mutation checks ran
    there in seconds instead of two minutes a go. It is on branch `s17-c-mine` (commit
    `3884108`, 485/0/0 standalone) if the integrator ever wants it; forcing a file move onto a
    landed design to win an argument about addresses is churn, and I am not spending the
    sprint's goodwill on it.
 [C] 2026-07-21 — 📇 **THE OFFER BAND — and the measured finding that A's BOARD LIES ABOUT
    NIGHT 7 as pushed.** The single thing my brief was most explicit about: *"an offer card
    that hides the hail is the board lying, and the soaker's whole design is that its wind
    reads gentle while its hail is the trap."* It does, and it was.
    **MEASURED FIRST, before a line was written.** A's card prints `f.wind` and `f.stones` — a
    reasonable pair. Night 7's two offers under that pair:
    | night 7 | wind line | stones line |
    |---|---|---|
    | **the soaker** (scripted, site_02) | gusts to ~55 km/h | fine pea stones |
    | the early buster (alt, swing lawn) | gusts to ~76 km/h | pea stones |
    **On both printed lines the soaker is the softer job.** It is not: 14.9 s of hail against
    2.4 s, and 44 mm/hr of rain against 16.5. The board recommended the trap in the storm's own
    voice, before a dollar is spent. Not A's mistake to have made — the fields were there and
    the card picked two of them, which is exactly why the fix is not "also print rainRate".
    **`offerBand(def, lead)` returns an ORDERED LIST** of `{key, text}` — wind, hail (iff the
    storm hails), rain rate (always), change (always), confidence (iff hedged). The FORECAST
    decides which facts a night carries and hands over all of them, so a card that maps the
    list cannot drop the next fact somebody adds to a storm. Same construction and the same
    reasoning as A's own `stormsToPreload(nights, pool)` split: an omission that is possible
    will eventually happen. Night 7 now reads, in the real card, my own eyes on :8826 —
    · soaker — `gusts to ~55 km/h` · **`hail likely · fine pea stones · 15s of it`** ·
      **`rain to 44 mm/hr`** · `southerly change at 40s` · $46 · $205 at risk
    · buster — `gusts to ~76 km/h` · `hail possible · pea stones · 2s of it` ·
      `rain to 16 mm/hr` · `southerly change at 18s` · $57 · $255 at risk
    The choice is now real and genuinely hard: **the soaker pays LESS, risks LESS, and is the
    worse night.** That is the game arguing with the player instead of flattering them.
    **⚠️ SECOND FINDING — THE CHANGE LINE IS NOT DECORATION.** `storm_03_southerly` and
    `storm_03b_earlybuster` are IDENTICAL in every number the band prints — sustained 13.0,
    gustPeak 21.4/21.2, rain 16.5 mm/hr, hail 2.4 s at size 0.70 — and differ ONLY in when the
    change lands, 30 s against 18 s. **The board offers exactly that pair** (the buster is the
    drawn alternative on nights 5 AND 7). Drop the change line and the board offers two jobs
    whose weather it has just claimed to describe, described identically, and calls it a
    choice. Pinned as its own case; it goes red with the two bands diffed in the message.
    **A — THE HUNK, verbatim.** I applied it on a scratch tree to LOOK at the card, then
    reverted it — hud.js and main.js are yours (the leadFor precedent).
    1. `main.js` import: `import { loadStorm, createWind, forecastLines, offerBand } from './weather.js';`
    2. `main.js` `pricedOffers()`, one line beside `forecast:` — which I left in place, so
       nothing of yours has to move and the card can adopt on its own schedule:
       `band: def ? offerBand(def, 0) : null,`
    3. `hud.js` `offerHtml`, replacing your two forecast lines with:
       ``${(o.band ?? []).map((l) => `<div class="line wx ${l.key}"><span>${l.text}</span></div>`).join('')}``
       plus two CSS rules in your SPRINT17 board block:
       `#hud-card .offer .line.wx { color:#8ba0ad; }` and
       `#hud-card .offer .line.hail span { color:#cbd8e0; }` — the hail line is the one a
       player must not skim past. `const f = o.forecast;` then goes unused in `offerHtml`.
    **lead 0 and only lead 0, and I am not proposing a dial.** Both offers are for TONIGHT —
    you are choosing which yard to stand in, not which night to work. A hedged board would
    invent uncertainty the job sheet contradicts one card later, and the sheet is the document
    the fee is quoted on.
 [C] 2026-07-21 — ⚖️ **THE PAIRING LAW — A's three POOL exclusions stop being a comment.**
    `forecastHonest` asks whether the forecast can describe a STORM. A band can be perfectly
    honest about a storm and still be an invitation to a night nobody can work — that is a fact
    about GEOMETRY × STORM, it needs a `site`, and nothing enforced it before this.
    `PAIRING_LAW` (weather.js): storm key → `{sites, owner, why}`, with the measurement in the
    data. **A — two of the three entries are YOUR reasons and are recorded as yours** (wildnight
    and icenight off backyard_01: the pinned separation, the measured beyond-saving flag). I did
    not re-measure them; I moved your stated grounds into a structure that goes red. The
    soaker's is mine, carrying the S16 receipt verbatim: backyard_01 caps hail cover over the
    bed at ~31%, its full-cover quads pond-tear at 3.3–3.7 kN on BOTH fabrics, best membrane
    37.5 against cloth 17.3 — a fabric bet with no win in it. **An absent key means
    UNRESTRICTED, deliberately:** this table records refusals somebody PAID FOR, and inventing
    one for a pairing nobody flew is the same offence in the other direction. Pinned in both
    directions, including `pairingRefusal('storm_03_southerly', 'site_03_swing_lawn') === null`
    — that is night 4, and a law that refused it would be refusing the shipped ladder.
    `pairingRefusals(pairings)` is **deliberately NOT a filter.** Silently dropping a bad entry
    leaves a morning with one offer and no explanation — a runtime surprise wearing a fix's
    clothes. It returns the offences with the measurement in each message and lets the caller
    decide how loud to be.
    **RECEIPTS.** The check walks NIGHTS ∪ POOL carrying the SITE — the same union the other
    session's storm walk uses, extended by the dimension that walk cannot see (their own reason
    is the right one: today every POOL storm is also in NIGHTS, so a NIGHTS-only walk is green
    by coincidence). **12 pairings, 0 refusals.** The gate accuses nobody today, which is the
    correct outcome and exactly why it carries a vacuity guard in the same case: move the
    soaker onto backyard_01 and at least one refusal must appear, or the clean result above is
    being produced by a law that cannot say no.
    **A — if you want it at DATA level rather than in my suite**, `import { pairingRefusals }
    from './weather.js'` in `board.js` and throw on a non-empty result at load. My brief's words
    were "a DATA-level constraint on the pool agreed with A in THREADS — never a runtime
    surprise", and the suite is where I can put it without touching your file. Yours to promote.
 [C] 2026-07-21 — 🔬 **MUTATIONS, THE DISCLOSURE, AND A FALSE ALARM I KILLED BY MEASURING IT.**
    Six run on my own tree before the convergence, and the two that guard the surviving code
    re-run on THIS tree after the code changed address (the whole point of re-running: a
    mutation receipt is about the shipped file, not about a file that used to exist):
    | mutation | result |
    |---|---|
    | offer band drops the HAIL line (the night-7 trap) | RED — "storm_02_wildnight: hails for 11.4s but the band's hail line is MISSING" |
    | soaker's restriction deleted from `PAIRING_LAW` | RED ×2 — "the soaker over the backyard is offerable — the ~31% hail-cover measurement has stopped being enforced" |
    | offer band drops the CHANGE line | RED — "the two busters differ on `sustained to 13 m/s…` — expected the CHANGE TIME to be the difference" |
    | offer band drops the rain-rate line | RED — "storm_01_gentle: no rain-rate line on the offer band" |
    | night 7's soaker moved onto backyard_01 in week.js | RED — the ladder gate names the yard AND the measurement; D's two week laws also went red, which is them working |
    | `collateralKey: "swing_set"` stripped from site_03 JSON | RED — reachability; superseded by the other session's stronger cross, recorded because it was run |
    All restored; final run green.
    **⚠️ A HOLE IN MY OWN GATE, found by probing it rather than reading it** — and worth
    recording even though the code it lived in is gone, because the OTHER session's
    `STONE_WORD_CEILING` fixes the top of exactly this range and nothing yet fixes the bottom:
    a def with `hail.size: 0` and a live hail curve worded itself **"fine pea stones"**, because
    `stoneWord` has no FLOOR and `0 < 0.6`. The card names a stone the storm does not carry, on
    the axis the entire fabric bet is decided on. Their ceiling refuses 2.6; nothing refuses 0.
    **Filed for whoever holds the pen on `forecastHonest` next** (one line beside the ceiling
    check): `if (s.hailSeconds > 0 && !(s.hailSize > 0)) errors.push(…)`. Not landed by me — it
    is inside their predicate and this is the wrong sprint for two people editing one function.
    **THE FALSE ALARM, recorded because the process is the point.** I thought my dressed worlds
    had taken the selftest from ~25 s to ~115 s and was about to trim the harness. Measured it
    instead: **baseline 485/0/0 takes 131 s; 496/0/0 with my work took 115 s.** The "25 s" was
    never a measurement — it was the first number I happened to read off a poll. Dressing all
    three sites costs ~90 ms total (loadSite 4–5 ms, dress 28–32 ms each). Nothing was trimmed,
    and the suspicion is dead rather than parked. Measure, don't reason.
    **Two smalls for A, neither urgent.** (1) Pool ids `corner_block_no_house` and
    `corner_block_cheapest` — the first is `site_03_swing_lawn`, not the corner block (the
    `_why`, the client and the brief are all right; only the id reads wrong, and ids surface in
    `takenOffer` and the settlement). (2) On most nights the two offers carry DIFFERENT STORMS
    for the same night — a fiction question, not a bug. Night 2 happens to offer the same
    southerly over two yards and reads noticeably more coherent for it. Yours to rule if it
    ever matters; the band tells the truth either way.
 [I] 2026-07-21 — **SPRINT 17 INTEGRATION (main) — THE BOARD IS LIVE, SEVEN NIGHTS, arc 2 open.**
    Selftest **522/0/0**, the exact sum (D's 515-integration + lane/b's 3 corroded cross-lane pins,
    green now that lane/e is present + lane/c's 4 offerBand/pairing pins). Verified in the browser
    and deployed to partly.party/hardyards. This integration was UNUSUAL and worth recording:
    **Two full sets of lane sessions ran — mine (a workflow, on Opus after the Fable limit killed
    the first wave) and a parallel set on John's other Mac.** Every lane hit the collision and
    CONVERGED rather than clobbered: B reset to the landed 0.2/0.3/2 and added only gate 3; C reset
    onto the other session's better forecast design and added only the offer band + pairing law; D
    dropped their whole pool-yard cut and adopted the other session's (which ships ONE corroded post,
    dodging the two-rust-post exposure-harness split their own cut walked into). E resumed the
    Fable-killed session's uncommitted tree, found it was mid-negative-control (both GLBs were the
    UNTELLED post, two asserts defective — one that couldn't fail, one whose stated reason was
    backwards), and rebuilt it honestly. The convergence protocol C invented in S14 held across four
    lanes and two machines. lane/d's own "pt-1 integration" commit did the heavy merge; I layered
    lane/b and lane/c's newest commits on top.
    **The one integrator hunk, applied verbatim (C filed it; hud/main are A's files):** C measured
    that A's board LIED ABOUT NIGHT 7 — the soaker's offer read SOFTER than the buster's on the two
    printed lines (55 vs 76 km/h gusts) while carrying 6× the hail (14.9 s vs 2.4) and 2.7× the rain.
    The board was recommending its own trap in the storm's own voice. `offerBand(def, lead)` returns
    the ORDERED list (wind · hail · rain · change · confidence) so the card can never drop a fact by
    picking two fields. Applied the main.js `band:` line + the hud.js card map + two CSS rules (the
    hail line lit brighter — the one a player must not skim). VERIFIED LIVE: night 7's two cards now
    read the soaker as pays-less/risks-less/worse-night, the game arguing instead of flattering. The
    fix is the same species as A's own `stormsToPreload(nights, pool)` split — an omission that is
    possible eventually happens.
    **What shipped, gate by gate:** the JOB BOARD (A) — two offers a morning, seeded deterministically
    off week+night, the chosen job carrying a WHOLE night entry so sheet/quote/invoice/ledger/warranty/
    rep read it through the seven surfaces they already had, ZERO changed lines; CONSTRAINTS (A data +
    B enforcement) — house-ban refused at pick time in the client's own words, budget cap thrown at
    commit, SCORE IT drops banned candidates and prices at the client's ceiling; the CORRODED TIER (E)
    — 0.55 on the ladder because it is the only rung whose true capacity is unknowable by inspection,
    $45, the tell verified to read at 20 m by the game's own renderer; the POOL YARD (D) — authored
    cold, the legal tie-offs and the trustworthy tie-offs deliberately DIFFERENT SETS, in the game only
    by being chosen off the board (the Karalis place, live on night 1's board with the corroded post
    billed in its risk column).
    **Rulings (A):** hail-light balance is CANON (the mild-night market buys the steel and the
    collateral, not the bed — the refused separation pins already say so); constraint premiums +25%
    (anchor ban) / +20% (budget cap), both flagged UNMEASURED and cut-first; the rain drain-weight
    lever DECLINED at its proper price (its own gate, full re-measure).
    **Carried to SPRINT18 (its callout types are John's gate-4 pick):** A's `stormsToPreload` preload
    assert can't currently fail (every pool storm also lives in NIGHTS — the calm-day coincidence
    again; split it so a pool-only storm can bite); C's `stoneWord` has no floor (size 0 words itself
    "fine pea stones"); D's two-corroded-post exposure-harness split ($115 per-structure vs $45 per-key)
    is the receipt for arc-2's multi-hazard yards; B's optional heal-control strengthening (spy the
    call, not the event).
    **Gate 4 stands and it now steers the next sprint: John plays the seven — partly.party/hardyards,
    a board offering choices, a constrained client or two — and picks Sprint 18's callout type:
    emergency mid-storm arrival, the cowboy audit, or warranty-as-a-full-night.**
--- a/tools/site_audit/gardenfly.selftest.js
+++ b/tools/site_audit/gardenfly.selftest.js
@ -33,15 +33,6 @@ import { createSkyFx } from '../../web/world/js/skyfx.js';
 import { createGarden } from '../../web/world/js/garden.js';
 import { FIXED_DT } from '../../web/world/js/contracts.js';
 import { flyGarden, flySeparation, hardwareByName } from './gardenfly.js';
 import { buildScoringWorld, collateralExposure } from './scorecard.js';
 import { factoryExtras } from '../../web/world/js/ratings.js';
 // SPRINT17 gate 3 [B] — CROSS-LANE SEAM. The corroded tier (rating_hint 0.55,
 // the GLB, the gen entry) lives on lane/e. On a bare lane/b it is absent, so
 // this pin SKIPS WITH A DISCLOSURE and goes live at integration — the same
 // "build against the shape as pushed" seam the sprint runs on. Measured GREEN
 // on the scratch merge (lane/a + lane/e): hint 0.55, collateral $45.
 const CORRODED_TIER_LIVE = !!(factoryExtras('corroded_post'));
 const assert = (cond, msg) => { if (!cond) throw new Error(msg); };
@ -165,62 +156,7 @@ export async function buildGardenflyTests() {
    fabRun = { byDefault: flyFab(undefined), cloth: flyFab(0.30), membrane: flyFab(0) };
  } catch (err) { fabErr = String((err && err.stack) || err); }
  // SPRINT17 gate 3 support [B]: the corroded tier priced through the CARD'S
  // OWN path, in a real dressed world. E landed the post; the 0.2/0.3/2 pass
  // deferred gate 3; this pins that a corroded anchor prices honestly the
  // moment it is placed. Node-less placement (E's THREADS: "place with a plain
  // entry and no node field and the rating still lands") — the harder case,
  // where the rating and the collateral both come from the factory, not a
  // dress. buildScoringWorld only DRESSES (no sweep), so this is ~40 ms.
  let corRun = null, corErr = null;
  try {
    if (!CORRODED_TIER_LIVE) throw { skip: true };
    const corSite = await loadSite('backyard_01');
    corSite.structures = [...(corSite.structures ?? []), {
      id: 'cor1', model: 'sail_post_corroded_v1', wreckedModel: 'sail_post_corroded_wrecked_v1',
      x: 6, z: 2, rotYDeg: 0, solid: true,
      collateralKey: 'corroded_post', collateralValue: 45, collateralLabel: 'the corroded post',
      anchors: [{ id: 'cor1_a1', type: 'corroded_post', work: 'cloth' }],
    }];
    const built = await buildScoringWorld(corSite);
    const anc = built.anchors.find((a) => a.id === 'cor1_a1');
    const col = {};
    for (const a of built.anchors) {
      if (!a.collateral) continue;
      const p = built.world.collateralFor(a.collateral);
      col[a.id] = p ? { key: a.collateral, cost: p.cost, label: p.label }
        : { key: a.collateral, cost: null, label: a.collateral, unpriced: true };
    }
    corRun = { anchor: anc, priced: built.world.collateralFor('corroded_post'),
      exposure: collateralExposure({ collateral: col }), dressed: built.dressed, dressError: built.dressError };
  } catch (err) { if (err && err.skip) corErr = 'skip'; else corErr = String((err && err.stack) || err); }
  return [
    ['gate 3: a corroded post prices honestly in the card — 0.55 hint, $45 collateral, dressed', () => {
      if (!CORRODED_TIER_LIVE) return 'SKIPPED — corroded tier lands with lane/e; measured GREEN on '
        + 'the scratch merge (hint 0.55, collateral $45 through collateralFor)';
      if (corErr) throw new Error(`corroded pricing died: ${corErr}`);
      assert(corRun.dressed, `the corroded world did not dress (${corRun.dressError}) — GLB missing or broke`);
      const a = corRun.anchor;
      assert(a, 'the corroded anchor cor1_a1 was not created');
      // The STEEL half, node-less: factoryExtras had to reach it, or the tier
      // math prices this trap as the best steel in the game (adoptAnchor's
      // `?? 1`, E's load-bearing _v1 warning).
      assert(a.ratingHint === 0.55, `corroded anchor rated ${a.ratingHint}, not 0.55 — a node-less placement `
        + 'lost E\'s factory hint and the card would price it as sound steel');
      assert(a.collateral === 'corroded_post', `corroded anchor collateral "${a.collateral}", not "corroded_post"`);
      // The COLLATERAL half, through the card's OWN resolver and exposure sum —
      // not the baked GLB value read directly (the carport-to-null shortcut).
      assert(corRun.priced && corRun.priced.cost === 45,
        `world.collateralFor('corroded_post') gave ${JSON.stringify(corRun.priced)}, expected $45`);
      assert(corRun.priced.label === 'the corroded post', `collateral label "${corRun.priced.label}"`);
      const line = corRun.exposure.priced.find((e) => e.key === 'corroded_post');
      assert(line && line.cost === 45,
        `collateralExposure has no $45 corroded line (${JSON.stringify(corRun.exposure.priced.map((e) => [e.key, e.cost]))})`);
      assert(!corRun.exposure.unpriced.some((e) => e.key === 'corroded_post'),
        'the corroded post landed in UNPRICED — the exposure total silently drops its $45');
      return `corroded_post: hint ${a.ratingHint}, collateral $${corRun.priced.cost} "${corRun.priced.label}", in the exposure sum`;
    }],
    ['gardenfly: the pinned separation line, flown in BOTH chains — the 12s-skew disagreement, pinned', () => {
      // ⚠ THE STATE OF PLAY (2026-07-18, [B] THREADS, receipts in the entry):
      // the pinned recipe HOLDS and rigging matters by a full state's width —
--- a/web/world/js/hud.js
+++ b/web/world/js/hud.js
@ -331,11 +331,6 @@ const CSS = `
 #hud-card .offer .line { display:flex; justify-content:space-between; gap:14px;
  font-size:12px; color:#8ba0ad; padding:2px 0; }
 #hud-card .offer .line b { color:#dde5ea; font-weight:700; }
 /* SPRINT17 [C]: the weather band. The hail line is lit brighter than the rest
   because the soaker's whole trap is that its wind reads gentle — the one line
   a player must not skim past. */
 #hud-card .offer .line.wx { color:#8ba0ad; }
 #hud-card .offer .line.hail span { color:#cbd8e0; }
 /* The two numbers a tradie decides on. The fee is the reason to say yes and
   the exposure is the reason to say no, so they are weighted against each
   other rather than both being grey: money in, money at risk. */
@ -821,17 +816,14 @@ export function createHud(d) {
      const offerHtml = (o, i) => {
        const n = o.night;
        const cons = o.constraints ?? [];
-        // SPRINT17 [C], applied by the integrator: the offer maps C's ORDERED
+        const f = o.forecast;
        // band (wind · hail · rain · change · confidence) instead of picking
        // two forecast fields, so an offer card can never hide a night's hail.
        // The .hail line is lit brighter because it is the one a player must
        // not skim past — the soaker's whole trap is a gentle-reading wind.
        return `
        <button class="offer${cons.length ? ' constrained' : ''}" data-offer="${i}">
          <span class="tag">${o.kind === 'scripted' ? 'tonight, as booked' : 'callout'}</span>
          <div class="who">${n.client ?? 'no client'}</div>
          <div class="addr">${n.addr ?? ''}</div>
-          ${(o.band ?? []).map((l) => `<div class="line wx ${l.key}"><span>${l.text}</span></div>`).join('')}
+          ${f?.wind ? `<div class="line"><span>${f.wind}</span></div>` : ''}
          ${f?.stones ? `<div class="line"><span>${f.stones}</span></div>` : ''}
          ${o.fee != null ? `<div class="line fee"><span>the job pays${
            o.premium ? ` · +${Math.round(o.premium * 100)}% on their terms` : ''
          }</span><b>$${o.fee}</b></div>` : ''}
--- a/web/world/js/main.js
+++ b/web/world/js/main.js
@ -17,7 +17,7 @@ import * as THREE from '../vendor/three.module.js';
 import { FIXED_DT, PHASES, STORM_LEN, HARDWARE, SPARE_COST, Emitter } from './contracts.js';
 import { createWorld, loadSite } from './world.js';
 import { createCameraRig, spawnYawFor } from './camera.js';
-import { loadStorm, createWind, forecastLines, offerBand } from './weather.js';
+import { loadStorm, createWind, forecastLines } from './weather.js';
 import { SailRig, createSailView } from './sail.js';
 import { createPlayer } from './player.js';
 import { Interact, wireYardActions } from './interact.js';
@ -1041,12 +1041,6 @@ export async function boot(opts = {}) {
        // C's honest lines at lead 0 — tonight, exact. The same call the job
        // sheet makes, so the board can never be more confident than the sheet.
        forecast: def ? forecastLines(def, 0) : null,
        // SPRINT17 [C], applied by the integrator: the ORDERED band the offer
        // card maps, so a night's hail can never be dropped by the card picking
        // two fields. Night 7 read softer than the buster on wind+stones alone
        // (55 vs 76 km/h) while carrying 6× the hail — the board recommending
        // its own trap. offerBand carries every fact the storm has.
        band: def ? offerBand(def, 0) : null,
        fee: def ? calloutFee(def, week.rep, night.constraints) : null,
        exposure: exp.total,
        exposureItems: exp.items,
--- a/web/world/js/rigging.selftest.js
+++ b/web/world/js/rigging.selftest.js
@ -9,7 +9,6 @@
 import { RiggingSession, FABRIC, fabricNoteFor } from './rigging.js';
 import { SailRig, TENSION_MIN, TENSION_MAX } from './sail.js';
 import { HARDWARE, START_BUDGET, SPARE_COST } from './contracts.js';
 import { factoryExtras } from './ratings.js';
 const [CARABINER, SHACKLE, RATED] = HARDWARE;
@ -495,66 +494,6 @@ test('gate 2: the constraint door is a checked enum, and the terms survive reset
  return 'five malformed shapes thrown out at the door; terms survive reset, cleared only explicitly';
 });
 // --- SPRINT17 gate 3 support: THE CORRODED TIER PRICES HONESTLY -------------
 // E landed the corroded post (rating_hint 0.55, its own ANCHOR_TYPE word, a
 // $45 collateral); the gates-0.2/0.3/2 pass DEFERRED gate 3, and this is it.
 // B owns the pricing surfaces the card reads, so the number the shop charges
 // for a corroded corner is pinned HERE, off E's real resolver — not a
 // hand-typed 0.55. The collateral half ($45 through world.collateralFor → the
 // exposure line) is pinned in gardenfly.selftest, where a dressed world exists;
 // this is the STEEL half: a corroded post is weaker, so the same load costs
 // MORE steel to hold, which is what "prices honestly" means and is B's tier
 // math (_effRating), not E's mesh.
 //
 // ⚠️ CROSS-LANE SEAM. The corroded tier lives on lane/e; on lane/b in
 // isolation `factoryExtras('corroded_post')` is null (no gen entry, no GLB).
 // These pins SKIP WITH A DISCLOSURE on a bare lane/b and go live the moment
 // lane/e merges — the "build against the shape as pushed" seam the sprint runs
 // on. Measured GREEN on the scratch merge (lane/a + lane/e): hint 0.55.
 const CORRODED_TIER_LIVE = !!(factoryExtras('corroded_post'));
 const CORRODED_SKIP = 'SKIPPED — corroded tier is on lane/e, absent on bare lane/b; this pin is '
  + 'inert here and goes live at integration (measured GREEN on the scratch merge, hint 0.55)';
 test('gate 3: the corroded tier is 0.55, read off E\'s resolver not a literal', () => {
  if (!CORRODED_TIER_LIVE) return CORRODED_SKIP;
  const ex = factoryExtras('corroded_post');
  assert(ex && ex.ratingHint === 0.55,
    `factoryExtras('corroded_post') gave ${JSON.stringify(ex)} — the card reads this for a node-less `
    + 'corroded placement, and if E re-rules the number it must move here, not be re-typed');
  assert(ex.collateral === 'corroded_post',
    'the corroded anchor carries no collateral key — the exposure line would read "not scored" over a $45 trap');
  return `corroded_post → hint ${ex.ratingHint}, collateral "${ex.collateral}"`;
 });
 test('gate 3: a corroded corner costs MORE steel than a sound post at the same load', () => {
  if (!CORRODED_TIER_LIVE) return CORRODED_SKIP;
  // _effRating is what the panel's arrow and the audit's tier both price
  // against: hardware.rating × the anchor's ratingHint. A corroded post fails
  // at 0.55 of the steel's spec, so a load a carabiner holds on a sound post
  // may need a shackle on a corroded one. Built off E's real hint.
  const hint = factoryExtras('corroded_post').ratingHint;
  const SOUND = { id: 'ps', type: 'post', pos: { x: -6.4, y: 3.9, z: 7.4 }, sway: () => ({ x: -6.4, y: 3.9, z: 7.4 }) };
  const COR = { id: 'pc', type: 'corroded_post', pos: { x: 5.3, y: 3.9, z: 8 }, ratingHint: hint,
    sway: () => ({ x: 5.3, y: 3.9, z: 8 }) };
  const s = new RiggingSession({ anchors: [SOUND, COR, ...ANCHORS] });
  s.rig('ps'); s.rig('pc'); s.rig('h1'); s.rig('t1');
  const sound = s._effRating(s.pickOf('ps'));
  const cor = s._effRating(s.pickOf('pc'));
  // Both start on carabiners (rating 1200): the sound post holds 1200 N, the
  // corroded holds 1200 × 0.55 = 660 N. Same steel, less strength — measured.
  assert(sound === CARABINER.rating, `sound post effRating ${sound}, expected the carabiner's ${CARABINER.rating}`);
  assert(Math.abs(cor - CARABINER.rating * hint) < 1e-9,
    `corroded effRating ${cor}, expected ${CARABINER.rating} × ${hint} = ${CARABINER.rating * hint}`);
  assert(cor < sound,
    'a corroded post held as much as a sound one — the trap is priced as safe steel, which inverts it');
  // The tier consequence: a load in the corroded gap (660–1200 N) is HELD by a
  // carabiner on the sound post and OVER a carabiner on the corroded one.
  const load = 900;
  assert(load < sound && load > cor,
    `pick a load in the corroded gap (${cor}..${sound} N) so the tier difference is real`);
  return `same carabiner: sound holds ${sound} N, corroded holds ${cor} N — the rust costs a tier`;
 });
 export const RIGGING_TESTS = TESTS;
 export function runRiggingSelftest() {
--- a/web/world/js/tests/c.test.js
+++ b/web/world/js/tests/c.test.js
@ -19,15 +19,12 @@ import { FIXED_DT, checkContract, DEBRIS_PIECE_FIELDS, createStubWind } from '..
 import {
  loadStorm, createWind, windForSite, forecastLines, forecastFor, leadFor, hailBlockFor,
  forecastHonest, stormStats, STONE_WORD_CEILING,
  // SPRINT17, the second half of gate 1 (see weather.js's divider): what the
  // card PRINTS, and which yard a storm may be printed over.
  offerBand, PAIRING_LAW, pairingRefusal, pairingRefusals,
 } from '../weather.js';
 import { loadSite, createWorld } from '../world.js';
 // SPRINT17 gate 1 — the board's weather side. NIGHTS ∪ POOL is every storm an
 // offer card can print; both are data, so the honesty walk below tracks them
 // without a test edit the day D's pool yard lands.
-import { NIGHTS, nightAt } from '../week.js';
+import { NIGHTS } from '../week.js';
 import { POOL, exposureOf } from '../board.js';
 // GATE 2.3 — the GAME's own wind wiring, IMPORTED rather than re-typed. A pin
 // that copied main.js's two lines would agree with a copy of the game forever,
@ -1385,133 +1382,6 @@ export default async function run(t) {
    }
  });
  t.test('GATE 1 (S17): the offer band carries every fact the storm delivers, and none it does not', () => {
    // ⚠️ THE FINDING THIS CASE EXISTS FOR. A's board prints `f.wind` and
    // `f.stones` — a reasonable pair — and under that pair NIGHT 7 LIES:
    //   soaker (scripted)     gusts to ~55 km/h · fine pea stones
    //   early buster (alt)    gusts to ~76 km/h · pea stones
    // On both printed lines the soaker is the softer job, while delivering
    // 14.9s of hail against 2.4s and 44 mm/hr against 16.5. `offerBand` returns
    // the ORDERED LIST instead, so the forecast decides which facts a night
    // carries and a card cannot drop the next one somebody adds.
    for (const nm of offerStormNames) {
      const def = offerDefs[nm];
      const st = stormStats(def);
      const lines = offerBand(def, 0);
      const keys = lines.map((l) => l.key);
      const text = (k) => lines.find((l) => l.key === k)?.text ?? '';
      assert(keys.includes('wind'), `${nm}: no wind line on the offer band`);
      assert(keys.includes('rain'), `${nm}: no rain-rate line on the offer band`);
      assert(keys.includes('change'), `${nm}: no change line on the offer band`);
      assert(!keys.includes('confidence'),
        `${nm}: tonight's band hedged its own confidence — lead 0 is exact`);
      // HAIL, BOTH DIRECTIONS — the assert night 7 needed. Present iff it hails:
      // a missing line recommends the trap, an invented one teaches that the
      // absence of a hail line means somebody checked.
      assert(keys.includes('hail') === (st.hailSeconds > 0),
        `${nm}: hails for ${st.hailSeconds.toFixed(1)}s but the band's hail line is `
        + `${keys.includes('hail') ? 'present' : 'MISSING'}`);
      if (st.hailSeconds > 0) {
        assert(/fine pea|pea|marble|golf ball/.test(text('hail')),
          `${nm}: hail line has no stone word — "${text('hail')}"`);
        assert(/\ds of it/.test(text('hail')),
          `${nm}: hail line does not say how long it hails — "${text('hail')}"`);
      }
      // The rate is the OTHER half of the soaker's trap, and the unit ponding
      // reads — its absence is what made the two-field card lie.
      assert(new RegExp(`${Math.round(st.rainPeakMmPerHour)} mm/hr`).test(text('rain')),
        `${nm}: peaks at ${st.rainPeakMmPerHour.toFixed(1)} mm/hr, band says "${text('rain')}"`);
      if (st.changeAt != null) {
        assert(text('change').includes(`${Math.round(st.changeAt)}s`),
          `${nm}: changes at ${st.changeAt}s, band says "${text('change')}"`);
      } else {
        assert(!/\d/.test(text('change')), `${nm}: never changes, band says "${text('change')}"`);
      }
      for (const l of lines) {
        assert(!/NaN|Infinity|undefined/.test(l.text),
          `${nm}: the ${l.key} line does not word its own numbers — "${l.text}"`);
      }
    }
  });
  t.test('GATE 1 (S17): the two buster variants are TELLABLE APART on a board card', () => {
    // storm_03 and storm_03b are IDENTICAL in every number the band prints
    // (sustained 13.0, gustPeak 21.4/21.2, rain 16.5 mm/hr, hail 2.4s at size
    // 0.70) and differ ONLY in when the change lands, 30s against 18s. The
    // board offers exactly that pair — the buster is the drawn alternative on
    // nights 5 and 7. Drop the change line and the board offers two jobs whose
    // weather it has just claimed to describe, described identically, and calls
    // it a choice. That is why the band is a list and not two named fields.
    const a = offerBand(storms.storm_03_southerly, 0).map((l) => l.text);
    const b = offerBand(storms.storm_03b_earlybuster, 0).map((l) => l.text);
    const differing = a.filter((line, ix) => line !== b[ix]);
    assert(differing.length > 0,
      'storm_03 and storm_03b word IDENTICAL offer bands — the board would offer two '
      + 'indistinguishable jobs and call it a choice');
    assert(differing.some((l) => /change/.test(l)),
      `the two busters differ on ${differing.join(' / ')} — expected the CHANGE TIME, since `
      + 'that is the only thing that differs in the storms');
  });
  // ── The PAIRING half of gate 1. `forecastHonest` above asks whether the
  // forecast can describe a STORM; a band can be perfectly honest about a storm
  // and still be an invitation to a night nobody can work. NIGHTS ∪ POOL again,
  // this time carrying the SITE — the dimension the storm-side walk cannot see.
  const offerPairings = [
    ...NIGHTS.map((_, ix) => {
      const n = nightAt(ix);
      return { id: `night ${ix + 1}`, storm: n.storm, site: n.site };
    }),
    ...POOL.map((p) => ({ id: `pool:${p.id}`, storm: p.storm, site: p.site })),
  ];
  t.test('GATE 1 (S17): every offerable PAIRING respects the measured yard/storm law', () => {
    assert(offerPairings.length >= 12,
      `only ${offerPairings.length} pairings found — the NIGHTS ∪ POOL walk is broken`);
    const refused = pairingRefusals(offerPairings);
    assert(refused.length === 0,
      `the board would offer ${refused.length} pairing(s) refused by measurement:\n  `
      + refused.map((r) => `${r.id}: ${r.why}`).join('\n  '));
    // Vacuity guard, on this exact input: without it the assert above passes on
    // a law that returns [] unconditionally — the failure mode I shipped in S13
    // and named. Move ONE night's yard and exactly one refusal must appear.
    const moved = offerPairings.map((p) =>
      (p.storm === 'storm_06_soaker' ? { ...p, site: 'backyard_01' } : p));
    assert(pairingRefusals(moved).length >= 1,
      'moving the soaker onto backyard_01 did not trip the law — the assert above is '
      + 'passing on a gate that cannot say no');
  });
  t.test('GATE 1 (S17): the pairing law refuses what it was measured to refuse, and nothing else', () => {
    // MINE, with the S16 receipt in the message: the soaker over backyard_01
    // has no win in it (hail cover capped at ~31%, both fabrics pond-tearing).
    assert(pairingRefusal('storm_06_soaker', 'backyard_01') !== null,
      'the soaker over the backyard is offerable — the ~31% hail-cover measurement has '
      + 'stopped being enforced');
    assert(/31%/.test(pairingRefusal('storm_06_soaker', 'backyard_01')),
      'the refusal does not carry the measurement that justifies it');
    assert(pairingRefusal('storm_06_soaker', 'site_03_swing_lawn') !== null,
      'the soaker over the swing lawn is offerable, and nobody has ever flown it');
    assert(pairingRefusal('storm_06_soaker', 'site_02_corner_block') === null,
      'the soaker over site_02 is REFUSED — that is the pairing it shipped for');
    // A's two, enforced the same way and credited to A in the data.
    assert(pairingRefusal('storm_02_wildnight', 'site_02_corner_block') !== null,
      'the wild night is offerable off backyard_01, where its separation pin lives');
    assert(pairingRefusal('storm_02b_icenight', 'site_03_swing_lawn') !== null,
      'the ice night is offerable off backyard_01, where gardenBeyondSaving was measured');
    assert(PAIRING_LAW.storm_02_wildnight.owner === 'A' && PAIRING_LAW.storm_06_soaker.owner === 'C',
      'the law has lost track of who ruled which entry — the owner field is how a reader '
      + 'knows whose measurement to go and read');
    // And it must NOT over-refuse: absence of a measurement is not a refusal.
    assert(pairingRefusal('storm_03_southerly', 'site_03_swing_lawn') === null,
      'the southerly over the swing lawn is refused — that is night 4, the shipped ladder');
    assert(pairingRefusal('storm_99_unmeasured', 'anywhere') === null,
      'a storm with no entry in the law was refused — inventing a refusal for a pairing '
      + 'nobody flew is the same offence in the other direction');
  });
  // ── GATE 1.2 (S17): THE EXPOSURE CROSS — A's exposureOf vs the failure
  // route, the S14 pin pattern (two harnesses, one number, by construction).
  // Prep up front (Suite.test can't await); the tests skip honestly offline.
--- a/web/world/js/weather.js
+++ b/web/world/js/weather.js
@ -224,186 +224,6 @@ export function forecastHonest(def, name = def?.name ?? 'storm') {
  return { ok: errors.length === 0, errors };
 }
 // ─────────────────────────────────────────────────────────────────────────────
 //  THE OFFER BAND, and THE PAIRING HALF OF THE GATE (SPRINT17 gate 1)
 //
 //  Landed ON TOP of forecastHonest above, by the other half of Lane C this
 //  sprint — two sessions converged on gate 1 and split it cleanly without
 //  meaning to. `forecastHonest` answers "can the forecast describe this STORM",
 //  which is the storm-side gate and stays exactly as it landed. These two add
 //  the parts it does not reach: WHAT THE CARD ACTUALLY PRINTS, and WHICH YARD
 //  the storm may be printed over. Nothing above this line was changed.
 // ─────────────────────────────────────────────────────────────────────────────
 /**
 * THE HONEST BAND FOR AN OFFER CARD — an ORDERED LIST of lines, not a bag of
 * named fields, and the shape is the whole point.
 *
 * ⚠️ **WHY A LIST, when `forecastLines` already returns every string a card
 * could want.** A card that reads named fields prints the fields its author
 * remembered. A's board shipped `f.wind` and `f.stones` — a reasonable pair —
 * and that pair MEASURABLY LIES ABOUT NIGHT 7:
 *
 *   | night 7's two offers | wind line | stones line |
 *   |---|---|---|
 *   | the soaker (scripted) | gusts to ~55 km/h | fine pea stones |
 *   | the early buster (alt) | gusts to ~76 km/h | pea stones |
 *
 * On both printed lines the soaker is the SOFTER job. It is not: it delivers
 * **14.9 s of hail against 2.4 s, and 44 mm/hr of rain against 16.5**. The
 * soaker's whole design is that its wind reads gentle while its hail is the
 * trap (C, S16 gate 3.1) — so a board printing only wind and stone size
 * recommends the trap, in the storm's own voice, before a dollar is spent.
 *
 * The fix is not "also print rainRate". The fix is that the FORECAST decides
 * which facts a night carries and hands over all of them, so the next fact
 * added to a storm cannot be silently dropped by a card that predates it. Same
 * construction, and the same reasoning, as A's `stormsToPreload(nights, pool)`
 * split: an omission that is possible will eventually happen.
 *
 * ⚠️ **It never renders MORE than the truth either.** A hail line appears if and
 * only if the storm hails — "hail: none" on a hail-free night teaches that the
 * absence of a hail line means nobody checked.
 *
 * @param {object} def   parsed storm JSON
 * @param {number} [lead] 0..1 — the BOARD passes 0, and only 0: both offers are
 *   for TONIGHT. You are choosing which yard to stand in, not which night to
 *   work, and a hedged board would invent uncertainty the job sheet contradicts
 *   one card later.
 * @returns {{key:string, text:string}[]} reading order: wind, hail, rain,
 *   change, confidence. `key` is for styling; `text` is the whole printed line.
 */
 export function offerBand(def, lead = 0) {
  const f = forecastLines(def, lead);
  const ff = forecastFor(def, lead);
  const t = f.truth;
  const i = (v) => v.toFixed(0);
  const lines = [{ key: 'wind', text: f.wind }];
  // Hail, with its DURATION. `chance` at lead 0 is a duration threshold wearing
  // a probability word (hailSeconds > 6 ⇒ 'likely'), which is honest enough on
  // a job sheet and far too coarse on a board where two hail nights sit side by
  // side: 'likely' covers both the soaker's 15 s and the ice night's 21 s, and
  // 'possible' covers the buster's 2.4 s. The seconds are what a tradie buys
  // steel against, so the seconds print.
  if (f.stones) {
    lines.push({
      key: 'hail',
      text: `hail ${f.hail.chance} · ${f.stones} · ${bandStr(ff.hail.seconds, i)}s of it`,
    });
  }
  // The rain RATE, always — the line A's card had no field for, and half of the
  // soaker's trap. mm/hr is the unit the ponding model reads, so the card and
  // the sim agree on what "heavy" means instead of each having an opinion.
  lines.push({ key: 'rain', text: f.rainRate });
  // The change, always — including "no change forecast", which is information,
  // not filler. storm_03_southerly and storm_03b_earlybuster are IDENTICAL in
  // every other number this band prints (sustained 13.0, gustPeak 21.4/21.2,
  // rain 16.5 mm/hr, hail 2.4 s at size 0.70) and differ ONLY in when the change
  // lands, 30 s against 18 s. The board offers exactly that pair — the buster is
  // the drawn alternative on nights 5 and 7. Drop this line and the board offers
  // two jobs whose weather it has just claimed to describe, described
  // identically, and calls it a choice.
  lines.push({
    key: 'change',
    text: t.changeAt == null ? 'no change forecast'
      : (lead > 0 ? `southerly change ${bandStr(ff.changeAt, i)}s`
                  : `southerly change at ${i(t.changeAt)}s`),
  });
  if (f.confidence) lines.push({ key: 'confidence', text: f.confidence });
  return lines;
 }
 /** `band` under its own name — the module-scope helper, reused rather than retyped. */
 function bandStr(b, fmt) { return band(b, fmt); }
 /**
 * ⚖️ **THE PAIRING LAW — which yards a storm may be OFFERED over.**
 *
 * `forecastHonest` above asks whether the forecast can describe a STORM. This
 * asks the other half of SPRINT17 gate 1's rule, the half that is a fact about
 * GEOMETRY × STORM rather than about wording: a band can be perfectly honest
 * about a storm and still be an invitation to a night nobody can work.
 *
 * ⚠️ **These three were three prose comments before they were a rule.** A's POOL
 * carries them as a comment listing what is "deliberately NOT here" — and this
 * repo's standing verdict on that arrangement is A's own, on CONSTRAINT_KIND:
 * an unenforced enum is decoration, and the carport shipped typed as a post for
 * a sprint behind a JSDoc comment saying it couldn't. A comment cannot fail when
 * somebody adds the sixth pool entry. Promoted to data, checked, red in the suite.
 *
 * **A — two of these three are YOUR reasons and are recorded as yours.** I have
 * not re-measured a separation pin or a beyond-saving flag; I have moved your
 * stated grounds into a structure that goes red. Reword freely — the mechanism
 * is what I am defending, not the prose.
 *
 * An absent key means UNRESTRICTED, deliberately: this table records refusals
 * somebody PAID FOR, and inventing one for a pairing nobody flew is the same
 * offence in the other direction.
 */
 export const PAIRING_LAW = Object.freeze({
  storm_06_soaker: {
    sites: ['site_02_corner_block'],
    owner: 'C',
    why: 'MEASURED (C, S16 gate 3.1, both shipped yards flown through gardenfly before the '
       + 'storm shipped): backyard_01\'s buyable geometry caps hail cover over the bed at '
       + '~31%, and its full-cover quads pond-tear at 3.3–3.7 kN in this mild wind on BOTH '
       + 'fabrics — best membrane line 37.5 against cloth 17.3, a fabric bet with no win in '
       + 'it. The soaker\'s forecast reads "fine pea stones · rain to 44 mm/hr" over there '
       + 'exactly as it does over site_02, and over there that band is an invitation to a '
       + 'night nobody can work. The swing lawn is not measured under it at all, which is '
       + 'the same refusal for a cheaper reason.',
  },
  storm_02_wildnight: {
    sites: ['backyard_01'],
    owner: 'A',
    why: 'A (S17 gate 1, POOL): its separation is PINNED to backyard_01\'s site data. Fly it '
       + 'elsewhere and the pin describes a night nobody plays.',
  },
  storm_02b_icenight: {
    sites: ['backyard_01'],
    owner: 'A',
    why: 'A (S17 gate 1, POOL), on A\'s S13 measurement: `gardenBeyondSaving` is a fact about '
       + 'THAT BED under that ice, not a property of the storm. Offered over another yard the '
       + 'night would carry the excuse without the evidence.',
  },
 });
 /**
 * May this storm be offered over this yard?
 * @returns {string|null} the refusal in English, or null when the pairing is offerable
 */
 export function pairingRefusal(stormKey, siteKey) {
  const law = PAIRING_LAW[stormKey];
  if (!law || !law.sites) return null;
  if (law.sites.includes(siteKey)) return null;
  return `${stormKey} over ${siteKey}: not an offerable pairing — ${law.why} `
       + `(offerable: ${law.sites.join(', ')}; ruled by ${law.owner})`;
 }
 /**
 * Every pairing refusal in a list of candidate nights, as data.
 *
 * ⚠️ Deliberately NOT a filter. Silently dropping a bad entry leaves a morning
 * with one offer and no explanation — a runtime surprise wearing a fix's
 * clothes. The caller (c.test today; a `board.js` load-time assert the day A
 * wants one) decides how loud to be, and gets the measurement in the message.
 *
 * @param {Array<{id?:string, storm:string, site:string}>} pairings
 * @returns {{id:string, why:string}[]} empty = every pairing is offerable
 */
 export function pairingRefusals(pairings = []) {
  const out = [];
  for (const p of pairings) {
    const why = pairingRefusal(p.storm, p.site);
    if (why) out.push({ id: p.id ?? `${p.storm}×${p.site}`, why });
  }
  return out;
 }
 // Resolved against this module, not the server root: server.py serves the repo
 // root (so the 2D prototype stays reachable), but the demo bench serves web/.
 // import.meta.url is right under both, and under whatever Lane A does next.