agentic-qe 3.15.14 → 3.15.16

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/integrations/agentic-flow/reasoning-bank/experience-replay.d.ts

@@ -41,6 +41,11 @@ export interface Experience {
     readonly avgTokenSavings: number;
     /** Embedding for similarity search */
     readonly embedding?: number[];
+    /**
+     * #1217: embedding-space identity (ADR-097 spaceId) the embedding was
+     * computed in. Only vectors from the active space are compared.
+     */
+    readonly embeddingSpaceId?: string;
     /** Creation timestamp */
     readonly createdAt: Date;
     /** Last applied timestamp */
@@ -135,6 +140,12 @@ export declare class ExperienceReplay {
     private idToExperienceId;
     private experienceIdToHnswId;
     private nextHnswId;
+    /**
+     * #1217: embedding space the HNSW index holds vectors of. The index only
+     * holds vectors of one space, so a similarity is never measured across
+     * spaces. Null until the embedder's space is known.
+     */
+    private indexSpaceId;
     private recentExperiences;
     private reservoirBuffer;
     private stats;
@@ -157,6 +168,10 @@ export declare class ExperienceReplay {
     /**
      * Load embeddings into HNSW index for O(log n) similarity search
      * Performance: 150x-12,500x faster than linear scan
+     *
+     * #1217: loads only vectors of the given embedding space, as the pattern
+     * banks do (ADR-097). Vectors of another space, or without provenance, are
+     * not comparable with a query embedded in this one.
      */
     private loadEmbeddingIndex;
     /**
@@ -245,6 +260,13 @@ export declare class ExperienceReplay {
     dispose(): Promise<void>;
     private ensureInitialized;
     private rowToExperience;
+    /**
+     * #1217: add a stored vector to the HNSW index. A vector of another
+     * embedding space re-binds the index to that space (the active one, since
+     * the vector was just computed): the rows of that space are reloaded,
+     * including this one.
+     */
+    private indexExperience;
     private floatArrayToBuffer;
     private bufferToFloatArray;
 }

package/dist/integrations/agentic-flow/reasoning-bank/experience-replay.js

@@ -14,8 +14,9 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import { getUnifiedMemory } from '../../../kernel/unified-memory.js';
-import { computeRealEmbedding, cosineSimilarity, } from '../../../learning/real-embeddings.js';
+import { computeRealEmbedding, cosineSimilarity, getActiveEmbeddingSpaceIdentity, } from '../../../learning/real-embeddings.js';
 import { EmbedderRecovery, probeEmbedder } from '../../../learning/embedder-recovery.js';
+import { verifyLegacyExperienceSpaces } from '../../../learning/experience-space-verification.js';
 import { CircularBuffer } from '../../../shared/utils/circular-buffer.js';
 import { HNSWEmbeddingIndex } from '../../embeddings/index/HNSWIndex.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
@@ -74,6 +75,12 @@ export class ExperienceReplay {
     idToExperienceId = new Map();
     experienceIdToHnswId = new Map();
     nextHnswId = 0;
+    /**
+     * #1217: embedding space the HNSW index holds vectors of. The index only
+     * holds vectors of one space, so a similarity is never measured across
+     * spaces. Null until the embedder's space is known.
+     */
+    indexSpaceId = null;
     // Recent experiences buffer
     recentExperiences;
     // Reservoir replay buffer (R10, ADR-087) — coherence-gated admission
@@ -130,7 +137,7 @@ export class ExperienceReplay {
         // Prepare statements
         this.prepareStatements();
         // Load embeddings into memory index
-        await this.loadEmbeddingIndex();
+        await this.loadEmbeddingIndex(getActiveEmbeddingSpaceIdentity()?.spaceId ?? null);
         // Backfill missing embeddings on captured_experiences. Hook-side INSERT
         // paths (sources: cli-hook-post-command, patch-060-post-task, etc.)
         // bypass storeExperience() and never call computeRealEmbedding(),
@@ -149,7 +156,7 @@ export class ExperienceReplay {
                     return;
                 const updateStmt = this.db.prepare(`
           UPDATE captured_experiences
-          SET embedding = ?, embedding_dimension = ?
+          SET embedding = ?, embedding_dimension = ?, embedding_space_id = ?
           WHERE id = ?
         `);
                 let written = 0;
@@ -157,21 +164,15 @@ export class ExperienceReplay {
                     // ADR-099: legacy rows may predate ingestion-time scrubbing
                     const text = scrubReasoningBlocks(`${row.domain ?? ''}: ${row.task}`).slice(0, 512);
                     const embedding = await computeRealEmbedding(text);
+                    const spaceId = getActiveEmbeddingSpaceIdentity()?.spaceId;
+                    // ADR-097: a vector without provenance would never be compared.
+                    if (!spaceId)
+                        break;
                     const buf = Buffer.from(new Float32Array(embedding).buffer);
-                    updateStmt.run(buf, embedding.length, row.id);
+                    // #1263: retried asynchronously, so a locked DB does not freeze the MCP server.
+                    await this.unifiedMemory.writeWhenUnlocked(() => updateStmt.run(buf, embedding.length, spaceId, row.id));
                     // Add to live HNSW so freshly-embedded rows are immediately searchable
-                    const hnswId = this.nextHnswId++;
-                    this.hnswIndex.addEmbedding({
-                        vector: embedding,
-                        dimension: 384,
-                        namespace: 'experiences',
-                        text: row.id,
-                        timestamp: Date.now(),
-                        quantization: 'none',
-                        metadata: {},
-                    }, hnswId);
-                    this.idToExperienceId.set(hnswId, row.id);
-                    this.experienceIdToHnswId.set(row.id, hnswId);
+                    this.indexExperience(row.id, embedding, spaceId);
                     written++;
                 }
                 console.log(`[ExperienceReplay] Backfilled ${written} captured_experiences embeddings`);
@@ -180,6 +181,30 @@ export class ExperienceReplay {
                 console.warn('[ExperienceReplay] Embedding backfill failed:', err instanceof Error ? err.message : err);
             }
         })();
+        // #1217: vectors stored before embedding-space provenance existed are
+        // never compared. Attribute those the active embedder reproduces to its
+        // space; the vectors themselves are never rewritten. Same cap per boot.
+        void (async () => {
+            try {
+                if (!this.db)
+                    return;
+                const result = await verifyLegacyExperienceSpaces(this.db, {
+                    embed: (text) => computeRealEmbedding(text, this.config.embedding),
+                    activeSpaceId: () => getActiveEmbeddingSpaceIdentity()?.spaceId,
+                    write: (fn) => this.unifiedMemory.writeWhenUnlocked(fn),
+                });
+                if (result.checked === 0)
+                    return;
+                if (result.stamped.length > 0 && result.spaceId) {
+                    await this.loadEmbeddingIndex(result.spaceId);
+                }
+                console.log(`[ExperienceReplay] Checked ${result.checked} experience vectors without an embedding space: ` +
+                    `${result.stamped.length} match the active embedder, ${result.left} left uncompared`);
+            }
+            catch (err) {
+                console.warn('[ExperienceReplay] Embedding-space check failed:', err instanceof Error ? err.message : err);
+            }
+        })();
         // Backfill missing embeddings on qe_trajectories. TrajectoryTracker.endTrajectory()
         // writes embedding=NULL with no follow-up worker; hook-side trajectory inserts
         // (cli-hook-post-task) also leave the column NULL. Without this, kNN over
@@ -206,7 +231,7 @@ export class ExperienceReplay {
                     // ADR-099: legacy rows may predate ingestion-time scrubbing
                     const text = scrubReasoningBlocks(`${row.domain ?? ''}: ${row.task}`).slice(0, 512);
                     const embedding = await computeRealEmbedding(text);
-                    updateStmt.run(Buffer.from(new Float32Array(embedding).buffer), row.id);
+                    await this.unifiedMemory.writeWhenUnlocked(() => updateStmt.run(Buffer.from(new Float32Array(embedding).buffer), row.id));
                     written++;
                 }
                 console.log(`[ExperienceReplay] Backfilled ${written} qe_trajectories embeddings`);
@@ -254,6 +279,7 @@ export class ExperienceReplay {
         avg_token_savings REAL DEFAULT 0,
         embedding BLOB,
         embedding_dimension INTEGER,
+        embedding_space_id TEXT,
         tags TEXT,
         last_applied_at TEXT
       );
@@ -269,6 +295,8 @@ export class ExperienceReplay {
             ['avg_token_savings', 'REAL DEFAULT 0'],
             ['embedding', 'BLOB'],
             ['embedding_dimension', 'INTEGER'],
+            // #1217: embedding-space identity of the stored vector (ADR-097)
+            ['embedding_space_id', 'TEXT'],
             ['tags', 'TEXT'],
             ['last_applied_at', 'TEXT'],
             // Consolidation columns (experience-consolidation system)
@@ -320,8 +348,8 @@ export class ExperienceReplay {
         this.prepared.set('insertExperience', this.db.prepare(`
       INSERT INTO captured_experiences (
         id, task, agent, domain, success, quality, duration_ms,
-        steps_json, routing_json, embedding, embedding_dimension, tags, source
-      ) VALUES (?, ?, ?, ?, 1, ?, 0, ?, ?, ?, ?, ?, 'experience-replay')
+        steps_json, routing_json, embedding, embedding_dimension, embedding_space_id, tags, source
+      ) VALUES (?, ?, ?, ?, 1, ?, 0, ?, ?, ?, ?, ?, ?, 'experience-replay')
     `));
         this.prepared.set('getExperience', this.db.prepare(`
       SELECT * FROM captured_experiences WHERE id = ?
@@ -333,7 +361,8 @@ export class ExperienceReplay {
       SELECT * FROM captured_experiences WHERE consolidated_into IS NULL ORDER BY quality DESC LIMIT ?
     `));
         this.prepared.set('getAllEmbeddings', this.db.prepare(`
-      SELECT id, embedding, embedding_dimension FROM captured_experiences WHERE embedding IS NOT NULL AND consolidated_into IS NULL
+      SELECT id, embedding, embedding_dimension FROM captured_experiences
+      WHERE embedding IS NOT NULL AND embedding_space_id = ? AND consolidated_into IS NULL
     `));
         this.prepared.set('updateApplication', this.db.prepare(`
       UPDATE captured_experiences SET
@@ -353,17 +382,22 @@ export class ExperienceReplay {
     /**
      * Load embeddings into HNSW index for O(log n) similarity search
      * Performance: 150x-12,500x faster than linear scan
+     *
+     * #1217: loads only vectors of the given embedding space, as the pattern
+     * banks do (ADR-097). Vectors of another space, or without provenance, are
+     * not comparable with a query embedded in this one.
      */
-    async loadEmbeddingIndex() {
+    async loadEmbeddingIndex(spaceId) {
         const stmt = this.prepared.get('getAllEmbeddings');
         if (!stmt)
             return;
-        const rows = stmt.all();
+        const rows = (spaceId ? stmt.all(spaceId) : []);
         // Clear existing mappings
         this.idToExperienceId.clear();
         this.experienceIdToHnswId.clear();
         this.hnswIndex.clearIndex('experiences');
         this.nextHnswId = 0;
+        this.indexSpaceId = spaceId;
         // Build HNSW index with all embeddings
         for (const row of rows) {
             if (row.embedding && row.embedding_dimension) {
@@ -413,6 +447,8 @@ export class ExperienceReplay {
         // Generate embedding for similarity search
         const embeddingText = `${task} ${strategy} ${keyActions.join(' ')}`;
         const embedding = (await this.embedOrNull(embeddingText)) ?? undefined;
+        // ADR-097: a vector is kept only with the space it was computed in.
+        const embeddingSpaceId = embedding ? getActiveEmbeddingSpaceIdentity()?.spaceId : undefined;
         const id = uuidv4();
         const domain = trajectory.domain || 'test-generation';
         const experience = {
@@ -426,7 +462,8 @@ export class ExperienceReplay {
             applicationCount: 0,
             successRate: 1.0,
             avgTokenSavings: 0,
-            embedding,
+            embedding: embeddingSpaceId ? embedding : undefined,
+            embeddingSpaceId,
             createdAt: new Date(),
             originalMetrics: trajectory.metrics,
             tags,
@@ -434,27 +471,17 @@ export class ExperienceReplay {
         // Store in captured_experiences table
         const insertStmt = this.prepared.get('insertExperience');
         if (insertStmt) {
-            const embeddingBuffer = embedding ? this.floatArrayToBuffer(embedding) : null;
-            insertStmt.run(id, task, strategy, // agent column stores strategy
+            const embeddingBuffer = experience.embedding ? this.floatArrayToBuffer(experience.embedding) : null;
+            // Queued (#1274): runs when task completion events end a trajectory.
+            const run = () => insertStmt.run(id, task, strategy, // agent column stores strategy
             domain, trajectory.metrics.efficiencyScore, JSON.stringify(keyActions), // steps_json stores key actions
             JSON.stringify(trajectory.metrics), // routing_json stores original metrics
-            embeddingBuffer, embedding?.length ?? null, JSON.stringify(tags));
+            embeddingBuffer, experience.embedding?.length ?? null, embeddingSpaceId ?? null, JSON.stringify(tags));
+            await (this.unifiedMemory ? this.unifiedMemory.writeWhenUnlocked(run) : run());
         }
         // Add to HNSW index for fast similarity search
-        if (embedding) {
-            const hnswId = this.nextHnswId++;
-            const iEmbedding = {
-                vector: embedding,
-                dimension: 384,
-                namespace: 'experiences',
-                text: id, // Use ID as text identifier
-                timestamp: Date.now(),
-                quantization: 'none',
-                metadata: {},
-            };
-            this.hnswIndex.addEmbedding(iEmbedding, hnswId);
-            this.idToExperienceId.set(hnswId, id);
-            this.experienceIdToHnswId.set(id, hnswId);
+        if (experience.embedding && embeddingSpaceId) {
+            this.indexExperience(id, experience.embedding, embeddingSpaceId);
         }
         // Add to recent buffer
         this.recentExperiences.push(experience);
@@ -515,7 +542,9 @@ export class ExperienceReplay {
         // #1022: without an embedding of the query nothing measures relevance, so
         // return no guidance rather than picks with a made-up similarity.
         const queryEmbedding = await this.embedOrNull(scrubReasoningBlocks(task));
-        if (!queryEmbedding) {
+        // #1217: the query's embedding space; only vectors of it are compared.
+        const querySpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId;
+        if (!queryEmbedding || !querySpaceId) {
             return null;
         }
         // Find similar experiences via HNSW
@@ -535,7 +564,11 @@ export class ExperienceReplay {
                 // Skip if domain filter doesn't match
                 if (domain && exp.domain !== domain)
                     continue;
-                if (!exp.embedding || exp.embedding.length !== queryEmbedding.length)
+                // #1217: a vector from another embedding space (even of the same
+                // dimension), or without provenance, has no comparable similarity.
+                if (!exp.embedding || exp.embeddingSpaceId !== querySpaceId)
+                    continue;
+                if (exp.embedding.length !== queryEmbedding.length)
                     continue;
                 const similarity = cosineSimilarity(queryEmbedding, exp.embedding);
                 if (similarity < this.config.similarityThreshold)
@@ -600,8 +633,9 @@ export class ExperienceReplay {
     async findSimilarExperiences(task, domain, limit) {
         this.ensureInitialized();
         const k = limit ?? this.config.topK;
-        // Check if index is empty
-        if (this.idToExperienceId.size === 0) {
+        // Check if index is empty (and bound to the active embedding space)
+        const knownSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? null;
+        if (this.idToExperienceId.size === 0 && knownSpaceId !== null && knownSpaceId === this.indexSpaceId) {
             return [];
         }
         // Generate embedding for the task
@@ -611,6 +645,16 @@ export class ExperienceReplay {
         if (!taskEmbedding) {
             return [];
         }
+        // #1217: search only vectors of the query's embedding space.
+        const querySpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? null;
+        if (!querySpaceId)
+            return [];
+        if (querySpaceId !== this.indexSpaceId) {
+            await this.loadEmbeddingIndex(querySpaceId);
+        }
+        if (this.idToExperienceId.size === 0) {
+            return [];
+        }
         // Create query embedding for HNSW search
         const queryEmbedding = {
             vector: taskEmbedding,
@@ -722,7 +766,7 @@ export class ExperienceReplay {
                 // Remove HNSW mappings for absorbed experiences
                 if (result.merged > 0) {
                     // Reload HNSW index to reflect consolidated state
-                    await this.loadEmbeddingIndex();
+                    await this.loadEmbeddingIndex(this.indexSpaceId);
                 }
                 console.log(`[ExperienceReplay] Auto-consolidated ${domain}: ` +
                     `${result.merged} merged, ${result.archived} archived`);
@@ -815,12 +859,38 @@ export class ExperienceReplay {
             embedding: row.embedding && row.embedding_dimension
                 ? this.bufferToFloatArray(row.embedding, row.embedding_dimension)
                 : undefined,
+            embeddingSpaceId: row.embedding_space_id ?? undefined,
             createdAt: new Date(row.started_at),
             lastAppliedAt: row.last_applied_at ? new Date(row.last_applied_at) : undefined,
             originalMetrics: safeJsonParse(row.routing_json || '{}'),
             tags: safeJsonParse(row.tags || '[]'),
         };
     }
+    /**
+     * #1217: add a stored vector to the HNSW index. A vector of another
+     * embedding space re-binds the index to that space (the active one, since
+     * the vector was just computed): the rows of that space are reloaded,
+     * including this one.
+     */
+    indexExperience(id, embedding, spaceId) {
+        if (spaceId !== this.indexSpaceId) {
+            void this.loadEmbeddingIndex(spaceId);
+            return;
+        }
+        const hnswId = this.nextHnswId++;
+        const iEmbedding = {
+            vector: embedding,
+            dimension: 384,
+            namespace: 'experiences',
+            text: id, // Use ID as text identifier
+            timestamp: Date.now(),
+            quantization: 'none',
+            metadata: {},
+        };
+        this.hnswIndex.addEmbedding(iEmbedding, hnswId);
+        this.idToExperienceId.set(hnswId, id);
+        this.experienceIdToHnswId.set(id, hnswId);
+    }
     floatArrayToBuffer(arr) {
         const buffer = Buffer.alloc(arr.length * 4);
         for (let i = 0; i < arr.length; i++) {

package/dist/integrations/agentic-flow/reasoning-bank/pattern-evolution.d.ts

@@ -231,6 +231,12 @@ export declare class PatternEvolution {
      * Record an evolution event
      */
     private recordEvent;
+    /**
+     * Run a write through the shared connection's writeWhenUnlocked queue, so a
+     * locked memory.db does not freeze the MCP server's event loop while the
+     * hourly consolidation timer merges and prunes patterns (#1274).
+     */
+    private write;
     /**
      * Get statistics
      */

package/dist/integrations/agentic-flow/reasoning-bank/pattern-evolution.js

@@ -223,31 +223,38 @@ export class PatternEvolution {
      */
     async trackVersion(patternId, embedding, changes = [], trigger = 'manual') {
         this.ensureInitialized();
-        // Get current version count
-        const countStmt = this.prepared.get('getVersionCount');
-        const countResult = countStmt?.get(patternId);
-        const newVersion = (countResult?.count ?? 0) + 1;
-        // Get pattern quality/success rate
-        const patternStmt = this.prepared.get('getPattern');
-        const pattern = patternStmt?.get(patternId);
         const id = uuidv4();
-        const version = {
-            id,
-            patternId,
-            version: newVersion,
-            embedding,
-            changes,
-            qualityScore: pattern?.quality_score ?? 0.5,
-            successRate: pattern?.success_rate ?? 0.5,
-            timestamp: new Date(),
-            trigger,
-        };
-        // Store in database
-        const insertStmt = this.prepared.get('insertVersion');
-        if (insertStmt) {
-            const embeddingBuffer = this.floatArrayToBuffer(embedding);
-            insertStmt.run(id, patternId, newVersion, embeddingBuffer, embedding.length, JSON.stringify(changes), version.qualityScore, version.successRate, trigger);
-        }
+        const embeddingBuffer = this.floatArrayToBuffer(embedding);
+        // #1283: read the version count and insert the new version as one queued
+        // unit, so a locked memory.db does not freeze the MCP server and two
+        // concurrent calls cannot both claim the same version number.
+        const version = await this.write(() => {
+            // Get current version count
+            const countStmt = this.prepared.get('getVersionCount');
+            const countResult = countStmt?.get(patternId);
+            const newVersion = (countResult?.count ?? 0) + 1;
+            // Get pattern quality/success rate
+            const patternStmt = this.prepared.get('getPattern');
+            const pattern = patternStmt?.get(patternId);
+            const tracked = {
+                id,
+                patternId,
+                version: newVersion,
+                embedding,
+                changes,
+                qualityScore: pattern?.quality_score ?? 0.5,
+                successRate: pattern?.success_rate ?? 0.5,
+                timestamp: new Date(),
+                trigger,
+            };
+            // Store in database
+            const insertStmt = this.prepared.get('insertVersion');
+            if (insertStmt) {
+                insertStmt.run(id, patternId, newVersion, embeddingBuffer, embedding.length, JSON.stringify(changes), tracked.qualityScore, tracked.successRate, trigger);
+            }
+            return tracked;
+        });
+        const newVersion = version.version;
         // Update embedding cache
         this.embeddingCache.set(patternId, embedding);
         // Record evolution event
@@ -429,7 +436,8 @@ export class PatternEvolution {
      */
     async mergePatterns(patternId1, patternId2, mergedName) {
         this.ensureInitialized();
-        if (!this.db)
+        const db = this.db;
+        if (!db)
             return null;
         const patternStmt = this.prepared.get('getPattern');
         const p1 = patternStmt?.get(patternId1);
@@ -442,13 +450,13 @@ export class PatternEvolution {
             : [p2, p1];
         // Update retained pattern name if provided
         if (mergedName) {
-            this.db.prepare(`UPDATE qe_patterns SET name = ? WHERE id = ?`).run(mergedName, retained.id);
+            await this.write(() => db.prepare(`UPDATE qe_patterns SET name = ? WHERE id = ?`).run(mergedName, retained.id));
         }
         // Combine usage counts and recalculate success rate
         const totalUsage = (retained.usage_count ?? 0) + (archived.usage_count ?? 0);
         const totalSuccess = (retained.successful_uses ?? 0) + (archived.successful_uses ?? 0);
         const newSuccessRate = totalUsage > 0 ? totalSuccess / totalUsage : 0;
-        this.db.prepare(`
+        await this.write(() => db.prepare(`
       UPDATE qe_patterns SET
         usage_count = ?,
         successful_uses = ?,
@@ -460,14 +468,15 @@ export class PatternEvolution {
         END,
         updated_at = datetime('now')
       WHERE id = ?
-    `).run(totalUsage, totalSuccess, newSuccessRate, archived.last_used_at, archived.last_used_at, archived.last_used_at, retained.id);
+    `).run(totalUsage, totalSuccess, newSuccessRate, archived.last_used_at, archived.last_used_at, archived.last_used_at, retained.id));
         // Record merge relationship
         const relStmt = this.prepared.get('insertRelationship');
         if (relStmt) {
-            relStmt.run(uuidv4(), archived.id, retained.id, 'merged', 1.0);
+            const relId = uuidv4();
+            await this.write(() => relStmt.run(relId, archived.id, retained.id, 'merged', 1.0));
         }
         // Archive the lower quality pattern (mark as archived)
-        this.db.prepare(`UPDATE qe_patterns SET tier = 'archived' WHERE id = ?`).run(archived.id);
+        await this.write(() => db.prepare(`UPDATE qe_patterns SET tier = 'archived' WHERE id = ?`).run(archived.id));
         // Record events
         await this.recordEvent(retained.id, 'merged', { absorbedFrom: archived.id });
         await this.recordEvent(archived.id, 'archived', { mergedInto: retained.id });
@@ -497,8 +506,9 @@ export class PatternEvolution {
         for (const candidate of pruneCandidates) {
             if (candidate.reason === 'low-quality' || candidate.reason === 'obsolete') {
                 // Actually delete the pattern
-                if (this.db) {
-                    this.db.prepare(`DELETE FROM qe_patterns WHERE id = ?`).run(candidate.patternId);
+                const db = this.db;
+                if (db) {
+                    await this.write(() => db.prepare(`DELETE FROM qe_patterns WHERE id = ?`).run(candidate.patternId));
                     this.embeddingCache.delete(candidate.patternId);
                     await this.recordEvent(candidate.patternId, 'pruned', { reason: candidate.reason });
                     pruned++;
@@ -560,10 +570,18 @@ export class PatternEvolution {
                 details,
                 timestamp: new Date(),
             };
-            insertStmt.run(event.id, patternId, eventType, JSON.stringify(details));
+            await this.write(() => insertStmt.run(event.id, patternId, eventType, JSON.stringify(details)));
             this.recentEvents.push(event);
         }
     }
+    /**
+     * Run a write through the shared connection's writeWhenUnlocked queue, so a
+     * locked memory.db does not freeze the MCP server's event loop while the
+     * hourly consolidation timer merges and prunes patterns (#1274).
+     */
+    write(fn) {
+        return this.unifiedMemory ? this.unifiedMemory.writeWhenUnlocked(fn) : Promise.resolve(fn());
+    }
     /**
      * Get statistics
      */