agentic-qe 3.15.15 → 3.15.17

package/dist/cli/handlers/task-handler.js

@@ -10,21 +10,29 @@ import { createTimedSpinner } from '../utils/progress.js';
 import { parseJsonOption } from '../helpers/safe-json.js';
 import { validateIndexTaskPayload } from '../../domains/code-intelligence/index-path-guard.js';
 import { writeOutput, toJSON } from '../utils/ci-output.js';
+import { taskResultLines } from '../utils/task-result.js';
 // ============================================================================
 // Task Handler
 // ============================================================================
 /**
  * What a completed task's result says it could not check (#1135, #1052):
  * `incompleteChecks`, or a top-level status of incomplete/failed with its reason.
+ * #1228: a result whose top-level status is not-measured or partial (part of what was
+ * asked was not measured) is not a clean run either. `measured: false` alone is not
+ * flagged: analyze-coverage sets it for caller-supplied coverage it did analyze.
  */
 export function incompleteResultReasons(result) {
     if (!result || typeof result !== 'object')
         return [];
-    const { status, error, incompleteChecks } = result;
+    const { status, error, incompleteChecks, message, notMeasuredReason } = result;
     const reasons = Array.isArray(incompleteChecks) ? incompleteChecks.filter((reason) => typeof reason === 'string') : [];
     if (reasons.length === 0 && (status === 'incomplete' || status === 'failed')) {
         reasons.push(typeof error === 'string' ? error : `result status is ${status}`);
     }
+    if (reasons.length === 0 && (status === 'not-measured' || status === 'partial')) {
+        const why = [message, notMeasuredReason].find((text) => typeof text === 'string');
+        reasons.push(why ?? `result status is ${status}`);
+    }
     return reasons;
 }
 export class TaskHandler {
@@ -49,6 +57,7 @@ export class TaskHandler {
             .option('-t, --timeout <ms>', 'Task timeout in ms', '300000')
             .option('--payload <json>', 'Task payload as JSON', '{}')
             .option('--wait', 'Wait for task completion (required: CLI tasks are not persisted)')
+            .option('-o, --output <file>', 'Write the full task result as JSON to a file')
             .option('--no-progress', 'Disable progress indicator')
             .action(async (type, options) => {
             await this.executeSubmit(type, options, context);
@@ -167,9 +176,11 @@ export class TaskHandler {
                                 const incomplete = incompleteResultReasons(taskStatus.result);
                                 if (incomplete.length > 0) {
                                     waitSpinner.fail(`Task completed, but its result is incomplete: ${incomplete.join('; ')}`);
+                                    this.printResult(taskStatus.result, options.output);
                                     return this.cleanupAndExit(1);
                                 }
                                 waitSpinner.succeed('Task completed successfully');
+                                this.printResult(taskStatus.result, options.output);
                                 completed = true;
                             }
                             else if (taskStatus.status === 'failed' || taskStatus.status === 'cancelled') {
@@ -202,6 +213,14 @@ export class TaskHandler {
             await this.cleanupAndExit(1);
         }
     }
+    /** #1228, #1146: show what a completed task returned, not only that it completed. */
+    printResult(result, outputPath) {
+        console.log('');
+        for (const line of taskResultLines(result))
+            console.log(`  ${line}`);
+        if (outputPath)
+            writeOutput(toJSON(result ?? null), outputPath);
+    }
     async executeList(options, context) {
         if (!await this.ensureInitialized())
             return this.cleanupAndExit(1);
@@ -362,6 +381,7 @@ Submit Options:
   --payload <json>            Task payload as JSON
   --wait                      Wait for task completion (required; CLI-submitted
                               tasks run in this process and are not persisted)
+  -o, --output <file>         Write the full task result as JSON to a file
   --no-progress               Disable progress indicator
 
 List Options:

package/dist/cli/utils/task-result.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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).
+ */
+export declare const MAX_RESULT_LINES = 200;
+export declare function taskResultLines(result: unknown, maxLines?: number): string[];
+//# sourceMappingURL=task-result.d.ts.map

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

@@ -11,9 +11,11 @@ import { toError } from '../../shared/error-utils.js';
 import { capDiagnostics, getTestRunnerExecutionError, TestRunnerExecutionError } from '../../shared/test-runner-verdict.js';
 import { createVitestJsonReport } from '../../shared/vitest-json-report.js';
 import { jestExactPathPattern, runnerFilePath } from '../../shared/test-runner-args.js';
-import { testCasesFromRunnerReport } from '../../domains/test-execution/services/runner-test-cases.js';
+import { testCaseFailureMessage, testCasesFromRunnerReport } from '../../domains/test-execution/services/runner-test-cases.js';
+import { createPytestJunitReport, isPythonTestFile, pytestCommand, pytestRunFromReport, PYTEST_ENV } from '../../shared/pytest-junit-report.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, runnerFrameworkFor } from '../../shared/test-runner-project.js';
 function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -57,6 +59,106 @@ export function rewriteTempPathsInGeneratedTest(testCode, sourceFile, tempPath,
     const newRef = sourceFile === tempPath ? (originalFilePath || sourceFile) : sourceFile;
     return { testCode: newCode, sourceFile: newRef };
 }
+/** #1248: run Python test files with pytest, reading its JUnit report. */
+async function runPytestTests(testFiles, cwd) {
+    const report = createPytestJunitReport();
+    try {
+        const { command, args } = pytestCommand(testFiles.map(file => runnerFilePath(file)), report.path);
+        const execution = await runTestRunnerProcess(command, args, { cwd, timeout: 120000, env: { ...process.env, ...PYTEST_ENV } });
+        const output = [execution.stderr, execution.stdout].filter(Boolean).join('\n');
+        if (execution.error || execution.signal) {
+            const reason = execution.error?.message ?? `Terminated by ${execution.signal}`;
+            return err(new TestRunnerExecutionError(`pytest could not complete: ${capDiagnostics(`${reason}\n${output}`)}`));
+        }
+        const run = pytestRunFromReport(report.read(), testFiles, execution.status, output, command);
+        if (!run.success)
+            return run;
+        const testCases = run.value.tests.map(test => {
+            const failureMessage = test.failureMessage && testCaseFailureMessage(test.failureMessage);
+            return {
+                name: test.name, file: test.file, status: test.status,
+                ...(test.duration !== undefined ? { duration: test.duration } : {}),
+                ...(failureMessage ? { failureMessage } : {}),
+            };
+        });
+        const { total, passed, failed, skipped } = run.value;
+        return ok({ total, passed, failed, skipped, testCases });
+    }
+    finally {
+        report.cleanup();
+    }
+}
+/**
+ * Run `testFiles` (paths relative to the process cwd, or absolute) with the
+ * runner started in `cwd`.
+ */
+async function runProjectTests(testFiles, cwd) {
+    if (testFiles.some(isPythonTestFile))
+        return runPytestTests(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 };
+    const runJest = () => runTestRunnerProcess('npx', ['jest', ...testFiles.map(file => jestExactPathPattern(file)), '--json'], options);
+    let runner = 'vitest';
+    let execution;
+    let output = '';
+    if (runnerFrameworkFor(cwd) === 'jest') {
+        // #1272: a project configured for Jest runs with Jest, never Vitest first.
+        runner = 'jest';
+        execution = await runJest();
+        output = execution.stdout || '';
+    }
+    else {
+        // 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();
+        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 runJest();
+            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 +300,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 +319,43 @@ 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();
+            // #1247: a runner loads the config of the directory it starts in, so
+            // each runner project's files run from that project (or projectRoot).
+            // #1248: Python files run apart from the others, with pytest.
+            const groups = projectRoot
+                ? [testFiles.filter(isPythonTestFile), testFiles.filter(file => !isPythonTestFile(file))]
+                    .filter(files => files.length > 0)
+                    .map(files => ({ cwd: projectRoot, files }))
+                : 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;
             }
-            // 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)}`));
-            }
-            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 };
     }