Claude-Code-Workflow/.claude/skills/team-iterdev/roles/developer.md

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