agentic-qe 3.15.14 → 3.15.16

package/dist/routing/routing-feedback.js

@@ -10,6 +10,7 @@ import { QE_AGENT_REGISTRY } from './qe-agent-registry.js';
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
 import { safeJsonParse } from '../shared/safe-json.js';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { isBusyError } from '../learning/dream/dream-lock-retry.js';
 import { EMACalibrator } from './calibration/index.js';
 import { AutoEscalationTracker } from './escalation/index.js';
 import { ensureRoutingOutcomesAdr095Columns } from './routing-outcomes-migration.js';
@@ -141,10 +142,11 @@ export class RoutingFeedbackCollector {
      * Persist a single outcome to the database
      */
     persistOutcome(outcome) {
-        if (!this.db)
-            return;
-        try {
-            const database = this.db.getDatabase();
+        const modelTier = this.inferTier(outcome.usedAgent);
+        const advisorJson = outcome.advisorConsultation
+            ? JSON.stringify(outcome.advisorConsultation)
+            : null;
+        this.persistInBackground('outcome', (database) => {
             // Ensure schema columns exist for databases created before ADR-092
             // and ADR-095. Runs once per process via the flag; new databases have
             // columns from unified-memory-schemas.ts CREATE TABLE.
@@ -156,17 +158,17 @@ export class RoutingFeedbackCollector {
                     try {
                         database.prepare(col).run();
                     }
-                    catch { /* column already exists */ }
+                    catch (error) {
+                        // Column already exists. A locked database is retried instead (#1274).
+                        if (isBusyError(error))
+                            throw error;
+                    }
                 }
                 // ADR-095: routing exploration columns via shared helper so all
                 // writer paths agree on the column set.
                 ensureRoutingOutcomesAdr095Columns(database);
                 RoutingFeedbackCollector.schemaMigrated = true;
             }
-            const modelTier = this.inferTier(outcome.usedAgent);
-            const advisorJson = outcome.advisorConsultation
-                ? JSON.stringify(outcome.advisorConsultation)
-                : null;
             database.prepare(`
         INSERT OR REPLACE INTO routing_outcomes (
           id, task_json, decision_json, used_agent,
@@ -174,13 +176,30 @@ export class RoutingFeedbackCollector {
           duration_ms, error, model_tier, advisor_consultation_json
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `).run(outcome.id, JSON.stringify(outcome.task), JSON.stringify(outcome.decision), outcome.usedAgent, outcome.followedRecommendation ? 1 : 0, outcome.outcome.success ? 1 : 0, outcome.outcome.qualityScore, outcome.outcome.durationMs, outcome.outcome.error || null, modelTier, advisorJson);
+        }, () => {
             this.persistCount++;
             if (this.persistCount % RoutingFeedbackCollector.RETENTION_CLEANUP_INTERVAL === 0) {
-                this.enforceRetention(database);
+                this.enforceRetention();
             }
+        });
+    }
+    /**
+     * 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.
+     */
+    persistInBackground(what, write, onPersisted) {
+        if (!this.db)
+            return;
+        const warn = (error) => console.warn(`[RoutingFeedbackCollector] Failed to persist ${what}:`, toErrorMessage(error));
+        try {
+            const database = this.db.getDatabase();
+            this.db.writeWhenUnlocked(() => write(database)).then(onPersisted, warn);
         }
         catch (error) {
-            console.warn('[RoutingFeedbackCollector] Failed to persist outcome:', toErrorMessage(error));
+            warn(error);
         }
     }
     /**
@@ -228,18 +247,15 @@ export class RoutingFeedbackCollector {
     /**
      * Delete oldest rows beyond retention limit
      */
-    enforceRetention(database) {
-        try {
-            const maxRows = this.maxOutcomes * 2;
+    enforceRetention() {
+        const maxRows = this.maxOutcomes * 2;
+        this.persistInBackground('retention cleanup', (database) => {
             database.prepare(`
         DELETE FROM routing_outcomes WHERE id NOT IN (
           SELECT id FROM routing_outcomes ORDER BY created_at DESC LIMIT ?
         )
       `).run(maxRows);
-        }
-        catch (error) {
-            console.warn('[RoutingFeedbackCollector] Retention cleanup failed:', toErrorMessage(error));
-        }
+        });
     }
     /**
      * Load persisted EMA calibrator state from the database
@@ -268,14 +284,17 @@ export class RoutingFeedbackCollector {
     persistCalibratorState() {
         if (!this.db || !this.calibrator)
             return;
+        let serialized;
         try {
-            const database = this.db.getDatabase();
-            const serialized = JSON.stringify(this.calibrator.serialize());
-            database.prepare(`INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, datetime('now'))`).run('routing:ema_calibrator_state', serialized);
+            serialized = JSON.stringify(this.calibrator.serialize());
         }
         catch (error) {
             console.warn('[RoutingFeedbackCollector] Failed to persist calibrator state:', toErrorMessage(error));
+            return;
         }
+        this.persistInBackground('calibrator state', (database) => {
+            database.prepare(`INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, datetime('now'))`).run('routing:ema_calibrator_state', serialized);
+        });
     }
     /**
      * Load persisted economic routing state from the database
@@ -304,14 +323,17 @@ export class RoutingFeedbackCollector {
     persistEconomicState() {
         if (!this.db || !this.economicModel)
             return;
+        let serialized;
         try {
-            const database = this.db.getDatabase();
-            const serialized = JSON.stringify(this.economicModel.serializeEstimates());
-            database.prepare(`INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, datetime('now'))`).run('routing:economic_quality_estimates', serialized);
+            serialized = JSON.stringify(this.economicModel.serializeEstimates());
         }
         catch (error) {
             console.warn('[RoutingFeedbackCollector] Failed to persist economic state:', toErrorMessage(error));
+            return;
         }
+        this.persistInBackground('economic state', (database) => {
+            database.prepare(`INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, datetime('now'))`).run('routing:economic_quality_estimates', serialized);
+        });
     }
     /**
      * Connect to router for automatic performance updates

package/dist/routing/routing-outcomes-migration.js

@@ -13,6 +13,7 @@
  * Callers run this before INSERTing rows that reference the new columns.
  * A process-local flag prevents repeated migration attempts.
  */
+import { isBusyError } from '../learning/dream/dream-lock-retry.js';
 let migrated = false;
 /**
  * Add the ADR-095 columns to routing_outcomes if they don't already exist.
@@ -34,11 +35,15 @@ export function ensureRoutingOutcomesAdr095Columns(db) {
         try {
             db.prepare(stmt).run();
         }
-        catch {
+        catch (error) {
             // Column already exists, or table doesn't exist yet. Both are
             // acceptable — ALTER is additive, and a missing table means the
             // unified schema hasn't been applied yet (caller's INSERT will fail
-            // separately with a clearer error).
+            // separately with a clearer error). A locked database is not (#1274):
+            // rethrow so a retrying caller migrates on its next attempt instead of
+            // marking the migration done without the columns.
+            if (isBusyError(error))
+                throw error;
         }
     }
     // Index on exploration for the bucket-comparison queries used by

package/dist/shared/llm/spend-ledger.d.ts

@@ -64,8 +64,17 @@ export declare class SqliteSpendLedger implements SpendLedger {
      * drop ALL spend — bypassing the budget cap (the #557 class).
      */
     private hasAgentColumn;
+    /**
+     * Charges queued but not yet in the table (#1283). record() queues its
+     * INSERT so a locked memory.db does not freeze the MCP server; until the row
+     * lands, the spend reads below count it from here, so the ADR-123 budget cap
+     * never under-counts. Each entry leaves this set in the same synchronous
+     * step that inserts its row, so a charge is never counted twice.
+     */
+    private readonly pending;
     constructor(db: DatabaseType);
     record(entry: SpendEntry): void;
+    private insert;
     spentSince(windowMs: number, nowMs?: number): number;
     spentByAgentSince(windowMs: number, nowMs?: number): Record<string, number>;
 }

package/dist/shared/llm/spend-ledger.js

@@ -18,6 +18,7 @@
  * cross-process pattern.
  */
 import { createSafeRecord } from '../utils/safe-record.js';
+import { writeWhenUnlockedOn } from '../sqlite-write-queue.js';
 /** Bucket used for charges recorded without an agent context. */
 export const UNATTRIBUTED_AGENT = '(unattributed)';
 const CREATE_TABLE_SQL = `
@@ -49,6 +50,14 @@ export class SqliteSpendLedger {
      * drop ALL spend — bypassing the budget cap (the #557 class).
      */
     hasAgentColumn = false;
+    /**
+     * Charges queued but not yet in the table (#1283). record() queues its
+     * INSERT so a locked memory.db does not freeze the MCP server; until the row
+     * lands, the spend reads below count it from here, so the ADR-123 budget cap
+     * never under-counts. Each entry leaves this set in the same synchronous
+     * step that inserts its row, so a charge is never counted twice.
+     */
+    pending = new Set();
     constructor(db) {
         this.db = db;
         // Additive schema only — CREATE TABLE/INDEX IF NOT EXISTS never drops data.
@@ -70,45 +79,52 @@ export class SqliteSpendLedger {
         }
     }
     record(entry) {
-        try {
-            if (this.hasAgentColumn) {
-                this.db
-                    .prepare(`INSERT INTO llm_spend
-               (ts, provider, model, cost_usd, cost_source, prompt_tokens, completion_tokens, request_id, agent_type)
-             VALUES (@ts, @provider, @model, @cost_usd, @cost_source, @prompt_tokens, @completion_tokens, @request_id, @agent_type)`)
-                    .run({
-                    ts: Date.now(),
-                    provider: entry.provider,
-                    model: entry.model,
-                    cost_usd: entry.costUsd,
-                    cost_source: entry.costSource,
-                    prompt_tokens: entry.promptTokens,
-                    completion_tokens: entry.completionTokens,
-                    request_id: entry.requestId,
-                    agent_type: entry.agent ?? null,
-                });
-            }
-            else {
-                // Column absent (migration couldn't run) — still record spend so the
-                // budget cap holds; just without per-agent attribution.
-                this.db
-                    .prepare(`INSERT INTO llm_spend
-               (ts, provider, model, cost_usd, cost_source, prompt_tokens, completion_tokens, request_id)
-             VALUES (@ts, @provider, @model, @cost_usd, @cost_source, @prompt_tokens, @completion_tokens, @request_id)`)
-                    .run({
-                    ts: Date.now(),
-                    provider: entry.provider,
-                    model: entry.model,
-                    cost_usd: entry.costUsd,
-                    cost_source: entry.costSource,
-                    prompt_tokens: entry.promptTokens,
-                    completion_tokens: entry.completionTokens,
-                    request_id: entry.requestId,
-                });
-            }
-        }
-        catch {
+        const ts = Date.now();
+        const charge = { ts, costUsd: entry.costUsd, agent: entry.agent ?? UNATTRIBUTED_AGENT };
+        this.pending.add(charge);
+        writeWhenUnlockedOn(this.db, () => {
+            this.insert(entry, ts);
+            this.pending.delete(charge);
+        }).catch(() => {
             // A ledger write must never break a generation call.
+            this.pending.delete(charge);
+        });
+    }
+    insert(entry, ts) {
+        if (this.hasAgentColumn) {
+            this.db
+                .prepare(`INSERT INTO llm_spend
+             (ts, provider, model, cost_usd, cost_source, prompt_tokens, completion_tokens, request_id, agent_type)
+           VALUES (@ts, @provider, @model, @cost_usd, @cost_source, @prompt_tokens, @completion_tokens, @request_id, @agent_type)`)
+                .run({
+                ts,
+                provider: entry.provider,
+                model: entry.model,
+                cost_usd: entry.costUsd,
+                cost_source: entry.costSource,
+                prompt_tokens: entry.promptTokens,
+                completion_tokens: entry.completionTokens,
+                request_id: entry.requestId,
+                agent_type: entry.agent ?? null,
+            });
+        }
+        else {
+            // Column absent (migration couldn't run) — still record spend so the
+            // budget cap holds; just without per-agent attribution.
+            this.db
+                .prepare(`INSERT INTO llm_spend
+             (ts, provider, model, cost_usd, cost_source, prompt_tokens, completion_tokens, request_id)
+           VALUES (@ts, @provider, @model, @cost_usd, @cost_source, @prompt_tokens, @completion_tokens, @request_id)`)
+                .run({
+                ts,
+                provider: entry.provider,
+                model: entry.model,
+                cost_usd: entry.costUsd,
+                cost_source: entry.costSource,
+                prompt_tokens: entry.promptTokens,
+                completion_tokens: entry.completionTokens,
+                request_id: entry.requestId,
+            });
         }
     }
     spentSince(windowMs, nowMs = Date.now()) {
@@ -116,7 +132,12 @@ export class SqliteSpendLedger {
             const row = this.db
                 .prepare(`SELECT COALESCE(SUM(cost_usd), 0) AS total FROM llm_spend WHERE ts >= ?`)
                 .get(nowMs - windowMs);
-            return row?.total ?? 0;
+            let total = row?.total ?? 0;
+            for (const charge of this.pending) {
+                if (charge.ts >= nowMs - windowMs)
+                    total += charge.costUsd;
+            }
+            return total;
         }
         catch {
             return 0;
@@ -131,6 +152,10 @@ export class SqliteSpendLedger {
             const out = createSafeRecord();
             for (const r of rows)
                 out[r.agent] = r.total;
+            for (const charge of this.pending) {
+                if (charge.ts >= nowMs - windowMs)
+                    out[charge.agent] = (out[charge.agent] ?? 0) + charge.costUsd;
+            }
             return out;
         }
         catch {

package/dist/shared/sqlite-lock-wait.d.ts

@@ -0,0 +1,27 @@
+/**
+ * How long one attempt of an asynchronously retried write may wait for a
+ * SQLite lock (#1263).
+ *
+ * better-sqlite3 waits for a locked database synchronously, inside the call,
+ * for up to the connection's busy_timeout (5 s by default). In a one-shot CLI
+ * command that is the patience we want. In the MCP server it freezes the event
+ * loop: while another process held memory.db's write lock, background writes
+ * blocked for 5 s each, back to back, and stopped all tool calls for 10-15 s.
+ *
+ * The MCP server sets this cap. Writes routed through
+ * UnifiedMemoryManager.writeWhenUnlocked then wait at most the cap per
+ * attempt and retry asynchronously until the connection's busy_timeout has
+ * passed. Connections keep their busy_timeout, so writes not routed that way
+ * keep their full (blocking) patience.
+ *
+ * Dependency-free so any module can read it.
+ */
+/** Longest one retried write attempt blocks the MCP server's event loop on a locked database. */
+export declare const INTERACTIVE_LOCK_WAIT_MS = 200;
+/** Set the per-attempt wait for asynchronously retried writes (null: no cap). */
+export declare function setLockWaitCap(ms: number | null): void;
+/** The current cap, or null when retried writes wait the full busy_timeout per attempt. */
+export declare function getLockWaitCap(): number | null;
+/** The per-attempt wait for a requested busy_timeout, honouring the process cap. */
+export declare function capBusyTimeout(requestedMs: number): number;
+//# sourceMappingURL=sqlite-lock-wait.d.ts.map

package/dist/shared/sqlite-lock-wait.js

@@ -0,0 +1,37 @@
+/**
+ * How long one attempt of an asynchronously retried write may wait for a
+ * SQLite lock (#1263).
+ *
+ * better-sqlite3 waits for a locked database synchronously, inside the call,
+ * for up to the connection's busy_timeout (5 s by default). In a one-shot CLI
+ * command that is the patience we want. In the MCP server it freezes the event
+ * loop: while another process held memory.db's write lock, background writes
+ * blocked for 5 s each, back to back, and stopped all tool calls for 10-15 s.
+ *
+ * The MCP server sets this cap. Writes routed through
+ * UnifiedMemoryManager.writeWhenUnlocked then wait at most the cap per
+ * attempt and retry asynchronously until the connection's busy_timeout has
+ * passed. Connections keep their busy_timeout, so writes not routed that way
+ * keep their full (blocking) patience.
+ *
+ * Dependency-free so any module can read it.
+ */
+/** Longest one retried write attempt blocks the MCP server's event loop on a locked database. */
+export const INTERACTIVE_LOCK_WAIT_MS = 200;
+let lockWaitCapMs = null;
+/** Set the per-attempt wait for asynchronously retried writes (null: no cap). */
+export function setLockWaitCap(ms) {
+    if (ms !== null && (!Number.isFinite(ms) || ms < 0)) {
+        throw new RangeError(`Lock wait cap must be a non-negative number of ms, got ${ms}`);
+    }
+    lockWaitCapMs = ms === null ? null : Math.floor(ms);
+}
+/** The current cap, or null when retried writes wait the full busy_timeout per attempt. */
+export function getLockWaitCap() {
+    return lockWaitCapMs;
+}
+/** The per-attempt wait for a requested busy_timeout, honouring the process cap. */
+export function capBusyTimeout(requestedMs) {
+    return lockWaitCapMs === null ? requestedMs : Math.min(requestedMs, lockWaitCapMs);
+}
+//# sourceMappingURL=sqlite-lock-wait.js.map

package/dist/shared/sqlite-write-queue.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Which SQLite connections have a write queue (#1283).
+ *
+ * UnifiedMemoryManager registers its shared memory.db connection here while it
+ * is open, with its writeWhenUnlocked queue. Modules that hold only the raw
+ * connection route writes through `writeWhenUnlockedOn` without importing
+ * unified-memory's sqlite graph: on a registered connection the write is
+ * queued (FIFO, retried asynchronously under the MCP server's lock wait cap,
+ * full busy_timeout budget), so a locked memory.db does not freeze the event
+ * loop. A write on any other connection runs now, as it always did.
+ *
+ * Dependency-free so any module can import it.
+ */
+/** A connection's FIFO write queue: runs `fn` when the database is unlocked. */
+export type WriteQueue = <T>(fn: () => T) => Promise<T>;
+/** Route writes on `db` through `queue` until unregistered. */
+export declare function registerWriteQueue(db: object, queue: WriteQueue): void;
+/** Stop routing writes on `db` (the connection is closing). */
+export declare function unregisterWriteQueue(db: object): void;
+/** True when writes on `db` are queued. */
+export declare function hasWriteQueue(db: object | null | undefined): boolean;
+/**
+ * Run a write on `db`: queued when `db` has a write queue, otherwise at once.
+ * With the queue empty and the database unlocked a queued write also runs at
+ * once, so callers see the same result as a direct write.
+ */
+export declare function writeWhenUnlockedOn<T>(db: object | null | undefined, fn: () => T): Promise<T>;
+//# sourceMappingURL=sqlite-write-queue.d.ts.map

package/dist/shared/sqlite-write-queue.js

@@ -0,0 +1,38 @@
+/**
+ * Which SQLite connections have a write queue (#1283).
+ *
+ * UnifiedMemoryManager registers its shared memory.db connection here while it
+ * is open, with its writeWhenUnlocked queue. Modules that hold only the raw
+ * connection route writes through `writeWhenUnlockedOn` without importing
+ * unified-memory's sqlite graph: on a registered connection the write is
+ * queued (FIFO, retried asynchronously under the MCP server's lock wait cap,
+ * full busy_timeout budget), so a locked memory.db does not freeze the event
+ * loop. A write on any other connection runs now, as it always did.
+ *
+ * Dependency-free so any module can import it.
+ */
+const queues = new WeakMap();
+/** Route writes on `db` through `queue` until unregistered. */
+export function registerWriteQueue(db, queue) {
+    queues.set(db, queue);
+}
+/** Stop routing writes on `db` (the connection is closing). */
+export function unregisterWriteQueue(db) {
+    queues.delete(db);
+}
+/** True when writes on `db` are queued. */
+export function hasWriteQueue(db) {
+    return db != null && queues.has(db);
+}
+/**
+ * Run a write on `db`: queued when `db` has a write queue, otherwise at once.
+ * With the queue empty and the database unlocked a queued write also runs at
+ * once, so callers see the same result as a direct write.
+ */
+export function writeWhenUnlockedOn(db, fn) {
+    const queue = db != null ? queues.get(db) : undefined;
+    if (queue)
+        return queue(fn);
+    return new Promise((resolve) => resolve(fn()));
+}
+//# sourceMappingURL=sqlite-write-queue.js.map

package/dist/shared/test-runner-project.d.ts

@@ -0,0 +1,69 @@
+/**
+ * #1247: the runner project a test file belongs to.
+ *
+ * Vitest and Jest load their configuration (setup files, aliases, include
+ * patterns, environment) from the directory they are started in. In a
+ * monorepo whose packages have their own config (`apps/webapp/vitest.config.ts`)
+ * a run started at the repository root never loads that package's setup, so
+ * the package's tests fail or produce no report. Each test file is therefore
+ * run from the nearest directory, at or above it, with runner configuration,
+ * but never from above the project root. Only real configuration counts, so a
+ * workspace package without its own config runs from the root that defines
+ * its project.
+ *
+ * A run from the current working directory is kept whenever that directory is
+ * already inside the file's runner project (a single-project repository, or a
+ * server started inside the package), so those runs behave as before.
+ */
+import { Result } from './types';
+/**
+ * Files whose presence makes a directory a Vitest or Jest project. A root
+ * workspace file (`vitest.workspace.*`) counts too: its packages run from it.
+ */
+export declare const RUNNER_CONFIG_FILES: readonly string[];
+export interface RunnerProjectOptions {
+    /** Directory runs start in today; defaults to process.cwd(). */
+    cwd?: string;
+    /** Highest directory the search may reach; defaults to findProjectRoot(). */
+    boundary?: string;
+    /** Directories already checked, so files that share a directory check it once. */
+    checked?: Map<string, boolean>;
+}
+/** A set of test files that run together from one directory. */
+export interface RunnerProjectGroup {
+    cwd: string;
+    files: string[];
+}
+/** True when `dir` holds a Vitest or Jest configuration. */
+export declare function isRunnerProjectDir(dir: string): boolean;
+/**
+ * The nearest directory at or above `file` with runner configuration, searching no
+ * higher than `boundary`. Undefined when the file lies outside the boundary or
+ * no directory on the way has runner configuration.
+ */
+export declare function findRunnerProjectDir(file: string, boundary: string, cwd?: string, checked?: Map<string, boolean>): string | undefined;
+/**
+ * Directory to start the runner in for `file`: its runner project, unless the
+ * current directory is already inside that project (or none is found), in
+ * which case the current directory is kept.
+ */
+export declare function runnerCwdFor(file: string, options?: RunnerProjectOptions): string;
+/**
+ * Group `files` by the directory each must run from, in first-seen order.
+ * Files keep the spelling they were given.
+ */
+export declare function groupByRunnerProject(files: readonly string[], options?: RunnerProjectOptions): RunnerProjectGroup[];
+/** Test files to run, and the directory to run them from when the caller named one. */
+export interface TestRunTargets {
+    testFiles: string[];
+    projectRoot?: string;
+}
+/**
+ * Handler-side check for an execute-tests payload. `testFiles` must name
+ * files or directories inside the project (#1126). An explicit `projectRoot`
+ * must be a directory inside the project, checked by realpath so `..`, an
+ * outside absolute path or a symlink pointing out is refused; relative test
+ * files are then read from it, and every path is returned absolute.
+ */
+export declare function requireTestRunTargets(taskType: string, testFiles: unknown, projectRoot: unknown): Promise<Result<TestRunTargets, Error>>;
+//# sourceMappingURL=test-runner-project.d.ts.map