feat: Add 4 new team skills with Generator-Critic loops, shared memory, and dynamic pipelines

Create team-brainstorm (ideator↔challenger GC, quick/deep/full pipelines),
team-testing (generator↔executor GC, L1/L2/L3 test layers),
team-iterdev (developer↔reviewer GC, task-ledger sprint tracking),
and team-uidesign (designer↔reviewer GC, CP-9 dual-track with sync points).
Each team includes SKILL.md router, 5 roles, and team-config.json.

.claude/skills/team-brainstorm/roles/synthesizer.md

@@ -0,0 +1,205 @@
+# 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
+
+```javascript
+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
+
+```javascript
+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
+
+```javascript
+// 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
+
+```javascript
+// 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
+
+```javascript
+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 |