lacuna-cli 0.1.5 → 0.1.6

package/README.md

@@ -67,10 +67,16 @@ Interactive setup wizard. Configures your model, test runner, source directory,
 
 Works from any subdirectory — lacuna finds the project root automatically.
 
-For **React and Next.js** projects, `lacuna init` also:
+For **React** projects, `lacuna init` also:
 - Installs `@testing-library/react`, `@testing-library/jest-dom`, `@testing-library/user-event`, and `jsdom`
-- Creates `vitest.config.ts` with the correct `environment: 'jsdom'` and `@/` alias (read from your `tsconfig.json`)
-- Creates a setup file pre-loaded with global `vi.mock()` calls for `next/navigation`, `next/headers`, and `next/cache` so individual tests don't need to mock them
+- Creates `vitest.config.ts` with `environment: 'jsdom'` and `restoreMocks: true` + `clearMocks: true`
+- Creates a setup file with `@testing-library/jest-dom` and `beforeEach`/`afterEach` mock cleanup hooks
+
+For **Next.js** projects, the setup is different — Next.js and plain React are not compatible:
+- Installs the same testing-library packages but does **not** add `environment: 'jsdom'` to vitest config (Next.js manages its own environment)
+- Adds `@/` alias (from your `tsconfig.json`) and a `server-only` stub alias to vitest config
+- Creates a setup file with global `vi.mock()` calls for `next/navigation`, `next/headers`, `next/cache`, `next/image`, and `next/font` — these are Next.js-specific mocks that would crash a plain React project
+- If test dependencies are found in `node_modules` but not declared in `package.json` (e.g. from a different branch), lacuna will prompt you to add them — undeclared deps break CI on a fresh checkout
 
 ```bash
 lacuna init
@@ -108,7 +114,7 @@ lacuna generate --format json --output report.json
 ```
 
 ### `lacuna fix`
-Finds all failing tests and repairs them using AI — without rewriting them from scratch. Sends each failing file along with its error output and source code to the model, which surgically fixes what's broken and retries until it passes.
+Finds all failing tests and repairs them using AI. Sends each failing file along with its error output and source code to the model, which surgically fixes what's broken and retries until it passes. If all fix retries fail, lacuna automatically deletes the broken test and regenerates it from the source file — a clean slate rather than another round of patchwork.
 
 ```bash
 lacuna fix
@@ -117,15 +123,19 @@ lacuna fix --file src/utils/math.test.ts   # fix a single test file (skips full
 lacuna fix --dry-run                       # preview fixes without writing
 lacuna fix --verbose                       # live code panel as model writes each fix
 lacuna fix --fresh                         # re-run the suite even if cache is recent
+lacuna fix --no-regenerate-on-failure      # disable the regen fallback (fix only, no delete)
+lacuna fix --fix-polluters                 # also handle tests that pass alone but fail in suite
 ```
 
-Unlike `lacuna generate`, which creates new tests, `lacuna fix` operates on existing failing tests. It preserves all test logic and only changes what is necessary to make the suite pass.
+Unlike `lacuna generate`, which creates new tests, `lacuna fix` operates on existing failing tests and preserves all test logic where possible.
+
+**Regeneration fallback (default on):** When fix retries are exhausted, lacuna deletes the test file and regenerates it from scratch using the generate path. This works better than continued repair for structurally broken tests — the AI starts with a clean conversation and full source context instead of carrying forward a chain of failed hypotheses. Use `--no-regenerate-on-failure` to disable this and get fix-only behaviour.
 
-If all retries fail or the model oscillates (identical output detected), the original file is restored automatically. Your test suite is always left in a coherent state.
+**Passing in isolation, failing in suite (`--fix-polluters`):** Some tests pass when run alone but fail in the full suite. `--fix-polluters` handles these in two phases: (1) bisect the test suite to find if another file is leaking state (e.g. an uncleaned mock or global), and fix the polluter; (2) if no polluter can be isolated (the test has an internal spy lifecycle bug), delete and regenerate the victim file directly.
 
-If a fix attempt breaks an import (causing 0 tests to be collected) or reduces the number of passing tests, lacuna detects the regression and tells the model exactly what the original failure was — so it doesn't waste further iterations trying to recover from the wrong problem.
+If all retries fail or the model oscillates (identical output detected), the original file is restored automatically. If a fix attempt breaks an import or reduces passing tests, lacuna detects the regression and anchors the next retry to the original error.
 
-When `--file` is given, lacuna skips the full suite and runs only the target file — much faster for iterating on a single broken test. Without `--file`, the failing-files list is cached for 30 minutes. After a fix run, the cache is updated to contain only the files that are still failing — so re-running `lacuna fix` immediately picks up exactly where the last run left off. Once all files are fixed, the cache is cleared so the next run does a clean suite scan.
+When `--file` is given, lacuna skips the full suite and runs only the target file. Without `--file`, the failing-files list is cached for 30 minutes. After a fix run, the cache is updated to contain only the still-failing files — so re-running immediately picks up where the last run left off.
 
 ### `lacuna run`
 Runs your test suite and reports coverage. No AI involved.
@@ -167,7 +177,7 @@ Created by `lacuna init`. All fields are optional with sensible defaults.
 | `testRunner` | auto-detect | `jest` \| `vitest` \| `pytest` \| `mocha` \| `go-test` |
 | `coverageFormat` | `lcov` | `lcov` \| `json-summary` |
 | `coverageDir` | `coverage` | Where your test runner writes coverage |
-| `sourceDir` | `src` | Root directory of source files — set during `lacuna init` |
+| `sourceDir` | `"src"` | Source directory to scan. Accepts a string or an array — `["src", "lib", "utils"]` scans multiple directories |
 | `threshold` | `80` | Minimum line coverage % to pass |
 | `maxIterations` | `3` | How many times to retry a failing generated test |
 | `coverageTimeout` | `300` | Seconds before the test suite is killed (prevents hanging on open handles) |
@@ -257,7 +267,25 @@ beforeEach(() => {
 lacuna generate
 ```
 
-Every generated test will import from `src/test/mocks.ts` instead of creating its own `vi.fn()` calls. If a test needs a mock that doesn't exist yet, Claude will add it to the mocks file and import it — keeping everything centralized.
+Every generated test will import from `src/test/mocks.ts` instead of creating its own `vi.fn()` calls. If a test needs a mock that doesn't exist yet, lacuna will add it to the mocks file and import it — keeping everything centralized.
+
+### How lacuna reads and updates the shared mock file
+
+Lacuna parses your mock file before every prompt and builds a **mock inventory** — a structured table of every `vi.mock()` call, its line number, and all the keys it exports:
+
+```
+'react-router-dom'  → useNavigate, useParams
+'axios'             → get, post, put, delete
+```
+
+This inventory is injected into every prompt so the AI knows exactly which modules are already mocked and what they export. When the AI needs to add a new export (e.g. a new API client method), it updates the **existing** `vi.mock()` block with the full list of old + new exports — never appending a second block for the same module.
+
+**Structure rules the AI follows:**
+- Module already in inventory → update the existing block (never a duplicate)
+- New mock variable → declare near same-domain exports, reset in existing `beforeEach`
+- New module → append at end before the final `beforeEach`
+
+For fix prompts, the mock file is **compressed** before sending (multi-line React component stub bodies are collapsed to `vi.fn()`) to reduce token cost while preserving all `vi.mock()` blocks and factory functions. For generate prompts, only the inventory and exports list are sent — the raw file is skipped entirely since the AI only needs to know what to import, not re-read every implementation.
 
 ---
 

package/dist/agent/fix-loop.d.ts

@@ -9,11 +9,16 @@ export interface FixOptions {
     targetFile?: string;
     workers?: number;
     fresh?: boolean;
+    regenerateOnFailure?: boolean;
+    fixPolluters?: boolean;
     log: (msg: string) => void;
 }
 export interface FixResult {
     filesProcessed: number;
     filesFixed: number;
+    filesAlreadyPassing: number;
+    pollutersFixed: number;
+    victimsRegenerated: number;
     errors: string[];
 }
 export declare function runFixLoop(options: FixOptions): Promise<FixResult>;

package/dist/agent/fix-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fix-loop.d.ts","sourceRoot":"","sources":["../../src/agent/fix-loop.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAe7D,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,YAAY,CAAA;IACpB,GAAG,EAAE,mBAAmB,CAAA;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3B;AAoCD,MAAM,WAAW,SAAS;IACxB,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AA6UD,wBAAsB,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAgIxE"}
+{"version":3,"file":"fix-loop.d.ts","sourceRoot":"","sources":["../../src/agent/fix-loop.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAiB7D,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,YAAY,CAAA;IACpB,GAAG,EAAE,mBAAmB,CAAA;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3B;AAoCD,MAAM,WAAW,SAAS;IACxB,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,cAAc,EAAE,MAAM,CAAA;IACtB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AA6nBD,wBAAsB,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAwJxE"}

package/dist/agent/fix-loop.js

@@ -1,17 +1,18 @@
-import { readFile, writeFile, mkdir, unlink } from 'fs/promises';
+import { readFile, writeFile, mkdir, unlink, readdir } from 'fs/promises';
 import { join, dirname, basename, extname } from 'path';
 import { access, stat } from 'fs/promises';
 import chalk from 'chalk';
-import { fileTestCommand } from '../lib/detector.js';
+import { fileTestCommand, multiFileTestCommand } from '../lib/detector.js';
 import { runCommand } from '../lib/runner.js';
 import { startCoverageSpinner } from '../lib/coverage-spinner.js';
 import { WorkerDisplay } from '../lib/worker-display.js';
 import { buildFixFileContext, computeRelativeImport, collectTypeDefinitions, collectLocalImportPaths, detectReactMajorVersion } from './context.js';
-import { TestGenerator, TruncatedOutputError, OscillationError, TRUNCATION_RETRY_MESSAGE } from './generator.js';
+import { TestGenerator, TruncatedOutputError, OscillationError, TRUNCATION_RETRY_MESSAGE, OSCILLATION_ESCAPE_MESSAGE } from './generator.js';
+import { processGap } from './loop.js';
 import { ProjectMemory } from './project-memory.js';
 import { getActiveTips, createTipRotator, formatTip } from '../lib/tips.js';
 import { typeCheckFile } from '../lib/typecheck.js';
-import { hasTestFunctions, enrichNoTestsError, isZeroTestsOutput, parsePassCount, buildStructureBrokenMessage, buildRegressionMessage, sanitizeMocksContent, stripLeadingProse, mergeMocksContent } from '../lib/validate.js';
+import { hasTestFunctions, enrichNoTestsError, isZeroTestsOutput, parsePassCount, buildStructureBrokenMessage, buildRegressionMessage, sanitizeMocksContent, stripLeadingProse, mergeMocksContent, deduplicateViMocks } from '../lib/validate.js';
 import { extractTestFailure } from '../lib/extract-error.js';
 import { StreamingFileViewer } from '../lib/streaming-viewer.js';
 // ─── Failing-files cache ──────────────────────────────────────────────────────
@@ -46,42 +47,84 @@ async function clearFixCache(cwd) {
     catch { /* already gone — fine */ }
 }
 // ─── Parse failing test files from runner output ──────────────────────────────
-const TEST_FILE_RE = /[\w./\\@-]+\.(?:test|spec)\.(?:tsx|mts|ts|jsx|js)/;
+const TEST_FILE_RE = /[\w./\\@\[\]-]+\.(?:test|spec)\.(?:tsx|mts|ts|jsx|js)/;
+function stripAnsi(s) {
+    // Strip all CSI sequences (ESC [ ... letter), OSC sequences, carriage returns
+    return s.replace(/\x1B\[[0-9;]*[A-Za-z]/g, '').replace(/\x1B\][^\x1B]*/g, '').replace(/\r/g, '');
+}
 function parseFailingTestFiles(output, runner) {
-    const files = new Set();
     const lines = output.split('\n');
+    // Two separate sets — cross/tick pattern (per-file summary) vs FAIL pattern (per-test details)
+    const crossFiles = new Set();
+    const failFiles = new Set();
     for (const line of lines) {
-        const clean = line.replace(/\x1B\[[0-9;]*m/g, '').trim();
-        // Vitest: cross character followed by file path (covers multiple cross symbols across versions)
+        const clean = stripAnsi(line).trim();
         if (runner === 'vitest' || runner === 'unknown') {
             const m = clean.match(new RegExp(`^[×✗✕✖✘❌]\\s+(${TEST_FILE_RE.source})`));
             if (m) {
-                files.add(m[1]);
+                crossFiles.add(m[1]);
                 continue;
             }
         }
-        // "FAIL <path>" — used by Jest and some Vitest reporters/configurations
         if (runner === 'jest' || runner === 'vitest' || runner === 'unknown') {
             const m = clean.match(new RegExp(`^FAIL\\s+(${TEST_FILE_RE.source})`));
             if (m) {
-                files.add(m[1]);
-                continue;
+                failFiles.add(m[1]);
             }
         }
     }
-    // Fallback: if no files matched via primary patterns, extract test file paths from
-    // stack traces. A path in a stack trace always belongs to a file that ran and failed.
-    // Over-inclusive is fine — fixFile re-runs each file first and skips it if already passing.
-    if (files.size === 0) {
+    // Parse the expected failing file count from the runner summary line
+    let expectedCount = null;
+    for (const line of lines) {
+        const clean = stripAnsi(line).trim();
+        const mv = clean.match(/Test Files\s+(\d+)\s+failed/);
+        if (mv) {
+            expectedCount = parseInt(mv[1], 10);
+            break;
+        }
+        const mj = clean.match(/Test Suites:\s+(\d+)\s+failed/);
+        if (mj) {
+            expectedCount = parseInt(mj[1], 10);
+            break;
+        }
+    }
+    const combined = new Set([...crossFiles, ...failFiles]);
+    if (expectedCount !== null && combined.size > expectedCount) {
+        // Over-detected: prune false positives by preferring files confirmed by both patterns,
+        // then FAIL-only (strong signal — comes from the detailed failures section),
+        // then cross-only last (more likely to include false positives).
+        const pruned = new Set();
+        for (const f of crossFiles) {
+            if (failFiles.has(f))
+                pruned.add(f);
+        }
+        for (const f of failFiles) {
+            if (pruned.size < expectedCount)
+                pruned.add(f);
+        }
+        for (const f of crossFiles) {
+            if (pruned.size < expectedCount)
+                pruned.add(f);
+        }
+        return [...pruned];
+    }
+    // Supplement with stack traces only when primary patterns under-detected
+    const needsSupplement = expectedCount !== null ? combined.size < expectedCount : combined.size === 0;
+    if (needsSupplement) {
+        let inTrace = false;
         for (const line of lines) {
-            const clean = line.replace(/\x1B\[[0-9;]*m/g, '').trim();
-            // stack trace: at ... (src/foo.test.tsx:42:5) or at src/foo.test.tsx:42
+            const clean = stripAnsi(line).trim();
+            if (!clean || clean.startsWith('●') || clean.startsWith('FAIL') || /^[×✗✕✖✘❌]/.test(clean)) {
+                inTrace = false;
+            }
             const m = clean.match(new RegExp(`\\(?(${TEST_FILE_RE.source}):\\d+`));
-            if (m)
-                files.add(m[1]);
+            if (m && !combined.has(m[1]) && !inTrace) {
+                combined.add(m[1]);
+                inTrace = true;
+            }
         }
     }
-    return [...files];
+    return [...combined];
 }
 // ─── Find the source file that a test file is testing ────────────────────────
 async function findSourceFile(testFilePath, cwd) {
@@ -94,7 +137,11 @@ async function findSourceFile(testFilePath, cwd) {
     const sourceDir = basename(dir) === '__tests__' ? dirname(dir) : dir;
     const exts = [ext, '.ts', '.tsx', '.js', '.jsx'];
     for (const e of exts) {
-        const candidate = join(cwd, sourceDir, `${sourceBase}${e}`);
+        // If sourceDir is absolute (testFilePath was absolute), use it directly.
+        // join(cwd, absoluteDir) doubles the path: /project/home/project/app/... which never exists.
+        const candidate = sourceDir.startsWith('/') || sourceDir.startsWith('\\')
+            ? join(sourceDir, `${sourceBase}${e}`)
+            : join(cwd, sourceDir, `${sourceBase}${e}`);
         try {
             await access(candidate);
             return candidate;
@@ -115,9 +162,9 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
     const firstRun = await runCommand(fileTestCommand(env, absTestPath), cwd, 60_000);
     if (firstRun.success) {
         if (!onStatus)
-            log(chalk.green('  Already passing — skipping.'));
+            log(chalk.dim('  Already passing — skipping.'));
         onStatus?.({ phase: 'passed', file: shortPath });
-        return { success: true };
+        return { success: true, skipped: true };
     }
     let errorOutput = extractTestFailure(firstRun.stdout + '\n' + firstRun.stderr);
     const initialErrorOutput = errorOutput;
@@ -201,6 +248,16 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
                 continue;
             }
             if (err instanceof OscillationError) {
+                if (attempt < config.maxIterations) {
+                    // Iterations remain — give one escape-hatch attempt with fresh oscillation state
+                    // and an explicit "completely different approach" message instead of stopping.
+                    if (!onStatus)
+                        log(chalk.yellow(`\n  ⚠ Agent loop detected — retrying with different strategy...`));
+                    onStatus?.({ phase: 'retrying', file: shortPath, attempt, max: config.maxIterations });
+                    generator.resetOscillationState();
+                    errorOutput = OSCILLATION_ESCAPE_MESSAGE;
+                    continue;
+                }
                 if (!onStatus)
                     log(chalk.red(`\n  ⚠ Agent loop detected — output identical to a previous attempt. Stopping early.`));
                 onStatus?.({ phase: 'failed', file: shortPath });
@@ -255,6 +312,7 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
                 }
             }
         }
+        testFileContent = deduplicateViMocks(testFileContent);
         // Catch empty test files before writing
         if (!hasTestFunctions(testFileContent)) {
             errorOutput =
@@ -317,13 +375,210 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
         error: `Still failing after ${config.maxIterations} attempts. Last error:\n${errorOutput.slice(0, 1500)}`,
     };
 }
+// ─── Polluter detection ───────────────────────────────────────────────────────
+function buildTestFileRegex(pattern) {
+    const filename = pattern.split('/').pop() ?? pattern;
+    const regexStr = filename
+        .replace(/\{([^}]+)\}/g, (_, g) => `(${g.split(',').map((s) => s.trim()).join('|')})`)
+        .replace(/\./g, '\\.')
+        .replace(/\*+/g, '[^/]+');
+    return new RegExp(regexStr + '$');
+}
+async function discoverTestFiles(cwd, env) {
+    const testRe = buildTestFileRegex(env.testFilePattern);
+    const files = [];
+    const skipDirs = new Set(['node_modules', 'dist', '.git', 'coverage', '.nyc_output', '.lacuna']);
+    async function walk(dir) {
+        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+        for (const e of entries) {
+            if (e.isDirectory()) {
+                if (!skipDirs.has(e.name))
+                    await walk(join(dir, e.name));
+            }
+            else if (testRe.test(e.name)) {
+                files.push(join(dir, e.name));
+            }
+        }
+    }
+    await walk(cwd);
+    return files.sort();
+}
+function victimInFailing(victim, failing, cwd) {
+    const rel = (p) => (p.startsWith(cwd + '/') ? p.slice(cwd.length + 1) : p);
+    const shortVictim = rel(victim);
+    return failing.some(f => {
+        const shortF = rel(f);
+        return shortF === shortVictim || shortVictim.endsWith(shortF) || shortF.endsWith(shortVictim);
+    });
+}
+async function victimFailsWithSubset(victim, subset, env, cwd) {
+    if (subset.length === 0)
+        return false;
+    const result = await runCommand(multiFileTestCommand(env, [...subset, victim]), cwd, 120_000);
+    if (result.success)
+        return false;
+    const failing = parseFailingTestFiles(result.stdout + '\n' + result.stderr, env.testRunner);
+    return victimInFailing(victim, failing, cwd);
+}
+async function bisectPolluter(victim, candidates, env, cwd) {
+    if (candidates.length === 0)
+        return null;
+    if (candidates.length === 1) {
+        const fails = await victimFailsWithSubset(victim, candidates, env, cwd);
+        return fails ? candidates[0] : null;
+    }
+    const mid = Math.floor(candidates.length / 2);
+    const left = candidates.slice(0, mid);
+    const right = candidates.slice(mid);
+    if (await victimFailsWithSubset(victim, left, env, cwd))
+        return bisectPolluter(victim, left, env, cwd);
+    if (await victimFailsWithSubset(victim, right, env, cwd))
+        return bisectPolluter(victim, right, env, cwd);
+    return null;
+}
+async function findAndFixPolluters(victimFiles, options, projectMemory) {
+    const { config, env, cwd, log } = options;
+    const allTestFiles = await discoverTestFiles(cwd, env);
+    log(chalk.dim(`  Discovered ${allTestFiles.length} test files to search.`));
+    const generator = new TestGenerator({ config, env });
+    let pollutersFixed = 0;
+    let victimsRegenerated = 0;
+    const seenPolluters = new Set();
+    const unresolvedVictims = [];
+    for (const victim of victimFiles) {
+        const shortVictim = victim.replace(cwd + '/', '');
+        log(chalk.dim(`\n  Bisecting for: ${chalk.cyan(shortVictim)}`));
+        const candidates = allTestFiles.filter(f => f !== victim);
+        // Probe: verify the pollution reproduces before spending O(log N) bisect runs.
+        // If it doesn't reproduce here, the pollution requires vitest's default multi-worker
+        // config to manifest and can't be found by this approach.
+        log(chalk.dim(`  Probing (${candidates.length} files + victim)...`));
+        const reproduced = await victimFailsWithSubset(victim, candidates, env, cwd);
+        if (!reproduced) {
+            log(chalk.yellow(`  Pollution did not reproduce in sequential mode — this is concurrency-based globalThis contamination.`));
+            log(chalk.dim(`  A vi.spyOn(global, ...) spy from another file is persisting in the shared worker thread.`));
+            log(chalk.dim(`  Fix: add restoreMocks: true and clearMocks: true to the test: {} block in vitest.config.ts`));
+            log(chalk.dim(`  Also add beforeEach(() => vi.restoreAllMocks()) to your test setup file.`));
+            unresolvedVictims.push(victim);
+            continue;
+        }
+        const polluter = await bisectPolluter(victim, candidates, env, cwd);
+        if (!polluter) {
+            log(chalk.yellow(`  Could not isolate a polluter — file may have an internal spy lifecycle bug.`));
+            unresolvedVictims.push(victim);
+            continue;
+        }
+        const shortPolluter = polluter.replace(cwd + '/', '');
+        log(`  Found polluter: ${chalk.cyan(shortPolluter)}`);
+        if (seenPolluters.has(polluter)) {
+            log(chalk.dim(`  Already processed ${shortPolluter}.`));
+            continue;
+        }
+        seenPolluters.add(polluter);
+        // Capture the victim's failure output when run after the polluter
+        const errorRun = await runCommand(multiFileTestCommand(env, [polluter, victim]), cwd, 60_000);
+        const victimError = extractTestFailure(errorRun.stdout + '\n' + errorRun.stderr);
+        const pollutorCode = await readFile(polluter, 'utf-8').catch(() => null);
+        const victimCode = await readFile(victim, 'utf-8').catch(() => null);
+        if (!pollutorCode || !victimCode) {
+            log(chalk.red(`  Could not read files — skipping ${shortPolluter}`));
+            unresolvedVictims.push(victim);
+            continue;
+        }
+        log(chalk.dim(`  Sending to ${config.model} for cleanup...`));
+        let fixed;
+        try {
+            fixed = await generator.fixPollution({
+                pollutorFile: shortPolluter,
+                pollutorCode,
+                victimFile: shortVictim,
+                victimCode,
+                victimError,
+                env,
+            });
+        }
+        catch (err) {
+            log(chalk.red(`  AI error: ${err instanceof Error ? err.message : String(err)}`));
+            unresolvedVictims.push(victim);
+            continue;
+        }
+        await writeFile(polluter, fixed, 'utf-8');
+        const verifyRun = await runCommand(multiFileTestCommand(env, [polluter, victim]), cwd, 60_000);
+        const verifyFailing = parseFailingTestFiles(verifyRun.stdout + '\n' + verifyRun.stderr, env.testRunner);
+        const victimResolved = !victimInFailing(victim, verifyFailing, cwd);
+        if (victimResolved) {
+            log(chalk.green(`  Cleanup applied: ${shortPolluter}`));
+            pollutersFixed++;
+        }
+        else {
+            log(chalk.red(`  Cleanup did not resolve the victim — restoring ${shortPolluter}`));
+            await writeFile(polluter, pollutorCode, 'utf-8').catch(() => { });
+            unresolvedVictims.push(victim);
+        }
+    }
+    // Phase 2: regenerate victims that bisection couldn't resolve.
+    // These files pass alone but fail in the suite due to internal bugs
+    // (e.g. module-level vi.spyOn, wrong mock structure). A fresh generation
+    // produces properly-structured tests with spies inside beforeEach.
+    if (unresolvedVictims.length > 0 && options.regenerateOnFailure !== false) {
+        log(chalk.bold(`\n  Regenerating ${unresolvedVictims.length} victim file(s) that couldn't be resolved by polluter cleanup...`));
+        for (const victim of unresolvedVictims) {
+            const shortVictim = victim.replace(cwd + '/', '');
+            log(chalk.dim(`\n  Regenerating: ${chalk.cyan(shortVictim)}`));
+            const result = await regenerateFile(victim, options, undefined, projectMemory);
+            if (result.success) {
+                log(chalk.green(`  Regenerated successfully.`));
+                victimsRegenerated++;
+            }
+            else {
+                log(chalk.red(`  Regeneration failed: ${result.error?.slice(0, 200) ?? 'unknown error'}`));
+            }
+        }
+    }
+    return { pollutersFixed, victimsRegenerated };
+}
+// ─── Regeneration fallback ────────────────────────────────────────────────────
+async function regenerateFile(testFilePath, options, onStatus, projectMemory) {
+    const absTestFile = testFilePath.startsWith('/') ? testFilePath : join(options.cwd, testFilePath);
+    // Find the source file so processGap gets the right starting point.
+    // processGap expects gap.filePath to be the SOURCE file, not the test file.
+    const sourceFile = await findSourceFile(absTestFile, options.cwd);
+    if (!sourceFile) {
+        return { success: false, error: `Could not find source file for ${absTestFile}` };
+    }
+    // Delete the broken test file before regenerating. If it stays on disk,
+    // buildFileContext reads it as existingTestCode and the generate prompt says
+    // "preserve all existing tests" — locking the AI into the same broken structure.
+    await unlink(absTestFile).catch(() => { });
+    const gap = { filePath: sourceFile, uncoveredLines: [], uncoveredFunctions: [] };
+    const generator = new TestGenerator({ config: options.config, env: options.env });
+    // processGap uses gap.filePath (the source file) as its display identifier, but during
+    // regen the worker should stay in 'regenerating' for all intermediate phases and only
+    // flip to passed/failed at the end. This prevents the brief flash where 'regenerating'
+    // gets overwritten by 'generating' (<80ms) as soon as processGap starts.
+    const testShortPath = absTestFile.replace(options.cwd + '/', '');
+    const regenOnStatus = onStatus
+        ? (state) => {
+            if (state.phase === 'passed' || state.phase === 'failed') {
+                onStatus('file' in state ? { ...state, file: testShortPath } : state);
+            }
+            else {
+                onStatus({ phase: 'regenerating', file: testShortPath });
+            }
+        }
+        : undefined;
+    const result = await processGap(gap, options, generator, true, regenOnStatus, projectMemory);
+    return { success: result.success, error: result.error };
+}
 // ─── Worker pool ──────────────────────────────────────────────────────────────
 async function runFixWorkers(testFiles, options, workerCount, projectMemory) {
     const queue = [...testFiles];
     let filesProcessed = 0;
     let filesFixed = 0;
+    let filesAlreadyPassing = 0;
     const errors = [];
     const stillFailingFiles = [];
+    const victimFiles = [];
     const tips = getActiveTips({
         workers: workerCount,
         targetFile: options.targetFile,
@@ -344,10 +599,32 @@ async function runFixWorkers(testFiles, options, workerCount, projectMemory) {
             if (!file)
                 break;
             const onStatus = (state) => display.update(wi, state);
-            const result = await fixFile(file, { ...options, log: () => { }, verbose: false }, generator, onStatus, projectMemory);
+            const absFile = file.startsWith('/') ? file : join(options.cwd, file);
+            const workerOptions = { ...options, log: () => { }, verbose: false };
+            const result = await fixFile(absFile, workerOptions, generator, onStatus, projectMemory);
             filesProcessed++;
-            if (result.success)
-                filesFixed++;
+            if (result.success) {
+                if (result.skipped) {
+                    filesAlreadyPassing++;
+                    victimFiles.push(absFile);
+                }
+                else
+                    filesFixed++;
+            }
+            else if (options.regenerateOnFailure) {
+                // Signal 'regenerating' first — this undoes the 'failed' done-count from fixFile
+                // so the regen's final phase is the single counted outcome for this file.
+                onStatus?.({ phase: 'regenerating', file: absFile.replace(options.cwd + '/', '') });
+                const regenResult = await regenerateFile(absFile, workerOptions, onStatus, projectMemory);
+                if (regenResult.success) {
+                    filesFixed++;
+                }
+                else {
+                    stillFailingFiles.push(file);
+                    if (regenResult.error)
+                        errors.push(regenResult.error);
+                }
+            }
             else {
                 stillFailingFiles.push(file);
                 if (result.error)
@@ -356,7 +633,7 @@ async function runFixWorkers(testFiles, options, workerCount, projectMemory) {
         }
     }));
     display.finish();
-    return { filesProcessed, filesFixed, errors, stillFailingFiles };
+    return { filesProcessed, filesFixed, filesAlreadyPassing, errors, stillFailingFiles, victimFiles };
 }
 // ─── Main entry point ─────────────────────────────────────────────────────────
 export async function runFixLoop(options) {
@@ -374,7 +651,7 @@ export async function runFixLoop(options) {
         spinner.stop();
         if (fileResult.success) {
             log(chalk.green('\n  All tests are passing — nothing to fix.'));
-            return { filesProcessed: 0, filesFixed: 0, errors: [] };
+            return { filesProcessed: 0, filesFixed: 0, filesAlreadyPassing: 0, pollutersFixed: 0, victimsRegenerated: 0, errors: [] };
         }
         failingFiles = [absTarget];
     }
@@ -396,7 +673,7 @@ export async function runFixLoop(options) {
             }
             if (suiteResult.success) {
                 log(chalk.green('\n  All tests are passing — nothing to fix.'));
-                return { filesProcessed: 0, filesFixed: 0, errors: [] };
+                return { filesProcessed: 0, filesFixed: 0, filesAlreadyPassing: 0, pollutersFixed: 0, victimsRegenerated: 0, errors: [] };
             }
             failingFiles = parseFailingTestFiles(suiteResult.stdout + suiteResult.stderr, env.testRunner);
             failingFiles = failingFiles.filter((f) => {
@@ -413,7 +690,7 @@ export async function runFixLoop(options) {
                     .join('\n');
                 if (lastLines)
                     log(chalk.dim('\n  Last output lines:\n' + lastLines.split('\n').map((l) => `    ${l}`).join('\n')));
-                return { filesProcessed: 0, filesFixed: 0, errors: [] };
+                return { filesProcessed: 0, filesFixed: 0, filesAlreadyPassing: 0, pollutersFixed: 0, victimsRegenerated: 0, errors: [] };
             }
             await saveFixCache(cwd, failingFiles);
         }
@@ -429,17 +706,21 @@ export async function runFixLoop(options) {
     const memorySnapshot = memory.toPromptSection();
     let filesProcessed;
     let filesFixed;
+    let filesAlreadyPassing;
     let errors;
     let stillFailingFiles;
+    let victimFiles;
     if (parallel) {
         ;
-        ({ filesProcessed, filesFixed, errors, stillFailingFiles } = await runFixWorkers(failingFiles, options, workerCount, memorySnapshot));
+        ({ filesProcessed, filesFixed, filesAlreadyPassing, errors, stillFailingFiles, victimFiles } = await runFixWorkers(failingFiles, options, workerCount, memorySnapshot));
     }
     else {
         filesProcessed = 0;
         filesFixed = 0;
+        filesAlreadyPassing = 0;
         errors = [];
         stillFailingFiles = [];
+        victimFiles = [];
         const generator = new TestGenerator({ config, env });
         const tips = getActiveTips({
             workers: 1,
@@ -460,8 +741,26 @@ export async function runFixLoop(options) {
             const absFile = file.startsWith('/') ? file : join(cwd, file);
             const result = await fixFile(absFile, options, generator, undefined, memory.toPromptSection());
             filesProcessed++;
-            if (result.success)
-                filesFixed++;
+            if (result.success) {
+                if (result.skipped) {
+                    filesAlreadyPassing++;
+                    victimFiles.push(absFile);
+                }
+                else
+                    filesFixed++;
+            }
+            else if (options.regenerateOnFailure) {
+                log(chalk.yellow(`  Fix exhausted — falling back to full regeneration...`));
+                const regenResult = await regenerateFile(absFile, options, undefined, memory.toPromptSection());
+                if (regenResult.success) {
+                    filesFixed++;
+                }
+                else {
+                    stillFailingFiles.push(file);
+                    if (regenResult.error)
+                        errors.push(regenResult.error);
+                }
+            }
             else {
                 stillFailingFiles.push(file);
                 if (result.error)
@@ -479,6 +778,14 @@ export async function runFixLoop(options) {
         else
             await clearFixCache(cwd);
     }
-    return { filesProcessed, filesFixed, errors };
+    let pollutersFixed = 0;
+    let victimsRegenerated = 0;
+    if (options.fixPolluters && victimFiles.length > 0) {
+        log(chalk.bold(`\n  Scanning for test polluters (${victimFiles.length} victim file(s) pass alone but fail in suite)...`));
+        const polluterResult = await findAndFixPolluters(victimFiles, options, memorySnapshot);
+        pollutersFixed = polluterResult.pollutersFixed;
+        victimsRegenerated = polluterResult.victimsRegenerated;
+    }
+    return { filesProcessed, filesFixed, filesAlreadyPassing, pollutersFixed, victimsRegenerated, errors };
 }
 //# sourceMappingURL=fix-loop.js.map