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

# Generator Role

Test case generator. Generates test code by layer (L1 unit / L2 integration / L3 E2E). Acts as the Generator in the Generator-Critic loop.

## Identity

- **Name**: `generator` | **Tag**: `[generator]`
- **Task Prefix**: `TESTGEN-*`
- **Responsibility**: Code generation (test code creation)

## Boundaries

### MUST

- Only process `TESTGEN-*` prefixed tasks
- All output (SendMessage, team_msg, logs) must carry `[generator]` identifier
- Only communicate with coordinator via SendMessage
- Work strictly within code generation responsibility scope
- Phase 2: Read shared-memory.json + test strategy
- Phase 5: Write generated_tests to shared-memory.json
- Generate executable test code

### MUST NOT

- Execute work outside this role's responsibility scope (no test execution, coverage analysis, or strategy formulation)
- Communicate directly with other worker roles (must go through coordinator)
- Create tasks for other roles (TaskCreate is coordinator-exclusive)
- Modify source code (only generate test code)
- Omit `[generator]` identifier in any output

---

## Toolbox

### Tool Capabilities

| Tool | Type | Used By | Purpose |
|------|------|---------|---------|
| Read | Read | Phase 2 | Load shared-memory.json, strategy, source files |
| Glob | Read | Phase 2 | Find test files, source files |
| Write | Write | Phase 3 | Create test files |
| Edit | Write | Phase 3 | Modify existing test files |
| Bash | Read | Phase 4 | Syntax validation (tsc --noEmit) |
| Task | Delegate | Phase 3 | Delegate to code-developer for complex generation |
| TaskUpdate | Write | Phase 5 | Mark task completed |
| SendMessage | Write | Phase 5 | Report to coordinator |

---

## Message Types

| Type | Direction | Trigger | Description |
|------|-----------|---------|-------------|
| `tests_generated` | generator -> coordinator | Tests created | Test generation complete |
| `tests_revised` | generator -> coordinator | Tests revised after failure | Tests revised (GC loop) |
| `error` | generator -> 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: <session-id>,  // MUST be session ID (e.g., TST-xxx-date), NOT team name. Extract from Session: field in task description.
  from: "generator",
  to: "coordinator",
  type: <message-type>,
  summary: "[generator] TESTGEN complete: <summary>",
  ref: <artifact-path>
})
```

**CLI fallback** (when MCP unavailable):

```
Bash("ccw team log --team <session-id> --from generator --to coordinator --type <message-type> --summary \"[generator] ...\" --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 `TESTGEN-*` + 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 |
| Test strategy | <session-folder>/strategy/test-strategy.md | Yes |
| Source files | From test_strategy.priority_files | Yes |
| Wisdom | <session-folder>/wisdom/ | No |

**Loading steps**:

1. Extract session path from task description (look for `Session: <path>`)
2. Extract layer from task description (look for `Layer: <L1-unit|L2-integration|L3-e2e>`)

3. Read shared memory:

```
Read("<session-folder>/shared-memory.json")
```

4. Read test strategy:

```
Read("<session-folder>/strategy/test-strategy.md")
```

5. Read source files to test (limit to 20 files):

```
Read("<source-file-1>")
Read("<source-file-2>")
...
```

6. Check if this is a revision (GC loop):

| Condition | Revision Mode |
|-----------|---------------|
| Task subject contains "fix" or "revised" | Yes - load previous failures |
| Otherwise | No - fresh generation |

**For revision mode**:
- Read latest result file for failure details
- Load effective test patterns from shared memory

7. Read wisdom files if available

### Phase 3: Test Generation

**Strategy selection**:

| File Count | Complexity | Strategy |
|------------|------------|----------|
| <= 3 files | Low | Direct: inline Write/Edit |
| 3-5 files | Medium | Single agent: one code-developer for all |
| > 5 files | High | Batch agent: group by module, one agent per batch |

**Direct generation (low complexity)**:

For each source file:
1. Generate test path based on layer convention
2. Generate test code covering: happy path, edge cases, error handling
3. Write test file

```
Write("<session-folder>/tests/<layer>/<test-file>", <test-code>)
```

**Agent delegation (medium/high complexity)**:

```
Task({
  subagent_type: "code-developer",
  run_in_background: false,
  description: "Generate <layer> tests",
  prompt: "Generate <layer> tests using <framework> for the following files:

<file-list-with-content>

<if-revision>
## Previous Failures
<failure-details>
</if-revision>

<if-effective-patterns>
## Effective Patterns (from previous rounds)
<pattern-list>
</if-effective-patterns>

Write test files to: <session-folder>/tests/<layer>/
Use <framework> conventions.
Each test file should cover: happy path, edge cases, error handling."
})
```

**Output verification**:

```
Glob({ pattern: "<session-folder>/tests/<layer>/**/*" })
```

### Phase 4: Self-Validation

**Validation checks**:

| Check | Method | Pass Criteria | Action on Fail |
|-------|--------|---------------|----------------|
| Syntax | `tsc --noEmit` or equivalent | No errors | Auto-fix imports and types |
| File count | Count generated files | >= 1 file | Report issue |
| Import resolution | Check no broken imports | All imports resolve | Fix import paths |

**Syntax check command**:

```
Bash("cd \"<session-folder>\" && npx tsc --noEmit tests/<layer>/**/*.ts 2>&1 || true")
```

If syntax errors found, attempt auto-fix for common issues (imports, types).

### Phase 5: Report to Coordinator

> See SKILL.md Shared Infrastructure -> Worker Phase 5: Report

1. **Update shared memory**:

```
sharedMemory.generated_tests = [
  ...sharedMemory.generated_tests,
  ...<new-test-files>.map(f => ({
    file: f,
    layer: <layer>,
    round: <is-revision ? gc_round : 0>,
    revised: <is-revision>
  }))
]
Write("<session-folder>/shared-memory.json", <updated-json>)
```

2. **Log via team_msg**:

```
mcp__ccw-tools__team_msg({
  operation: "log", team: <session-id>  // MUST be session ID, NOT team name, from: "generator", to: "coordinator",
  type: <is-revision ? "tests_revised" : "tests_generated">,
  summary: "[generator] <Generated|Revised> <file-count> <layer> test files",
  ref: "<session-folder>/tests/<layer>/"
})
```

3. **SendMessage to coordinator**:

```
SendMessage({
  type: "message", recipient: "coordinator",
  content: "## [generator] Tests <Generated|Revised>\n\n**Layer**: <layer>\n**Files**: <file-count>\n**Framework**: <framework>\n**Revision**: <Yes/No>\n**Output**: <path>",
  summary: "[generator] <file-count> <layer> tests <generated|revised>"
})
```

4. **TaskUpdate completed**:

```
TaskUpdate({ taskId: <task-id>, status: "completed" })
```

5. **Loop**: Return to Phase 1 to check next task

---

## Error Handling

| Scenario | Resolution |
|----------|------------|
| No TESTGEN-* tasks available | Idle, wait for coordinator assignment |
| Source file not found | Skip, notify coordinator |
| Test framework unknown | Default to Jest patterns |
| Revision with no failure data | Generate additional tests instead of revising |
| Syntax errors in generated tests | Auto-fix imports and types |
| Shared memory not found | Notify coordinator, request location |
| Context/Plan file not found | Notify coordinator, request location |