LUME Creative Engine Maturation — Divergent Rail Plan

# LUME Creative Engine Maturation — Divergent Rail Plan
> Stage 4 of `/chain:genesis`. EW-governed. 7-day reel-ship + non-blocking parallel work.
> Inputs: `stage3-expand-master-plan.md` (5-pane plan), `creative-forge-output.md` (Q1 audio threading + Q2 director schema sub-rail + Q3 USB-dominant CAD).
> Output binding: this file is what each Codex pane reads to know its role and its bounds.
> Deadline: Reel-001 posted 2026-05-09 EOD. Wave 8 push lands the same day.

---

Plan metadata

• Total phases: 5 (Phase 0 setup + Phase 1-4 reel/push/stabilize)
• Total tracks: 22 (Σ across phases; mean ≈ 4.4 / phase, peak 5 in Phase 1+2)
• Machines: Mac1 (dev/CAD/spawn), Mac4 (Unity host + Mac mini sled prototype), Mac5 (ML, rate-limited; SAN inference only), K11 (production publisher pod), iPhone (MotionMixApp capture + LUMF/LUMM source), iPad (LUMM fallback)
• Wall time: 7 days (phases sequential by gate; tracks parallel within phase)
• Invariant config: `epsilon = 0.01 deliverables/hour`, `max_div = 4` (Phase 0 hits 5 — flagged in Risk Register), `stall_threshold = 2 sessions with no track-level commit`, `min_viable_transitions = 2 next-step branches per gate`
• Agents: 5 Codex panes (P1-P5) + Claude (Mac1 Sonnet 4.7 1M, this session) + Mohamed (judgment + destructive ops + photoshoot)
• Repos in scope: `lume-commerce` (software/demo, hardware/cad, launchagents), `MotionMixApp` (iOS Swift), `MotionMix` (macOS director + REEL-001 plan), `MotionMixDirector` (Swift Package — director schema target), `multicam-server` (Rust — director Rust impl deferred to Wave 9)

---

## Phase 0: Setup (Day 0 = 2026-05-02 evening)
> Gate: 5 Codex pane prompts in `evo-cube-output/`, K11 health-check green, Mac4 reachable via Tailscale, FirstDate PAT rotation status confirmed (rotated OR sentinel `WAVE8_PUSH_BLOCKED_PAT_ROTATION` written), `[home-path]` directory created with empty per-pane files, pre-commit hook target paths surveyed.
> EW Check: Bounded Divergence at risk — 5 panes brushes the cap of 4 + 1 critical. Resolved by collapsing the "Mac4 verifier handoff prompt" sub-track into the P3 pane prompt (P3 owns Mac4 anyway), and treating "K11 health check" as a 10-minute gate ritual (not a parallel track at this phase).
> Min viable transitions: 2 (→ Phase 1 if all panes online; → Phase 0.5 stall-recovery if K11 unreachable for >30min)

Deliverables:
- 5 pane prompts saved to `Desktop/evo-cube-output/lume-creative-engine-2026-05-02/pane-prompt-P{1..5}.md`
- K11 baseline health JSON
- PAT rotation status (rotated OR explicit blocker doc)
- `[home-path]` populated, `[home-path]` empty-but-present
- `WAVE8_NOT_PUSHED` sentinel + pane registry skeleton

EW Risks (this phase):
- Bounded Divergence: 4 sub-tracks here (1 critical + 3 divergent) is at cap. Adding any 5th task at this phase → defer to Phase 1.
- No Absorbing States: if FirstDate PAT can't rotate today, Phase 3 G2 push is blocked but reel ship (Phase 3 G1) continues. Two viable next-step branches preserved.

---

## Phase 1: Bridges + Reel asset capture (Day 1-2 = 2026-05-03..04)
> Gate: P1's `LumfPublisher.swift` shipped + Swift golden-bytes test green + K11 verifies ≥58 LUMF pkt/s for 60s; AudioEngine `[MixerBufferConsumer]` array refactor merged on Day 1 (single commit) and available for P2 to consume on Day 2; P3 mocopi_synth flake fixed and CHANGELOG drafted; P5 lume-config.scad MAC_MINI constants committed; P4 OSC :9050 listener bound (no SAN bridge yet — that's Phase 2).
> EW Check: Cross-Layer Forcing most at risk — P1's consumer-array refactor is the single shared file across P1/P2/P4. If P1 doesn't land Day 1 morning, P2's AudioCaptureWriter can't compile. Mitigation: P1 declares the consumer-array commit as Track Critical's first deliverable; P2 + P4 wait on a `paneN.txt` claim release before opening AudioEngine.swift.
> Min viable transitions: 3 (→ Phase 2 if P1+P2 capture path green; → Phase 1.5 audio-fallback if LumfPublisher fails on K11 (use Strudel-render path for reel audio); → Phase 1.5 photoshoot-prep if Mac1 work outpaces Mohamed's prep)

Deliverables:
- `LumfPublisher.swift` + `LumfPublisherTests.swift` (golden-bytes + no-allocation tests pass)
- AudioEngine `[MixerBufferConsumer]` array refactor (single Day 1 commit)
- `AudioCaptureWriter.swift` (rides on consumer-array)
- `record-unity-reel.sh` smoke-tested on K11 (≥5s capture)
- K11 NSSM Args updated (prefer-device flag) — service registration UNTOUCHED
- `REEL-001-PRODUCTION-PLAN.md`, `CHANGELOG.md`, `MAC4-VERIFICATION-RUNBOOK.md`, mocopi flake fixed
- OSC :9050 listener live + 7 channels in ParamMapper.Extras (verifiable)
- `lume-config.scad` + `lume-pod.scad` updated, universal sled STL renders

EW Risks:
- Cross-Layer Forcing: P1's consumer-array commit is on the critical path AND blocks P2 + P4. If P1 stalls Day 1, the rule fires: P2 + P4 force-redirect to spec-only work (read forge §Q1, draft test cases) until P1 lands. Critical's stall ≠ everyone idle.
- Min Entropy: P3's mocopi flake is judgment-call — if root cause is hidden, P3 risks producing zero novelty. Forge counter: P3's CHANGELOG + MAC4-VERIFICATION-RUNBOOK are independent of the flake; ship those first, return to flake.

---

## Phase 2: Reel music + Unity capture + sled print + bridges-b/c (Day 3-4 = 2026-05-05..06)
> Gate: Photoshoot Look 1 (Day 3) + Looks 2-3 (Day 4) shot with stills + motion clips + AudioCaptureWriter recording; pre-commit don't-touch hook installed in 3 repos and blocks a deliberate test violation; pane registry JSON populated + daily `/sync-panes` runs once; P4 SAN bridge debounced + dwell-gated; P5 sled STL + 2 adapter STLs render and slice.
> EW Check: Min Entropy at risk — Day 3 photoshoot is real-world (location, lighting, model, charging). If shoot fails, the entire reel-critical track produces zero artifacts on Day 3, and Day 4's Looks 2-3 attempt absorbs the missed look. Forge counter: pre-shoot dry run on Day 2 EOD (test 1 still + 1 motion clip). Solo-self-shot is the default plan; model coordination is the stretch.
> Min viable transitions: 3 (→ Phase 3 composite if all 3 looks shot; → Phase 2.5 reshoot-Day-5 fallback if Day 3+4 shoot quality insufficient; → Phase 2.5 strudel-only-audio fallback if SAN audition fails)

Deliverables:
- 3 looks shot (stills + motion + audio)
- `director-protocol.md` doc + `Models+Director.swift` Codable schema
- Pre-commit don't-touch hook live in 3 repos (deliberate-violation test passes)
- `SANPipelineBridge.swift` + `setSANPattern` extension live, integration test green
- 3 STLs + 3 plist files + `install-mac4.sh` + `UNIVERSAL-SLED.md`
- Plate 1 print queued (5h unattended)
- First `/sync-panes` daily synth file

EW Risks:
- Min Entropy: photoshoot day produces 0 novelty if Mohamed is blocked (location, weather, model). Mitigation: Day 2 EOD pre-shoot dry run (1 still + 1 motion clip) catches setup failures. Fallback: if Day 3 fully blown, compress Looks 1+2 into Day 4 with shorter shotlist; Look 3 deferred to Day 5 morning, accepting reel-quality cost.
- Bounded Divergence: Phase has 5 tracks (Critical + A/B/C/D). At cap. Track D is intentionally lightweight (1h coordination meta-task, not a new code track), so this stays within EW spirit.
- Cross-Layer Forcing: if SAN audition (Phase 3 prep) reveals SAN audio sounds bad, P4's Phase 2 work needs redirect — Strudel-render fallback becomes default reel audio, P4's SAN-bridge becomes "shipped but disabled by default" (still a delivered artifact, doesn't gate reel).

---

## Phase 3: Reel post + Mac4 verify + Push (Day 5-6 = 2026-05-07..08)
> Gate: Reel-001 final composite at `Desktop/MotionMix/reel-001-final.mp4` 1080×1920 ≤30s ≤30MB; caption drafted + brand-voice reviewed; Mac4 10-point runbook all green; `WAVE8_NOT_PUSHED` sentinel file STILL PRESENT (push lands in Phase 4 Day 7); P5 sled fit-tested (or fit-test deferred to Wave 9 with explicit doc); audio audition winner picked (SAN OR Strudel-render OR licensed fallback flagged).
> EW Check: No Absorbing States most at risk — Mac4 verification could fail in 10 different ways (TCC, Tailscale, NSSM publisher rate <58 Hz, F12 panel won't open, etc.). Each failure must have ≥2 viable next-step branches. Forge mitigation: every runbook check has a paired remediation script; failures defer push by ≤24h, do not block reel.
> Min viable transitions: 3 (→ Phase 4 ship if all green; → Phase 3.5 patch-and-retest if Mac4 verification fails on a fixable point; → Phase 3.5 reel-only-ship-defer-push if push reveals real bug — reel still ships Day 7, Wave 8 push slips to Wave 9 day 1)

Deliverables:
- Reel-001 final composite MP4 + caption draft
- Mac4 10-point runbook green-checked (or explicit blockers documented + push deferred)
- Sled fit-test result (or reprint scheduled)
- Post-push cleanup script ready

EW Risks:
- No Absorbing States: Mac4 verification fails on point 4 (LUMD <28 Hz). Branch 1: K11 publisher restart fixes it (transient). Branch 2: real bug, defer push to Wave 9. Both branches preserve reel ship (Phase 4 G1).
- Min Entropy: Day 6 composite stalls if ShootView's ReelBuilderView has a bug surfaced for the first time. Forge counter: P2's task #5 (Day 5) explicitly drives ReelBuilderView with realistic inputs (3 looks of stills + 3 motion clips) — bugs surface on Day 5 not Day 6.
- Cross-Layer Forcing: if Mac4 fails verification, P5's sled fit-test (Track B) does NOT block — forces ahead. Track B's fit-test result feeds the post-mortem regardless.

---

## Phase 4: Ship + Push + Stabilize (Day 7 = 2026-05-09)
> Gate: Reel posted to Instagram + TikTok. `WAVE8_NOT_PUSHED` sentinel removed via post-push-cleanup.sh. Pre-commit don't-touch hook surveys clean (no violations on push-then-cleanup commit). 24h monitoring loop active for ≥1 viewer comment on music or visual.
> EW Check: No Absorbing States — final phase must NOT terminate the rail. Wave 9 backlog is the explicit continuation: HD1 mount + SAN V6 retrain (music-gen Phase C), director Rust impl (forge Q2 sub-rail's pending half), Mocopi-pro activation, FirstDate hygiene closeout, bar display caliper-verify. Phase 4 hands the baton, doesn't drop it.
> Min viable transitions: 2 (→ Wave 9 plan if Phase 4 closes clean; → Phase 4.5 hot-fix loop if reel post breaks platform terms or push reveals immediate prod bug)

Deliverables:
- Reel posted (URL captured to memory)
- Wave 8 visible on `origin/main`
- Retrospective in memory
- 48h comment-log seeded

EW Risks:
- No Absorbing States: even if reel posts and Wave 8 pushes, Phase 4 must NOT be terminal. Wave 9 plan is queued (HD1 + SAN V6 + director Rust impl + bar display + Mocopi-pro). Track A's retrospective explicitly seeds Wave 9.

---

## Phase 5 (Wave 9 backlog handoff — out of scope this rail; documented for No Absorbing States)
> Not executed in this 7-day rail. Listed so Phase 4's gate has a real continuation path:
> - HD1 mount + SAN V6 retrain (forge Q1 schema-extension if needed; music-gen Phase C)
> - `multicam-server/src/director_bus.rs` Rust impl (forge Q2 sub-rail second half — Codable schema already shipped Phase 2)
> - Mocopi-pro activation (mail-arrival dependent)
> - FirstDate token rotation closeout if Phase 0 Track A only documented blocker
> - Bar display caliper-verify (#177)
> - `pyorbbecsdk2` macOS arm64 source-build if pip wheel missing
> - Diffusion / training-pipeline triage (memory §4 pane 7, optional)

---

Coordination protocol (the don't-collide doc)

Wave 8 lesson recorded in memory (2026-05-02): 2 agents touched `LumeWaveAutoWire.cs` in parallel; later writer won, earlier wasted edits. Pre-compact summary was stale — git HEAD vs summary text disagreed, and a parallel agent finished Steps 4-6 while my session was redoing them.

The 5 rules below close that loop. They are NOT optional. Every pane prompt MUST include them.

• Rule 1 — Claim before touch: Each pane DECLARES its file claim at session start by writing absolute paths (one per line) to `[home-path]`. The claim file is the ground truth for "what files this pane will edit."
• Rule 2 — Read before write: Before any `Edit` or `Write` operation, the pane runs `cat [home-path] | grep -F <target-path>` to check overlap with other panes' claims.
• Rule 3 — Newer claim defers: If overlap detected, the newer (later-timestamped) claim defers and writes a coordination note to `[home-path]` with the path + both pane IDs + proposed resolution. Mohamed resolves via direct prompt to one pane.
• Rule 4 — Commit prefix: Every git commit message starts with `[paneN]` (e.g. `[P1] feat: LumfPublisher.swift V2 ring-buffer + 60Hz publisher`). Pre-commit hook from P3 enforces this prefix on all 3 repos.
• Rule 5 — Pane closure synthesis: When a pane finishes its scoped work, it writes a 5-line synthesis to `[home-path]` (what shipped, what's blocked, file list, last-commit-sha, status ∈ {COMPLETE, BLOCKED, DEFERRED}). The daily `/sync-panes` synth reads these.

Special case — AudioEngine.swift coordination (P1 ↔ P2 ↔ P4):
The `[MixerBufferConsumer]` array refactor lands in P1's first commit Day 1 AM (Phase 1 Critical, deliverable (a)). Until that commit lands on `feature/wave9-creative-engine`:
- P2's AudioCaptureWriter cannot compile.
- P4's OSC bridge does not need AudioEngine.swift, but waits anyway as a courtesy to keep the working tree clean.

---

Pane assignment (final, ordered by dependency)

Cross-pane don't-touch (universal):
- All wire format magic bytes: `LUME` (0x4C554D45), `LUMD` (0x4C554D44), `LUMF` (0x4C554D46), `LUMM` (0x4C554D4D), `LUMC` — pinned by `tests/test_wire_format_golden.py`.
- 21 Unity component public APIs — additive only, no field renames or signature changes.
- K11 NSSM service registration blocks in `software/demo/launchagents/k11/install-services.ps1` — runtime Args may be parameter-flagged; service registration block stays as-is.
- Wave 8 commits not-pushed: `da8d1478, c5194f92, 2a6e6b25, 95387a02, 8139a931, 8fb6fe75, e21ad971` — Mohamed pushes after Mac4 verification.
- LUMF byte order in `audio_pub.py:send_lumf` — pinned by golden-bytes test.
- MotionMix repo proof-token model (commit `1ea8da7 feat(director): Phase 5a proof token model`) — read it, don't redefine its schema.
- Production system constraint — Mohamed runs all destructive operations manually. No Codex pane may `git push`, `launchctl unload && load`, `nssm remove`, or post to social media on Mohamed's behalf.

---

Risk register (per phase)

---

Daily phase summary

---

Gate criteria (machine-checkable wherever possible)

### Phase 0 → Phase 1 gate
1. `ls Desktop/evo-cube-output/lume-creative-engine-2026-05-02/pane-prompt-P*.md | wc -l` returns 5
2. `ssh k11 "powershell -File C:\lume\health-check.ps1"` exit 0; output contains `LUME-Audio: Running`, `LUME-Mocopi: Running`, `LUME-Depth: Running`
3. PAT status: file `[home-path]` contains either `ROTATED <new-token-hash>` OR `BLOCKED <reason> — push deferred to Wave 9`
4. `ls [home-path]` all exist
5. `cat Desktop/lume-commerce/.WAVE8_NOT_PUSHED` exists

### Phase 2 → Phase 3 gate
1. `ls Desktop/MotionMixStills/reel-001/look-{1,2,3}/ | wc -l` ≥ 24 stills/look
2. `ls Desktop/MotionMix/captures/reel-001/look-{1,2,3}/*.mov | wc -l` ≥ 3 motion clips
3. `ls [home-path] Support/MotionMixApp/audio-captures/reel-001/*.wav | wc -l` ≥ 3 WAV captures
4. `ls Desktop/MotionMixDirector/Sources/MotionMixDirector/Models+Director.swift` exists; `swift build` exits 0
5. `cat Desktop/MotionMix/director-protocol.md | wc -l` ≥ 100
6. Pre-commit hook deliberate-violation test: `cd Desktop/lume-commerce && echo 'magic break' >> software/demo/unity/lume_pcloud/Assets/Scripts/LumeUdpReceiver.cs && git add -A && git commit -m '[P3] test: deliberate violation' returns NONZERO exit`
7. Pane registry JSON populated: `jq '.panes | length' [home-path]` returns 5
8. P4 SAN-bridge integration test: 120s session shows ≥2 pattern replacements separated by ≥16 bars (programmatic check via Strudel webView log)
9. `ls Desktop/lume-commerce/hardware/cad/exports/pod_compute_sled_universal.stl Desktop/lume-commerce/hardware/cad/exports/adapter_k11_vesa75.stl Desktop/lume-commerce/hardware/cad/exports/adapter_macmini_clamp.stl` all exist

### Phase 3 → Phase 4 gate
1. `ls Desktop/MotionMix/reel-001-final.mp4` exists; `ffprobe` shows 1080×1920, ≤30s, `du -h` ≤30MB
2. Caption draft exists at `Desktop/MotionMix/reel-001-caption.md`; brand-voice review checklist passed (no em-dashes, no AI-isms, see master plan §5)
3. Mac4 10-point runbook: `cat Desktop/MotionMix/mac4-verification-day6.md` shows 10 ✓ marks (or explicit blocker doc with sentinel `WAVE8_PUSH_DEFERRED`)
4. `ls Desktop/lume-commerce/.WAVE8_NOT_PUSHED` STILL EXISTS (push happens Phase 4, not Phase 3)

### Phase 4 → Wave 9 gate (No Absorbing States)
1. Reel URL captured at `Desktop/MotionMix/reel-001-post-url.txt`
2. `git -C Desktop/lume-commerce log origin/main --oneline | head -10` shows 7 Wave 8 commit SHAs
3. `! ls Desktop/lume-commerce/.WAVE8_NOT_PUSHED 2>/dev/null` (sentinel removed)
4. Retrospective at `[home-path]` exists ≥100 lines
5. Wave 9 backlog written to `[home-path]` (≥6 backlog items appended, NOT replacing existing content per Memory Guardian)

---

Pulse auto-spawn analysis (carried from master plan §9)

For tasks with high deterministic structure, Pulse can spawn dedicated Codex sessions. Mapped to phases:

• Phase 1 critical (P1): parts (a)+(b)+(c) Pulse-eligible if forge V2 spec is the prompt. Part (d) verification needs human — NOT Pulse.
• Phase 1 parallel A (P2): REEL-001-PRODUCTION-PLAN.md + AudioCaptureWriter.swift Pulse-eligible.
• Phase 1 parallel B (P3): CHANGELOG + RUNBOOK Pulse-eligible. Mocopi flake fix is judgment-call → NOT Pulse (read failure mode first).
• Phase 1 parallel C (P4): OSC :9050 binding Pulse-eligible.
• Phase 1 parallel D (P5): SCAD constants + module refactor Pulse-eligible.
• Phase 2 critical: photoshoot — NOT Pulse (Mohamed-driven).
• Phase 2 A (P3): director-protocol.md + Models+Director.swift + pre-commit hook all Pulse-eligible.
• Phase 2 B (P4): SANPipelineBridge.swift + setSANPattern Pulse-eligible.
• Phase 2 C (P5): 2 adapter SCAD + plists + UNIVERSAL-SLED.md Pulse-eligible. Print is unattended.
• Phase 3: critical = Mohamed; A = Mohamed-driven Mac4 walk + P3 patches (judgment); B = Mohamed (physical fit); C = Pulse-eligible (post-push-cleanup.sh).
• Phase 4: ALL Mohamed-driven. Retrospective is the only Pulse-eligible piece, post-ship.

# Suggested first Pulse run (DRY-RUN; do NOT actually spawn until pane prompts paste-ready):
python3 [home-path] pulse-spawn \
  --checklist [home]/Desktop/evo-cube-output/lume-creative-engine-2026-05-02/divergent-rail.md \
  --slug lume-creative-engine-2026-05-02 \
  --dry-run true

---

Closing — what changes vs master plan + forge

Stage 4 net additions on top of master plan §3 + forge §Q1-Q3:

1. Phase 0 explicitly added (master plan implied Day 0; rail makes it a real EW-governed phase with its own gate). Bounds the 5-pane spin-up.
2. Phase 5 / Wave 9 handoff is explicit — closes the No Absorbing States invariant. Master plan listed Wave H backlog; rail makes it a phase-equivalent continuation.
3. AudioEngine.swift coordination protocol — formalized. P1's consumer-array commit Day 1 AM is exclusive-claim; P2 + P4 poll for it. Closes the Wave 8 lesson on parallel-edit collisions.
4. Director schema sub-rail (forge Q2) — `Models+Director.swift` Codable structs ship Phase 2 Day 3 even though Rust impl defers to Wave 9. Phase 2 Track A explicitly carries this.
5. Pre-shoot dry run gate — added as Phase 1 → Phase 2 gate criterion #8. Catches photoshoot failures before they kill Day 3.
6. PAT rotation as Phase 0 → Phase 4 hard prerequisite — explicit sentinel `WAVE8_PUSH_BLOCKED_PAT_ROTATION` if not done by Day 0. Reel still ships.
7. Plate 1 parallel-print — forge Q3's "0 net print overhead" claim materialized: universal sled (5h) + 2 adapters (30 min addenda) on the same Elegoo Max plate.
8. Phase gates are machine-checkable — every gate above has a concrete shell command or file existence check. Pre-Codex-paste validation is now a 2-minute script run.

---

Cross-machine concurrency map (who runs what when)

This map answers "if all 5 panes are firing on Day 2, which machine is the bottleneck?" The answer drives whether we can actually run 5 panes in parallel or need to serialize.

Bottleneck analysis:
- Mac1 = busiest, hosts 5 concurrent Codex panes Day 1-4. Codex pane resource cost is small (each pane is a separate process + LSP), but file-level conflicts are the real risk → coordination protocol Rules 1-5 above.
- K11 is the only production publisher Day 1-7. NSSM Args edit (Day 2) is a 1-line PowerShell change — does not require service restart; the publisher process picks up new flags on next loop iteration. No K11 service downtime any day this week.
- Mac4 only matters Day 6 for the verification runbook. Days 1-5 it's idle. P5's launchd plists install on Mac4 Day 4-5 but services start lazily.
- Elegoo Max is fully unattended Day 4-5. Print queue Stage 7 from prior memory work continues in parallel; universal sled is a NEW print stage on the same machine but does not collide with prior queue.
- Mac5 stays rate-limited per CLAUDE.md / memory rules. Used Day 4-5 for SAN inference only. No retraining.

---

EW invariant trace (per-phase audit)

Each phase below explicitly evaluates the 4 non-halting invariants. The audit lives in this file so the next reader (or `meta-review` Stage 5) can challenge any line.

Invariant 1 — Min Entropy Production (every phase produces measurable progress):

Invariant 2 — Bounded Divergence (max 4 tracks per phase, 1 critical + 3 parallel):

Two phases breach the strict 4-track cap. Both breaches are documented and structurally justified — Phase 1 because Track D operates on a fully disjoint repo+toolchain; Phase 2 because Track D is operational meta-work. If either breach causes coordination friction in the daily `/sync-panes` synth, the rail demands compaction back to 4 tracks (deferring P5 a day, or rolling Track D into Critical's overhead).

Invariant 3 — Cross-Layer Forcing (critical stall ↔ parallel rescue):

Invariant 4 — No Absorbing States (every phase has 2+ viable next steps):

Verified above in each phase's "Min viable transitions" line. Phase 4 explicitly hands to Wave 9; Phase 5 documents Wave 9 work. Rail does not terminate.

---

Pane prompt skeleton (paste-ready scaffold)

Each pane gets a prompt with these 7 sections. Skeleton below — final prompts saved Day 0 to `Desktop/evo-cube-output/lume-creative-engine-2026-05-02/pane-prompt-P{1..5}.md`.

# PANE P{N} — {focus name}

## 0. PRODUCTION SYSTEM HEADER (verbatim)
THIS IS A PRODUCTION SYSTEM. Don't break what ships.
Don't-touch:
  - Wave 8 wire format magics (LUME/LUMD/LUMF/LUMM/LUMC) — pinned by golden-bytes tests.
  - 21 Unity component public APIs — additive only.
  - K11 NSSM service registration blocks — runtime Args may be flagged, registration stays.
  - Wave 8 commits not-pushed — Mohamed pushes manually after Mac4 verification.
  - MotionMix repo's Phase 5a proof token model — read it, don't redefine it.
Mohamed runs all destructive ops: git push, launchctl unload && load, nssm remove,
social posts. Codex panes propose; Mohamed disposes.
Verification before declaration. A pane that says "done" includes runtime evidence.

## 1. Reading order
1. Desktop/evo-cube-output/lume-creative-engine-2026-05-02/divergent-rail.md (this rail) — your phase / track row
2. Desktop/evo-cube-output/lume-creative-engine-2026-05-02/stage3-expand-master-plan.md — your P{N} section
3. Desktop/evo-cube-output/lume-creative-engine-2026-05-02/creative-forge-output.md — relevant Q section ({Q1 for P1+P4, Q2 for P3, Q3 for P5})
4. (P-specific source files listed below)

## 2. Coordination protocol (verbatim)
Rule 1 — Claim before touch: write your file claims to [home-path]
Rule 2 — Read before write: cat [home-path] | grep -F <target> before any Edit/Write
Rule 3 — Newer claim defers; conflicts logged to [home-path]
Rule 4 — Commit prefix [P{N}] on every commit
Rule 5 — Pane closure: 5-line synthesis to [home-path]

## 3. File claim (write to [home-path] before first edit)
{exact paths from rail Pane assignment table}

## 4. Phase-by-phase task list
{copy from rail Phase tables, this pane's row only}

## 5. Success criterion (machine-checkable)
{copy from rail Pane assignment + gate criteria}

## 6. Don't-touch (universal + pane-specific)
{universal list + pane-specific list}

## 7. Escalation triggers (when to message Mohamed via inbox or sms)
- Production system constraint requires destructive op (git push, launchctl, nssm remove, social post)
- Mocopi flake reveals real timing bug (P3 only)
- LUMF golden-bytes test fails on byte ≥1 (P1 only)
- Photoshoot dry run fails at Day 2 EOD (P2 + Mohamed)
- ASA fit-test reveals tolerance breach (P5 only)
- Mac4 verification fails on point ≥1 (P3 + Mohamed)
- Pane registry shows file-claim conflict (any pane)

The Day 0 critical track produces 5 instances of this prompt with the bracketed sections filled in per pane. Pane P1's prompt is ~120 lines; P3's is the longest at ~180 lines (includes director-protocol sub-rail spec).

---

Decision log (Stage 4 specific — items resolved during rail-planning)

These are decisions made during this rail draft that the master plan + forge did not explicitly settle:

---

Forge V2 → V3 fallback decision tree (P1 audio path resilience)

Forge Q1 §2 enumerated 6 audio-tap variants V1-V6 and selected V2. Rail formalizes the fallback ladder so P1 doesn't get stuck if V2 underperforms on real device:

                          ┌─────────────────────────┐
                          │  V2 (chosen)            │
                          │  SPSC ring + 60 Hz      │
                          │  publisher thread       │
                          └────────┬────────────────┘
                                   │
                       Day 1 PM verify on iPhone
                                   │
                  ┌────────────────┴────────────────┐
                  │ K11 LUMF rate >= 58 pkt/s ?     │
                  │ no allocation in handlePCM ?    │
                  └────────────────┬────────────────┘
                                   │
                ┌──────────────────┴──────────────────┐
                │                                     │
              YES                                    NO
                │                                     │
        ┌───────▼────────┐                  ┌─────────▼──────────────────┐
        │  Phase 1 gate  │                  │  Day 1 EOD diagnose:       │
        │  passes        │                  │   - drop in ring? fail mode A │
        │                │                  │   - heartbeat starves?    │
        └────────────────┘                  │     fail mode B           │
                                            │   - alloc surfaces in     │
                                            │     publisher? mode C     │
                                            └─────────┬──────────────────┘
                                                      │
                                  ┌───────────────────┴──────────────────┐
                                  │   V3 (fallback)                       │
                                  │   sample-and-hold, 30 Hz publisher,   │
                                  │   accept LUMF rate ~30 pkt/s          │
                                  │   (Wave 8 receiver tolerates ≥28 Hz)  │
                                  └───────────────────┬──────────────────┘
                                                      │
                                          Day 2 verify again
                                                      │
                                  ┌───────────────────┴──────────────────┐
                                  │   pass → Phase 1 gate (degraded)     │
                                  │   fail → escalate to Mohamed,        │
                                  │           reel falls back to         │
                                  │           Strudel-render audio path  │
                                  │           (ships, just less          │
                                  │           "engine-driven" framing)   │
                                  └──────────────────────────────────────┘

V3 is documented in this rail (not the master plan or forge) because it's the rail-level contingency. P1 owns the V2→V3 pivot if needed and reports via inbox to Mohamed before pivoting.

---

Risk → Gate cross-reference (which risk fires which gate failure)

For Stage 5 meta-review's challenge surface — every risk should map to at least one gate failure mode:

---

Final fitness check (Stage 4 self-audit)

Before handing to Stage 5 `meta-review`, the rail self-audits against the original Stage 4 charter:

• [x] Sequential phases × parallel tracks — 5 phases, 22 tracks, max 5 per phase (with structural justification for the 2 over-cap cases)
• [x] EW invariants honored — explicit per-phase audit table above; breaches documented + mitigated
• [x] Machine-mapped — Mac1, Mac4, Mac5, K11, iPhone, iPad, Elegoo Max all assigned with day-by-day load
• [x] Coordination protocol — 5 rules + AudioEngine.swift special-case + commit-prefix enforcement
• [x] Pane assignment with don't-touch — Production System constraint in every row
• [x] Reel-ship deadline — 2026-05-09 EOD, Phase 4 Day 7 critical track
• [x] Director schema sub-rail (forge Q2) — Phase 2 Track A, Codable structs ship even though Rust defers
• [x] PAT rotation as hard prerequisite — Phase 0 Track A, sentinel-enforced
• [x] Mac4 vs K11 distinction explicit — Mac4 = recording surface for Phase 3 reel-record (Day 5 falls back to K11 if Mac4 sled isn't ready), K11 = publisher/recording surface throughout
• [x] Risk register per phase — 19 rows, every phase covered, security finding (FirstDate PAT) = top row
• [x] Gate criteria machine-checkable — every phase has shell commands or file-existence checks
• [x] Pane prompts not yet generated, but skeleton specified — so Day 0 critical track has a clear template
• [x] Length 500-900 lines — see footer count

End of divergent rail.