agentic-qe 3.15.15 → 3.15.17

package/dist/mcp/entry.js

@@ -29,6 +29,7 @@ import { initFeatureFlagsFromEnv } from '../integrations/ruvector/feature-flags.
 import { resetSharedRvfAdapter } from '../integrations/ruvector/shared-rvf-adapter.js';
 import { resetSharedRvfDualWriter } from '../integrations/ruvector/shared-rvf-dual-writer.js';
 import { claimProcessLifecycle, closeRegisteredStores } from '../kernel/process-lifecycle.js';
+import { INTERACTIVE_LOCK_WAIT_MS, setLockWaitCap } from '../shared/sqlite-lock-wait.js';
 import { getBackgroundWorkersState, startBackgroundWorkers } from './background-workers.js';
 import { DAEMON_HEARTBEAT_ENV, DAEMON_LOG_MAX_SIZE_ENV, DAEMON_LOG_PATH_ENV, DAEMON_MODE_ENV, createDaemonLogRotator, detectStdinKind, parseDaemonHeartbeatMs, parseDaemonLogMaxBytes, resolveStdinGuardMode, startDaemonHeartbeat, } from './daemon-mode.js';
 import { readFileSync } from 'node:fs';
@@ -74,6 +75,9 @@ function releaseProcessStores() {
     catch { /* best effort */ }
 }
 async function main() {
+    // #1263: a write waiting on another process's lock blocks the event loop, so
+    // memory writes wait briefly per attempt and retry asynchronously instead.
+    setLockWaitCap(INTERACTIVE_LOCK_WAIT_MS);
     initFeatureFlagsFromEnv();
     // Output startup message BEFORE suppressing stderr (Claude Code health check needs this)
     const version = pkg.version;

package/dist/mcp/handlers/domain-handler-configs.js

@@ -199,6 +199,8 @@ export const testExecuteConfig = {
         routingTier: routingResult?.decision.tier,
         useAgentBooster: routingResult?.useAgentBooster,
         compiledContext: routingResult?.compiledContext,
+        // #1247: validated by the execute-tests handler before any runner starts.
+        ...(params.projectRoot !== undefined ? { projectRoot: params.projectRoot } : {}),
     }),
     calculateTimeout: (params) => params.timeout || 300000,
     mapToResult: (taskId, data, duration, savedFiles) => {

package/dist/mcp/handlers/trajectory-judge.js

@@ -41,7 +41,7 @@ export async function scoreUnjudgedTrajectories() {
         try {
             const verdict = await scoreTrajectory(row, apiKey, baseUrl);
             if (verdict) {
-                updateStmt.run(JSON.stringify(verdict), row.id);
+                await um.writeWhenUnlocked(() => updateStmt.run(JSON.stringify(verdict), row.id));
             }
         }
         catch {

package/dist/mcp/protocol-server.js

@@ -897,6 +897,7 @@ export class MCPProtocolServer {
                 parameters: [
                     { name: 'testFiles', type: 'array', description: 'Nonempty list of concrete test file paths (relative to the project working directory or absolute). Expand glob patterns before calling; glob patterns are rejected.', items: { type: 'string' } },
                     { name: 'parallel', type: 'boolean', description: 'Enable parallel execution', default: true },
+                    { name: 'projectRoot', type: 'string', description: 'Optional directory inside the project to run every test file from (for example a monorepo package with its own vitest/jest config); relative testFiles are then relative to it. When omitted, each test file runs from its nearest directory with a vitest/jest config, never above the project root, even when a root config also lists that package in its projects. Either way the runner (jest or vitest) is the one the config of that directory sets up. Python test files (*.py) run with pytest (`python -m pytest`, or the interpreter in AQE_PYTHON) from their nearest pytest config (pytest.ini, pyproject.toml, setup.cfg, tox.ini). Paths outside the project, including through symlinks, are rejected.' },
                     saveResultsParameter('test_execute_parallel'),
                 ],
             },

package/dist/mcp/tools/visual-accessibility/index.js

@@ -243,18 +243,20 @@ export class A11yAuditTool extends MCPToolBase {
                     if (contrastResult.success) {
                         const failingContrast = contrastResult.value.filter((c) => !c.passes);
                         if (failingContrast.length > 0) {
+                            // #1228: a ratio the browser did not report (-1) is shown as not measured
+                            const ratioText = (c) => (c.ratio >= 1 ? `${c.ratio}:1` : 'not measured');
                             contrastViolations = failingContrast.map((c) => ({
                                 id: 'color-contrast',
                                 impact: 'serious',
                                 description: 'Elements must have sufficient color contrast',
-                                help: `Element ${c.element} has contrast ratio ${c.ratio}:1 but requires ${c.requiredRatio}:1`,
+                                help: `Element ${c.element} has contrast ratio ${ratioText(c)} but requires ${c.requiredRatio}:1`,
                                 helpUrl: 'https://www.w3.org/WAI/WCAG22/Understanding/contrast-minimum',
                                 wcagCriteria: ['1.4.3'],
                                 nodes: [
                                     {
                                         selector: c.element,
                                         html: `<${c.element.replace('.', ' class="')}>...</${c.element.split('.')[0]}>`,
-                                        failureSummary: `Contrast ratio ${c.ratio}:1 is below required ${c.requiredRatio}:1`,
+                                        failureSummary: `Contrast ratio ${ratioText(c)} is below required ${c.requiredRatio}:1`,
                                         fixSuggestion: `Change foreground color to achieve at least ${c.requiredRatio}:1 contrast`,
                                     },
                                 ],
@@ -271,6 +273,10 @@ export class A11yAuditTool extends MCPToolBase {
                     const keyboardResult = await service.checkKeyboardNavigation(url);
                     if (keyboardResult.success) {
                         const kbReport = keyboardResult.value;
+                        if (kbReport.notMeasured && kbReport.notMeasured.length > 0) {
+                            // #1228: no keyboard finding here is not a clean result for these aspects
+                            notMeasuredWarnings.push({ id: 'keyboard-not-measured', description: `Keyboard check did not measure: ${kbReport.notMeasured.join('; ')}`, nodes: 0 });
+                        }
                         // Convert keyboard issues to violations
                         for (const issue of kbReport.issues) {
                             keyboardViolations.push({

package/dist/mcp/types.d.ts

@@ -201,6 +201,12 @@ export interface TestExecuteParams {
     reportFormat?: 'json' | 'junit' | 'html' | 'markdown';
     /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
     saveResults?: boolean;
+    /**
+     * #1247: directory inside the project to run every test file from; relative
+     * testFiles are read from it. When omitted, each file runs from its nearest
+     * runner project (the directory with its vitest/jest config).
+     */
+    projectRoot?: string;
 }
 /**
  * Coverage analysis parameters

package/dist/optimization/session-cache.d.ts

@@ -59,7 +59,12 @@ export declare class SessionOperationCache {
     private hits;
     private misses;
     private generation;
-    constructor(config?: Partial<SessionCacheConfig>);
+    private readonly resolveMemory;
+    /**
+     * @param resolveMemory Where persisted entries live; defaults to the shared
+     *   UnifiedMemoryManager once it is initialized (injectable for tests).
+     */
+    constructor(config?: Partial<SessionCacheConfig>, resolveMemory?: () => UnifiedMemory | null);
     /**
      * Compute a deterministic fingerprint from build + domain + action + input.
      * Uses SHA-256 of the canonicalized JSON (recursively sorted keys), truncated to 16 hex chars.
@@ -113,6 +118,15 @@ export declare class SessionOperationCache {
      * number of entries removed.
      */
     invalidateDomain(domain: string): number;
+    /**
+     * Persist a cache change without blocking the caller (#1274). The write goes
+     * through the shared connection's writeWhenUnlocked queue: with memory.db
+     * unlocked and nothing queued it runs at once, as before; while another
+     * process holds the lock it retries asynchronously for the usual busy_timeout
+     * instead of freezing the MCP server's event loop. Failure is non-critical,
+     * since the in-memory cache is already up to date.
+     */
+    private persistInBackground;
     /** Evict the oldest entry by cachedAt */
     private evictOldest;
     /** Persist a single entry to kv_store */
@@ -120,7 +134,9 @@ export declare class SessionOperationCache {
     /** Delete a single persisted entry from kv_store (used by invalidateDomain). */
     private deletePersisted;
 }
+type UnifiedMemory = import('../kernel/unified-memory.js').UnifiedMemoryManager;
 export declare function getSessionCache(config?: Partial<SessionCacheConfig>): SessionOperationCache;
 /** Reset the singleton (for testing) */
 export declare function resetSessionCache(): void;
+export {};
 //# sourceMappingURL=session-cache.d.ts.map

package/dist/optimization/session-cache.js

@@ -90,8 +90,14 @@ export class SessionOperationCache {
     hits = 0;
     misses = 0;
     generation = 0;
-    constructor(config) {
+    resolveMemory;
+    /**
+     * @param resolveMemory Where persisted entries live; defaults to the shared
+     *   UnifiedMemoryManager once it is initialized (injectable for tests).
+     */
+    constructor(config, resolveMemory = tryGetMemory) {
         this.config = { ...DEFAULT_SESSION_CACHE_CONFIG, ...config };
+        this.resolveMemory = resolveMemory;
     }
     /**
      * Compute a deterministic fingerprint from build + domain + action + input.
@@ -175,7 +181,7 @@ export class SessionOperationCache {
      */
     loadFromDb() {
         try {
-            const db = tryGetDb();
+            const db = this.resolveMemory()?.getDatabase();
             if (!db)
                 return;
             const cutoffMs = Date.now() - this.config.ttlMs;
@@ -231,13 +237,10 @@ export class SessionOperationCache {
         this.cache.clear();
         this.generation++;
         if (this.config.persistToDb) {
-            try {
-                const db = tryGetDb();
-                db?.prepare("DELETE FROM kv_store WHERE namespace = 'session_cache'").run();
-            }
-            catch {
-                // Cache invalidation must not prevent the tool response.
-            }
+            // #1274: runs after every state-changing tool call, so it must not wait
+            // synchronously on a locked memory.db. Queued writes keep their order,
+            // so a later persistEntry still lands after this delete.
+            this.persistInBackground((db) => db.prepare("DELETE FROM kv_store WHERE namespace = 'session_cache'").run());
         }
         return removed;
     }
@@ -261,6 +264,26 @@ export class SessionOperationCache {
         }
         return removed;
     }
+    /**
+     * Persist a cache change without blocking the caller (#1274). The write goes
+     * through the shared connection's writeWhenUnlocked queue: with memory.db
+     * unlocked and nothing queued it runs at once, as before; while another
+     * process holds the lock it retries asynchronously for the usual busy_timeout
+     * instead of freezing the MCP server's event loop. Failure is non-critical,
+     * since the in-memory cache is already up to date.
+     */
+    persistInBackground(write) {
+        const um = this.resolveMemory();
+        if (!um)
+            return;
+        try {
+            const db = um.getDatabase();
+            um.writeWhenUnlocked(() => write(db)).catch(() => { });
+        }
+        catch {
+            /* cache works without persistence */
+        }
+    }
     /** Evict the oldest entry by cachedAt */
     evictOldest() {
         let oldestKey = null;
@@ -276,46 +299,27 @@ export class SessionOperationCache {
     }
     /** Persist a single entry to kv_store */
     persistEntry(entry) {
-        try {
-            const db = tryGetDb();
-            if (!db)
-                return;
-            db.prepare(`INSERT OR REPLACE INTO kv_store (key, namespace, value, created_at)
-         VALUES (?, 'session_cache', ?, ?)`).run(`session_cache:${entry.fingerprint}`, JSON.stringify(entry), Date.now());
-        }
-        catch {
-            /* non-critical - cache works without persistence */
-        }
+        const value = JSON.stringify(entry);
+        const createdAt = Date.now();
+        this.persistInBackground((db) => db.prepare(`INSERT OR REPLACE INTO kv_store (key, namespace, value, created_at)
+       VALUES (?, 'session_cache', ?, ?)`).run(`session_cache:${entry.fingerprint}`, value, createdAt));
     }
     /** Delete a single persisted entry from kv_store (used by invalidateDomain). */
     deletePersisted(fingerprint) {
-        try {
-            const db = tryGetDb();
-            if (!db)
-                return;
-            db.prepare(`DELETE FROM kv_store WHERE namespace = 'session_cache' AND key = ?`).run(`session_cache:${fingerprint}`);
-        }
-        catch {
-            /* non-critical */
-        }
+        this.persistInBackground((db) => db.prepare(`DELETE FROM kv_store WHERE namespace = 'session_cache' AND key = ?`).run(`session_cache:${fingerprint}`));
     }
 }
-// ============================================================================
-// DB Helper
-// ============================================================================
 /**
- * Attempt to get the unified memory database.
+ * Attempt to get the initialized unified memory manager.
  * Returns null if unavailable (graceful degradation).
  */
-function tryGetDb() {
+function tryGetMemory() {
     try {
         // Dynamic require to avoid circular dependencies at import time
         // eslint-disable-next-line @typescript-eslint/no-require-imports
         const { getUnifiedMemory } = require('../kernel/unified-memory.js');
         const um = getUnifiedMemory();
-        if (!um.isInitialized())
-            return null;
-        return um.getDatabase();
+        return um.isInitialized() ? um : null;
     }
     catch {
         return null;

package/dist/planning/goap-planner.d.ts

@@ -53,6 +53,11 @@ export declare class GOAPPlanner {
      * Get database instance, throwing if not initialized
      */
     private ensureDb;
+    /**
+     * Run a write through the shared connection's write queue (#1283), so a
+     * locked memory.db does not freeze the MCP server during a GOAP tool call.
+     */
+    private write;
     /**
      * Initialize the planner - uses unified persistence, seeds default actions
      * ADR-046: Auto-seeds QE actions if database is empty
@@ -238,6 +243,7 @@ export declare class GOAPPlanner {
      * Record plan reuse outcome
      */
     private recordPlanReuse;
+    private recordPlanReuseNow;
     /**
      * Validate that a plan can be executed from current state
      */

package/dist/planning/goap-planner.js

@@ -13,6 +13,7 @@
  */
 import { randomUUID } from 'crypto';
 import { safeJsonParse } from '../shared/safe-json.js';
+import { writeWhenUnlockedOn } from '../shared/sqlite-write-queue.js';
 import { getUnifiedPersistence } from '../kernel/unified-persistence.js';
 import { DEFAULT_MAX_PLAN_STEPS, validateMaxSteps } from './types.js';
 import { getAllQEActions, QE_GOALS } from './actions/qe-action-library.js';
@@ -131,6 +132,14 @@ export class GOAPPlanner {
         }
         return this.db;
     }
+    /**
+     * Run a write through the shared connection's write queue (#1283), so a
+     * locked memory.db does not freeze the MCP server during a GOAP tool call.
+     */
+    write(fn) {
+        const db = this.ensureDb();
+        return writeWhenUnlockedOn(db, () => fn(db));
+    }
     // ==========================================================================
     // Initialization
     // ==========================================================================
@@ -263,7 +272,7 @@ export class GOAPPlanner {
                 this.validatePlanForState(reusedPlan, currentState) &&
                 this.planSatisfiesConstraints(reusedPlan, currentState, goal, constraints)) {
                 // Update reuse stats
-                this.recordPlanReuse(reusedPlan.id, true);
+                await this.recordPlanReuse(reusedPlan.id, true);
                 const clonedPlan = {
                     ...reusedPlan,
                     estimatedDurationMs: reusedPlan.actions.reduce((sum, action) => sum + (action.estimatedDurationMs ?? DEFAULT_ACTION_DURATION_MS), 0),
@@ -802,7 +811,7 @@ export class GOAPPlanner {
     async addAction(action) {
         await this.initialize();
         const id = `action-${Date.now()}-${randomUUID().slice(0, 8)}`;
-        this.ensureDb()
+        await this.write((db) => db
             .prepare(`
       INSERT INTO goap_actions (
         id, name, description, agent_type, preconditions, effects,
@@ -810,7 +819,7 @@ export class GOAPPlanner {
         method, params, implemented
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?)
     `)
-            .run(id, action.name, action.description ?? null, action.agentType, JSON.stringify(action.preconditions), JSON.stringify(action.effects), action.cost, action.estimatedDurationMs ?? null, action.successRate, action.category, action.qeDomain ?? null, action.method ?? null, action.params ? JSON.stringify(action.params) : null, action.implemented ? 1 : 0);
+            .run(id, action.name, action.description ?? null, action.agentType, JSON.stringify(action.preconditions), JSON.stringify(action.effects), action.cost, action.estimatedDurationMs ?? null, action.successRate, action.category, action.qeDomain ?? null, action.method ?? null, action.params ? JSON.stringify(action.params) : null, action.implemented ? 1 : 0));
         // Update in-memory cache
         const fullAction = {
             ...action,
@@ -828,19 +837,23 @@ export class GOAPPlanner {
         const action = this.actions.get(actionId);
         if (!action)
             return;
-        const newCount = action.executionCount + 1;
-        const newRate = (action.successRate * action.executionCount + (success ? 1 : 0)) /
-            newCount;
-        this.ensureDb()
-            .prepare(`
+        // Read the cached stats, write, and update the cache as one queued unit,
+        // so concurrent updates cannot both build on the same old count.
+        await this.write((db) => {
+            const newCount = action.executionCount + 1;
+            const newRate = (action.successRate * action.executionCount + (success ? 1 : 0)) /
+                newCount;
+            db
+                .prepare(`
       UPDATE goap_actions
       SET success_rate = ?, execution_count = ?, updated_at = datetime('now')
       WHERE id = ?
     `)
-            .run(newRate, newCount, actionId);
-        // Update in-memory cache
-        action.successRate = newRate;
-        action.executionCount = newCount;
+                .run(newRate, newCount, actionId);
+            // Update in-memory cache
+            action.successRate = newRate;
+            action.executionCount = newCount;
+        });
     }
     /**
      * Get actions by category
@@ -885,14 +898,14 @@ export class GOAPPlanner {
      */
     async savePlan(plan) {
         await this.initialize();
-        this.ensureDb()
+        await this.write((db) => db
             .prepare(`
       INSERT OR REPLACE INTO goap_plans (
         id, goal_id, initial_state, goal_state, action_sequence,
         total_cost, estimated_duration_ms, status, reused_from, similarity_score
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `)
-            .run(plan.id, plan.goalId ?? null, JSON.stringify(plan.initialState), JSON.stringify(plan.goalState), JSON.stringify(plan.actions.map((a) => a.id)), plan.totalCost, plan.estimatedDurationMs, plan.status, plan.reusedFrom ?? null, plan.similarityScore ?? null);
+            .run(plan.id, plan.goalId ?? null, JSON.stringify(plan.initialState), JSON.stringify(plan.goalState), JSON.stringify(plan.actions.map((a) => a.id)), plan.totalCost, plan.estimatedDurationMs, plan.status, plan.reusedFrom ?? null, plan.similarityScore ?? null));
     }
     /**
      * Get plan by ID
@@ -999,19 +1012,22 @@ export class GOAPPlanner {
     async storePlanSignature(plan) {
         const goalHash = this.hashGoalConditions(plan.goalState);
         const stateVector = this.extractStateVector(plan.initialState);
-        this.ensureDb()
+        await this.write((db) => db
             .prepare(`
       INSERT OR REPLACE INTO goap_plan_signatures (
         id, plan_id, goal_hash, state_vector, action_sequence, total_cost
       ) VALUES (?, ?, ?, ?, ?, ?)
     `)
-            .run(`sig-${Date.now()}-${randomUUID().slice(0, 8)}`, plan.id, goalHash, JSON.stringify(stateVector), JSON.stringify(plan.actions.map((a) => a.id)), plan.totalCost);
+            .run(`sig-${Date.now()}-${randomUUID().slice(0, 8)}`, plan.id, goalHash, JSON.stringify(stateVector), JSON.stringify(plan.actions.map((a) => a.id)), plan.totalCost));
     }
     /**
      * Record plan reuse outcome
      */
     recordPlanReuse(planId, success) {
-        const db = this.ensureDb();
+        // Read and update as one queued unit (#1283).
+        return this.write((db) => this.recordPlanReuseNow(db, planId, success));
+    }
+    recordPlanReuseNow(db, planId, success) {
         const current = db
             .prepare('SELECT success_rate, usage_count FROM goap_plan_signatures WHERE plan_id = ?')
             .get(planId);
@@ -1121,12 +1137,12 @@ export class GOAPPlanner {
     async addGoal(goal) {
         await this.initialize();
         const id = `goal-${Date.now()}-${randomUUID().slice(0, 8)}`;
-        this.ensureDb()
+        await this.write((db) => db
             .prepare(`
       INSERT INTO goap_goals (id, name, description, conditions, priority, qe_domain)
       VALUES (?, ?, ?, ?, ?, ?)
     `)
-            .run(id, goal.name, goal.description ?? null, JSON.stringify(goal.conditions), goal.priority, goal.qeDomain ?? null);
+            .run(id, goal.name, goal.description ?? null, JSON.stringify(goal.conditions), goal.priority, goal.qeDomain ?? null));
         return id;
     }
     /**

package/dist/planning/plan-executor.js

@@ -17,6 +17,7 @@ import { secureRandom } from '../shared/utils/crypto-random.js';
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { safeJsonParse } from '../shared/safe-json.js';
+import { writeWhenUnlockedOn } from '../shared/sqlite-write-queue.js';
 /**
  * Default execution configuration
  */
@@ -760,31 +761,39 @@ export class PlanExecutor {
         agent_output, world_state_before, world_state_after, error_message
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
-        // Issue #535: steps from replacement plans (replanning) are recorded
-        // under the top-level plan id with a chronological step order, so one
-        // execution is one history record for the plan the caller executed —
-        // not split across sub-plan ids with colliding step orders.
-        result.steps.forEach((step, index) => {
-            insertStep.run(step.id, result.planId, executionId, step.action.id, index, step.status, step.retries, step.startedAt.toISOString(), step.durationMs ?? null, step.agentId ?? null, step.agentOutput ?? null, step.worldStateBefore ? JSON.stringify(step.worldStateBefore) : null, step.worldStateAfter ? JSON.stringify(step.worldStateAfter) : null, step.error ?? null);
+        // #1283: the step rows go in as one queued transaction, so a locked
+        // memory.db does not freeze the MCP server and a retried attempt cannot
+        // insert a step twice.
+        const insertSteps = this.db.transaction(() => {
+            // Issue #535: steps from replacement plans (replanning) are recorded
+            // under the top-level plan id with a chronological step order, so one
+            // execution is one history record for the plan the caller executed —
+            // not split across sub-plan ids with colliding step orders.
+            result.steps.forEach((step, index) => {
+                insertStep.run(step.id, result.planId, executionId, step.action.id, index, step.status, step.retries, step.startedAt.toISOString(), step.durationMs ?? null, step.agentId ?? null, step.agentOutput ?? null, step.worldStateBefore ? JSON.stringify(step.worldStateBefore) : null, step.worldStateAfter ? JSON.stringify(step.worldStateAfter) : null, step.error ?? null);
+            });
+            // Issue #535 (codex review): an execution's cancellation cannot be
+            // inferred from its step rows once replanning is involved (the step
+            // count no longer matches the executed plan's action count), so record
+            // it explicitly with a marker row that history reads and then hides.
+            if (result.status === 'cancelled') {
+                insertStep.run(`${executionId}-${CANCELLED_MARKER_STATUS}`, result.planId, executionId, CANCELLED_MARKER_ACTION_ID, result.steps.length, CANCELLED_MARKER_STATUS, 0, new Date().toISOString(), null, null, null, null, null, result.error ?? 'Execution was cancelled');
+            }
         });
-        // Issue #535 (codex review): an execution's cancellation cannot be
-        // inferred from its step rows once replanning is involved (the step
-        // count no longer matches the executed plan's action count), so record
-        // it explicitly with a marker row that history reads and then hides.
-        if (result.status === 'cancelled') {
-            insertStep.run(`${executionId}-${CANCELLED_MARKER_STATUS}`, result.planId, executionId, CANCELLED_MARKER_ACTION_ID, result.steps.length, CANCELLED_MARKER_STATUS, 0, new Date().toISOString(), null, null, null, null, null, result.error ?? 'Execution was cancelled');
-        }
+        await writeWhenUnlockedOn(this.db, () => insertSteps());
         // Reflects only the most recent execution attempt for this plan — a
         // deliberate, documented scope limit: goap_plans is one row per plan,
         // not per attempt. Full per-attempt history remains queryable via
         // goap_execution_steps grouped by execution_id (see getExecutionHistory).
         try {
-            this.db.prepare(`
+            const executedAt = new Date(Date.now() - result.totalDurationMs).toISOString();
+            const completedAt = new Date().toISOString();
+            await writeWhenUnlockedOn(this.db, () => this.db.prepare(`
         UPDATE goap_plans SET status = ?, executed_at = COALESCE(executed_at, ?), completed_at = ?
         WHERE id = ?
       `).run(result.status === 'completed' ? 'completed'
                 : result.status === 'cancelled' ? 'cancelled'
-                    : 'failed', new Date(Date.now() - result.totalDurationMs).toISOString(), new Date().toISOString(), result.planId);
+                    : 'failed', executedAt, completedAt, result.planId));
         }
         catch (error) {
             // Best-effort — a plan row might not exist yet in edge cases (e.g.

package/dist/routing/co-execution-repository.js

@@ -6,6 +6,7 @@
  * A single co-execution registers at 0.05; twenty successes reach full confidence.
  */
 import { toErrorMessage } from '../shared/error-utils.js';
+import { writeWhenUnlockedOn } from '../shared/sqlite-write-queue.js';
 // ============================================================================
 // Constants
 // ============================================================================
@@ -56,15 +57,14 @@ export class CoExecutionRepository {
         if (!this.db)
             return;
         const [a, b] = [record.agentA, record.agentB].sort();
-        try {
-            this.db.prepare(`
-        INSERT INTO qe_agent_co_execution (agent_a, agent_b, domain, success, task_description)
-        VALUES (?, ?, ?, ?, ?)
-      `).run(a, b, record.domain, record.success ? 1 : 0, record.taskDescription?.slice(0, 500) || null);
-        }
-        catch (error) {
+        const db = this.db;
+        // #1283: queued, so a locked memory.db does not freeze the MCP server.
+        writeWhenUnlockedOn(db, () => db.prepare(`
+      INSERT INTO qe_agent_co_execution (agent_a, agent_b, domain, success, task_description)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(a, b, record.domain, record.success ? 1 : 0, record.taskDescription?.slice(0, 500) || null)).catch((error) => {
             console.debug(`[CoExecutionRepository] Record error: ${toErrorMessage(error)}`);
-        }
+        });
     }
     /**
      * Get co-execution stats for a specific agent pair.
@@ -166,7 +166,10 @@ export class CoExecutionRepository {
                     }
                 }
             });
-            transaction();
+            // #1283: queued, so a locked memory.db does not freeze the MCP server.
+            writeWhenUnlockedOn(this.db, () => transaction()).catch((error) => {
+                console.debug(`[CoExecutionRepository] Swarm record error: ${toErrorMessage(error)}`);
+            });
         }
         catch (error) {
             console.debug(`[CoExecutionRepository] Swarm record error: ${toErrorMessage(error)}`);

package/dist/routing/routing-feedback.d.ts

@@ -42,6 +42,14 @@ export declare class RoutingFeedbackCollector {
      * Persist a single outcome to the database
      */
     private persistOutcome;
+    /**
+     * Queue a write on the shared connection without blocking the caller
+     * (#1274). recordOutcome runs after every routed task, so a locked
+     * memory.db must not freeze the MCP server's event loop. Writes keep their
+     * call order and the connection's full busy_timeout budget; with the
+     * database unlocked and nothing queued the write runs at once, as before.
+     */
+    private persistInBackground;
     /**
      * Infer model tier from agent name for analytics.
      * Maps known agent patterns to ADR-026 tiers.