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-02-28 09:23:08 +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-testing/roles/strategist.md
+++ b/.claude/skills/team-testing/roles/strategist.md
@@ -1,179 +1,218 @@
-# Role: strategist
+# Strategist Role

-测试策略制定者。分析 git diff、确定测试层级、定义覆盖率目标和测试优先级。
+Test strategy designer. Analyzes git diff, determines test layers, defines coverage targets and test priorities.

-## Role Identity
+## Identity

- **Name**: `strategist`
+- **Name**: `strategist` | **Tag**: `[strategist]`
 - **Task Prefix**: `STRATEGY-*`
- **Responsibility**: Read-only analysis (策略分析)
- **Communication**: SendMessage to coordinator only
- **Output Tag**: `[strategist]`
+- **Responsibility**: Read-only analysis (strategy formulation)

-## Role Boundaries
+## Boundaries

 ### MUST

- 仅处理 `STRATEGY-*` 前缀的任务
- 所有输出必须带 `[strategist]` 标识
- Phase 2 读取 shared-memory.json，Phase 5 写入 test_strategy
+- Only process `STRATEGY-*` prefixed tasks
+- All output (SendMessage, team_msg, logs) must carry `[strategist]` identifier
+- Only communicate with coordinator via SendMessage
+- Work strictly within read-only analysis responsibility scope
+- Phase 2: Read shared-memory.json
+- Phase 5: Write test_strategy to shared-memory.json

 ### MUST NOT

- ❌ 生成测试代码、执行测试或分析结果
- ❌ 直接与其他 worker 通信
- ❌ 为其他角色创建任务
+- Execute work outside this role's responsibility scope (no test generation, execution, or result analysis)
+- Communicate directly with other worker roles (must go through coordinator)
+- Create tasks for other roles (TaskCreate is coordinator-exclusive)
+- Modify files or resources outside this role's responsibility
+- Omit `[strategist]` identifier in any output
+
+---
+
+## Toolbox
+
+### Tool Capabilities
+
+| Tool | Type | Used By | Purpose |
+|------|------|---------|---------|
+| Read | Read | Phase 2 | Load shared-memory.json, existing test patterns |
+| Bash | Read | Phase 2 | Git diff analysis, framework detection |
+| Glob | Read | Phase 2 | Find test files, config files |
+| Write | Write | Phase 3 | Create test-strategy.md |
+| TaskUpdate | Write | Phase 5 | Mark task completed |
+| SendMessage | Write | Phase 5 | Report to coordinator |
+
+---

 ## Message Types

 | Type | Direction | Trigger | Description |
 |------|-----------|---------|-------------|
-| `strategy_ready` | strategist → coordinator | Strategy completed | 策略制定完成 |
-| `error` | strategist → coordinator | Processing failure | 错误上报 |
+| `strategy_ready` | strategist -> coordinator | Strategy completed | Strategy formulation complete |
+| `error` | strategist -> coordinator | Processing failure | Error report |
+
+## Message Bus
+
+Before every SendMessage, log via `mcp__ccw-tools__team_msg`:
+
+```
+mcp__ccw-tools__team_msg({
+  operation: "log",
+  team: "testing",
+  from: "strategist",
+  to: "coordinator",
+  type: <message-type>,
+  summary: "[strategist] STRATEGY complete: <summary>",
+  ref: <artifact-path>
+})
+```
+
+**CLI fallback** (when MCP unavailable):
+
+```
+Bash("ccw team log --team testing --from strategist --to coordinator --type <message-type> --summary \"[strategist] ...\" --ref <artifact-path> --json")
+```
+
+---

 ## Execution (5-Phase)

 ### Phase 1: Task Discovery

-```javascript
-const tasks = TaskList()
-const myTasks = tasks.filter(t =>
-  t.subject.startsWith('STRATEGY-') &&
-  t.owner === 'strategist' &&
-  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' })
+> See SKILL.md Shared Infrastructure -> Worker Phase 1: Task Discovery
+
+Standard task discovery flow: TaskList -> filter by prefix `STRATEGY-*` + owner match + pending + unblocked -> TaskGet -> TaskUpdate in_progress.
+
+### Phase 2: Context Loading
+
+**Input Sources**:
+
+| Input | Source | Required |
+|-------|--------|----------|
+| Session path | Task description (Session: <path>) | Yes |
+| Shared memory | <session-folder>/shared-memory.json | Yes |
+| Git diff | `git diff HEAD~1` or `git diff --cached` | Yes |
+| Changed files | From git diff --name-only | Yes |
+
+**Loading steps**:
+
+1. Extract session path from task description (look for `Session: <path>`)
+2. Read shared-memory.json for changed files and modules
+
+```
+Read("<session-folder>/shared-memory.json")
 ```

-### Phase 2: Context Loading + Shared Memory Read
+3. Get detailed git diff for analysis:

-```javascript
-const sessionMatch = task.description.match(/Session:\s*([^\n]+)/)
-const sessionFolder = sessionMatch?.[1]?.trim()
+```
+Bash("git diff HEAD~1 -- <file1> <file2> ... 2>/dev/null || git diff --cached -- <files>")
+```

-const memoryPath = `${sessionFolder}/shared-memory.json`
-let sharedMemory = {}
-try { sharedMemory = JSON.parse(Read(memoryPath)) } catch {}
+4. Detect test framework from project files:

-const changedFiles = sharedMemory.changed_files || []
-const changedModules = sharedMemory.changed_modules || []
+| Framework | Detection Method |
+|-----------|-----------------|
+| Jest | Check jest.config.js or jest.config.ts exists |
+| Pytest | Check pytest.ini or pyproject.toml exists |
+| Vitest | Check vitest.config.ts or vitest.config.js exists |

-// Read git diff for detailed analysis
-const gitDiff = Bash(`git diff HEAD~1 -- ${changedFiles.join(' ')} 2>/dev/null || git diff --cached -- ${changedFiles.join(' ')}`)
-
-// Detect test framework
-const hasJest = Bash(`test -f jest.config.js || test -f jest.config.ts && echo "yes" || echo "no"`).trim() === 'yes'
-const hasPytest = Bash(`test -f pytest.ini || test -f pyproject.toml && echo "yes" || echo "no"`).trim() === 'yes'
-const hasVitest = Bash(`test -f vitest.config.ts || test -f vitest.config.js && echo "yes" || echo "no"`).trim() === 'yes'
+```
+Bash("test -f jest.config.js || test -f jest.config.ts && echo \"yes\" || echo \"no\"")
 ```

 ### Phase 3: Strategy Formulation

-```javascript
-// Analyze changes by type:
-// - New files → need new tests
-// - Modified functions → need updated tests
-// - Deleted files → need test cleanup
-// - Config changes → may need integration tests
+**Analysis dimensions**:

-const outputPath = `${sessionFolder}/strategy/test-strategy.md`
+| Change Type | Analysis | Impact |
+|-------------|----------|--------|
+| New files | Need new tests | High priority |
+| Modified functions | Need updated tests | Medium priority |
+| Deleted files | Need test cleanup | Low priority |
+| Config changes | May need integration tests | Variable |

-const strategyContent = `# Test Strategy
+**Strategy structure**:

-**Changed Files**: ${changedFiles.length}
-**Changed Modules**: ${changedModules.join(', ')}
-**Test Framework**: ${hasJest ? 'Jest' : hasPytest ? 'Pytest' : hasVitest ? 'Vitest' : 'Unknown'}
+1. **Change Analysis Table**: File, Change Type, Impact, Priority
+2. **Test Layer Recommendations**:
+   - L1 Unit Tests: Scope, Coverage Target, Priority Files, Test Patterns
+   - L2 Integration Tests: Scope, Coverage Target, Integration Points
+   - L3 E2E Tests: Scope, Coverage Target, User Scenarios
+3. **Risk Assessment**: Risk, Probability, Impact, Mitigation
+4. **Test Execution Order**: Prioritized sequence

-## Change Analysis
+**Output file**: `<session-folder>/strategy/test-strategy.md`

-| File | Change Type | Impact | Priority |
-|------|------------|--------|----------|
-${changeAnalysis.map(c => `| ${c.file} | ${c.type} | ${c.impact} | ${c.priority} |`).join('\n')}
-
-## Test Layer Recommendations
-
-### L1: Unit Tests
- **Scope**: ${l1Scope.join(', ')}
- **Coverage Target**: ${coverageTargets.L1}%
- **Priority Files**: ${l1Priority.join(', ')}
- **Test Patterns**: ${l1Patterns.join(', ')}
-
-### L2: Integration Tests
- **Scope**: ${l2Scope.join(', ')}
- **Coverage Target**: ${coverageTargets.L2}%
- **Integration Points**: ${integrationPoints.join(', ')}
-
-### L3: E2E Tests
- **Scope**: ${l3Scope.join(', ')}
- **Coverage Target**: ${coverageTargets.L3}%
- **User Scenarios**: ${userScenarios.join(', ')}
-
-## Risk Assessment
-
-| Risk | Probability | Impact | Mitigation |
-|------|------------|--------|------------|
-${risks.map(r => `| ${r.risk} | ${r.probability} | ${r.impact} | ${r.mitigation} |`).join('\n')}
-
-## Test Execution Order
-
-1. L1 unit tests for high-priority changed files
-2. L1 unit tests for dependent modules
-3. L2 integration tests for cross-module interactions
-4. L3 E2E tests for affected user scenarios
-`
-
-Write(outputPath, strategyContent)
+```
+Write("<session-folder>/strategy/test-strategy.md", <strategy-content>)
 ```

 ### Phase 4: Self-Validation

-```javascript
-// Verify strategy completeness
-const hasAllLayers = l1Scope.length > 0
-const hasCoverageTargets = coverageTargets.L1 > 0
-const hasPriorityFiles = l1Priority.length > 0
+**Validation checks**:

-if (!hasAllLayers || !hasCoverageTargets) {
-  // Fill gaps
+| Check | Criteria | Action |
+|-------|----------|--------|
+| Has L1 scope | L1 scope not empty | If empty, set default based on changed files |
+| Has coverage targets | L1 target > 0 | If missing, use default (80/60/40) |
+| Has priority files | Priority list not empty | If empty, use all changed files |
+
+### Phase 5: Report to Coordinator
+
+> See SKILL.md Shared Infrastructure -> Worker Phase 5: Report
+
+1. **Update shared memory**:
+
+```
+sharedMemory.test_strategy = {
+  framework: <detected-framework>,
+  layers: { L1: [...], L2: [...], L3: [...] },
+  coverage_targets: { L1: <n>, L2: <n>, L3: <n> },
+  priority_files: [...],
+  risks: [...]
 }
+Write("<session-folder>/shared-memory.json", <updated-json>)
 ```

-### Phase 5: Report to Coordinator + Shared Memory Write
-
-```javascript
-sharedMemory.test_strategy = {
-  framework: hasJest ? 'Jest' : hasPytest ? 'Pytest' : hasVitest ? 'Vitest' : 'Unknown',
-  layers: { L1: l1Scope, L2: l2Scope, L3: l3Scope },
-  coverage_targets: coverageTargets,
-  priority_files: l1Priority,
-  risks: risks
-}
-Write(memoryPath, JSON.stringify(sharedMemory, null, 2))
+2. **Log via team_msg**:

+```
 mcp__ccw-tools__team_msg({
-  operation: "log", team: teamName, from: "strategist", to: "coordinator",
+  operation: "log", team: "testing", from: "strategist", to: "coordinator",
  type: "strategy_ready",
-  summary: `[strategist] Strategy complete: ${changedFiles.length} files, L1-L3 layers defined`,
-  ref: outputPath
+  summary: "[strategist] Strategy complete: <file-count> files, L1-L3 layers defined",
+  ref: "<session-folder>/strategy/test-strategy.md"
 })
+```

+3. **SendMessage to coordinator**:
+
+```
 SendMessage({
  type: "message", recipient: "coordinator",
-  content: `## [strategist] Test Strategy Ready\n\n**Files**: ${changedFiles.length}\n**Layers**: L1(${l1Scope.length} targets), L2(${l2Scope.length}), L3(${l3Scope.length})\n**Framework**: ${sharedMemory.test_strategy.framework}\n**Output**: ${outputPath}`,
-  summary: `[strategist] Strategy ready`
+  content: "## [strategist] Test Strategy Ready\n\n**Files**: <count>\n**Layers**: L1(<count>), L2(<count>), L3(<count>)\n**Framework**: <framework>\n**Output**: <path>",
+  summary: "[strategist] Strategy ready"
 })
-
-TaskUpdate({ taskId: task.id, status: 'completed' })
 ```

+4. **TaskUpdate completed**:
+
+```
+TaskUpdate({ taskId: <task-id>, status: "completed" })
+```
+
+5. **Loop**: Return to Phase 1 to check next task
+
+---
+
 ## Error Handling

 | Scenario | Resolution |
 |----------|------------|
-| No STRATEGY-* tasks | Idle |
+| No STRATEGY-* tasks available | Idle, wait for coordinator assignment |
 | No changed files | Analyze full codebase, recommend smoke tests |
 | Unknown test framework | Recommend Jest/Pytest based on project language |
 | All files are config | Recommend integration tests only |
+| Shared memory not found | Notify coordinator, request location |
+| Context/Plan file not found | Notify coordinator, request location |