claude-code-workflow 7.2.24 → 7.2.26

package/.codex/skills/team-iterdev/roles/coordinator/commands/analyze.md

@@ -1,62 +0,0 @@
-# Analyze Task
-
-Parse iterative development task -> detect capabilities -> assess pipeline complexity -> design roles.
-
-**CONSTRAINT**: Text-level analysis only. NO source code reading, NO codebase exploration.
-
-## Signal Detection
-
-| Keywords | Capability | Role |
-|----------|------------|------|
-| design, architect, restructure, refactor plan | architect | architect |
-| implement, build, code, fix, develop | developer | developer |
-| test, verify, validate, coverage | tester | tester |
-| review, audit, quality, check | reviewer | reviewer |
-
-## Pipeline Selection
-
-| Signal | Score |
-|--------|-------|
-| Changed files > 10 | +3 |
-| Changed files 3-10 | +2 |
-| Structural change (refactor, architect, restructure) | +3 |
-| Cross-cutting (multiple, across, cross) | +2 |
-| Simple fix (fix, bug, typo, patch) | -2 |
-
-| Score | Pipeline |
-|-------|----------|
-| >= 5 | multi-sprint |
-| 2-4 | sprint |
-| 0-1 | patch |
-
-## Dependency Graph
-
-Natural ordering tiers:
-- Tier 0: architect (design must come first)
-- Tier 1: developer (implementation requires design)
-- Tier 2: tester, reviewer (validation requires artifacts, can run parallel)
-
-## Complexity Assessment
-
-| Factor | Points |
-|--------|--------|
-| Cross-module changes | +2 |
-| Serial depth > 3 | +1 |
-| Multiple developers needed | +2 |
-| GC loop likely needed | +1 |
-
-## Output
-
-Write <session>/task-analysis.json:
-```json
-{
-  "task_description": "<original>",
-  "pipeline_type": "<patch|sprint|multi-sprint>",
-  "capabilities": [{ "name": "<cap>", "role": "<role>", "keywords": ["..."] }],
-  "roles": [{ "name": "<role>", "prefix": "<PREFIX>", "inner_loop": false }],
-  "complexity": { "score": 0, "level": "Low|Medium|High" },
-  "needs_architecture": true,
-  "needs_testing": true,
-  "needs_review": true
-}
-```

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

@@ -1,187 +0,0 @@
-# Command: Dispatch
-
-Create the iterative development task chain with correct dependencies and structured task descriptions.
-
-## Phase 2: Context Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| User requirement | From coordinator Phase 1 | Yes |
-| Session folder | From coordinator Phase 2 | Yes |
-| Pipeline definition | From SKILL.md Pipeline Definitions | Yes |
-| Pipeline mode | From tasks.json `pipeline_mode` | Yes |
-
-1. Load user requirement and scope from tasks.json
-2. Load pipeline stage definitions from SKILL.md Task Metadata Registry
-3. Read `pipeline_mode` from tasks.json (patch / sprint / multi-sprint)
-
-## Phase 3: Task Chain Creation
-
-### Task Entry Template
-
-Each task in tasks.json `tasks` object:
-```json
-{
-  "<TASK-ID>": {
-    "title": "<concise 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: <task-scope>\n  - Upstream artifacts: <artifact-1>, <artifact-2>\n  - Shared memory: <session>/.msg/meta.json\nEXPECTED: <deliverable path> + <quality criteria>\nCONSTRAINTS: <scope limits, focus areas>\n---\nInnerLoop: <true|false>",
-    "role": "<role-name>",
-    "prefix": "<PREFIX>",
-    "deps": ["<dependency-list>"],
-    "status": "pending",
-    "findings": "",
-    "error": ""
-  }
-}
-```
-
-### Mode Router
-
-| Mode | Action |
-|------|--------|
-| `patch` | Create DEV-001 + VERIFY-001 |
-| `sprint` | Create DESIGN-001 + DEV-001 + VERIFY-001 + REVIEW-001 |
-| `multi-sprint` | Create Sprint 1 chain, subsequent sprints created dynamically |
-
----
-
-### Patch Pipeline
-
-**DEV-001** (developer):
-```json
-{
-  "DEV-001": {
-    "title": "Implement fix",
-    "description": "PURPOSE: Implement fix | Success: Fix applied, syntax clean\nTASK:\n  - Load target files and understand context\n  - Apply fix changes\n  - Validate syntax\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <task-scope>\n  - Shared memory: <session>/.msg/meta.json\nEXPECTED: Modified source files + <session>/code/dev-log.md | Syntax clean\nCONSTRAINTS: Minimal changes | Preserve existing behavior\n---\nInnerLoop: true",
-    "role": "developer",
-    "prefix": "DEV",
-    "deps": [],
-    "status": "pending",
-    "findings": "",
-    "error": ""
-  }
-}
-```
-
-**VERIFY-001** (tester):
-```json
-{
-  "VERIFY-001": {
-    "title": "Verify fix correctness",
-    "description": "PURPOSE: Verify fix correctness | Success: Tests pass, no regressions\nTASK:\n  - Detect test framework\n  - Run targeted tests for changed files\n  - Run regression test suite\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <task-scope>\n  - Upstream artifacts: code/dev-log.md\n  - Shared memory: <session>/.msg/meta.json\nEXPECTED: <session>/verify/verify-001.json | Pass rate >= 95%\nCONSTRAINTS: Focus on changed files | Report any regressions\n---\nInnerLoop: false",
-    "role": "tester",
-    "prefix": "VERIFY",
-    "deps": ["DEV-001"],
-    "status": "pending",
-    "findings": "",
-    "error": ""
-  }
-}
-```
-
----
-
-### Sprint Pipeline
-
-**DESIGN-001** (architect):
-```json
-{
-  "DESIGN-001": {
-    "title": "Technical design and task breakdown",
-    "description": "PURPOSE: Technical design and task breakdown | Success: Design document + task breakdown ready\nTASK:\n  - Explore codebase for patterns and dependencies\n  - Create component design with integration points\n  - Break down into implementable tasks with acceptance criteria\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <task-scope>\n  - Shared memory: <session>/.msg/meta.json\nEXPECTED: <session>/design/design-001.md + <session>/design/task-breakdown.json | Components defined, tasks actionable\nCONSTRAINTS: Focus on <task-scope> | Risk assessment required\n---\nInnerLoop: false",
-    "role": "architect",
-    "prefix": "DESIGN",
-    "deps": [],
-    "status": "pending",
-    "findings": "",
-    "error": ""
-  }
-}
-```
-
-**DEV-001** (developer):
-```json
-{
-  "DEV-001": {
-    "title": "Implement design",
-    "description": "PURPOSE: Implement design | Success: All design tasks implemented, syntax clean\nTASK:\n  - Load design and task breakdown\n  - Implement tasks in execution order\n  - Validate syntax after changes\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <task-scope>\n  - Upstream artifacts: design/design-001.md, design/task-breakdown.json\n  - Shared memory: <session>/.msg/meta.json\nEXPECTED: Modified source files + <session>/code/dev-log.md | Syntax clean, all tasks done\nCONSTRAINTS: Follow design | Preserve existing behavior | Follow code conventions\n---\nInnerLoop: true",
-    "role": "developer",
-    "prefix": "DEV",
-    "deps": ["DESIGN-001"],
-    "status": "pending",
-    "findings": "",
-    "error": ""
-  }
-}
-```
-
-**VERIFY-001** (tester, parallel with REVIEW-001):
-```json
-{
-  "VERIFY-001": {
-    "title": "Verify implementation",
-    "description": "PURPOSE: Verify implementation | Success: Tests pass, no regressions\nTASK:\n  - Detect test framework\n  - Run tests for changed files\n  - Run regression test suite\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <task-scope>\n  - Upstream artifacts: code/dev-log.md\n  - Shared memory: <session>/.msg/meta.json\nEXPECTED: <session>/verify/verify-001.json | Pass rate >= 95%\nCONSTRAINTS: Focus on changed files | Report regressions\n---\nInnerLoop: false",
-    "role": "tester",
-    "prefix": "VERIFY",
-    "deps": ["DEV-001"],
-    "status": "pending",
-    "findings": "",
-    "error": ""
-  }
-}
-```
-
-**REVIEW-001** (reviewer, parallel with VERIFY-001):
-```json
-{
-  "REVIEW-001": {
-    "title": "Code review for correctness and quality",
-    "description": "PURPOSE: Code review for correctness and quality | Success: All dimensions reviewed, verdict issued\nTASK:\n  - Load changed files and design document\n  - Review across 4 dimensions: correctness, completeness, maintainability, security\n  - Score quality (1-10) and issue verdict\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <task-scope>\n  - Upstream artifacts: design/design-001.md, code/dev-log.md\n  - Shared memory: <session>/.msg/meta.json\nEXPECTED: <session>/review/review-001.md | Per-dimension findings with severity\nCONSTRAINTS: Focus on implementation changes | Provide file:line references\n---\nInnerLoop: false",
-    "role": "reviewer",
-    "prefix": "REVIEW",
-    "deps": ["DEV-001"],
-    "status": "pending",
-    "findings": "",
-    "error": ""
-  }
-}
-```
-
----
-
-### Multi-Sprint Pipeline
-
-Sprint 1: DESIGN-001 -> DEV-001 -> DEV-002(incremental) -> VERIFY-001 -> DEV-fix -> REVIEW-001
-
-Create Sprint 1 tasks using sprint templates above, plus:
-
-**DEV-002** (developer, incremental):
-```json
-{
-  "DEV-002": {
-    "title": "Incremental implementation",
-    "description": "PURPOSE: Incremental implementation | Success: Remaining tasks implemented\nTASK:\n  - Load remaining tasks from breakdown\n  - Implement incrementally\n  - Validate syntax\nCONTEXT:\n  - Session: <session-folder>\n  - Scope: <task-scope>\n  - Upstream artifacts: design/task-breakdown.json, code/dev-log.md\n  - Shared memory: <session>/.msg/meta.json\nEXPECTED: Modified source files + updated dev-log.md\nCONSTRAINTS: Incremental delivery | Follow existing patterns\n---\nInnerLoop: true",
-    "role": "developer",
-    "prefix": "DEV",
-    "deps": ["DEV-001"],
-    "status": "pending",
-    "findings": "",
-    "error": ""
-  }
-}
-```
-
-Subsequent sprints created dynamically after Sprint N completes.
-
-## Phase 4: Validation
-
-Verify task chain integrity:
-
-| Check | Method | Expected |
-|-------|--------|----------|
-| Task count correct | tasks.json count | patch: 2, sprint: 4, multi: 5+ |
-| Dependencies correct | Trace deps graph | Acyclic, correct ordering |
-| No circular dependencies | Trace full graph | Acyclic |
-| Structured descriptions | Each has PURPOSE/TASK/CONTEXT/EXPECTED | All present |
-
-If validation fails, fix the specific task and re-validate.

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

@@ -1,227 +0,0 @@
-# Command: Monitor
-
-Synchronous pipeline coordination using spawn_agent + wait_agent.
-
-## Constants
-
-- WORKER_AGENT: team_worker
-- MAX_GC_ROUNDS: 3
-
-## Handler Router
-
-| Source | Handler |
-|--------|---------|
-| "capability_gap" | handleAdapt |
-| "check" or "status" | handleCheck |
-| "resume" or "continue" | handleResume |
-| All tasks completed | handleComplete |
-| Default | handleSpawnNext |
-
-## Phase 2: Context Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Session state | tasks.json | Yes |
-| Trigger event | From Entry Router detection | Yes |
-| Meta state | <session>/.msg/meta.json | Yes |
-
-1. Load tasks.json for current state, pipeline_mode, gc_round, max_gc_rounds
-2. Read tasks from tasks.json to get current task statuses
-3. Identify trigger event type from Entry Router
-
-## Phase 3: Event Handlers
-
-### handleCallback
-
-Triggered when a worker completes (wait_agent returns).
-
-1. Determine role from completed task prefix:
-
-| Task Prefix | Role Detection |
-|-------------|---------------|
-| `DESIGN-*` | architect |
-| `DEV-*` | developer |
-| `VERIFY-*` | tester |
-| `REVIEW-*` | reviewer |
-
-2. Mark task as completed in tasks.json:
-
-```
-state.tasks[taskId].status = 'completed'
-```
-
-3. Record completion in session state and update metrics
-
-4. **Generator-Critic check** (when reviewer completes):
-   - If completed task is REVIEW-* AND pipeline is sprint or multi-sprint:
-   - Read review report for GC signal (critical_count, score)
-   - Read tasks.json for gc_round
-
-   | GC Signal | gc_round < max | Action |
-   |-----------|----------------|--------|
-   | review.critical_count > 0 OR review.score < 7 | Yes | Increment gc_round, create DEV-fix task in tasks.json with deps on this REVIEW, log `gc_loop_trigger` |
-   | review.critical_count > 0 OR review.score < 7 | No (>= max) | Force convergence, accept with warning, log to wisdom/issues.md |
-   | review.critical_count == 0 AND review.score >= 7 | - | Review passed, proceed to handleComplete check |
-
-   - Log team_msg with type "gc_loop_trigger" or "task_unblocked"
-
-5. Proceed to handleSpawnNext
-
-### handleSpawnNext
-
-Find and spawn the next ready tasks.
-
-1. Read tasks.json, find tasks where:
-   - Status is "pending"
-   - All deps tasks have status "completed"
-
-2. For each ready task, determine role from task prefix:
-
-| Task Prefix | Role | Inner Loop |
-|-------------|------|------------|
-| DESIGN-* | architect | false |
-| DEV-* | developer | true |
-| VERIFY-* | tester | false |
-| REVIEW-* | reviewer | false |
-
-3. 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., "DEV-001" — enables named targeting
-  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}` },
-
-    { type: "text", text: `Read role_spec file to load Phase 2-4 domain instructions.
-Execute built-in Phase 1 -> role-spec Phase 2-4 -> built-in Phase 5.` }
-  ]
-})
-
-// 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]
-  // Report timeout, STOP
-} 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]
-}
-```
-
-4. **Parallel spawn rules**:
-
-| Pipeline | Scenario | Spawn Behavior |
-|----------|----------|---------------|
-| Patch | DEV -> VERIFY | One worker at a time |
-| Sprint | VERIFY + REVIEW both unblocked | Spawn BOTH in parallel, wait_agent for both |
-| Sprint | Other stages | One worker at a time |
-| Multi-Sprint | VERIFY + DEV-fix both unblocked | Spawn BOTH in parallel, wait_agent for both |
-| Multi-Sprint | Other stages | One worker at a time |
-
-**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 design results to running developer
-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. STOP after processing -- wait for next event
-
-### handleCheck
-
-Output current pipeline status from tasks.json. Do NOT advance pipeline.
-
-```
-Pipeline Status (<pipeline-mode>):
-  [DONE]  DESIGN-001  (architect)   -> design/design-001.md
-  [DONE]  DEV-001     (developer)   -> code/dev-log.md
-  [RUN]   VERIFY-001  (tester)      -> verifying...
-  [RUN]   REVIEW-001  (reviewer)    -> reviewing...
-  [WAIT]  DEV-fix     (developer)   -> blocked by REVIEW-001
-
-GC Rounds: <gc_round>/<max_gc_rounds>
-Sprint: <sprint_id>
-Session: <session-id>
-```
-
-### 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
-```
-
-Resume pipeline after user pause or interruption.
-
-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. Proceed to handleSpawnNext
-
-### 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
-```
-
-Triggered when all pipeline tasks are completed.
-
-**Completion check by mode**:
-
-| Mode | Completion Condition |
-|------|---------------------|
-| patch | DEV-001 + VERIFY-001 completed |
-| sprint | DESIGN-001 + DEV-001 + VERIFY-001 + REVIEW-001 (+ any GC tasks) completed |
-| multi-sprint | All sprint tasks (+ any GC tasks) completed |
-
-1. Verify all tasks completed in tasks.json
-2. If any tasks not completed, return to handleSpawnNext
-3. **Multi-sprint check**: If multi-sprint AND more sprints planned:
-   - Record sprint metrics to .msg/meta.json sprint_history
-   - Evaluate downgrade eligibility (velocity >= expected, review avg >= 8)
-   - Pause for user confirmation before Sprint N+1
-4. If all completed, transition to coordinator Phase 5 (Report + Completion Action)
-
-## Phase 4: State Persistence
-
-After every handler execution:
-
-1. Update tasks.json with current state (gc_round, last event, active tasks)
-2. Update .msg/meta.json gc_round if changed
-3. Verify task list consistency
-4. STOP and wait for next event

package/.codex/skills/team-iterdev/roles/coordinator/role.md

@@ -1,193 +0,0 @@
-# Coordinator Role
-
-Orchestrate team-iterdev: analyze -> dispatch -> spawn -> monitor -> report.
-
-## 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
-- Use `team_worker` agent type for all worker spawns (NOT `general-purpose`)
-- Follow Command Execution Protocol for dispatch and monitor commands
-- Respect pipeline stage dependencies (deps)
-- Stop after spawning workers -- wait for results via wait_agent
-- Handle developer<->reviewer GC loop (max 3 rounds)
-- Maintain tasks.json for real-time progress
-- Execute completion action in Phase 5
-- **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 (designing, coding, testing, reviewing) -- workers handle this
-- Spawn workers without creating tasks first
-- Write source code directly
-- Force-advance pipeline past failed review/validation
-- Modify task outputs (workers own their deliverables)
-- Call CLI tools (ccw cli) — only workers use CLI
-
-## Command Execution Protocol
-
-When coordinator needs to execute a command:
-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) |
-| Pipeline complete | All tasks completed | -> handleComplete (monitor.md) |
-| Interrupted session | Active/paused session in .workflow/.team/IDS-* | -> Phase 0 |
-| New session | None of above | -> Phase 1 |
-
-For check/resume/complete: load @commands/monitor.md, execute handler, STOP.
-
-## Phase 0: Session Resume Check
-
-1. Scan `.workflow/.team/IDS-*/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 user task description from $ARGUMENTS
-2. Delegate to @commands/analyze.md
-3. Assess complexity for pipeline selection:
-
-| Signal | Weight |
-|--------|--------|
-| Changed files > 10 | +3 |
-| Changed files 3-10 | +2 |
-| Structural change (refactor, architect, restructure) | +3 |
-| Cross-cutting (multiple, across, cross) | +2 |
-| Simple fix (fix, bug, typo, patch) | -2 |
-
-| Score | Pipeline |
-|-------|----------|
-| >= 5 | multi-sprint |
-| 2-4 | sprint |
-| 0-1 | patch |
-
-4. Ask for missing parameters via request_user_input (mode selection)
-5. Record requirement with scope, pipeline mode
-6. CRITICAL: Always proceed to Phase 2, never skip team workflow
-
-## Phase 2: Session & Team Setup
-
-1. Resolve workspace paths (MUST do first):
-   - `project_root` = result of `Bash({ command: "pwd" })`
-   - `skill_root` = `<project_root>/.codex/skills/team-iterdev`
-2. Generate session ID: `IDS-<slug>-<YYYY-MM-DD>`
-3. Create session folder structure:
-```
-mkdir -p .workflow/.team/<session-id>/{design,code,verify,review,wisdom}
-```
-4. Read specs/pipelines.md -> select pipeline based on complexity
-5. Initialize wisdom directory (learnings.md, decisions.md, conventions.md, issues.md)
-6. Write initial tasks.json:
-   ```json
-   {
-     "session_id": "<id>",
-     "pipeline_mode": "<patch|sprint|multi-sprint>",
-     "requirement": "<original requirement>",
-     "created_at": "<ISO timestamp>",
-     "gc_round": 0,
-     "max_gc_rounds": 3,
-     "active_agents": {},
-     "tasks": {}
-   }
-   ```
-7. Initialize meta.json with pipeline metadata:
-```typescript
-mcp__ccw-tools__team_msg({
-  operation: "log", session_id: "<id>", from: "coordinator",
-  type: "state_update", summary: "Session initialized",
-  data: {
-    pipeline_mode: "<patch|sprint|multi-sprint>",
-    pipeline_stages: ["architect", "developer", "tester", "reviewer"],
-    roles: ["coordinator", "architect", "developer", "tester", "reviewer"]
-  }
-})
-```
-
-## Phase 3: Task Chain Creation
-
-Delegate to @commands/dispatch.md:
-1. Read specs/pipelines.md for selected pipeline task registry
-2. Add task entries to tasks.json `tasks` object with deps
-3. Update tasks.json metadata
-
-## Phase 4: Spawn-and-Wait
-
-Delegate to @commands/monitor.md#handleSpawnNext:
-1. Find ready tasks (pending + all 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. Load session state -> count completed tasks, calculate duration
-2. Record sprint learning to .msg/meta.json sprint_history
-3. List deliverables:
-
-| Deliverable | Path |
-|-------------|------|
-| Design Document | <session>/design/design-001.md |
-| Task Breakdown | <session>/design/task-breakdown.json |
-| Dev Log | <session>/code/dev-log.md |
-| Verification Results | <session>/verify/verify-001.json |
-| Review Report | <session>/review/review-001.md |
-
-4. Execute completion action per session.completion_action:
-   - interactive -> request_user_input (Archive/Keep/Export)
-   - auto_archive -> Archive & Clean (status=completed)
-   - auto_keep -> Keep Active (status=paused)
-
-## 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 too vague | request_user_input for clarification |
-| Session corruption | Attempt recovery, fallback to manual |
-| Worker crash | Reset task to pending, respawn |
-| GC loop exceeds 3 rounds | Accept with warning, record in shared memory |
-| Sprint velocity drops below 50% | Alert user, suggest scope reduction |
-| Task ledger corrupted | Rebuild from tasks.json state |