lacuna-cli 0.1.6 → 0.1.8

package/dist/agent/{prompts.js → prompts/index.js}

@@ -1,114 +1,113 @@
-import { buildSourceSkeleton, shouldUseSkeleton, compressSource, filterMockFileForTest, filterMockFileForSource } from '../lib/skeleton.js';
-// Extracts module names that are already globally mocked in the setup file.
-// Used to tell the agent "don't mock these again" to avoid double-mock conflicts.
+import { buildSourceSkeleton, shouldUseSkeleton, compressSource, filterMockFileForTest, filterMockFileForSource } from '../../lib/skeleton.js';
+import { detectReactNative, buildReactNativeGuidance, detectRntlErrors } from './react-native.js';
+import { analyzeNextJs, buildNextJsGuidance, detectNextJsImportError } from './nextjs.js';
+import { buildReactCauses } from './react.js';
+import { detectVue, buildVueGuidance } from './vue.js';
+import { buildJsCauses } from './runners/js-common.js';
+import { buildVitestCauses } from './runners/vitest.js';
+import { buildTsRule } from './runners/typescript.js';
+// ─── Setup file mock extractor ────────────────────────────────────────────────
 function extractGlobalNextMocks(setupCode) {
     const mocked = [];
-    for (const m of setupCode.matchAll(/vi\.mock\(['"]([^'"]+)['"]/g)) {
+    for (const m of setupCode.matchAll(/(?:vi|jest)\.mock\(['"]([^'"]+)['"]/g)) {
         mocked.push(m[1]);
     }
     return [...new Set(mocked)];
 }
-function analyzeNextJs(sourceCode) {
-    const hasNavigation = /from\s+['"]next\/navigation['"]/.test(sourceCode);
-    const hasHeaders = /from\s+['"]next\/headers['"]/.test(sourceCode);
-    const hasCache = /from\s+['"]next\/cache['"]/.test(sourceCode);
-    const clientModules = [];
-    for (const m of sourceCode.matchAll(/from\s+['"]([^'"]+\.client)['"]/g))
-        clientModules.push(m[1]);
-    const serverModules = [];
-    for (const m of sourceCode.matchAll(/from\s+['"]([^'"]+\.server)['"]/g))
-        serverModules.push(m[1]);
-    const sessionProviders = [];
-    for (const m of sourceCode.matchAll(/from\s+['"]([^'"]*(?:session|auth)[^'"]*)['"]/gi)) {
-        const p = m[1];
-        if (!p.startsWith('next-auth') && !p.startsWith('@auth'))
-            sessionProviders.push(p);
-    }
-    return { hasNavigation, hasHeaders, hasCache, clientModules, serverModules, sessionProviders };
-}
-function buildNextJsGuidance(a) {
-    if (!a.hasNavigation && !a.hasHeaders && !a.hasCache && !a.clientModules.length && !a.serverModules.length && !a.sessionProviders.length)
-        return null;
-    const lines = [
-        'NEXT.JS MOCKING (critical — Vitest cannot resolve these modules without explicit mocks):',
-    ];
-    if (a.hasNavigation) {
-        lines.push("Mock next/navigation — required for any component that uses useRouter, usePathname, useSearchParams, or useParams (skip if already listed as globally mocked above):", "  vi.mock('next/navigation', () => ({", "    useRouter:       vi.fn(() => ({ push: vi.fn(), replace: vi.fn(), back: vi.fn(), forward: vi.fn() })),", "    usePathname:     vi.fn(() => '/'),", "    useSearchParams: vi.fn(() => new URLSearchParams()),", "    useParams:       vi.fn(() => ({})),", "    redirect:        vi.fn(),", "  }))");
-    }
-    if (a.hasHeaders) {
-        lines.push("Mock next/headers — it is server-only and will throw in Vitest:", "  vi.mock('next/headers', () => ({", "    cookies:  vi.fn(() => ({ get: vi.fn(), set: vi.fn(), delete: vi.fn(), has: vi.fn() })),", "    headers:  vi.fn(() => new Headers()),", "  }))");
-    }
-    if (a.hasCache) {
-        lines.push("Mock next/cache — revalidatePath, revalidateTag, unstable_cache are no-ops in tests:", "  vi.mock('next/cache', () => ({", "    revalidatePath:  vi.fn(),", "    revalidateTag:   vi.fn(),", "    unstable_cache:  vi.fn((fn: () => unknown) => fn),", "  }))");
-    }
-    if (a.clientModules.length > 0) {
-        lines.push(`The source imports .client boundary files that Vitest cannot resolve: ${a.clientModules.join(', ')}`, "Mock each one by its EXACT import path as it appears in the source file. Export every function the source uses as a vi.fn():", ...a.clientModules.map(p => `  vi.mock('${p}', () => ({ /* each exported function: myFn: vi.fn() */ }))`), "Do not try to import the real .client file — it will always fail in Vitest.");
-    }
-    if (a.serverModules.length > 0) {
-        lines.push(`The source imports .server boundary files that Vitest cannot resolve: ${a.serverModules.join(', ')}`, "Mock each one the same way as .client files:", ...a.serverModules.map(p => `  vi.mock('${p}', () => ({ /* each exported function: myFn: vi.fn() */ }))`));
-    }
-    if (a.sessionProviders.length > 0) {
-        lines.push(`The source imports session/auth providers: ${a.sessionProviders.join(', ')}`, "Mock them and return a controlled session object:", `  vi.mock('${a.sessionProviders[0]}', () => ({`, "    useSession: vi.fn(() => ({ user: { id: 'user-1', email: 'test@example.com' }, status: 'authenticated' })),", "    getSession: vi.fn(() => Promise.resolve({ user: { id: 'user-1' } })),", "  }))");
-    }
-    lines.push("If Vitest still reports 'Failed to resolve import', the mock path does not exactly match the import in the source. Copy it character-for-character.");
-    return lines.join('\n');
-}
-// ─── React Native detector & guidance ───────────────────────────────────────
-function detectReactNative(packageDeps) {
-    if (!packageDeps)
-        return false;
-    return /\breact-native\b/.test(packageDeps) || /\bexpo\b/.test(packageDeps);
-}
-function buildReactNativeGuidance() {
-    return [
-        'REACT NATIVE PROJECT — use @testing-library/react-native, not @testing-library/react.',
-        "- Import render, screen, fireEvent, waitFor from '@testing-library/react-native'",
-        '- No document, window, or localStorage globals — they do not exist in React Native',
-        "- Mock react-native modules with vi.mock('react-native', ...) or jest.mock('react-native', ...)",
-        '- Mock navigation: if @react-navigation/native is used, mock useNavigation, useRoute',
-        '- Mock expo-router if present: mock useRouter, useLocalSearchParams, Link',
-        '- Use fireEvent.press() not fireEvent.click() for Pressable/TouchableOpacity',
-        '- Async state: use waitFor() from @testing-library/react-native, not from @testing-library/react',
-    ].join('\n');
-}
-// ─── Vue detector & guidance ─────────────────────────────────────────────────
-function detectVue(packageDeps) {
-    if (!packageDeps)
-        return false;
-    return /\bvue\b/.test(packageDeps);
-}
-function buildVueGuidance() {
-    return [
-        'VUE PROJECT — use @testing-library/vue for component tests.',
-        "- Import render, screen, fireEvent, waitFor from '@testing-library/vue'",
-        "- Import userEvent from '@testing-library/user-event'",
-        '- Wrap async user interactions with await userEvent.setup() and await act()',
-    ].join('\n');
-}
-// Matches both directory-level patterns (/api/, /services/) and file-level names
-// (../../lib/api, ../apiClient, ./httpService) so axios instance files aren't missed.
 const API_IMPORT_RE = /\/(?:api|services?|requests?|http|client|network)\/|\/(?:api|axios|http|request)(?:Client|Config|Instance|Service|Helper)?(?:\/|$)|[/.]api(?:[./]|$)/i;
 function analyzeNetworkDeps(sourceCode) {
     const usesAxios = /\baxios\b/.test(sourceCode);
     const usesFetch = /\bfetch\s*\(/.test(sourceCode);
     const usesCustomInstance = /axios\.create\s*\(/.test(sourceCode);
-    // Collect local imports from paths that look like API/service modules
     const apiModuleImports = [];
     for (const m of sourceCode.matchAll(/from\s+['"](\.[^'"]+)['"]/g)) {
         const path = m[1];
-        if (API_IMPORT_RE.test(path)) {
+        if (API_IMPORT_RE.test(path))
             apiModuleImports.push(path);
-        }
     }
     return { usesAxios, usesFetch, usesCustomInstance, apiModuleImports };
 }
-// Surfaces TypeScript compiler errors in a form the model can act on directly.
-// Philosophy: tsc output is already the fix instruction — our job is to make sure
-// the model reads it literally rather than overriding it with framework conventions.
-// Two layers:
-//   1. Extract structured info from the error text for the highest-value patterns
-//      (member lists, suggestions, mismatched types) so the model doesn't have to hunt.
-//   2. Generic pass-through for everything else — the compiler already said what's wrong.
+function buildNetworkMockingGuidance(analysis, sourceFile, mockApi) {
+    if (!analysis.usesAxios && !analysis.usesFetch && analysis.apiModuleImports.length === 0)
+        return null;
+    const lines = ['NETWORK MOCKING (critical — a real HTTP request reaching the network is a test bug):'];
+    if (analysis.apiModuleImports.length > 0) {
+        lines.push(`The source file imports from API/service modules: ${analysis.apiModuleImports.join(', ')}`, `Mock THOSE modules, not the underlying HTTP client:`, `  ${mockApi}.mock('${analysis.apiModuleImports[0]}', () => ({ myFn: ${mockApi}.fn() }))`, `This is the most reliable approach — it intercepts at the contract boundary regardless of which HTTP client is used underneath.`);
+    }
+    if (analysis.usesCustomInstance) {
+        lines.push(`The source creates a custom axios instance (axios.create()). ${mockApi}.mock('axios') alone WILL NOT intercept calls made through a custom instance.`, `Instead: mock the module that exports the axios instance, or mock the API service module that wraps it.`);
+    }
+    else if (analysis.usesAxios && analysis.apiModuleImports.length === 0) {
+        lines.push(`The source imports axios directly. Mock it with: ${mockApi}.mock('axios') and set return values with axios.get.mockResolvedValue({ data: ... })`);
+    }
+    if (analysis.usesFetch) {
+        lines.push(`The source uses fetch. Mock it with: ${mockApi}.spyOn(global, 'fetch').mockResolvedValue(new Response(JSON.stringify(data)))`);
+    }
+    lines.push(`If you see a real URL (e.g. https://...) or a 401/403/network error in the test output, your mock is missing or at the wrong module level. Fix it before the test can pass.`);
+    return lines.join('\n');
+}
+function parseMockInventory(code) {
+    const entries = [];
+    const lines = code.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const mockMatch = lines[i].match(/\b(?:vi|jest)\.mock\(\s*(['"])([^'"]+)\1/);
+        if (!mockMatch)
+            continue;
+        const modulePath = mockMatch[2];
+        const lineNumber = i + 1;
+        const exports = [];
+        let braceDepth = 0;
+        let inFactory = false;
+        for (let j = i; j < Math.min(i + 80, lines.length); j++) {
+            const l = lines[j];
+            if (!inFactory && /\(\)\s*=>\s*\(?\s*\{/.test(l))
+                inFactory = true;
+            if (!inFactory)
+                continue;
+            for (const ch of l) {
+                if (ch === '{')
+                    braceDepth++;
+                if (ch === '}')
+                    braceDepth--;
+            }
+            const multiLine = l.match(/^\s{2,}(\w+)\s*:\s*(\w+)/);
+            if (multiLine && multiLine[1] !== 'type') {
+                const key = multiLine[1], val = multiLine[2];
+                exports.push(val && val !== key ? `${key}(${val})` : key);
+            }
+            if (j === i || l.includes('() =>') || l.includes('() => {')) {
+                for (const m of l.matchAll(/\b(\w+)\s*:\s*(mock\w+)/gi)) {
+                    const key = m[1], val = m[2];
+                    const entry = val.toLowerCase() !== `mock${key.toLowerCase()}` ? `${key}(${val})` : key;
+                    if (!exports.some(e => e === key || e.startsWith(`${key}(`)))
+                        exports.push(entry);
+                }
+            }
+            if (braceDepth <= 0 && inFactory)
+                break;
+        }
+        entries.push({ modulePath, lineNumber, exports });
+    }
+    return entries;
+}
+function parseMockExports(code) {
+    const names = [];
+    for (const m of code.matchAll(/^export\s+(?:const|let|var|function|class|async\s+function)\s+(\w+)/gm)) {
+        names.push(m[1]);
+    }
+    for (const m of code.matchAll(/^export\s*\{([^}]+)\}/gm)) {
+        for (const part of m[1].split(',')) {
+            const alias = part.trim().split(/\s+as\s+/).pop()?.trim();
+            if (alias && /^\w+$/.test(alias))
+                names.push(alias);
+        }
+    }
+    const defM = code.match(/^export\s+default\s+(\w+)/m);
+    if (defM)
+        names.push(`default (${defM[1]})`);
+    return [...new Set(names)];
+}
+// ─── Error detectors ──────────────────────────────────────────────────────────
 function detectTypeScriptErrors(errorOutput) {
     if (!/error TS\d+:/.test(errorOutput))
         return null;
@@ -117,12 +116,9 @@ function detectTypeScriptErrors(errorOutput) {
         'The TypeScript compiler tells you precisely what is wrong and usually what the fix is.',
         'Do NOT override it with framework conventions or assumptions.',
     ];
-    // TS1378: top-level await — only specific branch because the fix is structural
     if (/TS1378/.test(errorOutput)) {
         parts.push('• Top-level await (TS1378): move ALL await calls inside it()/test()/beforeEach()/etc.', '  WRONG: const result = await fn();', '  RIGHT: it("desc", async () => { const result = await fn(); });');
     }
-    // Wrong member name — extract the actual member list TypeScript printed inline.
-    // Covers TS2339, TS2551, TS2561 and any variant with "does not exist on/in type '{...}'"
     const propErrors = [...errorOutput.matchAll(/'(\w+)' does not exist (?:on|in) type '\{([^']+)\}'/g)];
     if (propErrors.length > 0) {
         parts.push('• Wrong member name — the actual available members are:');
@@ -137,12 +133,10 @@ function detectTypeScriptErrors(errorOutput) {
             parts.push(`  '${wrongProp}' → not valid. Use one of: ${available.slice(0, 12).join(', ')}${available.length > 12 ? ' …' : ''}`);
         }
     }
-    // Compiler suggestions — TypeScript already provides the answer
     const suggestions = [...new Set([...errorOutput.matchAll(/Did you mean(?: to write)? '(\w+)'\?/g)].map(m => m[1]))];
     if (suggestions.length > 0) {
         parts.push(`• Compiler suggestion: use ${suggestions.map(s => `'${s}'`).join(', ')}`);
     }
-    // Type mismatch — extract what was passed vs what was required
     const typeMismatches = [...errorOutput.matchAll(/Argument of type '([^']+)' is not assignable to parameter of type '([^']+)'/g)];
     if (typeMismatches.length > 0) {
         for (const m of typeMismatches) {
@@ -150,8 +144,6 @@ function detectTypeScriptErrors(errorOutput) {
         }
         parts.push('  (use null not undefined for nullable values; check TYPE DEFINITIONS for the required shape)');
     }
-    // Generic pass-through for all other TS errors — list them so the model reads each one
-    // rather than guessing. No special handling needed: the message IS the instruction.
     const otherErrors = [...errorOutput.matchAll(/error (TS(?!1378|2339|2551|2561|2345)\d+): ([^\n]+)/g)];
     if (otherErrors.length > 0) {
         parts.push('• Additional compiler errors — read each one and apply the exact fix it describes:');
@@ -166,19 +158,14 @@ function detectTypeScriptErrors(errorOutput) {
     }
     return parts.join('\n');
 }
-// Detects thinking-bleed parse errors: model wrote reasoning inside <code_output>
-// causing the file to start with prose instead of TypeScript.
 function detectThinkingBleed(errorOutput) {
-    // Vitest/esbuild parse errors at line 1 with non-code content are a strong signal
     const parseErr = errorOutput.match(/PARSE_ERROR|Unexpected token|SyntaxError.*\b1:\d+\b/);
     if (!parseErr)
         return null;
-    // Check if the error context shows non-TypeScript at the file start
     const contextLine = errorOutput.match(/^\s*1\s*[│|]\s*(.+)/m);
     if (!contextLine)
         return null;
     const firstLine = contextLine[1].trim();
-    // If first line looks like prose (no import/export/const/vi./etc.)
     if (/^(import|export|const|let|var|\/\/|\/\*|describe|it\s*\(|test\s*\(|vi\.|jest\.)/.test(firstLine))
         return null;
     return [
@@ -189,43 +176,6 @@ function detectThinkingBleed(errorOutput) {
         `Do NOT continue thinking inside <code_output> under any circumstances.`,
     ].join('\n');
 }
-// Scans error output for Next.js import resolution failures (Failed to resolve import).
-function detectNextJsImportError(errorOutput) {
-    const failedImport = errorOutput.match(/Failed to resolve import "([^"]+)"/);
-    if (!failedImport)
-        return null;
-    const importPath = failedImport[1];
-    const isServerOnly = importPath === 'server-only';
-    const isAlias = importPath.startsWith('@/');
-    const isClient = importPath.endsWith('.client');
-    const isServer = importPath.endsWith('.server');
-    const isNextInternal = importPath.startsWith('next/');
-    const isProviderOrSession = /session|auth|provider/i.test(importPath);
-    if (!isServerOnly && !isAlias && !isClient && !isServer && !isNextInternal && !isProviderOrSession)
-        return null;
-    const lines = [
-        `IMPORT RESOLUTION ERROR — Vitest cannot resolve "${importPath}".`,
-    ];
-    if (isServerOnly) {
-        lines.push(`"server-only" is a Next.js build guard — it throws intentionally when server code is loaded in a non-server context.`, `This is a CONFIGURATION issue, not something fixable in the test file. Two options:`, `  OPTION A (preferred): Add an alias in vitest.config.ts that maps "server-only" to an empty module:`, `    alias: { 'server-only': path.resolve(__dirname, './test/empty-module.ts') }`, `    and create test/empty-module.ts containing: export default {}`, `  OPTION B: Mock the entire module that imports server-only (the hook or service) so Vitest never resolves its dependency tree.`, `Do NOT try to mock "server-only" directly in the test file — vi.mock('server-only') is too late; the import is resolved before mocks run.`);
-    }
-    else if (isAlias) {
-        lines.push(`The "@/" alias is not configured in vitest.config.ts — you cannot fix this by changing the test file.`, `WORKAROUND: use the pre-computed relative paths from LOCAL IMPORT PATHS in your vi.mock() calls instead of "@/" paths.`, `  WRONG:   vi.mock('@/components/ui/button', ...)`, `  CORRECT: vi.mock('../../../components/ui/button', ...)  ← use the relative path from LOCAL IMPORT PATHS`, `Do NOT attempt to add resolve aliases inside the test file — that does not work.`, `Do NOT switch import statements to relative paths — only vi.mock() calls need to change.`);
-    }
-    else if (isClient || isServer) {
-        lines.push(`This is a Next.js ${isClient ? 'client' : 'server'} boundary file. Vitest never resolves these.`, `If the source file IMPORTS this module directly, mock it with the exact import path:`, `  vi.mock('${importPath}', () => ({ myFn: vi.fn() }))`, ``, `If the failing source is a HOOK that internally imports *.client services (which chain into many other server-only modules),`, `use the complete self-replacement strategy — mock the entire hook, not its sub-dependencies:`, `  const mockState = vi.hoisted(() => ({ data: [], loading: false, error: null }))`, `  vi.mock('../useMyHook', () => ({`, `    useMyHook: () => mockState,`, `  }))`, `This bypasses the entire dependency tree and tests the component contract, not the hook internals.`);
-    }
-    else if (isNextInternal) {
-        lines.push(`${importPath} is a Next.js internal that does not work in Vitest. Mock it:`, `  vi.mock('${importPath}', () => ({ /* relevant exports as vi.fn() */ }))`);
-    }
-    else if (isProviderOrSession) {
-        lines.push(`This looks like a session or auth provider that Vitest cannot resolve. Mock it:`, `  vi.mock('${importPath}', () => ({`, `    useSession: vi.fn(() => ({ user: { id: 'user-1', email: 'test@example.com' }, status: 'authenticated' })),`, `  }))`);
-    }
-    return lines.join('\n');
-}
-// Scans error output for an unhandled rejection caused by mockRejectedValueOnce.
-// Vitest surfaces this as a top-level "Unhandled Rejection" or "Vitest caught N unhandled error(s)"
-// even when the component catches the error internally — the test never awaited the error state.
 function detectUnhandledRejection(errorOutput) {
     const hasUnhandled = /unhandled\s+(promise\s+)?rejection|vitest caught \d+ unhandled/i.test(errorOutput);
     const hasRejectedMock = /mockRejectedValue(Once)?/.test(errorOutput);
@@ -239,8 +189,7 @@ function detectUnhandledRejection(errorOutput) {
         'This chains the rejection inside the test scope. Without it, Vitest flags it as unhandled even if the UI handles it correctly.',
     ].join('\n');
 }
-// Scans error output for signs that a real HTTP request leaked through.
-function detectRealRequestInError(errorOutput) {
+function detectRealRequestInError(errorOutput, mockApi = 'vi') {
     const hasRealUrl = /https?:\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/.test(errorOutput);
     const hasHttpStatus = /\bstatus:\s*[45]\d\d\b/.test(errorOutput);
     const hasNetworkError = /ECONNREFUSED|ENOTFOUND|ETIMEDOUT|network\s+error/i.test(errorOutput);
@@ -253,118 +202,30 @@ function detectRealRequestInError(errorOutput) {
     const urlMatch = errorOutput.match(/https?:\/\/[^\s,'")\]}]+/);
     if (urlMatch)
         lines.push(`Intercepted URL: ${urlMatch[0]}`);
-    lines.push('Required fix: find which module the source file imports for its API calls and mock THAT module.', "vi.mock('axios') does NOT intercept axios.create() instances — you must mock the module that exports the instance or the service layer above it.");
+    lines.push('Required fix: find which module the source file imports for its API calls and mock THAT module.', `${mockApi}.mock('axios') does NOT intercept axios.create() instances — you must mock the module that exports the instance or the service layer above it.`);
     return lines.join('\n');
 }
-function buildNetworkMockingGuidance(analysis, sourceFile) {
-    if (!analysis.usesAxios && !analysis.usesFetch && analysis.apiModuleImports.length === 0) {
-        return null;
-    }
-    const lines = [
-        'NETWORK MOCKING (critical — a real HTTP request reaching the network is a test bug):',
-    ];
-    if (analysis.apiModuleImports.length > 0) {
-        lines.push(`The source file imports from API/service modules: ${analysis.apiModuleImports.join(', ')}`, `Mock THOSE modules, not the underlying HTTP client:`, `  vi.mock('${analysis.apiModuleImports[0]}', () => ({ myFn: vi.fn() }))`, `This is the most reliable approach — it intercepts at the contract boundary regardless of which HTTP client is used underneath.`);
-    }
-    if (analysis.usesCustomInstance) {
-        lines.push(`The source creates a custom axios instance (axios.create()). vi.mock('axios') alone WILL NOT intercept calls made through a custom instance.`, `Instead: mock the module that exports the axios instance, or mock the API service module that wraps it.`);
-    }
-    else if (analysis.usesAxios && analysis.apiModuleImports.length === 0) {
-        lines.push(`The source imports axios directly. Mock it with: vi.mock('axios') and set return values with axios.get.mockResolvedValue({ data: ... })`);
-    }
-    if (analysis.usesFetch) {
-        lines.push(`The source uses fetch. Mock it with: vi.spyOn(global, 'fetch').mockResolvedValue(new Response(JSON.stringify(data)))`);
-    }
-    lines.push(`If you see a real URL (e.g. https://...) or a 401/403/network error in the test output, your mock is missing or at the wrong module level. Fix it before the test can pass.`);
-    return lines.join('\n');
-}
-function parseMockInventory(code) {
-    const entries = [];
-    const lines = code.split('\n');
-    for (let i = 0; i < lines.length; i++) {
-        const mockMatch = lines[i].match(/\bvi\.mock\(\s*(['"])([^'"]+)\1/);
-        if (!mockMatch)
-            continue;
-        const modulePath = mockMatch[2];
-        const lineNumber = i + 1;
-        const exports = [];
-        // Scan forward up to 80 lines to find the factory () => ({ ... })
-        // and extract the top-level key names from the object literal.
-        let braceDepth = 0;
-        let inFactory = false;
-        for (let j = i; j < Math.min(i + 80, lines.length); j++) {
-            const l = lines[j];
-            if (!inFactory && /\(\)\s*=>\s*\(?\s*\{/.test(l))
-                inFactory = true;
-            if (!inFactory)
-                continue;
-            for (const ch of l) {
-                if (ch === '{')
-                    braceDepth++;
-                if (ch === '}')
-                    braceDepth--;
-            }
-            // Top-level keys: indented 2+ spaces (multi-line). Capture both key and variable value
-            // so the inventory shows key(Variable) — e.g. ValidationError(MockValidationError).
-            // This lets the AI look up exactly which export to import for a given mocked symbol.
-            const multiLine = l.match(/^\s{2,}(\w+)\s*:\s*(\w+)/);
-            if (multiLine && multiLine[1] !== 'type') {
-                const key = multiLine[1], val = multiLine[2];
-                exports.push(val && val !== key ? `${key}(${val})` : key);
-            }
-            // Inline single-line factory: vi.mock('x', () => ({ key: mockVar, ... }))
-            if (j === i || l.includes('() =>')) {
-                for (const m of l.matchAll(/\b(\w+)\s*:\s*(mock\w+)/gi)) {
-                    const key = m[1], val = m[2];
-                    const entry = val.toLowerCase() !== `mock${key.toLowerCase()}` ? `${key}(${val})` : key;
-                    if (!exports.some(e => e === key || e.startsWith(`${key}(`)))
-                        exports.push(entry);
-                }
-            }
-            if (braceDepth <= 0 && inFactory)
-                break;
-        }
-        entries.push({ modulePath, lineNumber, exports });
-    }
-    return entries;
-}
-// Extract exported names from a mocks file so the AI sees a concrete inventory.
-function parseMockExports(code) {
-    const names = [];
-    // export const/let/var/function/class/async function name
-    for (const m of code.matchAll(/^export\s+(?:const|let|var|function|class|async\s+function)\s+(\w+)/gm)) {
-        names.push(m[1]);
-    }
-    // export { name1, name2 as alias2, ... }
-    for (const m of code.matchAll(/^export\s*\{([^}]+)\}/gm)) {
-        for (const part of m[1].split(',')) {
-            const alias = part.trim().split(/\s+as\s+/).pop()?.trim();
-            if (alias && /^\w+$/.test(alias))
-                names.push(alias);
-        }
-    }
-    // export default identifier
-    const defM = code.match(/^export\s+default\s+(\w+)/m);
-    if (defM)
-        names.push(`default (${defM[1]})`);
-    return [...new Set(names)];
-}
+// ─── System prompt ────────────────────────────────────────────────────────────
 export function buildSystemPrompt(env) {
     const isJS = env.language === 'typescript' || env.language === 'javascript' || env.language === 'unknown';
     const isTS = env.language === 'typescript';
     const isVitest = env.testRunner === 'vitest';
     const isJSRunner = env.testRunner === 'jest' || env.testRunner === 'vitest' || env.testRunner === 'mocha';
-    // ── Thinking template ────────────────────────────────────────────────────────
+    const mockApi = isVitest ? 'vi' : 'jest';
     const mockAuditStep = isJS ? `
     2. MOCK AUDIT — do this before writing a single line of test code:
-       a) IMPORT INVENTORY: List every import in the source file. For each client/service/hook, find every method it calls (grep for Client.method() patterns). Mock exactly those methods — nothing more, nothing less. Mocking a method the source never calls is useless; missing a method the source DOES call is a silent failure.
-       b) RESPONSE ENVELOPE: At each Client.method() call site, check how the return value is consumed. If the source guards with \`if (res.success)\` or destructures \`{ success, data }\`, the mock MUST return that envelope — NOT a raw array. \`mockResolvedValue([...])\` when the hook expects \`{ success: true, data: [...] }\` produces silently empty state with no error. Pattern: \`const ok = (data: unknown) => ({ success: true, data })\`.
-       c) RETURN FIELD ENUMERATION: Find the hook's \`return { ... }\` statement. List every key. Only write assertions for fields that actually appear there. A field not in the return statement is always undefined — asserting it produces a vacuous test that passes and fails for the wrong reasons.
-       d) LOADING TRIGGER MAP: Not all data loads on mount. For each piece of state, find what populates it. If a function like loadResults(classId) must be called explicitly (user selects something), the mount test will never see that data. Map: state → function that populates it → when that function is triggered.
-       e) FIXTURE FIELD NAMES: Read the source's selector logic — every .find(), .filter(), and property access. Field names in fixture data must match what the source reads, not what sounds reasonable. \`is_active\` and \`is_current\` are both plausible; only one will pass the filter. Read the source.
-       f) MOCK STRUCTURE — object vs factory: when the source imports a client/service as a module export and calls it as \`SomeClient.method()\`, the mock must be a plain object \`{ SomeClient: { method: vi.fn() } }\`. If you mock it as \`vi.fn().mockReturnValue({ method: vi.fn() })\`, SomeClient.method is undefined at runtime — the mock replaced a singleton with a callable that the source never calls. The mock structure must match how the source uses the import, not how you'd design an API.
-       g) DATA TRANSFORMATIONS: Before writing any assertion about the shape of loaded data, read every .map(), .filter(), and mutation the hook applies to the raw API response. If the hook does \`.map(s => ({ ...s, selected: true, status: 'promoted' }))\`, the fixture assertion must expect the TRANSFORMED shape, not the raw API fixture. Keep two separate fixtures: the raw API response (for mockResolvedValue) and the expected hook output (for assertions).
-       h) USEEFFECT COMPOUND SIDE EFFECTS: For each useEffect, read its dependency array AND every state setter it calls. Some effects reset sibling state as a side effect (e.g. fetchSourceClasses always calls setSelectedSourceClassId('')). Setting state that triggers such an effect will silently undo other state you set in the same act(). Map the full chain: which state changes trigger which effects, and what those effects do to other state — before writing any test that sets multiple state values.
+       a) SOURCE ANCHOR — AI models pattern-match function names to common implementations. A route named "inviteTeamMember" triggers priors about Firestore, teamId parameters, and standard error messages that may be completely wrong for this specific codebase. Override every prior by quoting verbatim from the actual source file before you write anything:
+          • Backend routes/functions: (1) list every req.body/req.params/req.query field the source ACTUALLY reads — not what the function name implies; (2) quote the exact database or service call pattern used (e.g. adminDb.ref(path) vs adminDb.collection().doc()); (3) copy every error message string verbatim from each res.json({error:...}) or throw statement in the source; (4) note every HTTP status code and the exact guard condition (if block) that produces it.
+          • Components/screens: (1) quote every string literal rendered in JSX/template — not what you assume is shown; (2) list the exact method name on each service/hook call as it appears in the source (e.g. UserService.inviteMember not UserService.invite); (3) note every conditional render guard (ternary, &&) and the exact state variable driving it.
+          If ANYTHING you quote differs from what you expected — the source wins. Write tests for what the code ACTUALLY does, not what a similarly-named function typically does.
+       b) IMPORT INVENTORY: List every import in the source file. For each client/service/hook, find every method it calls (grep for Client.method() patterns). Mock exactly those methods — nothing more, nothing less. Mocking a method the source never calls is useless; missing a method the source DOES call is a silent failure.
+       c) RESPONSE ENVELOPE: At each Client.method() call site, check how the return value is consumed. If the source guards with \`if (res.success)\` or destructures \`{ success, data }\`, the mock MUST return that envelope — NOT a raw array. \`mockResolvedValue([...])\` when the hook expects \`{ success: true, data: [...] }\` produces silently empty state with no error. Pattern: \`const ok = (data: unknown) => ({ success: true, data })\`.
+       d) RETURN FIELD ENUMERATION: Check the DEPENDENCY FILE CONTENTS section for each hook's implementation and read its \`return { ... }\` statement. List every key the hook actually returns — not just what the component destructures. A hook may return more keys than the component currently uses, and missing keys in mocks are silently undefined and can break conditional renders, validation, or dynamic text. If the section is absent, fall back to the component's destructure as a minimum baseline.
+       e) LOADING TRIGGER MAP: Not all data loads on mount. For each piece of state, find what populates it. If a function like loadResults(classId) must be called explicitly (user selects something), the mount test will never see that data. Map: state → function that populates it → when that function is triggered.
+       f) FIXTURE FIELD NAMES: Read the source's selector logic — every .find(), .filter(), and property access. Field names in fixture data must match what the source reads, not what sounds reasonable. \`is_active\` and \`is_current\` are both plausible; only one will pass the filter. Read the source.
+       g) MOCK STRUCTURE — object vs factory: when the source imports a client/service as a module export and calls it as \`SomeClient.method()\`, the mock must be a plain object \`{ SomeClient: { method: ${mockApi}.fn() } }\`. If you mock it as \`${mockApi}.fn().mockReturnValue({ method: ${mockApi}.fn() })\`, SomeClient.method is undefined at runtime — the mock replaced a singleton with a callable that the source never calls. The mock structure must match how the source uses the import, not how you'd design an API.
+       h) DATA TRANSFORMATIONS: Before writing any assertion about the shape of loaded data, read every .map(), .filter(), and mutation the hook applies to the raw API response. If the hook does \`.map(s => ({ ...s, selected: true, status: 'promoted' }))\`, the fixture assertion must expect the TRANSFORMED shape, not the raw API fixture. Keep two separate fixtures: the raw API response (for mockResolvedValue) and the expected hook output (for assertions).
+       i) USEEFFECT COMPOUND SIDE EFFECTS: For each useEffect, read its dependency array AND every state setter it calls. Some effects reset sibling state as a side effect (e.g. fetchSourceClasses always calls setSelectedSourceClassId('')). Setting state that triggers such an effect will silently undo other state you set in the same act(). Map the full chain: which state changes trigger which effects, and what those effects do to other state — before writing any test that sets multiple state values.
        HOOK STATE SYNC: If the test mocks a hook or function that returns an object (e.g. useClasses(), useUsers()), compare its CURRENT return signature in the source against the mocked return object in the test. If any properties are missing, renamed, or stale, realign the mock FIRST — before touching any assertions.
        UNCONDITIONAL CRASH CHECK: Look at the very top of the component body — what fields are destructured and used BEFORE any conditional render (e.g. totalRevenue.toLocaleString(), sessions.length)? Every one of those fields MUST be present in the mock return value or ALL tests will crash immediately.
        MOCK PROP INTERFACE: When mocking a child component (e.g. EmptyState, Modal), check how the PARENT calls it — what prop names does the JSX pass? Use those exact names in the mock, not the names from the child's own prop type definition.
@@ -378,39 +239,31 @@ export function buildSystemPrompt(env) {
     1. WHAT IS NEEDED: What functions/behaviors are untested or broken?${mockAuditStep}
     4. WHY IT FAILED (retries only): Errors cascade — a compile error hides a resolution error which hides a wiring error which hides a logic error. Fix the first layer and expect a new error to surface. What layer are we on now?
     5. PLAN: List the exact steps you will take before writing a single line of code.`;
-    // ── JS/TS-specific rules ─────────────────────────────────────────────────────
     const jsRules = isJS ? `
 3. Use path aliases from the PROJECT TYPESCRIPT CONFIG section in IMPORT statements (e.g. "@/components/Button" not "../../components/Button").
    EXCEPTION — mock call paths: use the exact same path string that appears in the SOURCE FILE'S import statement.
    If a LOCAL IMPORT PATHS section is provided, use those pre-computed relative paths in mock calls — they are the fallback when aliases cannot be resolved by the test runner.
    Never second-guess the pre-computed paths. Never convert them back to @/ aliases in mock calls.
 4. Only import from packages listed in PROJECT DEPENDENCIES. Do not invent packages that are not listed.
-5. When a SHARED MOCK FILE is provided, its exported names are listed under "Available exports". Before writing the test, go through that list and identify every mock that relates to what the source file does. Import and use ALL of those mocks. Never re-create inline vi.fn() / jest.fn() for anything already exported from the mocks file.
+5. When a SHARED MOCK FILE is provided, its exported names are listed under "Available exports". Before writing the test, go through that list and identify every mock that relates to what the source file does. Import and use ALL of those mocks. Never re-create inline ${mockApi}.fn() for anything already exported from the mocks file.
    CRITICAL — never rename or change the casing of existing mock exports.
 6. If you need a mock that is missing from the shared mock file, add it to that file AND import it in the test. Return BOTH files separated by exactly one line containing only: // ---MOCKS_FILE---
+   CRITICAL — if you have NO new mocks to add, OMIT the // ---MOCKS_FILE--- separator entirely. Do NOT write a comment-only or placeholder mock file (e.g. "// No mocks needed"). Either add real code or omit the separator.
+   CRITICAL — when writing the mocks file, you receive the FULL EXISTING content. You MUST write the complete merged result. Never add a second import statement for a module that is already imported — merge all named imports from the same module into one statement. WRONG: line 2 has \`import { View } from 'react-native'\` and you add line 28 \`import { View, Text } from 'react-native'\`. RIGHT: update line 2 to \`import { View, Text } from 'react-native'\` and omit the duplicate.
 7. If a SHARED MOCK FILE (does not exist yet) section is shown — create it for any mocks you need and return it using the // ---MOCKS_FILE--- separator.
-   CRITICAL — the mocks file must contain ONLY: vi.fn()/jest.fn() mock definitions, vi.mock() module stubs, shared mock objects/constants, and beforeEach reset hooks. NEVER write describe(), it(), test(), or expect() calls in the mocks file.
+   CRITICAL — the mocks file must contain ONLY: ${mockApi}.fn() mock definitions, ${mockApi}.mock() module stubs, shared mock objects/constants, and beforeEach reset hooks. NEVER write describe(), it(), test(), or expect() calls in the mocks file.
 8. If a TEST SETUP FILE is shown, assume its globals and matchers are already available. Do NOT import or re-declare them.` : `
 3. Use the project's import conventions as shown in the source file and existing tests.
 4. Only import from packages listed in PROJECT DEPENDENCIES. Do not invent packages that are not listed.`;
-    const tsRule = isTS ? `
-9. TypeScript type safety: all test code must compile without type errors. The TypeScript compiler is the authority — its error messages are exact instructions, not hints.
-   - Use EXACT property/member names from the TYPE DEFINITIONS section and source code. Do not apply naming conventions: if a hook returns { loading, users }, do NOT write isLoading or isUsers.
-   - Import enums, constants, interfaces, and types from the project's existing files. Do NOT redeclare them inline or invent lookalike values.
-   - Never use "as any", "@ts-ignore", or "@ts-expect-error" to suppress type errors.
-   - For vi.fn() / jest.fn(), either let TypeScript infer the type from context or type it explicitly: vi.fn<Parameters<typeof fn>, ReturnType<typeof fn>>().
-   - Use ReturnType<>, Parameters<>, and other utility types to derive mock types from real function signatures.
-   - When accessing optional properties, handle null/undefined correctly.` : '';
+    const tsRule = isTS ? buildTsRule(mockApi) : '';
     const ruleCount = isTS ? 10 : (isJS ? 9 : 6);
-    // ── JS/Vitest-specific output format rules ───────────────────────────────────
     const jsOutputRules = isJS ? `
 ${ruleCount + 2}. Inside <code_output>: output ONLY the test file content (or test file // ---MOCKS_FILE--- mocks file).
     If you use // ---MOCKS_FILE---, everything AFTER the separator is the mocks file. The mocks file must contain ONLY:
-    vi.fn()/jest.fn() mock definitions, vi.mock() module stubs, shared constants, and beforeEach resets.
+    ${mockApi}.fn() mock definitions, ${mockApi}.mock() module stubs, shared constants, and beforeEach resets.
     NEVER put describe(), it(), test(), or expect() calls after the separator.
 ${ruleCount + 3}. NEVER output vitest.config.ts, jest.config.js, or any framework configuration. If an import cannot be resolved,
-    fix it by mocking it with vi.mock() — NOT by modifying the test runner configuration.` : '';
-    // ── Common failure causes — universal ────────────────────────────────────────
+    fix it by mocking it with ${mockApi}.mock() — NOT by modifying the test runner configuration.` : '';
     const universalCauses = `- Wrong import paths (use the project's conventions — aliases where configured, relative paths otherwise)
 - Importing from test utilities that are not in the dependency list
 - Mocking modules that are already mocked in the setup file
@@ -418,40 +271,9 @@ ${ruleCount + 3}. NEVER output vitest.config.ts, jest.config.js, or any framewor
 - Real HTTP requests: NEVER let a real network call reach the internet. Every function that calls an API must be mocked before the test runs.
 - Error surface mismatch: before writing any error-path test, find the catch block. Does it set state, call a notification, or just log silently? Test only what is actually observable from outside.
 - Code drift — assert what the code ACTUALLY does: before writing any assertion, re-read the relevant section of the source. If it catches an error and returns null, assert null — not a rejection.`;
-    // ── Common failure causes — JS/Jest/Vitest only ───────────────────────────────
-    const jsCauses = isJSRunner ? `
-- vi.mock() / jest.mock() paths are relative to the TEST FILE, not the source file. Count directories from the test file's location, not the source file's.
-- Missing mock is the silent killer: if expect(mockFn).toHaveBeenCalled() fails but the code path is clearly reached, the mock declaration is missing or uses the wrong path. The real implementation ran instead.
-- Response envelope mismatch (silent empty state): if a hook guards \`if (res.success)\` or destructures \`{ success, data }\`, mocking with a raw array means .success is undefined and state is never populated — silently. Trace each call site individually — different clients in the same hook often have different shapes (one returns \`{ data: [] }\`, another \`{ success, data: { items: [] } }\` with nested access). Never assume a uniform envelope across the whole hook.
-- Barrel file mock miss: mocking a barrel/index file (vi.mock('../components')) will NOT intercept imports of the direct file ('../components/Foo'). Mock the specific module the source actually imports.` : '';
-    const vitestCauses = isVitest ? `
-- Never use require() in Vitest: Vitest runs files as ESM — dynamic require() fails at transform time. Always use static ES import + vi.mocked().
-- Shared mock file factory syntax: \`vi.mock('../service', async () => await import('../../test/mocks'))\` — synchronous factory cannot import external files in Vitest.
-- vi.hoisted() for shared mock references: when a mock object is created inside vi.mock() AND configured in beforeEach, use vi.hoisted() so both closures reference the same object instance.
-- Complete hook self-replacement for *.client-importing hooks: when a hook imports *.client services that chain into browser/server-only modules, mock the entire hook — \`vi.mock('../useMyHook', () => ({ useMyHook: vi.fn() }))\` — rather than each sub-dependency.
-- server-only resolution in Next.js: \`Failed to resolve import "server-only"\` is a config issue, not a test issue. Add an alias in vitest.config.ts: \`'server-only': path.resolve(__dirname, './test/empty-module.ts')\` and create that file with \`export default {}\`.
-- Top-level await (TS1378): NEVER use \`await\` at the top level of a test file. Every \`await\` must be inside an async callback: \`it("...", async () => { ... })\`.
-- NEVER call vi.spyOn(global, ...) or vi.spyOn(globalThis, ...) at module level (outside beforeEach/beforeAll). Each Vitest file has its own vi registry. A module-level spy is installed on the shared worker globalThis but setup-file afterEach cleanup (vi.restoreAllMocks) uses a different vi instance and cannot remove it — the spy persists after the file ends and poisons the next file that runs in the same worker. Always create global spies inside beforeEach so they are fresh per test and properly cleaned up:
-  WRONG: const mockFetch = vi.spyOn(global, 'fetch');  // module level — breaks other files
-  RIGHT: let mockFetch: ReturnType<typeof vi.spyOn>;
-         beforeEach(() => { mockFetch = vi.spyOn(global, 'fetch'); });
-- Never write two vi.mock() calls for the same module path in the same file. The second call silently overrides the first — exports from the first mock are lost. If a module exports many things (e.g. lucide-react icons), list them all in a single vi.mock() factory:
-  WRONG: vi.mock('lucide-react', () => ({ Search: () => null }))  ...later...  vi.mock('lucide-react', () => ({ Plus: () => null }))
-  RIGHT: vi.mock('lucide-react', () => ({ Search: () => null, Plus: () => null }))
-- vi.resetAllMocks() vs vi.clearAllMocks() — use the right one or tests break under shuffle:
-  clearAllMocks() only wipes call history (mock.calls, mock.results). It does NOT reset mockReturnValue / mockResolvedValue / mockImplementation.
-  resetAllMocks() wipes call history AND resets all implementations back to undefined.
-  RULE: if ANY test in the file calls mockFn.mockImplementation(...) directly (e.g. a loading-state test that uses \`() => new Promise(() => {})\` to freeze async), the beforeEach MUST use vi.resetAllMocks() — otherwise that implementation bleeds into the next test when run in shuffle order, and mockResolvedValue set in beforeEach is silently overridden by the stale mockImplementation.
-  PATTERN: loading-state test sets mockImplementation → test passes → shuffle puts it before the success-state test → success test's beforeEach calls clearAllMocks (history wiped, implementation NOT wiped) → mockResolvedValue set in beforeEach loses to the stale never-resolving implementation → success test gets 0 instead of expected data.` : '';
-    // ── Common failure causes — React/Vue (JS component tests) only ───────────────
-    const reactCauses = isJSRunner ? `
-- React 18 act() async rule: ALWAYS await act() when it wraps async code. Unawaited act() calls cause state to leak across tests, producing "Cannot read properties of null" failures in unrelated tests.
-- Loading state architecture: before asserting a button is disabled during loading, check whether the component unmounts it entirely. If unmounted, getByText("Submit") throws — test for the spinner instead.
-- Unhandled promise rejections: after triggering an action with mockRejectedValueOnce, always await the resulting state change with waitFor() so the rejection is resolved inside the test scope.
-- getByText / getByTestId ambiguity: generic strings and reused icon components often appear multiple times on a complex page. Use getAllByText(...)[0], getByRole, or within(container).getByText(...) to scope queries.
-- Functional state updater assertions: when a component calls setState with an updater function (e.g. setPage(p => p + 1)), toHaveBeenCalledWith(3) always fails. Capture the updater and call it: \`const fn = mockSetPage.mock.calls[0][0]; expect(fn(2)).toBe(3)\`.
-- React 18 act() warning in hook tests: wrap async mock resolutions in \`await act(async () => {})\` at the end of the test to flush pending state updates before the test exits.` : '';
-    // ── Good test suite checklist ────────────────────────────────────────────────
+    const jsCauses = isJSRunner ? buildJsCauses(mockApi) : '';
+    const vitestCauses = isVitest ? buildVitestCauses() : '';
+    const reactCauses = buildReactCauses(isJSRunner, mockApi);
     const hookSuiteNote = isJSRunner
         ? `\n- For hooks: cover mutations (save, update, delete) and derived/computed state — not just the initial-load lifecycle. Mutations and derived state are where real bugs hide.`
         : '';
@@ -486,9 +308,11 @@ Test file pattern for this project: ${env.testFilePattern}
 
 You MUST wrap your reasoning inside <thinking> tags and your complete file output inside <code_output> tags. Do not output anything outside of these two tags.`;
 }
+// ─── Generate prompt ──────────────────────────────────────────────────────────
 export function buildGeneratePrompt(args) {
-    const { sourceFile, existingTestCode, uncoveredFunctions, uncoveredLines, sourceImportPath, mocksCode, mocksImportPath, setupFileCode, packageDeps, tsconfigPaths, typeDefinitions, localImportPaths, reactMajorVersion, projectMemory, } = args;
+    const { sourceFile, env, existingTestCode, uncoveredFunctions, uncoveredLines, sourceImportPath, mocksCode, mocksImportPath, setupFileCode, packageDeps, tsconfigPaths, typeDefinitions, localImportPaths, localImportContents, reactMajorVersion, projectMemory, } = args;
     const sourceCode = compressSource(args.sourceCode);
+    const mockApi = env.testRunner === 'vitest' ? 'vi' : 'jest';
     const parts = [];
     if (projectMemory) {
         parts.push(projectMemory);
@@ -508,7 +332,7 @@ export function buildGeneratePrompt(args) {
         parts.push(tsconfigPaths);
     }
     if (localImportPaths && localImportPaths.length > 0) {
-        parts.push('\nLOCAL IMPORT PATHS (pre-computed relative to the test file — use EXACTLY these strings in vi.mock() calls, even if the source file uses @/ aliases. Vitest resolves vi.mock() paths relative to the test file, not via tsconfig aliases. Do NOT convert these back to @/ paths in vi.mock(). Do NOT recount directory levels yourself.):');
+        parts.push(`\nLOCAL IMPORT PATHS (pre-computed relative to the test file — use EXACTLY these strings in ${mockApi}.mock() calls, even if the source file uses @/ aliases. The test runner resolves ${mockApi}.mock() paths relative to the test file, not via tsconfig aliases. Do NOT convert these back to @/ paths in ${mockApi}.mock(). Do NOT recount directory levels yourself.):`);
         for (const p of localImportPaths)
             parts.push(`  ${p}`);
     }
@@ -518,10 +342,16 @@ export function buildGeneratePrompt(args) {
         parts.push(typeDefinitions);
         parts.push('```');
     }
+    if (localImportContents) {
+        parts.push('\nUSED SYMBOL DEFINITIONS (extracted from files the component imports — only the specific symbols used, with function bodies collapsed to signature + return and class bodies collapsed to method signatures. Use this to find exact hook return shapes, service method names, and type definitions. Cross-check every hook mock against the hook\'s actual return statement here):');
+        parts.push('```typescript');
+        parts.push(localImportContents);
+        parts.push('```');
+    }
     if (setupFileCode) {
         const nextMocked = extractGlobalNextMocks(setupFileCode);
         const setupNote = nextMocked.length > 0
-            ? `\nTEST SETUP FILE (already loaded before every test — do NOT import it again):\nThe following modules are ALREADY mocked globally in this setup file — do NOT add vi.mock() for them in the test: ${nextMocked.join(', ')}`
+            ? `\nTEST SETUP FILE (already loaded before every test — do NOT import it again):\nThe following modules are ALREADY mocked globally in this setup file — do NOT add ${mockApi}.mock() for them in the test: ${nextMocked.join(', ')}`
             : `\nTEST SETUP FILE (already loaded before every test — do NOT import it again):`;
         parts.push(setupNote);
         parts.push('```');
@@ -539,40 +369,32 @@ export function buildGeneratePrompt(args) {
             const inventory = parseMockInventory(mocksCode);
             if (inventory.length > 0) {
                 const maxLen = Math.max(...inventory.map(e => e.modulePath.length));
-                parts.push('\nMOCK MODULE INVENTORY — modules already vi.mocked:');
+                parts.push(`\nMOCK MODULE INVENTORY — modules already ${mockApi}.mocked:`);
                 for (const entry of inventory) {
                     const path = `'${entry.modulePath}'`.padEnd(maxLen + 2);
-                    const exp = entry.exports.length > 0
-                        ? entry.exports.join(', ')
-                        : '(no simple key exports)';
+                    const exp = entry.exports.length > 0 ? entry.exports.join(', ') : '(no simple key exports)';
                     parts.push(`  ${path} → ${exp}`);
                 }
                 parts.push('MOCK EDITING RULES — follow exactly when returning a ---MOCKS_FILE--- block:');
-                parts.push('• A module in the inventory is ALREADY mocked. To add a new export: write ONE updated vi.mock() block with ALL existing exports PLUS the new one. NEVER write a second vi.mock() for the same path — Vitest only honours the last one, so the second block silently wipes every export from the first.');
-                parts.push('• New export const mockFoo = vi.fn(): declare it near other exports of the same domain. Add its .mockReset() or .mockClear() to the EXISTING beforeEach — do NOT create an extra beforeEach for one variable.');
-                parts.push('• New module (not in inventory): append a new vi.mock() at the END of the file, before the final beforeEach.');
+                parts.push(`• A module in the inventory is ALREADY mocked. To add a new export: write ONE updated ${mockApi}.mock() block with ALL existing exports PLUS the new one. NEVER write a second ${mockApi}.mock() for the same path — the second block silently wipes every export from the first.`);
+                parts.push(`• New export const mockFoo = ${mockApi}.fn(): declare it near other exports of the same domain. Add its .mockReset() or .mockClear() to the EXISTING beforeEach — do NOT create an extra beforeEach for one variable.`);
+                parts.push(`• New module (not in inventory): append a new ${mockApi}.mock() at the END of the file, before the final beforeEach.`);
             }
-            // Generate prompt: send only the sections of the mock file relevant to this source file
-            // (vi.mock() blocks for modules it imports + export declarations for inferred mock names).
-            // Skips unrelated mocks entirely. Falls back to the full file if nothing matches.
             const relevantMocks = filterMockFileForSource(mocksCode, sourceCode);
             if (relevantMocks !== mocksCode || relevantMocks.split('\n').length < 80) {
-                // Filtered down or already small — worth sending
                 parts.push('```');
                 parts.push(relevantMocks);
                 parts.push('```');
             }
-            // If filter returned the full file unchanged AND it's large, skip it —
-            // the exports list + inventory above already cover what the AI needs.
         }
         else {
-            parts.push(`\nSHARED MOCK FILE (does not exist yet) — create it if you need mocks, return it via the // ---MOCKS_FILE--- separator. Path: '${mocksImportPath}'\n⚠ Mocks file must contain ONLY vi.fn()/vi.mock() definitions and beforeEach resets — NEVER describe/it/test/expect blocks.`);
+            parts.push(`\nSHARED MOCK FILE (does not exist yet) — create it if you need mocks, return it via the // ---MOCKS_FILE--- separator. Path: '${mocksImportPath}'\n⚠ Mocks file must contain ONLY ${mockApi}.fn()/${mockApi}.mock() definitions and beforeEach resets — NEVER describe/it/test/expect blocks.`);
         }
     }
-    const networkGuidance = buildNetworkMockingGuidance(analyzeNetworkDeps(sourceCode), sourceFile);
+    const networkGuidance = buildNetworkMockingGuidance(analyzeNetworkDeps(sourceCode), sourceFile, mockApi);
     if (networkGuidance)
         parts.push(`\n${networkGuidance}`);
-    const nextGuidance = buildNextJsGuidance(analyzeNextJs(sourceCode));
+    const nextGuidance = buildNextJsGuidance(analyzeNextJs(sourceCode), mockApi);
     if (nextGuidance)
         parts.push(`\n${nextGuidance}`);
     if (detectReactNative(packageDeps ?? null))
@@ -606,9 +428,11 @@ export function buildGeneratePrompt(args) {
     parts.push('\nWrite the complete test file now.');
     return parts.join('\n');
 }
+// ─── Fix prompt ───────────────────────────────────────────────────────────────
 export function buildFixPrompt(args) {
-    const { testFile, testCode, sourceFile, sourceImportPath, errorOutput, mocksCode, mocksImportPath, setupFileCode, packageDeps, tsconfigPaths, typeDefinitions, localImportPaths, reactMajorVersion, projectMemory } = args;
+    const { testFile, testCode, sourceFile, sourceImportPath, errorOutput, env, mocksCode, mocksImportPath, setupFileCode, packageDeps, tsconfigPaths, typeDefinitions, localImportPaths, reactMajorVersion, projectMemory } = args;
     const sourceCode = args.sourceCode ? compressSource(args.sourceCode) : null;
+    const mockApi = env.testRunner === 'vitest' ? 'vi' : 'jest';
     const parts = [];
     parts.push('Your job is to fix a failing test file. Do NOT rewrite it from scratch — preserve every existing test and only change what is necessary to make them pass.');
     parts.push('');
@@ -630,7 +454,7 @@ export function buildFixPrompt(args) {
         parts.push(tsconfigPaths);
     }
     if (localImportPaths && localImportPaths.length > 0) {
-        parts.push('\nLOCAL IMPORT PATHS (pre-computed relative to the test file — use EXACTLY these strings in vi.mock() calls, even if the source file uses @/ aliases. Vitest resolves vi.mock() paths relative to the test file, not via tsconfig aliases. Do NOT convert these back to @/ paths in vi.mock(). Do NOT recount directory levels yourself.):');
+        parts.push(`\nLOCAL IMPORT PATHS (pre-computed relative to the test file — use EXACTLY these strings in ${mockApi}.mock() calls, even if the source file uses @/ aliases. The test runner resolves ${mockApi}.mock() paths relative to the test file, not via tsconfig aliases. Do NOT convert these back to @/ paths in ${mockApi}.mock(). Do NOT recount directory levels yourself.):`);
         for (const p of localImportPaths)
             parts.push(`  ${p}`);
     }
@@ -649,39 +473,32 @@ export function buildFixPrompt(args) {
     if (mocksImportPath) {
         if (mocksCode) {
             const exports = parseMockExports(mocksCode);
-            // Filter to only the sections this failing test actually imports.
-            // A billing test importing 6 mocks gets ~40 lines instead of 820.
-            // The filter already does the heavy lifting — no compression needed on top.
-            // Line numbers in the inventory refer to lines in THIS filtered slice.
             const compressed = filterMockFileForTest(mocksCode, args.testCode);
             parts.push(`\nSHARED MOCK FILE (import from: '${mocksImportPath}')`);
             if (exports.length > 0) {
                 parts.push(`Available exports: ${exports.join(', ')}`);
                 parts.push(`↑ Every name above ALREADY EXISTS in the mock file — do NOT re-declare any of them in a ---MOCKS_FILE--- block. Only declare names that do NOT appear in this list.\n↑ Import every mock that matches the source file's domain. Do NOT create inline mocks for anything already in this list.`);
             }
-            // Parse inventory from the compressed file so line numbers match what the AI sees below
             const inventory = parseMockInventory(compressed);
             if (inventory.length > 0) {
                 const maxLen = Math.max(...inventory.map(e => e.modulePath.length));
-                parts.push('\nMOCK MODULE INVENTORY — modules already vi.mocked (line numbers refer to the file below):');
+                parts.push(`\nMOCK MODULE INVENTORY — modules already ${mockApi}.mocked (line numbers refer to the file below):`);
                 for (const entry of inventory) {
                     const path = `'${entry.modulePath}'`.padEnd(maxLen + 2);
-                    const exp = entry.exports.length > 0
-                        ? entry.exports.join(', ')
-                        : '(no simple key exports)';
+                    const exp = entry.exports.length > 0 ? entry.exports.join(', ') : '(no simple key exports)';
                     parts.push(`  Line ${String(entry.lineNumber).padStart(4)}: ${path} → ${exp}`);
                 }
                 parts.push('MOCK EDITING RULES — follow exactly when returning a ---MOCKS_FILE--- block:');
-                parts.push('• A module in the inventory is ALREADY mocked. To add a new export: write ONE updated vi.mock() block with ALL existing exports PLUS the new one. NEVER write a second vi.mock() for the same path — Vitest only honours the last one, so the second block silently wipes every export from the first.');
-                parts.push('• New export const mockFoo = vi.fn(): declare it near other exports of the same domain. Add its .mockReset() or .mockClear() to the EXISTING beforeEach — do NOT create an extra beforeEach for one variable.');
-                parts.push('• New module (not in inventory): append a new vi.mock() at the END of the file, before the final beforeEach.');
+                parts.push(`• A module in the inventory is ALREADY mocked. To add a new export: write ONE updated ${mockApi}.mock() block with ALL existing exports PLUS the new one. NEVER write a second ${mockApi}.mock() for the same path — the second block silently wipes every export from the first.`);
+                parts.push(`• New export const mockFoo = ${mockApi}.fn(): declare it near other exports of the same domain. Add its .mockReset() or .mockClear() to the EXISTING beforeEach — do NOT create an extra beforeEach for one variable.`);
+                parts.push(`• New module (not in inventory): append a new ${mockApi}.mock() at the END of the file, before the final beforeEach.`);
             }
             parts.push('```');
             parts.push(compressed);
             parts.push('```');
         }
         else {
-            parts.push(`\nSHARED MOCK FILE (does not exist yet) — create it if you need mocks, return it via the // ---MOCKS_FILE--- separator. Path: '${mocksImportPath}'\n⚠ Mocks file must contain ONLY vi.fn()/vi.mock() definitions and beforeEach resets — NEVER describe/it/test/expect blocks.`);
+            parts.push(`\nSHARED MOCK FILE (does not exist yet) — create it if you need mocks, return it via the // ---MOCKS_FILE--- separator. Path: '${mocksImportPath}'\n⚠ Mocks file must contain ONLY ${mockApi}.fn()/${mockApi}.mock() definitions and beforeEach resets — NEVER describe/it/test/expect blocks.`);
         }
     }
     if (detectReactNative(packageDeps ?? null))
@@ -689,14 +506,12 @@ export function buildFixPrompt(args) {
     else if (detectVue(packageDeps ?? null))
         parts.push(`\n${buildVueGuidance()}`);
     if (sourceFile && sourceCode) {
-        const networkGuidance = buildNetworkMockingGuidance(analyzeNetworkDeps(sourceCode), sourceFile);
+        const networkGuidance = buildNetworkMockingGuidance(analyzeNetworkDeps(sourceCode), sourceFile, mockApi);
         if (networkGuidance)
             parts.push(`\n${networkGuidance}`);
-        const nextGuidance = buildNextJsGuidance(analyzeNextJs(sourceCode));
+        const nextGuidance = buildNextJsGuidance(analyzeNextJs(sourceCode), mockApi);
         if (nextGuidance)
             parts.push(`\n${nextGuidance}`);
-        // For fix: show the full source so the AI can see exact return shapes, field names,
-        // and mock structure. Only skeleton truly enormous files to stay within token limits.
         const FIX_SKELETON_THRESHOLD = 600;
         const displaySource = sourceCode.split('\n').length > FIX_SKELETON_THRESHOLD
             ? buildSourceSkeleton(sourceCode, [])
@@ -718,13 +533,16 @@ export function buildFixPrompt(args) {
     parts.push('```');
     parts.push(errorOutput.slice(0, 3000));
     parts.push('```');
-    const realRequestWarning = detectRealRequestInError(errorOutput);
+    const realRequestWarning = detectRealRequestInError(errorOutput, mockApi);
     if (realRequestWarning)
         parts.push(`\n⚠️  ${realRequestWarning}`);
     const rejectionWarning = detectUnhandledRejection(errorOutput);
     if (rejectionWarning)
         parts.push(`\n⚠️  ${rejectionWarning}`);
-    const nextImportWarning = detectNextJsImportError(errorOutput);
+    const rntlWarning = detectRntlErrors(errorOutput);
+    if (rntlWarning)
+        parts.push(`\n⚠️  ${rntlWarning}`);
+    const nextImportWarning = detectNextJsImportError(errorOutput, mockApi);
     if (nextImportWarning)
         parts.push(`\n⚠️  ${nextImportWarning}`);
     const bleedWarning = detectThinkingBleed(errorOutput);
@@ -733,11 +551,10 @@ export function buildFixPrompt(args) {
     const tsErrorWarning = detectTypeScriptErrors(errorOutput);
     if (tsErrorWarning)
         parts.push(`\n⚠️  ${tsErrorWarning}`);
-    // Detect wrong mock pattern: test uses vi.mock('axios') but source uses axios.create()
     const testHasAxiosMock = /vi\.mock\(['"]axios['"]\)/.test(testCode);
     const sourceHasCustomInstance = sourceCode != null && /axios\.create\s*\(/.test(sourceCode);
     if (testHasAxiosMock && sourceHasCustomInstance) {
-        parts.push("\n⚠️  WRONG MOCK PATTERN: The test mocks 'axios' directly but the source file uses axios.create().", "vi.mock('axios') cannot intercept a custom axios instance.", 'You must mock the module that exports the axios instance, or mock the service/API module the source imports.');
+        parts.push("\n⚠️  WRONG MOCK PATTERN: The test mocks 'axios' directly but the source file uses axios.create().", `${mockApi}.mock('axios') cannot intercept a custom axios instance.`, 'You must mock the module that exports the axios instance, or mock the service/API module the source imports.');
     }
     parts.push('\nCommon causes to check:');
     parts.push('- Wrong import path (use path aliases, not deep relative paths)');
@@ -749,6 +566,7 @@ export function buildFixPrompt(args) {
     parts.push('\nReturn your response in the required <thinking> + <code_output> format.');
     return parts.join('\n');
 }
+// ─── Pollution fix prompt ─────────────────────────────────────────────────────
 export function buildPollutionFixPrompt(args) {
     const { pollutorFile, pollutorCode, victimFile, victimCode, victimError } = args;
     const parts = [];
@@ -820,6 +638,9 @@ export function buildRetryPrompt(failureOutput, failedAttempts = []) {
     const rejectionWarning = detectUnhandledRejection(failureOutput);
     if (rejectionWarning)
         parts.push(`\n⚠️  ${rejectionWarning}`);
+    const rntlRetryWarning = detectRntlErrors(failureOutput);
+    if (rntlRetryWarning)
+        parts.push(`\n⚠️  ${rntlRetryWarning}`);
     const nextImportWarning = detectNextJsImportError(failureOutput);
     if (nextImportWarning)
         parts.push(`\n⚠️  ${nextImportWarning}`);
@@ -833,8 +654,8 @@ export function buildRetryPrompt(failureOutput, failedAttempts = []) {
     parts.push('Common causes:');
     parts.push('- Wrong import path — check the path aliases and dependency list from the original prompt');
     parts.push('- Missing mock — if a module needs mocking, add it to the shared mock file');
-    parts.push('- Wrong vi.mock() path: mock paths are relative to the TEST FILE, not the source file. Count up from the test file\'s directory to reach the mocked module — if the test is in src/features/x/__tests__/ and mocks src/components/, that is ../../../components/, not ../components/.');
-    parts.push('- Barrel file mock miss: if a module is re-exported from a barrel/index file, mocking the barrel (vi.mock(\'../components\')) will NOT intercept imports of the direct file (\'../components/Foo\'). Mock the specific file the source actually imports. If unsure, mock both.');
+    parts.push('- Wrong mock path: mock paths are relative to the TEST FILE, not the source file. Count up from the test file\'s directory to reach the mocked module — if the test is in src/features/x/__tests__/ and mocks src/components/, that is ../../../components/, not ../components/.');
+    parts.push('- Barrel file mock miss: if a module is re-exported from a barrel/index file, mocking the barrel will NOT intercept imports of the direct file. Mock the specific file the source actually imports. If unsure, mock both.');
     parts.push('- Wrong API — use only methods that exist in the installed version of the library');
     parts.push('- Type error — make sure the types match what the source file exports');
     parts.push('- React 18 act() async: every act(async () => ...) MUST be awaited. Unawaited act() calls cause state to leak across tests, producing "Cannot read properties of null" or timeout failures in unrelated tests. Fix: add await before every act() call that wraps async code.');
@@ -844,4 +665,4 @@ export function buildRetryPrompt(failureOutput, failedAttempts = []) {
     parts.push('Fix the issue and return your response in the required <thinking> + <code_output> format.');
     return parts.join('\n');
 }
-//# sourceMappingURL=prompts.js.map
+//# sourceMappingURL=index.js.map