@boyingliu01/xp-gate 0.24.0 → 0.26.0

package/lib/phase-transition.js

@@ -532,12 +532,14 @@ async function handlePhaseTransition(args = []) {
     console.log('  --render           Render ASCII dashboard after transition');
     console.log('  --dir <path>       Project directory (default: cwd)');
     console.log('  --skip-evidence <reason>  Skip evidence validation (requires reason)');
+    console.log('  --force            Override the phase sequence guard (#519)');
     console.log('');
     console.log('Examples:');
     console.log('  xp-gate phase-transition 1 completed');
     console.log('  xp-gate phase-transition 3 completed --render');
     console.log('  xp-gate phase-transition 2 in_progress --outputs \'{"spec":"path.yaml"}\'');
     console.log('  xp-gate phase-transition 4 completed --skip-evidence "Emergency hotfix"');
+    console.log('  xp-gate phase-transition 3 completed --force   # skip-order override');
     return 0;
   }
 
@@ -576,6 +578,9 @@ async function handlePhaseTransition(args = []) {
     }
   }
 
+  // #519: explicit override for the sequence guard below.
+  const forceTransition = args.includes('--force');
+
   // Validate inputs
   if (phase < 1 || phase > 6) {
     console.error(`Error: Phase must be 1-6, got ${phase}`);
@@ -592,6 +597,37 @@ async function handlePhaseTransition(args = []) {
   try {
     const manager = new SprintStateManager(projectDir);
 
+    // ── #519 Layer 0: Sequence guard ──
+    // `completed` on phase n requires phase n-1 to be completed/skipped first.
+    // #507 proved that a missed transition is invisible in the state file (the
+    // pointer just looks "not yet advanced"), so out-of-order completion —
+    // skipping a phase, or completing from a stale pointer — must be refused
+    // loudly rather than written silently. `--force` overrides for the rare
+    // legitimate case (e.g. retroactively recording a skipped phase).
+    if (status === 'completed' && phase >= 2) {
+      const seqState = manager.read();
+      if (seqState && Array.isArray(seqState.phase_history)) {
+        const prevPhase = phase - 1;
+        const prevEntry = seqState.phase_history.find(e => e.phase === prevPhase);
+        const prevOk = prevEntry && (prevEntry.status === 'completed' || prevEntry.status === 'skipped');
+        if (!prevOk && !forceTransition) {
+          const summary = seqState.phase_history
+            .map(e => `  ${e.phase}:${e.phase_name || PHASE_NAMES[e.phase] || '?'} = ${e.status}`)
+            .join('\n');
+          console.error(`❌ [sprint-audit] Cannot complete phase ${phase} (${PHASE_NAMES[phase]}):`);
+          console.error(`   phase ${prevPhase} (${PHASE_NAMES[prevPhase]}) is not completed/skipped.`);
+          console.error('   Current phase history:');
+          console.error(summary || '  (empty)');
+          console.error(`   Advance it first: xp-gate phase-transition ${prevPhase} completed`);
+          console.error('   Or override explicitly: --force');
+          return 1;
+        }
+        if (!prevOk && forceTransition) {
+          console.warn(`⚠️  [sprint-audit] Sequence guard overridden (--force): phase ${prevPhase} is not completed/skipped.`);
+        }
+      }
+    }
+
     // ── Layer 1: Pre-transition gate check ──
     // Check BEFORE transitionPhase() to validate previous phase completion.
     // Runs when status === 'in_progress' and phase >= 2.
@@ -640,9 +676,34 @@ async function handlePhaseTransition(args = []) {
       }
     }
 
+    // Capture the before-image for the echo below (#519). Read once here so a
+    // concurrent writer cannot make before/after disagree about their baseline.
+    const beforeSnapshot = (() => {
+      try {
+        const s = manager.read();
+        if (!s) return { phase: undefined, status: undefined, entryStatus: undefined };
+        const e = Array.isArray(s.phase_history) ? s.phase_history.find(x => x.phase === phase) : undefined;
+        return { phase: s.phase, status: s.status, entryStatus: e ? e.status : undefined };
+      } catch {
+        return { phase: undefined, status: undefined, entryStatus: undefined };
+      }
+    })();
+
     const newState = manager.transitionPhase(phase, status, { outputs });
 
+    // #519: before/after echo. The #507 failure mode was "the command either
+    // never ran or ran without effect" — both look identical in a terminal that
+    // prints only a success line. Printing the observed state on both sides
+    // makes those two cases distinguishable in the output itself.
+    const afterEntry = Array.isArray(newState.phase_history)
+      ? newState.phase_history.find(e => e.phase === phase)
+      : undefined;
+    const oldTop = `${beforeSnapshot.phase ?? '-'}/${beforeSnapshot.status ?? '-'}`;
+    const newTop = `${newState.phase ?? '-'}/${newState.status ?? '-'}`;
+    const oldEntry = beforeSnapshot.entryStatus ?? '(none)';
+    const newEntryStatus = afterEntry ? afterEntry.status : '(none)';
     console.log(`✅ Phase ${phase} transitioned to '${status}'`);
+    console.log(`   before→after  phase/status: ${oldTop} → ${newTop}  |  phase ${phase} entry: ${oldEntry} → ${newEntryStatus}`);
 
     // ── Layer 1.5: Auto-trigger Layer 2 reminder on Phase 6 completed ──
     if (phase === 6 && status === 'completed') {

package/lib/sprint-state-manager.js

@@ -12,6 +12,38 @@ const fs = require('fs');
 const path = require('path');
 const { migrateState, createInitialState, rollbackState, LEGACY_PHASE_MAP } = require('./sprint-state-migrator');
 
+/** Canonical phase order; index = phase - 1. */
+const PHASE_NAMES = ['PREP', 'DESIGN', 'BUILD', 'VERIFY', 'SHIP', 'CLOSE'];
+
+/**
+ * Apply a status change to the phase_history entry for `phase`, creating it on
+ * first sight, and stamp started_at/completed_at/duration_seconds.
+ *
+ * Module-level and pure (it only mutates the passed-in state), extracted from
+ * transitionPhase (#519) so that method stays within the long-function budget.
+ */
+function applyHistoryEntry(state, phase, phaseName, status) {
+  let entry = state.phase_history.find(e => e.phase === phase);
+  if (!entry) {
+    entry = { phase, phase_name: phaseName, status };
+    state.phase_history.push(entry);
+  }
+
+  entry.status = status;
+  if (status === 'in_progress' && !entry.started_at) {
+    entry.started_at = new Date().toISOString();
+  }
+  if (status === 'completed' || status === 'skipped') {
+    entry.completed_at = new Date().toISOString();
+    if (entry.started_at) {
+      const startMs = new Date(entry.started_at).getTime();
+      const endMs = new Date(entry.completed_at).getTime();
+      entry.duration_seconds = Math.round((endMs - startMs) / 1000);
+    }
+  }
+  return entry;
+}
+
 class SprintStateManager {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
@@ -48,59 +80,57 @@ class SprintStateManager {
   }
 
   write(state) {
-    // Ensure state directory exists
-    if (!fs.existsSync(this.stateDir)) {
-      fs.mkdirSync(this.stateDir, { recursive: true });
+    try {
+      if (!fs.existsSync(this.stateDir)) {
+        fs.mkdirSync(this.stateDir, { recursive: true });
+      }
+      // Atomic write: write to tmp, then rename
+      const tmpFile = this.stateFile + '.tmp';
+      fs.writeFileSync(tmpFile, JSON.stringify(state, null, 2), 'utf8');
+      fs.renameSync(tmpFile, this.stateFile);
+    } catch (err) {
+      throw new Error(`Failed to write sprint state: ${err.message}`);
     }
-
-    // Atomic write: write to tmp, then rename
-    const tmpFile = this.stateFile + '.tmp';
-    fs.writeFileSync(tmpFile, JSON.stringify(state, null, 2), 'utf8');
-    fs.renameSync(tmpFile, this.stateFile);
   }
 
   transitionPhase(phase, status, options = {}) {
     const state = this.read() || createInitialState(this.projectRoot);
 
-    // Update current phase
-    state.phase = phase;
-
-    // Find or create phase_history entry
-    const phaseNames = ['PREP', 'DESIGN', 'BUILD', 'VERIFY', 'SHIP', 'CLOSE'];
-    const phaseName = phaseNames[phase - 1];
-
-    let entry = state.phase_history.find(e => e.phase === phase);
-    if (!entry) {
-      entry = {
-        phase,
-        phase_name: phaseName,
-        status,
-      };
-      state.phase_history.push(entry);
-    }
+    // Capture the before-image so the caller can echo a before/after
+    // comparison. #519: the same values feed the append-only audit log.
+    const beforePhase = state.phase;
+    const beforeEntry = Array.isArray(state.phase_history)
+      ? state.phase_history.find(e => e.phase === phase)
+      : undefined;
+    const beforeStatus = beforeEntry ? beforeEntry.status : undefined;
 
-    // Update entry
-    entry.status = status;
-    if (status === 'in_progress' && !entry.started_at) {
-      entry.started_at = new Date().toISOString();
-    }
-    if (status === 'completed' || status === 'skipped') {
-      entry.completed_at = new Date().toISOString();
-      if (entry.started_at) {
-        const startMs = new Date(entry.started_at).getTime();
-        const endMs = new Date(entry.completed_at).getTime();
-        entry.duration_seconds = Math.round((endMs - startMs) / 1000);
-      }
-    }
+    state.phase = phase;
+    const phaseName = PHASE_NAMES[phase - 1];
+    applyHistoryEntry(state, phase, phaseName, status);
 
-    // Update outputs if provided
     if (options.outputs) {
       state.outputs = { ...state.outputs, ...options.outputs };
     }
 
-    // Write state atomically
     this.write(state);
 
+    // #519: append-only transition audit. The #507 incident proved that a
+    // MISSED transition is invisible in the state file — the pointer drift
+    // looked identical to a legitimately-not-yet-run phase. A per-transition
+    // record — from/to plus statuses — lets post-mortems distinguish "never
+    // ran" from "ran and was overwritten". Best-effort: a logging failure must
+    // never break the transition, same contract as the onTransition callback.
+    this.appendTransitionAudit({
+      phase,
+      phase_name: phaseName,
+      from_phase: beforePhase,
+      // from_status === undefined together with a defined to_status is exactly
+      // what proves the phase was reached from nothing — i.e. never ran.
+      from_status: beforeStatus,
+      to_status: status,
+      timestamp: new Date().toISOString(),
+    });
+
     // Trigger onTransition callback (for auto-render)
     if (typeof options.onTransition === 'function') {
       try {
@@ -114,6 +144,23 @@ class SprintStateManager {
     return state;
   }
 
+  /**
+   * Append one JSON line to .sprint-state/transition-audit.jsonl (#519).
+   * Never throws — audit is evidence, not a gate.
+   * @param {object} record
+   */
+  appendTransitionAudit(record) {
+    try {
+      if (!fs.existsSync(this.stateDir)) {
+        fs.mkdirSync(this.stateDir, { recursive: true });
+      }
+      const auditFile = path.join(this.stateDir, 'transition-audit.jsonl');
+      fs.appendFileSync(auditFile, JSON.stringify(record) + '\n', 'utf8');
+    } catch (err) {
+      console.warn(`[WARN] transition audit write failed: ${err.message}`);
+    }
+  }
+
   rollback() {
     return rollbackState(this.stateFile, this.backupFile);
   }

package/lib/sprint-state-migrator.js

@@ -57,18 +57,9 @@ function migrateState(state, stateDir) {
   if (!state.phase_history) { state.phase_history = []; }
   if (!state.isolation) { state.isolation = { worktree_path: null, branch: null }; }
 
-  state.phase_history = state.phase_history.map(entry => {
-    const phaseNum = String(entry.phase);
-    const mapped = LEGACY_PHASE_MAP[phaseNum];
-    if (mapped) {
-      warnings.push(`Migrated legacy phase ${entry.phase} → ${mapped.phase} (${mapped.phase_name})`);
-      return { ...entry, phase: mapped.phase, phase_name: mapped.phase_name };
-    }
-    if (!entry.phase_name && entry.phase >= 1 && entry.phase <= 6) {
-      entry.phase_name = PHASE_NAMES[entry.phase - 1];
-    }
-    return entry;
-  });
+  state.phase_history = state.phase_history.map(entry =>
+    normalizePhaseEntry(entry, warnings),
+  );
 
   const currentPhaseNum = String(state.phase);
   const currentMapped = LEGACY_PHASE_MAP[currentPhaseNum];
@@ -91,6 +82,47 @@ function migrateState(state, stateDir) {
   return state;
 }
 
+/**
+ * Migrate and normalize a single phase_history entry.
+ *
+ * Two passes, in this order:
+ *   1. legacy numbering → current numbering via LEGACY_PHASE_MAP;
+ *   2. field normalization: phase 1 historically carried `name` while phase 2+
+ *      carried `phase_name` (transitionPhase always writes `phase_name`).
+ *      Normalize to `phase_name` as the single canonical field, in BOTH
+ *      directions so a half-migrated file converges. The legacy `name` is kept
+ *      (not deleted) so any reader still consulting it keeps working.
+ *
+ * Ordering matters: the normalization must run for every entry, including those
+ * the legacy remap just rewrote — LEGACY_PHASE_MAP covers every phase 1-6, so
+ * gating normalization on "not remapped" would skip exactly the legacy files it
+ * exists for. (#507 left such a file: phase 1 with `name: 'PREP'`, phase 2+
+ * with `phase_name`.)
+ *
+ * @param {Object} entry - One phase_history entry (possibly legacy-shaped)
+ * @param {string[]} warnings - Accumulator for human-readable migration notes
+ * @returns {Object} The normalized entry
+ */
+function normalizePhaseEntry(entry, warnings) {
+  const phaseNum = String(entry.phase);
+  const mapped = LEGACY_PHASE_MAP[phaseNum];
+  if (mapped) {
+    warnings.push(`Migrated legacy phase ${entry.phase} → ${mapped.phase} (${mapped.phase_name})`);
+    entry = { ...entry, phase: mapped.phase, phase_name: mapped.phase_name };
+  }
+
+  if (!entry.phase_name && entry.name) {
+    entry.phase_name = entry.name;
+  }
+  if (!entry.phase_name && entry.phase >= 1 && entry.phase <= 6) {
+    entry.phase_name = PHASE_NAMES[entry.phase - 1];
+  }
+  if (!entry.name && entry.phase_name) {
+    entry.name = entry.phase_name;
+  }
+  return entry;
+}
+
 /**
  * Create initial sprint state for new sprints.
  *
@@ -120,17 +152,23 @@ function createInitialState(projectRoot) {
  * @param {string} stateDir - Path to .sprint-state directory
  */
 function logMigrationWarnings(warnings, stateDir) {
-  if (!fs.existsSync(stateDir)) {
-    fs.mkdirSync(stateDir, { recursive: true });
-  }
-
-  const warningsFile = path.join(stateDir, 'migration-warnings.json');
-  const existing = fs.existsSync(warningsFile)
-    ? JSON.parse(fs.readFileSync(warningsFile, 'utf8'))
-    : [];
+  try {
+    if (!fs.existsSync(stateDir)) {
+      fs.mkdirSync(stateDir, { recursive: true });
+    }
 
-  existing.push({ timestamp: new Date().toISOString(), warnings });
-  fs.writeFileSync(warningsFile, JSON.stringify(existing, null, 2), 'utf8');
+    const warningsFile = path.join(stateDir, 'migration-warnings.json');
+    const existing = fs.existsSync(warningsFile)
+      ? JSON.parse(fs.readFileSync(warningsFile, 'utf8'))
+      : [];
+
+    existing.push({ timestamp: new Date().toISOString(), warnings });
+    fs.writeFileSync(warningsFile, JSON.stringify(existing, null, 2), 'utf8');
+  } catch (err) {
+    // Migration must still return the migrated state; a failure to persist the
+    // warning log is reported to stderr and never thrown.
+    console.warn(`[WARN] could not write migration warnings: ${err.message}`);
+  }
 }
 
 /**

package/mock-policy/AGENTS.md

@@ -1,9 +1,9 @@
 # SRC/MOCK-POLICY KNOWLEDGE BASE
 
-**Generated:** 2026-10-14
-**Commit:** e466ce16
+**Generated:** 2026-10-16
+**Commit:** 98096abe
 **Branch:** main
-**Version:** 0.24.0.0
+**Version:** 0.26.0.0
 
 ## OVERVIEW
 Mock layering policy enforcement — Gate M3 of pre-push hook. Ensures integration tests use real implementations for internal dependencies, mock external dependencies, and annotate pending mocks with removal plans. Combines project scope scanning, mock decision engine, and per-file validation into a single pipeline.

package/mutation/AGENTS.md

@@ -1,9 +1,9 @@
 # SRC/MUTATION KNOWLEDGE BASE
 
-**Generated:** 2026-10-14
-**Commit:** e466ce16
+**Generated:** 2026-10-16
+**Commit:** 98096abe
 **Branch:** main
-**Version:** 0.24.0.0
+**Version:** 0.26.0.0
 
 ## OVERVIEW
 **Gate M** (incremental mutation testing) + **Gate M2** helpers (test-layer detection used by `src/mock-policy/`). Pre-push quality gate. TypeScript-only; uses Stryker.

package/mutation/__tests__/gremlins-runner.test.ts

@@ -0,0 +1,167 @@
+/**
+ * @intent #410: mutmut 3.x depends on fork() and cannot run natively on
+ *         Windows — Gate M (Python) formed a structural deadlock (installed =>
+ *         always blocked, uninstalled => always skipped). pytest-gremlins is
+ *         architecturally cross-platform (mutation switching, no fork), so it
+ *         becomes the second engine. This runner drives
+ *         `pytest --gremlins` and parses the console report.
+ * @covers GremlinsRunner availability probe + console report parsing
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { spawn, execSync, type ChildProcess } from 'child_process';
+
+vi.mock('child_process', () => ({
+  spawn: vi.fn(),
+  execSync: vi.fn(),
+}));
+
+/** Capture the stdout/close callbacks so the test can drive them by hand. */
+function mockChild(capture: {
+  stdout?: (cb: (d: Buffer) => void) => void;
+  stderr?: (cb: (d: Buffer) => void) => void;
+  close?: (cb: (code: number | null) => void) => void;
+  error?: (cb: (e: Error) => void) => void;
+}): ChildProcess {
+  return {
+    stdout: { on: (_e: string, cb: (d: Buffer) => void) => capture.stdout?.(cb) },
+    stderr: { on: (_e: string, cb: (d: Buffer) => void) => capture.stderr?.(cb) },
+    on: (event: string, cb: (arg: never) => void) => {
+      if (event === 'close') capture.close?.(cb as (code: number | null) => void);
+      if (event === 'error') capture.error?.(cb as unknown as (e: Error) => void);
+    },
+    kill: vi.fn(),
+  } as unknown as ChildProcess;
+}
+
+describe('GremlinsRunner', () => {
+  let GremlinsRunner: typeof import('../runners/gremlins-runner').GremlinsRunner;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    vi.mocked(execSync).mockReset();
+    vi.mocked(spawn).mockReset();
+    vi.mocked(execSync).mockReturnValue('' as never);
+    GremlinsRunner = (await import('../runners/gremlins-runner')).GremlinsRunner;
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it('declares the pytest-gremlins engine name and the py extension', () => {
+    const runner = new GremlinsRunner();
+    expect(runner.name).toBe('pytest-gremlins');
+    expect(runner.extensions).toEqual(['py']);
+  });
+
+  it('isAvailable probes the pytest_gremlins import', async () => {
+    const runner = new GremlinsRunner();
+    await expect(runner.isAvailable()).resolves.toBe(true);
+    const probed = vi.mocked(execSync).mock.calls[0]?.[0] as string;
+    expect(probed).toContain('import pytest_gremlins');
+  });
+
+  it('isAvailable returns false when the import probe fails', async () => {
+    vi.mocked(execSync).mockImplementation(() => {
+      throw new Error('ModuleNotFoundError');
+    });
+    const runner = new GremlinsRunner();
+    await expect(runner.isAvailable()).resolves.toBe(false);
+  });
+
+  it('parses the console report (Zapped/Survived) into a normalized result', async () => {
+    let closeCb: ((code: number | null) => void) | undefined;
+    let stdoutCb: ((d: Buffer) => void) | undefined;
+    vi.mocked(spawn).mockReturnValue(
+      mockChild({
+        stdout: cb => { stdoutCb = cb; },
+        close: cb => { closeCb = cb; },
+      }),
+    );
+
+    const runner = new GremlinsRunner();
+    const promise = runner.run({ files: ['src/foo.py'], timeoutMs: 5000, cwd: '/tmp' });
+    await new Promise(r => setTimeout(r, 0));
+
+    stdoutCb?.(
+      Buffer.from(
+        '================== pytest-gremlins mutation report ==================\n' +
+          'Zapped: 142 gremlins (89%)\n' +
+          'Survived: 18 gremlins (11%)\n' +
+          '=====================================================================\n',
+      ),
+    );
+    closeCb?.(0);
+
+    const outcome = await promise;
+    expect(outcome.report).not.toBeNull();
+    expect(outcome.report?.nrOfKilledMutants).toBe(142);
+    expect(outcome.report?.nrOfSurvivedMutants).toBe(18);
+    expect(outcome.report?.nrOfMutants).toBe(160);
+    expect(Math.round(outcome.report!.mutationScore)).toBe(89);
+    expect(outcome.timedOut).toBe(false);
+  });
+
+  it('returns report=null (never throws) when the report lines are absent', async () => {
+    let closeCb: ((code: number | null) => void) | undefined;
+    vi.mocked(spawn).mockReturnValue(mockChild({ stdout: () => {}, close: cb => { closeCb = cb; } }));
+
+    const runner = new GremlinsRunner();
+    const promise = runner.run({ files: ['src/foo.py'], timeoutMs: 5000, cwd: '/tmp' });
+    await new Promise(r => setTimeout(r, 0));
+    closeCb?.(1);
+
+    const outcome = await promise;
+    expect(outcome.report).toBeNull();
+  });
+
+  it('returns report=null when the report has zero gremlins', async () => {
+    let closeCb: ((code: number | null) => void) | undefined;
+    let stdoutCb: ((d: Buffer) => void) | undefined;
+    vi.mocked(spawn).mockReturnValue(
+      mockChild({ stdout: cb => { stdoutCb = cb; }, close: cb => { closeCb = cb; } }),
+    );
+
+    const runner = new GremlinsRunner();
+    const promise = runner.run({ files: ['src/foo.py'], timeoutMs: 5000, cwd: '/tmp' });
+    await new Promise(r => setTimeout(r, 0));
+    stdoutCb?.(Buffer.from('Zapped: 0 gremlins (0%)\nSurvived: 0 gremlins (0%)\n'));
+    closeCb?.(0);
+
+    const outcome = await promise;
+    expect(outcome.report).toBeNull();
+  });
+
+  it('passes --gremlin-targets derived from the changed file directories', async () => {
+    let closeCb: ((code: number | null) => void) | undefined;
+    vi.mocked(spawn).mockReturnValue(mockChild({ stdout: () => {}, close: cb => { closeCb = cb; } }));
+
+    const runner = new GremlinsRunner();
+    const promise = runner.run({ files: ['src/foo/bar.py', 'src/baz.py'], timeoutMs: 5000, cwd: '/tmp' });
+    await new Promise(r => setTimeout(r, 0));
+    closeCb?.(0);
+    await promise;
+
+    const spawnArgs = vi.mocked(spawn).mock.calls[0]?.[1] as string[];
+    const joined = spawnArgs.join(' ');
+    expect(joined).toContain('--gremlins');
+    expect(joined).toContain('--gremlin-targets=src/foo,src');
+  });
+
+  it('reports timedOut when the child exceeds the deadline', async () => {
+    let closeCb: ((code: number | null) => void) | undefined;
+    const child = mockChild({ stdout: () => {}, close: cb => { closeCb = cb; } });
+    vi.mocked(spawn).mockReturnValue(child);
+
+    const runner = new GremlinsRunner();
+    const promise = runner.run({ files: ['src/foo.py'], timeoutMs: 1, cwd: '/tmp' });
+    await new Promise(r => setTimeout(r, 20));
+    closeCb?.(null);
+
+    const outcome = await promise;
+    expect(outcome.timedOut).toBe(true);
+    expect(child.kill).toHaveBeenCalled();
+  });
+});

package/mutation/__tests__/mutmut-runner.test.ts

@@ -119,7 +119,7 @@ describe('MutmutRunner', () => {
     it('should return true when mutmut is installed', async () => {
       vi.mocked(execSync).mockReturnValue('mutmut, version 3.0.0\n');
 
-      const runner = new MutmutRunner();
+      const runner = new MutmutRunner('linux');
       const result = await runner.isAvailable();
       expect(result).toBe(true);
       expect(execSync).toHaveBeenCalledWith('mutmut --version', {
@@ -150,9 +150,11 @@ describe('MutmutRunner', () => {
       const result = await runner.isAvailable();
 
       expect(result).toBe(true);
-      expect(execSync).toHaveBeenNthCalledWith(2, 'wsl mutmut --version', {
+      // #410: win32 route is decided by the WSL probe alone (no native probe).
+      expect(execSync).toHaveBeenCalledTimes(1);
+      expect(execSync).toHaveBeenCalledWith('wsl mutmut --version', {
         stdio: 'pipe',
-        timeout: 5000,
+        timeout: 10000,
       });
     });
 
@@ -205,7 +207,7 @@ describe('MutmutRunner', () => {
       // No existing pyproject.toml
       vi.mocked(existsSync).mockReturnValue(false);
 
-      const runner = new MutmutRunner();
+      const runner = new MutmutRunner('linux');
       const promise = runner.run({
         files: ['src/main.py'],
         timeoutMs: 60000,
@@ -235,14 +237,12 @@ describe('MutmutRunner', () => {
       expect(result.report!.nrOfSurvivedMutants).toBe(29);
     });
 
-    it('should execute native mutmut when native detection succeeds on Windows', async () => {
-      let closeCb: ((code: number | null) => void) | null = null;
+    it('should be unavailable on Windows when WSL is absent even if native mutmut is installed', async () => {
       const mockChild = {
         stdout: { on: vi.fn() },
         stderr: { on: vi.fn() },
-        on: vi.fn((event: string, cb: (code: number | null) => void) => {
-          if (event === 'close') closeCb = cb;
-        }),
+        // Unavailable route: `run()` never spawns, so `close` is never subscribed.
+        on: vi.fn(),
         kill: vi.fn(),
         killed: false,
       };
@@ -254,22 +254,17 @@ describe('MutmutRunner', () => {
       vi.mocked(existsSync).mockReturnValue(false);
 
       const runner = new MutmutRunner('win32');
-      expect(await runner.isAvailable()).toBe(true);
-      const promise = runner.run({
+      // #410: native mutmut on Windows proves nothing about `mutmut run`
+      // (fork()-based). The WSL route decides availability; no WSL → SKIP.
+      expect(await runner.isAvailable()).toBe(false);
+      const outcome = await runner.run({
         files: ['src/main.py'],
         timeoutMs: 60000,
         cwd: 'C:\\work\\project',
       });
-      await waitForSpawn();
-      closeCb!(0);
-      await promise;
 
-      expect(execSync).toHaveBeenCalledTimes(1);
-      expect(spawn).toHaveBeenCalledWith(
-        'mutmut',
-        ['run'],
-        expect.objectContaining({ cwd: 'C:\\work\\project' }),
-      );
+      expect(outcome).toEqual({ report: null, timedOut: false });
+      expect(spawn).not.toHaveBeenCalled();
     });
 
     it('should execute selected WSL route with Linux --cd and Windows host cwd', async () => {
@@ -428,7 +423,7 @@ describe('MutmutRunner', () => {
         expect(vi.mocked(spawn).mock.calls[0]?.[0]).toBe('wsl');
     });
 
-    it('should follow repeated WSL to native availability transitions', async () => {
+    it('should keep the WSL route on Windows even when native mutmut becomes available', async () => {
       const mockChild = {
         stdout: { on: vi.fn() },
         stderr: { on: vi.fn() },
@@ -450,10 +445,13 @@ describe('MutmutRunner', () => {
       const runner = new MutmutRunner('win32');
       expect(await runner.isAvailable()).toBe(true);
       nativeAvailable = true;
+      // #410: even when native `mutmut --version` starts succeeding, the win32
+      // route is decided by WSL alone — native success proves nothing about
+      // `mutmut run` (fork()). The route must NOT flip to native.
       expect(await runner.isAvailable()).toBe(true);
       await runner.run({ files: ['src/main.py'], timeoutMs: 60000, cwd: 'C:\\repo' });
 
-      expect(vi.mocked(spawn).mock.calls[0]?.[0]).toBe('mutmut');
+      expect(vi.mocked(spawn).mock.calls[0]?.[0]).toBe('wsl');
     });
 
     it('should stop spawning after availability transitions to unavailable', async () => {