agentic-qe 3.15.14 → 3.15.15

package/dist/integrations/agent-booster-wasm/index.d.ts

@@ -41,6 +41,14 @@ export interface TransformOptions {
     maxChunks?: number;
     allowFallback?: boolean;
 }
+/**
+ * Locate the wasm-bindgen glue (#1241). A relative require resolved against
+ * the bundle's directory (dist/mcp/ or dist/cli/chunks/), where the glue does
+ * not exist, so WASM never loaded from the published package. Look next to
+ * this module first (unbundled src/ or dist/), then in the copy the build
+ * places under dist/integrations/agent-booster-wasm/ in the package root.
+ */
+export declare function resolveWasmGlue(metaUrl?: string): string | null;
 /**
  * Map file extension to Language enum
  */

package/dist/integrations/agent-booster-wasm/index.js

@@ -8,7 +8,11 @@
  * Accuracy: 81% (13/16 test cases)
  */
 import { createRequire } from 'module';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { LoggerFactory } from '../../logging/index.js';
+import { findPackageRoot } from '../../init/find-package-root.js';
 const logger = LoggerFactory.create('agent-booster-wasm');
 // Language constants (const object instead of enum for ESM compatibility)
 // This pattern works consistently across tsx dev mode, node, and bundled builds
@@ -45,6 +49,21 @@ const LanguageNames = {
 let wasmModule = null;
 let wasmBooster = null;
 let loadError = null;
+const GLUE_FILE = 'agent_booster_wasm.js';
+/**
+ * Locate the wasm-bindgen glue (#1241). A relative require resolved against
+ * the bundle's directory (dist/mcp/ or dist/cli/chunks/), where the glue does
+ * not exist, so WASM never loaded from the published package. Look next to
+ * this module first (unbundled src/ or dist/), then in the copy the build
+ * places under dist/integrations/agent-booster-wasm/ in the package root.
+ */
+export function resolveWasmGlue(metaUrl = import.meta.url) {
+    const candidates = [join(dirname(fileURLToPath(metaUrl)), GLUE_FILE)];
+    const root = findPackageRoot(metaUrl);
+    if (root)
+        candidates.push(join(root, 'dist', 'integrations', 'agent-booster-wasm', GLUE_FILE));
+    return candidates.find((p) => existsSync(p)) ?? null;
+}
 /**
  * Load the WASM module
  */
@@ -54,9 +73,13 @@ async function loadWasm() {
     if (loadError)
         return false;
     try {
-        // Use createRequire for ESM compatibility
+        const gluePath = resolveWasmGlue();
+        if (!gluePath) {
+            throw new Error(`${GLUE_FILE} not found next to the module or under dist/integrations/agent-booster-wasm/`);
+        }
+        // The glue is CommonJS (it reads the .wasm via __dirname), so load it with require.
         const require = createRequire(import.meta.url);
-        wasmModule = require('./agent_booster_wasm.js');
+        wasmModule = require(gluePath);
         if (!wasmModule) {
             throw new Error('WASM module loaded but is null');
         }

package/dist/integrations/agent-booster-wasm/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "agent-booster-wasm",
+  "collaborators": [
+    "Agent Booster Team"
+  ],
+  "description": "WebAssembly bindings for agent-booster",
+  "version": "0.1.0",
+  "license": "MIT",
+  "files": [
+    "agent_booster_wasm_bg.wasm",
+    "agent_booster_wasm.js",
+    "agent_booster_wasm.d.ts"
+  ],
+  "main": "agent_booster_wasm.js",
+  "types": "agent_booster_wasm.d.ts"
+}

package/dist/learning/dream/dream-engine.d.ts

@@ -212,9 +212,10 @@ export declare class DreamEngine {
      * #1060: write the results of a `dream(…, { commit: false })` run, in the
      * same single transaction a normal dream uses. Returns the commit duration
      * in ms. Throws (and writes nothing) if the engine is closed or the write
-     * fails.
+     * fails. #1253: async, because a locked database is retried without
+     * blocking the process.
      */
-    commitDreamResult(result: DreamCycleResult): number;
+    commitDreamResult(result: DreamCycleResult): Promise<number>;
     /**
      * Commit a computed dream, then record it in the witness chain (#1060) and
      * run the default retention steps (#1239).

package/dist/learning/dream/dream-engine.js

@@ -31,6 +31,7 @@ import { v4 as uuidv4 } from 'uuid';
 import { getUnifiedPersistence } from '../../kernel/unified-persistence.js';
 import { registerStoreCloser } from '../../kernel/process-lifecycle.js';
 import { ConceptGraph } from './concept-graph.js';
+import { DREAM_LOCK_WAIT_MS, DREAM_SHUTDOWN_LOCK_WAIT_MS, isBusyError, retryWhileBusy, withBusyTimeout, } from './dream-lock-retry.js';
 import { SpreadingActivation, } from './spreading-activation.js';
 import { InsightGenerator, } from './insight-generator.js';
 import { DEFAULT_VALIDATION_THRESHOLDS, } from './rvcow-branch-manager.js';
@@ -277,16 +278,14 @@ export class DreamEngine {
                 await this.persistence.initialize();
             }
             this.db = this.persistence.getDatabase();
-            // ADR-001 Option C: dynamic-import paths in checkAndTriggerDream() open
-            // a fresh handle that the hook/worker busy_timeout pragmas never reach.
-            // 60s patient timeout here keeps dream cycles from failing under WAL
-            // contention from MCP workers (was 71% failure rate observed).
-            try {
-                this.db.pragma('busy_timeout = 60000');
-            }
-            catch { /* fail-soft */ }
-            // Migrate legacy schema: rename 'duration' → 'duration_ms' if needed
-            this.migrateSchema();
+            // #1253: no 60 s busy_timeout on this shared connection. better-sqlite3
+            // waits synchronously, so it froze the whole process (the MCP event loop)
+            // while another writer held the database. Dream writes instead wait
+            // briefly per attempt and retry asynchronously (dream-lock-retry.ts),
+            // which keeps the patience that avoided failures under contention (#1060).
+            // Migrate legacy schema: rename 'duration' → 'duration_ms' if needed.
+            // #1253: a short lock wait only; migrateSchema() logs and carries on.
+            withBusyTimeout(this.db, DREAM_LOCK_WAIT_MS, () => this.migrateSchema());
             // Initialize concept graph (shares same unified persistence)
             this.graph = new ConceptGraph();
             await this.graph.initialize();
@@ -296,9 +295,19 @@ export class DreamEngine {
                     'committed in one short transaction instead of a SAVEPOINT held across the dream');
             }
             // #1060: a process that exited mid-dream left its cycle 'running'.
-            const abandoned = markAbandonedCycles(this.db, Math.max(this.config.maxDurationMs, MAX_TOOL_DREAM_MS) + ABANDONED_CYCLE_GRACE_MS);
-            if (abandoned > 0) {
-                dreamLogger.info('Marked abandoned dream cycles as interrupted', { abandoned });
+            // #1253: housekeeping, so a locked database skips it after a short
+            // wait instead of blocking the process; the next initialize() retries.
+            const db = this.db;
+            try {
+                const abandoned = withBusyTimeout(db, DREAM_LOCK_WAIT_MS, () => markAbandonedCycles(db, Math.max(this.config.maxDurationMs, MAX_TOOL_DREAM_MS) + ABANDONED_CYCLE_GRACE_MS));
+                if (abandoned > 0) {
+                    dreamLogger.info('Marked abandoned dream cycles as interrupted', { abandoned });
+                }
+            }
+            catch (error) {
+                if (!isBusyError(error))
+                    throw error;
+                dreamLogger.warn('Abandoned dream cycle sweep skipped: database is locked', { error: toErrorMessage(error) });
             }
             this.initialized = true;
             this.closing = false;
@@ -433,7 +442,7 @@ export class DreamEngine {
         let committed = false;
         try {
             if (commitResults)
-                await this.saveCycle(cycle);
+                await this.saveCycle(cycle, live);
             if (!live())
                 throw new Error('Dream cycle cancelled');
             // 1. Check we have enough concepts
@@ -483,7 +492,7 @@ export class DreamEngine {
                 committed = true; // nothing to record: the caller decides
                 return { ...result, pending: computed };
             }
-            const commit = this.commitComputed(db, computed);
+            const commit = await this.commitComputed(db, computed, live);
             committed = true;
             result.commitDurationMs = commit.durationMs;
             result.retention = commit.retention;
@@ -499,7 +508,7 @@ export class DreamEngine {
                 cycle.durationMs = Date.now() - startTime;
                 if (commitResults && this.db === db) {
                     try {
-                        this.updateCycleSync(cycle);
+                        await retryWhileBusy(db, () => this.updateCycleSync(cycle), { shouldContinue: () => this.db === db });
                     }
                     catch { /* best effort */ }
                 }
@@ -528,9 +537,10 @@ export class DreamEngine {
      * #1060: write the results of a `dream(…, { commit: false })` run, in the
      * same single transaction a normal dream uses. Returns the commit duration
      * in ms. Throws (and writes nothing) if the engine is closed or the write
-     * fails.
+     * fails. #1253: async, because a locked database is retried without
+     * blocking the process.
      */
-    commitDreamResult(result) {
+    async commitDreamResult(result) {
         this.ensureInitialized();
         if (this.closing) {
             throw new Error('Dream engine is closing; nothing is committed');
@@ -538,7 +548,8 @@ export class DreamEngine {
         if (!result.pending) {
             throw new Error('Dream result has nothing pending to commit (it was already committed)');
         }
-        const commit = this.commitComputed(this.db, result.pending);
+        const db = this.db;
+        const commit = await this.commitComputed(db, result.pending, () => !this.closing && this.db === db);
         result.pending = undefined;
         result.commitDurationMs = commit.durationMs;
         result.retention = commit.retention;
@@ -548,8 +559,12 @@ export class DreamEngine {
      * Commit a computed dream, then record it in the witness chain (#1060) and
      * run the default retention steps (#1239).
      */
-    commitComputed(db, computed) {
-        const commit = commitDream(db, computed);
+    async commitComputed(db, computed, live) {
+        // #1253: retry a locked database asynchronously; each attempt is short.
+        const commit = await retryWhileBusy(db, () => commitDream(db, computed), {
+            shouldContinue: live,
+            cancelledError: () => new Error('Dream cycle cancelled'),
+        });
         try {
             this._witnessChain?.append('DREAM_COMMIT', {
                 cycleId: computed.cycle.id,
@@ -613,7 +628,9 @@ export class DreamEngine {
             cycle.endTime = new Date();
             cycle.durationMs = Date.now() - startTime;
             try {
-                this.updateCycleSync(cycle);
+                // #1253: a short wait only; if the database stays locked, the
+                // abandoned-cycle sweep marks the cycle interrupted later.
+                withBusyTimeout(this.db, DREAM_SHUTDOWN_LOCK_WAIT_MS, () => this.updateCycleSync(cycle));
             }
             catch {
                 // Best effort during shutdown
@@ -912,16 +929,17 @@ export class DreamEngine {
     // ==========================================================================
     // Persistence
     // ==========================================================================
-    async saveCycle(cycle) {
+    async saveCycle(cycle, live) {
         if (!this.db)
             return;
+        const db = this.db;
         const stmt = this.db.prepare(`
       INSERT INTO dream_cycles
       (id, start_time, end_time, duration_ms, concepts_processed, associations_found,
        insights_generated, status, error, created_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
-        stmt.run(cycle.id, cycle.startTime.toISOString(), cycle.endTime?.toISOString() ?? null, cycle.durationMs ?? null, cycle.conceptsProcessed, cycle.associationsFound, cycle.insightsGenerated, cycle.status, cycle.error ?? null, cycle.startTime.toISOString());
+        await retryWhileBusy(db, () => stmt.run(cycle.id, cycle.startTime.toISOString(), cycle.endTime?.toISOString() ?? null, cycle.durationMs ?? null, cycle.conceptsProcessed, cycle.associationsFound, cycle.insightsGenerated, cycle.status, cycle.error ?? null, cycle.startTime.toISOString()), { shouldContinue: live, cancelledError: () => new Error('Dream cycle cancelled') });
     }
     updateCycleSync(cycle) {
         if (!this.db)

package/dist/learning/dream/dream-lock-retry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Lock waits for dream writes (#1253).
+ *
+ * better-sqlite3 waits for a locked database synchronously, so a long
+ * busy_timeout freezes the whole process: in the MCP server that is the event
+ * loop and every tool call. Dream writes therefore wait only briefly per
+ * attempt and retry asynchronously, so other work runs between attempts.
+ */
+import type { Database as DatabaseType } from 'better-sqlite3';
+/** Longest a single dream write attempt blocks the process on a locked database. */
+export declare const DREAM_LOCK_WAIT_MS = 200;
+/** Total time a dream write keeps retrying a locked database before it fails. */
+export declare const DREAM_LOCK_RETRY_BUDGET_MS = 60000;
+/** True for SQLite "database is locked" / "busy" failures. */
+export declare function isBusyError(error: unknown): boolean;
+/** Run `fn` with a temporary busy_timeout, restoring the connection's previous value. */
+export declare function withBusyTimeout<T>(db: DatabaseType, timeoutMs: number, fn: () => T): T;
+export interface RetryWhileBusyOptions {
+    /** Synchronous wait per attempt (default DREAM_LOCK_WAIT_MS). */
+    waitMs?: number;
+    /** Total retry time before the busy error is thrown (default DREAM_LOCK_RETRY_BUDGET_MS). */
+    budgetMs?: number;
+    /** Checked before every attempt; when false, `cancelledError` is thrown instead of retrying. */
+    shouldContinue?: () => boolean;
+    cancelledError?: () => Error;
+    /** Injectable for tests. */
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}
+/**
+ * Run a synchronous write, retrying while the database is locked. Each attempt
+ * blocks for at most `waitMs`; between attempts the event loop is free. Errors
+ * other than a busy database are thrown at once.
+ */
+export declare function retryWhileBusy<T>(db: DatabaseType, fn: () => T, options?: RetryWhileBusyOptions): Promise<T>;
+/** Wait for the synchronous best-effort write made while a dream is interrupted at shutdown. */
+export declare const DREAM_SHUTDOWN_LOCK_WAIT_MS = 1000;
+//# sourceMappingURL=dream-lock-retry.d.ts.map

package/dist/learning/dream/dream-lock-retry.js

@@ -0,0 +1,66 @@
+/**
+ * Lock waits for dream writes (#1253).
+ *
+ * better-sqlite3 waits for a locked database synchronously, so a long
+ * busy_timeout freezes the whole process: in the MCP server that is the event
+ * loop and every tool call. Dream writes therefore wait only briefly per
+ * attempt and retry asynchronously, so other work runs between attempts.
+ */
+/** Longest a single dream write attempt blocks the process on a locked database. */
+export const DREAM_LOCK_WAIT_MS = 200;
+/** Total time a dream write keeps retrying a locked database before it fails. */
+export const DREAM_LOCK_RETRY_BUDGET_MS = 60_000;
+/** Longest pause between attempts; the pause doubles from 25 ms up to this. */
+const MAX_BACKOFF_MS = 1000;
+/** True for SQLite "database is locked" / "busy" failures. */
+export function isBusyError(error) {
+    const code = error?.code;
+    if (typeof code === 'string' && /^SQLITE_(BUSY|LOCKED)/.test(code))
+        return true;
+    const message = error instanceof Error ? error.message : String(error);
+    return /database is locked|database table is locked|SQLITE_BUSY/i.test(message);
+}
+/** Run `fn` with a temporary busy_timeout, restoring the connection's previous value. */
+export function withBusyTimeout(db, timeoutMs, fn) {
+    const previous = db.pragma('busy_timeout', { simple: true });
+    db.pragma(`busy_timeout = ${timeoutMs}`);
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            db.pragma(`busy_timeout = ${previous}`);
+        }
+        catch { /* connection closed */ }
+    }
+}
+/**
+ * Run a synchronous write, retrying while the database is locked. Each attempt
+ * blocks for at most `waitMs`; between attempts the event loop is free. Errors
+ * other than a busy database are thrown at once.
+ */
+export async function retryWhileBusy(db, fn, options = {}) {
+    const waitMs = options.waitMs ?? DREAM_LOCK_WAIT_MS;
+    const budgetMs = options.budgetMs ?? DREAM_LOCK_RETRY_BUDGET_MS;
+    const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const now = options.now ?? Date.now;
+    const started = now();
+    let backoff = 25;
+    for (;;) {
+        if (options.shouldContinue && !options.shouldContinue()) {
+            throw options.cancelledError?.() ?? new Error('Cancelled while waiting for a locked database');
+        }
+        try {
+            return withBusyTimeout(db, waitMs, fn);
+        }
+        catch (error) {
+            if (!isBusyError(error) || now() - started + backoff >= budgetMs)
+                throw error;
+        }
+        await sleep(backoff);
+        backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
+    }
+}
+/** Wait for the synchronous best-effort write made while a dream is interrupted at shutdown. */
+export const DREAM_SHUTDOWN_LOCK_WAIT_MS = 1000;
+//# sourceMappingURL=dream-lock-retry.js.map

package/dist/learning/dream/speculative-dreamer.js

@@ -117,7 +117,7 @@ export class SpeculativeDreamer {
         let commitDurationMs;
         if (winner?.result) {
             try {
-                commitDurationMs = this.engine.commitDreamResult(winner.result);
+                commitDurationMs = await this.engine.commitDreamResult(winner.result);
                 winner.selected = true;
             }
             catch (error) {