@mutineerjs/mutineer 0.6.0 → 0.7.0

package/dist/runner/__tests__/discover.spec.js

@@ -114,6 +114,134 @@ describe('autoDiscoverTargetsAndTests', () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it('calls onProgress at least twice with informational messages', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-progress-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const moduleFile = path.join(srcDir, 'foo.ts');
+        const testFile = path.join(srcDir, 'foo.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(moduleFile, 'export const foo = 1\n', 'utf8');
+        const importLine = ['im', 'port { foo } from "./foo"'].join('');
+        await fs.writeFile(testFile, `${importLine}\nconsole.log(foo)\n`, 'utf8');
+        const messages = [];
+        try {
+            await autoDiscoverTargetsAndTests(tmpDir, { testPatterns: ['**/*.test.ts'] }, (msg) => messages.push(msg));
+            expect(messages.length).toBeGreaterThanOrEqual(2);
+            expect(messages.some((m) => m.includes('test file'))).toBe(true);
+            expect(messages.some((m) => m.includes('Discovery complete'))).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('shared dep imported by 2 tests appears in testMap for both', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-shared-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const sharedDep = path.join(srcDir, 'shared.ts');
+        const test1 = path.join(srcDir, 'a.test.ts');
+        const test2 = path.join(srcDir, 'b.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(sharedDep, 'export const shared = 1\n', 'utf8');
+        const importShared = ['im', 'port { shared } from "./shared"'].join('');
+        await fs.writeFile(test1, `${importShared}\n`, 'utf8');
+        await fs.writeFile(test2, `${importShared}\n`, 'utf8');
+        try {
+            const { testMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const sharedAbs = normalizePath(sharedDep);
+            const test1Abs = normalizePath(test1);
+            const test2Abs = normalizePath(test2);
+            expect(testMap.get(sharedAbs)?.has(test1Abs)).toBe(true);
+            expect(testMap.get(sharedAbs)?.has(test2Abs)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('diamond graph: shared grandchild discovered with no duplicates', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-diamond-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const fileA = path.join(srcDir, 'A.ts');
+        const fileB = path.join(srcDir, 'B.ts');
+        const fileC = path.join(srcDir, 'C.ts');
+        const fileD = path.join(srcDir, 'D.ts');
+        const testFile = path.join(srcDir, 'test.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(fileD, 'export const d = 4\n', 'utf8');
+        const importD = ['im', 'port { d } from "./D"'].join('');
+        await fs.writeFile(fileB, `${importD}\nexport const b = 2\n`, 'utf8');
+        await fs.writeFile(fileC, `${importD}\nexport const c = 3\n`, 'utf8');
+        const importB = ['im', 'port { b } from "./B"'].join('');
+        const importC = ['im', 'port { c } from "./C"'].join('');
+        await fs.writeFile(fileA, `${importB}\n${importC}\nexport const a = 1\n`, 'utf8');
+        const importA = ['im', 'port { a } from "./A"'].join('');
+        await fs.writeFile(testFile, `${importA}\n`, 'utf8');
+        try {
+            const { testMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const dAbs = normalizePath(fileD);
+            const testAbs = normalizePath(testFile);
+            expect(testMap.get(dAbs)?.has(testAbs)).toBe(true);
+            // D should only be in testMap once (Set ensures no duplicates)
+            expect(testMap.get(dAbs)?.size).toBe(1);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('deep chain: deepest file is discovered correctly', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-deep-'));
+        const srcDir = path.join(tmpDir, 'src');
+        await fs.mkdir(srcDir, { recursive: true });
+        // chain: test -> f1 -> f2 -> f3 -> f4 -> f5
+        const files = Array.from({ length: 5 }, (_, i) => path.join(srcDir, `f${i + 1}.ts`));
+        const testFile = path.join(srcDir, 'chain.test.ts');
+        await fs.writeFile(files[4], 'export const f5 = 5\n', 'utf8');
+        for (let i = 3; i >= 0; i--) {
+            const importNext = ['im', `port { f${i + 2} } from "./f${i + 2}"`].join('');
+            await fs.writeFile(files[i], `${importNext}\nexport const f${i + 1} = ${i + 1}\n`, 'utf8');
+        }
+        const importF1 = ['im', 'port { f1 } from "./f1"'].join('');
+        await fs.writeFile(testFile, `${importF1}\n`, 'utf8');
+        try {
+            const { testMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const f5Abs = normalizePath(files[4]);
+            const testAbs = normalizePath(testFile);
+            expect(testMap.get(f5Abs)?.has(testAbs)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('2 tests directly importing same file both appear in directTestMap', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-direct2-'));
+        const srcDir = path.join(tmpDir, 'src');
+        const sharedDep = path.join(srcDir, 'shared.ts');
+        const test1 = path.join(srcDir, 'a.test.ts');
+        const test2 = path.join(srcDir, 'b.test.ts');
+        await fs.mkdir(srcDir, { recursive: true });
+        await fs.writeFile(sharedDep, 'export const shared = 1\n', 'utf8');
+        const importShared = ['im', 'port { shared } from "./shared"'].join('');
+        await fs.writeFile(test1, `${importShared}\n`, 'utf8');
+        await fs.writeFile(test2, `${importShared}\n`, 'utf8');
+        try {
+            const { directTestMap } = await autoDiscoverTargetsAndTests(tmpDir, {
+                testPatterns: ['**/*.test.ts'],
+            });
+            const sharedAbs = normalizePath(sharedDep);
+            const test1Abs = normalizePath(test1);
+            const test2Abs = normalizePath(test2);
+            expect(directTestMap.get(sharedAbs)?.has(test1Abs)).toBe(true);
+            expect(directTestMap.get(sharedAbs)?.has(test2Abs)).toBe(true);
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
     it('ignores test files when collecting mutate targets', async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mutineer-discover-'));
         const srcDir = path.join(tmpDir, 'src');

package/dist/runner/__tests__/orchestrator.spec.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 // Mock all heavy dependencies before importing orchestrator
 vi.mock('../config.js', () => ({
     loadMutineerConfig: vi.fn(),
@@ -34,11 +34,26 @@ vi.mock('../discover.js', () => ({
 vi.mock('../changed.js', () => ({
     listChangedFiles: vi.fn().mockReturnValue([]),
 }));
-import { runOrchestrator } from '../orchestrator.js';
+vi.mock('../pool-executor.js', () => ({
+    executePool: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('../variants.js', () => ({
+    enumerateAllVariants: vi.fn().mockResolvedValue([]),
+    getTargetFile: vi
+        .fn()
+        .mockImplementation((t) => typeof t === 'string' ? t : t.file),
+}));
+vi.mock('../tasks.js', () => ({
+    prepareTasks: vi.fn().mockReturnValue([]),
+}));
+import { runOrchestrator, parseMutantTimeoutMs } from '../orchestrator.js';
 import { loadMutineerConfig } from '../config.js';
 import { createVitestAdapter } from '../vitest/index.js';
 import { autoDiscoverTargetsAndTests } from '../discover.js';
 import { listChangedFiles } from '../changed.js';
+import { executePool } from '../pool-executor.js';
+import { prepareTasks } from '../tasks.js';
+import { enumerateAllVariants } from '../variants.js';
 const mockAdapter = {
     name: 'vitest',
     init: vi.fn().mockResolvedValue(undefined),
@@ -54,6 +69,95 @@ beforeEach(() => {
     vi.clearAllMocks();
     vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
 });
+describe('parseMutantTimeoutMs', () => {
+    it('returns the parsed value for a valid positive number', () => {
+        expect(parseMutantTimeoutMs('5000')).toBe(5000);
+    });
+    it('returns 30_000 for undefined', () => {
+        expect(parseMutantTimeoutMs(undefined)).toBe(30_000);
+    });
+    it('returns 30_000 for zero (kills tightenGT: n>=0 would return 0)', () => {
+        expect(parseMutantTimeoutMs('0')).toBe(30_000);
+    });
+    it('returns 30_000 for Infinity (kills andToOr: || would return Infinity)', () => {
+        expect(parseMutantTimeoutMs('Infinity')).toBe(30_000);
+    });
+    it('returns 30_000 for negative values', () => {
+        expect(parseMutantTimeoutMs('-1')).toBe(30_000);
+    });
+    it('returns 30_000 for non-numeric strings', () => {
+        expect(parseMutantTimeoutMs('abc')).toBe(30_000);
+    });
+});
+describe('runOrchestrator no tests found', () => {
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('sets exitCode=1 when no tests are found for targets', async () => {
+        process.exitCode = undefined;
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [],
+            testMap: new Map(),
+            directTestMap: new Map(),
+        });
+        await runOrchestrator([], '/cwd');
+        expect(process.exitCode).toBe(1);
+    });
+    it('logs error message when no tests are found for targets', async () => {
+        process.exitCode = undefined;
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [],
+            testMap: new Map(),
+            directTestMap: new Map(),
+        });
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        await runOrchestrator([], '/cwd');
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('No tests found for the selected targets'));
+    });
+    it('does not run baseline when no tests are found', async () => {
+        process.exitCode = undefined;
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [],
+            testMap: new Map(),
+            directTestMap: new Map(),
+        });
+        await runOrchestrator([], '/cwd');
+        expect(mockAdapter.runBaseline).not.toHaveBeenCalled();
+    });
+});
+describe('runOrchestrator discovery logging', () => {
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('logs "Discovering tests..." before calling autoDiscoverTargetsAndTests', async () => {
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator([], '/cwd');
+        const calls = consoleSpy.mock.calls.map((c) => c[0]);
+        const discoveringIdx = calls.findIndex((m) => m === 'Discovering tests...');
+        expect(discoveringIdx).toBeGreaterThanOrEqual(0);
+    });
+    it('passes an onProgress callback to autoDiscoverTargetsAndTests', async () => {
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        await runOrchestrator([], '/cwd');
+        const [, , onProgress] = vi.mocked(autoDiscoverTargetsAndTests).mock
+            .calls[0];
+        expect(typeof onProgress).toBe('function');
+    });
+    it('logs progress messages emitted by autoDiscoverTargetsAndTests', async () => {
+        vi.mocked(loadMutineerConfig).mockResolvedValue({});
+        vi.mocked(autoDiscoverTargetsAndTests).mockImplementationOnce(async (_root, _cfg, onProgress) => {
+            onProgress?.('Discovery complete: 3 source file(s), 2 test file(s)');
+            return { targets: [], testMap: new Map(), directTestMap: new Map() };
+        });
+        const consoleSpy = vi.spyOn(console, 'log');
+        await runOrchestrator([], '/cwd');
+        expect(consoleSpy).toHaveBeenCalledWith('Discovery complete: 3 source file(s), 2 test file(s)');
+    });
+});
 describe('runOrchestrator --changed-with-deps diagnostic', () => {
     it('logs uncovered targets when wantsChangedWithDeps is true', async () => {
         const cfg = {};
@@ -139,3 +243,64 @@ describe('runOrchestrator timeout precedence', () => {
         expect(Number.isFinite(call.timeoutMs)).toBe(true);
     });
 });
+describe('runOrchestrator shard filtering', () => {
+    const targetFile = '/cwd/src/foo.ts';
+    const testFile = '/cwd/src/__tests__/foo.spec.ts';
+    function makeTask(key) {
+        return {
+            key,
+            v: {
+                id: `${key}`,
+                name: 'flipEQ',
+                file: targetFile,
+                code: '',
+                line: 1,
+                col: 0,
+                tests: [testFile],
+            },
+            tests: [testFile],
+        };
+    }
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        vi.mocked(createVitestAdapter).mockReturnValue(mockAdapter);
+        vi.mocked(loadMutineerConfig).mockResolvedValue({
+            targets: [targetFile],
+        });
+        vi.mocked(autoDiscoverTargetsAndTests).mockResolvedValue({
+            targets: [targetFile],
+            testMap: new Map([[targetFile, new Set([testFile])]]),
+            directTestMap: new Map(),
+        });
+        vi.mocked(mockAdapter.runBaseline).mockResolvedValue(true);
+        // Return a non-empty variants array so orchestrator doesn't exit early
+        vi.mocked(enumerateAllVariants).mockResolvedValue([{}]);
+        const tasks = ['k0', 'k1', 'k2', 'k3'].map(makeTask);
+        vi.mocked(prepareTasks).mockReturnValue(tasks);
+    });
+    afterEach(() => {
+        process.exitCode = undefined;
+    });
+    it('shard 1/2 assigns even-indexed tasks', async () => {
+        await runOrchestrator(['--shard', '1/2'], '/cwd');
+        const call = vi.mocked(executePool).mock.calls[0][0];
+        expect(call.tasks.map((t) => t.key)).toEqual(['k0', 'k2']);
+    });
+    it('shard 2/2 assigns odd-indexed tasks', async () => {
+        await runOrchestrator(['--shard', '2/2'], '/cwd');
+        const call = vi.mocked(executePool).mock.calls[0][0];
+        expect(call.tasks.map((t) => t.key)).toEqual(['k1', 'k3']);
+    });
+    it('does not call executePool when shard has no tasks', async () => {
+        // Only 1 task total; shard 2/2 gets nothing
+        vi.mocked(prepareTasks).mockReturnValue([makeTask('only')]);
+        await runOrchestrator(['--shard', '2/2'], '/cwd');
+        expect(executePool).not.toHaveBeenCalled();
+    });
+    it('propagates shard to executePool', async () => {
+        await runOrchestrator(['--shard', '1/4'], '/cwd');
+        const call = vi.mocked(executePool).mock.calls[0][0];
+        expect(call.shard).toEqual({ index: 1, total: 4 });
+    });
+});

package/dist/runner/__tests__/pool-executor.spec.js

@@ -189,10 +189,47 @@ describe('executePool', () => {
             progressMode: 'list',
             cwd: tmpDir,
         });
-        const cacheFile = path.join(tmpDir, '.mutate-cache.json');
+        const cacheFile = path.join(tmpDir, '.mutineer-cache.json');
         const content = JSON.parse(await fs.readFile(cacheFile, 'utf8'));
         expect(content['persist-key']).toBeDefined();
     });
+    it('saves to shard-named cache file when shard is provided', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [makeTask({ key: 'shard-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            shard: { index: 2, total: 4 },
+        });
+        const shardFile = path.join(tmpDir, '.mutineer-cache-shard-2-of-4.json');
+        const content = JSON.parse(await fs.readFile(shardFile, 'utf8'));
+        expect(content['shard-key']).toBeDefined();
+        // default file should NOT exist
+        await expect(fs.access(path.join(tmpDir, '.mutineer-cache.json'))).rejects.toThrow();
+    });
+    it('writes shard-suffixed JSON report when shard and reportFormat=json are set', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        await executePool({
+            tasks: [makeTask({ key: 'shard-report-key' })],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+            reportFormat: 'json',
+            shard: { index: 1, total: 2 },
+        });
+        const reportFile = path.join(tmpDir, 'mutineer-report-shard-1-of-2.json');
+        const content = JSON.parse(await fs.readFile(reportFile, 'utf8'));
+        expect(content.schemaVersion).toBe(1);
+        // default report should NOT exist
+        await expect(fs.access(path.join(tmpDir, 'mutineer-report.json'))).rejects.toThrow();
+    });
     it('escaped mutant stores snippets when lines differ', async () => {
         const tmpFile = path.join(tmpDir, 'source.ts');
         await fs.writeFile(tmpFile, 'const x = a + b\n');
@@ -410,6 +447,28 @@ describe('executePool', () => {
         expect(cache['cache-key-3'].originalSnippet).toBe('const x = a + b');
         expect(cache['cache-key-3'].mutatedSnippet).toBe('const x = a / b');
     });
+    it('does not eagerly JSON.stringify cache on every task (only once for save)', async () => {
+        const adapter = makeAdapter();
+        const cache = {};
+        const stringifySpy = vi.spyOn(JSON, 'stringify');
+        // 3 tasks — if stringify(cache) ran per-task it would be called 3 times with cache
+        await executePool({
+            tasks: [
+                makeTask({ key: 'k1' }),
+                makeTask({ key: 'k2' }),
+                makeTask({ key: 'k3' }),
+            ],
+            adapter,
+            cache,
+            concurrency: 1,
+            progressMode: 'list',
+            cwd: tmpDir,
+        });
+        // saveCacheAtomic calls stringify(cache) exactly once; per-task eager call was removed
+        const cacheStringifyCalls = stringifySpy.mock.calls.filter((args) => args[0] === cache);
+        expect(cacheStringifyCalls.length).toBe(1);
+        stringifySpy.mockRestore();
+    });
     it('handles adapter errors gracefully and still shuts down', async () => {
         const adapter = makeAdapter({
             runMutant: vi.fn().mockRejectedValue(new Error('adapter failure')),

package/dist/runner/args.d.ts

@@ -20,6 +20,11 @@ export interface ParsedCliOptions {
     readonly minKillPercent: number | undefined;
     readonly runner: 'vitest' | 'jest';
     readonly timeout: number | undefined;
+    readonly reportFormat: 'text' | 'json';
+    readonly shard: {
+        index: number;
+        total: number;
+    } | undefined;
 }
 /**
  * Parse a numeric CLI flag value.
@@ -54,6 +59,14 @@ export declare function parseProgressMode(args: readonly string[]): 'bar' | 'lis
  * Handles --config=path, -c=path, --config path, and -c path.
  */
 export declare function extractConfigPath(args: readonly string[]): string | undefined;
+/**
+ * Parse the --shard <n>/<total> option.
+ * Throws on bad format or out-of-range values.
+ */
+export declare function parseShardOption(args: readonly string[]): {
+    index: number;
+    total: number;
+} | undefined;
 /**
  * Parse all CLI options.
  */

package/dist/runner/args.js

@@ -105,6 +105,28 @@ export function parseProgressMode(args) {
 export function extractConfigPath(args) {
     return readStringFlag(args, '--config', '-c');
 }
+/**
+ * Parse the --shard <n>/<total> option.
+ * Throws on bad format or out-of-range values.
+ */
+export function parseShardOption(args) {
+    const raw = readStringFlag(args, '--shard');
+    if (raw === undefined)
+        return undefined;
+    const match = /^(\d+)\/(\d+)$/.exec(raw);
+    if (!match) {
+        throw new Error(`Invalid --shard format: expected <n>/<total>, got "${raw}"`);
+    }
+    const index = parseInt(match[1], 10);
+    const total = parseInt(match[2], 10);
+    if (total < 1) {
+        throw new Error(`Invalid --shard: total must be >= 1 (got ${total})`);
+    }
+    if (index < 1 || index > total) {
+        throw new Error(`Invalid --shard: index must be between 1 and ${total} (got ${index})`);
+    }
+    return { index, total };
+}
 /**
  * Parse all CLI options.
  */
@@ -127,6 +149,9 @@ export function parseCliOptions(args, cfg) {
     const configKillPercent = validatePercent(cfg.minKillPercent, 'mutineer.config minKillPercent');
     const minKillPercent = cliKillPercent ?? configKillPercent;
     const timeout = validatePositiveMs(readNumberFlag(args, '--timeout'), '--timeout');
+    const reportFlag = readStringFlag(args, '--report');
+    const reportFormat = reportFlag === 'json' || cfg.report === 'json' ? 'json' : 'text';
+    const shard = parseShardOption(args);
     return {
         configPath,
         wantsChanged,
@@ -139,5 +164,7 @@ export function parseCliOptions(args, cfg) {
         minKillPercent,
         runner,
         timeout,
+        reportFormat,
+        shard,
     };
 }

package/dist/runner/cache.d.ts

@@ -5,14 +5,27 @@
  * Handles reading, writing, and decoding cache entries.
  */
 import type { MutantCacheEntry } from '../types/mutant.js';
+/**
+ * Get the cache filename for a given shard (or the default if none).
+ */
+export declare function getCacheFilename(shard?: {
+    index: number;
+    total: number;
+}): string;
 /**
  * Clear the cache file at the start of a run.
  */
-export declare function clearCacheOnStart(cwd: string): Promise<void>;
+export declare function clearCacheOnStart(cwd: string, shard?: {
+    index: number;
+    total: number;
+}): Promise<void>;
 /**
  * Save cache atomically using a temp file + rename.
  */
-export declare function saveCacheAtomic(cwd: string, cache: Record<string, MutantCacheEntry>): Promise<void>;
+export declare function saveCacheAtomic(cwd: string, cache: Record<string, MutantCacheEntry>, shard?: {
+    index: number;
+    total: number;
+}): Promise<void>;
 /**
  * Decode a cache key into its component parts.
  * Cache keys have the format: testSig:codeSig:file:line,col:mutator
@@ -35,4 +48,7 @@ export declare function hash(s: string): string;
  * Read the mutant cache from disk.
  * Normalizes both old (string status) and new (object) formats.
  */
-export declare function readMutantCache(cwd: string): Promise<Record<string, MutantCacheEntry>>;
+export declare function readMutantCache(cwd: string, shard?: {
+    index: number;
+    total: number;
+}): Promise<Record<string, MutantCacheEntry>>;

package/dist/runner/cache.js

@@ -7,12 +7,19 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
-const CACHE_FILENAME = '.mutate-cache.json';
+/**
+ * Get the cache filename for a given shard (or the default if none).
+ */
+export function getCacheFilename(shard) {
+    if (!shard)
+        return '.mutineer-cache.json';
+    return `.mutineer-cache-shard-${shard.index}-of-${shard.total}.json`;
+}
 /**
  * Clear the cache file at the start of a run.
  */
-export async function clearCacheOnStart(cwd) {
-    const p = path.join(cwd, CACHE_FILENAME);
+export async function clearCacheOnStart(cwd, shard) {
+    const p = path.join(cwd, getCacheFilename(shard));
     try {
         await fs.unlink(p);
     }
@@ -23,8 +30,8 @@ export async function clearCacheOnStart(cwd) {
 /**
  * Save cache atomically using a temp file + rename.
  */
-export async function saveCacheAtomic(cwd, cache) {
-    const p = path.join(cwd, CACHE_FILENAME);
+export async function saveCacheAtomic(cwd, cache, shard) {
+    const p = path.join(cwd, getCacheFilename(shard));
     const tmp = p + '.tmp';
     const json = JSON.stringify(cache, null, 2);
     await fs.writeFile(tmp, json, 'utf8');
@@ -87,8 +94,8 @@ export function hash(s) {
  * Read the mutant cache from disk.
  * Normalizes both old (string status) and new (object) formats.
  */
-export async function readMutantCache(cwd) {
-    const p = path.join(cwd, CACHE_FILENAME);
+export async function readMutantCache(cwd, shard) {
+    const p = path.join(cwd, getCacheFilename(shard));
     try {
         const data = await fs.readFile(p, 'utf8');
         const raw = JSON.parse(data);

package/dist/runner/cleanup.d.ts

@@ -1,4 +1,6 @@
 /**
  * Clean up all __mutineer__ temp directories created during mutation testing.
  */
-export declare function cleanupMutineerDirs(cwd: string): Promise<void>;
+export declare function cleanupMutineerDirs(cwd: string, opts?: {
+    includeCacheFiles?: boolean;
+}): Promise<void>;

package/dist/runner/cleanup.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 /**
  * Clean up all __mutineer__ temp directories created during mutation testing.
  */
-export async function cleanupMutineerDirs(cwd) {
+export async function cleanupMutineerDirs(cwd, opts = {}) {
     const glob = await import('fast-glob');
     const dirs = await glob.default('**/__mutineer__', {
         cwd,
@@ -18,4 +18,21 @@ export async function cleanupMutineerDirs(cwd) {
             // Ignore cleanup errors
         }
     }
+    if (opts.includeCacheFiles) {
+        // Remove cache files (new name + legacy .mutate-cache* for migration)
+        const cacheFiles = await glob.default([
+            '.mutineer-cache*.json',
+            '.mutineer-cache*.json.tmp',
+            '.mutate-cache*.json',
+            '.mutate-cache*.json.tmp',
+        ], { cwd, absolute: true });
+        for (const f of cacheFiles) {
+            try {
+                await fs.unlink(f);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
 }

package/dist/runner/coverage-resolver.js

@@ -15,7 +15,7 @@ export async function resolveCoverageConfig(opts, cfg, adapter, cliArgs) {
         ? true
         : coveragePreference === false
             ? false
-            : isCoverageRequestedInArgs([...cliArgs]) || coverageConfig.coverageEnabled;
+            : isCoverageRequestedInArgs([...cliArgs]);
     // Load pre-existing coverage data if provided
     let coverageData = null;
     if (opts.coverageFilePath) {

package/dist/runner/discover.d.ts

@@ -5,4 +5,4 @@ export interface DiscoveryResult {
     readonly testMap: TestMap;
     readonly directTestMap: TestMap;
 }
-export declare function autoDiscoverTargetsAndTests(root: string, cfg: MutineerConfig): Promise<DiscoveryResult>;
+export declare function autoDiscoverTargetsAndTests(root: string, cfg: MutineerConfig, onProgress?: (msg: string) => void): Promise<DiscoveryResult>;