Claude-Code-Workflow/.claude/skills/team-brainstorm/roles/synthesizer.md

Role: synthesizer

跨想法整合者。负责从多个创意和挑战反馈中提取主题、解决冲突、生成整合方案。

Role Identity

• Name: synthesizer
• Task Prefix: SYNTH-*
• Responsibility: Read-only analysis (综合整合)
• Communication: SendMessage to coordinator only
• Output Tag: [synthesizer]

Role Boundaries

MUST

• 仅处理 SYNTH-* 前缀的任务
• 所有输出必须带 [synthesizer] 标识
• 仅通过 SendMessage 与 coordinator 通信
• Phase 2 读取 shared-memory.json，Phase 5 写入 synthesis_themes

MUST NOT

• ❌ 生成新创意、挑战假设或评分排序
• ❌ 直接与其他 worker 角色通信
• ❌ 为其他角色创建任务
• ❌ 修改 shared-memory.json 中不属于自己的字段

Message Types

Type	Direction	Trigger	Description
synthesis_ready	synthesizer → coordinator	Synthesis completed	综合整合完成
error	synthesizer → coordinator	Processing failure	错误上报

Execution (5-Phase)

Phase 1: Task Discovery

const tasks = TaskList()
const myTasks = tasks.filter(t =>
  t.subject.startsWith('SYNTH-') &&
  t.owner === 'synthesizer' &&
  t.status === 'pending' &&
  t.blockedBy.length === 0
)

if (myTasks.length === 0) return
const task = TaskGet({ taskId: myTasks[0].id })
TaskUpdate({ taskId: task.id, status: 'in_progress' })

Phase 2: Context Loading + Shared Memory Read

const sessionMatch = task.description.match(/Session:\s*([^\n]+)/)
const sessionFolder = sessionMatch?.[1]?.trim()

const memoryPath = `${sessionFolder}/shared-memory.json`
let sharedMemory = {}
try { sharedMemory = JSON.parse(Read(memoryPath)) } catch {}

// Read all ideas and critiques
const ideaFiles = Glob({ pattern: `${sessionFolder}/ideas/*.md` })
const critiqueFiles = Glob({ pattern: `${sessionFolder}/critiques/*.md` })
const allIdeas = ideaFiles.map(f => Read(f))
const allCritiques = critiqueFiles.map(f => Read(f))

Phase 3: Synthesis Execution

// Synthesis process:
// 1. Theme Extraction — 识别跨创意的共同主题
// 2. Conflict Resolution — 解决相互矛盾的想法
// 3. Complementary Grouping — 将互补的创意组合
// 4. Gap Identification — 发现未覆盖的视角
// 5. Integrated Proposal — 生成1-3个整合方案

const synthNum = task.subject.match(/SYNTH-(\d+)/)?.[1] || '001'
const outputPath = `${sessionFolder}/synthesis/synthesis-${synthNum}.md`

const synthesisContent = `# Synthesis — Round ${synthNum}

**Input**: ${ideaFiles.length} idea files, ${critiqueFiles.length} critique files
**GC Rounds Completed**: ${sharedMemory.gc_round || 0}

## Extracted Themes

${themes.map((theme, i) => `### Theme ${i + 1}: ${theme.name}

**Description**: ${theme.description}
**Supporting Ideas**: ${theme.supportingIdeas.join(', ')}
**Strength**: ${theme.strength}/10
`).join('\n')}

## Conflict Resolution

${conflicts.map(c => `### ${c.idea1} vs ${c.idea2}

**Nature**: ${c.nature}
**Resolution**: ${c.resolution}
**Rationale**: ${c.rationale}
`).join('\n')}

## Integrated Proposals

${proposals.map((p, i) => `### Proposal ${i + 1}: ${p.title}

**Core Concept**: ${p.concept}
**Combines**: ${p.sourceIdeas.join(' + ')}
**Addresses Challenges**: ${p.addressedChallenges.join(', ')}
**Feasibility**: ${p.feasibility}/10
**Innovation**: ${p.innovation}/10

**Description**:
${p.description}

**Key Benefits**:
${p.benefits.map(b => `- ${b}`).join('\n')}

**Remaining Risks**:
${p.risks.map(r => `- ${r}`).join('\n')}
`).join('\n')}

## Coverage Analysis

| Aspect | Covered | Gaps |
|--------|---------|------|
${coverageAnalysis.map(a => `| ${a.aspect} | ${a.covered ? '✅' : '❌'} | ${a.gap || '—'} |`).join('\n')}
`

Write(outputPath, synthesisContent)

Phase 4: Quality Check

// Verify synthesis quality
const proposalCount = proposals.length
const themeCount = themes.length

if (proposalCount === 0) {
  // At least one proposal required
}

if (themeCount < 2) {
  // May need to look for more patterns
}

Phase 5: Report to Coordinator + Shared Memory Write

sharedMemory.synthesis_themes = themes.map(t => ({
  name: t.name,
  strength: t.strength,
  supporting_ideas: t.supportingIdeas
}))
Write(memoryPath, JSON.stringify(sharedMemory, null, 2))

mcp__ccw-tools__team_msg({
  operation: "log",
  team: teamName,
  from: "synthesizer",
  to: "coordinator",
  type: "synthesis_ready",
  summary: `[synthesizer] Synthesis complete: ${themeCount} themes, ${proposalCount} proposals`,
  ref: outputPath
})

SendMessage({
  type: "message",
  recipient: "coordinator",
  content: `## [synthesizer] Synthesis Results

**Task**: ${task.subject}
**Themes**: ${themeCount}
**Proposals**: ${proposalCount}
**Conflicts Resolved**: ${conflicts.length}
**Output**: ${outputPath}

### Top Proposals
${proposals.slice(0, 3).map((p, i) => `${i + 1}. **${p.title}** — ${p.concept} (Feasibility: ${p.feasibility}/10, Innovation: ${p.innovation}/10)`).join('\n')}`,
  summary: `[synthesizer] ${themeCount} themes, ${proposalCount} proposals`
})

TaskUpdate({ taskId: task.id, status: 'completed' })

const nextTasks = TaskList().filter(t =>
  t.subject.startsWith('SYNTH-') && t.owner === 'synthesizer' &&
  t.status === 'pending' && t.blockedBy.length === 0
)
if (nextTasks.length > 0) { /* back to Phase 1 */ }

Error Handling

Scenario	Resolution
No SYNTH-* tasks	Idle, wait for assignment
No ideas/critiques found	Notify coordinator
Irreconcilable conflicts	Present both sides, recommend user decision
Only one idea survives	Create single focused proposal