claude-code-workflow 7.2.27 → 7.2.29

package/.codex/skills/team-motion-design/roles/coordinator/commands/dispatch.md

@@ -0,0 +1,168 @@
+# Command: Dispatch
+
+Create the motion design task chain with correct dependencies and structured task descriptions. Supports tokens, component, and page pipeline modes.
+
+## Phase 2: Context Loading
+
+| Input | Source | Required |
+|-------|--------|----------|
+| User requirement | From coordinator Phase 1 | Yes |
+| Session folder | From coordinator Phase 2 | Yes |
+| Pipeline mode | From tasks.json `pipeline_mode` | Yes |
+| Framework config | From tasks.json `framework` | Yes |
+
+1. Load user requirement and motion scope from tasks.json
+2. Load pipeline stage definitions from specs/pipelines.md
+3. Read `pipeline_mode` and `framework` from tasks.json
+
+## Phase 3: Task Chain Creation (Mode-Branched)
+
+### Task Description Template
+
+Every task is added to tasks.json with structured format:
+
+```json
+{
+  "<TASK-ID>": {
+    "title": "<task title>",
+    "description": "PURPOSE: <what this task achieves> | Success: <measurable completion criteria>\nTASK:\n  - <step 1: specific action>\n  - <step 2: specific action>\n  - <step 3: specific action>\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <motion-scope>\n  - Framework: <framework>\n  - Upstream artifacts: <artifact-1>, <artifact-2>\n  - Shared memory: <session>/wisdom/.msg/meta.json\nEXPECTED: <deliverable path> + <quality criteria>\nCONSTRAINTS: <scope limits, focus areas>",
+    "role": "<role>",
+    "prefix": "<PREFIX>",
+    "deps": ["<dependency-list>"],
+    "status": "pending",
+    "findings": "",
+    "error": ""
+  }
+}
+```
+
+### Mode Router
+
+| Mode | Action |
+|------|--------|
+| `tokens` | Create 4 tasks: MRESEARCH -> CHOREO -> ANIM -> MTEST |
+| `component` | Create 4 tasks: MRESEARCH -> CHOREO -> ANIM -> MTEST (GC loop) |
+| `page` | Create 4+ tasks: MRESEARCH -> CHOREO -> [ANIM-001..N parallel] -> MTEST |
+
+---
+
+### Tokens Pipeline Task Chain
+
+**MRESEARCH-001** (motion-researcher):
+```json
+{
+  "MRESEARCH-001": {
+    "title": "Audit existing animations and measure performance baseline",
+    "description": "PURPOSE: Audit existing animations, measure performance baseline, catalog easing patterns | Success: 3 research artifacts produced with valid data\nTASK:\n  - Scan codebase for existing CSS @keyframes, transitions, JS animation code\n  - Measure paint/composite costs via Chrome DevTools performance traces (if available)\n  - Catalog existing easing functions and timing patterns\n  - Identify properties being animated (safe vs unsafe for compositor)\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <motion-scope>\n  - Framework: <framework>\n  - Shared memory: <session>/wisdom/.msg/meta.json\nEXPECTED: <session>/research/*.json | All 3 research files with valid JSON\nCONSTRAINTS: Read-only analysis | Focus on existing animation patterns",
+    "role": "motion-researcher",
+    "prefix": "MRESEARCH",
+    "deps": [],
+    "status": "pending",
+    "findings": "",
+    "error": ""
+  }
+}
+```
+
+**CHOREO-001** (choreographer):
+```json
+{
+  "CHOREO-001": {
+    "title": "Design animation token system",
+    "description": "PURPOSE: Design animation token system with easing functions, duration scale, stagger formulas | Success: Complete motion-tokens.json with all token categories\nTASK:\n  - Define easing functions (ease-out, ease-in-out, ease-spring) as cubic-bezier values\n  - Define duration scale (fast, base, slow, slower, slowest)\n  - Define stagger formula with base delay and increment\n  - Define reduced-motion fallback tokens\n  - Reference specs/motion-tokens.md for token schema\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <motion-scope>\n  - Framework: <framework>\n  - Upstream artifacts: research/*.json\n  - Shared memory: <session>/wisdom/.msg/meta.json\nEXPECTED: <session>/choreography/motion-tokens.json | Complete token system\nCONSTRAINTS: Follow motion-tokens.md schema | All tokens must have reduced-motion fallback",
+    "role": "choreographer",
+    "prefix": "CHOREO",
+    "deps": ["MRESEARCH-001"],
+    "status": "pending",
+    "findings": "",
+    "error": ""
+  }
+}
+```
+
+**ANIM-001** (animator):
+```json
+{
+  "ANIM-001": {
+    "title": "Implement CSS custom properties and utility classes from motion tokens",
+    "description": "PURPOSE: Implement CSS custom properties and utility classes from motion tokens | Success: Production-ready CSS with token consumption and reduced-motion overrides\nTASK:\n  - Generate CSS custom properties from motion-tokens.json\n  - Create utility animation classes consuming tokens\n  - Add prefers-reduced-motion media query overrides\n  - Ensure compositor-only properties (transform, opacity) per specs/gpu-constraints.md\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <motion-scope>\n  - Framework: <framework>\n  - Upstream artifacts: choreography/motion-tokens.json\n  - Shared memory: <session>/wisdom/.msg/meta.json\nEXPECTED: <session>/animations/keyframes/*.css | Token CSS + utility classes + reduced-motion\nCONSTRAINTS: Compositor-only animations | No layout-triggering properties | will-change budget",
+    "role": "animator",
+    "prefix": "ANIM",
+    "deps": ["CHOREO-001"],
+    "status": "pending",
+    "findings": "",
+    "error": ""
+  }
+}
+```
+
+**MTEST-001** (motion-tester):
+```json
+{
+  "MTEST-001": {
+    "title": "Verify animation performance and accessibility compliance",
+    "description": "PURPOSE: Verify animation performance and accessibility compliance | Success: 60fps confirmed, no layout thrashing, reduced-motion present\nTASK:\n  - Start Chrome DevTools performance trace (if available)\n  - Verify compositor-only animations (no paint/layout triggers)\n  - Check will-change usage (not excessive, max 3-4 elements)\n  - Validate prefers-reduced-motion @media query presence\n  - Static code analysis as fallback if Chrome DevTools unavailable\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <motion-scope>\n  - Framework: <framework>\n  - Upstream artifacts: animations/keyframes/*.css, choreography/motion-tokens.json\n  - Shared memory: <session>/wisdom/.msg/meta.json\nEXPECTED: <session>/testing/reports/perf-report-001.md | Performance validation report\nCONSTRAINTS: Target 60fps | Flag any layout-triggering properties",
+    "role": "motion-tester",
+    "prefix": "MTEST",
+    "deps": ["ANIM-001"],
+    "status": "pending",
+    "findings": "",
+    "error": ""
+  }
+}
+```
+
+---
+
+### Component Pipeline Task Chain
+
+Same as Tokens pipeline with enhanced task descriptions:
+
+- **MRESEARCH-001**: Same as tokens, plus focus on target component(s) existing animation
+- **CHOREO-001**: Same token design, plus transition state diagrams (entry/exit/hover/focus/loading) and scroll-triggered reveal sequences for the component(s)
+- **ANIM-001**: Implement component-specific animations: @keyframes, IntersectionObserver triggers, rAF coordination, staggered orchestration
+- **MTEST-001**: Same as tokens, plus GC loop -- if FPS < 60 or layout thrashing, send `fix_required` signal
+
+GC loop between animator and motion-tester (max 2 rounds).
+
+---
+
+### Page Pipeline Task Chain
+
+**MRESEARCH-001** and **CHOREO-001**: Same as component, but scope is full page with multiple scroll sections.
+
+**CHOREO-001** additionally defines scroll section boundaries, parallax depths, and staggered entry sequences per section.
+
+**ANIM-001..N** (parallel): One ANIM task per scroll section or page area:
+```json
+{
+  "ANIM-<NNN>": {
+    "title": "Implement animations for <section-name>",
+    "description": "PURPOSE: Implement animations for <section-name> | Success: Scroll-triggered reveals with 60fps performance\nTASK:\n  - Implement IntersectionObserver-based scroll triggers for <section-name>\n  - Apply staggered entry animations with calculated delays\n  - Add scroll-linked parallax (if specified in choreography)\n  - Ensure prefers-reduced-motion fallback\nCONTEXT:\n  - Session: <session-folder>\n  - Section: <section-name>\n  - Upstream artifacts: choreography/sequences/<section>.md, choreography/motion-tokens.json\n  - Shared memory: <session>/wisdom/.msg/meta.json\nEXPECTED: <session>/animations/keyframes/<section>.css + orchestrators/<section>.js\nCONSTRAINTS: Compositor-only | will-change budget | Follow motion-tokens",
+    "role": "animator",
+    "prefix": "ANIM",
+    "deps": ["CHOREO-001"],
+    "status": "pending",
+    "findings": "",
+    "error": ""
+  }
+}
+```
+
+**MTEST-001**: Blocked by all ANIM tasks. Full page performance validation.
+
+---
+
+## Phase 4: Validation
+
+Verify task chain integrity:
+
+| Check | Method | Expected |
+|-------|--------|----------|
+| Task count correct | tasks.json count | tokens: 4, component: 4, page: 4+N |
+| Dependencies correct | Trace dependency graph | Acyclic, correct deps |
+| No circular dependencies | Trace dependency graph | Acyclic |
+| Task IDs use correct prefixes | Pattern check | MRESEARCH/CHOREO/ANIM/MTEST |
+| Structured descriptions complete | Each has PURPOSE/TASK/CONTEXT/EXPECTED/CONSTRAINTS | All present |
+
+If validation fails, fix the specific task and re-validate.

package/.codex/skills/team-motion-design/roles/coordinator/commands/monitor.md

@@ -0,0 +1,242 @@
+# Monitor Pipeline
+
+Synchronous pipeline coordination using spawn_agent + wait_agent.
+
+## Constants
+
+- WORKER_AGENT: team_worker
+- MAX_GC_ROUNDS: 2
+
+## Handler Router
+
+| Source | Handler |
+|--------|---------|
+| "capability_gap" | handleAdapt |
+| "check" or "status" | handleCheck |
+| "resume" or "continue" | handleResume |
+| All tasks completed | handleComplete |
+| Default | handleSpawnNext |
+
+## handleCallback
+
+Worker completed (wait_agent returns). Process and advance.
+
+1. Determine role from completed task prefix:
+
+| Task Prefix | Role |
+|-------------|------|
+| `MRESEARCH-*` | motion-researcher |
+| `CHOREO-*` | choreographer |
+| `ANIM-*` | animator |
+| `MTEST-*` | motion-tester |
+
+2. Mark task completed in tasks.json: `state.tasks[taskId].status = 'completed'`
+3. Record completion in session state
+
+4. Check checkpoint for completed task:
+
+| Completed Task | Checkpoint | Action |
+|---------------|------------|--------|
+| MRESEARCH-001 | - | Notify user: research complete |
+| CHOREO-001 | - | Proceed to ANIM task(s) |
+| ANIM-* (single) | - | Proceed to MTEST-001 |
+| ANIM-* (page mode) | - | Check if all ANIM tasks complete, then unblock MTEST-001 |
+| MTEST-001 | PERF-001: Performance Gate | Check perf signal -> GC loop or complete |
+
+5. **Performance Gate handling** (MTEST task completed):
+   Read performance signal from result: `perf_passed`, `perf_warning`, or `fix_required`
+
+   | Signal | Condition | Action |
+   |--------|-----------|--------|
+   | `perf_passed` | FPS >= 60, no layout thrashing, reduced-motion present | Performance gate passed -> pipeline complete |
+   | `perf_warning` | Minor issues (will-change count high, near 60fps) | gc_rounds < max -> create ANIM-fix task |
+   | `fix_required` | FPS < 60 or layout thrashing detected | gc_rounds < max -> create ANIM-fix task (CRITICAL) |
+   | Any | gc_rounds >= max | Escalate to user |
+
+   **GC Fix Task Creation** (add to tasks.json):
+   ```json
+   {
+     "ANIM-fix-<round>": {
+       "title": "Address performance issues from motion-tester report",
+       "description": "PURPOSE: Address performance issues from motion-tester report | Success: All critical perf issues resolved\nTASK:\n  - Parse performance report for specific issues (layout thrashing, unsafe properties, excessive will-change)\n  - Replace layout-triggering properties with compositor-only alternatives\n  - Optimize will-change usage\n  - Verify reduced-motion fallback completeness\nCONTEXT:\n  - Session: <session-folder>\n  - Upstream artifacts: testing/reports/perf-report-<NNN>.md",
+       "role": "animator",
+       "prefix": "ANIM",
+       "deps": [],
+       "status": "pending",
+       "findings": "",
+       "error": ""
+     }
+   }
+   ```
+   Then create new MTEST task in tasks.json with deps on fix. Increment gc_state.round.
+
+   **GC Escalation Options** (when max rounds exceeded):
+   1. Accept current animations - skip performance review, continue
+   2. Try one more round
+   3. Terminate
+
+6. -> handleSpawnNext
+
+## handleCheck
+
+Read-only status report from tasks.json, then STOP.
+
+```
+Pipeline Status (<pipeline-mode>):
+  [DONE]  MRESEARCH-001 (motion-researcher)  -> research/*.json
+  [DONE]  CHOREO-001    (choreographer)       -> motion-tokens.json + sequences/
+  [RUN]   ANIM-001      (animator)            -> implementing animations...
+  [WAIT]  MTEST-001     (motion-tester)       -> blocked by ANIM-001
+
+GC Rounds: 0/2
+Performance Gate: pending
+Session: <session-id>
+Commands: 'resume' to advance | 'check' to refresh
+```
+
+Output status -- do NOT advance pipeline.
+
+## handleResume
+
+**Agent Health Check** (v4):
+```
+// Verify actual running agents match session state
+const runningAgents = list_agents({})
+// For each active_agent in tasks.json:
+//   - If agent NOT in runningAgents -> agent crashed
+//   - Reset that task to pending, remove from active_agents
+// This prevents stale agent references from blocking the pipeline
+```
+
+1. Audit tasks.json for inconsistencies:
+   - Tasks stuck in "in_progress" -> reset to "pending"
+   - Tasks with completed deps but still "pending" -> include in spawn list
+2. -> handleSpawnNext
+
+## handleSpawnNext
+
+Find ready tasks, spawn workers, wait for results.
+
+1. Read tasks.json: completedTasks, inProgressTasks, readyTasks (pending + all deps completed)
+2. No ready + work in progress -> report waiting, STOP
+3. No ready + nothing in progress -> handleComplete
+4. Has ready -> for each:
+   a. Check inner loop role with active worker -> skip (worker picks up)
+   b. Update task status to in_progress in tasks.json
+   c. team_msg log -> task_unblocked
+   d. Spawn team_worker:
+
+```javascript
+// 1) Update status in tasks.json
+state.tasks[taskId].status = 'in_progress'
+
+// 2) Spawn worker
+const agentId = spawn_agent({
+  agent_type: "team_worker",
+  task_name: taskId,  // e.g., "ANIM-001" -- enables named targeting
+  fork_context: false,
+  items: [
+    { type: "text", text: `## Role Assignment
+role: ${role}
+role_spec: ${skillRoot}/roles/${role}/role.md
+session: ${sessionFolder}
+session_id: ${sessionId}
+requirement: ${taskDescription}
+inner_loop: ${innerLoop}
+
+Read role_spec file to load Phase 2-4 domain instructions.
+Execute built-in Phase 1 (task discovery) -> role Phase 2-4 -> built-in Phase 5 (report).` },
+
+    { type: "text", text: `## Task Context
+task_id: ${taskId}
+title: ${taskTitle}
+description: ${taskDescription}
+pipeline_phase: ${pipelinePhase}` },
+
+    { type: "text", text: `## Upstream Context
+${prevContext}` }
+  ]
+})
+
+// 3) Track agent
+state.active_agents[taskId] = { agentId, role, started_at: now }
+
+// 4) Wait for completion -- use task_name for stable targeting (v4)
+const waitResult = wait_agent({ targets: [taskId], timeout_ms: 900000 })
+if (waitResult.timed_out) {
+  state.tasks[taskId].status = 'timed_out'
+  close_agent({ target: taskId })
+  delete state.active_agents[taskId]
+} else {
+  // 5) Collect results and update tasks.json
+  state.tasks[taskId].status = 'completed'
+  close_agent({ target: taskId })  // Use task_name, not agentId
+  delete state.active_agents[taskId]
+}
+```
+
+**Parallel spawn rules by mode**:
+
+| Mode | Scenario | Spawn Behavior |
+|------|----------|---------------|
+| tokens | Sequential | One task at a time |
+| component | Sequential | One task at a time, GC loop on MTEST |
+| page | After CHOREO-001 | Spawn ANIM-001..N in parallel, wait_agent for all |
+| page | After all ANIM complete | Spawn MTEST-001 |
+
+**Cross-Agent Supplementary Context** (v4):
+
+When spawning workers in a later pipeline phase, send upstream results as supplementary context to already-running workers:
+
+```
+// Example: Send research results to running choreographer
+send_message({
+  target: "<running-agent-task-name>",
+  items: [{ type: "text", text: `## Supplementary Context\n${upstreamFindings}` }]
+})
+// Note: send_message queues info without interrupting the agent's current work
+```
+
+Use `send_message` (not `assign_task`) for supplementary info that enriches but doesn't redirect the agent's current task.
+
+5. Update tasks.json, output summary, STOP
+
+## handleComplete
+
+**Cleanup Verification** (v4):
+```
+// Verify all agents are properly closed
+const remaining = list_agents({})
+// If any team agents still running -> close_agent each
+// Ensures clean session shutdown
+```
+
+Pipeline done. Generate report and completion action.
+
+**Completion check by mode**:
+
+| Mode | Completion Condition |
+|------|---------------------|
+| tokens | All 4 tasks (+ fix tasks) completed |
+| component | All 4 tasks (+ fix tasks) completed |
+| page | All 4+N tasks (+ fix tasks) completed |
+
+1. If any tasks not completed -> handleSpawnNext
+2. If all completed -> transition to coordinator Phase 5
+
+## handleAdapt
+
+Capability gap reported mid-pipeline.
+
+1. Parse gap description
+2. Check if existing role covers it -> redirect
+3. Role count < 5 -> generate dynamic role spec
+4. Create new task in tasks.json, spawn worker
+5. Role count >= 5 -> merge or pause
+
+## Fast-Advance Reconciliation
+
+On every coordinator wake:
+1. Read tasks.json for completed tasks
+2. Sync active_agents with actual state
+3. No duplicate spawns

package/.codex/skills/team-motion-design/roles/coordinator/role.md

@@ -0,0 +1,210 @@
+# Coordinator Role
+
+Motion Design Team coordinator. Orchestrate pipeline: analyze -> dispatch -> spawn -> monitor -> report. Manages animation task chains with GC loops for performance validation.
+
+## Scope Lock (READ FIRST -- overrides all other sections)
+
+**You are a dispatcher, not a doer.** Your ONLY outputs are:
+- Session state files (`.workflow/.team/` directory)
+- `spawn_agent` / `wait_agent` / `close_agent` / `send_message` / `assign_task` calls
+- Status reports to the user / `request_user_input` prompts
+
+**FORBIDDEN** (even if the task seems trivial):
+```
+WRONG: Read/Grep/Glob on project source code        -- worker work
+WRONG: Bash("ccw cli ...")                           -- worker work
+WRONG: Edit/Write on project source files            -- worker work
+```
+
+**Self-check gate**: Before ANY tool call, ask: "Is this orchestration or project work? If project work -> STOP -> spawn worker."
+
+---
+
+## Identity
+- **Name**: coordinator | **Tag**: [coordinator]
+- **Responsibility**: Analyze task -> Create session -> Dispatch tasks -> Monitor progress -> Report results
+
+## Boundaries
+
+### MUST
+- All output (team_msg, logs) must carry `[coordinator]` identifier
+- Use `team_worker` agent type for all worker spawns (NOT `general-purpose`)
+- Dispatch tasks with proper dependency chains and deps in tasks.json
+- Monitor worker progress via wait_agent and process results
+- Handle Generator-Critic loops with max 2 iterations
+- Maintain session state persistence (tasks.json)
+- **Always proceed through full Phase 1-5 workflow, never skip to direct execution**
+- Use `send_message` for supplementary context (non-interrupting) and `assign_task` for triggering new work
+- Use `list_agents` for session resume health checks and cleanup verification
+
+### MUST NOT
+- Implement domain logic (researching, choreographing, animating, testing) -- workers handle this
+- Spawn workers without creating tasks first
+- Skip sync points when configured
+- Force-advance pipeline past failed performance test
+- Modify source code or animation artifacts directly -- delegate to workers
+- Omit `[coordinator]` identifier in any output
+- Call CLI tools (ccw cli) -- only workers use CLI
+
+## Command Execution Protocol
+
+When coordinator needs to execute a command (analyze, dispatch, monitor):
+
+1. Read `commands/<command>.md`
+2. Follow the workflow defined in the command
+3. Commands are inline execution guides, NOT separate agents
+4. Execute synchronously, complete before proceeding
+
+## Entry Router
+
+| Detection | Condition | Handler |
+|-----------|-----------|---------|
+| Status check | Args contain "check" or "status" | -> handleCheck (monitor.md) |
+| Manual resume | Args contain "resume" or "continue" | -> handleResume (monitor.md) |
+| Capability gap | Message contains "capability_gap" | -> handleAdapt (monitor.md) |
+| Pipeline complete | All tasks have status "completed" | -> handleComplete (monitor.md) |
+| Interrupted session | Active/paused session exists in .workflow/.team/MD-* | -> Phase 0 |
+| New session | None of above | -> Phase 1 |
+
+For check/resume/adapt/complete: load `@commands/monitor.md`, execute matched handler, STOP.
+
+## Phase 0: Session Resume Check
+
+1. Scan `.workflow/.team/MD-*/tasks.json` for active/paused sessions
+2. No sessions -> Phase 1
+3. Single session -> reconcile (read tasks.json, reset in_progress->pending, kick first ready task)
+4. Multiple -> request_user_input for selection
+
+## Phase 1: Requirement Clarification
+
+TEXT-LEVEL ONLY. No source code reading.
+
+1. Parse task description from arguments
+2. Detect motion scope:
+
+| Signal | Pipeline Mode |
+|--------|---------------|
+| Token, easing, duration system, motion tokens | tokens |
+| Animate specific component(s), single element | component |
+| Full page scroll choreography, page transitions | page |
+| Unclear | ask user |
+
+3. Ask for missing parameters if scope unclear:
+   ```
+   request_user_input({
+     questions: [
+       { question: "Motion design scope?", header: "Scope", options: [
+         { label: "Animation token system", description: "Easing functions, duration scale, stagger formulas" },
+         { label: "Component animation", description: "Animate specific component(s) with transitions" },
+         { label: "Page scroll choreography", description: "Full page scroll-triggered reveals and transitions" }
+       ]},
+       { question: "Target framework?", header: "Framework", options: [
+         { label: "CSS-only" }, { label: "React" },
+         { label: "Vue" }, { label: "Vanilla JS" }, { label: "Other" }
+       ]}
+     ]
+   })
+   ```
+4. Delegate to `@commands/analyze.md` -> output scope context
+5. Record: pipeline_mode, framework, complexity
+
+## Phase 2: Create Session + Initialize
+
+1. Resolve workspace paths (MUST do first):
+   - `project_root` = result of `Bash({ command: "pwd" })`
+   - `skill_root` = `<project_root>/.codex/skills/team-motion-design`
+2. Generate session ID: `MD-<slug>-<YYYY-MM-DD>`
+3. Create session folder structure:
+   ```
+   .workflow/.team/MD-<slug>-<date>/research/perf-traces/
+   .workflow/.team/MD-<slug>-<date>/choreography/sequences/
+   .workflow/.team/MD-<slug>-<date>/animations/keyframes/
+   .workflow/.team/MD-<slug>-<date>/animations/orchestrators/
+   .workflow/.team/MD-<slug>-<date>/testing/traces/
+   .workflow/.team/MD-<slug>-<date>/testing/reports/
+   .workflow/.team/MD-<slug>-<date>/wisdom/
+   .workflow/.team/MD-<slug>-<date>/.msg/
+   ```
+4. Initialize `.msg/meta.json` via team_msg state_update with pipeline metadata
+5. Write initial tasks.json:
+   ```json
+   {
+     "session_id": "<id>",
+     "pipeline_mode": "<tokens|component|page>",
+     "framework": "<framework>",
+     "created_at": "<ISO timestamp>",
+     "gc_rounds": 0,
+     "max_gc_rounds": 2,
+     "active_agents": {},
+     "tasks": {}
+   }
+   ```
+6. Do NOT spawn workers yet - deferred to Phase 4
+
+## Phase 3: Create Task Chain
+
+Delegate to `@commands/dispatch.md`. Task chains by mode:
+
+| Mode | Task Chain |
+|------|------------|
+| tokens | MRESEARCH-001 -> CHOREO-001 -> ANIM-001 -> MTEST-001 |
+| component | MRESEARCH-001 -> CHOREO-001 -> ANIM-001 -> MTEST-001 (GC loop) |
+| page | MRESEARCH-001 -> CHOREO-001 -> [ANIM-001..N parallel] -> MTEST-001 |
+
+## Phase 4: Spawn-and-Wait
+
+Delegate to `@commands/monitor.md#handleSpawnNext`:
+1. Find ready tasks (pending + deps resolved)
+2. Spawn team_worker agents via spawn_agent, wait_agent for results
+3. Output status summary
+4. STOP
+
+## Phase 5: Report + Completion Action
+
+1. Read session state -> collect all results
+2. List deliverables:
+
+| Deliverable | Path |
+|-------------|------|
+| Animation Inventory | <session>/research/animation-inventory.json |
+| Performance Baseline | <session>/research/performance-baseline.json |
+| Easing Catalog | <session>/research/easing-catalog.json |
+| Motion Tokens | <session>/choreography/motion-tokens.json |
+| Choreography Sequences | <session>/choreography/sequences/*.md |
+| CSS Keyframes | <session>/animations/keyframes/*.css |
+| JS Orchestrators | <session>/animations/orchestrators/*.js |
+| Performance Reports | <session>/testing/reports/perf-report-*.md |
+
+3. Calculate: completed_tasks, gc_rounds, perf_score, final_fps
+4. Output pipeline summary with [coordinator] prefix
+5. Execute completion action:
+   ```
+   request_user_input({
+     questions: [{ question: "Pipeline complete. What next?", header: "Completion", options: [
+       { label: "Archive & Clean", description: "Archive session and clean up resources" },
+       { label: "Keep Active", description: "Keep session for follow-up work" },
+       { label: "Export Results", description: "Export deliverables to specified location" }
+     ]}]
+   })
+   ```
+
+## v4 Coordination Patterns
+
+### Message Semantics
+- **send_message**: Queue supplementary info to a running agent. Does NOT interrupt current processing. Use for: sharing upstream results, context enrichment, FYI notifications.
+- **assign_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output.
+
+### Agent Lifecycle Management
+- **list_agents({})**: Returns all running agents. Use in handleResume to reconcile session state with actual running agents. Use in handleComplete to verify clean shutdown.
+- **Named targeting**: Workers spawned with `task_name: "<task-id>"` can be addressed by name in send_message, assign_task, and close_agent calls.
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| Task timeout | Log, mark failed, ask user to retry or skip |
+| Worker crash | Reset task to pending, respawn worker |
+| Dependency cycle | Detect, report to user, halt |
+| Invalid scope | Reject with error, ask to clarify |
+| Session corruption | Attempt recovery, fallback to manual reconciliation |
+| GC loop stuck > 2 rounds | Escalate to user: accept / try one more / terminate |