@boyingliu01/xp-gate 0.15.4 → 0.18.0

package/lib/__tests__/doctor.test.js

@@ -31,6 +31,12 @@ describe('doctor', () => {
       originalDetectDepsTools = [...detectDeps.GATE_CLI_TOOLS];
       detectDeps.GATE_CLI_TOOLS.length = 0;
     }
+    // Mock checkBash to return success by default (tests override as needed)
+    detectDeps.checkBash = () => ({
+      ok: true,
+      path: 'bash',
+      version: '5.1.16',
+    });
   });
 
   afterAll(() => {
@@ -217,9 +223,6 @@ describe('doctor', () => {
       if (cmd === 'git --version') {
         return 'git version 2.39.0\n';
       }
-      if (cmd === 'bash --version') {
-        return 'GNU bash, version 5.1.16\n';
-      }
       return '';
     };
 
@@ -237,8 +240,6 @@ describe('doctor', () => {
         callback(null, 'v20.0.0\n', '');
       } else if (cmd === 'git --version') {
         callback(null, 'git version 2.39.0\n', '');
-      } else if (cmd === 'bash --version') {
-        callback(null, 'GNU bash, version 5.1.16\n', '');
       } else {
         callback(null, '', '');
       }
@@ -401,9 +402,6 @@ describe('doctor', () => {
       if (cmd === 'git --version') {
         return 'git version 2.39.0\n';
       }
-      if (cmd === 'bash --version') {
-        return 'GNU bash, version 5.1.16\n';
-      }
       return '';
     };
     // Async mock matching execSync above
@@ -417,8 +415,6 @@ describe('doctor', () => {
         callback(null, 'v20.0.0\n', '');
       } else if (cmd === 'git --version') {
         callback(null, 'git version 2.39.0\n', '');
-      } else if (cmd === 'bash --version') {
-        callback(null, 'GNU bash, version 5.1.16\n', '');
       } else {
         callback(null, '', '');
       }
@@ -502,9 +498,6 @@ describe('doctor', () => {
       if (cmd === 'git --version') {
         return 'git version 2.39.0\n';
       }
-      if (cmd === 'bash --version') {
-        return 'GNU bash, version 5.1.16\n';
-      }
       return '';
     };
     // Async exec mock for execWithTimeout (util.promisify(exec) in doctor.js)
@@ -518,8 +511,6 @@ describe('doctor', () => {
         callback(null, 'v20.0.0\n', '');
       } else if (cmd === 'git --version') {
         callback(null, 'git version 2.39.0\n', '');
-      } else if (cmd === 'bash --version') {
-        callback(null, 'GNU bash, version 5.1.16\n', '');
       } else {
         callback(null, '', '');
       }
@@ -569,6 +560,10 @@ describe('doctor', () => {
   it('detects missing environment dependencies', async () => {
     setupLocalInstall();
     seedVersionCache();
+    // Make checkBash fail for this test (detect-deps module already loaded + mocked in beforeAll)
+    const detectDeps = require('../detect-deps.js');
+    const origCheckBash = detectDeps.checkBash;
+    detectDeps.checkBash = () => ({ ok: false, message: 'Not found' });
     mockExecFail();
     const { doctor } = require('../doctor');
 
@@ -578,6 +573,9 @@ describe('doctor', () => {
     expect(logSpy).toHaveBeenCalledWith(
       expect.stringContaining('Not found')
     );
+
+    // Restore
+    detectDeps.checkBash = origCheckBash;
   });
 
   // === Issue #186: Version mismatch detection ===

package/lib/__tests__/gate-audit.test.ts

@@ -201,6 +201,44 @@ describe('gate-audit', () => {
     });
   });
 
+  describe('duration_anomaly handling', () => {
+    it('should exclude duration_anomaly entries from avg_ms calculation', () => {
+      const repoRoot = join(TEST_DIR, 'anomaly-avg-test');
+      // 2 normal entries: 100ms + 200ms → avg 150ms
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-1', duration_ms: 100 }), repoRoot);
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-1', duration_ms: 200 }), repoRoot);
+      // 1 anomalous entry: should be excluded from avg
+      appendAuditEntry(
+        makeEntry({ repo_path: repoRoot, gate_id: 'gate-1', duration_ms: 1784536915891, duration_anomaly: true }),
+        repoRoot,
+      );
+
+      const stats = computeStats(repoRoot);
+      const g1 = stats.find(s => s.gate_id === 'gate-1')!;
+      // avg should be (100+200)/2 = 150, NOT (100+200+1784536915891)/3
+      expect(g1.avg_ms).toBe(150);
+    });
+
+    it('should count anomaly entries separately in stats output', () => {
+      const repoRoot = join(TEST_DIR, 'anomaly-count-test');
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-5', duration_ms: 500 }), repoRoot);
+      appendAuditEntry(
+        makeEntry({ repo_path: repoRoot, gate_id: 'gate-5', duration_ms: 9999999999999, duration_anomaly: true }),
+        repoRoot,
+      );
+      appendAuditEntry(
+        makeEntry({ repo_path: repoRoot, gate_id: 'gate-5', duration_ms: 8888888888888, duration_anomaly: true }),
+        repoRoot,
+      );
+
+      const stats = computeStats(repoRoot);
+      const g5 = stats.find(s => s.gate_id === 'gate-5')!;
+      expect(g5.anomaly_count).toBe(2);
+      // avg_ms only from the 1 normal entry
+      expect(g5.avg_ms).toBe(500);
+    });
+  });
+
   describe('CLI helpers', () => {
     it('should parse CLI options and skip dangling flags', () => {
       expect(parseCliOptions(['--gate-id', 'gate-1', '--passed', 'true', '--dangling'])).toEqual({

package/lib/__tests__/phase-transition.test.js

@@ -12,7 +12,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { handlePhaseTransition, renderDashboard, PHASE_NAMES } from '../phase-transition.js';
+import { handlePhaseTransition, renderDashboard, PHASE_NAMES, validateEvidence } from '../phase-transition.js';
 
 describe('phase-transition', () => {
   let tmpDir;
@@ -25,6 +25,29 @@ describe('phase-transition', () => {
     fs.rmSync(tmpDir, { recursive: true, force: true });
   });
 
+  /** Helper: write phase 2 evidence (requirements-reviewed.json) so phase 2 completed passes */
+  function writePhase2Evidence(dir) {
+    const outputsDir = path.join(dir, '.sprint-state', 'phase-outputs');
+    fs.mkdirSync(outputsDir, { recursive: true });
+    fs.writeFileSync(path.join(outputsDir, 'requirements-reviewed.json'), JSON.stringify({
+      verdict: 'APPROVED',
+      requirements_hash: 'test-hash-placeholder',
+      timestamp: new Date().toISOString(),
+    }));
+  }
+
+  /** Helper: write phase 4 evidence (test-alignment-report.json) so phase 4 completed passes */
+  function writePhase4Evidence(dir) {
+    const outputsDir = path.join(dir, '.sprint-state', 'phase-outputs');
+    fs.mkdirSync(outputsDir, { recursive: true });
+    fs.writeFileSync(path.join(outputsDir, 'test-alignment-report.json'), JSON.stringify({
+      alignment_status: 'PASS',
+      head_commit: 'unknown',
+      spec_hash: null,
+      timestamp: new Date().toISOString(),
+    }));
+  }
+
   describe('handlePhaseTransition()', () => {
     it('returns 0 and shows help with --help', async () => {
       const code = await handlePhaseTransition(['--help']);
@@ -61,6 +84,7 @@ describe('phase-transition', () => {
     });
 
     it('records outputs when --outputs flag is provided', async () => {
+      writePhase2Evidence(tmpDir);
       const outputs = JSON.stringify({ spec: 'path/to/spec.yaml' });
       const code = await handlePhaseTransition(['2', 'completed', '--outputs', outputs, '--dir', tmpDir]);
       expect(code).toBe(0);
@@ -78,6 +102,7 @@ describe('phase-transition', () => {
     it('transitions through multiple phases sequentially', async () => {
       await handlePhaseTransition(['1', 'completed', '--dir', tmpDir]);
       await handlePhaseTransition(['2', 'in_progress', '--dir', tmpDir]);
+      writePhase2Evidence(tmpDir);
       await handlePhaseTransition(['2', 'completed', '--dir', tmpDir]);
       await handlePhaseTransition(['3', 'in_progress', '--dir', tmpDir]);
 
@@ -187,6 +212,7 @@ describe('phase-transition', () => {
 
     it('does NOT warn when previous phase is completed', async () => {
       await handlePhaseTransition(['1', 'completed', '--dir', tmpDir]);
+      writePhase2Evidence(tmpDir);
       await handlePhaseTransition(['2', 'completed', '--dir', tmpDir]);
 
       const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
@@ -247,8 +273,10 @@ describe('phase-transition', () => {
     it('outputs sprint-audit reminder on Phase 6 completed', async () => {
       // Set up state through Phase 5
       await handlePhaseTransition(['1', 'completed', '--dir', tmpDir]);
+      writePhase2Evidence(tmpDir);
       await handlePhaseTransition(['2', 'completed', '--dir', tmpDir]);
       await handlePhaseTransition(['3', 'completed', '--dir', tmpDir]);
+      writePhase4Evidence(tmpDir);
       await handlePhaseTransition(['4', 'completed', '--dir', tmpDir]);
       await handlePhaseTransition(['5', 'completed', '--dir', tmpDir]);
 
@@ -269,4 +297,216 @@ describe('phase-transition', () => {
       expect(PHASE_NAMES[6]).toBe('CLOSE');
     });
   });
+
+  describe('evidence validation', () => {
+    /** Helper: create a sprint-state.json with given evidence_schema_version */
+    function createSprintState(dir, evidenceSchemaVersion) {
+      const stateDir = path.join(dir, '.sprint-state');
+      fs.mkdirSync(stateDir, { recursive: true });
+      const state = {
+        _schema_version: 1,
+        id: 'sprint-test-evidence',
+        task_description: 'Evidence test',
+        phase: 4,
+        status: 'in_progress',
+        started_at: new Date().toISOString(),
+        phase_history: [
+          { phase: 1, phase_name: 'PREP', status: 'completed' },
+          { phase: 2, phase_name: 'DESIGN', status: 'completed' },
+          { phase: 3, phase_name: 'BUILD', status: 'completed' },
+          { phase: 4, phase_name: 'VERIFY', status: 'in_progress' },
+        ],
+        isolation: { worktree_path: dir, branch: null },
+        outputs: {},
+        metrics: {},
+      };
+      if (evidenceSchemaVersion !== undefined) {
+        state.evidence_schema_version = evidenceSchemaVersion;
+      }
+      fs.writeFileSync(path.join(stateDir, 'sprint-state.json'), JSON.stringify(state, null, 2));
+    }
+
+    /** Helper: write a test-alignment-report.json */
+    function writeAlignmentReport(dir, report) {
+      const outputsDir = path.join(dir, '.sprint-state', 'phase-outputs');
+      fs.mkdirSync(outputsDir, { recursive: true });
+      fs.writeFileSync(path.join(outputsDir, 'test-alignment-report.json'), JSON.stringify(report, null, 2));
+    }
+
+    it('(a) BLOCKs when evidence file is missing for new sprint (evidence_schema_version >= 2)', () => {
+      createSprintState(tmpDir, 2);
+      const result = validateEvidence(4, tmpDir);
+      expect(result.ok).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors[0]).toContain('test-alignment-report.json');
+    });
+
+    it('(b) BLOCKs when alignment_status is FAIL', () => {
+      createSprintState(tmpDir, 2);
+      writeAlignmentReport(tmpDir, {
+        alignment_status: 'FAIL',
+        head_commit: 'unknown',
+        spec_hash: null,
+        timestamp: new Date().toISOString(),
+      });
+      const result = validateEvidence(4, tmpDir);
+      expect(result.ok).toBe(false);
+      expect(result.errors.some(e => e.includes('alignment') || e.includes('PASS'))).toBe(true);
+    });
+
+    it('(c) BLOCKs when head_commit is stale (does not match current HEAD)', () => {
+      createSprintState(tmpDir, 2);
+      writeAlignmentReport(tmpDir, {
+        alignment_status: 'PASS',
+        head_commit: 'deadbeef00000000000000000000000000000000',
+        spec_hash: null,
+        timestamp: new Date().toISOString(),
+      });
+      const result = validateEvidence(4, tmpDir);
+      // In tmpDir (no git repo), current HEAD is 'unknown'.
+      // A non-'unknown' head_commit that doesn't match 'unknown' should BLOCK.
+      expect(result.ok).toBe(false);
+      expect(result.errors.some(e => e.includes('head_commit'))).toBe(true);
+    });
+
+    it('(d) BLOCKs when evidence file is malformed JSON (treated as missing)', () => {
+      createSprintState(tmpDir, 2);
+      const outputsDir = path.join(tmpDir, '.sprint-state', 'phase-outputs');
+      fs.mkdirSync(outputsDir, { recursive: true });
+      fs.writeFileSync(path.join(outputsDir, 'test-alignment-report.json'), '{invalid json!!!');
+      const result = validateEvidence(4, tmpDir);
+      expect(result.ok).toBe(false);
+      expect(result.errors.some(e => e.includes('malformed'))).toBe(true);
+    });
+
+    it('(e) WARNs but does NOT block for legacy sprint (no evidence_schema_version)', () => {
+      createSprintState(tmpDir); // no evidence_schema_version
+      const result = validateEvidence(4, tmpDir);
+      expect(result.ok).toBe(true);
+      expect(result.warnings.length).toBeGreaterThan(0);
+      expect(result.warnings[0]).toContain('evidence_schema_version');
+    });
+
+    it('(f) allows bypass with --skip-evidence and --reason via handlePhaseTransition', async () => {
+      createSprintState(tmpDir, 2);
+      // No evidence file — would normally BLOCK
+      const code = await handlePhaseTransition([
+        '4', 'completed', '--dir', tmpDir,
+        '--skip-evidence', 'Emergency hotfix',
+      ]);
+      expect(code).toBe(0);
+
+      // Verify audit entry was written
+      const auditFile = path.join(tmpDir, '.xp-gate', 'audit.jsonl');
+      expect(fs.existsSync(auditFile)).toBe(true);
+      const lines = fs.readFileSync(auditFile, 'utf8').trim().split('\n');
+      const lastEntry = JSON.parse(lines[lines.length - 1]);
+      expect(lastEntry.event).toBe('evidence_skipped');
+      expect(lastEntry.phase).toBe(4);
+      expect(lastEntry.reason).toBe('Emergency hotfix');
+    });
+
+    it('(g) rejects --skip-evidence without --reason', async () => {
+      createSprintState(tmpDir, 2);
+      const code = await handlePhaseTransition([
+        '4', 'completed', '--dir', tmpDir,
+        '--skip-evidence',
+      ]);
+      expect(code).toBe(1);
+    });
+
+    it('returns ok for phases without evidence requirements (phase 1, 3, 5, 6)', () => {
+      createSprintState(tmpDir, 2);
+      for (const phase of [1, 3, 5, 6]) {
+        const result = validateEvidence(phase, tmpDir);
+        expect(result.ok).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }
+    });
+
+    it('accepts valid evidence with head_commit matching current HEAD (unknown in non-git dir)', () => {
+      createSprintState(tmpDir, 2);
+      writeAlignmentReport(tmpDir, {
+        alignment_status: 'PASS',
+        head_commit: 'unknown', // matches non-git tmpDir
+        spec_hash: null,
+        timestamp: new Date().toISOString(),
+      });
+      const result = validateEvidence(4, tmpDir);
+      expect(result.ok).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('validates spec_hash when specification.yaml exists', () => {
+      createSprintState(tmpDir, 2);
+      // Create a specification.yaml
+      const specContent = 'requirements:\n  - id: REQ-001\n';
+      fs.writeFileSync(path.join(tmpDir, 'specification.yaml'), specContent);
+
+      // Compute expected hash
+      const crypto = require('crypto');
+      const expectedHash = crypto.createHash('sha256').update(specContent, 'utf8').digest('hex');
+
+      writeAlignmentReport(tmpDir, {
+        alignment_status: 'PASS',
+        head_commit: 'unknown',
+        spec_hash: expectedHash,
+        timestamp: new Date().toISOString(),
+      });
+      const result = validateEvidence(4, tmpDir);
+      expect(result.ok).toBe(true);
+    });
+
+    it('BLOCKs when spec_hash does not match specification.yaml', () => {
+      createSprintState(tmpDir, 2);
+      fs.writeFileSync(path.join(tmpDir, 'specification.yaml'), 'requirements:\n  - id: REQ-001\n');
+      writeAlignmentReport(tmpDir, {
+        alignment_status: 'PASS',
+        head_commit: 'unknown',
+        spec_hash: 'wronghash000000000000000000000000000000000000000000000000000000',
+        timestamp: new Date().toISOString(),
+      });
+      const result = validateEvidence(4, tmpDir);
+      expect(result.ok).toBe(false);
+      expect(result.errors.some(e => e.includes('spec_hash'))).toBe(true);
+    });
+
+    it('BLOCKs when required fields are missing from evidence', () => {
+      createSprintState(tmpDir, 2);
+      writeAlignmentReport(tmpDir, {
+        alignment_status: 'PASS',
+        // missing head_commit and spec_hash
+      });
+      const result = validateEvidence(4, tmpDir);
+      expect(result.ok).toBe(false);
+      expect(result.errors.some(e => e.includes('head_commit'))).toBe(true);
+    });
+
+    it('does NOT validate evidence for non-completed statuses', async () => {
+      createSprintState(tmpDir, 2);
+      // in_progress should not trigger evidence validation
+      const code = await handlePhaseTransition(['4', 'in_progress', '--dir', tmpDir]);
+      expect(code).toBe(0);
+    });
+
+    it('handlePhaseTransition BLOCKs phase 4 completed without evidence for new sprint', async () => {
+      createSprintState(tmpDir, 2);
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const code = await handlePhaseTransition(['4', 'completed', '--dir', tmpDir]);
+      expect(code).toBe(1);
+      errorSpy.mockRestore();
+    });
+
+    it('handlePhaseTransition allows phase 4 completed with valid evidence', async () => {
+      createSprintState(tmpDir, 2);
+      writeAlignmentReport(tmpDir, {
+        alignment_status: 'PASS',
+        head_commit: 'unknown',
+        spec_hash: null,
+        timestamp: new Date().toISOString(),
+      });
+      const code = await handlePhaseTransition(['4', 'completed', '--dir', tmpDir]);
+      expect(code).toBe(0);
+    });
+  });
 });

package/lib/__tests__/retro.test.js

@@ -0,0 +1,131 @@
+/**
+ * TDD: written RED first (Phase G per design §12)
+ * @test REQ-RETRO-001 Sprint engineering retrospective CLI
+ * @intent Validate xp-gate retro generates Markdown report with rework trend + skip exposure sections
+ */
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const { handleRetro } = require('../retro');
+
+let TMP_DIR;
+let cwdSpy;
+
+beforeAll(() => {
+  TMP_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'retro-test-'));
+  cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(TMP_DIR);
+});
+
+afterAll(() => {
+  cwdSpy.mockRestore();
+  fs.rmSync(TMP_DIR, { recursive: true, force: true });
+});
+
+function writeAudit(entries) {
+  const dir = path.join(TMP_DIR, '.xp-gate');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, 'audit.jsonl'),
+    entries.map(e => JSON.stringify(e)).join('\n') + '\n'
+  );
+}
+
+function writeHistory(entry) {
+  const dir = path.join(TMP_DIR, '.sprint-state', 'sprint-history');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `${entry.id}.json`), JSON.stringify(entry, null, 2));
+}
+
+function cleanDir() {
+  for (const sub of ['.xp-gate', '.sprint-state', '.quality-history.jsonl']) {
+    fs.rmSync(path.join(TMP_DIR, sub), { recursive: true, force: true });
+  }
+}
+
+describe('retro: report generation', () => {
+  // TDD: written RED first (G phase per design §12)
+  test('(a) empty data sources → skeleton report with "No data" sections', async () => {
+    cleanDir();
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const code = await handleRetro(['--days', '7']);
+    const output = logSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    logSpy.mockRestore();
+
+    expect(code).toBe(0);
+    expect(output).toContain('# Sprint Engineering Retrospective');
+    expect(output).toContain('## Activity Summary');
+    expect(output).toContain('## Rework Rate Trend (#369)');
+    expect(output).toContain('## Evidence Skip Exposure');
+    expect(output).toContain('## Quality Trend');
+    expect(output).toContain('No data');
+  });
+
+  // TDD: written RED first (G phase per design §12)
+  test('(b) rework rate > 30% → alert line present with sprint id', async () => {
+    cleanDir();
+    writeHistory({
+      id: 'sprint-high-rework',
+      task_description: 'High rework sprint',
+      metrics: {
+        completed_at: new Date(Date.now() - 2 * 86400000).toISOString(),
+        total_sprint_commits: 10,
+        rework_rate: 0.42,
+      },
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const code = await handleRetro(['--days', '7']);
+    const output = logSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    logSpy.mockRestore();
+
+    expect(code).toBe(0);
+    expect(output).toContain('⚠️');
+    expect(output).toContain('sprint-high-rework');
+    expect(output).toContain('exceeds 30% threshold');
+  });
+
+  // TDD: written RED first (G phase per design §12)
+  test('(c) skip-evidence events > 2 per sprint → alert present', async () => {
+    cleanDir();
+    const ts = new Date().toISOString();
+    writeAudit([
+      { event: 'evidence_skipped', phase: '3', reason: 'r1', timestamp: ts, sprint_id: 'sprint-skip' },
+      { event: 'evidence_skipped', phase: '4', reason: 'r2', timestamp: ts, sprint_id: 'sprint-skip' },
+      { event: 'evidence_skipped', phase: '5', reason: 'r3', timestamp: ts, sprint_id: 'sprint-skip' },
+    ]);
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const code = await handleRetro(['--days', '7']);
+    const output = logSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    logSpy.mockRestore();
+
+    expect(code).toBe(0);
+    expect(output).toContain('⚠️');
+    expect(output).toContain('sprint-skip');
+    expect(output).toContain('used skip 3 times');
+  });
+
+  // TDD: written RED first (G phase per design §12)
+  test('(d) duration_anomaly entries excluded from avg_ms', async () => {
+    cleanDir();
+    const ts = new Date().toISOString();
+    writeAudit([
+      { gate_id: 'gate-1', gate_name: 'g1', passed: true, issues_found: 0, duration_ms: 100, timestamp: ts, trigger: 'manual', repo_path: TMP_DIR, commit_hash: 'abc' },
+      { gate_id: 'gate-1', gate_name: 'g1', passed: true, issues_found: 0, duration_ms: 200, timestamp: ts, trigger: 'manual', repo_path: TMP_DIR, commit_hash: 'abc' },
+      { gate_id: 'gate-1', gate_name: 'g1', passed: true, issues_found: 0, duration_ms: 99999, duration_anomaly: true, timestamp: ts, trigger: 'manual', repo_path: TMP_DIR, commit_hash: 'abc' },
+    ]);
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const code = await handleRetro(['--days', '7']);
+    const output = logSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    logSpy.mockRestore();
+
+    expect(code).toBe(0);
+    // avg_ms = (100+200)/2 = 150 (anomaly excluded)
+    expect(output).toContain('150ms');
+    // If anomaly were included: (100+200+99999)/3 ≈ 33433ms
+    expect(output).not.toContain('33433ms');
+  });
+});