agentic-qe 3.15.16 → 3.15.18

package/dist/learning/real-embeddings.js

@@ -8,9 +8,11 @@
 // 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 { resolveEmbeddingSpaceAdoptingLegacy, } from './embedding-space-registry.js';
+import { findAdoptableLegacySpace } from './embedding-space-legacy-adoption.js';
 // Lazy-loaded transformer pipeline
 let pipeline = null;
 let embeddingModel = null;
@@ -106,7 +108,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 +118,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], createEndpointPipeline(endpointClient))
+                    : 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 +131,17 @@ 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 (#1302: nor one that
+                    // adopted its pre-registry space).
+                    const spaceKept = space?.resolution === 'matched-exact' ||
+                        space?.resolution === 'matched-cosine' ||
+                        space?.resolution === 'adopted-legacy';
+                    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 +190,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 +200,7 @@ async function initializeModel(config = {}, retryingAfterFailure = false) {
                 implementation: `transformers:${fullConfig.quantized ? 'quantized' : 'full'}`,
                 runtimeFingerprint: fingerprintEmbeddingRuntime(canaryVector),
             });
+            activeEmbeddingSpaceIdentity = (await resolveActiveSpace(derivedSpace, EMBEDDING_SPACE_CANARY, canaryVector, initializedModel)).identity;
             initializationFailed = false;
             failureReason = '';
             const loadTime = performance.now() - startTime;
@@ -198,6 +214,55 @@ 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.
+ *
+ * #1302: when no registered space matches, a pre-registry space id whose
+ * stored experience vectors `model` reproduces is adopted instead of minting
+ * a new one. That check re-embeds a bounded number of rows and runs once:
+ * afterwards the chosen space is registered and matched from the registry.
+ */
+async function resolveActiveSpace(derived, canaryText, canary, model) {
+    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 = await resolveEmbeddingSpaceAdoptingLegacy(db, derived, canaryText, canary, async (space, registered) => {
+        const adoption = await findAdoptableLegacySpace(db, space, registered, async (text) => {
+            if (isNonSemanticText(text))
+                return new Array(space.dimensions).fill(0);
+            const output = await model(text, { pooling: 'mean', normalize: true });
+            return Array.from(output.data);
+        });
+        if (adoption.spaceId) {
+            console.log(`[RealEmbeddings] Embedding space ${adoption.spaceId.slice(0, 12)} adopted: it has no reference canary, ` +
+                `and the active runtime reproduces its stored experience vectors: ${adoption.reason}`);
+        }
+        else {
+            console.log(`[RealEmbeddings] No earlier embedding space adopted: ${adoption.reason}`);
+        }
+        return adoption.spaceId;
+    });
+    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 +497,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 +513,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) {

package/dist/learning/rvf-pattern-store.js

@@ -378,7 +378,12 @@ export class RvfPatternStore {
         // Empty string query = return all patterns sorted by quality score
         if (typeof query === 'string' && !query.trim() && this.sqliteStore) {
             try {
-                const allPatterns = this.sqliteStore.getPatterns({ limit: limit * 2 });
+                // Filter by domain in SQL (#1325): a global LIMIT followed by the
+                // domain filter below silently dropped patterns of that domain.
+                const allPatterns = this.sqliteStore.getPatterns({
+                    domain: options.domain,
+                    limit: limit * 2,
+                });
                 const existingIds = new Set(results.map(r => r.pattern.id));
                 for (const pattern of allPatterns) {
                     if (existingIds.has(pattern.id))