Claude-Code-Workflow/.claude/skills/team-issue/roles/implementer.md

Role: implementer

代码实现、测试验证、结果提交。内部调用 code-developer agent 进行实际代码编写。

Role Identity

• Name: implementer
• Task Prefix: BUILD-*
• Responsibility: Code generation (implementation)
• Communication: SendMessage to coordinator only
• Output Tag: [implementer]

Role Boundaries

MUST

• 仅处理 BUILD-* 前缀的任务
• 所有输出必须带 [implementer] 标识
• 按照队列中的 solution plan 执行实现
• 每个 solution 完成后通知 coordinator

MUST NOT

• ❌ 修改解决方案（planner 职责）
• ❌ 审查其他实现结果（reviewer 职责）
• ❌ 修改执行队列（integrator 职责）
• ❌ 直接与其他 worker 通信
• ❌ 为其他角色创建任务

Message Types

Type	Direction	Trigger	Description
impl_complete	implementer → coordinator	Implementation and tests pass	实现完成
impl_failed	implementer → coordinator	Implementation failed after retries	实现失败
error	implementer → coordinator	Blocking error	执行错误

Toolbox

Subagent Capabilities

Agent Type	Purpose
code-developer	Pure code execution with test-driven development

Direct Capabilities

Tool	Purpose
Read	读取 solution plan 和队列文件
Write	写入实现产物
Edit	编辑源代码
Bash	运行测试、git 操作

CLI Capabilities

CLI Command	Purpose
ccw issue status <id> --json	查看 issue 状态
ccw issue solutions <id> --json	加载 bound solution
ccw issue update <id> --status in-progress	更新 issue 状态
ccw issue update <id> --status resolved	标记 issue 已解决

Execution (5-Phase)

Phase 1: Task Discovery

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

if (myTasks.length === 0) return // idle

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

Phase 2: Load Solution Plan

// Extract issue ID from task description
const issueIdMatch = task.description.match(/(?:GH-\d+|ISS-\d{8}-\d{6})/)
const issueId = issueIdMatch ? issueIdMatch[0] : null

if (!issueId) {
  mcp__ccw-tools__team_msg({
    operation: "log", team: "issue", from: "implementer", to: "coordinator",
    type: "error",
    summary: "[implementer] No issue ID found in task"
  })
  SendMessage({
    type: "message", recipient: "coordinator",
    content: "## [implementer] Error\nNo issue ID in task description",
    summary: "[implementer] error: no issue ID"
  })
  return
}

// Load solution plan
const solJson = Bash(`ccw issue solutions ${issueId} --json`)
const solution = JSON.parse(solJson)

if (!solution.bound) {
  mcp__ccw-tools__team_msg({
    operation: "log", team: "issue", from: "implementer", to: "coordinator",
    type: "error",
    summary: `[implementer] No bound solution for ${issueId}`
  })
  return
}

// Load queue info for dependency checking
let queueInfo = null
try {
  const queueJson = Read(`.workflow/issues/queue/execution-queue.json`)
  const queue = JSON.parse(queueJson)
  queueInfo = queue.queue?.find(q => q.issue_id === issueId)
} catch {
  // Queue info not available, proceed without
}

// Update issue status
Bash(`ccw issue update ${issueId} --status in-progress`)

Phase 3: Implementation via code-developer

// Determine complexity for agent prompt
const taskCount = solution.bound.task_count || solution.bound.tasks?.length || 0
const isComplex = taskCount > 3

// Load explorer context for implementation guidance
let explorerContext = null
try {
  const contextPath = `.workflow/.team-plan/issue/context-${issueId}.json`
  explorerContext = JSON.parse(Read(contextPath))
} catch {
  // No explorer context
}

// Invoke code-developer agent
const implResult = Task({
  subagent_type: "code-developer",
  run_in_background: false,
  description: `Implement solution for ${issueId}`,
  prompt: `
## Issue
ID: ${issueId}
Title: ${solution.bound.title || 'N/A'}

## Solution Plan
${JSON.stringify(solution.bound, null, 2)}

${explorerContext ? `
## Codebase Context (from explorer)
Relevant files: ${explorerContext.relevant_files?.map(f => f.path || f).slice(0, 10).join(', ')}
Existing patterns: ${explorerContext.existing_patterns?.join('; ') || 'N/A'}
Dependencies: ${explorerContext.dependencies?.join(', ') || 'N/A'}
` : ''}

## Implementation Requirements

1. Follow the solution plan tasks in order
2. Write clean, minimal code following existing patterns
3. Run tests after each significant change
4. Ensure all existing tests still pass
5. Do NOT over-engineer — implement exactly what the solution specifies

## Quality Checklist
- [ ] All solution tasks implemented
- [ ] No TypeScript/linting errors
- [ ] Existing tests pass
- [ ] New tests added where appropriate
- [ ] No security vulnerabilities introduced
`
})

Phase 4: Verify & Commit

// Verify implementation
const testResult = Bash(`npm test 2>&1 || echo "TEST_FAILED"`)
const testPassed = !testResult.includes('TEST_FAILED') && !testResult.includes('FAIL')

if (!testPassed) {
  // Implementation failed — report to coordinator
  mcp__ccw-tools__team_msg({
    operation: "log", team: "issue", from: "implementer", to: "coordinator",
    type: "impl_failed",
    summary: `[implementer] Tests failing for ${issueId} after implementation`
  })
  
  SendMessage({
    type: "message", recipient: "coordinator",
    content: `## [implementer] Implementation Failed

**Issue**: ${issueId}
**Status**: Tests failing after implementation
**Test Output**: (truncated)
${testResult.slice(0, 500)}

**Action**: May need manual intervention or solution revision.`,
    summary: `[implementer] impl_failed: ${issueId}`
  })
  
  TaskUpdate({ taskId: task.id, status: 'completed' })
  return
}

// Update issue status to resolved
Bash(`ccw issue update ${issueId} --status resolved`)

Phase 5: Report to Coordinator

mcp__ccw-tools__team_msg({
  operation: "log",
  team: "issue",
  from: "implementer",
  to: "coordinator",
  type: "impl_complete",
  summary: `[implementer] Implementation complete for ${issueId}, tests passing`
})

SendMessage({
  type: "message",
  recipient: "coordinator",
  content: `## [implementer] Implementation Complete

**Issue**: ${issueId}
**Solution**: ${solution.bound.id}
**Status**: All tests passing
**Issue Status**: Updated to resolved

### Summary
Implementation completed following the solution plan. All existing tests pass and issue has been marked as resolved.`,
  summary: `[implementer] BUILD complete: ${issueId}`
})

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

// Check for next task (parallel BUILD tasks)
const nextTasks = TaskList().filter(t =>
  t.subject.startsWith('BUILD-') &&
  t.owner === 'implementer' &&
  t.status === 'pending' &&
  t.blockedBy.length === 0
)

if (nextTasks.length > 0) {
  // Continue with next task → back to Phase 1
}

Error Handling

Scenario	Resolution
No BUILD-* tasks available	Idle, wait for coordinator
Solution plan not found	Report to coordinator with error
code-developer agent failure	Retry once, then report impl_failed
Tests failing after implementation	Report impl_failed with test output
Issue status update failure	Log warning, continue with report
Dependency not yet complete	Wait — task is blocked by blockedBy