lacuna-cli 0.1.8 → 0.2.0

package/dist/agent/fix-loop.js

@@ -1,22 +1,27 @@
 import { readFile, writeFile, mkdir, unlink, readdir } from 'fs/promises';
-import { join, dirname, basename, extname } from 'path';
+import { join, dirname, basename, extname, isAbsolute } from 'path';
 import { access, stat } from 'fs/promises';
 import chalk from 'chalk';
 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 { buildFixFileContext, computeRelativeImport, collectTypeDefinitions, collectLocalImportPaths, detectReactMajorVersion, findFileByName } from './context.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, deduplicateViMocks } from '../lib/validate.js';
+import { typeCheckFile, findTestFilesWithTypeErrors } from '../lib/typecheck.js';
+import { hasTestFunctions, hasPlaceholderBodies, enrichNoTestsError, isZeroTestsOutput, parsePassCount, buildStructureBrokenMessage, buildRegressionMessage, sanitizeMocksContent, stripLeadingProse, mergeMocksContent, deduplicateViMocks, tryApplyPatch, tryApplyMocksPatch } from '../lib/validate.js';
 import { extractTestFailure } from '../lib/extract-error.js';
 import { StreamingFileViewer } from '../lib/streaming-viewer.js';
 // ─── Failing-files cache ──────────────────────────────────────────────────────
 const FIX_CACHE_TTL_S = 1800; // 30 minutes
+// Regenerate-on-failure only attempts a from-scratch rewrite when the file has FEWER than
+// this many passing tests. A file with a substantial passing suite is repaired, never nuked
+// and rebuilt — regenerating it from scratch is slow and almost never reproduces the suite.
+// (regenerateFile additionally never keeps a regen that reduces the passing count.)
+const REGEN_MAX_BASELINE_PASS = 10;
 function fixCachePath(cwd) {
     return join(cwd, '.lacuna-fix-cache.json');
 }
@@ -127,26 +132,74 @@ function parseFailingTestFiles(output, runner) {
     return [...combined];
 }
 // ─── Find the source file that a test file is testing ────────────────────────
-async function findSourceFile(testFilePath, cwd) {
+async function findSourceFile(testFilePath, cwd, configSourceDirs = 'src') {
     const ext = extname(testFilePath);
     const base = basename(testFilePath, ext);
     const dir = dirname(testFilePath);
-    // strip test suffix: Button.test → Button, Button.spec → Button
     const sourceBase = base.replace(/\.(test|spec)$/, '').replace(/^test_/, '').replace(/_test$/, '');
-    // if inside __tests__ dir, source is in parent
-    const sourceDir = basename(dir) === '__tests__' ? dirname(dir) : dir;
     const exts = [ext, '.ts', '.tsx', '.js', '.jsx'];
+    const srcDirs = Array.isArray(configSourceDirs) ? configSourceDirs : [configSourceDirs];
+    async function tryCandidates(targetDir) {
+        const resolved = isAbsolute(targetDir) ? targetDir : join(cwd, targetDir);
+        for (const e of exts) {
+            try {
+                await access(join(resolved, `${sourceBase}${e}`));
+                return join(resolved, `${sourceBase}${e}`);
+            }
+            catch { /* next */ }
+        }
+        return null;
+    }
+    // Attempt 1: same directory as test file, or parent of __tests__
+    const sameDir = basename(dir) === '__tests__' ? dirname(dir) : dir;
+    const attempt1 = await tryCandidates(sameDir);
+    if (attempt1)
+        return attempt1;
+    // Attempt 2: replace test directory segment with sourceDir
+    // Handles monorepo layouts like:  packages/server/test/unit/adapters/Foo.test.ts
+    //                              →  packages/server/src/adapters/Foo.ts
+    const TEST_SEGMENT_RE = /^(.*[/\\])(?:tests?|specs?)[/\\](?:(?:unit|integration|e2e|functional|features?)[/\\])?(.*)$/i;
+    const match = dir.match(TEST_SEGMENT_RE);
+    if (match) {
+        const [, prefix, suffix] = match;
+        for (const srcDir of srcDirs) {
+            // Strategy A: relative srcDir appended to the test root prefix
+            // Works when sourceDir is short ("src") and test is nested under same package root
+            const a = await tryCandidates(join(prefix, srcDir, suffix));
+            if (a)
+                return a;
+            // Strategy B: absolute resolved srcDir + relative suffix
+            // Works when sourceDir is explicit ("packages/server/src")
+            const absSrc = isAbsolute(srcDir) ? srcDir : join(cwd, srcDir);
+            const b = await tryCandidates(join(absSrc, suffix));
+            if (b)
+                return b;
+        }
+    }
+    // Attempt 3: recursive filename search.
+    // Handles extra segments between src/ and the file (e.g. test/unit/interactors/Foo.test.ts
+    // → src/lib/interactors/Foo.ts — the "lib" is invisible to the mirror logic above).
+    // Search roots: (a) package prefix + srcDir (most targeted, e.g. packages/server/src/),
+    // then (b) absolute srcDir from config (for flat repos).
+    const searchRoots = [];
+    if (match) {
+        const [, prefix] = match;
+        for (const srcDir of srcDirs) {
+            searchRoots.push(join(prefix, srcDir));
+        }
+    }
+    for (const srcDir of srcDirs) {
+        const abs = isAbsolute(srcDir) ? srcDir : join(cwd, srcDir);
+        if (!searchRoots.includes(abs))
+            searchRoots.push(abs);
+    }
     for (const e of exts) {
-        // 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;
+        const filename = `${sourceBase}${e}`;
+        for (const root of searchRoots) {
+            const found = await findFileByName(root, filename);
+            if (found)
+                return found;
         }
-        catch { /* try next */ }
     }
     return null;
 }
@@ -160,13 +213,26 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
     onStatus?.({ phase: 'running', file: shortPath });
     // Run just this test file to get focused error output
     const firstRun = await runCommand(fileTestCommand(env, absTestPath), cwd, 60_000);
+    let typeErrorsAtStart = null;
     if (firstRun.success) {
+        // Tests pass. In targeted (--file) or --types mode, a green file may still have
+        // TypeScript errors the runner ignores (it transpiles, doesn't type-check) — repair
+        // those rather than skip, otherwise generate's "run lacuna fix --file …" hand-off and
+        // `lacuna fix --types` are dead ends. Default full-suite mode keeps skipping so
+        // pollution-victim accounting is untouched.
+        typeErrorsAtStart = (options.targetFile || options.types) ? await typeCheckFile(absTestPath, cwd, env) : null;
+        if (!typeErrorsAtStart) {
+            if (!onStatus)
+                log(chalk.dim('  Already passing — skipping.'));
+            onStatus?.({ phase: 'passed', file: shortPath });
+            return { success: true, skipped: true };
+        }
         if (!onStatus)
-            log(chalk.dim('  Already passing — skipping.'));
-        onStatus?.({ phase: 'passed', file: shortPath });
-        return { success: true, skipped: true };
+            log(chalk.yellow('  Tests pass but type errors found — repairing types.'));
     }
-    let errorOutput = extractTestFailure(firstRun.stdout + '\n' + firstRun.stderr);
+    let errorOutput = typeErrorsAtStart
+        ? `Tests pass but the test file has TypeScript type errors:\n${typeErrorsAtStart}\n\nFix ALL type errors without changing test behavior. Do not use 'as any' or '@ts-ignore'.`
+        : extractTestFailure(firstRun.stdout + '\n' + firstRun.stderr);
     const initialErrorOutput = errorOutput;
     const baselinePassCount = parsePassCount(firstRun.stdout + '\n' + firstRun.stderr);
     // Read existing test file
@@ -182,7 +248,7 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
         return { success: false, error: msg };
     }
     // Find and read the source file being tested
-    const sourceFilePath = await findSourceFile(testFilePath, cwd);
+    const sourceFilePath = await findSourceFile(testFilePath, cwd, config.sourceDir);
     let sourceCode = null;
     if (sourceFilePath) {
         sourceCode = await readFile(sourceFilePath, 'utf-8').catch(() => null);
@@ -245,6 +311,7 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
                     localImportPaths,
                     reactMajorVersion,
                     projectMemory,
+                    existingTestLineCount: testCode.split('\n').length,
                 })
                 : await generator.retry(errorOutput);
         }
@@ -304,6 +371,29 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
             onStatus?.({ phase: 'passed', file: shortPath });
             return { success: true };
         }
+        // Patch mode: apply surgical edits against the current file on disk
+        if (generator.isPatch) {
+            const currentContent = await readFile(absTestPath, 'utf-8').catch(() => null) ?? testCode;
+            const patched = tryApplyPatch(currentContent, fixed);
+            if (patched !== null) {
+                fixed = patched;
+            }
+            else {
+                // Anchor(s) not found — do NOT write raw patch markers to disk
+                errorOutput =
+                    'PATCH APPLICATION FAILED: one or more anchor strings in your patch were not found in the test file.\n' +
+                        'Anchors must be copied character-for-character (including quote style) from the CURRENT TEST FILE shown above.\n' +
+                        'Checklist:\n' +
+                        '  • REPLACE_TEST / DELETE_TEST anchor = exact it/test name already in the file\n' +
+                        '  • ADD_AFTER_DESCRIBE anchor = exact describe() name already in the file\n' +
+                        '  • For a brand-new test, use ADD_AFTER_DESCRIBE with the enclosing describe name\n' +
+                        'Re-read the test file, find the exact anchor names, and rewrite your patch.';
+                if (!onStatus)
+                    log(chalk.yellow(`  Patch anchors not found — retrying...`));
+                onStatus?.({ phase: 'retrying', file: shortPath, attempt, max: config.maxIterations });
+                continue;
+            }
+        }
         // Strip thinking/prose that leaked before the first real code line.
         const { code: cleanFixed, stripped: bleedText } = stripLeadingProse(fixed);
         if (bleedText !== null) {
@@ -313,8 +403,37 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
         }
         // Split out mocks file if AI returned one
         const MOCKS_SEPARATOR = '// ---MOCKS_FILE---';
+        const MOCKS_PATCH_SEPARATOR = '// ---MOCKS_PATCH---';
         let testFileContent = fixed;
-        if (fixed.includes(MOCKS_SEPARATOR) && config.mocksFile) {
+        if (fixed.includes(MOCKS_PATCH_SEPARATOR) && config.mocksFile) {
+            // Surgical patch mode: model only emits the changed sections
+            const [newTestCode, patchContent] = fixed.split(MOCKS_PATCH_SEPARATOR);
+            testFileContent = newTestCode.trim();
+            if (patchContent?.trim()) {
+                const absoluteMocksFile = join(cwd, config.mocksFile);
+                let existing = '';
+                try {
+                    existing = await readFile(absoluteMocksFile, 'utf-8');
+                }
+                catch { /* new file — patch can't apply */ }
+                if (existing) {
+                    const applied = tryApplyMocksPatch(existing, patchContent.trim());
+                    if (applied) {
+                        if (applied.failedOps.length > 0) {
+                            const anchors = applied.failedOps.map(op => `"${op.oldText.slice(0, 60).replace(/\n/g, '↵')}"`).join(', ');
+                            errorOutput = `MOCKS PATCH FAILED: the following REPLACE anchor(s) were not found in the mock file:\n${anchors}\nAnchors must be copied character-for-character from the SHARED MOCK FILE shown above. Re-read it and rewrite your ---MOCKS_PATCH--- block.`;
+                            if (!onStatus)
+                                log(chalk.yellow(`  ⚠ Mock patch anchors not found — retrying...`));
+                            continue;
+                        }
+                        await writeFile(absoluteMocksFile, applied.result, 'utf-8');
+                        if (!onStatus)
+                            log(chalk.dim(`  Patched mocks file: ${config.mocksFile}`));
+                    }
+                }
+            }
+        }
+        else if (fixed.includes(MOCKS_SEPARATOR) && config.mocksFile) {
             const [newTestCode, newMocksCode] = fixed.split(MOCKS_SEPARATOR);
             testFileContent = newTestCode.trim();
             if (newMocksCode?.trim()) {
@@ -356,14 +475,39 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
         onStatus?.({ phase: 'running', file: shortPath });
         const result = await runCommand(fileTestCommand(env, absTestPath), cwd, 60_000);
         if (result.success) {
+            if (hasPlaceholderBodies(testFileContent)) {
+                errorOutput =
+                    'ERROR: One or more test bodies contain placeholder comments (e.g. `// body`, `// TODO`) with no real assertions.\n' +
+                        'Every test must have complete, working expectations:\n' +
+                        '  it(\'description\', async () => {\n' +
+                        '    const result = await subject.doThing(...);\n' +
+                        '    expect(result).toEqual(expectedValue);\n' +
+                        '  })\n' +
+                        'Replace every `// body` placeholder with real arrange-act-assert code.';
+                if (!onStatus)
+                    log(chalk.yellow('  Placeholder test bodies detected — retrying...'));
+                onStatus?.({ phase: 'retrying', file: shortPath, attempt, max: config.maxIterations });
+                continue;
+            }
             const typeErrors = await typeCheckFile(absTestPath, cwd, env);
-            if (typeErrors) {
+            if (typeErrors && typeErrorsAtStart !== null) {
+                // Type-cleanup mode: the file's tests already passed at start (generate→fix handoff or
+                // --types), so type errors ARE the goal — keep retrying to clear them.
                 errorOutput = `Tests passed but TypeScript type errors were found:\n${typeErrors}\n\nFix ALL type errors. Do not use 'as any' or '@ts-ignore'.`;
                 if (!onStatus)
-                    log(chalk.yellow('  Type errors found — retrying...'));
+                    log(chalk.yellow('  Tests pass but type errors found — retrying...'));
                 onStatus?.({ phase: 'retrying', file: shortPath, attempt, max: config.maxIterations });
                 continue;
             }
+            if (typeErrors) {
+                // Test-repair mode: the failing test(s) now PASS — that IS the fix. Residual type
+                // errors (often just implicit-any in mocks) must not make us burn retries or revert to
+                // the broken original. Keep the passing fix; surface the types as a follow-up.
+                if (!onStatus)
+                    log(chalk.yellow('  ⚠ Tests now pass — keeping the fix. Type errors remain; run `lacuna fix --types` to clean them up.'));
+                onStatus?.({ phase: 'passed', file: shortPath });
+                return { success: true };
+            }
             if (!onStatus)
                 log(chalk.green('  Fixed.'));
             onStatus?.({ phase: 'passed', file: shortPath });
@@ -376,7 +520,7 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
         // 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);
+        const extracted = enrichNoTestsError(rawExtracted, rawRunOutput);
         if (structureBroken) {
             errorOutput = buildStructureBrokenMessage(initialErrorOutput, rawExtracted);
             if (!onStatus)
@@ -395,12 +539,17 @@ async function fixFile(testFilePath, options, generator, onStatus, projectMemory
         if (!onStatus && verbose)
             log(chalk.dim(errorOutput.split('\n').slice(0, 20).join('\n')));
     }
-    // Restore original test file — don't leave broken AI code on disk
+    // Restore original test file — don't leave broken AI code on disk.
+    // For a type-only repair this puts back the passing (but type-erroring) file, which is
+    // strictly better than a regenerated guess — so the caller must NOT regenerate it.
     await writeFile(absTestPath, testCode, 'utf-8').catch(() => { });
     onStatus?.({ phase: 'failed', file: shortPath });
+    const typeOnly = firstRun.success;
     return {
         success: false,
-        error: `Still failing after ${config.maxIterations} attempts. Last error:\n${errorOutput.slice(0, 1500)}`,
+        typeOnly,
+        baselinePassCount,
+        error: `${typeOnly ? 'Type errors remain' : 'Still failing'} after ${config.maxIterations} attempts. Last error:\n${errorOutput.slice(0, 1500)}`,
     };
 }
 // ─── Polluter detection ───────────────────────────────────────────────────────
@@ -566,14 +715,21 @@ async function findAndFixPolluters(victimFiles, options, projectMemory) {
     return { pollutersFixed, victimsRegenerated };
 }
 // ─── Regeneration fallback ────────────────────────────────────────────────────
-async function regenerateFile(testFilePath, options, onStatus, projectMemory) {
+async function regenerateFile(testFilePath, options, onStatus, projectMemory, baselinePassCount = 0) {
     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);
+    const sourceFile = await findSourceFile(absTestFile, options.cwd, options.config.sourceDir);
     if (!sourceFile) {
         return { success: false, error: `Could not find source file for ${absTestFile}` };
     }
+    // Back up the current content so a failed regeneration never leaves the file deleted or
+    // filled with a broken last attempt — on failure we restore exactly what was here.
+    let originalContent = null;
+    try {
+        originalContent = await readFile(absTestFile, 'utf-8');
+    }
+    catch { /* already gone */ }
     // 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.
@@ -595,7 +751,23 @@ async function regenerateFile(testFilePath, options, onStatus, projectMemory) {
             }
         }
         : undefined;
-    const result = await processGap(gap, options, generator, true, regenOnStatus, projectMemory);
+    const result = await processGap(gap, options, generator, true, regenOnStatus, projectMemory, absTestFile);
+    if (result.success) {
+        // Never-regress: a "green" regen with fewer tests than the original is still a net loss
+        // (e.g. 50 passing replacing 477). Re-run the regenerated file and keep it only if it has
+        // at least as many passing tests as the original — otherwise restore the original.
+        const regenRun = await runCommand(fileTestCommand(options.env, absTestFile), options.cwd, 60_000);
+        const regenPass = parsePassCount(regenRun.stdout + '\n' + regenRun.stderr);
+        if (regenPass < baselinePassCount && originalContent !== null) {
+            await writeFile(absTestFile, originalContent, 'utf-8').catch(() => { });
+            return { success: false, error: `Regeneration produced fewer passing tests (${regenPass}) than the original (${baselinePassCount}) — restored the original.` };
+        }
+        return { success: true };
+    }
+    // Regeneration failed — restore the original so we never leave the workspace worse than we
+    // found it (deleted, or holding a truncated/garbage attempt).
+    if (originalContent !== null)
+        await writeFile(absTestFile, originalContent, 'utf-8').catch(() => { });
     return { success: result.success, error: result.error };
 }
 // ─── Worker pool ──────────────────────────────────────────────────────────────
@@ -639,11 +811,16 @@ async function runFixWorkers(testFiles, options, workerCount, projectMemory) {
                 else
                     filesFixed++;
             }
-            else if (options.regenerateOnFailure) {
+            else if (options.regenerateOnFailure && !options.types && !result.typeOnly && (result.baselinePassCount ?? Infinity) < REGEN_MAX_BASELINE_PASS) {
+                // Regenerate from scratch only for mostly-broken files (few passing tests) — that's
+                // where a fresh take rescues stuck tests. A file with a substantial passing suite is
+                // left restored by fixFile, never nuked. Skip too for type-only/--types repairs, and
+                // when the baseline is unknown (?? Infinity ⇒ don't risk it). regenerateFile itself
+                // also discards any regen that lowers the passing count.
                 // 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);
+                const regenResult = await regenerateFile(absFile, workerOptions, onStatus, projectMemory, result.baselinePassCount ?? 0);
                 if (regenResult.success) {
                     filesFixed++;
                 }
@@ -669,7 +846,24 @@ export async function runFixLoop(options) {
     const workerCount = Math.max(1, Math.min(options.workers ?? 1, 10));
     const parallel = workerCount > 1;
     let failingFiles;
-    if (options.targetFile) {
+    if (options.types && !options.targetFile) {
+        // Types mode: select by type errors rather than test failures. One project-wide tsc
+        // finds every test file that fails type-checking — including files whose tests pass,
+        // which the normal failure-driven selection never sees.
+        if (env.language !== 'typescript') {
+            log(chalk.yellow('\n  --types only applies to TypeScript projects — nothing to do.'));
+            return { filesProcessed: 0, filesFixed: 0, filesAlreadyPassing: 0, pollutersFixed: 0, victimsRegenerated: 0, errors: [] };
+        }
+        const spinner = startCoverageSpinner(chalk.dim('  Type-checking project to find test files with type errors...'), env.testRunner);
+        const allTestFiles = await discoverTestFiles(cwd, env);
+        failingFiles = await findTestFilesWithTypeErrors(allTestFiles, cwd, env);
+        spinner.stop();
+        if (failingFiles.length === 0) {
+            log(chalk.green('\n  All test files are type-clean — nothing to fix.'));
+            return { filesProcessed: 0, filesFixed: 0, filesAlreadyPassing: 0, pollutersFixed: 0, victimsRegenerated: 0, errors: [] };
+        }
+    }
+    else if (options.targetFile) {
         // Single-file mode: skip the full suite run, go straight to the target file
         const absTarget = options.targetFile.startsWith('/')
             ? options.targetFile
@@ -678,8 +872,15 @@ export async function runFixLoop(options) {
         const fileResult = await runCommand(fileTestCommand(env, absTarget), cwd, 60_000, spinner.onLine);
         spinner.stop();
         if (fileResult.success) {
-            log(chalk.green('\n  All tests are passing — nothing to fix.'));
-            return { filesProcessed: 0, filesFixed: 0, filesAlreadyPassing: 0, pollutersFixed: 0, victimsRegenerated: 0, errors: [] };
+            // Tests pass — but the runner only transpiles, it doesn't type-check. A green file
+            // can still have TypeScript errors (the exact case `generate` hands off here). Only
+            // declare victory if the file is also type-clean; otherwise fall through and repair.
+            const typeErrors = await typeCheckFile(absTarget, cwd, env);
+            if (!typeErrors) {
+                log(chalk.green('\n  All tests are passing — nothing to fix.'));
+                return { filesProcessed: 0, filesFixed: 0, filesAlreadyPassing: 0, pollutersFixed: 0, victimsRegenerated: 0, errors: [] };
+            }
+            log(chalk.yellow('\n  Tests pass but TypeScript type errors remain — repairing types.'));
         }
         failingFiles = [absTarget];
     }
@@ -723,7 +924,7 @@ export async function runFixLoop(options) {
             await saveFixCache(cwd, failingFiles);
         }
     }
-    log(chalk.bold(`\n  Found ${failingFiles.length} failing test file(s).`));
+    log(chalk.bold(`\n  Found ${failingFiles.length} ${options.types ? 'test file(s) with type errors' : 'failing test file(s)'}.`));
     if (parallel) {
         if (options.verbose)
             log(chalk.dim(`  (--verbose is not shown in parallel mode — use --workers 1 to see the live code panel)`));
@@ -777,9 +978,11 @@ export async function runFixLoop(options) {
                 else
                     filesFixed++;
             }
-            else if (options.regenerateOnFailure) {
+            else if (options.regenerateOnFailure && !options.types && !result.typeOnly && (result.baselinePassCount ?? Infinity) < REGEN_MAX_BASELINE_PASS) {
+                // Regenerate only for mostly-broken files (few passing tests) — see runFixWorkers.
+                // A substantial passing suite is left restored by fixFile, never nuked + rebuilt.
                 log(chalk.yellow(`  Fix exhausted — falling back to full regeneration...`));
-                const regenResult = await regenerateFile(absFile, options, undefined, memory.toPromptSection());
+                const regenResult = await regenerateFile(absFile, options, undefined, memory.toPromptSection(), result.baselinePassCount ?? 0);
                 if (regenResult.success) {
                     filesFixed++;
                 }
@@ -800,7 +1003,9 @@ export async function runFixLoop(options) {
     // This means the next `lacuna fix` run skips the full suite and picks up exactly
     // where we left off. If everything was fixed, delete the cache so the next run
     // does a clean suite scan to confirm.
-    if (!options.targetFile) {
+    // Skip in --types mode: it selects by type errors, not the suite-failure axis the
+    // cache represents, so it must not overwrite the failing-files cache.
+    if (!options.targetFile && !options.types) {
         if (stillFailingFiles.length > 0)
             await saveFixCache(cwd, stillFailingFiles);
         else