agentic-qe 3.15.15 → 3.15.16

package/dist/cli/utils/task-result.js

@@ -0,0 +1,39 @@
+/**
+ * Agentic QE v3 - Printing a completed task's result (#1228, #1146)
+ *
+ * `aqe task submit --wait` reported only "Task completed", so a CLI user never
+ * saw what the task found, nor that part of it was not measured. These lines
+ * show the result: its status / measured / message fields first, then the
+ * whole result as JSON (cut after a line limit; --output writes all of it).
+ */
+import { toJSON } from './ci-output.js';
+export const MAX_RESULT_LINES = 200;
+/** Top-level fields that say whether, and how much of, the result was measured. */
+const HEADLINE_FIELDS = ['status', 'measured', 'message', 'note', 'notMeasuredReason', 'notMeasured', 'warning', 'error', 'incompleteChecks'];
+export function taskResultLines(result, maxLines = MAX_RESULT_LINES) {
+    if (result === undefined || result === null)
+        return ['Result: none (the task returned no result)'];
+    const lines = [];
+    if (typeof result === 'object' && !Array.isArray(result)) {
+        const record = result;
+        for (const field of HEADLINE_FIELDS) {
+            if (record[field] !== undefined)
+                lines.push(`${field}: ${headline(record[field])}`);
+        }
+    }
+    const json = toJSON(result).split('\n');
+    lines.push('Result:');
+    lines.push(...json.slice(0, maxLines).map((line) => `  ${line}`));
+    if (json.length > maxLines) {
+        lines.push(`  … ${json.length - maxLines} more line(s); --output <file> writes the full result`);
+    }
+    return lines;
+}
+function headline(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value) && value.length === 0)
+        return '[]';
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=task-result.js.map

package/dist/coordination/handlers/test-execution-handlers.js

@@ -14,6 +14,7 @@ import { jestExactPathPattern, runnerFilePath } from '../../shared/test-runner-a
 import { testCasesFromRunnerReport } from '../../domains/test-execution/services/runner-test-cases.js';
 import { runTestRunnerProcess } from '../../shared/test-runner-process.js';
 import { MAX_PAYLOAD_FILE_BYTES, requirePayloadFiles } from '../../shared/io/payload-path-guard.js';
+import { groupByRunnerProject, requireTestRunTargets } from '../../shared/test-runner-project.js';
 function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -57,6 +58,66 @@ export function rewriteTempPathsInGeneratedTest(testCode, sourceFile, tempPath,
     const newRef = sourceFile === tempPath ? (originalFilePath || sourceFile) : sourceFile;
     return { testCode: newCode, sourceFile: newRef };
 }
+/**
+ * Run `testFiles` (paths relative to the process cwd, or absolute) with the
+ * runner started in `cwd`.
+ */
+async function runProjectTests(testFiles, cwd) {
+    // #1074: run the runner asynchronously so the MCP server keeps serving
+    // other requests (task_status, task_cancel, ...) during the test run.
+    const options = { cwd, timeout: 120000 };
+    let runner = 'vitest';
+    // Vitest 5 writes the JSON report to a file rather than stdout; an explicit
+    // --outputFile gives Vitest 4 and 5 the same contract.
+    const report = createVitestJsonReport();
+    let execution;
+    let output;
+    try {
+        // #909: absolute paths cannot be read as flags (e.g. a "--watch" entry).
+        execution = await runTestRunnerProcess('npx', ['vitest', 'run', ...testFiles.map(file => runnerFilePath(file)), '--reporter=json', ...report.args], options);
+        output = execution.error || execution.signal
+            ? ''
+            : report.read(execution.stdout || '') ?? '';
+    }
+    finally {
+        report.cleanup();
+    }
+    // Preserve the existing Jest fallback when Vitest cannot produce a report.
+    if (!output.includes('{') && execution.status !== 0 && !execution.error && !execution.signal) {
+        runner = 'jest';
+        execution = await runTestRunnerProcess('npx', ['jest', ...testFiles.map(file => jestExactPathPattern(file)), '--json'], options);
+        output = execution.stdout || '';
+    }
+    const diagnostics = [execution.error?.message, execution.signal && `Terminated by ${execution.signal}`, execution.stderr, output].filter(Boolean).join('\n');
+    if (execution.error) {
+        return err(new TestRunnerExecutionError(`${runner} could not complete: ${capDiagnostics(diagnostics)}`));
+    }
+    try {
+        const jsonStart = output.indexOf('{');
+        if (jsonStart >= 0) {
+            const json = JSON.parse(output.slice(jsonStart));
+            if (json.testResults) {
+                const total = json.numTotalTests || 0;
+                const passed = json.numPassedTests || 0;
+                const failed = json.numFailedTests || 0;
+                const skipped = total - passed - failed;
+                const executionError = getTestRunnerExecutionError(runner, testFiles.join(', '), execution.status, { passed, failed, skipped }, diagnostics, json);
+                if (executionError)
+                    return err(executionError);
+                // #1110: per-test entries come from the runner report itself, or are left out.
+                const testCases = testCasesFromRunnerReport(json, testFiles.join(', '));
+                return ok({
+                    total, passed, failed, skipped,
+                    ...(testCases && testCases.length === total ? { testCases } : {}),
+                });
+            }
+        }
+    }
+    catch {
+        // A malformed report cannot establish that the requested tests completed.
+    }
+    return err(new TestRunnerExecutionError(`Could not parse ${runner} results (exit code ${execution.status ?? 'unknown'}):\n${capDiagnostics(diagnostics)}`));
+}
 export function registerTestExecutionHandlers(ctx) {
     // Register test generation handler - REAL IMPLEMENTATION
     ctx.registerHandler('generate-tests', async (task) => {
@@ -198,10 +259,11 @@ export function registerTestExecutionHandlers(ctx) {
             // #1126: a runner executes what it is given, so only files and
             // directories (#909 Jest targets) inside the project, run as the real
             // paths that were checked. A missing file is still reported by the runner.
-            const confined = await requirePayloadFiles('execute-tests', 'testFiles', requestedFiles, { allowMissing: true, allowDirectory: true });
+            // #1247: an explicit projectRoot is confined the same way.
+            const confined = await requireTestRunTargets('execute-tests', requestedFiles, payload.projectRoot);
             if (!confined.success)
                 return confined;
-            const testFiles = confined.value;
+            const { testFiles, projectRoot } = confined.value;
             // A caller-owned MCP task skips the Queen's plugin dispatch. Run through
             // that same domain API here: it owns persistence, measured quality evidence
             // and TestRunStarted/Completed events as well as the runner itself.
@@ -216,68 +278,40 @@ export function registerTestExecutionHandlers(ctx) {
                     workers: payload.parallelism,
                     // The domain owns requested retries; Queen dispatch must not replay it.
                     retryCount: payload.retryCount ?? 0,
+                    projectRoot,
                 });
                 if (!result.success)
                     return result;
                 return ok({ ...result.value, coverage: result.value.coverage?.line ?? null });
             }
-            // #1074: run the runner asynchronously so the MCP server keeps serving
-            // other requests (task_status, task_cancel, ...) during the test run.
-            const options = { cwd: process.cwd(), timeout: 120000 };
-            let runner = 'vitest';
-            // Vitest 5 writes the JSON report to a file rather than stdout; an explicit
-            // --outputFile gives Vitest 4 and 5 the same contract.
-            const report = createVitestJsonReport();
-            let execution;
-            let output;
-            try {
-                // #909: absolute paths cannot be read as flags (e.g. a "--watch" entry).
-                execution = await runTestRunnerProcess('npx', ['vitest', 'run', ...testFiles.map(file => runnerFilePath(file, options.cwd)), '--reporter=json', ...report.args], options);
-                output = execution.error || execution.signal
-                    ? ''
-                    : report.read(execution.stdout || '') ?? '';
-            }
-            finally {
-                report.cleanup();
-            }
-            // Preserve the existing Jest fallback when Vitest cannot produce a report.
-            if (!output.includes('{') && execution.status !== 0 && !execution.error && !execution.signal) {
-                runner = 'jest';
-                execution = await runTestRunnerProcess('npx', ['jest', ...testFiles.map(file => jestExactPathPattern(file, options.cwd)), '--json'], options);
-                output = execution.stdout || '';
-            }
-            const diagnostics = [execution.error?.message, execution.signal && `Terminated by ${execution.signal}`, execution.stderr, output].filter(Boolean).join('\n');
-            if (execution.error) {
-                return err(new TestRunnerExecutionError(`${runner} could not complete: ${capDiagnostics(diagnostics)}`));
+            // #1247: a runner loads the config of the directory it starts in, so
+            // each runner project's files run from that project (or projectRoot).
+            const groups = projectRoot
+                ? [{ cwd: projectRoot, files: testFiles }]
+                : groupByRunnerProject(testFiles);
+            const totals = { total: 0, passed: 0, failed: 0, skipped: 0 };
+            const testCases = [];
+            let everyTestCase = true;
+            for (const group of groups) {
+                const run = await runProjectTests(group.files, group.cwd);
+                if (!run.success)
+                    return run;
+                totals.total += run.value.total;
+                totals.passed += run.value.passed;
+                totals.failed += run.value.failed;
+                totals.skipped += run.value.skipped;
+                if (run.value.testCases)
+                    testCases.push(...run.value.testCases);
+                else
+                    everyTestCase = false;
             }
-            try {
-                const jsonStart = output.indexOf('{');
-                if (jsonStart >= 0) {
-                    const json = JSON.parse(output.slice(jsonStart));
-                    if (json.testResults) {
-                        const total = json.numTotalTests || 0;
-                        const passed = json.numPassedTests || 0;
-                        const failed = json.numFailedTests || 0;
-                        const skipped = total - passed - failed;
-                        const executionError = getTestRunnerExecutionError(runner, testFiles.join(', '), execution.status, { passed, failed, skipped }, diagnostics, json);
-                        if (executionError)
-                            return err(executionError);
-                        // #1027 N5/NB5: this handler runs the tests without --coverage, so it has no
-                        // coverage figure to return (null, never 0%). For test_execute_parallel the
-                        // measured coverage + testsPassing are recorded by TestExecutorService.
-                        // #1110: per-test entries come from the runner report itself, or are left out.
-                        const testCases = testCasesFromRunnerReport(json, testFiles.join(', '));
-                        return ok({
-                            total, passed, failed, skipped, duration: 0, coverage: null, failedTests: [],
-                            ...(testCases && testCases.length === total ? { testCases } : {}),
-                        });
-                    }
-                }
-            }
-            catch {
-                // A malformed report cannot establish that the requested tests completed.
-            }
-            return err(new TestRunnerExecutionError(`Could not parse ${runner} results (exit code ${execution.status ?? 'unknown'}):\n${capDiagnostics(diagnostics)}`));
+            // #1027 N5/NB5: this handler runs the tests without --coverage, so it has no
+            // coverage figure to return (null, never 0%). For test_execute_parallel the
+            // measured coverage + testsPassing are recorded by TestExecutorService.
+            return ok({
+                ...totals, duration: 0, coverage: null, failedTests: [],
+                ...(everyTestCase ? { testCases } : {}),
+            });
         }
         catch (error) {
             return err(toError(error));

package/dist/coordination/mincut/mincut-persistence.js

@@ -49,12 +49,14 @@ export class MinCutPersistence {
         this.ensureInitialized();
         const id = uuidv4();
         const db = this.memory.getDatabase();
-        db.prepare(`
+        // #1274: the queen's snapshot timer and agent events write here, so the
+        // writes queue instead of freezing the MCP server on a locked memory.db.
+        await this.memory.writeWhenUnlocked(() => db.prepare(`
       INSERT INTO mincut_snapshots (
         id, timestamp, vertex_count, edge_count, total_weight,
         is_connected, component_count, vertices_json, edges_json
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, snapshot.timestamp.toISOString(), snapshot.stats.vertexCount, snapshot.stats.edgeCount, snapshot.stats.totalWeight, snapshot.stats.isConnected ? 1 : 0, snapshot.stats.componentCount, JSON.stringify(snapshot.vertices), JSON.stringify(snapshot.edges));
+    `).run(id, snapshot.timestamp.toISOString(), snapshot.stats.vertexCount, snapshot.stats.edgeCount, snapshot.stats.totalWeight, snapshot.stats.isConnected ? 1 : 0, snapshot.stats.componentCount, JSON.stringify(snapshot.vertices), JSON.stringify(snapshot.edges)));
         // Enforce retention to prevent unbounded snapshot growth (Issue #258)
         await this.enforceRetention();
         return id;
@@ -70,20 +72,20 @@ export class MinCutPersistence {
         if (!countRow || countRow.count <= maxSnapshots)
             return 0;
         const deleteCount = countRow.count - maxSnapshots;
-        db.prepare(`
+        await this.memory.writeWhenUnlocked(() => db.prepare(`
       DELETE FROM mincut_snapshots WHERE id IN (
         SELECT id FROM mincut_snapshots ORDER BY created_at ASC LIMIT ?
       )
-    `).run(deleteCount);
+    `).run(deleteCount));
         // Also trim history
         const historyCount = db.prepare('SELECT COUNT(*) as count FROM mincut_history').get();
         if (historyCount.count > 500) {
             const historyDelete = historyCount.count - 500;
-            db.prepare(`
+            await this.memory.writeWhenUnlocked(() => db.prepare(`
         DELETE FROM mincut_history WHERE id IN (
           SELECT id FROM mincut_history ORDER BY created_at ASC LIMIT ?
         )
-      `).run(historyDelete);
+      `).run(historyDelete));
         }
         return deleteCount;
     }
@@ -121,11 +123,11 @@ export class MinCutPersistence {
     async recordHistory(entry) {
         this.ensureInitialized();
         const db = this.memory.getDatabase();
-        const result = db.prepare(`
+        const result = await this.memory.writeWhenUnlocked(() => db.prepare(`
       INSERT INTO mincut_history (
         mincut_value, vertex_count, edge_count, algorithm, duration_ms, snapshot_id
       ) VALUES (?, ?, ?, ?, ?, ?)
-    `).run(entry.minCutValue, entry.vertexCount, entry.edgeCount, entry.algorithm ?? 'weighted-degree', entry.durationMs ?? null, entry.snapshotId ?? null);
+    `).run(entry.minCutValue, entry.vertexCount, entry.edgeCount, entry.algorithm ?? 'weighted-degree', entry.durationMs ?? null, entry.snapshotId ?? null));
         return Number(result.lastInsertRowid);
     }
     /**
@@ -225,13 +227,15 @@ export class MinCutPersistence {
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         const insertMany = db.transaction((vertices) => {
+            ids.length = 0; // a retried attempt starts over (#1283)
             for (const weak of vertices) {
                 const id = uuidv4();
                 insert.run(id, weak.vertexId, weak.weightedDegree, weak.riskScore, weak.reason, weak.vertex.domain ?? null, weak.vertex.type, JSON.stringify(weak.suggestions), snapshotId ?? null);
                 ids.push(id);
             }
         });
-        insertMany(weakVertices);
+        // #1283: queued, so a locked memory.db does not freeze the MCP server.
+        await this.memory.writeWhenUnlocked(() => insertMany(weakVertices));
         return ids;
     }
     /**
@@ -260,11 +264,11 @@ export class MinCutPersistence {
     async resolveWeakVertex(id) {
         this.ensureInitialized();
         const db = this.memory.getDatabase();
-        const result = db.prepare(`
+        const result = await this.memory.writeWhenUnlocked(() => db.prepare(`
       UPDATE mincut_weak_vertices
       SET resolved_at = datetime('now')
       WHERE id = ? AND resolved_at IS NULL
-    `).run(id);
+    `).run(id));
         return result.changes > 0;
     }
     // ==========================================================================
@@ -276,12 +280,12 @@ export class MinCutPersistence {
     async saveAlert(alert) {
         this.ensureInitialized();
         const db = this.memory.getDatabase();
-        db.prepare(`
+        await this.memory.writeWhenUnlocked(() => db.prepare(`
       INSERT INTO mincut_alerts (
         id, severity, message, mincut_value, threshold,
         affected_vertices_json, remediations_json, acknowledged, timestamp
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(alert.id, alert.severity, alert.message, alert.minCutValue, alert.threshold, JSON.stringify(alert.affectedVertices), JSON.stringify(alert.remediations), alert.acknowledged ? 1 : 0, alert.timestamp.toISOString());
+    `).run(alert.id, alert.severity, alert.message, alert.minCutValue, alert.threshold, JSON.stringify(alert.affectedVertices), JSON.stringify(alert.remediations), alert.acknowledged ? 1 : 0, alert.timestamp.toISOString()));
         return alert.id;
     }
     /**
@@ -303,13 +307,13 @@ export class MinCutPersistence {
     async acknowledgeAlert(id, acknowledgedBy) {
         this.ensureInitialized();
         const db = this.memory.getDatabase();
-        const result = db.prepare(`
+        const result = await this.memory.writeWhenUnlocked(() => db.prepare(`
       UPDATE mincut_alerts
       SET acknowledged = 1,
           acknowledged_at = datetime('now'),
           acknowledged_by = ?
       WHERE id = ? AND acknowledged = 0
-    `).run(acknowledgedBy ?? null, id);
+    `).run(acknowledgedBy ?? null, id));
         return result.changes > 0;
     }
     /**
@@ -335,14 +339,14 @@ export class MinCutPersistence {
         this.ensureInitialized();
         const id = uuidv4();
         const db = this.memory.getDatabase();
-        db.prepare(`
+        await this.memory.writeWhenUnlocked(() => db.prepare(`
       INSERT INTO mincut_healing_actions (
         id, action_type, action_params_json, success,
         mincut_before, mincut_after, improvement,
         error_message, duration_ms, triggered_by,
         snapshot_before_id, snapshot_after_id
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, result.action.type, JSON.stringify(result.action), result.success ? 1 : 0, result.minCutBefore, result.minCutAfter, result.improvement, result.error ?? null, result.durationMs, result.triggeredBy ?? null, result.snapshotBeforeId ?? null, result.snapshotAfterId ?? null);
+    `).run(id, result.action.type, JSON.stringify(result.action), result.success ? 1 : 0, result.minCutBefore, result.minCutAfter, result.improvement, result.error ?? null, result.durationMs, result.triggeredBy ?? null, result.snapshotBeforeId ?? null, result.snapshotAfterId ?? null));
         return id;
     }
     /**
@@ -408,13 +412,13 @@ export class MinCutPersistence {
         if (observation.prediction) {
             actualVsPredictedDiff = observation.minCutValue - observation.prediction.predictedMinCut;
         }
-        db.prepare(`
+        await this.memory.writeWhenUnlocked(() => db.prepare(`
       INSERT INTO mincut_observations (
         id, iteration, mincut_value, weak_vertex_count,
         weak_vertices_json, snapshot_id, prediction_json,
         actual_vs_predicted_diff
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, observation.iteration, observation.minCutValue, observation.weakVertices.length, JSON.stringify(observation.weakVertices.map(v => v.vertexId)), observation.snapshotId ?? null, observation.prediction ? JSON.stringify(observation.prediction) : null, actualVsPredictedDiff);
+    `).run(id, observation.iteration, observation.minCutValue, observation.weakVertices.length, JSON.stringify(observation.weakVertices.map(v => v.vertexId)), observation.snapshotId ?? null, observation.prediction ? JSON.stringify(observation.prediction) : null, actualVsPredictedDiff));
         return id;
     }
     /**
@@ -474,18 +478,18 @@ export class MinCutPersistence {
         const historyMaxAge = options.historyMaxAge ?? 7 * 24 * 60 * 60 * 1000; // 7 days
         const snapshotMaxAge = options.snapshotMaxAge ?? 24 * 60 * 60 * 1000; // 1 day
         const alertMaxAge = options.alertMaxAge ?? 30 * 24 * 60 * 60 * 1000; // 30 days
-        const historyResult = db.prepare(`
+        const historyResult = await this.memory.writeWhenUnlocked(() => db.prepare(`
       DELETE FROM mincut_history
       WHERE timestamp < ?
-    `).run(new Date(now - historyMaxAge).toISOString());
-        const snapshotResult = db.prepare(`
+    `).run(new Date(now - historyMaxAge).toISOString()));
+        const snapshotResult = await this.memory.writeWhenUnlocked(() => db.prepare(`
       DELETE FROM mincut_snapshots
       WHERE timestamp < ?
-    `).run(new Date(now - snapshotMaxAge).toISOString());
-        const alertResult = db.prepare(`
+    `).run(new Date(now - snapshotMaxAge).toISOString()));
+        const alertResult = await this.memory.writeWhenUnlocked(() => db.prepare(`
       DELETE FROM mincut_alerts
       WHERE timestamp < ? AND acknowledged = 1
-    `).run(new Date(now - alertMaxAge).toISOString());
+    `).run(new Date(now - alertMaxAge).toISOString()));
         return {
             historyDeleted: historyResult.changes,
             snapshotsDeleted: snapshotResult.changes,

package/dist/domains/code-intelligence/coordinator.d.ts

@@ -217,6 +217,10 @@ export declare class CodeIntelligenceCoordinator extends BaseDomainCoordinator<C
     protected subscribeToEvents(): void;
     private handleTestRunCompleted;
     private handleFilesChanged;
+    /**
+     * #1230: makes every given file searchable, one file at a time (only one
+     * file's content is held at once), with no per-run file cap.
+     */
     indexForSearch(paths: string[]): Promise<SearchIndexSummary>;
     private loadWorkflowState;
     private saveWorkflowState;

package/dist/domains/code-intelligence/coordinator.js

@@ -59,8 +59,13 @@ const DEFAULT_CONFIG = {
  * CQ-002: Extends BaseDomainCoordinator
  */
 const logger = LoggerFactory.create('code-intelligence');
-/** Files made searchable per index run (content, plus vectors with an embedding model). */
-const SEARCH_INDEX_FILE_LIMIT = 100;
+/**
+ * #1230: after this many files in a row fail to embed, an index run stops
+ * asking the embedding model and stores the remaining files as text only.
+ * Each failed embed costs the client's retries and backoff (about 3s), which
+ * would otherwise dominate a large run while the model is down.
+ */
+const MAX_CONSECUTIVE_EMBED_FAILURES = 3;
 export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
     memory;
     agentCoordinator;
@@ -761,19 +766,39 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
     // ============================================================================
     // Helper Methods
     // ============================================================================
+    /**
+     * #1230: makes every given file searchable, one file at a time (only one
+     * file's content is held at once), with no per-run file cap.
+     */
     async indexForSearch(paths) {
-        // Index a subset of files for search
-        // Limit to 100 files for performance in a single batch
-        const filesToIndex = paths.slice(0, SEARCH_INDEX_FILE_LIMIT);
         let searchable = 0;
-        for (const path of filesToIndex) {
+        let withVector = 0;
+        let embedFailures = 0;
+        let consecutiveEmbedFailures = 0;
+        let lastEmbedFailure;
+        let notEmbedded = 0;
+        for (const path of paths) {
             try {
                 // Read actual file content
                 const result = await this.fileReader.readFile(path);
-                if (result.success && result.value) {
-                    const indexed = await this.semanticAnalyzer.indexCode(path, result.value);
-                    if (indexed.success)
-                        searchable++;
+                if (!result.success || !result.value)
+                    continue;
+                const embed = consecutiveEmbedFailures < MAX_CONSECUTIVE_EMBED_FAILURES;
+                const indexed = await this.semanticAnalyzer.indexCode(path, result.value, { embed });
+                if (!indexed.success)
+                    continue;
+                searchable++;
+                if (indexed.value.vector) {
+                    withVector++;
+                    consecutiveEmbedFailures = 0;
+                }
+                else if (indexed.value.vectorFailure !== undefined) {
+                    embedFailures++;
+                    consecutiveEmbedFailures++;
+                    lastEmbedFailure = indexed.value.vectorFailure;
+                }
+                else if (!embed) {
+                    notEmbedded++;
                 }
             }
             catch {
@@ -783,9 +808,17 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
         // #1224: say when search will not see every indexed file.
         const warnings = [];
         if (searchable < paths.length) {
-            warnings.push(`Search covers ${searchable} of ${paths.length} indexed files` +
-                (paths.length > SEARCH_INDEX_FILE_LIMIT ? ` (at most ${SEARCH_INDEX_FILE_LIMIT} per index run)` : '') +
-                '; code in the other files is not found by search.');
+            warnings.push(`Search covers ${searchable} of ${paths.length} indexed files; ` +
+                'the other files could not be added to the search index, so code in them is not found by search.');
+        }
+        // #1231: say which files a semantic search can only match by text.
+        if (embedFailures > 0) {
+            warnings.push(`The embedding model failed for ${embedFailures} file(s) (${lastEmbedFailure})` +
+                (notEmbedded > 0
+                    ? `, so it was not asked for the remaining ${notEmbedded} file(s) of this run`
+                    : '') +
+                `. ${searchable - withVector} of ${searchable} searchable files have no vector; ` +
+                'semantic search matches them by text only. Re-index when the model is available.');
         }
         return { searchable, warnings };
     }

package/dist/domains/code-intelligence/interfaces.d.ts

@@ -75,9 +75,18 @@ export interface SearchResults {
      * #1224, semantic searches only: 'vector' when an embedding model ranked the
      * results, 'lexical-only' when none was available and query words were
      * matched against the indexed text instead (`reason` says why).
+     * #1231: 'partial-vector' when only some indexed files have a vector; the
+     * others were matched by text (hits with `matchType: 'lexical'`) and
+     * `coverage` gives the counts.
      */
-    mode?: 'vector' | 'lexical-only';
+    mode?: 'vector' | 'partial-vector' | 'lexical-only';
     reason?: string;
+    /** #1231, semantic searches that ranked by vector: how many indexed files have a vector. */
+    coverage?: SearchVectorCoverage;
+}
+export interface SearchVectorCoverage {
+    indexedFiles: number;
+    filesWithVector: number;
 }
 export interface SearchResult {
     file: string;

package/dist/domains/code-intelligence/services/semantic-analyzer.d.ts

@@ -11,6 +11,17 @@ import { SearchRequest, SearchResults, SearchResult } from '../interfaces';
  * reported after searching an index that holds code.
  */
 export declare const NOTHING_INDEXED_FOR_SEARCH: string;
+export interface IndexCodeOptions {
+    /** false: store the text only, without asking the embedding model (#1230: it kept failing this run). */
+    embed?: boolean;
+}
+/** What indexCode stored for a file. */
+export interface IndexedCode {
+    /** A vector from the current embedding model was stored. */
+    vector: boolean;
+    /** Set when an embedding model is configured but failed for this file. */
+    vectorFailure?: string;
+}
 /**
  * Interface for the semantic analyzer service
  */
@@ -18,7 +29,7 @@ export interface ISemanticAnalyzerService {
     /** Perform semantic search across codebase */
     search(request: SearchRequest): Promise<Result<SearchResults, Error>>;
     /** Index code for semantic search */
-    indexCode(file: string, content: string): Promise<Result<void, Error>>;
+    indexCode(file: string, content: string, options?: IndexCodeOptions): Promise<Result<IndexedCode, Error>>;
     /** Find semantically similar code */
     findSimilar(code: string, limit?: number): Promise<Result<SearchResult[], Error>>;
     /** Analyze code semantics */
@@ -113,7 +124,7 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     /**
      * Index code content for semantic search
      */
-    indexCode(file: string, content: string): Promise<Result<void, Error>>;
+    indexCode(file: string, content: string, options?: IndexCodeOptions): Promise<Result<IndexedCode, Error>>;
     /**
      * Find semantically similar code
      */
@@ -139,17 +150,30 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     private isCurrentModelVector;
     private vectorKeyPrefix;
     private contentKeyPattern;
+    /** Visits every indexed file's stored content, one at a time. */
+    private forEachIndexed;
     /**
      * #1224: vector search when an embedding model is available. Otherwise (or
      * when no indexed file has a vector from that model) it matches query words
-     * against the indexed text and says so through `lexicalOnlyReason`; no
-     * similarity is invented for those hits.
+     * against the indexed text and reports `mode: 'lexical-only'` with the
+     * reason; no similarity is invented for those hits.
      */
     private semanticSearch;
+    /**
+     * #1231: files indexed while the embedding model was unavailable have no
+     * vector, so vector search cannot rank them. Match those by text, label the
+     * hits 'lexical', and report the result as 'partial-vector' with the counts.
+     * Cosine and text-match scores are not comparable, so vector hits come
+     * first (by cosine), then lexical hits (by share of query words found); the
+     * reason says how many text matches the limit left out.
+     */
+    private withVectorlessFiles;
     /** Word-overlap matching for a semantic query when no vectors can be used. */
     private lexicalSearch;
     private exactSearch;
     private fuzzySearch;
+    /** Token-overlap match of one indexed file, or null when it is filtered out or scores too low. */
+    private fuzzyMatch;
     private extractConcepts;
     private detectPatterns;
     private calculateComplexity;
@@ -160,9 +184,10 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     private tokenize;
     private calculateFuzzyScore;
     /**
-     * A content token matches a query token it contains, or that contains it.
-     * #1224: the second direction needs a content token of 3+ characters, so a
-     * one-letter variable such as `i` does not match the query "login".
+     * A query word is found when a content word contains it (or equals it):
+     * "login" is found in `loginWithPassword`. #1279: not the reverse; a query
+     * word such as `stepHandler450` is not found just because the file has the
+     * shorter word `step`, which made almost every file a full match.
      */
     private tokensMatch;
     private matchesFilters;