agentic-qe 3.15.15 → 3.15.16

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
      */

package/dist/integrations/agentic-flow/reasoning-bank/trajectory-tracker.js

@@ -75,7 +75,7 @@ export class TrajectoryTracker {
         // Load recent trajectories into buffer
         await this.loadRecentTrajectories();
         // Clean up orphaned trajectories from previous sessions (started > 1 hour ago, never completed)
-        this.cleanupOrphanedTrajectories();
+        await this.cleanupOrphanedTrajectories();
         this.initialized = true;
         console.log('[TrajectoryTracker] Initialized');
     }
@@ -83,18 +83,20 @@ export class TrajectoryTracker {
      * Clean up orphaned trajectories that were started but never completed.
      * Marks them as failed with an auto-close reason. Runs at initialization.
      */
-    cleanupOrphanedTrajectories() {
-        if (!this.db)
+    async cleanupOrphanedTrajectories() {
+        const db = this.db;
+        if (!db || !this.unifiedMemory)
             return;
         try {
-            const result = this.db.prepare(`
+            // #1263: retried asynchronously, so a locked DB does not freeze the MCP server.
+            const result = await this.unifiedMemory.writeWhenUnlocked(() => db.prepare(`
         UPDATE qe_trajectories
         SET success = 0,
             ended_at = datetime('now'),
             feedback = 'auto-closed: orphaned trajectory from previous session'
         WHERE success IS NULL
           AND started_at < datetime('now', '-1 hour')
-      `).run();
+      `).run());
             if (result.changes > 0) {
                 this.stats.trajectoriesAbandoned += result.changes;
                 console.log(`[TrajectoryTracker] Cleaned up ${result.changes} orphaned trajectories`);
@@ -238,10 +240,13 @@ export class TrajectoryTracker {
             startedAt,
             context: options.context,
         });
-        // Persist to SQLite
+        // Persist to SQLite. Queued (#1283): task_orchestrate starts a trajectory
+        // inside the tool call, and a locked memory.db must not freeze the MCP
+        // server's event loop. The later end update queues after this insert.
         const insertStmt = this.prepared.get('insertTrajectory');
         if (insertStmt) {
-            insertStmt.run(id, task, options.agent || null, options.domain || null, startedAt.toISOString(), options.context ? JSON.stringify(options.context) : null);
+            const run = () => insertStmt.run(id, task, options.agent || null, options.domain || null, startedAt.toISOString(), options.context ? JSON.stringify(options.context) : null);
+            await (this.unifiedMemory ? this.unifiedMemory.writeWhenUnlocked(run) : run());
         }
         this.stats.trajectoriesStarted++;
         // Set auto-end timeout
@@ -344,12 +349,15 @@ export class TrajectoryTracker {
             endedAt,
             feedback,
         };
-        // Persist to SQLite
+        // Persist to SQLite. Queued (#1274): task completion events end
+        // trajectories in the background, and a locked memory.db must not freeze
+        // the MCP server's event loop.
         const updateStmt = this.prepared.get('updateTrajectory');
         if (updateStmt) {
-            updateStmt.run(endedAt.toISOString(), success ? 1 : 0, JSON.stringify(active.steps), JSON.stringify({ metrics, context: active.context }), null, // embedding - computed later if needed
+            const run = () => updateStmt.run(endedAt.toISOString(), success ? 1 : 0, JSON.stringify(active.steps), JSON.stringify({ metrics, context: active.context }), null, // embedding - computed later if needed
             feedback ?? null, null, // related_patterns - computed later
             trajectoryId);
+            await (this.unifiedMemory ? this.unifiedMemory.writeWhenUnlocked(run) : run());
         }
         // Remove from active, add to recent buffer
         this.activeTrajectories.delete(trajectoryId);

package/dist/integrations/embeddings/cache/EmbeddingCache.d.ts

@@ -84,6 +84,14 @@ export declare class EmbeddingCache {
      * Persist entry to disk
      */
     private persistToDisk;
+    /**
+     * Run a write on the cache's connection without blocking the caller
+     * (#1283). On the shared memory.db connection it goes through the write
+     * queue, so a locked database does not freeze the MCP server's event loop;
+     * on a private (legacy) connection it runs at once. A failure is logged,
+     * since the in-memory cache is already up to date.
+     */
+    private persist;
     /**
      * Flush writes that were queued during async DB initialization
      */

package/dist/integrations/embeddings/cache/EmbeddingCache.js

@@ -24,6 +24,7 @@ import { join } from 'path';
 import { existsSync, mkdirSync } from 'fs';
 import { getUnifiedMemory, findProjectRoot } from '../../../kernel/unified-memory.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
+import { writeWhenUnlockedOn } from '../../../shared/sqlite-write-queue.js';
 /**
  * Embedding cache with LRU eviction and persistent storage
  */
@@ -183,8 +184,7 @@ export class EmbeddingCache {
         const cache = this.memoryCache.get(namespace);
         const deleted = cache?.delete(key) || false;
         if (deleted && this.persistent && this.db) {
-            const stmt = this.db.prepare('DELETE FROM embeddings WHERE key = ? AND namespace = ?');
-            stmt.run(key, namespace);
+            this.persist('delete', (db) => db.prepare('DELETE FROM embeddings WHERE key = ? AND namespace = ?').run(key, namespace));
         }
         return deleted;
     }
@@ -196,8 +196,7 @@ export class EmbeddingCache {
             const cache = this.memoryCache.get(namespace);
             cache?.clear();
             if (this.persistent && this.db) {
-                const stmt = this.db.prepare('DELETE FROM embeddings WHERE namespace = ?');
-                stmt.run(namespace);
+                this.persist('clear', (db) => db.prepare('DELETE FROM embeddings WHERE namespace = ?').run(namespace));
             }
         }
         else {
@@ -205,7 +204,7 @@ export class EmbeddingCache {
                 cache.clear();
             }
             if (this.persistent && this.db) {
-                this.db.exec('DELETE FROM embeddings');
+                this.persist('clear', (db) => db.exec('DELETE FROM embeddings'));
             }
         }
     }
@@ -243,8 +242,8 @@ export class EmbeddingCache {
         if (lruKey) {
             cache.delete(lruKey);
             if (this.persistent && this.db) {
-                const stmt = this.db.prepare('DELETE FROM embeddings WHERE key = ? AND namespace = ?');
-                stmt.run(lruKey, namespace);
+                const evicted = lruKey;
+                this.persist('evict', (db) => db.prepare('DELETE FROM embeddings WHERE key = ? AND namespace = ?').run(evicted, namespace));
             }
         }
     }
@@ -259,17 +258,32 @@ export class EmbeddingCache {
             const metadataJson = embedding.metadata
                 ? JSON.stringify(embedding.metadata)
                 : null;
-            const stmt = this.db.prepare(`
+            const lastAccess = Date.now();
+            this.persist('persist', (db) => db.prepare(`
         INSERT OR REPLACE INTO embeddings
         (key, namespace, vector, dimension, text, timestamp, quantization, metadata, last_access)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-            stmt.run(key, namespace, vectorBuffer, embedding.dimension, embedding.text, embedding.timestamp, embedding.quantization, metadataJson, Date.now());
+      `).run(key, namespace, vectorBuffer, embedding.dimension, embedding.text, embedding.timestamp, embedding.quantization, metadataJson, lastAccess));
         }
         catch (error) {
             console.warn('Failed to persist embedding:', error);
         }
     }
+    /**
+     * Run a write on the cache's connection without blocking the caller
+     * (#1283). On the shared memory.db connection it goes through the write
+     * queue, so a locked database does not freeze the MCP server's event loop;
+     * on a private (legacy) connection it runs at once. A failure is logged,
+     * since the in-memory cache is already up to date.
+     */
+    persist(action, write) {
+        const db = this.db;
+        if (!db)
+            return;
+        writeWhenUnlockedOn(db, () => write(db)).catch((error) => {
+            console.warn(`Failed to ${action} embedding cache entry:`, error);
+        });
+    }
     /**
      * Flush writes that were queued during async DB initialization
      */