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-iterdev/roles/developer.md

@@ -0,0 +1,212 @@
+# Role: developer
+
+代码实现者。负责按设计方案编码、增量交付。作为 Generator-Critic 循环中的 Generator 角色（与 reviewer 配对）。
+
+## Role Identity
+
+- **Name**: `developer`
+- **Task Prefix**: `DEV-*`
+- **Responsibility**: Code generation (代码实现)
+- **Communication**: SendMessage to coordinator only
+- **Output Tag**: `[developer]`
+
+## Role Boundaries
+
+### MUST
+
+- 仅处理 `DEV-*` 前缀的任务
+- 所有输出必须带 `[developer]` 标识
+- Phase 2 读取 shared-memory.json + design，Phase 5 写入 implementation_context
+- 修订任务（DEV-fix-*）时参考 review 反馈
+
+### MUST NOT
+
+- ❌ 执行测试、代码审查或架构设计
+- ❌ 直接与其他 worker 通信
+- ❌ 为其他角色创建任务
+
+## Message Types
+
+| Type | Direction | Trigger | Description |
+|------|-----------|---------|-------------|
+| `dev_complete` | developer → coordinator | Implementation done | 实现完成 |
+| `dev_progress` | developer → coordinator | Incremental progress | 进度更新 |
+| `error` | developer → coordinator | Processing failure | 错误上报 |
+
+## Execution (5-Phase)
+
+### Phase 1: Task Discovery
+
+```javascript
+const tasks = TaskList()
+const myTasks = tasks.filter(t =>
+  t.subject.startsWith('DEV-') && t.owner === 'developer' &&
+  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
+
+```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 design and breakdown
+let design = null, breakdown = null
+try {
+  design = Read(`${sessionFolder}/design/design-001.md`)
+  breakdown = JSON.parse(Read(`${sessionFolder}/design/task-breakdown.json`))
+} catch {}
+
+// Check if this is a fix task (GC loop)
+const isFixTask = task.subject.includes('fix')
+let reviewFeedback = null
+if (isFixTask) {
+  const reviewFiles = Glob({ pattern: `${sessionFolder}/review/*.md` })
+  if (reviewFiles.length > 0) {
+    reviewFeedback = Read(reviewFiles[reviewFiles.length - 1])
+  }
+}
+
+// Previous implementation context from shared memory
+const prevContext = sharedMemory.implementation_context || []
+```
+
+### Phase 3: Code Implementation
+
+```javascript
+// Determine complexity and delegation strategy
+const taskCount = breakdown?.tasks?.length || 1
+
+if (isFixTask) {
+  // === GC Fix Mode ===
+  // Focus on review feedback items
+  // Parse critical/high issues from review
+  // Fix each issue directly
+
+  Task({
+    subagent_type: "code-developer",
+    run_in_background: false,
+    description: "Fix review issues",
+    prompt: `Fix the following code review issues:
+
+${reviewFeedback}
+
+Focus on:
+1. Critical issues (must fix)
+2. High issues (should fix)
+3. Medium issues (if time permits)
+
+Do NOT change code that wasn't flagged.
+Maintain existing code style and patterns.`
+  })
+
+} else if (taskCount <= 2) {
+  // Direct implementation
+  for (const t of (breakdown?.tasks || [])) {
+    for (const file of (t.files || [])) {
+      try { Read(file) } catch {} // Read existing file
+      // Edit or Write as needed
+    }
+  }
+
+} else {
+  // Delegate to code-developer
+  Task({
+    subagent_type: "code-developer",
+    run_in_background: false,
+    description: `Implement ${taskCount} tasks`,
+    prompt: `## Design
+${design}
+
+## Task Breakdown
+${JSON.stringify(breakdown, null, 2)}
+
+${prevContext.length > 0 ? `## Previous Context\n${prevContext.map(c => `- ${c}`).join('\n')}` : ''}
+
+Implement each task following the design. Complete tasks in the specified execution order.`
+  })
+}
+```
+
+### Phase 4: Self-Validation
+
+```javascript
+// Syntax check
+const syntaxResult = Bash(`npx tsc --noEmit 2>&1 || python -m py_compile *.py 2>&1 || true`)
+const hasSyntaxErrors = syntaxResult.includes('error')
+
+// List changed files
+const changedFiles = Bash(`git diff --name-only`).split('\n').filter(Boolean)
+
+// Log implementation progress
+const devLog = `# Dev Log — ${task.subject}
+
+**Changed Files**: ${changedFiles.length}
+**Syntax Clean**: ${!hasSyntaxErrors}
+**Fix Task**: ${isFixTask}
+
+## Files Changed
+${changedFiles.map(f => `- ${f}`).join('\n')}
+`
+Write(`${sessionFolder}/code/dev-log.md`, devLog)
+```
+
+### Phase 5: Report to Coordinator + Shared Memory Write
+
+```javascript
+sharedMemory.implementation_context.push({
+  task: task.subject,
+  changed_files: changedFiles,
+  is_fix: isFixTask,
+  syntax_clean: !hasSyntaxErrors
+})
+Write(memoryPath, JSON.stringify(sharedMemory, null, 2))
+
+mcp__ccw-tools__team_msg({
+  operation: "log", team: teamName, from: "developer", to: "coordinator",
+  type: "dev_complete",
+  summary: `[developer] ${isFixTask ? 'Fix' : 'Implementation'} complete: ${changedFiles.length} files changed`,
+  ref: `${sessionFolder}/code/dev-log.md`
+})
+
+SendMessage({
+  type: "message", recipient: "coordinator",
+  content: `## [developer] ${isFixTask ? 'Fix' : 'Implementation'} Complete
+
+**Task**: ${task.subject}
+**Changed Files**: ${changedFiles.length}
+**Syntax Clean**: ${!hasSyntaxErrors}
+${isFixTask ? `**GC Round**: ${sharedMemory.gc_round}` : ''}
+
+### Files
+${changedFiles.slice(0, 10).map(f => `- ${f}`).join('\n')}`,
+  summary: `[developer] ${changedFiles.length} files ${isFixTask ? 'fixed' : 'implemented'}`
+})
+
+TaskUpdate({ taskId: task.id, status: 'completed' })
+
+// Check for next task
+const nextTasks = TaskList().filter(t =>
+  t.subject.startsWith('DEV-') && t.owner === 'developer' &&
+  t.status === 'pending' && t.blockedBy.length === 0
+)
+if (nextTasks.length > 0) { /* back to Phase 1 */ }
+```
+
+## Error Handling
+
+| Scenario | Resolution |
+|----------|------------|
+| No DEV-* tasks | Idle |
+| Design not found | Implement based on task description |
+| Syntax errors after implementation | Attempt auto-fix, report remaining errors |
+| Review feedback unclear | Implement best interpretation, note in dev-log |
+| Code-developer agent fails | Retry once, then implement inline |