guts/docs/LANES/ROUND1_INSTRUCTIONS.md

# GUTS — Round 1 lane instructions (from Fable, integrator)

Date: 2026-07-16 · Repo state: F's round-0 scaffold is committed on `main` — docs complete
(README/PROCESS/GDD/TECH/ART_BIBLE/PIPELINE + charters), shell boots the **stub world**
(straight pulsing tube, flat shading) with a fly camera, `tools/qa.sh` GREEN. Everything
below builds against that scaffold. Read PROCESS.md §A-lane-session before starting.

## Integrator decisions (settled — don't relitigate in-round)

1. **Movement is the flow-locked hybrid** (GDD). **Look is synthetic scanner** (ART_BIBLE).
   Wireframe-only and full-flesh-realism are both rejected.
2. **The world contract in TECH.md is v1.** Round 1 is its shakedown: A implements it, B
   consumes it (via stub first). Friction → NOTES immediately; F freezes it at round end.
3. **Level schema v0 in TECH.md is C's to ratify** — C may amend it this round (it's young),
   but must update the stub's sample level + notify A/B via NOTES in the same session.
4. **No mesh generation this round** (D). Textures + audio proof first; hero meshes need
   C's boss specs and concept sign-off (round 2). Exception: sf3d drafts to *test* the
   concept loop are fine (free, seconds).
5. **Vertical slice target = level 2 (esophagus)**, not level 1: the tube is the core tech
   risk and the esophagus is the purest tube. Mouth/arena tutorial comes after the spine
   works. Round 2 goal: fly the esophagus with 2 enemy types, HUD live, textured walls.
6. Dev port **8140**; evidence law and exact-path git staging are in force everywhere.

## Lane A — the canal, v0

Build `js/world/` per your charter, priority order:
1. Spline + parallel-transport frames + arclength LUT from level JSON (consume
   `js/levels/L2_esophagus.json`; the stub's inline level shows the shape). Seeded, and
   `world.hash()` + selfcheck wired for qa.
2. Chunked tube geometry with (s,θ) UVs, streaming window, dispose-clean (cite
   renderer.info deltas in NOTES).
3. Wall ShaderMaterial: biome tint + fresnel rim + fog (flat-tint fallback path — D's
   textures may land mid-round; integrate via `assets.get` if present).
4. Peristalsis vertex displacement + `world.flowPulse(s,t)` JS mirror.
5. `?fly=1` noclip camera. Screenshot set: esophagus straights, curves, a wave crest.
Stretch: stomach arena icosphere v0. Don't touch: player, HUD, levels' content values.

## Lane B — flight + first blood, on the stub

Work entirely against `?stub=1` (contract-identical); swap to A's world late in the round
if it's landed, but **don't block on A**.
1. `createPlayer`: tube-mode controller (s,x,y), mouse+WASD+gamepad, banking chase cam,
   boost + i-frames, wall-graze damage + shove. Feel numbers documented in NOTES.
2. Weapons: lysozyme cannon (pooled, instanced, heat) + hit tests vs sphere targets.
3. Enemy framework + 3 archetypes (floater/seeker/turret) as emissive primitives, spawned
   from `level:event` (the stub level includes sample spawns; C's L2 JSON is your real feed).
4. Damage/coat model + all bus emissions per TECH §Bus (E builds against these — emit
   faithfully even with no listener).
Evidence: capture or screenshot sequence + DBG numbers. Arena-mode controller = round 2.

## Lane C — GDD ownership + the data spine

1. Ratify/amend level schema v0 (TECH.md) — you own it from now; sync stub sample + NOTES.
2. `js/levels/index.js` registry + headless selfcheck (qa.sh already calls
   `node js/levels/index.js --selfcheck` — make it real).
3. **`L2_esophagus.json` complete** (the vertical-slice level): segments, flow, encounter
   curve with B's three archetypes, reflux-surge finale as a `hazard` event, checkpoints,
   par time. Fly it on the stub; pacing notes in NOTES.
4. Draft `L1_mouth.json` + `L3_stomach.json` skeletons (biomes/lengths/arenas only).
5. **Boss specs** (Pyloric Guardian, Tapeworm, Blockage) as one-pagers in your NOTES —
   phases/telegraphs/windows — so A can shape lairs and D can concept in round 2.

## Lane D — pipeline online + first texture pack + audio proof

On the m3ultra box (clone the repo there; PIPELINE.md has the verified operator map):
1. Port PROCITY's script shapes: `gen_textures.py` (--dry-run/--local/--harvest),
   `derive_maps.py`, `build_manifest.py`, `validate_manifest.py`.
2. **First pack:** esophagus ×2, stomach ×2, small-intestine ×2 walls (grayscale, tiling,
   ART_BIBLE prompts) + 1 wet-tissue matcap → normals → WebP → manifest. Contact sheet +
   in-engine stub screenshots to `docs/shots/laneD/`.
3. `js/core/assets.js` per the manifest contract (null-on-miss, `?localassets=0`).
4. **Audio proof (small):** port `gen_audio.py` shape; synthesize 1 esophagus bed (loop-
   clean) + 4 sfx (pellet, hit-squelch, boost, pickup). Spectrogram evidence. Full pack =
   round 2.

## Lane E — instrument panel v0

1. HUD overlay (DOM/canvas): coat/hull bars, heat, speed/flow, score — bus-driven only,
   against B's emissions (they land this round; stub-emit fake events for dev via a
   `?fakebus=1` helper you own).
2. **Gut-map v1**: draw the alimentary silhouette once (SVG path), show it as progress bar
   with player blip. This is the game's signature UI — spend the taste budget here.
3. Title screen (over the stub drift) + pause + respect `?shots=1`/`?mute=1`.
4. `js/audio/engine.js`: bed crossfade + sfx pool + autoplay unlock + **procedural fallback
   beeps** (D's pack may land mid-round; handle both paths).
Screenshots of every state to `docs/shots/laneE/`.

## Lane F (Fable) — done in round 0, then on-call

Scaffold committed. During the round: answer contract questions in NOTES daily-ish; end of
round: boot matrix, verify evidence, freeze world contract, write ROUND2.

## Round-2 preview (so you can aim): textured esophagus slice playable start-to-finish —
A's world + B's flight/enemies + C's L2 + D's pack + E's HUD, integrated by F, tagged v0.2.