Team Brainstorm

Team Brainstorm

Orchestrate multi-agent brainstorming: generate ideas → challenge assumptions → synthesize → evaluate. Supports Quick, Deep, and Full pipelines with Generator-Critic loop.

Architecture

Skill(skill="team-brainstorm", args="topic description")
                    |
         SKILL.md (this file) = Router
                    |
     +--------------+--------------+
     |                             |
  no --role flag              --role <name>
     |                             |
  Coordinator                  Worker
  roles/coordinator/role.md    roles/<name>/role.md
     |
     +-- analyze → dispatch → spawn workers → STOP
                                    |
                    +-------+-------+-------+
                    v       v       v       v
                 [ideator][challenger][synthesizer][evaluator]

Role Registry

Role Router

Parse $ARGUMENTS:

• Has --role <name> → Read roles/<name>/role.md, execute Phase 2-4
• No --role → @roles/coordinator/role.md, execute entry router

Shared Constants

• Session prefix: BRS
• Session path: .workflow/.team/BRS-<slug>-<date>/
• CLI tools: ccw cli --mode analysis (read-only), ccw cli --mode write (modifications)
• Message bus: mcp__ccw-tools__team_msg(session_id=<session-id>, ...)

Worker Spawn Template

Coordinator spawns workers using this template:

Agent({
  subagent_type: "team-worker",
  description: "Spawn <role> worker",
  team_name: "brainstorm",
  name: "<role>",
  run_in_background: true,
  prompt: `## Role Assignment
role: <role>
role_spec: <skill_root>/roles/<role>/role.md
session: <session-folder>
session_id: <session-id>
team_name: brainstorm
requirement: <topic-description>
inner_loop: false

## Progress Milestones
session_id: <session-id>
Report progress via team_msg at natural phase boundaries (context loaded -> core work done -> verification).
Report blockers immediately via team_msg type="blocker".
Report completion via team_msg type="task_complete" after final SendMessage.

Read role_spec file (@<skill_root>/roles/<role>/role.md) to load Phase 2-4 domain instructions.
Execute built-in Phase 1 (task discovery) -> role Phase 2-4 -> built-in Phase 5 (report).`
})

Parallel ideator spawn (Full pipeline with N angles):

When Full pipeline has N parallel IDEA tasks, spawn N distinct team-worker agents named ideator-1, ideator-2, etc.

Agent({
  subagent_type: "team-worker",
  name: "ideator-<N>",
  team_name: "brainstorm",
  run_in_background: true,
  prompt: `## Role Assignment
role: ideator
role_spec: <skill_root>/roles/ideator/role.md
session: <session-folder>
session_id: <session-id>
team_name: brainstorm
requirement: <topic-description>
agent_name: ideator-<N>
inner_loop: false

## Progress Milestones
session_id: <session-id>
Report progress via team_msg at natural phase boundaries (context loaded -> core work done -> verification).
Report blockers immediately via team_msg type="blocker".
Report completion via team_msg type="task_complete" after final SendMessage.

Read role_spec file (@<skill_root>/roles/ideator/role.md) to load Phase 2-4 domain instructions.
Execute built-in Phase 1 (task discovery, owner=ideator-<N>) -> role Phase 2-4 -> built-in Phase 5 (report).`
})

User Commands

Session Directory

.workflow/.team/BRS-<slug>-<date>/
├── session.json                    # Session metadata + pipeline + gc_round
├── task-analysis.json              # Coordinator analyze output
├── .msg/
│   ├── messages.jsonl              # Message bus log
│   └── meta.json                   # Session state + cross-role state
├── wisdom/                         # Cross-task knowledge
│   ├── learnings.md
│   ├── decisions.md
│   ├── conventions.md
│   └── issues.md
├── ideas/                          # Ideator output
│   ├── idea-001.md
│   └── idea-002.md
├── critiques/                      # Challenger output
│   ├── critique-001.md
│   └── critique-002.md
├── synthesis/                      # Synthesizer output
│   └── synthesis-001.md
└── evaluation/                     # Evaluator output
    └── evaluation-001.md

Specs Reference

• specs/pipelines.md — Pipeline definitions and task registry

Error Handling

Challenger

Devil's advocate role. Assumption challenging, feasibility questioning, risk identification. Acts as the Critic in the Generator-Critic loop.

Phase 2: Context Loading

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):

Severity Classification:

Generator-Critic Signal:

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

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

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

Results: 0-1 Low (quick), 2-3 Medium (deep), 4+ High (full)

Pipeline Selection

Output

Write <session>/task-analysis.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"]
}

Command: Dispatch

Create the brainstorm task chain with correct dependencies and structured task descriptions based on selected pipeline mode.

Phase 2: Context Loading

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 description uses structured format:

TaskCreate({
  subject: "<TASK-ID>",
  description: "PURPOSE: <what this task achieves> | Success: <completion criteria>
TASK:
  - <step 1>
  - <step 2>
  - <step 3>
CONTEXT:
  - Session: <session-folder>
  - Topic: <topic>
  - Angles: <angle-list>
  - Upstream artifacts: <artifact-list>
EXPECTED: <deliverable path> + <quality criteria>
CONSTRAINTS: <scope limits>
---
InnerLoop: false"
})
TaskUpdate({ taskId: "<TASK-ID>", addBlockedBy: [<dependency-list>], owner: "<role>" })

Pipeline Router

---

Quick Pipeline

IDEA-001 (ideator):

TaskCreate({
  subject: "IDEA-001",
  description: "PURPOSE: Generate multi-angle ideas for brainstorm topic | Success: >= 6 unique ideas across all angles
TASK:
  - Read topic and angles from session context
  - Generate 3+ ideas per angle with title, description, assumption, impact
  - Self-review for coverage and uniqueness
CONTEXT:
  - Session: <session-folder>
  - Topic: <topic>
  - Angles: <angle-list>
EXPECTED: <session>/ideas/idea-001.md with >= 6 ideas
CONSTRAINTS: Divergent thinking only, no evaluation
---
InnerLoop: false"
})
TaskUpdate({ taskId: "IDEA-001", owner: "ideator" })

CHALLENGE-001 (challenger):

TaskCreate({
  subject: "CHALLENGE-001",
  description: "PURPOSE: Challenge assumptions and assess feasibility of generated ideas | Success: Each idea rated by severity
TASK:
  - Read all idea files from ideas/ directory
  - Challenge each idea across 4 dimensions (assumption, feasibility, risk, competition)
  - Assign severity (CRITICAL/HIGH/MEDIUM/LOW) per idea
  - Determine GC signal (REVISION_NEEDED or CONVERGED)
CONTEXT:
  - Session: <session-folder>
  - Upstream artifacts: ideas/idea-001.md
EXPECTED: <session>/critiques/critique-001.md with severity table and GC signal
CONSTRAINTS: Critical analysis only, do not generate alternative ideas
---
InnerLoop: false"
})
TaskUpdate({ taskId: "CHALLENGE-001", addBlockedBy: ["IDEA-001"], owner: "challenger" })

SYNTH-001 (synthesizer):

TaskCreate({
  subject: "SYNTH-001",
  description: "PURPOSE: Synthesize ideas and critiques into integrated proposals | Success: >= 1 consolidated proposal
TASK:
  - Read all ideas and critiques
  - Extract themes, resolve conflicts, group complementary ideas
  - Generate 1-3 integrated proposals with feasibility and innovation scores
CONTEXT:
  - Session: <session-folder>
  - Upstream artifacts: ideas/*.md, critiques/*.md
EXPECTED: <session>/synthesis/synthesis-001.md with proposals
CONSTRAINTS: Integration and synthesis only, no new ideas
---
InnerLoop: false"
})
TaskUpdate({ taskId: "SYNTH-001", addBlockedBy: ["CHALLENGE-001"], owner: "synthesizer" })

Deep Pipeline

Creates all 6 tasks. First 2 same as Quick, then:

IDEA-002 (ideator, GC revision):

TaskCreate({
  subject: "IDEA-002",
  description: "PURPOSE: Revise ideas based on critique feedback (GC Round 1) | Success: HIGH/CRITICAL challenges addressed
TASK:
  - Read critique feedback from critiques/
  - Revise challenged ideas, replace unsalvageable ones
  - Retain unchallenged ideas intact
CONTEXT:
  - Session: <session-folder>
  - Upstream artifacts: critiques/critique-001.md
EXPECTED: <session>/ideas/idea-002.md with revised ideas
CONSTRAINTS: Address critique only, focused revision
---
InnerLoop: false"
})
TaskUpdate({ taskId: "IDEA-002", addBlockedBy: ["CHALLENGE-001"], owner: "ideator" })

CHALLENGE-002 (challenger, round 2):

TaskCreate({
  subject: "CHALLENGE-002",
  description: "PURPOSE: Validate revised ideas (GC Round 2) | Success: Severity assessment of revised ideas
TASK:
  - Read revised idea files
  - Re-evaluate previously challenged ideas
  - Assess new replacement ideas
CONTEXT:
  - Session: <session-folder>
  - Upstream artifacts: ideas/idea-002.md
EXPECTED: <session>/critiques/critique-002.md
CONSTRAINTS: Focus on revised/new ideas
---
InnerLoop: false"
})
TaskUpdate({ taskId: "CHALLENGE-002", addBlockedBy: ["IDEA-002"], owner: "challenger" })

SYNTH-001 blocked by CHALLENGE-002. EVAL-001 blocked by SYNTH-001:

TaskCreate({
  subject: "EVAL-001",
  description: "PURPOSE: Score and rank synthesized proposals | Success: Ranked list with weighted scores
TASK:
  - Read synthesis results
  - Score each proposal across 4 dimensions (Feasibility 30%, Innovation 25%, Impact 25%, Cost 20%)
  - Generate final ranking and recommendation
CONTEXT:
  - Session: <session-folder>
  - Upstream artifacts: synthesis/synthesis-001.md
EXPECTED: <session>/evaluation/evaluation-001.md with scoring matrix
CONSTRAINTS: Evaluation only, no new proposals
---
InnerLoop: false"
})
TaskUpdate({ taskId: "EVAL-001", addBlockedBy: ["SYNTH-001"], owner: "evaluator" })

Full Pipeline

Creates 7 tasks. Parallel ideators:

Each parallel IDEA task scoped to a specific angle from the angles list.

Phase 4: Validation

1. Verify all tasks created with TaskList() 2. Check dependency chain integrity:

• No circular dependencies
• All blockedBy references exist
• First task(s) have empty blockedBy

3. Log task count and pipeline mode

Monitor Pipeline

Event-driven pipeline coordination. Beat model: coordinator wake -> process -> spawn -> STOP.

Constants

• SPAWN_MODE: background
• ONE_STEP_PER_INVOCATION: true
• FAST_ADVANCE_AWARE: true
• WORKER_AGENT: team-worker
• MAX_GC_ROUNDS: 2

Handler Router

handleCallback

Worker completed. Process and advance.

1. Parse message to identify role and task ID:

2. Mark task as completed: TaskUpdate({ taskId: "<task-id>", status: "completed" }) 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

• Log team_msg with type "gc_loop_trigger" or "task_unblocked"
• If skipping GC tasks, mark them as completed (skip)

5. Proceed to handleSpawnNext

handleCheck

Read-only status report, then STOP.

Worker Progress (from message bus):

Before generating status output, read worker milestones:

const progressMsgs = mcp__ccw-tools__team_msg({
  operation: "list", session_id: sessionId, type: "progress", last: 50
})
const blockerMsgs = mcp__ccw-tools__team_msg({
  operation: "list", session_id: sessionId, type: "blocker", last: 10
})

// Aggregate latest milestone per task
const taskProgress = {}
for (const msg of (progressMsgs.result?.messages || [])) {
  const tid = msg.data?.task_id
  if (tid && (!taskProgress[tid] || msg.ts > taskProgress[tid].ts)) {
    taskProgress[tid] = { phase: msg.data.phase, pct: msg.data.progress_pct, ts: msg.ts }
  }
}

Include in status output:

• Per-worker latest milestone (phase + progress_pct) next to task status
• Active blockers section (if any blockerMsgs found)

[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. TaskUpdate -> in_progress b. team_msg log -> task_unblocked c. Spawn team-worker (see SKILL.md Spawn Template):

      Agent({
        subagent_type: "team-worker",
        description: "Spawn <role> worker for <task-id>",
        team_name: "brainstorm",
        name: "<role>",
        run_in_background: true,
        prompt: `## Role Assignment
      role: <role>
      role_spec: ~  or <project>/.claude/skills/team-brainstorm/roles/<role>/role.md
      session: <session-folder>
      session_id: <session-id>
      team_name: brainstorm
      requirement: <task-description>
      inner_loop: false

      ## Progress Milestones
      session_id: <session-id>
      Report progress via team_msg at natural phase boundaries (context loaded -> core work done -> verification).
      Report blockers immediately via team_msg type="blocker".
      Report completion via team_msg type="task_complete" after final SendMessage.

      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. Add to active_workers 5. Parallel spawn rules:

Parallel ideator spawn (Full pipeline):

Agent({
  subagent_type: "team-worker",
  name: "ideator-<N>",
  ...
  prompt: `...agent_name: ideator-<N>...`
})

6. Update session, output summary, STOP

handleComplete

Pipeline done. Generate report and completion action.

Completion check by mode:

1. Verify all tasks completed via TaskList() 2. If any tasks not completed, return to handleSpawnNext 3. If all completed -> transition to coordinator Phase 5

handleConsensus

Handle consensus_blocked signals.

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, 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

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 (NOT general-purpose)
• Follow Command Execution Protocol for dispatch and monitor commands
• Respect pipeline stage dependencies (blockedBy)
• Stop after spawning workers -- wait for callbacks
• 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

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 (audit TaskList, reset in_progress->pending, rebuild team, kick first ready task) 4. Multiple -> AskUserQuestion for selection

Phase 1: Topic Clarification + Complexity Assessment

TEXT-LEVEL ONLY. No source code reading.

1. Parse topic from $ARGUMENTS 2. Assess topic complexity:

3. AskUserQuestion 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({ command: "pwd" })
• skill_root = <project_root>/.claude/skills/team-brainstorm

2. Generate session ID: BRS-<topic-slug>-<date> 3. Create session folder structure: ideas/, critiques/, synthesis/, evaluation/, wisdom/, .msg/ 4. TeamCreate with team name brainstorm 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. Create tasks for selected pipeline, then set dependencies via TaskUpdate({ addBlockedBy }) 3. Update session.json with task count

Phase 4: Spawn-and-Stop

Delegate to @commands/monitor.md#handleSpawnNext: 1. Find ready tasks (pending + blockedBy 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:

3. Output pipeline summary: topic, pipeline mode, GC rounds, total ideas, key themes

4. Execute completion action per session.completion_action:

• interactive -> AskUserQuestion (Archive/Keep/Export)
• auto_archive -> Archive & Clean (status=completed, TeamDelete)
• auto_keep -> Keep Active (status=paused)

Error Handling

Evaluator

Scoring, ranking, and final selection. Multi-dimension evaluation of synthesized proposals with weighted scoring and priority recommendations.

Phase 2: Context Loading

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:

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

After passing checks, update shared state:

• Set .msg/meta.json evaluation_scores
• Each entry: title, weighted_score, rank, recommendation

Ideator

Multi-angle idea generator. Divergent thinking, concept exploration, and idea revision as the Generator in the Generator-Critic loop.

Phase 2: Context Loading

1. Extract session path from task description (match "Session: <path>") 2. Read .msg/meta.json for topic, angles, gc_round 3. Detect task mode:

4. If GC Revision mode:

• Glob critique files from <session>/critiques/
• Read latest critique for revision context

5. Read previous ideas from .msg/meta.json generated_ideas state

Phase 3: Idea Generation

Mode Router

Initial Generation:

• For each angle, generate 3+ ideas
• Each idea: title, description (2-3 sentences), key assumption, potential impact, implementation hint

GC Revision:

• Focus on HIGH/CRITICAL severity challenges from critique
• Retain unchallenged ideas intact
• Revise ideas with revision rationale
• Replace unsalvageable ideas with new alternatives

Output: Write to <session>/ideas/idea-<num>.md

• Sections: Topic, Angles, Mode, [Revision Context if applicable], Ideas list, Summary

Phase 4: Self-Review

After passing checks, update shared state:

• Append new ideas to .msg/meta.json generated_ideas
• Each entry: id, title, round, revised flag

Synthesizer

Cross-idea integrator. Extracts themes from multiple ideas and challenge feedback, resolves conflicts, generates consolidated proposals.

Phase 2: Context Loading

1. Extract session path from task description (match "Session: <path>") 2. Glob all idea files from <session>/ideas/ 3. Glob all critique files from <session>/critiques/ 4. Read all idea and critique files for synthesis 5. Read .msg/meta.json for context (topic, gc_round, generated_ideas, critique_insights)

Phase 3: Synthesis Execution

Integrated Proposal Structure:

• Core concept description
• Source ideas combined
• Addressed challenges from critiques
• Feasibility score (1-10), Innovation score (1-10)
• Key benefits list, Remaining risks list

Output: Write to <session>/synthesis/synthesis-<num>.md

• Sections: Input summary, Extracted Themes, Conflict Resolution, Integrated Proposals, Coverage Analysis

Phase 4: Quality Check

After passing checks, update shared state:

• Set .msg/meta.json synthesis_themes
• Each entry: name, strength, supporting_ideas

Pipeline Definitions — team-brainstorm

Available Pipelines

Quick Pipeline (3 beats, strictly serial)

IDEA-001 → CHALLENGE-001 → SYNTH-001
[ideator]   [challenger]   [synthesizer]

Deep Pipeline (6 beats, Generator-Critic loop)

IDEA-001 → CHALLENGE-001 → IDEA-002(fix) → CHALLENGE-002 → SYNTH-001 → EVAL-001

GC loop check: if critique.severity >= HIGH → create IDEA-fix → CHALLENGE-2 → SYNTH; else skip to SYNTH

Full Pipeline (7 tasks, fan-out parallel ideation + GC)

[IDEA-001 + IDEA-002 + IDEA-003](parallel) → CHALLENGE-001(batch) → IDEA-004(fix) → SYNTH-001 → EVAL-001

Task Metadata Registry

Checkpoints

Completion Conditions

Shared State (meta.json)

Message Types