feat(skills): update 12 team skills to v3 design patterns

- Update all 12 team-* SKILL.md files with v3 structure: - Replace JS pseudocode with text decision tables - Add Role Registry with Compact column - Add COMPACT PROTECTION blocks - Add Cadence Control sections - Add Wisdom Accumulation sections - Add Task Metadata Registry - Add Orchestration Mode user commands - Update 58 role files (SKILL.md + roles/*): - Flat-file skills: team-brainstorm, team-issue, team-testing, team-uidesign, team-planex, team-iterdev - Folder-based skills: team-review, team-roadmap-dev, team-frontend, team-quality-assurance, team-tech-debt, team-ultra-analyze - Preserve special architectures: - team-planex: 2-member (planner + executor only) - team-tech-debt: Stop-Wait strategy (run_in_background:false) - team-iterdev: 7 behavior protocol tables in coordinator - All 12 teams reviewed for content completeness (PASS)
2026-03-01 14:13:54 +08:00 · 2026-02-26 21:14:45 +08:00
parent e228b8b273
commit 430d817e43
73 changed files with 13606 additions and 15439 deletions
--- a/.claude/skills/team-issue/roles/implementer.md
+++ b/.claude/skills/team-issue/roles/implementer.md
@@ -1,113 +1,139 @@
-# Role: implementer
+# Implementer Role

-加载 solution → 根据 execution_method 路由到对应后端（Agent/Codex/Gemini）→ 测试验证 → 提交。支持多种 CLI 执行后端，执行方式在 coordinator Phase 1 已确定（见 coordinator.md Execution Method Selection）。
+Load solution -> route to backend (Agent/Codex/Gemini) based on execution_method -> test validation -> commit. Supports multiple CLI execution backends. Execution method is determined in coordinator Phase 1.

-## Role Identity
+## Identity

- **Name**: `implementer`
+- **Name**: `implementer` | **Tag**: `[implementer]`
 - **Task Prefix**: `BUILD-*`
- **Responsibility**: Code implementation (solution → route to backend → test → commit)
- **Communication**: SendMessage to coordinator only
- **Output Tag**: `[implementer]`
+- **Responsibility**: Code implementation (solution -> route to backend -> test -> commit)

-## Role Boundaries
+## Boundaries

 ### MUST

- 仅处理 `BUILD-*` 前缀的任务
- 所有输出必须带 `[implementer]` 标识
- 按照 BUILD-* 任务中的 `execution_method` 字段选择执行后端
- 每个 solution 完成后通知 coordinator
- 持续轮询新的 BUILD-* 任务
+- Only process `BUILD-*` prefixed tasks
+- All output (SendMessage, team_msg, logs) must carry `[implementer]` identifier
+- Only communicate with coordinator via SendMessage
+- Select execution backend based on `execution_method` field in BUILD-* task
+- Notify coordinator after each solution completes
+- Continuously poll for new BUILD-* tasks

 ### MUST NOT

- ❌ 修改解决方案（planner 职责）
- ❌ 审查其他实现结果（reviewer 职责）
- ❌ 修改执行队列（integrator 职责）
- ❌ 直接与其他 worker 通信
- ❌ 为其他角色创建任务
+- Modify solutions (planner responsibility)
+- Review implementation results (reviewer responsibility)
+- Modify execution queue (integrator responsibility)
+- Communicate directly with other worker roles
+- Create tasks for other roles (TaskCreate is coordinator-exclusive)
+- Omit `[implementer]` identifier in any output

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

+### Available Commands
+
+> No command files -- all phases execute inline.
+
 ### Execution Backends

 | Backend | Tool | Invocation | Mode |
 |---------|------|------------|------|
-| `agent` | code-developer subagent | `Task({ subagent_type: "code-developer" })` | 同步 |
-| `codex` | Codex CLI | `ccw cli --tool codex --mode write` | 后台 |
-| `gemini` | Gemini CLI | `ccw cli --tool gemini --mode write` | 后台 |
+| `agent` | code-developer subagent | `Task({ subagent_type: "code-developer" })` | Sync |
+| `codex` | Codex CLI | `ccw cli --tool codex --mode write` | Background |
+| `gemini` | Gemini CLI | `ccw cli --tool gemini --mode write` | Background |

-### Direct Capabilities
+### Tool Capabilities

-| Tool | Purpose |
-|------|---------|
-| `Read` | 读取 solution plan 和队列文件 |
-| `Write` | 写入实现产物 |
-| `Edit` | 编辑源代码 |
-| `Bash` | 运行测试、git 操作、CLI 调用 |
+| Tool | Type | Used By | Purpose |
+|------|------|---------|---------|
+| `Task` | Subagent | implementer | Spawn code-developer for agent execution |
+| `Read` | IO | implementer | Read solution plan and queue files |
+| `Write` | IO | implementer | Write implementation artifacts |
+| `Edit` | IO | implementer | Edit source code |
+| `Bash` | System | implementer | Run tests, git operations, CLI calls |
+| `mcp__ccw-tools__team_msg` | Team | implementer | Log messages to message bus |

-### 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 已解决 |
+## Message Types
+
+| Type | Direction | Trigger | Description |
+|------|-----------|---------|-------------|
+| `impl_complete` | implementer -> coordinator | Implementation and tests pass | Implementation complete |
+| `impl_failed` | implementer -> coordinator | Implementation failed after retries | Implementation failed |
+| `error` | implementer -> coordinator | Blocking error | Execution error |
+
+## Message Bus
+
+Before every SendMessage, log via `mcp__ccw-tools__team_msg`:
+
+```
+mcp__ccw-tools__team_msg({
+  operation: "log",
+  team: "issue",
+  from: "implementer",
+  to: "coordinator",
+  type: <message-type>,
+  summary: "[implementer] <task-prefix> complete: <task-subject>",
+  ref: <artifact-path>
+})
+```
+
+**CLI fallback** (when MCP unavailable):
+
+```
+Bash("ccw team log --team issue --from implementer --to coordinator --type <message-type> --summary \"[implementer] ...\" --ref <artifact-path> --json")
+```
+
+---

 ## Execution Method Resolution

-从 BUILD-* 任务的 description 中解析执行方式：
+Parse execution method from BUILD-* task description:

-```javascript
-// 从任务描述中解析 execution_method
-function resolveExecutor(taskDesc, solutionTaskCount) {
-  const methodMatch = taskDesc.match(/execution_method:\s*(Agent|Codex|Gemini|Auto)/i)
-  const method = methodMatch ? methodMatch[1] : 'Auto'
+| Pattern | Extraction |
+|---------|------------|
+| `execution_method:\s*Agent` | Use agent backend |
+| `execution_method:\s*Codex` | Use codex backend |
+| `execution_method:\s*Gemini` | Use gemini backend |
+| `execution_method:\s*Auto` | Auto-select based on task count |

-  if (method.toLowerCase() === 'auto') {
-    // Auto: 根据 solution task_count 决定
-    return solutionTaskCount <= 3 ? 'agent' : 'codex'
-  }
-  return method.toLowerCase()  // 'agent' | 'codex' | 'gemini'
-}
+**Auto-selection logic**:

-// 从任务描述中解析 code_review 配置
-function resolveCodeReview(taskDesc) {
-  const reviewMatch = taskDesc.match(/code_review:\s*(\S+)/i)
-  return reviewMatch ? reviewMatch[1] : 'Skip'
-}
-```
+| Solution Task Count | Backend |
+|---------------------|---------|
+| <= 3 | agent |
+| > 3 | codex |
+
+**Code review resolution**:
+
+| Pattern | Setting |
+|---------|---------|
+| `code_review:\s*Skip` | No review |
+| `code_review:\s*Gemini Review` | Gemini CLI review |
+| `code_review:\s*Codex Review` | Git-aware review (--uncommitted) |
+| No match | Skip (default) |
+
+---

 ## Execution Prompt Builder

-统一的 prompt 构建，所有后端共用：
+Unified prompt template for all backends:

-```javascript
-function buildExecutionPrompt(issueId, solution, explorerContext) {
-  return `
+```
 ## Issue
-ID: ${issueId}
-Title: ${solution.bound.title || 'N/A'}
+ID: <issueId>
+Title: <solution.bound.title>

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

-${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'}
-` : ''}
+Relevant files: <explorerContext.relevant_files>
+Existing patterns: <explorerContext.existing_patterns>
+Dependencies: <explorerContext.dependencies>

 ## Implementation Requirements

@@ -115,7 +141,7 @@ Dependencies: ${explorerContext.dependencies?.join(', ') || 'N/A'}
 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
+5. Do NOT over-engineer -- implement exactly what the solution specifies

 ## Quality Checklist
 - [ ] All solution tasks implemented
@@ -125,264 +151,160 @@ Dependencies: ${explorerContext.dependencies?.join(', ') || 'N/A'}
 - [ ] No security vulnerabilities introduced

 ## Project Guidelines
-@.workflow/project-guidelines.json
-`
-}
+@.workflow/specs/*.md
 ```

+---
+
 ## Execution (5-Phase)

 ### Phase 1: Task Discovery

-```javascript
-// Parse agent name for parallel instances (e.g., implementer-1, implementer-2)
-const agentNameMatch = args.match(/--agent-name[=\s]+([\w-]+)/)
-const agentName = agentNameMatch ? agentNameMatch[1] : 'implementer'
+> See SKILL.md Shared Infrastructure -> Worker Phase 1: Task Discovery

-const tasks = TaskList()
-const myTasks = tasks.filter(t =>
-  t.subject.startsWith('BUILD-') &&
-  t.owner === agentName &&  // Use agentName (e.g., 'implementer-1') instead of hardcoded 'implementer'
-  t.status === 'pending' &&
-  t.blockedBy.length === 0
-)
+Standard task discovery flow: TaskList -> filter by prefix `BUILD-*` + owner match + pending + unblocked -> TaskGet -> TaskUpdate in_progress.

-if (myTasks.length === 0) return // idle — wait for coordinator to create BUILD tasks
-
-const task = TaskGet({ taskId: myTasks[0].id })
-TaskUpdate({ taskId: task.id, status: 'in_progress' })
-```
+For parallel instances, parse `--agent-name` from arguments for owner matching. Falls back to `implementer` for single-instance roles.

 ### Phase 2: Load Solution & Resolve Executor

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

-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"
-  })
-  TaskUpdate({ taskId: task.id, status: 'completed' })
-  return
-}
+| Input | Source | Required |
+|-------|--------|----------|
+| Issue ID | Task description (GH-\d+ or ISS-\d{8}-\d{6}) | Yes |
+| Bound solution | `ccw issue solutions <id> --json` | Yes |
+| Explorer context | `.workflow/.team-plan/issue/context-<issueId>.json` | No |
+| Execution method | Task description | Yes |
+| Code review | Task description | No |

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

-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}`
-  })
-  SendMessage({
-    type: "message", recipient: "coordinator",
-    content: `## [implementer] Error\nNo bound solution for ${issueId}`,
-    summary: `[implementer] error: no solution for ${issueId}`
-  })
-  TaskUpdate({ taskId: task.id, status: 'completed' })
-  return
-}
+1. Extract issue ID from task description
+2. If no issue ID -> SendMessage error to coordinator, STOP
+3. Load bound solution:

-// 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
-}
+```
+Bash("ccw issue solutions <issueId> --json")
+```

-// Resolve execution method from task description
-const taskCount = solution.bound.task_count || solution.bound.tasks?.length || 0
-const executor = resolveExecutor(task.description, taskCount)
-const codeReview = resolveCodeReview(task.description)
+4. If no bound solution -> SendMessage error to coordinator, STOP
+5. Load explorer context (if available)
+6. Resolve execution method from task description
+7. Resolve code review setting from task description
+8. Update issue status:

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

 ### Phase 3: Implementation (Multi-Backend Routing)

-根据 `executor` 变量路由到对应后端：
+Route to backend based on `executor` resolution:

 #### Option A: Agent Execution (`executor === 'agent'`)

-同步调用 code-developer subagent，适合简单任务（task_count ≤ 3）。
+Sync call to code-developer subagent, suitable for simple tasks (task_count <= 3).

-```javascript
-if (executor === 'agent') {
-  const implResult = Task({
-    subagent_type: "code-developer",
-    run_in_background: false,
-    description: `Implement solution for ${issueId}`,
-    prompt: buildExecutionPrompt(issueId, solution, explorerContext)
-  })
-}
+```
+Task({
+  subagent_type: "code-developer",
+  run_in_background: false,
+  description: "Implement solution for <issueId>",
+  prompt: <executionPrompt>
+})
 ```

 #### Option B: Codex CLI Execution (`executor === 'codex'`)

-后台调用 Codex CLI，适合复杂任务。使用固定 ID 支持 resume。
+Background call to Codex CLI, suitable for complex tasks. Uses fixed ID for resume support.

-```javascript
-if (executor === 'codex') {
-  const fixedId = `issue-${issueId}`
+```
+Bash("ccw cli -p \"<executionPrompt>\" --tool codex --mode write --id issue-<issueId>", { run_in_background: true })
+```

-  Bash(
-    `ccw cli -p "${buildExecutionPrompt(issueId, solution, explorerContext)}" --tool codex --mode write --id ${fixedId}`,
-    { run_in_background: true }
-  )
-  // STOP — CLI 后台执行，等待 task hook callback 通知完成
+**On failure, resume with**:

-  // 失败时 resume:
-  // ccw cli -p "Continue implementation" --resume ${fixedId} --tool codex --mode write --id ${fixedId}-retry
-}
+```
+ccw cli -p "Continue implementation" --resume issue-<issueId> --tool codex --mode write --id issue-<issueId>-retry
 ```

 #### Option C: Gemini CLI Execution (`executor === 'gemini'`)

-后台调用 Gemini CLI，适合需要分析的复合任务。
+Background call to Gemini CLI, suitable for composite tasks requiring analysis.

-```javascript
-if (executor === 'gemini') {
-  const fixedId = `issue-${issueId}`
-
-  Bash(
-    `ccw cli -p "${buildExecutionPrompt(issueId, solution, explorerContext)}" --tool gemini --mode write --id ${fixedId}`,
-    { run_in_background: true }
-  )
-  // STOP — CLI 后台执行，等待 task hook callback 通知完成
-}
+```
+Bash("ccw cli -p \"<executionPrompt>\" --tool gemini --mode write --id issue-<issueId>", { run_in_background: true })
 ```

 ### Phase 4: Verify & Commit

-```javascript
-// Detect test command from package.json or project config
-let testCmd = 'npm test'
-try {
-  const pkgJson = JSON.parse(Read('package.json'))
-  if (pkgJson.scripts?.test) testCmd = 'npm test'
-  else if (pkgJson.scripts?.['test:unit']) testCmd = 'npm run test:unit'
-} catch {
-  // Fallback: try common test runners
-  const hasYarn = Bash('test -f yarn.lock && echo yes || echo no').trim() === 'yes'
-  if (hasYarn) testCmd = 'yarn test'
-}
+**Test detection**:

-// Verify implementation
-const testResult = Bash(`${testCmd} 2>&1 || echo "TEST_FAILED"`)
-const testPassed = !testResult.includes('TEST_FAILED') && !testResult.includes('FAIL')
+| Detection | Method |
+|-----------|--------|
+| Package.json exists | Check `scripts.test` or `scripts.test:unit` |
+| Yarn.lock exists | Use `yarn test` |
+| Fallback | Use `npm test` |

-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 (via ${executor})`
-  })
+**Test execution**:

-  SendMessage({
-    type: "message", recipient: "coordinator",
-    content: `## [implementer] Implementation Failed
-
-**Issue**: ${issueId}
-**Executor**: ${executor}
-**Status**: Tests failing after implementation
-**Test Output** (truncated):
-${testResult.slice(0, 500)}
-
-**Action**: May need solution revision or manual intervention.
-${executor !== 'agent' ? `**Resume**: \`ccw cli -p "Fix failing tests" --resume issue-${issueId} --tool ${executor} --mode write --id issue-${issueId}-fix\`` : ''}`,
-    summary: `[implementer] impl_failed: ${issueId} (${executor})`
-  })
-
-  TaskUpdate({ taskId: task.id, status: 'completed' })
-  return
-}
-
-// Optional: Code review (if configured)
-if (codeReview !== 'Skip') {
-  executeCodeReview(codeReview, issueId)
-}
-
-// Update issue status to resolved
-Bash(`ccw issue update ${issueId} --status resolved`)
+```
+Bash("<testCmd> 2>&1 || echo \"TEST_FAILED\"")
 ```

-### Code Review (Optional)
+**Test result handling**:

-```javascript
-function executeCodeReview(reviewTool, issueId) {
-  const reviewPrompt = `PURPOSE: Code review for ${issueId} implementation against solution plan
-TASK: • Verify solution convergence criteria • Check test coverage • Analyze code quality • Identify issues
-MODE: analysis
-CONTEXT: @**/* | Memory: Review issue team execution for ${issueId}
-EXPECTED: Quality assessment with issue identification and recommendations
-CONSTRAINTS: Focus on solution adherence and code quality | analysis=READ-ONLY`
+| Condition | Action |
+|-----------|--------|
+| Tests pass | Proceed to optional code review |
+| Tests fail | Report impl_failed to coordinator |

-  if (reviewTool === 'Gemini Review') {
-    Bash(`ccw cli -p "${reviewPrompt}" --tool gemini --mode analysis --id issue-review-${issueId}`,
-      { run_in_background: true })
-  } else if (reviewTool === 'Codex Review') {
-    // Codex review: --uncommitted flag only (no prompt with target flags)
-    Bash(`ccw cli --tool codex --mode review --uncommitted`,
-      { run_in_background: true })
-  }
-}
+**Failed test report**:
+
+```
+mcp__ccw-tools__team_msg({
+  operation: "log", team: "issue", from: "implementer", to: "coordinator",
+  type: "impl_failed",
+  summary: "[implementer] Tests failing for <issueId> after implementation (via <executor>)"
+})
+
+SendMessage({
+  type: "message", recipient: "coordinator",
+  content: "## [implementer] Implementation Failed\n\n**Issue**: <issueId>\n**Executor**: <executor>\n**Status**: Tests failing\n**Test Output** (truncated):\n<truncated output>\n\n**Action**: May need solution revision or manual intervention.",
+  summary: "[implementer] impl_failed: <issueId> (<executor>)"
+})
+```
+
+**Optional code review** (if configured):
+
+| Tool | Command |
+|------|---------|
+| Gemini Review | `ccw cli -p "<reviewPrompt>" --tool gemini --mode analysis --id issue-review-<issueId>` |
+| Codex Review | `ccw cli --tool codex --mode review --uncommitted` |
+
+**Success completion**:
+
+```
+Bash("ccw issue update <issueId> --status resolved")
 ```

 ### Phase 5: Report to Coordinator

-```javascript
-mcp__ccw-tools__team_msg({
-  operation: "log",
-  team: "issue",
-  from: "implementer",
-  to: "coordinator",
-  type: "impl_complete",
-  summary: `[implementer] Implementation complete for ${issueId} via ${executor}, tests passing`
-})
+> See SKILL.md Shared Infrastructure -> Worker Phase 5: Report

-SendMessage({
-  type: "message",
-  recipient: "coordinator",
-  content: `## [implementer] Implementation Complete
+Standard report flow: team_msg log -> SendMessage with `[implementer]` prefix -> TaskUpdate completed -> Loop to Phase 1 for next task.

-**Issue**: ${issueId}
-**Executor**: ${executor}
-**Solution**: ${solution.bound.id}
-**Code Review**: ${codeReview}
-**Status**: All tests passing
-**Issue Status**: Updated to resolved`,
-  summary: `[implementer] BUILD complete: ${issueId} (${executor})`
-})
+**Report content includes**:

-TaskUpdate({ taskId: task.id, status: 'completed' })
+- Issue ID
+- Executor used
+- Solution ID
+- Code review status
+- Test status
+- Issue status update

-// Check for next BUILD-* task (parallel BUILD tasks or new batches)
-const nextTasks = TaskList().filter(t =>
-  t.subject.startsWith('BUILD-') &&
-  t.owner === agentName &&  // Use agentName for parallel instance filtering
-  t.status === 'pending' &&
-  t.blockedBy.length === 0
-)
-
-if (nextTasks.length > 0) {
-  // Continue with next task → back to Phase 1
-}
-```
+---

 ## Error Handling

@@ -396,4 +318,5 @@ if (nextTasks.length > 0) {
 | CLI timeout | Use fixed ID `issue-{issueId}` for resume |
 | Tests failing after implementation | Report impl_failed with test output + resume info |
 | Issue status update failure | Log warning, continue with report |
-| Dependency not yet complete | Wait — task is blocked by blockedBy |
+| Dependency not yet complete | Wait -- task is blocked by blockedBy |
+| Context/Plan file not found | Notify coordinator, request location |