Add progressive artifact reveal to catwalk demo replay

[williamthorsen]

Problem

When the catwalk scene loads, all artifacts render immediately — inputs, outputs, and summary deliverables appear at once. In a demo or replay, artifacts should appear progressively as the orchestrator advances through stations and delivers outputs to recipients.

Three underlying issues prevent this:

1. Eager input derivation: buildInputArtifacts derives all input artifacts regardless of orchestrator position, so outputs and their derived inputs appear in the same diff with no delivery animation.
2. Wrong delivery target: The delivery choreography targets artifacts at the origin station instead of the destination, landing them at the wrong station.
3. No backward path: The scene can only move forward — there's no rebuild path when the demo restarts or steps backward.

Considerations

• The Polish catwalk M3: chute alignment, error visibility, and mapper test gap #239 catwalk layout work added input artifact propagation and summary station collection, roughly tripling the artifact count for completed runs.
• The demo system currently models recordings as { header: RunHeader, events: RunEvent[] } and folds events into snapshots on every tick — an unnecessary indirection.
• The non-catwalk visualizations (factory scene, flow diagram) are unused and can be removed.
• CatwalkCanvas.tsx imports GameCanvas.css directly, so deleting GameCanvas.tsx requires renaming the CSS file to avoid breaking canvas styles.
• Task 4 (choreographer delivery fix) depends on Task 2 (mapper deferral) for integration testing, since the new delivery filter only matches deferred inputs. Unit tests can be written independently.

Solution

• Remove non-catwalk visualizations. Strip the visualization switcher, factory scene, and flow diagram. Render CatwalkCanvas directly from App.tsx.
• Defer input derivation in mapper. buildInputArtifacts only derives inputs for stations the orchestrator has reached. Inputs appear in the diff exactly when the orchestrator moves to their station, producing the co-occurrence signal the choreographer needs.
• Add scene rebuild on artifact regression. updateStatus detects artifacts disappearing between configs and triggers a full clear + rebuild. Handles backward stepping and demo restarts.
• Fix delivery choreography. Delivery targets are slot: 'input' artifacts at the destination station. Sequence: flying ascend from origin chute → orchestrator walks → flying descend at destination → static input fades in.
• Simplify demo data model. Replace RunHeader + RunEvent[] with a flat CanonicalRunStatus[] snapshot sequence. PlaybackController becomes a snapshot stepper with fixed base interval (~1.5s at 1x) and minimum floor (~300ms).
• Create curated demo recording. ~20–25 snapshots covering all animation types: orchestrator movement, artifact fade-in, delivery, gate opens, agent state changes, summary reveal.

Acceptance criteria

• Artifacts appear only after their producing phase completes (or as the orchestrator arrives at the station)
• Input artifacts at station N+1 appear after outputs at station N are visible — delivered by the orchestrator (ascend → walk → descend → land)
• Summary station artifacts appear only when the run reaches completed status
• Loading a completed run in non-replay mode still shows the final state immediately
• Demo data is a flat CanonicalRunStatus[] snapshot sequence
• Non-catwalk visualizations removed

[williamthorsen]

<details>
<summary>Implementation plan</summary>

# Implementation plan: Progressive artifact reveal in catwalk demo replay

## Approach

Work in three streams, then converge. The animation-fixes stream has an internal dependency: Task 2 (mapper deferral) must be complete before Task 4 (choreographer delivery fix) can be fully integration-tested, because the new delivery filter in Task 4 only matches artifacts that Task 2 defers. Unit tests for each task can be written in isolation.

1. **Clean up** — remove non-catwalk visualizations to reduce surface area
2. **Animation fixes** — mapper deferral (Task 2), scene rebuild on regression (Task 3), choreographer delivery fix (Task 4); sequence Task 2 before Task 4 to support integration testing
3. **Demo system** — simplify to snapshot-based model, create curated demo data

## Tasks

### Task 1: Remove non-catwalk visualizations

**Files:**
- Remove: `VisualizationSwitcher.tsx`, `useVisualizationParam.ts`, `GameCanvas.tsx`, `FlowDiagram.tsx` and their CSS/test files
- Remove: factory scene and flow diagram source (follow import chain from removed components)
- Rename: `GameCanvas.css` → a neutral name (e.g. `canvas.css`) and update the import in `CatwalkCanvas.tsx` accordingly, since `CatwalkCanvas.tsx` imports `./GameCanvas.css` directly and must not lose those styles when `GameCanvas.tsx` is deleted
- Modify: `App.tsx` — render `CatwalkCanvas` directly instead of `VisualizationSwitcher`

**What:** Strip out the factory and flow visualizations and the visualization switcher. `App.tsx` renders `CatwalkCanvas` directly with the `status` prop. This reduces the component tree and removes dead code.

Note: `App.css` contains `.viz-toggle` rules and view-specific `.canvas-container[data-view='factory'/'flow']` variants that exist solely to support `VisualizationSwitcher`. CSS cleanup decisions (whether to remove these orphaned rules, and which base `.canvas-container` styles to preserve) are left to the implementer and reviewers.

**Key decisions:**
- Remove the `?visualization=` URL param handling entirely
- Keep CatwalkCanvas unchanged apart from the CSS import rename

**Acceptance criteria:**
- App renders CatwalkCanvas directly, no visualization tabs
- Factory scene, flow diagram, and switcher code deleted
- `GameCanvas.css` renamed and import in `CatwalkCanvas.tsx` updated so canvas styles are preserved
- TypeScript compiles clean, existing catwalk tests pass

### Task 2: Defer input artifact derivation in mapper

**Files:**
- Modify: `packages/factory/src/client/visualizations/catwalk/mappers/run-to-catwalk.ts`
- Test: `packages/factory/src/client/visualizations/catwalk/mappers/__tests__/run-to-catwalk.test.ts`

**What:** Change `buildInputArtifacts` to only derive input artifacts for stations the orchestrator has reached. This ensures inputs appear in the diff exactly when the orchestrator moves to their station, producing the co-occurrence of orchestrator movement + new artifacts that the choreographer needs to infer a delivery.

**Key decisions:**
- Compute orchestrator station index from `findCurrentPhase()` result (already available in `mapRunToCatwalk`)
- Pass the orchestrator's station index to `buildInputArtifacts`; filter: only create inputs at stations ≤ orchestrator station
- When the run is completed (`status.status === 'completed'`), derive all inputs (orchestrator has passed all stations). This preserves AC4
- Summary inputs (station 6) keep their existing guard (`status === 'completed'`) — unchanged

**Acceptance criteria:**
- For in-progress runs: inputs only exist at stations the orchestrator has reached
- For completed runs: all inputs present (same as today)
- Existing mapper tests updated; new tests for the deferred behavior

### Task 3: Add scene rebuild on artifact regression

**Files:**
- Modify: `packages/factory/src/client/visualizations/catwalk/scene/CatwalkScene.ts`
- Test: `packages/factory/src/client/visualizations/catwalk/scene/__tests__/CatwalkScene.test.ts`

**What:** When `updateStatus` detects that artifacts from prevConfig are missing in the new config, it triggers a full clear + rebuild instead of computing a forward-only diff. This handles demo backward stepping, playback restarts, and recording changes.

**Key decisions:**
- Detection: compare artifact key sets between prevConfig and nextConfig. If any key in prevConfig is absent from nextConfig, rebuild
- Extract a `resetScene(status)` method that clears all actors, resets internal registries (`artifactKeySet`, `artifactCountByKey`, `agentRefs`, `gateRefs`, `orchestratorRef`), and calls `buildScene()`
- Cancel any in-flight choreography before rebuild (set `choreographyInProgress = false`, clear `pendingDiff`)
- Rebuild is a cold start — no animations, instant render. This is correct for backward steps

**Acceptance criteria:**
- Forward status updates continue to use diff + animation (no regression)
- Backward status updates (fewer artifacts) trigger rebuild with correct final state
- In-flight choreography doesn't interfere with rebuild

### Task 4: Fix delivery choreography

**Files:**
- Modify: `packages/factory/src/client/visualizations/catwalk/choreography/chute-choreographer.ts`
- Test: `packages/factory/src/client/visualizations/catwalk/choreography/__tests__/chute-choreographer.test.ts`

**What:** Fix the delivery model so the orchestrator delivers input artifacts to destination stations, not output artifacts back to origin stations.

**Key decisions:**
- Delivery artifacts: `diff.artifacts.added.filter(a => a.stationIndex === moved.to && a.slot === 'input')` — inputs at the destination
- Non-delivery artifacts: everything else — fade in immediately via `refs.addArtifact`
- Ascend position: compute from `moved.from` (origin station) chute. Use a default chute position at the origin since the source output's agent slot may differ from the delivery artifact's
- Descend position: compute from `moved.to` (destination station) input zone layout
- Static artifact placed at destination station (fixes the "land at wrong station" bug where `addSingleArtifact` used `artifact.stationIndex`)
- If no delivery artifacts but orchestrator moved: `applyImmediate` path (unchanged)

Note: Task 2 must be merged before this task can be integration-tested end-to-end. Unit tests for the choreographer can be written in isolation using a mocked diff that already contains destination-station inputs. Sequence Task 2 before Task 4 in the merge order to avoid integration risk.

**Acceptance criteria:**
- When orchestrator moves from N to N+1 and inputs appear at N+1: flying ascend from N → walk → descend at N+1 → static input fades in
- Outputs at station N fade in when their `artifact_written` fires (no movement, `applyImmediate`)
- No artifacts land at the wrong station

### Task 5: Simplify demo data model and PlaybackController

**Files:**
- Modify: `packages/factory/src/client/demo/index.ts` — change `DemoRecording` type
- Modify: `packages/factory/src/client/playback/playback-controller.ts` — snapshot-based
- Modify: `packages/factory/src/client/hooks/usePlayback.ts` — adapt to new controller
- Modify: `packages/factory/src/client/hooks/useDemoMode.ts` — adapt to new recording type
- Modify: `packages/factory/src/client/components/DemoControlPanel.tsx` — remove normalize-gaps, update labels
- Modify: `packages/factory/src/client/App.tsx` — remove `normalized` state, `handleToggleNormalized` callback, and `normalized`/`onToggleNormalized` props passed to `DemoControlPanel`
- Test: all corresponding test files

**What:** Replace the event-folding playback model with direct snapshot stepping. `DemoRecording` becomes `{ name, description, snapshots: CanonicalRunStatus[] }`. PlaybackController holds `snapshots[]` and emits `snapshots[cursor]` directly. Fixed base interval between snapshots (adjustable by speed control).

**Key decisions:**
- Remove `header`, `events`, `foldEvents` from the playback path entirely
- Base interval: ~1.5 seconds between snapshots at 1x speed (long enough for a delivery animation to complete)
- Minimum interval floor: ~300ms regardless of speed, ensuring every snapshot's transition is visible
- Max speed: 32x (down from 128x). At 32x with 1.5s base interval, the computed interval is 47ms — clamped to 300ms
- Remove normalization concept (no event timestamps to normalize) — remove from PlaybackController, hook, DemoControlPanel, and App.tsx
- `eventCount` renamed to `snapshotCount` (or `frameCount`) in public API
- `cursor` semantics unchanged: -1 = before start, 0..length-1 = index into snapshots

**Acceptance criteria:**
- PlaybackController accepts `snapshots[]`, emits them directly
- No `foldEvents` call in the playback path
- Fixed interval timing with speed control and minimum floor
- Normalize-gaps checkbox removed from UI
- All playback controls (play/pause/stop/step/speed) work as before

### Task 6: Create snapshot-based demo recording

**Files:**
- Rewrite: `packages/factory/src/client/demo/recordings/moderately-complex-run.ts`
- Test: `packages/factory/src/client/demo/__tests__/demo-recordings.test.ts`

**What:** Replace the event-based recording with a curated sequence of `CanonicalRunStatus` snapshots. Each snapshot represents a meaningful visual transition point in the run.

**Key decisions:**
- Generate initial snapshots by folding the existing events at each step (use `foldEvents` as a one-time generation tool, not at runtime)
- Curate to include only snapshots that produce distinct `CatwalkSceneConfig` diffs: ~20–25 snapshots covering run start, each phase start, each artifact, each phase complete, run complete
- Include enough snapshots to exercise all animation types: orchestrator movement, artifact fade-in, delivery (ascend → walk → descend → land), gate opens, agent state changes, summary reveal

**Acceptance criteria:**
- Demo recording is `CanonicalRunStatus[]` with no `RunHeader` or `RunEvent[]`
- Playing the demo shows progressive artifact reveal with delivery animations
- All 6 ticket acceptance criteria pass when demo is played end-to-end

## Risks

- **Factory/flow removal** — deleting `GameCanvas` and `FlowDiagram` makes their transitive imports dead code. The import chain may be several files deep (scene → actors → utilities). TypeScript compiler errors will guide the cleanup.
- **Task 2 → Task 4 integration dependency** — Task 4's delivery filter only matches deferred inputs produced by Task 2. Unit tests for each task can be written independently, but integration testing requires Task 2 to be merged first.

## Verification

- `pnpm -w typecheck` — clean compilation
- `pnpm --filter factory test` — all catwalk and demo tests pass
- Manual: load the app, play the demo recording, observe progressive artifact reveal with delivery animations
- Manual: view a completed run in normal mode, verify all artifacts appear immediately
- Manual: step backward in demo, verify scene rebuilds correctly

</details>