agentic-qe 3.15.15 → 3.15.16

package/dist/learning/embedder-endpoint-client.js

@@ -82,35 +82,60 @@ export function parseEndpoint(endpoint) {
         safeUrl: url.toString().replace(/\/$/, ''),
     };
 }
+/**
+ * #1216: a connect or request timeout. The host did not answer within the
+ * budget, so the breaker opens on the first one instead of counting it as one
+ * failure of `failureThreshold`.
+ */
+export class EmbedderEndpointTimeoutError extends Error {
+    phase;
+    limitMs;
+    constructor(phase, limitMs) {
+        super(`[EmbedderEndpointClient] ${phase} timeout after ${limitMs}ms`);
+        this.phase = phase;
+        this.limitMs = limitMs;
+        this.name = 'EmbedderEndpointTimeoutError';
+    }
+}
 /**
  * Circuit breaker state.
  *
- * Tracks failure timestamps within `windowMs`. Opens when count reaches `threshold`.
+ * Tracks failure timestamps within `windowMs`. Opens when count reaches `threshold`,
+ * or at once on a timeout (#1216): timeouts arrive one timeout apart, so with a
+ * 30 s request timeout and a 60 s window they would never add up to three.
  * While open, every request fast-fails until the window expires. On recovery
  * (window elapses), the breaker calls `onRecover` so the client can invalidate
  * cached endpoint identity — endpoint restarts often coincide with model swaps.
+ * Whenever it opens, it calls `onTrip` so the client can abandon requests
+ * still waiting on the host.
  */
 class CircuitBreaker {
     threshold;
     windowMs;
     onRecover;
+    onTrip;
     failures = [];
     trippedAt = null;
-    constructor(threshold, windowMs, onRecover = () => { }) {
+    constructor(threshold, windowMs, onRecover = () => { }, onTrip = () => { }) {
         this.threshold = threshold;
         this.windowMs = windowMs;
         this.onRecover = onRecover;
+        this.onTrip = onTrip;
     }
     recordSuccess() {
         this.failures = [];
         this.trippedAt = null;
     }
-    recordFailure() {
+    recordFailure(tripNow = false) {
+        // Requests abandoned when the breaker opened fail too; they must not
+        // extend the window.
+        if (this.trippedAt !== null)
+            return;
         const now = Date.now();
         this.failures = this.failures.filter((t) => now - t < this.windowMs);
         this.failures.push(now);
-        if (this.failures.length >= this.threshold) {
-            this.trippedAt = now;
+        if (tripNow || this.failures.length >= this.threshold) {
+            this.trip();
         }
     }
     isOpen() {
@@ -128,6 +153,7 @@ class CircuitBreaker {
     /** #1204: open (or re-open) the breaker for a full window from now. */
     trip() {
         this.trippedAt = Date.now();
+        this.onTrip();
     }
     /** For tests / observability */
     getState() {
@@ -145,6 +171,14 @@ export class EmbedderEndpointClient {
     cachedIdentity = null;
     /** True while a probe is in flight — prevents the embed() lazy-probe race. */
     probeInFlight = null;
+    /**
+     * #1216: set when the breaker window elapsed and no probe has succeeded
+     * since. The next probe is the breaker's half-open trial; it runs in the
+     * background so no caller waits on a host that may still not answer.
+     */
+    trialPending = false;
+    /** #1216: requests waiting on the host, abandoned when the breaker opens. */
+    inFlight = new Set();
     constructor(options) {
         this.opts = {
             endpoint: options.endpoint,
@@ -177,6 +211,35 @@ export class EmbedderEndpointClient {
             // On breaker recovery, drop identity so the next embed() re-probes.
             // Endpoint restarts (the common cause of recovery) often change models.
             this.cachedIdentity = null;
+            this.trialPending = true;
+        }, () => this.abandonInFlight());
+    }
+    /**
+     * #1216: the breaker opened, so the host is treated as down. Requests that
+     * are still waiting on it fail now rather than each waiting out its own
+     * timeout.
+     */
+    abandonInFlight() {
+        if (this.inFlight.size === 0)
+            return;
+        const err = new Error(`[EmbedderEndpointClient] circuit breaker opened for ${this.parsed.safeUrl} — request abandoned`);
+        for (const reject of [...this.inFlight])
+            reject(err);
+    }
+    /**
+     * #1216: true while the endpoint is not known to work: the breaker is open,
+     * or its window elapsed and the trial probe has not succeeded yet.
+     */
+    needsTrial() {
+        return this.breaker.isOpen() || this.trialPending;
+    }
+    /** Start the half-open trial probe in the background (one at a time). */
+    startTrialProbe() {
+        if (this.probeInFlight)
+            return;
+        this.probe().catch(() => {
+            // Still failing: keep fast-failing for another full window.
+            this.breaker.trip();
         });
     }
     /** Public, redacted endpoint URL for logs/metrics. */
@@ -201,6 +264,14 @@ export class EmbedderEndpointClient {
         }
         // Identity gate: every embed call must have a verified identity behind it.
         if (this.cachedIdentity === null) {
+            if (this.trialPending) {
+                // #1216: half-open. The endpoint failed until a window ago and may
+                // still not answer. Probe it in the background as the single trial
+                // and fail fast here; callers after a successful trial embed again.
+                this.startTrialProbe();
+                throw new Error(`[EmbedderEndpointClient] circuit breaker half-open for ${this.parsed.safeUrl} — ` +
+                    `trial probe running, fast-failing`);
+            }
             await this.ensureProbed();
         }
         try {
@@ -210,7 +281,7 @@ export class EmbedderEndpointClient {
             return vectors;
         }
         catch (err) {
-            this.breaker.recordFailure();
+            this.breaker.recordFailure(err instanceof EmbedderEndpointTimeoutError);
             throw err;
         }
     }
@@ -242,7 +313,7 @@ export class EmbedderEndpointClient {
             this.breaker.recordSuccess();
         }
         catch (err) {
-            this.breaker.recordFailure();
+            this.breaker.recordFailure(err instanceof EmbedderEndpointTimeoutError);
             throw err;
         }
         if (!vec || vec.length !== this.opts.expectedDim) {
@@ -262,6 +333,7 @@ export class EmbedderEndpointClient {
             fingerprint,
             endpoint: this.parsed.safeUrl,
         };
+        this.trialPending = false;
         return this.cachedIdentity;
     }
     getCachedIdentity() {
@@ -374,18 +446,30 @@ export class EmbedderEndpointClient {
         const requestTimeoutMs = this.opts.requestTimeoutMs;
         return new Promise((resolve, reject) => {
             let settled = false;
+            // #1285: removes this request's listeners from its socket. Keep-alive
+            // sockets serve many requests; listeners left behind pile up and a
+            // finished request's timeout handler would fire for a later request.
+            let detachFromSocket = () => { };
             const safeResolve = (val) => {
                 if (settled)
                     return;
                 settled = true;
+                detachFromSocket();
+                this.inFlight.delete(abandon);
                 resolve(val);
             };
             const safeReject = (err) => {
                 if (settled)
                     return;
                 settled = true;
+                detachFromSocket();
+                this.inFlight.delete(abandon);
                 reject(err);
             };
+            const abandon = (err) => {
+                safeReject(err);
+                req.destroy(err);
+            };
             const req = requestFn(reqOptions, (res) => {
                 const chunks = [];
                 res.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
@@ -426,18 +510,27 @@ export class EmbedderEndpointClient {
                 else {
                     onConnect();
                 }
-                socket.on('timeout', () => {
+                const onTimeout = () => {
                     // Distinguish phase for the error message.
                     const phase = socket.connecting ? 'connect' : 'request';
                     const limit = socket.connecting ? connectTimeoutMs : requestTimeoutMs;
-                    const err = new Error(`[EmbedderEndpointClient] ${phase} timeout after ${limit}ms`);
+                    const err = new EmbedderEndpointTimeoutError(phase, limit);
                     // Reject FIRST, then destroy. If we destroy first, the 'error' event
                     // races us and we might lose the timeout-specific message.
                     safeReject(err);
                     req.destroy(err);
-                });
+                };
+                socket.on('timeout', onTimeout);
+                detachFromSocket = () => {
+                    socket.removeListener('timeout', onTimeout);
+                    socket.removeListener('connect', onConnect);
+                };
+                // Settled before the socket was assigned: nothing of ours may stay on it.
+                if (settled)
+                    detachFromSocket();
             });
             req.on('error', (err) => safeReject(err));
+            this.inFlight.add(abandon);
             req.write(body);
             req.end();
         });

package/dist/learning/embedding-space.d.ts

@@ -57,6 +57,18 @@ export declare const EMBEDDING_RUNTIME_UNAVAILABLE_CAUSE: string;
 export declare function reportEmbeddingRuntimeUnavailable(): void;
 /** @internal test-only seam */
 export declare function __resetEmbeddingRuntimeNoticeForTests(): void;
+/**
+ * #1217: record the embedding space of a vector stored on a
+ * captured_experiences row. ExperienceReplay compares only vectors of the
+ * active space. On a table without the column (it is added by
+ * ExperienceReplay's schema) the vector stays without provenance: it is never
+ * compared, and ExperienceReplay re-embeds it at its next start.
+ */
+export declare function recordExperienceEmbeddingSpace(db: {
+    prepare(sql: string): {
+        run(...params: unknown[]): unknown;
+    };
+}, experienceId: string, spaceId: string | undefined): void;
 /** Sidecar path used to bind a persistent ANN index to one embedding space. */
 export declare function embeddingSpaceManifestPath(indexPath: string): string;
 /**

package/dist/learning/embedding-space.js

@@ -120,6 +120,23 @@ export function reportEmbeddingRuntimeUnavailable() {
 export function __resetEmbeddingRuntimeNoticeForTests() {
     embeddingRuntimeNoticeShown = false;
 }
+/**
+ * #1217: record the embedding space of a vector stored on a
+ * captured_experiences row. ExperienceReplay compares only vectors of the
+ * active space. On a table without the column (it is added by
+ * ExperienceReplay's schema) the vector stays without provenance: it is never
+ * compared, and ExperienceReplay re-embeds it at its next start.
+ */
+export function recordExperienceEmbeddingSpace(db, experienceId, spaceId) {
+    if (!spaceId)
+        return;
+    try {
+        db.prepare('UPDATE captured_experiences SET embedding_space_id = ? WHERE id = ?').run(spaceId, experienceId);
+    }
+    catch {
+        // Older table without the column; see above.
+    }
+}
 /** Sidecar path used to bind a persistent ANN index to one embedding space. */
 export function embeddingSpaceManifestPath(indexPath) {
     return `${indexPath}.space.json`;

package/dist/learning/experience-capture-middleware.js

@@ -16,6 +16,7 @@ import { getUnifiedMemory } from '../kernel/unified-memory.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { createLogger } from '../logging/logger-factory.js';
 import { isLearnableResult } from './learnable-result.js';
+import { recordExperienceEmbeddingSpace } from './embedding-space.js';
 const ecLogger = createLogger('ExperienceCapture');
 // ============================================================================
 // Active Experience Tracking
@@ -308,8 +309,9 @@ async function persistExperience(context, outcome) {
         console.warn('[ExperienceCaptureMiddleware] Memory manager not available');
         return;
     }
+    const memory = memoryManager;
     try {
-        const db = memoryManager.getDatabase();
+        const db = memory.getDatabase();
         if (!db)
             return;
         const stmt = db.prepare(`
@@ -318,9 +320,11 @@ async function persistExperience(context, outcome) {
        routing_json, steps_json, result_json, error, started_at, completed_at, source)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), ?)
     `);
-        stmt.run(outcome.id, context.task, context.agent, context.domain, outcome.success ? 1 : 0, outcome.quality, outcome.durationMs, context.modelTier || null, safeJsonStringify(context.routing), safeJsonStringify(outcome.steps), safeJsonStringify(outcome.result), outcome.error || null, context.startedAt.toISOString(), 'middleware');
+        // #1274: queued, so a locked memory.db does not freeze the MCP server's
+        // event loop while experiences are captured.
+        await memory.writeWhenUnlocked(() => stmt.run(outcome.id, context.task, context.agent, context.domain, outcome.success ? 1 : 0, outcome.quality, outcome.durationMs, context.modelTier || null, safeJsonStringify(context.routing), safeJsonStringify(outcome.steps), safeJsonStringify(outcome.result), outcome.error || null, context.startedAt.toISOString(), 'middleware'));
         // Fire-and-forget: compute and store embedding for this experience
-        computeExperienceEmbedding(db, outcome.id, context.task, context.domain).catch((e) => { ecLogger.warn('Embedding computation failed', { error: e instanceof Error ? e.message : String(e), experienceId: outcome.id, domain: context.domain }); });
+        computeExperienceEmbedding(memory, outcome.id, context.task, context.domain).catch((e) => { ecLogger.warn('Embedding computation failed', { error: e instanceof Error ? e.message : String(e), experienceId: outcome.id, domain: context.domain }); });
     }
     catch (error) {
         console.error('[ExperienceCaptureMiddleware] Failed to persist experience:', error);
@@ -330,19 +334,26 @@ async function persistExperience(context, outcome) {
  * Compute and store embedding for a captured experience (async, non-blocking).
  * Uses the shared ONNX transformer model (all-MiniLM-L6-v2, 384-dim).
  */
-async function computeExperienceEmbedding(db, experienceId, task, domain) {
+async function computeExperienceEmbedding(memory, experienceId, task, domain) {
     try {
-        const { computeRealEmbedding } = await import('./real-embeddings.js');
+        const { computeRealEmbedding, getActiveEmbeddingSpaceIdentity } = await import('./real-embeddings.js');
         const text = `${domain}: ${task}`.slice(0, 512); // Cap input length
         const embedding = await computeRealEmbedding(text);
         if (!embedding || embedding.length === 0)
             return;
         const buffer = Buffer.from(new Float32Array(embedding).buffer);
-        db.prepare(`
-      UPDATE captured_experiences
-      SET embedding = ?, embedding_dimension = ?
-      WHERE id = ? AND embedding IS NULL
-    `).run(buffer, embedding.length, experienceId);
+        const db = memory.getDatabase();
+        await memory.writeWhenUnlocked(() => {
+            const updated = db.prepare(`
+        UPDATE captured_experiences
+        SET embedding = ?, embedding_dimension = ?
+        WHERE id = ? AND embedding IS NULL
+      `).run(buffer, embedding.length, experienceId);
+            // #1217 (ADR-097): store the vector's embedding space with it.
+            if (updated.changes > 0) {
+                recordExperienceEmbeddingSpace(db, experienceId, getActiveEmbeddingSpaceIdentity()?.spaceId);
+            }
+        });
     }
     catch {
         // Non-critical — embedding will be backfilled later if needed
@@ -354,8 +365,9 @@ async function computeExperienceEmbedding(db, experienceId, task, domain) {
 async function persistToSonaPatterns(context, outcome) {
     if (!memoryManager)
         return;
+    const memory = memoryManager;
     try {
-        const db = memoryManager.getDatabase();
+        const db = memory.getDatabase();
         if (!db)
             return;
         // Only store successful patterns with decent quality
@@ -368,12 +380,12 @@ async function persistToSonaPatterns(context, outcome) {
        confidence, usage_count, metadata, created_at, updated_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
     `);
-        stmt.run(`sona-${outcome.id}`, 'task-execution', context.domain, context.agent, safeJsonStringify({ task: context.task.slice(0, 200) }), outcome.quality, 1, outcome.quality, outcome.quality, 1, safeJsonStringify({
+        await memory.writeWhenUnlocked(() => stmt.run(`sona-${outcome.id}`, 'task-execution', context.domain, context.agent, safeJsonStringify({ task: context.task.slice(0, 200) }), outcome.quality, 1, outcome.quality, outcome.quality, 1, safeJsonStringify({
             experienceId: outcome.id,
             durationMs: outcome.durationMs,
             stepsCount: outcome.steps.length,
             modelTier: context.modelTier,
-        }));
+        })));
     }
     catch (error) {
         // Log but don't fail - sona_patterns might not exist

package/dist/learning/experience-capture.js

@@ -234,7 +234,7 @@ export class ExperienceCaptureService {
             const contextFingerprint = `${experience.domain ?? 'unknown'}:${experience.agent ?? 'unknown'}`;
             for (const patternId of experience.appliedPatterns) {
                 try {
-                    this.nullRecorder({
+                    await this.nullRecorder({
                         patternId,
                         contextFingerprint,
                         failureMode: experience.testOutcome ?? experience.feedback ?? 'task-failure',

package/dist/learning/experience-consolidation.d.ts

@@ -70,6 +70,11 @@ export interface ConsolidationConfig {
     contradictionSimilarityThreshold: number;
     /** Min quality gap that turns a near-duplicate into a contradiction (0-1). */
     contradictionQualityDelta: number;
+    /**
+     * #1281: embedding space (ADR-097 spaceId) whose vectors Phase 1 compares.
+     * Defaults to the active embedder's space.
+     */
+    embeddingSpaceId?: string;
 }
 export declare class ExperienceConsolidator {
     private readonly config;
@@ -94,9 +99,22 @@ export declare class ExperienceConsolidator {
     bootstrapDomain(domain: string): Promise<ConsolidationResult>;
     private clusterAndMerge;
     private reinforceQuality;
+    private reinforceQualityNow;
     private archiveValueless;
+    private archiveValuelessNow;
     private hardDeleteExcess;
+    private hardDeleteExcessNow;
+    /** #1281: the embedding space Phase 1 compares vectors in, or null if unknown. */
+    private resolveEmbeddingSpaceId;
+    /** Tables created before #1217 have no embedding_space_id column. */
+    private hasEmbeddingSpaceColumn;
     private ensureInitialized;
+    /**
+     * Queue a write on the shared connection (#1283): the learning worker runs
+     * consolidation inside the MCP server, where a locked memory.db must not
+     * freeze the event loop. On any other connection the write runs at once.
+     */
+    private write;
     private bufferToFloatArray;
 }
 /**

package/dist/learning/experience-consolidation.js

@@ -15,7 +15,8 @@
  * Ensures the Exp counter is monotonically non-decreasing.
  */
 import { v4 as uuidv4 } from 'uuid';
-import { getUnifiedMemory } from '../kernel/unified-memory.js';
+import { getUnifiedMemory, writeWhenUnlockedOn } from '../kernel/unified-memory.js';
+import { ensureEndpointEmbeddingSpaceIdentity, getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
 import { HNSWEmbeddingIndex } from '../integrations/embeddings/index/HNSWIndex.js';
 const DEFAULT_CONFIG = {
     mergeSimilarityThreshold: 0.85,
@@ -111,9 +112,9 @@ export class ExperienceConsolidator {
         result.merged = clusterResult.merged;
         result.contradicted = clusterResult.contradicted;
         // Phase 2: Quality Reinforcement
-        result.qualityUpdated = this.reinforceQuality(domain);
+        result.qualityUpdated = await this.reinforceQuality(domain);
         // Phase 3: Archive Valueless
-        result.archived = this.archiveValueless(domain);
+        result.archived = await this.archiveValueless(domain);
         // Safety valve: when the domain still exceeds hardThreshold after the
         // soft phases, archive (not delete) the oldest low-quality excess.
         // Result is attributed to `archived` — `hardDeleted` stays 0 since
@@ -121,7 +122,7 @@ export class ExperienceConsolidator {
         const afterCount = this.db.prepare("SELECT COUNT(*) as cnt FROM captured_experiences WHERE domain = ? AND consolidated_into IS NULL").get(domain).cnt;
         let safetyValveArchived = 0;
         if (afterCount > this.config.hardThreshold) {
-            safetyValveArchived = this.hardDeleteExcess(domain, afterCount);
+            safetyValveArchived = await this.hardDeleteExcess(domain, afterCount);
             result.archived += safetyValveArchived;
         }
         result.activeRemaining = afterCount - safetyValveArchived;
@@ -150,7 +151,8 @@ export class ExperienceConsolidator {
         Object.assign(this.config, savedConfig);
         // Set bootstrap flag
         try {
-            this.db.prepare("INSERT OR REPLACE INTO kv_store (key, value, namespace) VALUES (?, ?, 'system')").run(`consolidation_bootstrap_${domain}`, new Date().toISOString());
+            const bootstrappedAt = new Date().toISOString();
+            await this.write(() => this.db.prepare("INSERT OR REPLACE INTO kv_store (key, value, namespace) VALUES (?, ?, 'system')").run(`consolidation_bootstrap_${domain}`, bootstrappedAt));
         }
         catch {
             // kv_store may not exist in all setups
@@ -163,6 +165,12 @@ export class ExperienceConsolidator {
     // Phase 1: Cluster & Merge
     // ============================================================================
     async clusterAndMerge(domain) {
+        // #1281 (ADR-097): a cosine between vectors of different embedding spaces
+        // is meaningless, even at the same dimension. Only vectors recorded in the
+        // active space are compared; without a known space nothing is merged.
+        const spaceId = await this.resolveEmbeddingSpaceId();
+        if (!spaceId || !this.hasEmbeddingSpaceColumn())
+            return { merged: 0, contradicted: 0 };
         // Get active experiences with embeddings, sorted by quality DESC
         const candidates = this.db.prepare(`
       SELECT id, task, domain, quality, success, application_count,
@@ -170,8 +178,9 @@ export class ExperienceConsolidator {
              embedding, embedding_dimension, started_at
       FROM captured_experiences
       WHERE domain = ? AND consolidated_into IS NULL AND embedding IS NOT NULL
+        AND embedding_space_id = ?
       ORDER BY quality DESC
-    `).all(domain);
+    `).all(domain, spaceId);
         if (candidates.length < 2)
             return { merged: 0, contradicted: 0 };
         // Build a temporary HNSW index for this domain
@@ -293,7 +302,7 @@ export class ExperienceConsolidator {
                     boostSurvivor.run(mergedIds.length, boost, row.id);
                     logConsolidation.run(uuidv4(), domain, 'merge', JSON.stringify(mergedIds), row.id, JSON.stringify({ count: mergedIds.length, boost }));
                 });
-                transaction();
+                await writeWhenUnlockedOn(this.db, transaction);
             }
             // Apply contradiction suppressions in a transaction. The loser is
             // soft-suppressed (consolidated_into = 'contradicted'), so it is excluded
@@ -306,7 +315,7 @@ export class ExperienceConsolidator {
                     }
                     logConsolidation.run(uuidv4(), domain, 'contradiction', JSON.stringify(contradictedIds), row.id, JSON.stringify({ count: contradictedIds.length, survivorQuality: row.quality }));
                 });
-                tx();
+                await writeWhenUnlockedOn(this.db, tx);
             }
         }
         // Clean up HNSW index
@@ -317,6 +326,10 @@ export class ExperienceConsolidator {
     // Phase 2: Quality Reinforcement
     // ============================================================================
     reinforceQuality(domain) {
+        // Read and update in one queued unit, so the update uses current values.
+        return this.write(() => this.reinforceQualityNow(domain));
+    }
+    reinforceQualityNow(domain) {
         // Get experiences with application history
         const experiences = this.db.prepare(`
       SELECT ce.id, ce.quality, ce.consolidation_count,
@@ -366,6 +379,9 @@ export class ExperienceConsolidator {
     // Phase 3: Archive Valueless
     // ============================================================================
     archiveValueless(domain) {
+        return this.write(() => this.archiveValuelessNow(domain));
+    }
+    archiveValuelessNow(domain) {
         const cutoffDate = new Date();
         cutoffDate.setDate(cutoffDate.getDate() - this.config.archiveMinAgeDays);
         const cutoffStr = cutoffDate.toISOString().replace('T', ' ').slice(0, 19);
@@ -415,6 +431,9 @@ export class ExperienceConsolidator {
     // ConsolidationResult.hardDeleted is kept zero for that reason; the
     // archive count is rolled into Phase 3's `archived` total.
     hardDeleteExcess(domain, currentCount) {
+        return this.write(() => this.hardDeleteExcessNow(domain, currentCount));
+    }
+    hardDeleteExcessNow(domain, currentCount) {
         const excess = currentCount - this.config.hardThreshold;
         if (excess <= 0)
             return 0;
@@ -455,11 +474,39 @@ export class ExperienceConsolidator {
     // ============================================================================
     // Utilities
     // ============================================================================
+    /** #1281: the embedding space Phase 1 compares vectors in, or null if unknown. */
+    async resolveEmbeddingSpaceId() {
+        if (this.config.embeddingSpaceId)
+            return this.config.embeddingSpaceId;
+        const active = getActiveEmbeddingSpaceIdentity()?.spaceId;
+        if (active)
+            return active;
+        try {
+            // A configured endpoint's identity, as the pattern stores resolve it (#754).
+            return (await ensureEndpointEmbeddingSpaceIdentity())?.spaceId ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Tables created before #1217 have no embedding_space_id column. */
+    hasEmbeddingSpaceColumn() {
+        const columns = this.db.prepare('PRAGMA table_info(captured_experiences)').all();
+        return columns.some(c => c.name === 'embedding_space_id');
+    }
     ensureInitialized() {
         if (!this.initialized || !this.db) {
             throw new Error('ExperienceConsolidator not initialized. Call initialize() first.');
         }
     }
+    /**
+     * Queue a write on the shared connection (#1283): the learning worker runs
+     * consolidation inside the MCP server, where a locked memory.db must not
+     * freeze the event loop. On any other connection the write runs at once.
+     */
+    write(fn) {
+        return writeWhenUnlockedOn(this.db, fn);
+    }
     bufferToFloatArray(buffer, dimension) {
         const arr = [];
         for (let i = 0; i < dimension; i++) {

package/dist/learning/experience-space-verification.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Attribute legacy experience vectors to an embedding space (#1217)
+ *
+ * captured_experiences rows written before #1217 carry a vector but no
+ * embedding_space_id, so ExperienceReplay never compares them. Their vectors
+ * are learning data and are never overwritten here. Instead each row's text is
+ * re-embedded with the recipe its writer used; when the result matches the
+ * stored vector (cosine >= EMBEDDING_ROUND_TRIP_MIN_COSINE), the stored vector
+ * came from the active space and only embedding_space_id is set. A row that
+ * does not match (another space, or text that can no longer be rebuilt) is
+ * left as it is: it stays excluded from comparison.
+ *
+ * Progress is kept per space in kv_store, so rows that did not match are not
+ * re-checked on every start; a different active space starts over.
+ */
+interface VerifiableDatabase {
+    prepare(sql: string): {
+        all(...params: unknown[]): unknown[];
+        get(...params: unknown[]): unknown;
+        run(...params: unknown[]): {
+            changes: number;
+        };
+    };
+}
+export interface LegacyExperienceRow {
+    rowid: number;
+    id: string;
+    task: string;
+    agent: string | null;
+    domain: string | null;
+    steps_json: string | null;
+    source: string | null;
+    embedding: Buffer;
+    embedding_dimension: number;
+}
+export interface ExperienceSpaceVerificationOptions {
+    /** Embed text in the active space; throws when the embedder fails. */
+    embed: (text: string) => Promise<number[]>;
+    /** The active embedding space, read after embedding. */
+    activeSpaceId: () => string | undefined;
+    /** Rows to check in this pass. */
+    limit?: number;
+    /** Runs a write (e.g. UnifiedMemoryManager.writeWhenUnlocked). */
+    write?: <T>(fn: () => T) => Promise<T> | T;
+}
+export interface ExperienceSpaceVerificationResult {
+    spaceId: string | null;
+    checked: number;
+    stamped: string[];
+    left: number;
+}
+/**
+ * The texts the row's writer may have embedded. Each is only a candidate:
+ * a row is attributed only when one reproduces its stored vector.
+ * - experience-capture middleware and the CLI hooks: `${domain}: ${task}`,
+ *   capped at 512 chars (the hooks store task capped at 500, so a longer
+ *   task cannot be rebuilt and will not match);
+ * - ExperienceReplay's start-up backfill: the same, scrubbed (ADR-099);
+ * - ExperienceReplay.storeExperience (source 'experience-replay'):
+ *   `${task} ${strategy} ${keyActions}`, strategy in `agent`, key actions
+ *   in steps_json.
+ */
+export declare function legacyExperienceEmbeddingTexts(row: LegacyExperienceRow): string[];
+/**
+ * Check up to `limit` legacy rows (vector, no embedding_space_id) and set
+ * embedding_space_id on those whose stored vector the active embedder
+ * reproduces. Never writes a vector. Stops at the first embedder failure.
+ */
+export declare function verifyLegacyExperienceSpaces(db: VerifiableDatabase, options: ExperienceSpaceVerificationOptions): Promise<ExperienceSpaceVerificationResult>;
+export {};
+//# sourceMappingURL=experience-space-verification.d.ts.map