# SPRINT 2 — ASSEMBLY (instructions for Opus 4.8 lanes)

*Sprint 1 verdict: every module is built and proven in isolation — 121/121
selftest asserts green on merged main — but the game is not assembled. main.js
still drives the M0 placeholder capsule and stub wind. Sprint 2 is one thing:
**wire the proven modules into one playable storm.** Read THREADS.md from your
last entry down before starting; the integrator [I] entry lists what changed
under you.*

## Decisions (made — stop waiting on them)

1. **Lanes run on m3ultra.** Lane D's recommendation is adopted: the M1 Ultra
   (`johnking@100.91.239.7`) is an asset-build box you SSH to; GLBs get committed;
   the game never needs it at runtime. PLAN3D §0 is amended by this line.
2. **Sail-area problem (B's 70–192 m² finding): fix the yard, not the physics.**
   Lane A: move p1/p2 in to roughly (−4.5, 5.5) and (4.0, 6.0), add a third post
   p3 near (0, 7), and register the trees' `branch_anchor_*` empties (E shipped
   them with `rating_hint`) as anchors. Target: at least three pickable quads in
   the 18–45 m² range that can shade the garden bed, verified by a new a.test
   assert that enumerates quad areas. The huge quads stay possible — the load
   bars teaching "you cannot span the whole yard" is design working as intended.
3. **Flat-horizontal loophole: Lane C closes it with vertical gust structure.**
   Real gusts aren't horizontal; add a per-gust vertical component (downdraft
   fraction in storm JSON, default ~0.25 of gust power, validated) so a
   horizontal plate carries real load. Lane B adds the assert: over 8 directions
   in storm_02 wind, flat-horizontal peak load ≥ 60% of flat-pitched peak (i.e.
   no longer a free lunch). Ponding stays out of scope (M4 water spike).
4. **repair/trim seam: Lane B conforms to Lane D's call sites** (D landed first,
   duck-typed): add `repair(i)` (→ repairCorner with the spare's hw),
   `trim(i, delta)` (→ trimCorner) and `cornerPos(i) -> Vector3` (live world
   position, fresh vector) to the rig object. Contract entries + b.test asserts.
5. **debris↔sail seam: option (b)** — Lane B reads `debris.pieces`
   ({x,y,z,vx,vy,vz,r,mass}) inside `sail.step()` and applies impulses; momentum
   bookkeeping stays in the one integrator. Lane C freezes the `pieces` shape.
6. **House GLB: no re-cut.** Lane A reads `fascia_anchor_*` positions out of
   `house_yardside_v1.glb` at load and places anchors there (data wins over the
   yard constants). E's 2.80 m fascia replaces the 2.6 m graybox number.

## Lane A — assemble the game (this is the sprint)

main.js boot(), in order; keep each step behind a small commit:
1. Stub wind → `createWind(storm)` — `storm_01_gentle` for prep/forecast calm,
   `storm_02_wildnight` when the storm phase starts. Call
   `wind.setSheltersFromTrees(...)` after the yard builds, per C's ask.
2. Placeholder → `await createPlayer(scene, world, cameraRig, {wind, interact})`
   (async boot; D says same first three args). Delete the placeholder factory.
3. Sail: `const view = await createSailView(rig); scene.add(view); view.update()`
   per frame after `rig.step(dt, wind, t)`. B's THREADS entry has the exact shape.
4. `createSkyFx({scene, camera, wind, sun, hemi})` + `unlockAudio()` on first
   input; `createDebris({heightAt: world.heightAt, onHitPlayer: player.knockdown})`,
   `debris.setModels()` from `models/debris/` (glob the dir).
5. Yard dressing: swap graybox house → `house_yardside_v1.glb` (decision 6),
   shed + shed_table (D's spare pickup), sail posts as `sail_post_v1.glb` rotated
   about `rake_pivot`, fence set, grass billboards off `textures/grass_atlas.png`.
6. Anchor rework per decision 2.
7. HUD: loads in **kN** (B's units note), per-corner bars vs rating, wind meter +
   gust telegraph banner, garden % (wire `rig.coverageOver(world.gardenBed)` →
   HP → E's `plants_full/tattered/dead` visibility swap), phase banner, forecast
   card (storm JSON summary: peak wind, change time), aftermath screen (garden %,
   corners lost, budget delta).
8. Phase machine: forecast (show card, Enter) → prep (rigging UI live, budget
   $80, optional timer OFF this sprint) → storm (90 s, storm_02) → aftermath.
Acceptance: `python3 server.py` → rig a sail with the mouse, press Enter, watch
storm_02 try to kill it, repair a corner mid-storm, see the aftermath screen.
60 fps during the storm on this box. Selftest stays green after every merge.

## Lane B — sail in the world

1. Decision 4 API (repair/trim/cornerPos) + asserts.
2. Decision 5: consume `debris.pieces` in step(); assert momentum is conserved
   within tolerance on a crate-through-sail scenario.
3. Prep-phase picking adapter: RiggingSession → clicks. Raycast against Lane A's
   anchor markers (A exposes `world.anchorMarkers` if you need meshes — agree in
   THREADS), corner cycling + tension dial + spare purchase, HUD summary line
   from `summary()`. This unblocks A step 8.
4. Joint tuning session with C (their THREADS ask): retune cloth ρ against real
   m/s storms; then re-run the §7 gate against REAL wind (current assert used the
   stub) — flat cheap rig cascades in storm_02, twisted mixed rig + one repair
   survives. Log tuned constants in THREADS.
5. Small fix: `coverageOver()` rays start at `heightAt(x,z)`, not y=0 (your nit).
6. Decision 3 assert (flat-horizontal no longer dominant) once C lands vertical gusts.

## Lane C — weather in the game

1. Decision 3: vertical gust component in storm JSON + validator + asserts.
2. Decision 5: freeze and document `debris.pieces` shape in contracts.js.
3. Rain must react to the sail: cheap occlusion — sample `rig.coverageOver` cells
   or raycast a handful of drops so the garden visibly stays dry under cloth.
   (Coordinate the API with B; don't ray-test every drop.)
4. Storm tuning session with B (see B-4).
5. skyfx: verify light restoration on `dispose()` inside the real main.js scene —
   A will call you if teardown flickers phase transitions.
6. Consider retiring weather_demo.html once main.js hosts the storm — your call,
   it stops earning its place when the game IS the bench.

## Lane D — player in the storm

1. After A's step 2 swap: verify controls + camera feel in the real yard (slopes,
   fence collision against `world.solids`), tune walk/run speeds against yard
   scale, make gust shove + knockdown fire from real wind and real debris hits.
2. Wire the spare pickup loop end-to-end: shed_table `pickup_anchor` → carrying →
   `repair(i)` consumes it (B's decision-4 API). The §7 "one mid-storm repair"
   scenario must be playable by hand.
3. Interaction prompts follow `cornerPos(i)` live (flogging corner = moving prompt).
4. Kill dev_player.html only when the main game covers everything it proves.

## Lane E — polish targets (small sprint)

1. Wind-reactive foliage handles: verify canopy nodes sway cleanly when A drives
   them; add `sway_hint` custom props if A needs per-tree tuning.
2. Sail cloth texture (512² weave/UV-stripe atlas) so the membrane reads as
   fabric, + a simple tear decal strip for M3.
3. Storm dressing set: wheelie bin (debris, `mass_hint`), washing line, garden
   gnome (collateral scoring bait). One script run, same acceptance as before.
4. Contact-sheet the assembled yard from A's camera for DESIGN.md.

## Order & gates

```
gate 1: A steps 1-4 land  → the yard has weather, a person and a live sail
gate 2: B-3 picking + A-8 → the loop is playable start to finish
gate 3: B/C tuning + D-2  → §7 scenario passes BY HAND and in selftest
```
Definition of done = gate 3 + THREADS updated + selftest green + a 90 s
storm_02 run captured (screenshots or video) for the log.

## For John (human-only items)

- Mixamo login on the M1 for D's M3 wishlist (`tools/character/mixamo_wishlist.txt`
  — Climbing Ladder, Turning Key, Digging). Not blocking this sprint.
- Two dev servers float around: another session holds :8801; this repo's
  launch.json now uses :8809. Kill either freely; `server.py --port N` works.