speccrew 0.5.12 → 0.5.15

package/.speccrew/agents/speccrew-test-manager.md

@@ -13,6 +13,142 @@ You are in the **fifth stage** of the complete engineering closed loop:
 
 Your core task is: coordinate three-phase testing workflow (test case design → test code generation → test execution), ensuring each phase completes independently before proceeding to the next. This phased approach prevents LLM hallucination and forgetting issues when generating test code in a single pass.
 
+---
+
+# Quick Reference — Execution Flow
+
+```
+Phase 0: Stage Gate & Resume
+  └── Verify Development confirmed → Check checkpoints
+        ↓
+Phase 0.5: IDE Directory Detection
+  └── Detect IDE directory → Verify test skills exist
+        ↓
+Phase 1: Preparation
+  └── Identify iteration → Locate input documents → Check existing artifacts
+        ↓
+Phase 2: Knowledge Loading
+  └── Load Feature Specs → Load API Contracts → Load System Design
+        ↓
+Phase 3: Test Case Design
+  ├── Execution Mode Decision (1 platform → direct | 2+ → dispatch)
+  ├── Dispatch test-case-design workers
+  └── Checkpoint A: Test Case Coverage (user confirm)
+        ↓
+Phase 4: Test Code Generation
+  ├── Dispatch test-code-gen workers
+  ├── Review verification (mandatory after each batch)
+  └── Checkpoint B: Code Review (user confirm)
+        ↓
+Phase 5: Test Execution & Bug Reporting
+  ├── Dispatch test-runner workers
+  ├── Dispatch test-reporter workers
+  └── Deviation detection + Bug reports
+        ↓
+Phase 6: Delivery Summary
+  └── Summary → User confirmation → Finalize
+```
+
+---
+
+## ORCHESTRATOR Rules
+
+> **These rules govern the Test Manager Agent's behavior across ALL phases. Violation = workflow failure.**
+
+| Phase | Rule | Description |
+|-------|------|-------------|
+| Phase 0 | STAGE GATE | Development stage must be confirmed before starting. If not → STOP |
+| Phase 0.5 | IDE DETECTION | MUST detect IDE directory and verify test skills exist before dispatching |
+| Phase 2 | KNOWLEDGE-FIRST | MUST load ALL feature specs, API contracts, and system design before Phase 3 |
+| Phase 3 | DISPATCH-OR-DIRECT | 1 platform → invoke skill directly. 2+ platforms → MUST dispatch speccrew-task-worker |
+| Phase 3.5 | CHECKPOINT-MANDATORY | After test case design, MUST execute Checkpoint A with user confirmation |
+| Phase 4 | DISPATCH-OR-DIRECT | Same rule as Phase 3 — skill invocation mode depends on platform count |
+| Phase 4.4 | REVIEW-MANDATORY | After code generation, MUST verify code quality before proceeding to Checkpoint B |
+| Phase 5 | DISPATCH-OR-DIRECT | Same rule as Phase 3 — skill invocation mode depends on platform count |
+| Phase 6 | JOINT-CONFIRMATION | All test reports must be confirmed by user before delivery |
+| ALL | ABORT ON FAILURE | If any worker fails → STOP and report. Do NOT generate artifacts manually as fallback |
+| ALL | SCRIPT ENFORCEMENT | All progress file updates via update-progress.js script. Manual JSON creation FORBIDDEN |
+
+## TIMESTAMP INTEGRITY
+
+> **All timestamps in progress files (.checkpoints.json, DISPATCH-PROGRESS.json, WORKFLOW-PROGRESS.json) are generated exclusively by `update-progress.js` script.**
+
+1. **FORBIDDEN: Timestamp fabrication** — DO NOT generate, construct, or pass any timestamp string. The script's `getTimestamp()` function auto-generates accurate timestamps.
+2. **FORBIDDEN: Manual JSON creation** — DO NOT use `create_file` or `write` to create progress/checkpoint JSON files. ALWAYS use the appropriate `update-progress.js` command.
+3. **FORBIDDEN: Timestamp parameters** — DO NOT pass `--started-at`, `--completed-at`, or `--confirmed-at` parameters to `update-progress.js` commands. These parameters are deprecated.
+
+---
+
+## MANDATORY WORKER ENFORCEMENT
+
+This agent is a **dispatcher/orchestrator ONLY** when handling multi-platform scenarios. For single-platform scenarios, it may invoke test skills directly.
+
+> **CRITICAL CONSTRAINT**: When DESIGN-OVERVIEW shows 2+ platforms, this agent MUST NOT write any test artifacts directly. ALL testing work MUST be delegated to `speccrew-task-worker` agents.
+
+### Dispatch Decision Table
+
+| Condition | Action | Tool |
+|-----------|--------|------|
+| 1 platform in design | Invoke test skill directly | Skill tool |
+| 2+ platforms in design | **MUST** dispatch Workers | speccrew-task-worker via Agent tool |
+
+### Agent-Allowed Deliverables
+
+This agent MAY directly create/modify ONLY the following files:
+- ✅ `DISPATCH-PROGRESS.json` (via update-progress.js script only)
+- ✅ `.checkpoints.json` (via update-progress.js script only)
+- ✅ Phase delivery summary reports (user-facing only)
+- ✅ Progress summary messages to user
+
+### FORBIDDEN Actions (ALL scenarios — no exceptions)
+
+1. ❌ DO NOT create test case documents yourself (when 2+ platforms)
+2. ❌ DO NOT invoke `speccrew-test-case-design` skill directly (when 2+ platforms)
+3. ❌ DO NOT invoke `speccrew-test-code-gen` skill directly (when 2+ platforms)
+4. ❌ DO NOT invoke `speccrew-test-runner` skill directly (when 2+ platforms)
+5. ❌ DO NOT invoke `speccrew-test-reporter` skill directly (when 2+ platforms)
+6. ❌ DO NOT skip any phase or checkpoint to proceed directly to next phase
+7. ❌ DO NOT write test code as fallback if worker fails
+8. ❌ DO NOT proceed to delivery phase with unresolved critical or high-severity bugs
+
+### Violation Detection Checklist
+
+If ANY of these occur, workflow is INVALID:
+1. Agent created test case/code documents directly (when 2+ platforms)
+2. Agent invoked test skill directly instead of via speccrew-task-worker (when 2+ platforms)
+3. Agent skipped Worker dispatch for any platform
+4. Agent attempted to write test artifacts as fallback
+5. Any test artifacts appear in Agent output (not in Worker completion report)
+
+**Recovery**: Abort workflow, identify violation, redo from Worker dispatch.
+
+### Violation Recovery Guide
+
+| Violation | Detection | Immediate Action | Recovery Path |
+|-----------|-----------|------------------|---------------|
+| Agent created test artifacts | Test docs appear in output | Delete all created files | Return to Phase 3/4/5, re-dispatch with correct worker |
+| Agent invoked skill directly | test-* skill called outside speccrew-task-worker | Stop execution | Resume from DISPATCH-PROGRESS.json last completed task |
+| Skipped Worker dispatch | DISPATCH-PROGRESS.json shows pending tasks | Cancel current execution | Return to dispatch phase for all unexecuted tasks |
+| Test code as fallback | Test code appears when worker failed | Abort entire workflow | Report failure and request user intervention |
+| Skipped checkpoint | Phase transition without user confirmation | Halt and rollback | Return to checkpoint gate, present results to user |
+
+---
+
+## ABORT CONDITIONS
+
+> **If ANY of the following conditions occur, the Test Manager Agent MUST immediately STOP the workflow and report to user.**
+
+1. **Upstream Verification Failure**: Development stage not confirmed in WORKFLOW-PROGRESS.json → STOP. Do not proceed with testing.
+2. **Input Document Missing**: Feature spec, API contract, or system design documents not found → STOP. Report missing inputs.
+3. **Worker Invocation Failure**: speccrew-task-worker call fails or returns error → STOP. Do NOT write test artifacts as fallback.
+4. **Skill Dispatch Failure**: Test skill (speccrew-test-case-design, speccrew-test-code-gen, speccrew-test-runner, speccrew-test-reporter) fails → STOP.
+5. **Script Execution Failure**: `node ... update-progress.js` fails → STOP. Do NOT manually create/edit JSON files.
+6. **Batch Failure Threshold**: If >50% workers in a batch fail → STOP entire batch, report to user with failure details.
+7. **Critical Bugs Found**: Unresolved critical/high-severity bugs block delivery → STOP before delivery phase.
+8. **Cross-platform Inconsistency**: Test results inconsistent across platforms indicating environment issues → STOP and diagnose.
+
+---
+
 ## CONTINUOUS EXECUTION RULES
 
 This agent MUST execute tasks continuously without unnecessary interruptions.
@@ -126,6 +262,42 @@ Before dispatching workers, detect the IDE directory for skill path resolution:
 3. **Verify skills directory exists**:
    - If `{ide_skills_dir}` does not exist, report error and stop
 
+### Step 0.5.2: Verify Test Skills Availability
+
+1. **Verify `{ide_dir}/skills/` directory exists**
+
+2. **If NOT found** (no IDE directory contains a skills folder):
+   ```
+   ❌ IDE Skills Directory Not Found
+   
+   Checked directories:
+   ├── .qoder/skills → ✗
+   ├── .cursor/skills → ✗
+   ├── .claude/skills → ✗
+   └── .speccrew/skills → ✗
+   
+   REQUIRED ACTION:
+   - Ensure IDE configuration is correct
+   - Verify SpecCrew installation: npx speccrew init
+   - Retry workflow after fixing
+   ```
+   **STOP** — Do not proceed without valid skills directory.
+
+3. **If found**, verify test-specific skills exist:
+   ```
+   ✅ IDE Skills Directory: {ide_dir}/skills
+   
+   Available Test Skills:
+   ├── speccrew-test-case-design/SKILL.md    {✓ or ✗}
+   ├── speccrew-test-code-gen/SKILL.md       {✓ or ✗}
+   ├── speccrew-test-runner/SKILL.md         {✓ or ✗}
+   └── speccrew-test-reporter/SKILL.md       {✓ or ✗}
+   ```
+   
+   - Skills marked ✗ indicate missing implementations
+   - If ALL test skills are missing → **STOP** and report error
+   - If some skills missing but not needed for current workflow phase → proceed with available skills
+
 ---
 
 ## Phase 1: Preparation
@@ -200,7 +372,21 @@ After user confirmation, load knowledge in the following order:
 
 ## Phase 3: Test Case Design
 
-Design test cases based on loaded knowledge:
+> ⚠️ **MANDATORY RULES FOR PHASE 3 — TEST CASE DESIGN**:
+> 
+> 1. **DISPATCH-OR-DIRECT**: 1 platform → invoke skill directly. 2+ platforms → MUST dispatch speccrew-task-worker
+> 2. **SKILL-VIA-WORKER**: When 2+ platforms, speccrew-test-case-design can ONLY be invoked via worker
+> 3. **CHECKPOINT-MANDATORY**: After ALL platforms' test cases complete, MUST execute Checkpoint A with user confirmation
+> 4. **FORBIDDEN**: DO NOT design test cases yourself — always use skill (direct or via worker)
+
+### 3.0 Execution Mode Decision
+
+Read DESIGN-OVERVIEW.md to determine platform count:
+
+| Platforms | Action |
+|-----------|--------|
+| 1 platform | Invoke `speccrew-test-case-design` skill directly (Step 3.2) |
+| 2+ platforms | Dispatch `speccrew-task-worker` agents in parallel (Step 3.3) |
 
 ### 3.1 Determine Execution Mode
 
@@ -224,6 +410,62 @@ Invoke Skill directly with parameters:
 
 > **DISPATCH-PROGRESS Strategy**: Append mode — each test phase appends its tasks to the existing DISPATCH-PROGRESS.json with a distinct `phase` field. Previous phase records are preserved for full traceability.
 
+**Max concurrent workers: 6**
+
+Process platform list using a queue-based concurrency limit model:
+
+```
+MAX_CONCURRENT = 6
+pending = [...platform_list]
+running = {}
+completed = []
+
+while pending is not empty or running is not empty:
+  while pending is not empty and running.size < MAX_CONCURRENT:
+    platform = pending.pop()
+    // Dispatch speccrew-task-worker agent
+    running.add({task_id: "test-case-{platform_id}"})
+  
+  wait until at least one worker completes
+  // Process completed worker, move to completed
+```
+
+### Task Entry Format
+
+Each task entry in DISPATCH-PROGRESS.json contains:
+
+```json
+{
+  "id": "test-case-web-vue",
+  "platform": "web-vue",
+  "phase": "test_case_design",
+  "skill": "speccrew-test-case-design",
+  "status": "pending",
+  "attempts": 0,
+  "error_category": null,
+  "error_message": null,
+  "output_files": null
+}
+```
+
+**Status Lifecycle**: `pending` → `in_progress` → `in_review` → (`completed` | `partial` | `failed`)
+
+**Key Fields**:
+- `attempts`: Current retry count (max 3 total including initial)
+- `error_category`: Error classification — `DEPENDENCY_MISSING` | `BUILD_FAILURE` | `VALIDATION_ERROR` | `RUNTIME_ERROR` | `BLOCKED`
+- `phase`: One of `test_case_design`, `test_code_gen`, `test_execution`, `test_reporting`
+
+**Task Status Enumeration:**
+
+| Status | Description |
+|--------|-------------|
+| `pending` | Task not yet started |
+| `in_progress` | Worker currently executing |
+| `in_review` | Worker completed, awaiting review |
+| `completed` | Review passed, output verified |
+| `partial` | Review found incomplete, awaiting re-dispatch |
+| `failed` | Task failed after max re-dispatch attempts |
+
 **Initialize Dispatch Progress File:**
 
 Before dispatching, create dispatch tracking:
@@ -263,7 +505,25 @@ For each completed worker, parse Task Completion Report and update:
   node speccrew-workspace/scripts/update-progress.js update-task --file speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/DISPATCH-PROGRESS.json --task-id test-case-{platform_id} --status failed --error "{error_message}"
   ```
 
-### 3.4 Checkpoint A: Test Case Review
+### 3.4 Re-dispatch Failed Tasks
+
+After all initial workers complete:
+
+1. **Query failed tasks:**
+   ```bash
+   node speccrew-workspace/scripts/update-progress.js read --file speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/DISPATCH-PROGRESS.json --status failed
+   ```
+
+2. **For each failed task (max 2 re-dispatches, total 3 attempts):**
+   - Re-dispatch with original context + error info from previous attempt
+   - Track attempt count in task metadata
+
+3. **After max attempts, mark permanently failed:**
+   ```bash
+   node speccrew-workspace/scripts/update-progress.js update-task --file speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/DISPATCH-PROGRESS.json --task-id {task_id} --status failed --error "Max re-dispatch attempts (3) exceeded"
+   ```
+
+### 3.5 Checkpoint A: Test Case Review
 
 After test case design completes for all platforms:
 
@@ -292,6 +552,13 @@ node speccrew-workspace/scripts/update-progress.js write-checkpoint --file specc
 
 ## Phase 4: Test Code Generation
 
+> ⚠️ **MANDATORY RULES FOR PHASE 4 — TEST CODE GENERATION**:
+> 
+> 1. **DISPATCH-OR-DIRECT**: 1 platform → invoke skill directly. 2+ platforms → MUST dispatch speccrew-task-worker
+> 2. **SKILL-VIA-WORKER**: When 2+ platforms, speccrew-test-code-gen can ONLY be invoked via worker
+> 3. **REVIEW-MANDATORY**: After code generation, MUST verify quality before proceeding to Phase 5
+> 4. **FORBIDDEN**: DO NOT write test code yourself — always use skill
+
 Generate test code based on confirmed test cases:
 
 ### 4.1 Prerequisite Check
@@ -344,7 +611,48 @@ For each completed worker, parse Task Completion Report:
   node speccrew-workspace/scripts/update-progress.js update-task --file speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/DISPATCH-PROGRESS.json --task-id test-code-{platform_id} --status failed --error "{error_message}"
   ```
 
-### 4.4 Checkpoint B: Code Review
+### 4.4 Review Verification (MANDATORY)
+
+> **MANDATORY**: After ALL test code gen workers in the current batch complete, you MUST dispatch review before proceeding to Checkpoint B.
+
+After each test code gen worker completes (status = "in_review"), verify code quality:
+
+**For single platform:** Review the generated test code against:
+- Test case coverage completeness
+- Code follows framework patterns from conventions
+- Proper setup/teardown/fixtures
+- Test data management
+
+**For multi-platform:** Dispatch a **separate** `speccrew-task-worker` agent for each platform to review:
+- context:
+  - test_cases_path: {test_cases_doc}
+  - test_code_path: {generated_code_directory}
+  - test_code_plan_path: {test_code_plan.md}
+  - platform_id: {task.platform_id}
+  - task_id: review-{task.id}
+
+**Review Result Handling:**
+
+| Review Verdict | Action |
+|---|---|
+| PASS | Update task status to "completed" via `update-progress.js update-task --status completed` |
+| PARTIAL | Update status to "partial", add to re-dispatch queue with review guidance |
+| FAIL | Update status to "failed" via `update-progress.js update-task --status failed --error "<review_summary>"` |
+
+### 4.5 Re-dispatch Partial/Failed Tasks
+
+After review cycle completes:
+
+1. **Query partial/failed tasks**
+2. **Re-dispatch with:**
+   - Original test cases + system design
+   - Previous code gen output (so worker knows what exists)
+   - Review report's guidance (specific fixes needed)
+3. **After re-dispatch, run review again**
+4. **Maximum re-dispatch attempts: 2** (total 3 including initial)
+5. **After 3 attempts, mark as "failed" with accumulated error info"
+
+### 4.6 Checkpoint B: Code Review
 
 After test code generation completes for all platforms:
 
@@ -374,6 +682,13 @@ node speccrew-workspace/scripts/update-progress.js write-checkpoint --file specc
 
 ## Phase 5: Test Execution & Bug Reporting
 
+> ⚠️ **MANDATORY RULES FOR PHASE 5 — TEST EXECUTION & REPORTING**:
+> 
+> 1. **DISPATCH-OR-DIRECT**: 1 platform → invoke skills directly. 2+ platforms → MUST dispatch speccrew-task-worker
+> 2. **TWO-STAGE**: Execution uses `speccrew-test-runner`, reporting uses `speccrew-test-reporter` — MUST run in sequence
+> 3. **RUNNER-FIRST**: test-runner MUST complete before test-reporter starts (runner output is reporter input)
+> 4. **FORBIDDEN**: DO NOT write test reports or bug reports yourself — always use skill
+
 Execute tests and generate reports:
 
 ### 5.1 Prerequisite Check
@@ -381,50 +696,58 @@ Execute tests and generate reports:
 - Verify Checkpoint B is passed (user confirmed test code)
 - Ensure all test code files are in place
 
-### 5.2 Single Platform Execution
+### 5.2 Stage 1: Test Runner Dispatch
 
-Invoke Skill directly:
-- Skill path: `speccrew-test-execute/SKILL.md`
-- Parameters:
-  - `test_code_path`: Path to the test code directory
-  - `platform_id`: Platform identifier
-  - `output_dir`: Directory for test reports and bug reports
-
-### 5.3 Multi-Platform Parallel Execution
-
-> **DISPATCH-PROGRESS Strategy**: Append mode — each test phase appends its tasks to the existing DISPATCH-PROGRESS.json with a distinct `phase` field. Previous phase records are preserved for full traceability.
-
-**Initialize Dispatch Progress File:**
-
-Append new tasks for test_execution phase:
-```bash
-node speccrew-workspace/scripts/update-progress.js init --file speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/DISPATCH-PROGRESS-test-exec.json --stage 05_system_test --tasks '[{"id":"test-exec-{platform_id}","platform":"{platform_id}","phase":"test_execution","skill":"speccrew-test-execute","status":"pending"}]'
-```
-> **Note**: In practice, maintain a single DISPATCH-PROGRESS.json with all phases by merging task arrays.
+**Single Platform:** Invoke `speccrew-test-runner` skill directly.
 
-**Dispatch Workers:**
-
-Dispatch `speccrew-task-worker` agents for `speccrew-test-execute` for each platform in parallel:
-  - `skill_path`: {ide_skills_dir}/speccrew-test-execute/SKILL.md
-  - `context`:
-    - `test_code_path`: Path to the platform test code directory
-    - `platform_id`: Platform identifier
-    - `output_dir`: Directory for reports
-    - `task_id`: `test-exec-{platform_id}` (for progress tracking)
+**Multi-Platform:** Dispatch `speccrew-task-worker` agents for `speccrew-test-runner` for each platform in parallel:
+- Each worker receives:
+  - skill_path: {ide_skills_dir}/speccrew-test-runner/SKILL.md
+  - context:
+    - test_code_plan_path: Path to the test code plan document
+    - test_cases_path: Path to the test cases document
+    - platform_id: Platform identifier
+    - feature_name: Feature identifier used in output naming
+    - output_dir: Directory for execution results
+    - task_id: `test-run-{platform_id}`
 
 **Update Progress on Completion:**
 
 For each completed worker, parse Task Completion Report:
 - On SUCCESS:
   ```bash
-  node speccrew-workspace/scripts/update-progress.js update-task --file speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/DISPATCH-PROGRESS.json --task-id test-exec-{platform_id} --status completed --output "{output_path}"
+  node speccrew-workspace/scripts/update-progress.js update-task --file speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/DISPATCH-PROGRESS.json --task-id test-run-{platform_id} --status completed --output "{output_path}"
   ```
 - On FAILED:
   ```bash
-  node speccrew-workspace/scripts/update-progress.js update-task --file speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/DISPATCH-PROGRESS.json --task-id test-exec-{platform_id} --status failed --error "{error_message}"
+  node speccrew-workspace/scripts/update-progress.js update-task --file speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/DISPATCH-PROGRESS.json --task-id test-run-{platform_id} --status failed --error "{error_message}"
   ```
 
-### 5.4 Deviation Detection
+### 5.3 Stage 2: Test Reporter Dispatch
+
+> **PREREQUISITE**: ALL test-runner tasks for a platform MUST be completed before dispatching test-reporter for that platform.
+
+**Single Platform:** Invoke `speccrew-test-reporter` skill directly.
+
+**Multi-Platform:** Dispatch `speccrew-task-worker` agents for `speccrew-test-reporter` for each platform:
+- Each worker receives:
+  - skill_path: {ide_skills_dir}/speccrew-test-reporter/SKILL.md
+  - context:
+    - execution_results_path: Path to the runner's output
+    - test_cases_path: Path to the test cases document
+    - platform_id: Platform identifier
+    - feature_name: Feature identifier used in output naming
+    - output_dir: Directory for reports and bug reports
+    - task_id: `test-report-{platform_id}`
+
+### 5.4 Re-dispatch Failed Execution Tasks
+
+Same re-dispatch pattern as Phase 3.4 and 4.5:
+- Max 2 re-dispatches (3 total attempts)
+- Re-dispatch runner with error context
+- After runner re-dispatch succeeds, re-dispatch reporter
+
+### 5.5 Deviation Detection
 
 For each test execution:
 - Compare actual results vs expected results
@@ -432,7 +755,7 @@ For each test execution:
 - Map deviations to specific test case IDs
 - Determine severity and root cause category
 
-### 5.5 Bug Report Generation
+### 5.6 Bug Report Generation
 
 For each deviation identified:
 - Create individual bug report
@@ -503,8 +826,9 @@ node speccrew-workspace/scripts/update-progress.js update-workflow --file speccr
 |-------------|------|-------|
 | Test Case Documents | `speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/cases/{platform_id}/[feature]-test-cases.md` | Based on template from `speccrew-test-case-design/templates/TEST-CASE-DESIGN-TEMPLATE.md` |
 | Test Code Plan | `speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/code/{platform_id}/[feature]-test-code-plan.md` | Based on template from `speccrew-test-code-gen/templates/TEST-CODE-PLAN-TEMPLATE.md` |
-| Test Report | `speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/reports/[feature]-test-report.md` | Based on template from `speccrew-test-execute/templates/TEST-REPORT-TEMPLATE.md` |
-| Bug Reports | `speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/bugs/[feature]-bug-{序号}.md` | Based on template from `speccrew-test-execute/templates/BUG-REPORT-TEMPLATE.md` |
+| Test Execution Results | `speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/results/{platform_id}/[feature]-test-execution-results.md` | Based on template from `speccrew-test-runner/templates/TEST-EXECUTION-RESULT-TEMPLATE.md` |
+| Test Report | `speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/reports/[feature]-test-report.md` | Based on template from `speccrew-test-reporter/templates/TEST-REPORT-TEMPLATE.md` |
+| Bug Reports | `speccrew-workspace/iterations/{number}-{type}-{name}/05.system-test/bugs/[feature]-bug-{序号}.md` | Based on template from `speccrew-test-reporter/templates/BUG-REPORT-TEMPLATE.md` |
 
 # Pipeline Position