claude-code-workflow 7.2.15 → 7.2.16

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

@@ -0,0 +1,64 @@
+# Analyze Task
+
+Parse user issue description -> detect required capabilities -> assess complexity -> select pipeline mode.
+
+**CONSTRAINT**: Text-level analysis only. NO source code reading, NO codebase exploration.
+
+## Signal Detection
+
+| Keywords | Capability | Prefix |
+|----------|------------|--------|
+| explore, analyze, context, impact, understand | explorer | EXPLORE |
+| plan, solve, design, solution, approach | planner | SOLVE |
+| review, audit, validate, feasibility | reviewer | AUDIT |
+| marshal, integrate, queue, conflict, order | integrator | MARSHAL |
+| build, implement, execute, code, develop | implementer | BUILD |
+
+## Dependency Graph
+
+Natural ordering tiers:
+- Tier 0: explorer (context analysis -- no dependencies)
+- Tier 1: planner (requires explorer output)
+- Tier 2: reviewer (requires planner output, full/batch modes only)
+- Tier 3: integrator (requires reviewer or planner output)
+- Tier 4: implementer (requires integrator output)
+
+## Complexity Scoring
+
+| Factor | Points |
+|--------|--------|
+| Issue count > 2 | +3 |
+| Issue count > 4 | +2 more |
+| Any high-priority issue (priority >= 4) | +2 |
+| Multiple issue types / cross-cutting | +2 |
+| Simple / single issue | -2 |
+
+Results:
+- 0-2: Low -> quick (4 tasks: EXPLORE -> SOLVE -> MARSHAL -> BUILD)
+- 3-4: Medium -> full (5 tasks: EXPLORE -> SOLVE -> AUDIT -> MARSHAL -> BUILD)
+- 5+: High -> batch (N+N+1+1+M tasks, parallel exploration and implementation)
+
+## Pipeline Selection
+
+| Complexity | Pipeline | Tasks |
+|------------|----------|-------|
+| Low | quick | EXPLORE -> SOLVE -> MARSHAL -> BUILD |
+| Medium | full | EXPLORE -> SOLVE -> AUDIT -> MARSHAL -> BUILD |
+| High | batch | EXPLORE-001..N (parallel) -> SOLVE-001..N -> AUDIT -> MARSHAL -> BUILD-001..M (parallel) |
+
+## Output
+
+Write <session>/task-analysis.json:
+```json
+{
+  "task_description": "<original>",
+  "pipeline_type": "<quick|full|batch>",
+  "issue_ids": ["<id1>", "<id2>"],
+  "capabilities": [{ "name": "<cap>", "prefix": "<PREFIX>", "keywords": ["..."] }],
+  "dependency_graph": { "<TASK-ID>": { "role": "<role>", "blockedBy": ["..."], "priority": "P0|P1|P2" } },
+  "roles": [{ "name": "<role>", "prefix": "<PREFIX>", "inner_loop": false }],
+  "complexity": { "score": 0, "level": "Low|Medium|High" },
+  "parallel_explorers": 1,
+  "parallel_builders": 1
+}
+```

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

@@ -0,0 +1,273 @@
+# Dispatch
+
+Create the issue resolution task chain with correct dependencies and structured task descriptions based on selected pipeline mode.
+
+## Context Loading
+
+| Input | Source | Required |
+|-------|--------|----------|
+| Requirement | From coordinator Phase 1 | Yes |
+| Session folder | From coordinator Phase 2 | Yes |
+| Pipeline mode | From session.json mode | Yes |
+| Issue IDs | From session.json issue_ids | Yes |
+| Execution method | From session.json execution_method | Yes |
+| Code review | From session.json code_review | No |
+
+1. Load requirement, pipeline mode, issue IDs, and execution method from session.json
+2. Determine task chain from pipeline mode
+
+## Task Description Template
+
+Every task is built as a JSON entry in the tasks array:
+
+```json
+{
+  "id": "<TASK-ID>",
+  "title": "<TASK-ID>",
+  "description": "PURPOSE: <what this task achieves> | Success: <completion criteria>\nTASK:\n  - <step 1>\n  - <step 2>\n  - <step 3>\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <issue-id-list>\n  - Upstream artifacts: <artifact-list>\nEXPECTED: <deliverable path> + <quality criteria>\nCONSTRAINTS: <scope limits>\n---\nInnerLoop: false\nexecution_method: <method>\ncode_review: <setting>",
+  "status": "pending",
+  "role": "<role>",
+  "prefix": "<PREFIX>",
+  "deps": ["<dependency-list>"],
+  "findings": "",
+  "error": ""
+}
+```
+
+## Pipeline Router
+
+| Mode | Action |
+|------|--------|
+| quick | Create 4 tasks (EXPLORE -> SOLVE -> MARSHAL -> BUILD) |
+| full | Create 5 tasks (EXPLORE -> SOLVE -> AUDIT -> MARSHAL -> BUILD) |
+| batch | Create N+N+1+1+M tasks (EXPLORE-001..N -> SOLVE-001..N -> AUDIT-001 -> MARSHAL-001 -> BUILD-001..M) |
+
+---
+
+### Quick Pipeline
+
+Build tasks array and write to tasks.json:
+
+**EXPLORE-001** (explorer):
+```json
+{
+  "id": "EXPLORE-001",
+  "title": "EXPLORE-001",
+  "description": "PURPOSE: Analyze issue context and map codebase impact | Success: Context report with relevant files and dependencies\nTASK:\n  - Load issue details via ccw issue status\n  - Explore codebase for relevant files and patterns\n  - Assess complexity and impact scope\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <issue-id-list>\nEXPECTED: <session>/explorations/context-<issueId>.json with relevant files, dependencies, and impact assessment\nCONSTRAINTS: Exploration and analysis only, no solution design\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "explorer",
+  "prefix": "EXPLORE",
+  "deps": [],
+  "findings": "",
+  "error": ""
+}
+```
+
+**SOLVE-001** (planner):
+```json
+{
+  "id": "SOLVE-001",
+  "title": "SOLVE-001",
+  "description": "PURPOSE: Design solution and decompose into implementation tasks | Success: Bound solution with task decomposition\nTASK:\n  - Load explorer context report\n  - Generate solution plan via CLI\n  - Bind solution to issue\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <issue-id-list>\n  - Upstream artifacts: explorations/context-<issueId>.json\nEXPECTED: <session>/solutions/solution-<issueId>.json with solution plan and task list\nCONSTRAINTS: Solution design only, no code implementation\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "planner",
+  "prefix": "SOLVE",
+  "deps": ["EXPLORE-001"],
+  "findings": "",
+  "error": ""
+}
+```
+
+**MARSHAL-001** (integrator):
+```json
+{
+  "id": "MARSHAL-001",
+  "title": "MARSHAL-001",
+  "description": "PURPOSE: Form execution queue with conflict detection and ordering | Success: Execution queue file with resolved conflicts\nTASK:\n  - Verify all issues have bound solutions\n  - Detect file conflicts between solutions\n  - Produce ordered execution queue with DAG-based parallel groups\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <issue-id-list>\n  - Upstream artifacts: solutions/solution-<issueId>.json\nEXPECTED: .workflow/issues/queue/execution-queue.json with queue, conflicts, parallel groups\nCONSTRAINTS: Queue formation only, no implementation\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "integrator",
+  "prefix": "MARSHAL",
+  "deps": ["SOLVE-001"],
+  "findings": "",
+  "error": ""
+}
+```
+
+**BUILD-001** (implementer):
+```json
+{
+  "id": "BUILD-001",
+  "title": "BUILD-001",
+  "description": "PURPOSE: Implement solution plan and verify with tests | Success: Code changes committed, tests pass\nTASK:\n  - Load bound solution and explorer context\n  - Route to execution backend (Auto/Codex/Gemini)\n  - Run tests and verify implementation\n  - Commit changes\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <issue-id-list>\n  - Upstream artifacts: explorations/context-<issueId>.json, solutions/solution-<issueId>.json, queue/execution-queue.json\nEXPECTED: <session>/builds/ with implementation results, tests passing\nCONSTRAINTS: Follow solution plan, no scope creep\n---\nInnerLoop: false\nexecution_method: <execution_method>\ncode_review: <code_review>",
+  "status": "pending",
+  "role": "implementer",
+  "prefix": "BUILD",
+  "deps": ["MARSHAL-001"],
+  "findings": "",
+  "error": ""
+}
+```
+
+---
+
+### Full Pipeline
+
+Creates 5 tasks. EXPLORE-001 and SOLVE-001 same as Quick, then AUDIT gate before MARSHAL and BUILD.
+
+**AUDIT-001** (reviewer):
+```json
+{
+  "id": "AUDIT-001",
+  "title": "AUDIT-001",
+  "description": "PURPOSE: Review solution for technical feasibility, risk, and completeness | Success: Clear verdict (approved/concerns/rejected) with scores\nTASK:\n  - Load explorer context and bound solution\n  - Score across 3 dimensions: technical feasibility (40%), risk (30%), completeness (30%)\n  - Produce verdict: approved (>=80), concerns (60-79), rejected (<60)\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <issue-id-list>\n  - Upstream artifacts: explorations/context-<issueId>.json, solutions/solution-<issueId>.json\nEXPECTED: <session>/audits/audit-report.json with per-issue scores and overall verdict\nCONSTRAINTS: Review only, do not modify solutions\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "reviewer",
+  "prefix": "AUDIT",
+  "deps": ["SOLVE-001"],
+  "findings": "",
+  "error": ""
+}
+```
+
+**MARSHAL-001**: Same as Quick, but `deps: ["AUDIT-001"]`.
+
+**BUILD-001**: Same as Quick, `deps: ["MARSHAL-001"]`.
+
+---
+
+### Batch Pipeline
+
+Creates tasks in parallel batches. Issue count = N, BUILD tasks = M (from queue parallel groups).
+
+**EXPLORE-001..N** (explorer, parallel):
+
+For each issue in issue_ids (up to 5), create an EXPLORE task with distinct role:
+
+| Issue Count | Role Assignment |
+|-------------|-----------------|
+| N = 1 | role: "explorer" |
+| N > 1 | role: "explorer-1", "explorer-2", ..., "explorer-N" (max 5) |
+
+```json
+{
+  "id": "EXPLORE-<NNN>",
+  "title": "EXPLORE-<NNN>",
+  "description": "PURPOSE: Analyze issue <issueId> context and map codebase impact | Success: Context report for <issueId>\nTASK:\n  - Load issue details for <issueId>\n  - Explore codebase for relevant files\n  - Assess complexity and impact scope\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <issueId>\nEXPECTED: <session>/explorations/context-<issueId>.json\nCONSTRAINTS: Single issue scope, exploration only\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "explorer-<N>",
+  "prefix": "EXPLORE",
+  "deps": [],
+  "findings": "",
+  "error": ""
+}
+```
+
+**SOLVE-001..N** (planner, sequential after all EXPLORE):
+
+```json
+{
+  "id": "SOLVE-<NNN>",
+  "title": "SOLVE-<NNN>",
+  "description": "PURPOSE: Design solution for <issueId> | Success: Bound solution with tasks\nTASK:\n  - Load explorer context for <issueId>\n  - Generate solution plan\n  - Bind solution\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <issueId>\n  - Upstream artifacts: explorations/context-<issueId>.json\nEXPECTED: <session>/solutions/solution-<issueId>.json\nCONSTRAINTS: Solution design only\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "planner",
+  "prefix": "SOLVE",
+  "deps": ["EXPLORE-001", "...", "EXPLORE-<N>"],
+  "findings": "",
+  "error": ""
+}
+```
+
+**AUDIT-001** (reviewer, batch review):
+```json
+{
+  "id": "AUDIT-001",
+  "title": "AUDIT-001",
+  "description": "PURPOSE: Batch review all solutions | Success: Verdict for each solution\nTASK:\n  - Load all explorer contexts and bound solutions\n  - Score each solution across 3 dimensions\n  - Produce per-issue verdicts and overall verdict\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <all-issue-ids>\n  - Upstream artifacts: explorations/*.json, solutions/*.json\nEXPECTED: <session>/audits/audit-report.json with batch results\nCONSTRAINTS: Review only\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "reviewer",
+  "prefix": "AUDIT",
+  "deps": ["SOLVE-001", "...", "SOLVE-<N>"],
+  "findings": "",
+  "error": ""
+}
+```
+
+**MARSHAL-001** (integrator): `deps: ["AUDIT-001"]`.
+
+**BUILD-001..M** (implementer, DAG parallel):
+
+> Note: In Batch mode, BUILD task count M is not known at dispatch time (depends on MARSHAL queue output). Defer BUILD task creation to handleCallback when MARSHAL completes. Coordinator creates BUILD tasks dynamically after reading execution-queue.json.
+
+When M is known (deferred creation after MARSHAL), assign distinct roles:
+
+| Build Count | Role Assignment |
+|-------------|-----------------|
+| M <= 2 | role: "implementer" |
+| M > 2 | role: "implementer-1", ..., "implementer-M" (max 3) |
+
+```json
+{
+  "id": "BUILD-<NNN>",
+  "title": "BUILD-<NNN>",
+  "description": "PURPOSE: Implement solution for <issueId> | Success: Code committed, tests pass\nTASK:\n  - Load bound solution and explorer context\n  - Execute implementation via <execution_method>\n  - Run tests, commit\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <issueId>\n  - Upstream artifacts: explorations/context-<issueId>.json, solutions/solution-<issueId>.json, queue/execution-queue.json\nEXPECTED: <session>/builds/ with results\nCONSTRAINTS: Follow solution plan\n---\nInnerLoop: false\nexecution_method: <execution_method>\ncode_review: <code_review>",
+  "status": "pending",
+  "role": "implementer-<M>",
+  "prefix": "BUILD",
+  "deps": ["MARSHAL-001"],
+  "findings": "",
+  "error": ""
+}
+```
+
+---
+
+### Review-Fix Cycle (Full/Batch modes)
+
+When AUDIT rejects a solution, coordinator creates fix tasks dynamically in handleCallback -- NOT at dispatch time.
+
+**SOLVE-fix-001** (planner, revision) -- added to tasks.json dynamically:
+```json
+{
+  "id": "SOLVE-fix-001",
+  "title": "SOLVE-fix-001",
+  "description": "PURPOSE: Revise solution addressing reviewer feedback (fix cycle <round>) | Success: Revised solution addressing rejection reasons\nTASK:\n  - Read reviewer feedback from audit report\n  - Design alternative approach addressing concerns\n  - Re-bind revised solution\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <rejected-issue-ids>\n  - Upstream artifacts: audits/audit-report.json\n  - Reviewer feedback: <rejection-reasons>\nEXPECTED: <session>/solutions/solution-<issueId>.json (revised)\nCONSTRAINTS: Address reviewer concerns specifically\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "planner",
+  "prefix": "SOLVE",
+  "deps": ["AUDIT-001"],
+  "findings": "",
+  "error": ""
+}
+```
+
+**AUDIT-002** (reviewer, re-review) -- added to tasks.json dynamically:
+```json
+{
+  "id": "AUDIT-002",
+  "title": "AUDIT-002",
+  "description": "PURPOSE: Re-review revised solution (fix cycle <round>) | Success: Verdict on revised solution\nTASK:\n  - Load revised solution\n  - Re-evaluate previously rejected dimensions\n  - Produce updated verdict\nCONTEXT:\n  - Session: <session-folder>\n  - Issue IDs: <rejected-issue-ids>\n  - Upstream artifacts: solutions/solution-<issueId>.json (revised), audits/audit-report.json\nEXPECTED: <session>/audits/audit-report.json (updated)\nCONSTRAINTS: Focus on previously rejected dimensions\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "reviewer",
+  "prefix": "AUDIT",
+  "deps": ["SOLVE-fix-001"],
+  "findings": "",
+  "error": ""
+}
+```
+
+## Validation
+
+1. Verify all tasks created by reading tasks.json
+2. Check dependency chain integrity:
+   - No circular dependencies
+   - All deps references exist
+   - First task(s) have empty deps (EXPLORE tasks)
+3. Log task count and pipeline mode
+4. Verify mode-specific constraints:
+
+| Mode | Constraint |
+|------|-----------|
+| quick | Exactly 4 tasks, no AUDIT |
+| full | Exactly 5 tasks, includes AUDIT |
+| batch | N EXPLORE + N SOLVE + 1 AUDIT + 1 MARSHAL + deferred BUILD |

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

@@ -0,0 +1,194 @@
+# Monitor Pipeline
+
+Event-driven pipeline coordination. Beat model: coordinator wake -> process -> spawn -> STOP.
+
+## Constants
+
+- SPAWN_MODE: spawn_agent
+- ONE_STEP_PER_INVOCATION: true
+- FAST_ADVANCE_AWARE: true
+- WORKER_AGENT: team_worker
+- MAX_FIX_CYCLES: 2
+
+## Handler Router
+
+| Source | Handler |
+|--------|---------|
+| Message contains [explorer], [planner], [reviewer], [integrator], [implementer] | handleCallback |
+| "consensus_blocked" | handleConsensus |
+| "capability_gap" | handleAdapt |
+| "check" or "status" | handleCheck |
+| "resume" or "continue" | handleResume |
+| All tasks completed | handleComplete |
+| Default | handleSpawnNext |
+
+## handleCallback
+
+Worker completed. Process and advance.
+
+1. Parse message to identify role and task ID:
+
+| Message Pattern | Role Detection |
+|----------------|---------------|
+| `[explorer]` or task ID `EXPLORE-*` | explorer |
+| `[planner]` or task ID `SOLVE-*` | planner |
+| `[reviewer]` or task ID `AUDIT-*` | reviewer |
+| `[integrator]` or task ID `MARSHAL-*` | integrator |
+| `[implementer]` or task ID `BUILD-*` | implementer |
+
+2. Mark task as completed: Read tasks.json, update matching entry status to "completed", write back
+3. Record completion in session state
+
+4. **Review gate check** (when reviewer completes):
+   - If completed task is AUDIT-* AND pipeline is full or batch:
+   - Read audit report from `<session>/audits/audit-report.json`
+   - Read .msg/meta.json for fix_cycles
+
+   | Verdict | fix_cycles < max | Action |
+   |---------|-----------------|--------|
+   | rejected | Yes | Increment fix_cycles, create SOLVE-fix + AUDIT re-review tasks (add to tasks.json per dispatch.md Review-Fix Cycle), proceed to handleSpawnNext |
+   | rejected | No (>= max) | Force proceed -- log warning, unblock MARSHAL |
+   | concerns | - | Log concerns, proceed to MARSHAL (non-blocking) |
+   | approved | - | Proceed to MARSHAL via handleSpawnNext |
+
+   - Log team_msg with type "review_result" or "fix_required"
+   - If force proceeding past rejection, mark skipped fix tasks as completed (skip)
+
+5. **Deferred BUILD task creation** (when integrator completes):
+   - If completed task is MARSHAL-* AND pipeline is batch:
+   - Read execution queue from `.workflow/issues/queue/execution-queue.json`
+   - Parse parallel_groups to determine BUILD task count M
+   - Create BUILD-001..M tasks dynamically (add to tasks.json per dispatch.md Batch Pipeline BUILD section)
+   - Proceed to handleSpawnNext
+
+6. Close completed agent: `close_agent({ id: <agentId> })`
+7. Proceed to handleSpawnNext
+
+## handleCheck
+
+Read-only status report, then STOP.
+
+```
+[coordinator] Pipeline Status (<pipeline-mode>)
+[coordinator] Progress: <done>/<total> (<pct>%)
+[coordinator] Active: <workers with elapsed time>
+[coordinator] Ready: <pending tasks with resolved deps>
+[coordinator] Fix Cycles: <fix_cycles>/<max_fix_cycles>
+[coordinator] Commands: 'resume' to advance | 'check' to refresh
+```
+
+## handleResume
+
+1. Audit task list: Tasks stuck in "in_progress" -> reset to "pending"
+2. Proceed to handleSpawnNext
+
+## handleSpawnNext
+
+Find ready tasks, spawn workers, STOP.
+
+1. Collect: completedSubjects, inProgressSubjects, readySubjects
+2. No ready + work in progress -> report waiting, STOP
+3. No ready + nothing in progress -> handleComplete
+4. Has ready -> for each:
+   a. Update tasks.json entry status -> "in_progress"
+   b. team_msg log -> task_unblocked
+   c. Spawn team_worker:
+      ```
+      const agentId = spawn_agent({
+        agent_type: "team_worker",
+        items: [{ type: "text", text: `## Role Assignment
+      role: <role>
+      role_spec: ~  or <project>/.codex/skills/team-issue/roles/<role>/role.md
+      session: <session-folder>
+      session_id: <session-id>
+      team_name: issue
+      requirement: <task-description>
+      inner_loop: false
+
+      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).` }]
+      })
+      ```
+   d. Collect results: `wait_agent({ ids: [agentId], timeout_ms: 900000 })`
+   e. Read discoveries from output files
+   f. Update tasks.json with results
+   g. Close agent: `close_agent({ id: agentId })`
+
+5. Parallel spawn rules:
+
+| Pipeline | Scenario | Spawn Behavior |
+|----------|----------|---------------|
+| Quick | All stages | One worker at a time |
+| Full | All stages | One worker at a time |
+| Batch | EXPLORE-001..N unblocked | Spawn ALL N explorer workers in parallel (max 5) |
+| Batch | BUILD-001..M unblocked | Spawn ALL M implementer workers in parallel (max 3) |
+| Batch | Other stages | One worker at a time |
+
+**Parallel spawn** (Batch mode with multiple ready tasks for same role):
+```
+const agentIds = []
+for (const task of readyTasks) {
+  agentIds.push(spawn_agent({
+    agent_type: "team_worker",
+    items: [{ type: "text", text: `## Role Assignment
+role: <role>
+role_spec: ~  or <project>/.codex/skills/team-issue/roles/<role>/role.md
+session: <session-folder>
+session_id: <session-id>
+team_name: issue
+requirement: <task-description>
+agent_name: <role>-<N>
+inner_loop: false
+
+Read role_spec file to load Phase 2-4 domain instructions.
+Execute built-in Phase 1 (task discovery, owner=<role>-<N>) -> role Phase 2-4 -> built-in Phase 5 (report).` }]
+  }))
+}
+const results = wait_agent({ ids: agentIds, timeout_ms: 900000 })
+// Process results, close agents
+for (const id of agentIds) { close_agent({ id }) }
+```
+
+6. Update session, output summary, STOP
+
+## handleComplete
+
+Pipeline done. Generate report and completion action.
+
+Completion check by mode:
+| Mode | Completion Condition |
+|------|---------------------|
+| quick | All 4 tasks completed |
+| full | All 5 tasks (+ any fix cycle tasks) completed |
+| batch | All N EXPLORE + N SOLVE + 1 AUDIT + 1 MARSHAL + M BUILD (+ any fix cycle tasks) completed |
+
+1. Verify all tasks completed via reading tasks.json
+2. If any tasks not completed, return to handleSpawnNext
+3. If all completed -> transition to coordinator Phase 5
+
+## handleConsensus
+
+Handle consensus_blocked signals.
+
+| Severity | Action |
+|----------|--------|
+| HIGH | Pause pipeline, notify user with findings summary |
+| MEDIUM | Log finding, attempt to continue |
+| LOW | Log finding, continue pipeline |
+
+## handleAdapt
+
+Capability gap reported mid-pipeline.
+
+1. Parse gap description
+2. Check if existing role covers it -> redirect
+3. Role count < 6 -> generate dynamic role-spec in <session>/role-specs/
+4. Create new task (add to tasks.json), spawn worker
+5. Role count >= 6 -> merge or pause
+
+## Fast-Advance Reconciliation
+
+On every coordinator wake:
+1. Read team_msg entries with type="fast_advance"
+2. Sync active_workers with spawned successors
+3. No duplicate spawns