lacuna-cli 0.1.5 → 0.1.7

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;AAypBD,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, ModelStallError, 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;
@@ -153,15 +200,25 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
     ]);
     // Build mocks/setup context relative to the actual test file path
     const ctx = await buildFixFileContext(absTestPath, cwd, config).catch(() => null);
-    if (!onStatus)
-        log(chalk.dim(`  Sending to ${config.model} for repair...`));
-    onStatus?.({ phase: 'generating', file: shortPath });
+    let stallRetries = 0;
+    const MAX_STALL_RETRIES = 2;
     for (let attempt = 1; attempt <= config.maxIterations; attempt++) {
         if (attempt > 1) {
             if (!onStatus)
                 log(chalk.yellow(`\n  Retry ${attempt}/${config.maxIterations}...`));
-            onStatus?.({ phase: 'retrying', file: shortPath, attempt, max: config.maxIterations });
         }
+        // Show waiting phase before the model call; transition to generating/retrying on first token
+        onStatus?.({ phase: 'waiting', file: shortPath, since: Date.now() });
+        const currentAttempt = attempt;
+        generator.setFirstTokenCallback(() => {
+            onStatus?.({
+                phase: currentAttempt === 1 ? 'generating' : 'retrying',
+                file: shortPath,
+                ...(currentAttempt > 1 ? { attempt: currentAttempt, max: config.maxIterations } : {}),
+            });
+        });
+        if (!onStatus)
+            log(chalk.dim(`  ⌛ Waiting for model response...`));
         let viewer;
         if (verbose && !onStatus) {
             viewer = new StreamingFileViewer(shortPath);
@@ -178,6 +235,7 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
                     sourceCode,
                     sourceImportPath,
                     errorOutput,
+                    env,
                     mocksCode: ctx?.mocksCode ?? null,
                     mocksImportPath: ctx?.mocksImportPath ?? null,
                     setupFileCode: ctx?.setupFileCode ?? null,
@@ -193,6 +251,18 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
         catch (err) {
             viewer?.stop();
             generator.setTokenCallback(undefined);
+            generator.setFirstTokenCallback(undefined);
+            if (err instanceof ModelStallError) {
+                if (stallRetries < MAX_STALL_RETRIES) {
+                    stallRetries++;
+                    if (!onStatus)
+                        log(chalk.yellow(`\n  ⌛ Model stalled — reconnecting (${stallRetries}/${MAX_STALL_RETRIES})...`));
+                    onStatus?.({ phase: 'waiting', file: shortPath, since: Date.now() });
+                    await new Promise(r => setTimeout(r, 3000));
+                    attempt--; // don't consume an AI iteration for a connection stall
+                    continue;
+                }
+            }
             if (err instanceof TruncatedOutputError) {
                 errorOutput = TRUNCATION_RETRY_MESSAGE;
                 if (!onStatus)
@@ -201,6 +271,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 });
@@ -215,6 +295,7 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
         }
         viewer?.stop();
         generator.setTokenCallback(undefined);
+        generator.setFirstTokenCallback(undefined);
         if (dryRun) {
             if (!onStatus) {
                 log(chalk.yellow('\n  [dry-run] Would write:'));
@@ -255,6 +336,7 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
                 }
             }
         }
+        testFileContent = deduplicateViMocks(testFileContent);
         // Catch empty test files before writing
         if (!hasTestFunctions(testFileContent)) {
             errorOutput =
@@ -288,11 +370,15 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
             return { success: true };
         }
         const rawRunOutput = result.stdout + '\n' + result.stderr;
-        const extracted = enrichNoTestsError(extractTestFailure(rawRunOutput));
+        const rawExtracted = extractTestFailure(rawRunOutput);
         const structureBroken = isZeroTestsOutput(rawRunOutput);
         const currentPassCount = structureBroken ? 0 : parsePassCount(rawRunOutput);
+        // enrichNoTestsError adds guidance for genuinely missing test functions;
+        // in the structure-broken path the issue is always a broken import, so use
+        // rawExtracted there so the actual module error isn't buried in boilerplate.
+        const extracted = enrichNoTestsError(rawExtracted);
         if (structureBroken) {
-            errorOutput = buildStructureBrokenMessage(initialErrorOutput, extracted);
+            errorOutput = buildStructureBrokenMessage(initialErrorOutput, rawExtracted);
             if (!onStatus)
                 log(chalk.red(`  Fix broke file structure — 0 tests collected (attempt ${attempt}/${config.maxIterations})`));
         }
@@ -317,13 +403,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 +627,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 +661,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 +679,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 +701,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 +718,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 +734,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 +769,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 +806,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