claude-code-workflow 7.2.15 → 7.2.16

package/.codex/skills/team-brainstorm/roles/challenger/role.md

@@ -0,0 +1,61 @@
+---
+role: challenger
+prefix: CHALLENGE
+inner_loop: false
+message_types: [state_update]
+---
+
+# Challenger
+
+Devil's advocate role. Assumption challenging, feasibility questioning, risk identification. Acts as the Critic in the Generator-Critic loop.
+
+## Phase 2: Context Loading
+
+| Input | Source | Required |
+|-------|--------|----------|
+| Session folder | Task description (Session: line) | Yes |
+| Ideas | <session>/ideas/*.md files | Yes |
+| Previous critiques | <session>/.msg/meta.json critique_insights | No |
+
+1. Extract session path from task description (match "Session: <path>")
+2. Glob idea files from <session>/ideas/
+3. Read all idea files for analysis
+4. Read .msg/meta.json critique_insights to avoid repeating past challenges
+
+## Phase 3: Critical Analysis
+
+**Challenge Dimensions** (apply to each idea):
+
+| Dimension | Focus |
+|-----------|-------|
+| Assumption Validity | Does the core assumption hold? Counter-examples? |
+| Feasibility | Technical/resource/time feasibility? |
+| Risk Assessment | Worst case scenario? Hidden risks? |
+| Competitive Analysis | Better alternatives already exist? |
+
+**Severity Classification**:
+
+| Severity | Criteria |
+|----------|----------|
+| CRITICAL | Fundamental issue, idea may need replacement |
+| HIGH | Significant flaw, requires revision |
+| MEDIUM | Notable weakness, needs consideration |
+| LOW | Minor concern, does not invalidate the idea |
+
+**Generator-Critic Signal**:
+
+| Condition | Signal |
+|-----------|--------|
+| Any CRITICAL or HIGH severity | REVISION_NEEDED |
+| All MEDIUM or lower | CONVERGED |
+
+**Output**: Write to `<session>/critiques/critique-<num>.md`
+- Sections: Ideas Reviewed, Per-idea challenges with severity, Summary table with counts, GC Signal
+
+## Phase 4: Severity Summary
+
+1. Count challenges by severity level
+2. Determine signal: REVISION_NEEDED if critical+high > 0, else CONVERGED
+3. Update shared state:
+   - Append challenges to .msg/meta.json critique_insights
+   - Each entry: idea, severity, key_challenge, round

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

@@ -0,0 +1,58 @@
+# Analyze Task
+
+Parse user topic -> detect brainstorming capabilities -> assess complexity -> select pipeline.
+
+**CONSTRAINT**: Text-level analysis only. NO source code reading, NO codebase exploration.
+
+## Signal Detection
+
+| Keywords | Capability | Prefix |
+|----------|------------|--------|
+| generate, create, brainstorm, ideas, explore | ideator | IDEA |
+| challenge, critique, argue, devil, risk | challenger | CHALLENGE |
+| synthesize, integrate, combine, merge, themes | synthesizer | SYNTH |
+| evaluate, score, rank, prioritize, select | evaluator | EVAL |
+
+## Dependency Graph
+
+Natural ordering tiers:
+- Tier 0: ideator (divergent generation -- no dependencies)
+- Tier 1: challenger (requires ideator output)
+- Tier 2: ideator-revision (requires challenger output, GC loop)
+- Tier 3: synthesizer (requires last challenger output)
+- Tier 4: evaluator (requires synthesizer output, deep/full only)
+
+## Complexity Scoring
+
+| Factor | Points |
+|--------|--------|
+| Per capability needed | +1 |
+| Strategic/systemic topic | +3 |
+| Multi-dimensional analysis | +2 |
+| Innovation-focused request | +2 |
+| Simple/basic topic | -2 |
+
+Results: 0-1 Low (quick), 2-3 Medium (deep), 4+ High (full)
+
+## Pipeline Selection
+
+| Complexity | Pipeline | Tasks |
+|------------|----------|-------|
+| Low | quick | IDEA -> CHALLENGE -> SYNTH |
+| Medium | deep | IDEA -> CHALLENGE -> IDEA-fix -> CHALLENGE-2 -> SYNTH -> EVAL |
+| High | full | 3x IDEA (parallel) -> CHALLENGE -> IDEA-fix -> SYNTH -> EVAL |
+
+## Output
+
+Write <session>/task-analysis.json:
+```json
+{
+  "task_description": "<original>",
+  "pipeline_type": "<quick|deep|full>",
+  "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" },
+  "angles": ["Technical", "Product", "Innovation", "Risk"]
+}
+```

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

@@ -0,0 +1,162 @@
+# Command: Dispatch
+
+Create the brainstorm task chain with correct dependencies and structured task descriptions based on selected pipeline mode.
+
+## Phase 2: Context Loading
+
+| Input | Source | Required |
+|-------|--------|----------|
+| User topic | From coordinator Phase 1 | Yes |
+| Session folder | From coordinator Phase 2 | Yes |
+| Pipeline mode | From session.json pipeline | Yes |
+| Angles | From session.json angles | Yes |
+
+1. Load topic, pipeline mode, and angles from session.json
+2. Determine task chain from pipeline mode
+
+## Phase 3: Task Chain Creation
+
+### 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  - Topic: <topic>\n  - Angles: <angle-list>\n  - Upstream artifacts: <artifact-list>\nEXPECTED: <deliverable path> + <quality criteria>\nCONSTRAINTS: <scope limits>\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "<role>",
+  "prefix": "<PREFIX>",
+  "deps": ["<dependency-list>"],
+  "findings": "",
+  "error": ""
+}
+```
+
+### Pipeline Router
+
+| Mode | Action |
+|------|--------|
+| quick | Create 3 tasks (IDEA -> CHALLENGE -> SYNTH) |
+| deep | Create 6 tasks (IDEA -> CHALLENGE -> IDEA-fix -> CHALLENGE-2 -> SYNTH -> EVAL) |
+| full | Create 7 tasks (3 parallel IDEAs -> CHALLENGE -> IDEA-fix -> SYNTH -> EVAL) |
+
+---
+
+### Quick Pipeline
+
+Build the tasks array and write to tasks.json:
+
+```json
+[
+  {
+    "id": "IDEA-001",
+    "title": "IDEA-001",
+    "description": "PURPOSE: Generate multi-angle ideas for brainstorm topic | Success: >= 6 unique ideas across all angles\nTASK:\n  - Read topic and angles from session context\n  - Generate 3+ ideas per angle with title, description, assumption, impact\n  - Self-review for coverage and uniqueness\nCONTEXT:\n  - Session: <session-folder>\n  - Topic: <topic>\n  - Angles: <angle-list>\nEXPECTED: <session>/ideas/idea-001.md with >= 6 ideas\nCONSTRAINTS: Divergent thinking only, no evaluation\n---\nInnerLoop: false",
+    "status": "pending",
+    "role": "ideator",
+    "prefix": "IDEA",
+    "deps": [],
+    "findings": "",
+    "error": ""
+  },
+  {
+    "id": "CHALLENGE-001",
+    "title": "CHALLENGE-001",
+    "description": "PURPOSE: Challenge assumptions and assess feasibility of generated ideas | Success: Each idea rated by severity\nTASK:\n  - Read all idea files from ideas/ directory\n  - Challenge each idea across 4 dimensions (assumption, feasibility, risk, competition)\n  - Assign severity (CRITICAL/HIGH/MEDIUM/LOW) per idea\n  - Determine GC signal (REVISION_NEEDED or CONVERGED)\nCONTEXT:\n  - Session: <session-folder>\n  - Upstream artifacts: ideas/idea-001.md\nEXPECTED: <session>/critiques/critique-001.md with severity table and GC signal\nCONSTRAINTS: Critical analysis only, do not generate alternative ideas\n---\nInnerLoop: false",
+    "status": "pending",
+    "role": "challenger",
+    "prefix": "CHALLENGE",
+    "deps": ["IDEA-001"],
+    "findings": "",
+    "error": ""
+  },
+  {
+    "id": "SYNTH-001",
+    "title": "SYNTH-001",
+    "description": "PURPOSE: Synthesize ideas and critiques into integrated proposals | Success: >= 1 consolidated proposal\nTASK:\n  - Read all ideas and critiques\n  - Extract themes, resolve conflicts, group complementary ideas\n  - Generate 1-3 integrated proposals with feasibility and innovation scores\nCONTEXT:\n  - Session: <session-folder>\n  - Upstream artifacts: ideas/*.md, critiques/*.md\nEXPECTED: <session>/synthesis/synthesis-001.md with proposals\nCONSTRAINTS: Integration and synthesis only, no new ideas\n---\nInnerLoop: false",
+    "status": "pending",
+    "role": "synthesizer",
+    "prefix": "SYNTH",
+    "deps": ["CHALLENGE-001"],
+    "findings": "",
+    "error": ""
+  }
+]
+```
+
+### Deep Pipeline
+
+Creates all 6 tasks. First 2 same as Quick, then add:
+
+**IDEA-002** (ideator, GC revision):
+```json
+{
+  "id": "IDEA-002",
+  "title": "IDEA-002",
+  "description": "PURPOSE: Revise ideas based on critique feedback (GC Round 1) | Success: HIGH/CRITICAL challenges addressed\nTASK:\n  - Read critique feedback from critiques/\n  - Revise challenged ideas, replace unsalvageable ones\n  - Retain unchallenged ideas intact\nCONTEXT:\n  - Session: <session-folder>\n  - Upstream artifacts: critiques/critique-001.md\nEXPECTED: <session>/ideas/idea-002.md with revised ideas\nCONSTRAINTS: Address critique only, focused revision\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "ideator",
+  "prefix": "IDEA",
+  "deps": ["CHALLENGE-001"],
+  "findings": "",
+  "error": ""
+}
+```
+
+**CHALLENGE-002** (challenger, round 2):
+```json
+{
+  "id": "CHALLENGE-002",
+  "title": "CHALLENGE-002",
+  "description": "PURPOSE: Validate revised ideas (GC Round 2) | Success: Severity assessment of revised ideas\nTASK:\n  - Read revised idea files\n  - Re-evaluate previously challenged ideas\n  - Assess new replacement ideas\nCONTEXT:\n  - Session: <session-folder>\n  - Upstream artifacts: ideas/idea-002.md\nEXPECTED: <session>/critiques/critique-002.md\nCONSTRAINTS: Focus on revised/new ideas\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "challenger",
+  "prefix": "CHALLENGE",
+  "deps": ["IDEA-002"],
+  "findings": "",
+  "error": ""
+}
+```
+
+**SYNTH-001** blocked by CHALLENGE-002. **EVAL-001** blocked by SYNTH-001:
+
+```json
+{
+  "id": "EVAL-001",
+  "title": "EVAL-001",
+  "description": "PURPOSE: Score and rank synthesized proposals | Success: Ranked list with weighted scores\nTASK:\n  - Read synthesis results\n  - Score each proposal across 4 dimensions (Feasibility 30%, Innovation 25%, Impact 25%, Cost 20%)\n  - Generate final ranking and recommendation\nCONTEXT:\n  - Session: <session-folder>\n  - Upstream artifacts: synthesis/synthesis-001.md\nEXPECTED: <session>/evaluation/evaluation-001.md with scoring matrix\nCONSTRAINTS: Evaluation only, no new proposals\n---\nInnerLoop: false",
+  "status": "pending",
+  "role": "evaluator",
+  "prefix": "EVAL",
+  "deps": ["SYNTH-001"],
+  "findings": "",
+  "error": ""
+}
+```
+
+### Full Pipeline
+
+Creates 7 tasks. Parallel ideators:
+
+| Task | Owner | Deps |
+|------|-------|------|
+| IDEA-001 | ideator-1 | (none) |
+| IDEA-002 | ideator-2 | (none) |
+| IDEA-003 | ideator-3 | (none) |
+| CHALLENGE-001 | challenger | IDEA-001, IDEA-002, IDEA-003 |
+| IDEA-004 | ideator | CHALLENGE-001 |
+| SYNTH-001 | synthesizer | IDEA-004 |
+| EVAL-001 | evaluator | SYNTH-001 |
+
+Each parallel IDEA task scoped to a specific angle from the angles list.
+
+## Phase 4: 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
+3. Log task count and pipeline mode

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

@@ -0,0 +1,171 @@
+# 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_GC_ROUNDS: 2
+
+## Handler Router
+
+| Source | Handler |
+|--------|---------|
+| Message contains [ideator], [challenger], [synthesizer], [evaluator] | 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 |
+|----------------|---------------|
+| `[ideator]` or task ID `IDEA-*` | ideator |
+| `[challenger]` or task ID `CHALLENGE-*` | challenger |
+| `[synthesizer]` or task ID `SYNTH-*` | synthesizer |
+| `[evaluator]` or task ID `EVAL-*` | evaluator |
+
+2. Mark task as completed: Read tasks.json, update matching entry status to "completed", write back
+3. Record completion in session state
+4. **Generator-Critic check** (when challenger completes):
+   - If completed task is CHALLENGE-* AND pipeline is deep or full:
+   - Read critique file for GC signal
+   - Read .msg/meta.json for gc_round
+
+   | GC Signal | gc_round < max | Action |
+   |-----------|----------------|--------|
+   | REVISION_NEEDED | Yes | Increment gc_round, unblock IDEA-fix task |
+   | REVISION_NEEDED | No (>= max) | Force convergence, unblock SYNTH |
+   | CONVERGED | - | Unblock SYNTH (skip remaining GC tasks) |
+
+   - Log team_msg with type "gc_loop_trigger" or "task_unblocked"
+   - If skipping GC tasks, mark them as completed (skip)
+
+5. Close completed agent: `close_agent({ id: <agentId> })`
+6. 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] GC Rounds: <gc_round>/<max_gc_rounds>
+[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-brainstorm/roles/<role>/role.md
+      session: <session-folder>
+      session_id: <session-id>
+      team_name: brainstorm
+      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 agent 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 | Single sequential | One worker at a time |
+| Deep | Sequential with GC | One worker at a time |
+| Full | IDEA-001/002/003 unblocked | Spawn ALL 3 ideator workers in parallel |
+| Full | Other stages | One worker at a time |
+
+**Parallel ideator spawn** (Full pipeline):
+```
+const agentIds = []
+for (const task of readyIdeatorTasks) {
+  agentIds.push(spawn_agent({
+    agent_type: "team_worker",
+    items: [{ type: "text", text: `...role: ideator-<N>...` }]
+  }))
+}
+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 3 tasks completed |
+| deep | All 6 tasks (+ any skipped GC tasks) completed |
+| full | All 7 tasks (+ any skipped GC 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 < 5 -> generate dynamic role-spec in <session>/role-specs/
+4. Create new task (add to tasks.json), spawn worker
+5. Role count >= 5 -> 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

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

@@ -0,0 +1,140 @@
+# Coordinator
+
+Orchestrate team-brainstorm: topic clarify -> dispatch -> spawn -> monitor -> report.
+
+## Identity
+- Name: coordinator | Tag: [coordinator]
+- Responsibility: Topic clarification -> Create team -> Dispatch tasks -> Monitor progress -> Report results
+
+## Boundaries
+
+### MUST
+- Use `team_worker` agent type for all worker spawns
+- Follow Command Execution Protocol for dispatch and monitor commands
+- Respect pipeline stage dependencies (deps)
+- Stop after spawning workers -- wait for results via wait_agent
+- Manage Generator-Critic loop count (max 2 rounds)
+- Execute completion action in Phase 5
+
+### MUST NOT
+- Generate ideas, challenge assumptions, synthesize, or evaluate -- workers handle this
+- Spawn workers without creating tasks first
+- Force-advance pipeline past GC loop decisions
+- Modify artifact files (ideas/*.md, critiques/*.md, etc.) -- delegate to workers
+- Skip GC severity check when critique arrives
+
+## Command Execution Protocol
+
+When coordinator needs to execute a specific phase:
+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 |
+|-----------|-----------|---------|
+| Worker result | Result from wait_agent contains [ideator], [challenger], [synthesizer], [evaluator] | -> handleCallback (monitor.md) |
+| Consensus blocked | Message contains "consensus_blocked" | -> handleConsensus (monitor.md) |
+| 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 completed | -> handleComplete (monitor.md) |
+| Interrupted session | Active session in .workflow/.team/BRS-* | -> Phase 0 |
+| New session | None of above | -> Phase 1 |
+
+For callback/check/resume/consensus/adapt/complete: load @commands/monitor.md, execute handler, STOP.
+
+## Phase 0: Session Resume Check
+
+1. Scan `.workflow/.team/BRS-*/session.json` for active/paused sessions
+2. No sessions -> Phase 1
+3. Single session -> reconcile (read tasks.json, reset in_progress->pending, rebuild team, kick first ready task)
+4. Multiple -> request_user_input for selection
+
+## Phase 1: Topic Clarification + Complexity Assessment
+
+TEXT-LEVEL ONLY. No source code reading.
+
+1. Parse topic from $ARGUMENTS
+2. Assess topic complexity:
+
+| Signal | Weight | Keywords |
+|--------|--------|----------|
+| Strategic/systemic | +3 | strategy, architecture, system, framework, paradigm |
+| Multi-dimensional | +2 | multiple, compare, tradeoff, versus, alternative |
+| Innovation-focused | +2 | innovative, creative, novel, breakthrough |
+| Simple/basic | -2 | simple, quick, straightforward, basic |
+
+| Score | Complexity | Pipeline Recommendation |
+|-------|------------|-------------------------|
+| >= 4 | High | full |
+| 2-3 | Medium | deep |
+| 0-1 | Low | quick |
+
+3. request_user_input for pipeline mode and divergence angles
+4. Store requirements: mode, scope, angles, constraints
+
+## Phase 2: Create Team + Initialize Session
+
+1. Resolve workspace paths (MUST do first):
+   - `project_root` = result of `Bash("pwd")`
+   - `skill_root` = `<project_root>/.codex/skills/team-brainstorm`
+2. Generate session ID: `BRS-<topic-slug>-<date>`
+3. Create session folder structure: ideas/, critiques/, synthesis/, evaluation/, wisdom/, .msg/
+4. Create session folder + initialize `tasks.json` (empty array)
+5. Write session.json with pipeline, angles, gc_round=0, max_gc_rounds=2
+6. Initialize meta.json via team_msg state_update:
+   ```
+   mcp__ccw-tools__team_msg({
+     operation: "log", session_id: "<id>", from: "coordinator",
+     type: "state_update", summary: "Session initialized",
+     data: { pipeline_mode: "<mode>", pipeline_stages: ["ideator","challenger","synthesizer","evaluator"], team_name: "brainstorm", topic: "<topic>", angles: [...], gc_round: 0 }
+   })
+   ```
+7. Write session.json
+
+## Phase 3: Create Task Chain
+
+Delegate to @commands/dispatch.md:
+1. Read pipeline mode and angles from session.json
+2. Build tasks array and write to tasks.json with correct deps
+3. Update session.json with task count
+
+## Phase 4: Spawn-and-Stop
+
+Delegate to @commands/monitor.md#handleSpawnNext:
+1. Find ready tasks (pending + deps resolved)
+2. Spawn team_worker agents (see SKILL.md Spawn Template)
+3. Output status summary
+4. STOP
+
+## Phase 5: Report + Completion Action
+
+1. Load session state -> count completed tasks, calculate duration
+2. List deliverables:
+
+| Deliverable | Path |
+|-------------|------|
+| Ideas | <session>/ideas/*.md |
+| Critiques | <session>/critiques/*.md |
+| Synthesis | <session>/synthesis/*.md |
+| Evaluation | <session>/evaluation/*.md (deep/full only) |
+
+3. Output pipeline summary: topic, pipeline mode, GC rounds, total ideas, key themes
+
+4. Execute completion action per session.completion_action:
+   - interactive -> request_user_input (Archive/Keep/Export)
+   - auto_archive -> Archive & Clean (status=completed, clean up session)
+   - auto_keep -> Keep Active (status=paused)
+
+## 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 exceeded | Force convergence to synthesizer |
+| No ideas generated | Coordinator prompts with seed questions |

package/.codex/skills/team-brainstorm/roles/evaluator/role.md

@@ -0,0 +1,56 @@
+---
+role: evaluator
+prefix: EVAL
+inner_loop: false
+message_types: [state_update]
+---
+
+# Evaluator
+
+Scoring, ranking, and final selection. Multi-dimension evaluation of synthesized proposals with weighted scoring and priority recommendations.
+
+## Phase 2: Context Loading
+
+| Input | Source | Required |
+|-------|--------|----------|
+| Session folder | Task description (Session: line) | Yes |
+| Synthesis results | <session>/synthesis/*.md files | Yes |
+| All ideas | <session>/ideas/*.md files | No (for context) |
+| All critiques | <session>/critiques/*.md files | No (for context) |
+
+1. Extract session path from task description (match "Session: <path>")
+2. Glob synthesis files from <session>/synthesis/
+3. Read all synthesis files for evaluation
+4. Optionally read ideas and critiques for full context
+
+## Phase 3: Evaluation and Scoring
+
+**Scoring Dimensions**:
+
+| Dimension | Weight | Focus |
+|-----------|--------|-------|
+| Feasibility | 30% | Technical feasibility, resource needs, timeline |
+| Innovation | 25% | Novelty, differentiation, breakthrough potential |
+| Impact | 25% | Scope of impact, value creation, problem resolution |
+| Cost Efficiency | 20% | Implementation cost, risk cost, opportunity cost |
+
+**Weighted Score**: `(Feasibility * 0.30) + (Innovation * 0.25) + (Impact * 0.25) + (Cost * 0.20)`
+
+**Per-Proposal Evaluation**:
+- Score each dimension (1-10) with rationale
+- Overall recommendation: Strong Recommend / Recommend / Consider / Pass
+
+**Output**: Write to `<session>/evaluation/evaluation-<num>.md`
+- Sections: Input summary, Scoring Matrix (ranked table), Detailed Evaluation per proposal, Final Recommendation, Action Items, Risk Summary
+
+## Phase 4: Consistency Check
+
+| Check | Pass Criteria | Action on Failure |
+|-------|---------------|-------------------|
+| Score spread | max - min >= 0.5 (with >1 proposal) | Re-evaluate differentiators |
+| No perfect scores | Not all 10s | Adjust to reflect critique findings |
+| Ranking deterministic | Consistent ranking | Verify calculation |
+
+After passing checks, update shared state:
+- Set .msg/meta.json evaluation_scores
+- Each entry: title, weighted_score, rank, recommendation