agentic-qe 3.15.14 → 3.15.16

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

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

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

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

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

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

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

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

package/dist/learning/embed-and-insert-pattern.js

@@ -18,6 +18,7 @@
  * fail-soft (errors are logged at debug level and swallowed) — pattern row
  * persistence must not regress when embedding computation fails.
  */
+import { writeWhenUnlockedOn } from '../shared/sqlite-write-queue.js';
 import { computeRealEmbedding, DEFAULT_EMBEDDING_CONFIG, getActiveEmbeddingSpaceIdentity, } from './real-embeddings.js';
 /**
  * Compute an embedding for a pattern (`name + description + tags`) and persist
@@ -44,8 +45,9 @@ export async function ensurePatternEmbedding(db, patternId, name, description, t
         const spaceId = getActiveEmbeddingSpaceIdentity()?.spaceId;
         if (!spaceId)
             throw new Error('VECTOR_SPACE_UNVERIFIED: embedder has no runtime provenance');
-        db.prepare(`INSERT OR REPLACE INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, space_id)
-       VALUES (?, ?, ?, ?, ?)`).run(patternId, buffer, embedding.length, fullConfig.modelName, spaceId);
+        // #1283: queued on the shared connection so a locked memory.db does not freeze the MCP server.
+        await writeWhenUnlockedOn(db, () => db.prepare(`INSERT OR REPLACE INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, space_id)
+       VALUES (?, ?, ?, ?, ?)`).run(patternId, buffer, embedding.length, fullConfig.modelName, spaceId));
     }
     catch (error) {
         // Non-fatal: pattern row already persisted; embedding can be backfilled later.

package/dist/learning/embedder-endpoint-client.d.ts

@@ -82,6 +82,16 @@ interface ParsedEndpoint {
  */
 export declare function redactEndpoint(endpoint: string): string;
 export declare function parseEndpoint(endpoint: string): ParsedEndpoint;
+/**
+ * #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 declare class EmbedderEndpointTimeoutError extends Error {
+    readonly phase: 'connect' | 'request';
+    readonly limitMs: number;
+    constructor(phase: 'connect' | 'request', limitMs: number);
+}
 /**
  * OpenAI-compatible embeddings client with keep-alive, circuit breaker, and identity probe.
  */
@@ -93,7 +103,28 @@ export declare class EmbedderEndpointClient {
     private cachedIdentity;
     /** True while a probe is in flight — prevents the embed() lazy-probe race. */
     private probeInFlight;
+    /**
+     * #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.
+     */
+    private trialPending;
+    /** #1216: requests waiting on the host, abandoned when the breaker opens. */
+    private readonly inFlight;
     constructor(options: EmbedderEndpointClientOptions);
+    /**
+     * #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.
+     */
+    private abandonInFlight;
+    /**
+     * #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(): boolean;
+    /** Start the half-open trial probe in the background (one at a time). */
+    private startTrialProbe;
     /** Public, redacted endpoint URL for logs/metrics. */
     getSafeEndpoint(): string;
     /**

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`;