agentic-qe 3.15.15 → 3.15.17

package/dist/governance/witness-chain.d.ts

@@ -245,6 +245,11 @@ export declare class WitnessChain {
 export interface IWitnessChainPersistence {
     /** Store a receipt in SQLite. Called after each appendWitness(). */
     insertReceipt(receipt: WitnessReceipt): void;
+    /**
+     * Store a receipt without blocking on a locked database (#1283). When
+     * present, appendWitness() uses it instead of insertReceipt().
+     */
+    insertReceiptWhenUnlocked?(receipt: WitnessReceipt): Promise<void>;
     /** Load all receipts from SQLite, ordered by chainIndex. */
     loadAllReceipts(): WitnessReceipt[];
     /** Get the total count of persisted receipts. */

package/dist/governance/witness-chain.js

@@ -18,6 +18,7 @@
 import { createHash, randomUUID } from 'crypto';
 import { LoggerFactory } from '../logging/index.js';
 import { getRuVectorFeatureFlags } from '../integrations/ruvector/feature-flags.js';
+import { writeWhenUnlockedOn } from '../shared/sqlite-write-queue.js';
 const logger = LoggerFactory.create('witness-chain');
 // ============================================================================
 // SPRT Accumulator
@@ -387,14 +388,25 @@ export class PersistentWitnessChain extends WitnessChain {
      */
     appendWitness(decision) {
         const receipt = super.appendWitness(decision);
-        try {
-            this.persistence.insertReceipt(receipt);
-        }
-        catch (err) {
+        const warn = (err) => {
             logger.warn('Failed to persist witness receipt to SQLite', {
                 chainIndex: receipt.chainIndex,
                 error: err instanceof Error ? err.message : String(err),
             });
+        };
+        try {
+            // #1283: queue the insert when the backend can, so a locked memory.db
+            // does not freeze the MCP server's event loop. The receipt is already in
+            // the in-memory chain, which is what callers read.
+            if (this.persistence.insertReceiptWhenUnlocked) {
+                this.persistence.insertReceiptWhenUnlocked(receipt).catch(warn);
+            }
+            else {
+                this.persistence.insertReceipt(receipt);
+            }
+        }
+        catch (err) {
+            warn(err);
         }
         return receipt;
     }
@@ -440,9 +452,13 @@ export function createWitnessChainSQLitePersistence(db) {
     const countStmt = db.prepare(`
     SELECT COUNT(*) as cnt FROM witness_chain_receipts
   `);
+    const insertReceipt = (receipt) => {
+        insertStmt.run(receipt.id, receipt.chainIndex, receipt.timestamp, receipt.previousHash, receipt.hash, receipt.decision.type, receipt.decision.decision, JSON.stringify(receipt.decision.context), receipt.decision.evidence ?? null);
+    };
     return {
-        insertReceipt(receipt) {
-            insertStmt.run(receipt.id, receipt.chainIndex, receipt.timestamp, receipt.previousHash, receipt.hash, receipt.decision.type, receipt.decision.decision, JSON.stringify(receipt.decision.context), receipt.decision.evidence ?? null);
+        insertReceipt,
+        insertReceiptWhenUnlocked(receipt) {
+            return writeWhenUnlockedOn(db, () => insertReceipt(receipt));
         },
         loadAllReceipts() {
             const rows = loadAllStmt.all();

package/dist/init/copilot-installer.d.ts

@@ -29,6 +29,12 @@ export declare class CopilotInstaller {
     private generator;
     constructor(options: CopilotInstallerOptions);
     install(): Promise<CopilotInstallResult>;
+    /**
+     * Replace AQE's server entry in an existing config, keeping everything else.
+     * Returns null when the file cannot be merged safely (e.g. JSONC comments,
+     * which VS Code accepts but JSON.parse does not) so the user's file is never
+     * clobbered wholesale.
+     */
     private mergeExistingConfig;
 }
 export declare function createCopilotInstaller(options: CopilotInstallerOptions): CopilotInstaller;

package/dist/init/copilot-installer.js

@@ -8,6 +8,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { writeFileIfChanged } from './idempotent-write.js';
 import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 // ============================================================================
 // Copilot Installer Class
@@ -37,20 +38,28 @@ export class CopilotInstaller {
             const mcpConfig = this.generator.generateMcpConfig('copilot', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
-            if (!existsSync(configPath) || this.overwrite) {
+            // AQE's own server entry is refreshed on every init, independent of
+            // `overwrite` (#1269): its launch config is version-pinned, and a stale one
+            // leaves VS Code serving tool schemas cached from an older server. Other
+            // servers and top-level keys in the file are preserved.
+            if (!existsSync(configPath)) {
                 const configDir = dirname(configPath);
                 if (!existsSync(configDir)) {
                     mkdirSync(configDir, { recursive: true });
                 }
-                // Merge with existing if present
-                if (existsSync(configPath) && this.overwrite) {
-                    const merged = this.mergeExistingConfig(configPath, mcpConfig.content);
-                    writeFileSync(configPath, merged);
+                writeFileSync(configPath, mcpConfig.content);
+                result.mcpConfigured = true;
+            }
+            else {
+                const merged = this.mergeExistingConfig(configPath, mcpConfig.content);
+                if (merged === null) {
+                    result.errors.push(`${configPath} is not plain JSON (comments?) and was left unchanged; ` +
+                        `update its "agentic-qe" server entry by hand`);
                 }
                 else {
-                    writeFileSync(configPath, mcpConfig.content);
+                    writeFileIfChanged(configPath, merged);
+                    result.mcpConfigured = true;
                 }
-                result.mcpConfigured = true;
             }
             // Generate behavioral rules
             const rules = this.generator.generateBehavioralRules('copilot');
@@ -71,23 +80,34 @@ export class CopilotInstaller {
         }
         return result;
     }
+    /**
+     * Replace AQE's server entry in an existing config, keeping everything else.
+     * Returns null when the file cannot be merged safely (e.g. JSONC comments,
+     * which VS Code accepts but JSON.parse does not) so the user's file is never
+     * clobbered wholesale.
+     */
     mergeExistingConfig(configPath, newContent) {
+        let existing;
         try {
-            const existing = JSON.parse(readFileSync(configPath, 'utf-8'));
-            const incoming = JSON.parse(newContent);
-            // Merge servers
-            if (!existing.servers) {
-                existing.servers = {};
-            }
-            Object.assign(existing.servers, incoming.servers);
-            return JSON.stringify(existing, null, 2) + '\n';
+            existing = JSON.parse(readFileSync(configPath, 'utf-8'));
         }
         catch {
-            // If existing config is invalid, overwrite
-            return newContent;
+            return null;
         }
+        if (!isPlainObject(existing))
+            return null;
+        if (existing.servers === undefined)
+            existing.servers = {};
+        if (!isPlainObject(existing.servers))
+            return null;
+        const incoming = JSON.parse(newContent);
+        Object.assign(existing.servers, incoming.servers);
+        return JSON.stringify(existing, null, 2) + '\n';
     }
 }
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 // ============================================================================
 // Factory Function
 // ============================================================================

package/dist/init/platform-config-generator.d.ts

@@ -23,6 +23,16 @@ export interface GeneratedConfig {
     format: string;
 }
 export declare const PLATFORM_REGISTRY: Record<PlatformId, PlatformDefinition>;
+/**
+ * Issue #1269: VS Code caches each MCP server's tool list keyed by a hash of its
+ * launch config (command/args/env) and only restarts the server when that hash
+ * changes. The `agentic-qe@latest` entry is identical across releases, so tool
+ * schemas cached from an older server (the pre-#1185 "array type must have items"
+ * ones) survived upgrades. Stamping the installing version into the Copilot
+ * entry's env changes the hash whenever `aqe init` runs after an upgrade, without
+ * pinning which server version npx launches. The server does not read it.
+ */
+export declare function getCopilotInitVersionEnv(): Record<string, string>;
 export declare class PlatformConfigGenerator {
     /**
      * Get the platform definition for a given platform ID

package/dist/init/platform-config-generator.js

@@ -4,6 +4,7 @@
  *
  * Supports: GitHub Copilot, Cursor, Cline, Kilo Code, Roo Code, OpenAI Codex, Windsurf, Continue.dev
  */
+import { createRequire } from 'module';
 // ============================================================================
 // Platform Registry
 // ============================================================================
@@ -146,6 +147,29 @@ function getMcpServerEnv(dbFree) {
         ? { AQE_MEMORY_BACKEND: 'memory', AQE_V3_MODE: 'true' }
         : { AQE_MEMORY_PATH: '.agentic-qe/memory.db', AQE_V3_MODE: 'true' };
 }
+/**
+ * Installed AQE version: the build-time define in the CLI/MCP bundles, otherwise
+ * package.json (tsc output and tests). Both src/init/ and dist/cli/ sit two levels
+ * below the package root.
+ */
+function getInstalledAqeVersion() {
+    if (typeof __CLI_VERSION__ !== 'undefined')
+        return __CLI_VERSION__;
+    const pkg = createRequire(import.meta.url)('../../package.json');
+    return pkg.version;
+}
+/**
+ * Issue #1269: VS Code caches each MCP server's tool list keyed by a hash of its
+ * launch config (command/args/env) and only restarts the server when that hash
+ * changes. The `agentic-qe@latest` entry is identical across releases, so tool
+ * schemas cached from an older server (the pre-#1185 "array type must have items"
+ * ones) survived upgrades. Stamping the installing version into the Copilot
+ * entry's env changes the hash whenever `aqe init` runs after an upgrade, without
+ * pinning which server version npx launches. The server does not read it.
+ */
+export function getCopilotInitVersionEnv() {
+    return { AQE_INIT_VERSION: getInstalledAqeVersion() };
+}
 function getMcpServerEntry(withAutoApprove, dbFree) {
     const entry = {
         command: 'npx',
@@ -164,12 +188,13 @@ function getMcpServerEntry(withAutoApprove, dbFree) {
 function generateJsonConfig(platform, dbFree) {
     const serverEntry = getMcpServerEntry(platform.supportsAutoApprove, dbFree);
     if (platform.id === 'copilot') {
-        // Copilot uses "servers" key with "type": "stdio"
+        // Copilot uses "servers" key with "type": "stdio"; env carries the init version stamp (#1269)
         const config = {
             [platform.configKey]: {
                 'agentic-qe': {
                     type: 'stdio',
                     ...serverEntry,
+                    env: { ...serverEntry.env, ...getCopilotInitVersionEnv() },
                 },
             },
         };

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