@mutineerjs/mutineer 0.6.0 → 0.8.0

package/dist/runner/vitest/__tests__/pool.spec.js

@@ -160,4 +160,89 @@ describe('VitestPool', () => {
         const result = await runWithPool(mockPool, mutant, []);
         expect(result.status).toBe('error');
     });
+    it('passes MUTINEER_ACTIVE_ID_FILE env var to worker process', async () => {
+        let capturedEnv;
+        vi.mocked(childProcess.spawn).mockImplementationOnce((_cmd, _args, options) => {
+            capturedEnv = options?.env;
+            const proc = new EventEmitter();
+            proc.stdout = new EventEmitter();
+            proc.stderr = new EventEmitter();
+            proc.stdin = { writes: [], write: vi.fn() };
+            proc.kill = vi.fn();
+            return proc;
+        });
+        const rl = new EventEmitter();
+        vi.mocked(readline.createInterface).mockImplementationOnce(() => rl);
+        const cwd = '/my/project';
+        const pool = new VitestPool({ cwd, concurrency: 1 });
+        // Start init — synchronous part (spawn + createInterface) runs immediately
+        const initPromise = pool.init();
+        // Give event loop one tick so the async suspend in worker.start() is reached
+        await new Promise((resolve) => setImmediate(resolve));
+        // Verify env var was passed to spawn before completing init
+        expect(capturedEnv?.MUTINEER_ACTIVE_ID_FILE).toBe('/my/project/__mutineer__/active_id_w0.txt');
+        // Emit ready to unblock initPromise
+        rl.emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        // Shutdown: emit the shutdown response so worker.shutdown() resolves
+        const shutdownPromise = pool.shutdown();
+        await new Promise((resolve) => setImmediate(resolve));
+        rl.emit('line', JSON.stringify({ type: 'shutdown', ok: true }));
+        await shutdownPromise;
+    });
+    it('spawns workers with detached: true for process group isolation', async () => {
+        let capturedOptions;
+        vi.mocked(childProcess.spawn).mockImplementationOnce((_cmd, _args, options) => {
+            capturedOptions = options;
+            const proc = new EventEmitter();
+            proc.stdout = new EventEmitter();
+            proc.stderr = new EventEmitter();
+            proc.stdin = { writes: [], write: vi.fn() };
+            proc.kill = vi.fn();
+            return proc;
+        });
+        const rl = new EventEmitter();
+        vi.mocked(readline.createInterface).mockImplementationOnce(() => rl);
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1 });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        expect(capturedOptions?.detached).toBe(true);
+        rl.emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        const shutdownPromise = pool.shutdown();
+        await new Promise((r) => setImmediate(r));
+        rl.emit('line', JSON.stringify({ type: 'shutdown', ok: true }));
+        await shutdownPromise;
+    });
+    it('kills entire process group (negative PID) on mutant run timeout', async () => {
+        const mockProc = new EventEmitter();
+        mockProc.stdout = new EventEmitter();
+        mockProc.stderr = new EventEmitter();
+        mockProc.stdin = { writes: [], write: vi.fn() };
+        mockProc.kill = vi.fn();
+        mockProc.pid = 42000;
+        vi.mocked(childProcess.spawn).mockReturnValueOnce(mockProc);
+        const rl = new EventEmitter();
+        vi.mocked(readline.createInterface).mockReturnValueOnce(rl);
+        const killSpy = vi.spyOn(process, 'kill').mockReturnValue(true);
+        // Use a very short timeoutMs so the test doesn't wait long
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1, timeoutMs: 50 });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        rl.emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        const mutant = {
+            id: 't1',
+            name: 'test',
+            file: 'a.ts',
+            code: 'x',
+            line: 1,
+            col: 1,
+        };
+        // Don't emit a 'result' line — let the 50ms timeout fire and call kill()
+        const result = await pool.run(mutant, ['a.spec.ts']);
+        expect(result).toMatchObject({ error: 'timeout' });
+        expect(killSpy).toHaveBeenCalledWith(-42000, 'SIGKILL');
+        killSpy.mockRestore();
+    });
 });

package/dist/runner/vitest/__tests__/worker-runtime.spec.js

@@ -95,6 +95,15 @@ describe('VitestWorkerRuntime', () => {
         expect(createVitest).toHaveBeenCalledWith('test', expect.objectContaining({ config: '/custom/vitest.config.ts' }), expect.any(Object));
         await runtime.shutdown();
     });
+    it('passes maxWorkers: 1 and watch: false to createVitest to prevent fork resource contention and FS watcher re-runs', async () => {
+        const { createVitest } = await import('vitest/node');
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w-mw', cwd: tmp });
+        await runtime.init();
+        expect(createVitest).toHaveBeenCalledWith('test', expect.objectContaining({ maxWorkers: 1, watch: false }), expect.any(Object));
+        await runtime.shutdown();
+    });
     it('handles non-Error thrown during run', async () => {
         runSpecsFn.mockRejectedValue('string error');
         const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-'));
@@ -156,4 +165,121 @@ describe('VitestWorkerRuntime', () => {
         expect(result.killed).toBe(false);
         await runtime.shutdown();
     });
+    it('writes setup.mjs when MUTINEER_ACTIVE_ID_FILE is set', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-setup-'));
+        tmpFiles.push(tmp);
+        const activeIdFile = path.join(tmp, '__mutineer__', 'active_id_wx.txt');
+        const origEnv = process.env.MUTINEER_ACTIVE_ID_FILE;
+        process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+        try {
+            const runtime = createVitestWorkerRuntime({ workerId: 'wx', cwd: tmp });
+            await runtime.init();
+            const setupFile = path.join(tmp, '__mutineer__', 'setup.mjs');
+            expect(fs.existsSync(setupFile)).toBe(true);
+            expect(fs.readFileSync(setupFile, 'utf8')).toContain('beforeAll');
+            await runtime.shutdown();
+        }
+        finally {
+            if (origEnv === undefined) {
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+            else {
+                process.env.MUTINEER_ACTIVE_ID_FILE = origEnv;
+            }
+        }
+    });
+    it('uses schema path when isFallback is false and MUTINEER_ACTIVE_ID_FILE is set', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-schema-'));
+        tmpFiles.push(tmp);
+        const activeIdFile = path.join(tmp, '__mutineer__', 'active_id_ws.txt');
+        const origEnv = process.env.MUTINEER_ACTIVE_ID_FILE;
+        process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+        try {
+            const runtime = createVitestWorkerRuntime({ workerId: 'ws', cwd: tmp });
+            await runtime.init();
+            await runtime.run({
+                id: 'mut#schema',
+                name: 'm',
+                file: path.join(tmp, 'src.ts'),
+                code: 'export const x=1',
+                line: 1,
+                col: 1,
+                isFallback: false,
+            }, [path.join(tmp, 'test.ts')]);
+            // invalidateFile should NOT be called for schema path
+            expect(invalidateFn).not.toHaveBeenCalled();
+            // Active ID file should be cleared after run
+            expect(fs.readFileSync(activeIdFile, 'utf8')).toBe('');
+            await runtime.shutdown();
+        }
+        finally {
+            if (origEnv === undefined) {
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+            else {
+                process.env.MUTINEER_ACTIVE_ID_FILE = origEnv;
+            }
+        }
+    });
+    it('uses fallback path when isFallback is true even if MUTINEER_ACTIVE_ID_FILE is set', async () => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-fb-'));
+        tmpFiles.push(tmp);
+        const activeIdFile = path.join(tmp, '__mutineer__', 'active_id_wf.txt');
+        const origEnv = process.env.MUTINEER_ACTIVE_ID_FILE;
+        process.env.MUTINEER_ACTIVE_ID_FILE = activeIdFile;
+        try {
+            const runtime = createVitestWorkerRuntime({ workerId: 'wf', cwd: tmp });
+            await runtime.init();
+            await runtime.run({
+                id: 'mut#fb',
+                name: 'm',
+                file: path.join(tmp, 'src.ts'),
+                code: 'export const x=1',
+                line: 1,
+                col: 1,
+                isFallback: true,
+            }, [path.join(tmp, 'test.ts')]);
+            // invalidateFile SHOULD be called for fallback path
+            expect(invalidateFn).toHaveBeenCalledWith(path.join(tmp, 'src.ts'));
+            await runtime.shutdown();
+        }
+        finally {
+            if (origEnv === undefined) {
+                delete process.env.MUTINEER_ACTIVE_ID_FILE;
+            }
+            else {
+                process.env.MUTINEER_ACTIVE_ID_FILE = origEnv;
+            }
+        }
+    });
+    it('clears state.filesMap before each run to prevent memory accumulation', async () => {
+        const { createVitest } = await import('vitest/node');
+        const clearFn = vi.fn();
+        vi.mocked(createVitest).mockResolvedValueOnce({
+            init: initFn,
+            close: closeFn,
+            runTestSpecifications: runSpecsFn,
+            invalidateFile: invalidateFn,
+            getProjectByName: getProjectByNameFn,
+            state: { filesMap: { clear: clearFn } },
+        });
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mutineer-worker-state-'));
+        tmpFiles.push(tmp);
+        const runtime = createVitestWorkerRuntime({ workerId: 'w-state', cwd: tmp });
+        await runtime.init();
+        const mutant = {
+            id: 'mut#state',
+            name: 'm',
+            file: path.join(tmp, 'src.ts'),
+            code: 'export const x=1',
+            line: 1,
+            col: 1,
+        };
+        await runtime.run(mutant, [path.join(tmp, 'test.ts')]);
+        await runtime.run({ ...mutant, id: 'mut#state2' }, [
+            path.join(tmp, 'test.ts'),
+        ]);
+        expect(clearFn).toHaveBeenCalledTimes(2);
+        await runtime.shutdown();
+    });
 });

package/dist/runner/vitest/adapter.js

@@ -37,6 +37,7 @@ function stripMutineerArgs(args) {
         '--config',
         '-c',
         '--coverage-file',
+        '--shard',
     ]);
     const dropExact = new Set([
         '-m',
@@ -59,6 +60,8 @@ function stripMutineerArgs(args) {
             continue;
         if (a.startsWith('--config=') || a.startsWith('-c='))
             continue;
+        if (a.startsWith('--shard='))
+            continue;
         out.push(a);
     }
     return out;
@@ -127,6 +130,7 @@ export class VitestAdapter {
             cwd: this.options.cwd,
             concurrency: workerCount,
             vitestConfig: this.options.config.vitestConfig,
+            vitestProject: this.options.vitestProject,
             timeoutMs: this.options.timeoutMs,
         });
         await this.pool.init();
@@ -196,15 +200,16 @@ export class VitestAdapter {
         }
     }
     hasCoverageProvider() {
-        try {
-            require.resolve('@vitest/coverage-v8/package.json', {
-                paths: [this.options.cwd],
-            });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        const packages = ['@vitest/coverage-v8', '@vitest/coverage-istanbul'];
+        return packages.some((pkg) => {
+            try {
+                require.resolve(`${pkg}/package.json`, { paths: [this.options.cwd] });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
     }
     async detectCoverageConfig() {
         const configPath = this.options.config.vitestConfig;

package/dist/runner/vitest/plugin.d.ts

@@ -7,6 +7,9 @@
  *
  * The worker process sets globalThis.__mutineer_redirect__ before each test run,
  * and this plugin intercepts module loading to return the mutated code.
+ *
+ * For schema-eligible variants, the plugin serves a pre-built schema file that
+ * embeds all mutations as ternary chains keyed by globalThis.__mutineer_active_id__.
  */
 import type { PluginOption } from 'vite';
 export declare function poolMutineerPlugin(): PluginOption;

package/dist/runner/vitest/plugin.js

@@ -7,22 +7,41 @@
  *
  * The worker process sets globalThis.__mutineer_redirect__ before each test run,
  * and this plugin intercepts module loading to return the mutated code.
+ *
+ * For schema-eligible variants, the plugin serves a pre-built schema file that
+ * embeds all mutations as ternary chains keyed by globalThis.__mutineer_active_id__.
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { getRedirect } from '../shared/index.js';
+import { getRedirect, getSchemaFilePath } from '../shared/index.js';
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('mutineer:swap');
 export function poolMutineerPlugin() {
+    // Cache schema file contents keyed by normalised source path.
+    // null = checked and no schema exists; string = schema code.
+    // Schema files are written once before the pool starts and never change,
+    // so this cache is always valid for the lifetime of the plugin.
+    const schemaCache = new Map();
     return {
         name: 'mutineer:swap',
         enforce: 'pre',
-        load(id) {
-            const redirect = getRedirect();
-            if (!redirect) {
+        config(config) {
+            const activeIdFile = process.env.MUTINEER_ACTIVE_ID_FILE;
+            if (!activeIdFile || !path.isAbsolute(activeIdFile))
                 return null;
-            }
-            // Normalize the module ID, handling query strings
+            const setupFile = path.join(path.dirname(activeIdFile), 'setup.mjs');
+            const testConfig = config.test;
+            const existing = testConfig?.setupFiles;
+            const existingArr = Array.isArray(existing)
+                ? existing
+                : existing
+                    ? [existing]
+                    : [];
+            return {
+                test: { setupFiles: [...existingArr, setupFile] },
+            };
+        },
+        load(id) {
             const cleanId = id.split('?')[0];
             let normalizedId;
             try {
@@ -31,18 +50,37 @@ export function poolMutineerPlugin() {
             catch {
                 return null;
             }
-            // Check if this is the file we're redirecting
-            if (normalizedId === path.resolve(redirect.from)) {
-                // Read the mutated code from the temp file
+            // Redirect takes priority: fallback mutations use setRedirect + invalidateFile.
+            // Must check redirect first so the schema file (which exists for this source)
+            // does not shadow the mutant code during fallback runs.
+            const redirect = getRedirect();
+            if (redirect && normalizedId === path.resolve(redirect.from)) {
                 try {
-                    const mutatedCode = fs.readFileSync(redirect.to, 'utf8');
-                    return mutatedCode;
+                    return fs.readFileSync(redirect.to, 'utf8');
                 }
                 catch (err) {
                     log.error(`Failed to read mutant file: ${redirect.to} ${err}`);
                     return null;
                 }
             }
+            // Schema path: serves pre-built schema file for schema-eligible variants.
+            // Use cache to avoid existsSync + readFileSync on every module import.
+            const cached = schemaCache.get(normalizedId);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const schemaPath = getSchemaFilePath(normalizedId);
+            try {
+                if (fs.existsSync(schemaPath)) {
+                    const code = fs.readFileSync(schemaPath, 'utf8');
+                    schemaCache.set(normalizedId, code);
+                    return code;
+                }
+            }
+            catch {
+                // fall through
+            }
+            schemaCache.set(normalizedId, null);
             return null;
         },
     };

package/dist/runner/vitest/pool.d.ts

@@ -16,13 +16,14 @@ import type { MutantPayload, MutantRunResult, MutantRunSummary } from '../../typ
 declare class VitestWorker extends EventEmitter {
     private readonly cwd;
     private readonly vitestConfig?;
+    private readonly vitestProject?;
     readonly id: string;
     private process;
     private rl;
     private pendingTask;
     private ready;
     private shuttingDown;
-    constructor(id: string, cwd: string, vitestConfig?: string | undefined);
+    constructor(id: string, cwd: string, vitestConfig?: string | undefined, vitestProject?: string | undefined);
     start(): Promise<void>;
     private handleMessage;
     private handleExit;
@@ -36,10 +37,12 @@ export interface VitestPoolOptions {
     cwd: string;
     concurrency: number;
     vitestConfig?: string;
+    vitestProject?: string;
     timeoutMs?: number;
     createWorker?: (id: string, opts: {
         cwd: string;
         vitestConfig?: string;
+        vitestProject?: string;
     }) => VitestWorker;
 }
 export declare class VitestPool {

package/dist/runner/vitest/pool.js

@@ -17,15 +17,17 @@ import * as readline from 'node:readline';
 import * as fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { EventEmitter } from 'node:events';
+import { getActiveIdFilePath } from '../shared/index.js';
 import { createLogger, DEBUG } from '../../utils/logger.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const workerLog = createLogger('VitestWorker');
 const poolLog = createLogger('VitestPool');
 class VitestWorker extends EventEmitter {
-    constructor(id, cwd, vitestConfig) {
+    constructor(id, cwd, vitestConfig, vitestProject) {
         super();
         this.cwd = cwd;
         this.vitestConfig = vitestConfig;
+        this.vitestProject = vitestProject;
         this.process = null;
         this.rl = null;
         this.pendingTask = null;
@@ -54,9 +56,13 @@ class VitestWorker extends EventEmitter {
             ...process.env,
             MUTINEER_WORKER_ID: this.id,
             MUTINEER_CWD: this.cwd,
+            MUTINEER_ACTIVE_ID_FILE: getActiveIdFilePath(this.id, this.cwd),
             ...(this.vitestConfig
                 ? { MUTINEER_VITEST_CONFIG: this.vitestConfig }
                 : {}),
+            ...(this.vitestProject
+                ? { MUTINEER_VITEST_PROJECT: this.vitestProject }
+                : {}),
             ...(DEBUG ? { MUTINEER_DEBUG: '1' } : {}),
         };
         workerLog.debug(`[${this.id}] Starting worker process`);
@@ -71,6 +77,10 @@ class VitestWorker extends EventEmitter {
             cwd: this.cwd,
             env,
             stdio: ['pipe', 'pipe', 'pipe'],
+            // Create own process group so killing this process also kills its
+            // children (Vitest inner forks). Without this, SIGKILL to worker.mjs
+            // orphans the Vitest fork workers.
+            detached: true,
         });
         // Handle stderr (debug/error output)
         this.process.stderr?.on('data', (data) => {
@@ -205,8 +215,16 @@ class VitestWorker extends EventEmitter {
     }
     kill() {
         if (this.process) {
+            const pid = this.process.pid;
             try {
-                this.process.kill('SIGKILL');
+                if (pid !== undefined) {
+                    // Kill the entire process group (negative PID) so Vitest inner fork
+                    // workers die alongside worker.mjs instead of becoming orphans.
+                    process.kill(-pid, 'SIGKILL');
+                }
+                else {
+                    this.process.kill('SIGKILL');
+                }
             }
             catch {
                 // Ignore
@@ -227,6 +245,7 @@ export class VitestPool {
             cwd: options.cwd,
             concurrency: options.concurrency,
             vitestConfig: options.vitestConfig,
+            vitestProject: options.vitestProject,
             timeoutMs: options.timeoutMs ?? 10_000,
             createWorker: options.createWorker,
         };
@@ -240,8 +259,9 @@ export class VitestPool {
             const worker = this.options.createWorker?.(`w${i}`, {
                 cwd: this.options.cwd,
                 vitestConfig: this.options.vitestConfig,
+                vitestProject: this.options.vitestProject,
             }) ??
-                new VitestWorker(`w${i}`, this.options.cwd, this.options.vitestConfig);
+                new VitestWorker(`w${i}`, this.options.cwd, this.options.vitestConfig, this.options.vitestProject);
             worker.on('exit', () => {
                 if (!this.shuttingDown) {
                     this.handleWorkerExit(worker);
@@ -268,8 +288,9 @@ export class VitestPool {
         const newWorker = this.options.createWorker?.(worker.id, {
             cwd: this.options.cwd,
             vitestConfig: this.options.vitestConfig,
+            vitestProject: this.options.vitestProject,
         }) ??
-            new VitestWorker(worker.id, this.options.cwd, this.options.vitestConfig);
+            new VitestWorker(worker.id, this.options.cwd, this.options.vitestConfig, this.options.vitestProject);
         const idx = this.workers.indexOf(worker);
         if (idx >= 0) {
             this.workers[idx] = newWorker;

package/dist/runner/vitest/worker-runtime.d.ts

@@ -4,6 +4,7 @@ export interface VitestWorkerRuntimeOptions {
     workerId: string;
     cwd: string;
     vitestConfigPath?: string;
+    vitestProject?: string;
 }
 export declare class VitestWorkerRuntime {
     private readonly options;

package/dist/runner/vitest/worker-runtime.js

@@ -5,6 +5,14 @@ import { poolMutineerPlugin } from './plugin.js';
 import { getMutantFilePath, setRedirect, clearRedirect, } from '../shared/index.js';
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('vitest-runtime');
+const SETUP_MJS_CONTENT = `import { beforeAll } from 'vitest'
+import { readFileSync } from 'node:fs'
+const _f = process.env.MUTINEER_ACTIVE_ID_FILE
+beforeAll(() => {
+  try { globalThis.__mutineer_active_id__ = readFileSync(_f, 'utf8').trim() || null }
+  catch { globalThis.__mutineer_active_id__ = null }
+})
+`;
 export class VitestWorkerRuntime {
     constructor(options) {
         this.options = options;
@@ -12,12 +20,24 @@ export class VitestWorkerRuntime {
     }
     async init() {
         try {
+            // Write setup.mjs before creating Vitest so the config hook can find it
+            const activeIdFile = process.env.MUTINEER_ACTIVE_ID_FILE;
+            if (activeIdFile && path.isAbsolute(activeIdFile)) {
+                const mutineerDir = path.dirname(activeIdFile);
+                fs.mkdirSync(mutineerDir, { recursive: true });
+                fs.writeFileSync(path.join(mutineerDir, 'setup.mjs'), SETUP_MJS_CONTENT, 'utf8');
+            }
             this.vitest = await createVitest('test', {
-                watch: true,
+                watch: false,
                 reporters: ['dot'],
                 silent: true,
                 pool: 'forks',
                 bail: 1,
+                // Limit to 1 inner fork so bail:1 stops after the first failure
+                // without spawning additional fork processes. The single fork is
+                // persistent (reused across mutant runs), eliminating per-mutant
+                // fork startup overhead.
+                maxWorkers: 1,
                 ...(this.options.vitestConfigPath
                     ? { config: this.options.vitestConfigPath }
                     : {}),
@@ -43,20 +63,29 @@ export class VitestWorkerRuntime {
             throw new Error('Vitest runtime not initialised');
         }
         const start = Date.now();
+        const activeIdFile = process.env.MUTINEER_ACTIVE_ID_FILE;
+        const useSchema = !mutant.isFallback && !!activeIdFile;
         try {
-            const mutantPath = getMutantFilePath(mutant.file, mutant.id);
-            fs.writeFileSync(mutantPath, mutant.code, 'utf8');
-            log.debug(`Wrote mutant to ${mutantPath}`);
-            setRedirect({
-                from: path.resolve(mutant.file),
-                to: mutantPath,
-            });
-            this.vitest.invalidateFile(mutant.file);
-            log.debug(`Invalidated ${mutant.file}`);
+            if (useSchema) {
+                fs.writeFileSync(activeIdFile, mutant.id, 'utf8');
+                log.debug(`Schema path: wrote active ID ${mutant.id}`);
+            }
+            else {
+                const mutantPath = getMutantFilePath(mutant.file, mutant.id);
+                fs.writeFileSync(mutantPath, mutant.code, 'utf8');
+                log.debug(`Wrote mutant to ${mutantPath}`);
+                setRedirect({
+                    from: path.resolve(mutant.file),
+                    to: mutantPath,
+                });
+                this.vitest.invalidateFile(mutant.file);
+                log.debug(`Invalidated ${mutant.file}`);
+            }
             const specs = [];
+            const projectName = this.options.vitestProject ?? '';
             for (const testFile of tests) {
                 const spec = this.vitest
-                    .getProjectByName('')
+                    .getProjectByName(projectName)
                     ?.createSpecification(testFile);
                 if (spec)
                     specs.push(spec);
@@ -68,6 +97,7 @@ export class VitestWorkerRuntime {
                 };
             }
             log.debug(`Running ${specs.length} test specs`);
+            this.vitest.state?.filesMap?.clear();
             const results = await this.vitest.runTestSpecifications(specs);
             const requestedModules = new Set(specs.map((s) => s.moduleId));
             const relevantModules = results.testModules.filter((mod) => requestedModules.has(mod.moduleId));
@@ -88,14 +118,23 @@ export class VitestWorkerRuntime {
             };
         }
         finally {
-            // Clear redirect and clean up temp file
-            const mutantPath = getMutantFilePath(mutant.file, mutant.id);
-            clearRedirect();
-            try {
-                fs.rmSync(mutantPath, { force: true });
+            if (useSchema) {
+                try {
+                    fs.writeFileSync(activeIdFile, '', 'utf8');
+                }
+                catch {
+                    // ignore
+                }
             }
-            catch {
-                // ignore
+            else {
+                clearRedirect();
+                const mutantPath = getMutantFilePath(mutant.file, mutant.id);
+                try {
+                    fs.rmSync(mutantPath, { force: true });
+                }
+                catch {
+                    // ignore
+                }
             }
         }
     }

package/dist/runner/vitest/worker.mjs

@@ -26,11 +26,13 @@ async function main() {
     const workerId = process.env.MUTINEER_WORKER_ID ?? 'unknown';
     const cwd = process.env.MUTINEER_CWD ?? process.cwd();
     const vitestConfigPath = process.env.MUTINEER_VITEST_CONFIG;
+    const vitestProject = process.env.MUTINEER_VITEST_PROJECT;
     log.debug(`Starting worker ${workerId} in ${cwd}`);
     const runtime = createVitestWorkerRuntime({
         workerId,
         cwd,
         vitestConfigPath,
+        vitestProject,
     });
     try {
         await runtime.init();
@@ -41,6 +43,14 @@ async function main() {
     }
     // Signal ready
     send({ type: 'ready', workerId });
+    // Graceful SIGTERM handler: clean up Vitest inner forks before exiting.
+    // This runs when the parent kills the process group with SIGTERM (e.g.
+    // future graceful shutdown path). Vitest forks are in the same process
+    // group so they also receive the signal, but calling close() ensures the
+    // Vitest instance is torn down cleanly.
+    process.on('SIGTERM', () => {
+        void runtime.shutdown().finally(() => process.exit(0));
+    });
     // Process requests from stdin
     const rl = readline.createInterface({
         input: process.stdin,