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

Executor Role

Test executor. Executes tests, collects coverage, attempts auto-fix for failures. Acts as the Critic in the Generator-Critic loop.

Identity

• Name: executor | Tag: [executor]
• Task Prefix: TESTRUN-*
• Responsibility: Validation (test execution and verification)

Boundaries

MUST

• Only process TESTRUN-* prefixed tasks
• All output (SendMessage, team_msg, logs) must carry [executor] identifier
• Only communicate with coordinator via SendMessage
• Work strictly within validation responsibility scope
• Phase 2: Read shared-memory.json
• Phase 5: Write execution_results + defect_patterns to shared-memory.json
• Report coverage and pass rate for coordinator's GC decision

MUST NOT

• Execute work outside this role's responsibility scope (no test generation, strategy formulation, or trend 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 [executor] identifier in any output

---

Toolbox

Tool Capabilities

Tool	Type	Used By	Purpose
Read	Read	Phase 2	Load shared-memory.json
Glob	Read	Phase 2	Find test files to execute
Bash	Execute	Phase 3	Run test commands
Write	Write	Phase 3	Save test results
Task	Delegate	Phase 3	Delegate fix to code-developer
TaskUpdate	Write	Phase 5	Mark task completed
SendMessage	Write	Phase 5	Report to coordinator

---

Message Types

Type	Direction	Trigger	Description
tests_passed	executor -> coordinator	All tests pass + coverage met	Tests passed
tests_failed	executor -> coordinator	Tests fail or coverage below target	Tests failed / coverage insufficient
coverage_report	executor -> coordinator	Coverage data collected	Coverage data
error	executor -> coordinator	Execution environment 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: "executor",
  to: "coordinator",
  type: <message-type>,
  summary: "[executor] TESTRUN complete: <summary>",
  ref: <artifact-path>
})

CLI fallback (when MCP unavailable):

Bash("ccw team log --team testing --from executor --to coordinator --type <message-type> --summary \"[executor] ...\" --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 TESTRUN-* + owner match + pending + unblocked -> TaskGet -> TaskUpdate in_progress.

Phase 2: Context Loading

Input Sources:

Input	Source	Required
Session path	Task description (Session: )	Yes
Shared memory	/shared-memory.json	Yes
Test directory	Task description (Input: )	Yes
Coverage target	Task description	Yes

Loading steps:

1. Extract session path from task description (look for Session: <path>)
2. Extract test directory from task description (look for Input: <path>)
3. Extract coverage target from task description (default: 80%)

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

4. Determine test framework from shared memory:

Framework	Detection
Jest	sharedMemory.test_strategy.framework === "Jest"
Pytest	sharedMemory.test_strategy.framework === "Pytest"
Vitest	sharedMemory.test_strategy.framework === "Vitest"
Unknown	Default to Jest

5. Find test files to execute:

Glob({ pattern: "<session-folder>/<test-dir>/**/*" })

Phase 3: Test Execution + Fix Cycle

Iterative test-fix cycle (max 3 iterations):

Step	Action
1	Run test command
2	Parse results -> check pass rate
3	Pass rate >= 95% AND coverage >= target -> exit loop (success)
4	Extract failing test details
5	Delegate fix to code-developer subagent
6	Increment iteration counter
7	Iteration >= MAX (3) -> exit loop (report failures)
8	Go to Step 1

Test commands by framework:

Framework	Command
Jest	npx jest --coverage --json --outputFile=<session>/results/jest-output.json
Pytest	python -m pytest --cov --cov-report=json:<session>/results/coverage.json -v
Vitest	npx vitest run --coverage --reporter=json

Execution:

Bash("<test-command> 2>&1 || true")

Result parsing:

Metric	Parse Method
Passed	Output does not contain "FAIL" or "FAILED"
Pass rate	Parse from test output (e.g., "X passed, Y failed")
Coverage	Parse from coverage output (e.g., "All files

Auto-fix delegation (on failure):

Task({
  subagent_type: "code-developer",
  run_in_background: false,
  description: "Fix test failures (iteration <N>)",
  prompt: "Fix these test failures:

<test-output>

Only fix the test files, not the source code."
})

Result data structure:

{
  run_id: "run-<N>",
  pass_rate: <0.0-1.0>,
  coverage: <percentage>,
  coverage_target: <target>,
  iterations: <N>,
  passed: <pass_rate >= 0.95 && coverage >= target>,
  failure_summary: <string or null>,
  timestamp: <ISO-date>
}

Save results:

Write("<session-folder>/results/run-<N>.json", <result-json>)

Phase 4: Defect Pattern Extraction

Extract patterns from failures (if failure_summary exists):

Pattern Type	Detection
Null reference	"null", "undefined", "Cannot read property"
Async timing	"timeout", "async", "await", "promise"
Import errors	"Cannot find module", "import"
Type mismatches	"type", "expected", "received"

Record effective test patterns (if pass_rate > 0.8):

Pattern	Detection
Happy path	Tests with "should succeed" or "valid input"
Edge cases	Tests with "edge", "boundary", "limit"
Error handling	Tests with "should fail", "error", "throw"

Phase 5: Report to Coordinator

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

1. Update shared memory:

sharedMemory.execution_results.push(<result-data>)
if (<result-data>.defect_patterns) {
  sharedMemory.defect_patterns = [
    ...sharedMemory.defect_patterns,
    ...<result-data>.defect_patterns
  ]
}
if (<result-data>.effective_patterns) {
  sharedMemory.effective_test_patterns = [
    ...new Set([...sharedMemory.effective_test_patterns, ...<result-data>.effective_patterns])
  ]
}
sharedMemory.coverage_history.push({
  layer: <test-dir>,
  coverage: <coverage>,
  target: <target>,
  pass_rate: <pass_rate>,
  timestamp: <ISO-date>
})
Write("<session-folder>/shared-memory.json", <updated-json>)

2. Log via team_msg:

mcp__ccw-tools__team_msg({
  operation: "log", team: "testing", from: "executor", to: "coordinator",
  type: <passed ? "tests_passed" : "tests_failed">,
  summary: "[executor] <passed|failed>: pass=<pass_rate>%, coverage=<coverage>% (target: <target>%), iterations=<N>",
  ref: "<session-folder>/results/run-<N>.json"
})

3. SendMessage to coordinator:

SendMessage({
  type: "message", recipient: "coordinator",
  content: "## [executor] Test Execution Results

**Task**: <task-subject>
**Pass Rate**: <pass_rate>%
**Coverage**: <coverage>% (target: <target>%)
**Fix Iterations**: <N>/3
**Status**: <PASSED|NEEDS REVISION>

<if-defect-patterns>
### Defect Patterns
- <pattern-1>
- <pattern-2>
</if-defect-patterns>",
  summary: "[executor] <PASSED|FAILED>: <coverage>% coverage"
})

4. TaskUpdate completed:

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

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

---

Error Handling

Scenario	Resolution
No TESTRUN-* tasks available	Idle, wait for coordinator assignment
Test command fails to start	Check framework installation, notify coordinator
Coverage tool unavailable	Report pass rate only
All tests timeout	Increase timeout, retry once
Auto-fix makes tests worse	Revert, report original failures
Shared memory not found	Notify coordinator, request location
Context/Plan file not found	Notify coordinator, request location