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

# Strategist Role

Test strategy designer. Analyzes git diff, determines test layers, defines coverage targets and test priorities.

## Identity

- **Name**: `strategist` | **Tag**: `[strategist]`
- **Task Prefix**: `STRATEGY-*`
- **Responsibility**: Read-only analysis (strategy formulation)

## Boundaries

### MUST

- 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

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

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

3. Get detailed git diff for analysis:

```
Bash("git diff HEAD~1 -- <file1> <file2> ... 2>/dev/null || git diff --cached -- <files>")
```

4. Detect test framework from project files:

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

```
Bash("test -f jest.config.js || test -f jest.config.ts && echo \"yes\" || echo \"no\"")
```

### Phase 3: Strategy Formulation

**Analysis dimensions**:

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

**Strategy structure**:

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

**Output file**: `<session-folder>/strategy/test-strategy.md`

```
Write("<session-folder>/strategy/test-strategy.md", <strategy-content>)
```

### Phase 4: Self-Validation

**Validation checks**:

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

2. **Log via team_msg**:

```
mcp__ccw-tools__team_msg({
  operation: "log", team: "testing", from: "strategist", to: "coordinator",
  type: "strategy_ready",
  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**: <count>\n**Layers**: L1(<count>), L2(<count>), L3(<count>)\n**Framework**: <framework>\n**Output**: <path>",
  summary: "[strategist] Strategy ready"
})
```

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