agentic-qe 3.15.15 → 3.15.17

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

@@ -15,6 +15,8 @@
  *   - Bearer auth from env only; URL userinfo stripped + warned on construct.
  *   - Probe + identity fingerprint required before `embed()`; breaker recovery
  *     invalidates identity so re-probe runs against a fresh endpoint.
+ *   - The first identity is bound for the client's lifetime: a re-probe that
+ *     finds another model is refused, never adopted (#1282).
  *   - True TCP connect timeout via socket-level setTimeout (not req.setTimeout).
  *   - TLS knobs (ca / cert / key / rejectUnauthorized / servername) for self-hosted.
  */
@@ -22,7 +24,8 @@ import * as http from 'node:http';
 import * as https from 'node:https';
 import { createHash } from 'node:crypto';
 import { URL } from 'node:url';
-import { normalize as l2Normalize } from '../shared/utils/vector-math.js';
+import { cosineSimilarity, normalize as l2Normalize } from '../shared/utils/vector-math.js';
+import { EMBEDDING_ROUND_TRIP_MIN_COSINE } from './embedding-space.js';
 const DEFAULT_OPTIONS = {
     model: 'Xenova/all-MiniLM-L6-v2',
     expectedDim: 384,
@@ -31,7 +34,9 @@ const DEFAULT_OPTIONS = {
     failureThreshold: 3,
     failureWindowMs: 60_000,
 };
-const CANARY_TEXT = 'AQE embedder endpoint identity canary v1';
+/** The text every probe embeds; its vector is the endpoint's identity evidence. */
+export const ENDPOINT_IDENTITY_CANARY = 'AQE embedder endpoint identity canary v1';
+const CANARY_TEXT = ENDPOINT_IDENTITY_CANARY;
 const EMBEDDINGS_PATH = '/v1/embeddings';
 /**
  * Strip user:password@ from a URL for safe logging.
@@ -82,35 +87,79 @@ 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';
+    }
+}
+/**
+ * #1282: a probe found a different endpoint identity than the one the client
+ * bound to. Vectors from the new identity are not comparable with stored ones,
+ * so the client refuses to embed until the endpoint serves the bound identity
+ * again or the process restarts.
+ */
+export class EmbedderEndpointIdentityChangedError extends Error {
+    bound;
+    current;
+    constructor(bound, current) {
+        super(`[EmbedderEndpointClient] endpoint identity changed since this process bound to it ` +
+            `(fingerprint ${bound.fingerprint} -> ${current.fingerprint}, ` +
+            `dim ${bound.dim} -> ${current.dim}) at ${current.endpoint}; ` +
+            `restart to use the new embedding space`);
+        this.bound = bound;
+        this.current = current;
+        this.name = 'EmbedderEndpointIdentityChangedError';
+    }
+}
 /**
  * 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,12 +177,16 @@ 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() {
         return { open: this.isOpen(), failures: this.failures.length, trippedAt: this.trippedAt };
     }
 }
+function sameIdentity(a, b) {
+    return a.fingerprint === b.fingerprint && a.dim === b.dim;
+}
 /**
  * OpenAI-compatible embeddings client with keep-alive, circuit breaker, and identity probe.
  */
@@ -143,8 +196,25 @@ export class EmbedderEndpointClient {
     breaker;
     opts;
     cachedIdentity = null;
+    /**
+     * #1282: the first identity a probe found. Every embedding this client
+     * returns belongs to it; later probes must find it again.
+     */
+    boundIdentity = null;
+    /** #1282: the canary vector behind `boundIdentity`. */
+    boundCanary = null;
+    /** #1282: set while the endpoint serves an identity other than the bound one. */
+    identityChange = 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 +247,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. */
@@ -197,10 +296,21 @@ export class EmbedderEndpointClient {
         if (texts.length === 0)
             return [];
         if (this.breaker.isOpen()) {
+            // #1282: say why the breaker is open when the cause is a changed model.
+            if (this.identityChange)
+                throw this.identityChange;
             throw new Error(`[EmbedderEndpointClient] circuit breaker open for ${this.parsed.safeUrl} — fast-failing`);
         }
         // 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 +320,7 @@ export class EmbedderEndpointClient {
             return vectors;
         }
         catch (err) {
-            this.breaker.recordFailure();
+            this.breaker.recordFailure(err instanceof EmbedderEndpointTimeoutError);
             throw err;
         }
     }
@@ -242,7 +352,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) {
@@ -257,16 +367,73 @@ export class EmbedderEndpointClient {
             buf.writeInt16LE(q, i * 2);
         }
         const fingerprint = createHash('sha256').update(buf).digest('hex').slice(0, 16);
-        this.cachedIdentity = {
+        const identity = {
             dim: vec.length,
             fingerprint,
             endpoint: this.parsed.safeUrl,
         };
+        if (this.boundIdentity && this.boundCanary) {
+            if (!this.isBoundModel(identity, vec))
+                this.refuseIdentityChange(identity);
+        }
+        else {
+            this.boundIdentity = identity;
+            this.boundCanary = vec;
+        }
+        this.identityChange = null;
+        // The bound identity stays the one callers see, also when fp noise moved
+        // the hash: the embedding space did not change.
+        this.cachedIdentity = this.boundIdentity;
+        this.trialPending = false;
         return this.cachedIdentity;
     }
+    /**
+     * #1282: true when a re-probe found the bound model. The int16 fingerprint
+     * flips on noise of about 3e-5 per component, which the same model restarted
+     * on other hardware or kernels can produce, so a changed hash alone is not a
+     * changed model: the canary must also have moved below the ADR-097
+     * round-trip cosine.
+     */
+    isBoundModel(identity, canary) {
+        const bound = this.boundIdentity;
+        if (identity.dim !== bound.dim)
+            return false;
+        if (identity.fingerprint === bound.fingerprint)
+            return true;
+        return (cosineSimilarity(this.boundCanary, canary) >= EMBEDDING_ROUND_TRIP_MIN_COSINE);
+    }
+    /**
+     * #1282: the endpoint answers, but as a different model than the one this
+     * client bound to (an endpoint restarted with another model of the same
+     * dimension, typically seen when the breaker recovers). Treat it as down:
+     * open the breaker so every caller fast-fails with this error, and retry
+     * as a half-open trial after each window, in case the bound model returns.
+     * Reported once per new identity.
+     */
+    refuseIdentityChange(current) {
+        const bound = this.boundIdentity;
+        const previous = this.identityChange;
+        const change = new EmbedderEndpointIdentityChangedError(bound, current);
+        this.identityChange = change;
+        this.cachedIdentity = null;
+        this.trialPending = true;
+        this.breaker.trip();
+        if (!previous || !sameIdentity(previous.current, current)) {
+            console.warn(`${change.message}. Embedding requests are refused.`);
+        }
+        throw change;
+    }
     getCachedIdentity() {
         return this.cachedIdentity;
     }
+    /** #1282: the identity every vector from this client belongs to. */
+    getBoundIdentity() {
+        return this.boundIdentity;
+    }
+    /** #1298: the canary vector behind the bound identity (ENDPOINT_IDENTITY_CANARY). */
+    getBoundCanary() {
+        return this.boundCanary;
+    }
     getBreakerState() {
         return this.breaker.getState();
     }
@@ -374,18 +541,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 +605,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-registry.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Embedding-space registry (#1298).
+ *
+ * A space id is a hash of the runtime configuration plus an exact fingerprint
+ * of a canary vector, rounded to int16 (steps of about 3e-5). The same model
+ * restarted on other hardware or kernels can move the canary by more than
+ * that, which would mint a new space id for vectors that are still
+ * comparable. So each space minted here also stores its canary vector, as the
+ * space's reference. At the next start, a runtime with the same configuration
+ * whose canary is within EMBEDDING_ROUND_TRIP_MIN_COSINE of a reference is
+ * that space: it keeps the stored identity and id instead of minting one.
+ *
+ * Entries live in memory.db kv_store (namespace _system) and are only ever
+ * added: a reference is never updated, so slow drift cannot walk a space
+ * away, and no stored id, vector or manifest is ever rewritten. Without a
+ * database, or when it cannot be read, derivation is what it was before.
+ */
+import { type EmbeddingSpaceIdentity } from './embedding-space.js';
+/** The raw memory.db connection the registry reads and writes. */
+export interface EmbeddingSpaceRegistryDb {
+    prepare(sql: string): {
+        all(...params: unknown[]): unknown[];
+        run(...params: unknown[]): unknown;
+    };
+}
+/** A space and the canary vector it was minted with. */
+export interface RegisteredEmbeddingSpace {
+    identity: EmbeddingSpaceIdentity;
+    /** The text the canary vector embeds; only like canaries are compared. */
+    canaryText: string;
+    canary: number[];
+}
+export type EmbeddingSpaceResolution = 
+/** A registered space with the same fingerprint. */
+'matched-exact'
+/** A registered space whose canary is within the round-trip cosine. */
+ | 'matched-cosine'
+/** No registered space matched: the derived space was registered. */
+ | 'registered'
+/** No usable registry: the derived space is used as before. */
+ | 'unavailable';
+export interface ResolvedEmbeddingSpace {
+    identity: EmbeddingSpaceIdentity;
+    resolution: EmbeddingSpaceResolution;
+    /** Same-configuration spaces that did not match (for the drift warning). */
+    otherSpaces: number;
+    /** Settles when the registration write has run (or failed, logged). */
+    registration: Promise<void>;
+}
+/** Same configuration: everything but the runtime fingerprint. */
+export declare function sameEmbeddingSpaceConfig(a: EmbeddingSpaceIdentity, b: EmbeddingSpaceIdentity): boolean;
+/**
+ * The registered space a runtime belongs to, or null. Candidates share the
+ * runtime's configuration and canary text; an equal fingerprint wins, then
+ * the highest canary cosine at or above the round-trip threshold.
+ */
+export declare function matchRegisteredSpace(derived: EmbeddingSpaceIdentity, canaryText: string, canary: readonly number[], entries: readonly RegisteredEmbeddingSpace[]): {
+    entry: RegisteredEmbeddingSpace;
+    exact: boolean;
+} | null;
+/** Read every registered space. Malformed entries are skipped. Throws on a DB error. */
+export declare function loadRegisteredSpaces(db: EmbeddingSpaceRegistryDb): RegisteredEmbeddingSpace[];
+/**
+ * Add a space to the registry. Never replaces an entry. The write goes
+ * through the connection's write queue (#1283) when it has one, so a locked
+ * memory.db does not block the event loop.
+ */
+export declare function registerEmbeddingSpace(db: EmbeddingSpaceRegistryDb, space: RegisteredEmbeddingSpace): Promise<void>;
+/**
+ * Choose the space for a freshly derived runtime identity: a registered space
+ * it matches, or the derived space, which is then registered. Never throws:
+ * when the registry cannot be read the derived space is used, as before.
+ */
+export declare function resolveEmbeddingSpace(db: EmbeddingSpaceRegistryDb | null, derived: EmbeddingSpaceIdentity, canaryText: string, canary: readonly number[]): ResolvedEmbeddingSpace;
+//# sourceMappingURL=embedding-space-registry.d.ts.map

package/dist/learning/embedding-space-registry.js

@@ -0,0 +1,142 @@
+/**
+ * Embedding-space registry (#1298).
+ *
+ * A space id is a hash of the runtime configuration plus an exact fingerprint
+ * of a canary vector, rounded to int16 (steps of about 3e-5). The same model
+ * restarted on other hardware or kernels can move the canary by more than
+ * that, which would mint a new space id for vectors that are still
+ * comparable. So each space minted here also stores its canary vector, as the
+ * space's reference. At the next start, a runtime with the same configuration
+ * whose canary is within EMBEDDING_ROUND_TRIP_MIN_COSINE of a reference is
+ * that space: it keeps the stored identity and id instead of minting one.
+ *
+ * Entries live in memory.db kv_store (namespace _system) and are only ever
+ * added: a reference is never updated, so slow drift cannot walk a space
+ * away, and no stored id, vector or manifest is ever rewritten. Without a
+ * database, or when it cannot be read, derivation is what it was before.
+ */
+import { cosineSimilarity } from '../shared/utils/vector-math.js';
+import { writeWhenUnlockedOn } from '../shared/sqlite-write-queue.js';
+import { toErrorMessage } from '../shared/error-utils.js';
+import { EMBEDDING_ROUND_TRIP_MIN_COSINE, } from './embedding-space.js';
+const NAMESPACE = '_system';
+const KEY_PREFIX = 'embedding_space:';
+/** Same configuration: everything but the runtime fingerprint. */
+export function sameEmbeddingSpaceConfig(a, b) {
+    return (a.provider === b.provider &&
+        a.model === b.model &&
+        a.dimensions === b.dimensions &&
+        (a.pooling ?? null) === (b.pooling ?? null) &&
+        a.normalized === b.normalized &&
+        (a.preprocessingVersion ?? null) === (b.preprocessingVersion ?? null) &&
+        (a.implementation ?? null) === (b.implementation ?? null));
+}
+/**
+ * The registered space a runtime belongs to, or null. Candidates share the
+ * runtime's configuration and canary text; an equal fingerprint wins, then
+ * the highest canary cosine at or above the round-trip threshold.
+ */
+export function matchRegisteredSpace(derived, canaryText, canary, entries) {
+    const candidates = entries.filter((entry) => entry.canaryText === canaryText &&
+        entry.canary.length === canary.length &&
+        sameEmbeddingSpaceConfig(entry.identity, derived));
+    const exact = candidates.find((entry) => entry.identity.runtimeFingerprint === derived.runtimeFingerprint);
+    if (exact)
+        return { entry: exact, exact: true };
+    let best = null;
+    for (const entry of candidates) {
+        const cosine = cosineSimilarity(entry.canary, canary);
+        if (cosine >= EMBEDDING_ROUND_TRIP_MIN_COSINE && (!best || cosine > best.cosine)) {
+            best = { entry, cosine };
+        }
+    }
+    return best ? { entry: best.entry, exact: false } : null;
+}
+/** Read every registered space. Malformed entries are skipped. Throws on a DB error. */
+export function loadRegisteredSpaces(db) {
+    const rows = db
+        .prepare('SELECT value FROM kv_store WHERE namespace = ? AND key LIKE ?')
+        .all(NAMESPACE, `${KEY_PREFIX}%`);
+    const entries = [];
+    for (const row of rows) {
+        const entry = parseEntry(row.value);
+        if (entry)
+            entries.push(entry);
+    }
+    return entries;
+}
+function parseEntry(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+    const { identity, canaryText, canary } = parsed;
+    if (parsed.version !== 1 ||
+        !identity ||
+        typeof identity.spaceId !== 'string' ||
+        typeof identity.runtimeFingerprint !== 'string' ||
+        typeof identity.dimensions !== 'number' ||
+        typeof canaryText !== 'string' ||
+        !Array.isArray(canary) ||
+        canary.length !== identity.dimensions ||
+        !canary.every((x) => typeof x === 'number' && Number.isFinite(x))) {
+        return null;
+    }
+    return { identity, canaryText, canary };
+}
+/**
+ * Add a space to the registry. Never replaces an entry. The write goes
+ * through the connection's write queue (#1283) when it has one, so a locked
+ * memory.db does not block the event loop.
+ */
+export function registerEmbeddingSpace(db, space) {
+    const entry = { version: 1, createdAt: Date.now(), ...space };
+    return writeWhenUnlockedOn(db, () => {
+        db.prepare('INSERT OR IGNORE INTO kv_store (key, namespace, value) VALUES (?, ?, ?)').run(KEY_PREFIX + space.identity.spaceId, NAMESPACE, JSON.stringify(entry));
+    });
+}
+/**
+ * Choose the space for a freshly derived runtime identity: a registered space
+ * it matches, or the derived space, which is then registered. Never throws:
+ * when the registry cannot be read the derived space is used, as before.
+ */
+export function resolveEmbeddingSpace(db, derived, canaryText, canary) {
+    const unavailable = () => ({
+        identity: derived,
+        resolution: 'unavailable',
+        otherSpaces: 0,
+        registration: Promise.resolve(),
+    });
+    if (!db)
+        return unavailable();
+    let entries;
+    try {
+        entries = loadRegisteredSpaces(db);
+    }
+    catch (error) {
+        console.warn(`[EmbeddingSpaceRegistry] could not read registered embedding spaces ` +
+            `(${toErrorMessage(error)}); using the derived space id`);
+        return unavailable();
+    }
+    const match = matchRegisteredSpace(derived, canaryText, canary, entries);
+    if (match) {
+        return {
+            identity: match.entry.identity,
+            resolution: match.exact ? 'matched-exact' : 'matched-cosine',
+            otherSpaces: 0,
+            registration: Promise.resolve(),
+        };
+    }
+    const otherSpaces = entries.filter((entry) => entry.canaryText === canaryText && sameEmbeddingSpaceConfig(entry.identity, derived)).length;
+    const registration = Promise.resolve()
+        .then(() => registerEmbeddingSpace(db, { identity: derived, canaryText, canary: [...canary] }))
+        .catch((error) => {
+        console.warn(`[EmbeddingSpaceRegistry] could not register embedding space ${derived.spaceId.slice(0, 12)} ` +
+            `(${toErrorMessage(error)}); it is registered at a later start`);
+    });
+    return { identity: derived, resolution: 'registered', otherSpaces, registration };
+}
+//# sourceMappingURL=embedding-space-registry.js.map

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