agentic-qe 3.15.16 → 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.
@@ -97,6 +102,25 @@ export class EmbedderEndpointTimeoutError extends Error {
         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.
  *
@@ -160,6 +184,9 @@ class CircuitBreaker {
         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.
  */
@@ -169,6 +196,15 @@ 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;
     /**
@@ -260,6 +296,9 @@ 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.
@@ -328,17 +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();
     }

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/real-embeddings.d.ts

@@ -40,6 +40,7 @@ export interface EmbeddingConfig {
     endpointToken?: string;
 }
 export declare const DEFAULT_EMBEDDING_CONFIG: EmbeddingConfig;
+export declare function __spaceRegistrationSettledForTests(): Promise<void>;
 /**
  * Compute real embedding using transformer model
  *
@@ -95,6 +96,8 @@ export declare function allowEmbedderInitRetry(): void;
  *   for the breaker window as well as the caller's retry interval. The probe
  *   must find the identity this process bound to (ADR-097): a changed
  *   fingerprint means vectors would not be comparable.
+ *   The client refuses it (EmbedderEndpointIdentityChangedError) and keeps
+ *   refusing every caller, also when its breaker recovers on its own (#1282).
  * Callers rate-limit rechecks, then embed a canary to confirm.
  */
 export declare function recheckEmbedder(config?: Partial<EmbeddingConfig>): Promise<void>;

package/dist/learning/real-embeddings.js

@@ -8,9 +8,10 @@
 // Re-export cosineSimilarity from shared utility for backward compatibility
 export { cosineSimilarity } from '../shared/utils/vector-math.js';
 import { toErrorMessage } from '../shared/error-utils.js';
-import { EmbedderEndpointClient, redactEndpoint, } from './embedder-endpoint-client.js';
+import { EmbedderEndpointClient, ENDPOINT_IDENTITY_CANARY, redactEndpoint, } from './embedder-endpoint-client.js';
 import { loadEmbedderIdentity, resetEmbedderIdentityStore, saveEmbedderIdentity, } from './embedder-identity-store.js';
 import { EMBEDDING_SPACE_CANARY, deriveEmbeddingSpaceIdentity, fingerprintEmbeddingRuntime, } from './embedding-space.js';
+import { resolveEmbeddingSpace, } from './embedding-space-registry.js';
 // Lazy-loaded transformer pipeline
 let pipeline = null;
 let embeddingModel = null;
@@ -106,7 +107,7 @@ async function initializeModel(config = {}, retryingAfterFailure = false) {
                 });
                 // Probe + identity fingerprint. Fails loud on dim mismatch.
                 endpointIdentity = await endpointClient.probe();
-                activeEmbeddingSpaceIdentity = deriveEmbeddingSpaceIdentity({
+                const derivedSpace = deriveEmbeddingSpaceIdentity({
                     provider: 'openai-compatible-endpoint',
                     model: fullConfig.modelName,
                     dimensions: endpointIdentity.dim,
@@ -116,6 +117,11 @@ async function initializeModel(config = {}, retryingAfterFailure = false) {
                     implementation: endpointIdentity.endpoint,
                     runtimeFingerprint: endpointIdentity.fingerprint,
                 });
+                const boundCanary = endpointClient.getBoundCanary();
+                const space = boundCanary
+                    ? await resolveActiveSpace(derivedSpace, ENDPOINT_IDENTITY_CANARY, [...boundCanary])
+                    : null;
+                activeEmbeddingSpaceIdentity = space?.identity ?? derivedSpace;
                 console.log(`[RealEmbeddings] Endpoint identity: dim=${endpointIdentity.dim} fingerprint=${endpointIdentity.fingerprint}`);
                 // Cross-run drift detection: compare against the last-known identity
                 // for this endpoint (memory.db kv_store, namespace _system). If the
@@ -124,9 +130,14 @@ async function initializeModel(config = {}, retryingAfterFailure = false) {
                 // remote silently changed (poisoning risk for the existing index).
                 try {
                     const previous = loadEmbedderIdentity(endpointIdentity.endpoint);
-                    if (previous && previous.fingerprint !== endpointIdentity.fingerprint) {
+                    // #1298: a restart that kept its registered space is not a change,
+                    // even when float noise moved the fingerprint.
+                    const spaceKept = space?.resolution === 'matched-exact' || space?.resolution === 'matched-cosine';
+                    const changed = (previous !== null && previous.fingerprint !== endpointIdentity.fingerprint) ||
+                        (space?.otherSpaces ?? 0) > 0;
+                    if (!spaceKept && changed) {
                         console.warn(`[RealEmbeddings] WARNING: endpoint identity changed since last run. ` +
-                            `Previous fingerprint=${previous.fingerprint} dim=${previous.dim}, ` +
+                            `Previous fingerprint=${previous?.fingerprint ?? 'unknown'} dim=${previous?.dim ?? 'unknown'}, ` +
                             `current fingerprint=${endpointIdentity.fingerprint} dim=${endpointIdentity.dim}. ` +
                             `Vectors written before this change may no longer be comparable.`);
                     }
@@ -175,7 +186,7 @@ async function initializeModel(config = {}, retryingAfterFailure = false) {
                 normalize: true,
             });
             const canaryVector = Array.from(canary.data);
-            activeEmbeddingSpaceIdentity = deriveEmbeddingSpaceIdentity({
+            const derivedSpace = deriveEmbeddingSpaceIdentity({
                 provider: 'huggingface-transformers',
                 model: fullConfig.modelName,
                 dimensions: canaryVector.length,
@@ -185,6 +196,7 @@ async function initializeModel(config = {}, retryingAfterFailure = false) {
                 implementation: `transformers:${fullConfig.quantized ? 'quantized' : 'full'}`,
                 runtimeFingerprint: fingerprintEmbeddingRuntime(canaryVector),
             });
+            activeEmbeddingSpaceIdentity = (await resolveActiveSpace(derivedSpace, EMBEDDING_SPACE_CANARY, canaryVector)).identity;
             initializationFailed = false;
             failureReason = '';
             const loadTime = performance.now() - startTime;
@@ -198,6 +210,35 @@ async function initializeModel(config = {}, retryingAfterFailure = false) {
     })();
     return initPromise;
 }
+/** @internal test seam: settles when the last space registration write ran. */
+let lastSpaceRegistration = Promise.resolve();
+export function __spaceRegistrationSettledForTests() {
+    return lastSpaceRegistration;
+}
+/**
+ * #1298: keep a restarted runtime in its registered embedding space when its
+ * canary is within the round-trip cosine of that space's reference, instead
+ * of minting a new id from the exact fingerprint. Uses the shared memory.db
+ * connection only when UnifiedMemory is already open; otherwise (and on any
+ * registry error) the derived space is used, as before.
+ */
+async function resolveActiveSpace(derived, canaryText, canary) {
+    let db = null;
+    try {
+        const { getOpenUnifiedMemoryDatabase } = await import('../kernel/unified-memory.js');
+        db = getOpenUnifiedMemoryDatabase();
+    }
+    catch (error) {
+        console.warn(`[RealEmbeddings] embedding-space registry unavailable: ${toErrorMessage(error)}`);
+    }
+    const resolved = resolveEmbeddingSpace(db, derived, canaryText, canary);
+    lastSpaceRegistration = resolved.registration;
+    if (resolved.resolution === 'matched-cosine') {
+        console.log(`[RealEmbeddings] Embedding space ${resolved.identity.spaceId.slice(0, 12)} kept: ` +
+            `runtime fingerprint ${derived.runtimeFingerprint} is within the round-trip cosine of its reference`);
+    }
+    return resolved;
+}
 /**
  * Build a FeatureExtractionPipeline-shaped wrapper around the endpoint client.
  * The shape matches `pipeline('feature-extraction', ...)` so the rest of
@@ -432,6 +473,8 @@ export function allowEmbedderInitRetry() {
  *   for the breaker window as well as the caller's retry interval. The probe
  *   must find the identity this process bound to (ADR-097): a changed
  *   fingerprint means vectors would not be comparable.
+ *   The client refuses it (EmbedderEndpointIdentityChangedError) and keeps
+ *   refusing every caller, also when its breaker recovers on its own (#1282).
  * Callers rate-limit rechecks, then embed a canary to confirm.
  */
 export async function recheckEmbedder(config = {}) {
@@ -446,12 +489,7 @@ export async function recheckEmbedder(config = {}) {
     // succeeded yet; embed() would only start that trial and fail fast.
     if (!client || !client.needsTrial())
         return;
-    const identity = await client.probeThroughOpenBreaker();
-    if (endpointIdentity && identity.fingerprint !== endpointIdentity.fingerprint) {
-        throw new Error(`[RealEmbeddings] endpoint identity changed since this process bound to it ` +
-            `(fingerprint ${endpointIdentity.fingerprint} -> ${identity.fingerprint}); ` +
-            `restart to use the new embedding space`);
-    }
+    await client.probeThroughOpenBreaker();
 }
 async function retryInitialization(config) {
     if (endpointClient) {