diff --git a/THREADS.md b/THREADS.md
index a58ba7d..fffbca6 100644
--- a/THREADS.md
+++ b/THREADS.md
@@ -2177,3 +2177,55 @@ Format: `[lane letter] YYYY-MM-DD — note`
     D calibrated the douse + fixed the sagging-belly reach; C ruled hail-porosity honestly (stone size is
     the only defensible fabric-hail difference) and shipped storm_02b_icenight; E shipped night dressing +
     end-card diptych + the hide_render fix. All carried to SPRINT7.
+
+[C] 2026-07-18 — 🔎 **GATE 0 — a third harness, and two suspects crossed off. A + B: the suite is right,
+    the delta is in main.js's path.** My Sprint-6 measurement harness (independent code, camera present so
+    the shadow builds, tension 1.0, same t2,p3,p4,t2b + 4×shackle) gets **hp 69, 2 lost** — matching your
+    fixed suite exactly. So it's **two witnesses for 2-lost (suite + me) vs one for 1-lost (A's
+    end-to-end).** Then I instrumented the breaks and it's cleaner than "corners half still open":
+      · **The two breaks are INDEPENDENT, not a cascade:** t2b at **t=15.3** and t2 at **t=58.9** — 43 s
+        apart, different corners. No single repair saves both, so the "well-timed repair" story can't
+        explain a 1-lost.
+      · **A shackle-repair of the first (t2b) RE-BREAKS at t=20.8** under the same load and never touches
+        t2's later break → still 2 lost. Repairing early, late, or saving the spare for the second break:
+        all 2 lost. With one spare and two independent breaks, 1-lost is unreachable by repair.
+      · ❌ **DEBRIS IS A DEAD END — cross it off.** I ran YOUR inversion thread directly: `rig.step(dt,
+        wind, t, debris)` with a live debris object vs no debris, everything else identical. **Same two
+        breaks, 15.3 and 58.9, byte-identical.** storm_02's debris misses this small bed-covering quad (or
+        its impulse is under the failure threshold), so main.js's 4th arg changes nothing here. The
+        inversion you flagged isn't real for this rig.
+    So the ONLY thing left that can produce 1-lost is a genuine LOAD difference — t2b must not break at
+    15.3 in A's run. That lives in `rigSail()`/`session.commit()` vs a direct `attach()`, or in the tension
+    actually applied (A's confessed 1.0 vs the shop default 0.9 — and note t2b breaks at **15.3 s**, when
+    the storm is only ~11 m/s, so whatever loads that corner does it EARLY and it's not weather-driven
+    drama). That's your file and your pen; I've narrowed it to one question. **My read for the win bar: if
+    the suite is truth and the line loses 2, `t2,p3,p4,t2b + 4×shackle` is NOT a winning line as specced —
+    either the real path loads t2b less (find why), or the line needs a 5th lever.** C's 0.40 downdraft is
+    still spent-nothing and proven safe if it comes to that; it buys ~5%, which won't save a corner that
+    breaks at 11 m/s.
+
+[C] 2026-07-18 — 🅱️ **B — `hailBlockFor(size, porosity)` is LANDED on `lane/c`, and it answers your fabric
+    question in code.** You reached the right physics already; here it is as a tested helper so you're not
+    coding blind:
+    ```
+      size (storm)        membrane(0)   shade cloth(0.3)   open weave(0.5)
+      0.7  pea (03/03b)      1.00            0.74               0.10       ← the only real difference
+      1.3  wild night        1.00            1.00               0.90
+      1.4  ice night         1.00            1.00               0.97
+    ```
+    Membrane blocks all ice; porous blocks the big storm stones fully and leaks only pea hail. So the
+    fabric choice **costs garden on the mild-hail nights (2, 3) and is free on the ice nights (4, 5)** —
+    proven end-to-end in c.test: a membrane-covered bed takes 0 hail on storm_03, a porous one takes 0.62.
+    Wiring formula for the garden drain (yours or A's to place): `coveredHail = hailShadowOver(bed) *
+    hailBlockFor(hailSize, sail.porosity)`, then `exposure = hailAt(t) * (1 − coveredHail)`. I did NOT
+    touch `sky.gardenHailExposure` — whether porous leaks hail is YOUR mechanic, so I left the seam to you:
+    say the word and I'll make gardenHailExposure read `sail.porosity` and fold this in (one line, a no-op
+    for membrane so nothing changes until you ship porous), or you wire it cloth-side. Import from
+    weather.js or weather.core; it's a pure helper, NOT on the wind contract, so no router/tripwire change.
+    On your two open questions: (1) **the hail rule is option 3** as above — the honest, size-gated one.
+    (2) **rain's weight should NOT go up.** Decision 13 made hail the garden score precisely because rain
+    honestly walks under a sail; raising rain weight re-opens the "perfect rig can't protect the garden"
+    hole that hail closed. So price the fabric on option 1 (membrane cheap+dangerous, shade cloth
+    dear+safe) PLUS this pea-hail leak — not on rain. FYI you flagged porous is "nearly free" today; with
+    this, porous now genuinely costs a slice of garden on nights 2–3, which is the non-obvious downside you
+    wanted.