maestro-flow 0.3.46 → 0.3.48

package/.codex/skills/quality-auto-test/SKILL.md

@@ -6,320 +6,157 @@ allowed-tools: spawn_agents_on_csv, Read, Write, Edit, Bash, Glob, Grep, AskUser
 ---
 
 <purpose>
-Unified automated testing using `spawn_agents_on_csv` for parallel test writing and failure diagnosis. Reads project state to auto-select scenario source (PRD specs, coverage gaps, or code exploration). All sources converge into a shared CSV pipeline: discover infrastructure → plan → write tests via CSV parallel → execute per layer → diagnose failures via CSV parallel → iterate → report.
+CSV-parallel automated testing pipeline via `spawn_agents_on_csv`.
+Route -> Source Scenarios -> Write Tests (parallel per layer) -> Execute (L0->L3 sequential) -> Diagnose Failures (parallel) -> Iterate -> Report.
 
-**Core workflow**: Route → Source Scenarios → Build CSV → Layer-by-Layer Parallel Execution → Iterate (Diagnose CSV) → Report
-
-**Topology**: Layers as waves (L0→L1→L2→L3 sequential, scenarios within layer parallel)
-
-```
-+---------------------------------------------------------------------------+
-|                    AUTO-TEST CSV LAYER PIPELINE                            |
-+---------------------------------------------------------------------------+
-|                                                                           |
-|  Phase 1: Route & Plan -> CSV                                             |
-|     +-- Read project state, auto-select route (spec/gap/code)             |
-|     +-- Extract scenarios per route, normalize to unified format          |
-|     +-- Discover test infrastructure (framework, patterns)                |
-|     +-- Build scenarios.csv with one row per scenario                     |
-|     +-- Layers = waves (L1, L2, L3 sequential; L0 = static pre-check)    |
-|     +-- User validates test plan (skip if -y)                             |
-|                                                                           |
-|  Phase 2: Layer Execution Engine (write + run)                            |
-|     +-- L0: Static analysis (tsc + eslint) — no CSV needed               |
-|     +-- For each layer L1→L3 (sequential, fail-fast on critical):         |
-|     |   +-- Layer N: Write Tests (parallel via spawn_agents_on_csv)       |
-|     |   |   +-- Each agent writes one test file (RED-GREEN)               |
-|     |   |   +-- Agent reads target source + infrastructure patterns       |
-|     |   |   +-- Agent verifies RED (run test, check it targets behavior)  |
-|     |   |   +-- Results: test_file written, red_result, findings          |
-|     |   +-- Merge write-results into master scenarios.csv                 |
-|     |   +-- Run all layer tests together (full layer execution)           |
-|     |   +-- Record per-scenario pass/fail results                         |
-|                                                                           |
-|  Phase 3: Iteration Engine (diagnose + fix)                               |
-|     +-- OUTER LOOP (max_iter iterations):                                 |
-|     |   +-- For each layer with failures:                                 |
-|     |   |   +-- Build diagnosis.csv from failed scenarios                 |
-|     |   |   +-- Diagnose & Fix (parallel via spawn_agents_on_csv)         |
-|     |   |   |   +-- Each agent classifies one failure cluster             |
-|     |   |   |   +-- test_defect: agent provides fix diff                  |
-|     |   |   |   +-- code_defect: agent documents evidence                 |
-|     |   |   +-- Apply test_defect fixes, re-run layer                     |
-|     |   +-- Reflect: analyze trends, log strategy                         |
-|     |   +-- Adjust: select next strategy (conservative/aggressive/...)    |
-|     |   +-- Convergence check: >=95% → done                              |
-|     +-- discoveries.ndjson shared across all iterations                   |
-|                                                                           |
-|  Phase 4: Results & Routing                                               |
-|     +-- Export results.csv                                                |
-|     +-- Write report.json, state.json, reflection-log.md                  |
-|     +-- Conditional: traceability.md, issue creation                      |
-|     +-- Route to next step based on convergence                           |
-|                                                                           |
-+---------------------------------------------------------------------------+
-```
+Topology: layers as waves (L0->L1->L2->L3 sequential, scenarios within layer parallel).
 </purpose>
 
 <context>
-```bash
-$quality-auto-test "3"                    # auto-detect source, full iteration
-$quality-auto-test -c 4 "3"              # max 4 concurrent test writers per layer
-$quality-auto-test -y "3 --max-iter 1"   # single-pass generation only
-$quality-auto-test "3 --dry-run"          # plan only, no execution
-$quality-auto-test "3 --re-run"           # re-run only previously failed scenarios
-$quality-auto-test "3 --layer L2"         # restrict to L2 integration tests
-```
+$ARGUMENTS -- phase number and optional flags.
 
 **Flags**:
 - `-y, --yes`: Skip all confirmations
-- `-c, --concurrency N`: Max concurrent agents within each layer (default: 5)
-- `--max-iter N`: Max outer iterations (default 5). **1 = single-pass** generation only
-- `--layer L`: Start from or restrict to specific layer (L0|L1|L2|L3)
-- `--strategy conservative|aggressive|surgical|reflective`: Override starting iteration strategy (default: auto-selected)
-- `--dry-run`: Generate test plan only, do not execute
+- `-c, --concurrency N`: Max concurrent agents per layer (default: 5)
+- `--max-iter N`: Max outer iterations (default: 5; 1 = single-pass)
+- `--layer L`: Restrict to specific layer (L0|L1|L2|L3)
+- `--strategy conservative|aggressive|surgical|reflective`: Override starting strategy
+- `--dry-run`: Generate test plan only, no execution
 - `--re-run`: Re-run only previously failed/blocked scenarios
 
-**Intelligent routing** (auto-detected, priority order):
+**Intelligent routing** (auto-detected):
 
 | Priority | Condition | Route |
 |----------|-----------|-------|
-| 1 | Active session (state.json status=running) | Resume |
-| 2 | --re-run flag + previous failures | Re-run |
-| 3 | Spec package exists (REQ-*.md) | spec (PRD-forward) |
-| 4 | Nyquist gaps exist (verification.json) | gap (coverage-forward) |
+| 1 | Active session (state.json running) | Resume |
+| 2 | --re-run + previous failures | Re-run |
+| 3 | REQ-*.md exists | spec (PRD-forward) |
+| 4 | verification.json has gaps | gap (coverage-forward) |
 | 5 | Default | code (exploration-forward) |
 
-**Session Directory**: `.tests/auto-test/.csv-session/`
-**Core Output**: `scenarios.csv` (master state) + `results.csv` (final) + `discoveries.ndjson` (shared) + `report.json` + `state.json`
+**Session**: `.tests/auto-test/.csv-session/`
+**Output**: scenarios.csv, results.csv, discoveries.ndjson, report.json, state.json, reflection-log.md
 </context>
 
 <csv_schema>
 
-### scenarios.csv (Master State — Test Writing Phase)
+### scenarios.csv (Test Writing Phase)
 
 ```csv
 id,name,layer,priority,category,target_file,test_file,description,test_cases,fixtures,req_ref,infrastructure_hints,prev_context,status,red_result,findings,error
-"AT-001","Auth token validation","L1","critical","api_contract","src/auth/token.ts","src/auth/__tests__/token.test.ts","Validate JWT token verification returns correct payload","verify valid token returns payload;verify expired token throws;verify malformed token throws","valid_token fixture;expired_token fixture","REQ-001:AC-1","vitest;describe/it pattern;see src/utils/__tests__/hash.test.ts","","","","",""
-"AT-002","Login endpoint integration","L2","high","business_rule","src/routes/login.ts","src/routes/__tests__/login.integration.test.ts","POST /api/login returns JWT on valid credentials","valid login returns 200+token;invalid password returns 401;missing email returns 400","user_fixture;credentials_fixture","REQ-002:AC-1","supertest;see src/routes/__tests__/health.test.ts","AT-001 findings: token module exports verifyToken/generateToken","","","",""
+"AT-001","Auth token validation","L1","critical","api_contract","src/auth/token.ts","src/auth/__tests__/token.test.ts","Validate JWT verification","verify valid;verify expired;verify malformed","valid_token;expired_token","REQ-001:AC-1","vitest;describe/it;see hash.test.ts","","","","",""
 ```
 
-**Columns**:
-
-| Column | Phase | Description |
-|--------|-------|-------------|
-| `id` | Input | Scenario ID (AT-NNN format) |
-| `name` | Input | Short scenario name |
-| `layer` | Input | L1/L2/L3 (determines wave order) |
-| `priority` | Input | critical/high/medium |
-| `category` | Input | api_contract/business_rule/state_transition/user_flow/... |
-| `target_file` | Input | Source file being tested |
-| `test_file` | Input | Target test file path to create |
-| `description` | Input | What this scenario validates |
-| `test_cases` | Input | Semicolon-separated test cases |
-| `fixtures` | Input | Required fixtures/mocks (semicolon-separated) |
-| `req_ref` | Input | Requirement reference (REQ-NNN:AC-N or gap-id or empty) |
-| `infrastructure_hints` | Input | Framework + pattern references from Step 3 |
-| `prev_context` | Computed | Findings from prior layer scenarios (cross-layer propagation) |
-| `status` | Output | pending → written → passed → failed → blocked |
-| `red_result` | Output | expected_fail / unexpected_fail / pass (RED phase result) |
-| `findings` | Output | Implementation notes, patterns discovered (max 500 chars) |
-| `error` | Output | Error message if failed |
-
-### diagnosis.csv (Iteration Phase — Failure Diagnosis)
+**scenarios.csv column semantics**:
+- Input: id (AT-NNN), name, layer (L1/L2/L3 = wave order), priority (critical/high/medium), category (api_contract/business_rule/state_transition/user_flow/...), target_file (source file tested), test_file (test file path to create), description (what scenario validates), test_cases (semicolon-sep, each -> one it() block), fixtures (required mocks/fixtures, semicolon-sep), req_ref (REQ-NNN:AC-N or gap-id or empty), infrastructure_hints (framework + pattern refs from infra discovery)
+- Computed: prev_context (findings from prior layer scenarios, cross-layer propagation)
+- Output: status (pending->written->passed->failed->blocked), red_result (expected_fail/unexpected_fail/pass), findings (patterns discovered, notes for dependents, max 500 chars), error
+
+### diagnosis.csv (Iteration Phase)
 
 ```csv
 id,scenario_id,layer,test_file,error_detail,expected,actual,target_file,source_context,classification,fix_code,evidence,error
-"DX-001","AT-003","L1","src/auth/__tests__/token.test.ts","TypeError: verifyToken is not a function","verifyToken returns decoded payload","Function not exported from module","src/auth/token.ts","token.ts exports: generateToken only","test_defect","import { verifyToken } from '../token' → import { verifyToken } from '../verify-token'","src/auth/verify-token.ts:15 exports verifyToken",""
-"DX-002","AT-005","L2","src/routes/__tests__/login.test.ts","Expected 200, received 500","POST /login returns 200 with valid credentials","Internal server error: database connection refused","src/routes/login.ts","login.ts calls UserModel.findByEmail","env_issue","","Database not available in test environment",""
+"DX-001","AT-003","L1","token.test.ts","TypeError: not a function","verifyToken returns payload","Not exported","token.ts","exports: generateToken only","test_defect","fix import path","verify-token.ts:15",""
 ```
 
-**Columns**:
-
-| Column | Phase | Description |
-|--------|-------|-------------|
-| `id` | Input | Diagnosis ID (DX-NNN) |
-| `scenario_id` | Input | Reference to AT-NNN scenario |
-| `layer` | Input | Layer where failure occurred |
-| `test_file` | Input | Test file that failed |
-| `error_detail` | Input | Full error message/stack trace excerpt |
-| `expected` | Input | Expected behavior from scenario |
-| `actual` | Input | Actual behavior observed |
-| `target_file` | Input | Source file being tested |
-| `source_context` | Input | Relevant source code context (exports, imports) |
-| `classification` | Output | test_defect / code_defect / env_issue |
-| `fix_code` | Output | Fix diff for test_defect (old → new) |
-| `evidence` | Output | file:line references for diagnosis |
-| `error` | Output | Agent error if diagnosis failed |
-
-### Session Structure
-
-```
-.tests/auto-test/.csv-session/
-+-- scenarios.csv           (master state)
-+-- results.csv             (final export)
-+-- discoveries.ndjson      (shared across iterations)
-+-- layer-L{N}-write.csv    (temporary, per-layer write input)
-+-- layer-L{N}-write-results.csv
-+-- diagnosis-iter-{N}.csv  (temporary, per-iteration diagnosis)
-+-- diagnosis-iter-{N}-results.csv
-```
+**diagnosis.csv column semantics**:
+- Input: id (DX-NNN), scenario_id (ref to AT-NNN), layer, test_file, error_detail (full error/stack excerpt), expected (from scenario), actual (observed behavior), target_file, source_context (relevant code: exports, imports)
+- Output: classification (test_defect/code_defect/env_issue), fix_code (for test_defect: "old → new" or full replacement; empty for code_defect/env_issue), evidence (file:line references), error
 </csv_schema>
 
 <invariants>
-1. **Start Immediately**: First action is session initialization
-2. **Layer Order is Sacred**: Never execute L(N+1) before L(N) completes (fail-fast on critical)
-3. **CSV is Source of Truth**: Master scenarios.csv holds all test execution state
-4. **Context Propagation**: prev_context built from prior-layer findings in CSV, not memory
-5. **Discovery Board Append-Only**: Never clear or modify discoveries.ndjson
-6. **Route Auto-Detected**: Read state, never ask user for mode
-7. **RED-GREEN Methodology**: Tests target real behavior; failing test = bug discovery (never fix source)
-8. **Max 3 Inner Fix Attempts**: Per layer, fix test_defects up to 3 times via diagnosis CSV
-9. **Convergence Threshold**: 95% pass rate = converged
-10. **DO NOT STOP**: Continuous execution until convergence, max_iter, or all remaining = code_defect
+1. **Layer order sacred**: Never execute L(N+1) before L(N) completes (fail-fast on critical)
+2. **CSV is source of truth**: Master scenarios.csv holds all state
+3. **Context propagation**: prev_context from prior-layer findings in CSV
+4. **Discovery board append-only**: Never modify/delete discoveries.ndjson
+5. **Route auto-detected**: Read state, never ask user for mode
+6. **RED-GREEN methodology**: Tests target real behavior; failing test = bug discovery (never fix source)
+7. **Max 3 inner fix attempts**: Per layer, fix test_defects up to 3 times via diagnosis CSV
+8. **Convergence threshold**: 95% pass rate = converged
 </invariants>
 
-<execution>
-
-### Session Initialization
-
-```
-Parse from $ARGUMENTS:
-  AUTO_YES        ← --yes | -y
-  maxConcurrency  ← --concurrency | -c N  (default: 5)
-  MAX_ITER        ← --max-iter N  (default: 5)
-  layerFilter     ← --layer L  (default: null = all)
-  startStrategy   ← --strategy conservative|aggressive|surgical|reflective  (default: null = auto)
-  dryRun          ← --dry-run
-  reRun           ← --re-run
-  phaseArg        ← remaining text
-
-Derive:
-  dateStr        ← UTC+8 YYYYMMDD
-  sessionFolder  ← ".tests/auto-test/.csv-session"
-
-mkdir -p {sessionFolder}
-```
-
-### Phase 1: Route & Plan → CSV
-
-#### Step 0: Parse & Load
-
-Resolve phase dir from `state.json` artifact registry (`type='execute'`, matching phase). Error E002 if not found.
-
-```
-specs_test = maestro spec load --category test
-specs_arch = maestro spec load --category arch
-```
-
-#### Step 1: Read State & Route
-
-```
-Priority: Resume > Re-run > Spec > Gap > Code
-
-1. RESUME: .csv-session/scenarios.csv exists AND state.json status == "running"
-   → offer resume or restart (resume = reload CSV, jump to current iteration)
-
-2. RE-RUN: --re-run flag AND report.json has failed/blocked scenarios
-   → load failed scenarios into CSV with status reset to pending
-
-3. SPEC: .workflow/.spec/SPEC-*/requirements/REQ-*.md exists
-   → ROUTE = "spec", SPEC_MODE = "full" | "degraded"
-
-4. GAP: verification.json has gaps[] (MISSING/PARTIAL)
-   → ROUTE = "gap"
-
-5. CODE: Default fallback → ROUTE = "code"
-```
-
-#### Step 2: Source Scenarios
-
-Execute route-specific extraction, normalize to unified format.
-
-**Route A: spec** — Parse REQ acceptance criteria, classify layers, generate fixtures.
-**Route B: gap** — Read verification/coverage gaps, classify files by type.
-**Route C: code** — Explore module boundaries, API endpoints, integration points.
-
-All routes produce unified scenario objects (see csv_schema).
-
-#### Step 3: Discover Infrastructure
-
-Detect framework, read 2-3 existing tests for patterns. Build `infrastructure_hints` string per scenario.
-
-#### Step 4: Build scenarios.csv & Confirm
+<state_machine>
 
-1. Build master `scenarios.csv` — one row per scenario, grouped by layer
-2. Set `prev_context` for L2 scenarios from L1 scenario descriptions (cross-layer dependency)
-3. Set `prev_context` for L3 from L2 findings
+<states>
+S_PARSE      -- 解析参数、路由检测                          PERSIST: --
+S_SOURCE     -- 提取场景（spec/gap/code route）             PERSIST: --
+S_INFRA      -- 发现测试基础设施（framework/patterns）      PERSIST: --
+S_CSV_GEN    -- 生成 scenarios.csv                          PERSIST: scenarios.csv
+S_L0         -- Static analysis (tsc + eslint, no CSV)       PERSIST: L0 results
+S_LAYER_EXEC -- Per-layer write + run (L1->L2->L3)           PERSIST: test files + scenarios.csv
+S_ITERATE    -- Diagnose failures + fix loop                  PERSIST: diagnosis CSV + reflection-log.md
+S_REPORT     -- 输出报告、路由下一步                        PERSIST: report.json + state.json + results.csv
+</states>
 
-Display plan summary:
-```
-=== AUTO-TEST PLAN ===
-来源:  {ROUTE}  |  阶段:  {phase_name}  |  Spec:  {spec_ref or "N/A"}
+<transitions>
 
-  L0 Static:      {N} checks
-  L1 Unit/API:    {N} scenarios ({X} critical, {Y} high)
-  L2 Integration: {N} scenarios ({X} critical, {Y} high)
-  L3 E2E:         {N} scenarios ({X} critical, {Y} high)
+S_PARSE:
+  -> S_SOURCE       DO: resolve phase dir, detect route (resume/re-run/spec/gap/code)
 
-Total: {N} scenarios | Max iterations: {MAX_ITER} | Concurrency: {maxConcurrency}
-Proceed? (yes/edit/cancel)
-```
+S_SOURCE:
+  -> S_INFRA        DO: extract scenarios per route, normalize to unified format
+  Route A (spec): Parse REQ-*.md acceptance criteria, classify layers, generate fixtures
+  Route B (gap): Read verification/coverage gaps, classify files by type
+  Route C (code): Explore module boundaries, API endpoints, integration points
 
-- `--dry-run`: stop here. `-y`: skip confirmation.
+S_INFRA:
+  -> S_CSV_GEN      DO: detect framework, read 2-3 existing tests, build infrastructure_hints
 
-### Phase 2: Layer Execution Engine (Write + Run)
+S_CSV_GEN:
+  -> S_L0           DO: build scenarios.csv, set cross-layer prev_context
+  -> END            WHEN: --dry-run (plan only)
 
-#### L0: Static Analysis (no CSV)
+S_L0:
+  -> S_LAYER_EXEC   WHEN: L0 passes
+  -> END            WHEN: L0 fails (stop, do not proceed)
 
-```bash
-tsc --noEmit && eslint src/
-```
+S_LAYER_EXEC:
+  -> S_ITERATE      WHEN: failures exist AND max_iter > 1    DO: A_PER_LAYER_WRITE_RUN
+  -> S_REPORT       WHEN: all pass OR max_iter == 1          DO: A_PER_LAYER_WRITE_RUN
 
-If L0 fails → stop, do not proceed to L1.
+S_ITERATE:
+  -> S_REPORT       WHEN: converged (>=95%) OR max_iter reached OR all remaining = code_defect
+  -> S_ITERATE      WHEN: more iterations needed              DO: A_ITERATE_LOOP
 
-#### Per-Layer Write Loop (L1 → L2 → L3)
+S_REPORT:
+  -> END            DO: A_REPORT
 
-For each layer (sequential, respecting --layer filter):
+</transitions>
 
-**1. Extract layer rows** from master `scenarios.csv` (filter by `layer == L{N}`, status == pending)
+<actions>
 
-**2. Populate `prev_context`** from completed prior-layer findings in master CSV
+### A_PER_LAYER_WRITE_RUN
 
-**3. Write `layer-L{N}-write.csv`** then execute parallel test writing:
+For each layer L1->L3 (sequential, respecting --layer filter):
 
-```javascript
-spawn_agents_on_csv({
-  csv_path: `${sessionFolder}/layer-L${N}-write.csv`,
-  id_column: "id",
-  instruction: buildTestWriterInstruction(infrastructure, specsContent, phaseDir),
-  max_concurrency: maxConcurrency,
-  max_runtime_seconds: 1800,
-  output_csv_path: `${sessionFolder}/layer-L${N}-write-results.csv`,
-  output_schema: { id, status: [written|failed], red_result: [expected_fail|unexpected_fail|pass], findings, error }
-})
-```
+1. Extract layer rows from scenarios.csv (status==pending)
+2. Populate prev_context from completed prior-layer findings in master CSV
+3. Write layer-L{N}-write.csv -> `spawn_agents_on_csv` for parallel test writing
+4. Merge write-results -> scenarios.csv
+5. Run full layer test suite: `{run_command} --testPathPattern="{layer_pattern}"`
+6. Record per-scenario pass/fail
+7. Fail-fast: any critical-priority failed -> stop layer progression
 
-**Test Writer Agent Instruction** (per scenario row):
+**Test Writer Agent Instruction** (injected into spawn_agents_on_csv):
 ```
 You are a test writer. Write ONE test file for the given scenario.
 
 ## Task
-- Read the target_file to understand the module under test
+- Read target_file to understand module under test
 - Write test file at test_file path following infrastructure_hints patterns
-- Each test case in test_cases becomes one it() block
+- Each test_case in test_cases -> one it() block
 - Use fixtures from fixtures column (infer from source if empty)
 - Include scenario id in describe: describe("AT-NNN: {name}", ...)
-- Run the test file once after writing
+- Run test file once after writing
 
 ## RED-GREEN Rules
-- If test PASSES immediately: note "pass" — may need strengthening
-- If test FAILS as expected (tests real behavior): note "expected_fail" — good
-- If test FAILS unexpectedly (setup/import error): fix test setup, note "unexpected_fail"
+- Test PASSES immediately: note "pass" — may need strengthening
+- Test FAILS as expected (tests real behavior): note "expected_fail" — good
+- Test FAILS unexpectedly (setup/import error): fix test setup, note "unexpected_fail"
 - NEVER modify source code — only write/fix test files
 
 ## Output
-- status: "written" if test file created successfully, "failed" if unable
+- status: "written" if created, "failed" if unable
 - red_result: the RED phase outcome
 - findings: patterns discovered, notes for dependent scenarios (max 500 chars)
 - error: only if status == "failed"
@@ -330,224 +167,89 @@ You are a test writer. Write ONE test file for the given scenario.
 - Append to discoveries.ndjson if you find reusable patterns
 ```
 
-**4. Merge write-results** into master `scenarios.csv`, delete temp CSV
-
-**5. Run full layer test suite:**
-```bash
-{run_command} --testPathPattern="{layer_pattern}"
-```
-
-**6. Record per-scenario results** (pass/fail/blocked with error_detail)
-
-**7. Fail-fast check:** If ANY critical-priority scenario failed → do NOT proceed to next layer
-
-**If `--max-iter 1`:** After all layers written and run once, jump to Phase 4 (single-pass).
+### A_ITERATE_LOOP
 
-### Phase 3: Iteration Engine (Diagnose + Fix)
-
-```
 OUTER LOOP (max_iter iterations):
+  FOR each layer with failures:
+    INNER LOOP (max 3):
+      1. Build diagnosis.csv from failed scenarios (exclude code_defect)
+      2. `spawn_agents_on_csv` for parallel diagnosis
+      3. Diagnosis agent (see instruction below). test_defect -> provide fix. code_defect -> document evidence.
+      4. Apply test_defect fixes, re-run layer
 
-  FOR each layer with failures (L1 through current):
-
-    INNER LOOP (max 3 per layer):
-
-      1. Build diagnosis.csv from failed scenarios in master CSV
-         (only scenarios with status=failed AND classification != code_defect)
-
-      2. IF diagnosis rows >= 1:
-         spawn_agents_on_csv({
-           csv_path: `${sessionFolder}/diagnosis-iter-${iter}.csv`,
-           id_column: "id",
-           instruction: buildDiagnosisInstruction(infrastructure),
-           max_concurrency: maxConcurrency,
-           max_runtime_seconds: 1200,
-           output_csv_path: `${sessionFolder}/diagnosis-iter-${iter}-results.csv`,
-           output_schema: { id, classification, fix_code, evidence, error }
-         })
-
-      3. Merge diagnosis results:
-         - test_defect with fix_code → apply fix, update scenario status to "pending"
-         - code_defect → mark as confirmed failure (stop retrying)
-         - env_issue → mark as blocked
-
-      4. Re-run ALL scenarios in this layer (catch regressions)
-      5. IF no test_defects remain: break inner loop
-
-    END INNER
-
-    Record final layer results
-    IF critical code_defects: stop layer progression (fail-fast)
-
-  END FOR
-
-  REFLECT:
-    Analyze: pass rate delta, failure clusters, strategy effectiveness
-    Append to reflection-log.md
-
-    **Test confidence scoring** (at each REFLECT step):
-       Dimensions (5): scenario_coverage, test_quality, diagnostic_accuracy, strategy_effectiveness, infrastructure_fitness. Factors (weights): completeness(.30), pass_rate_trend(.25), classification_accuracy(.20), coverage_breadth(.15), consistency(.10). Enhanced convergence: BOTH pass_rate ≥ threshold AND confidence ≥ 60%. Add confidence to `report.json`.
-
-  ADJUST (Adaptive Strategy):
-    IF startStrategy provided AND iteration == 1: use startStrategy as initial
-    OTHERWISE auto-select:
-
-    | Condition | Strategy |
-    |-----------|----------|
-    | Iteration 1-2 | Conservative: fix obvious test_defects only |
-    | Pass rate >80% | Aggressive: batch-fix related failures |
-    | New regressions | Surgical: revert, fix regression only |
-    | Stuck 3+ iters | Reflective: re-analyze root cause pattern |
-
-  CONVERGENCE:
-    pass_rate >= 95% → Phase 4 (converged)
-    iteration >= max_iter → Phase 4 (max_iter_reached)
-    all remaining = code_defect → Phase 4 (confirmed_defects)
-    ELSE → next iteration
-
-END OUTER
-```
-
-**Diagnosis Agent Instruction** (per failure row):
+**Diagnosis Agent Instruction** (injected into spawn_agents_on_csv):
 ```
-You are a test failure diagnostician. Classify ONE test failure and provide fix if applicable.
+You are a test failure diagnostician. Classify ONE test failure.
 
 ## Task
-- Read test_file and target_file to understand the failure context
+- Read test_file and target_file to understand failure context
 - Analyze error_detail against expected vs actual
-- Classify the failure:
-  - test_defect: Test is wrong (bad import, wrong endpoint, bad fixture, incorrect assertion)
-  - code_defect: Source code violates business rule (actual behavior != expected requirement)
+- Classify:
+  - test_defect: Test wrong (bad import, wrong endpoint, bad fixture, incorrect assertion)
+  - code_defect: Source violates business rule (actual != expected requirement)
   - env_issue: Environment problem (service down, config missing, timeout)
 
 ## Output
-- classification: one of test_defect / code_defect / env_issue
-- fix_code: If test_defect, provide the fix (format: "old_line → new_line" or full replacement)
-             If code_defect or env_issue, leave empty
-- evidence: file:line references supporting your classification
-- error: only if you cannot determine classification
+- classification: test_defect / code_defect / env_issue
+- fix_code: If test_defect: "old_line → new_line" or full replacement. Empty for others.
+- evidence: file:line references supporting classification
+- error: only if cannot determine
 
 ## Rules
-- NEVER suggest source code changes — only test code fixes for test_defect
-- A test that correctly catches a real bug is a code_defect, not test_defect
-- When uncertain between test_defect and code_defect, prefer code_defect (conservative)
+- NEVER suggest source code changes — only test fixes for test_defect
+- Test correctly catching a real bug = code_defect, not test_defect
+- When uncertain: prefer code_defect (conservative)
 ```
+      5. If no test_defects remain: break inner
+  REFLECT: analyze trends, log strategy, test confidence scoring (5 dims: scenario_coverage, test_quality, diagnostic_accuracy, strategy_effectiveness, infrastructure_fitness)
+  ADJUST: auto-select strategy (conservative iter 1-2, aggressive >80%, surgical on regression, reflective stuck 3+)
+  CONVERGENCE: >=95% -> report; max_iter -> report; all code_defect -> report
 
-### Shared Discovery Board Protocol
-
-| Type | Dedup Key | Data Schema |
-|------|-----------|-------------|
-| `test_pattern` | `data.name` | `{name, file, description}` |
-| `mock_setup` | `data.target` | `{target, setup_code, file}` |
-| `fixture` | `data.name` | `{name, schema, file}` |
-| `convention` | singleton | `{describe_style, assertion_lib, import_pattern}` |
-| `blocker` | `data.issue` | `{issue, severity, layer}` |
-
-Read before writing tests. Append-only. Dedup by type+key.
-
-### Phase 4: Results & Routing
-
-1. Export final `scenarios.csv` as `results.csv`
-
-2. Write `.tests/auto-test/state.json`:
-```json
-{
-  "session_id": "auto-test-{YYYYMMDD-HHmmss}",
-  "phase": "{phase}", "phase_dir": "{PHASE_DIR}",
-  "source_route": "spec|gap|code|re-run",
-  "status": "converged|max_iter_reached|confirmed_defects|single_pass",
-  "iteration": N, "strategy": "conservative",
-  "strategy_history": [...],
-  "threshold": 95, "current_layer": "L2",
-  "layer_state": {
-    "L0": { "inner_iter": 1, "pass_rate": 100.0, "status": "passed" },
-    "L1": { "inner_iter": 2, "pass_rate": 95.0, "status": "passed" },
-    "L2": { ... }, "L3": { ... }
-  },
-  "pass_rate_history": [...],
-  "scenario_count": 30,
-  "csv_session": ".tests/auto-test/.csv-session/"
-}
-```
-
-3. Write `.tests/auto-test/report.json` (same schema as workflow reference)
+### A_REPORT
 
-4. **Conditional: Traceability** (spec source only) — build REQ→AC→scenario→result mapping
-
-5. **Conditional: Issue Creation** (code_defect failures):
-```
-FOR each failure WHERE classification == "code_defect":
-  Append to .workflow/issues/issues.jsonl
-```
+1. Export results.csv
+2. Write state.json + report.json (with confidence section)
+3. Conditional: traceability.md (spec route), issue creation (code_defect -> issues.jsonl)
+4. Register artifact in state.json (type: test)
+5. Display summary: route, iterations, convergence status, per-layer pass rates, bugs discovered
+6. Route: converged -> maestro-verify; bugs -> quality-debug; >80% -> quality-test; <80% -> quality-debug; single pass all pass -> quality-test
 
-6. **Register artifact** in state.json:
-```json
-{ "id": "TST-NNN", "type": "test", "status": "completed|failed" }
-```
+</actions>
 
-7. **Report Display:**
-```
-=== AUTO-TEST RESULTS ===
-阶段:      {phase_name}
-来源:      {ROUTE}
-迭代:      {N} (策略: {strategy_history})
-收敛:      {status} ({final_pass_rate}%)
-
-层级结果:
-  L0 Static:      {pass_rate}% ({passed}/{total})
-  L1 Unit/API:    {pass_rate}% ({passed}/{total})
-  L2 Integration: {pass_rate}% ({passed}/{total})
-  L3 E2E:         {pass_rate}% ({passed}/{total})
-
-场景: {passed} passed, {failed} failed, {blocked} blocked
-Bugs: {N} discovered
-{IF spec: "需求覆盖: {pct}% | 已验证: {n}/{total}"}
-
-CSV Session: .tests/auto-test/.csv-session/
-```
+</state_machine>
 
-8. **Route:**
+<discovery_board>
 
-| Result | Next Step |
-|--------|-----------|
-| Converged (>=95%) | `$maestro-verify "{phase}"` |
-| All requirements verified (spec) | `$maestro-milestone-audit` |
-| Bugs discovered | `$quality-debug "--from-auto-test {phase}"` |
-| Max iter, >80% | `$quality-test "{phase}"` for manual UAT |
-| Max iter, <80% | `$quality-debug "{phase}"` |
-| Coverage still low | `$quality-auto-test "{phase} --layer {missing}"` |
-| Re-run all pass | `$maestro-verify "{phase}"` |
-| Single pass, all pass | `$quality-test "{phase}"` |
+| Type | Dedup Key | Data |
+|------|-----------|------|
+| test_pattern | data.name | {name, file, description} |
+| mock_setup | data.target | {target, setup_code, file} |
+| fixture | data.name | {name, schema, file} |
+| convention | singleton | {describe_style, assertion_lib, import_pattern} |
+| blocker | data.issue | {issue, severity, layer} |
 
-</execution>
+Protocol: read before writing tests, append-only, dedup by type+key.
+</discovery_board>
 
 <error_codes>
-| Error | Resolution |
-|-------|------------|
-| Phase not found in artifact registry | Abort: "Phase {N} not found" |
-| No test framework detected | Abort: E003. Install framework or configure runner |
-| Agent spawn fails (write or diagnosis) | Retry once, then mark scenario as blocked |
+| Condition | Recovery |
+|-----------|----------|
+| Phase not found in artifact registry | Abort: "Phase not found" |
+| No test framework detected | Abort: E003, install framework |
+| Agent spawn fails | Retry once, then mark scenario blocked |
 | Convergence not met after max_iter | Report max_iter_reached, suggest debug |
 | All scenarios in layer blocked | Stop layer, report env_issue |
-| CSV parse error | Validate format, show line |
-| discoveries.ndjson corrupt | Ignore malformed lines, continue |
 | Resume: no session found | Start fresh |
 </error_codes>
 
 <success_criteria>
-- [ ] Session folder created with valid scenarios.csv
 - [ ] Route auto-selected from project state (spec/gap/code)
-- [ ] All layers executed in order with fail-fast on critical
-- [ ] Test writing parallelized via spawn_agents_on_csv per layer
-- [ ] Failure diagnosis parallelized via spawn_agents_on_csv per iteration
-- [ ] discoveries.ndjson append-only throughout
-- [ ] Cross-layer context propagation via prev_context column
-- [ ] Iteration engine ran (inner: test_defect fix, outer: strategy adjust)
-- [ ] Test confidence scored per iteration with 5-dimension factor model
-- [ ] Convergence check includes confidence >= 60% alongside pass_rate
-- [ ] Confidence section added to report.json
+- [ ] Layers executed in order with fail-fast on critical
+- [ ] Test writing + diagnosis parallelized via spawn_agents_on_csv
+- [ ] Cross-layer context propagation via prev_context
+- [ ] Iteration engine: inner test_defect fix, outer strategy adjust
+- [ ] Test confidence scored per iteration (5-dimension model)
 - [ ] state.json, report.json, reflection-log.md written
-- [ ] If spec: traceability.md produced
-- [ ] If failures: issues auto-created in issues.jsonl
-- [ ] Next step routed based on convergence status
+- [ ] If spec: traceability.md; if failures: issues auto-created
 </success_criteria>
+</output>