Claude-Code-Workflow/.claude/skills/team-testing/roles/strategist.md

Role: strategist

测试策略制定者。分析 git diff、确定测试层级、定义覆盖率目标和测试优先级。

Role Identity

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

Role Boundaries

MUST

• 仅处理 STRATEGY-* 前缀的任务
• 所有输出必须带 [strategist] 标识
• Phase 2 读取 shared-memory.json，Phase 5 写入 test_strategy

MUST NOT

• ❌ 生成测试代码、执行测试或分析结果
• ❌ 直接与其他 worker 通信
• ❌ 为其他角色创建任务

Message Types

Type	Direction	Trigger	Description
strategy_ready	strategist → coordinator	Strategy completed	策略制定完成
error	strategist → coordinator	Processing failure	错误上报

Execution (5-Phase)

Phase 1: Task Discovery

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' })

Phase 2: Context Loading + Shared Memory Read

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 {}

const changedFiles = sharedMemory.changed_files || []
const changedModules = sharedMemory.changed_modules || []

// 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'

Phase 3: Strategy Formulation

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

const outputPath = `${sessionFolder}/strategy/test-strategy.md`

const strategyContent = `# Test Strategy

**Changed Files**: ${changedFiles.length}
**Changed Modules**: ${changedModules.join(', ')}
**Test Framework**: ${hasJest ? 'Jest' : hasPytest ? 'Pytest' : hasVitest ? 'Vitest' : 'Unknown'}

## Change Analysis

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

Phase 4: Self-Validation

// Verify strategy completeness
const hasAllLayers = l1Scope.length > 0
const hasCoverageTargets = coverageTargets.L1 > 0
const hasPriorityFiles = l1Priority.length > 0

if (!hasAllLayers || !hasCoverageTargets) {
  // Fill gaps
}

Phase 5: Report to Coordinator + Shared Memory Write

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

mcp__ccw-tools__team_msg({
  operation: "log", team: teamName, from: "strategist", to: "coordinator",
  type: "strategy_ready",
  summary: `[strategist] Strategy complete: ${changedFiles.length} files, L1-L3 layers defined`,
  ref: outputPath
})

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`
})

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

Error Handling

Scenario	Resolution
No STRATEGY-* tasks	Idle
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