agentic-qe 3.13.5 → 3.13.6

package/dist/integrations/agentic-flow/reasoning-bank/experience-replay.js

@@ -59,6 +59,7 @@ export class ExperienceReplay {
     db = null;
     prepared = new Map();
     initialized = false;
+    initializationPromise = null;
     // Real HNSW index for O(log n) similarity search (150x-12,500x faster than linear scan)
     hnswIndex;
     // Mapping from HNSW numeric IDs to experience string IDs
@@ -95,6 +96,19 @@ export class ExperienceReplay {
     async initialize() {
         if (this.initialized)
             return;
+        if (this.initializationPromise)
+            return this.initializationPromise;
+        this.initializationPromise = this.initializeOnce();
+        try {
+            await this.initializationPromise;
+        }
+        catch (error) {
+            // Allow a later caller to retry after a failed initialization.
+            this.initializationPromise = null;
+            throw error;
+        }
+    }
+    async initializeOnce() {
         this.unifiedMemory = getUnifiedMemory();
         await this.unifiedMemory.initialize();
         this.db = this.unifiedMemory.getDatabase();

package/dist/kernel/hybrid-backend.d.ts

@@ -123,7 +123,7 @@ export declare class HybridMemoryBackend implements MemoryBackend {
      * Vector similarity search
      * Now uses unified memory's persistent vector storage
      */
-    vectorSearch(embedding: number[], k: number): Promise<VectorSearchResult[]>;
+    vectorSearch(embedding: number[], k: number, keyPrefix?: string): Promise<VectorSearchResult[]>;
     /**
      * Store vector embedding
      * Now persists to unified memory.db

package/dist/kernel/hybrid-backend.js

@@ -154,9 +154,9 @@ export class HybridMemoryBackend {
      * Vector similarity search
      * Now uses unified memory's persistent vector storage
      */
-    async vectorSearch(embedding, k) {
+    async vectorSearch(embedding, k, keyPrefix) {
         this.ensureInitialized();
-        const results = await this.unifiedMemory.vectorSearch(embedding, k);
+        const results = await this.unifiedMemory.vectorSearch(embedding, k, undefined, keyPrefix);
         // Convert to VectorSearchResult format
         return results.map(r => ({
             key: r.id,

package/dist/kernel/interfaces.d.ts

@@ -215,8 +215,8 @@ export interface MemoryBackend extends Initializable, Disposable {
     has(key: string, options?: RetrieveOptions): Promise<boolean>;
     /** Search by pattern (`options.namespace` mirrors `get`). */
     search(pattern: string, limit?: number, options?: RetrieveOptions): Promise<string[]>;
-    /** Vector similarity search (HNSW) */
-    vectorSearch(embedding: number[], k: number): Promise<VectorSearchResult[]>;
+    /** Vector similarity search (HNSW), optionally scoped by logical key prefix. */
+    vectorSearch(embedding: number[], k: number, keyPrefix?: string): Promise<VectorSearchResult[]>;
     /** Store vector embedding */
     storeVector(key: string, embedding: number[], metadata?: unknown): Promise<void>;
     /**

package/dist/kernel/memory-backend.d.ts

@@ -14,7 +14,7 @@ export declare class InMemoryBackend implements MemoryBackend {
     delete(key: string, options?: RetrieveOptions): Promise<boolean>;
     has(key: string, options?: RetrieveOptions): Promise<boolean>;
     search(pattern: string, limit?: number, options?: RetrieveOptions): Promise<string[]>;
-    vectorSearch(embedding: number[], k: number): Promise<VectorSearchResult[]>;
+    vectorSearch(embedding: number[], k: number, keyPrefix?: string): Promise<VectorSearchResult[]>;
     storeVector(key: string, embedding: number[], metadata?: unknown): Promise<void>;
     private buildKey;
     private cleanup;

package/dist/kernel/memory-backend.js

@@ -76,9 +76,11 @@ export class InMemoryBackend {
         }
         return results;
     }
-    async vectorSearch(embedding, k) {
+    async vectorSearch(embedding, k, keyPrefix) {
         const results = [];
         for (const [key, entry] of this.vectors.entries()) {
+            if (keyPrefix && !key.startsWith(keyPrefix))
+                continue;
             const score = cosineSimilarity(embedding, entry.embedding);
             results.push({ key, score, metadata: entry.metadata });
         }

package/dist/kernel/unified-memory.d.ts

@@ -157,7 +157,7 @@ export declare class UnifiedMemoryManager {
         metadata?: unknown;
     } | undefined>;
     vectorDelete(id: string): Promise<boolean>;
-    vectorSearch(query: number[], k?: number, namespace?: string): Promise<Array<{
+    vectorSearch(query: number[], k?: number, namespace?: string, keyPrefix?: string): Promise<Array<{
         id: string;
         score: number;
         metadata?: unknown;

package/dist/kernel/unified-memory.js

@@ -733,12 +733,24 @@ export class UnifiedMemoryManager {
         this.vectorIndex.remove(id);
         return result.changes > 0;
     }
-    async vectorSearch(query, k = 10, namespace) {
+    async vectorSearch(query, k = 10, namespace, keyPrefix) {
         this.ensureInitialized();
         if (!this.vectorsLoaded) {
             await this.loadVectorIndex();
         }
-        const results = this.vectorIndex.search(query, k * 2);
+        // Logical namespaces are encoded in vector ids (`namespace:key`), while
+        // the vectors table namespace identifies the physical backend. Widen the
+        // ANN query until enough logical matches are found so global top-K results
+        // cannot hide a valid namespaced hit.
+        const indexSize = this.vectorIndex.size();
+        let candidateCount = Math.min(indexSize, Math.max(k * 2, 1));
+        let results = this.vectorIndex.search(query, candidateCount);
+        while (keyPrefix &&
+            results.filter(result => result.id.startsWith(keyPrefix)).length < k &&
+            candidateCount < indexSize) {
+            candidateCount = Math.min(indexSize, candidateCount * 2);
+            results = this.vectorIndex.search(query, candidateCount);
+        }
         if (results.length === 0)
             return [];
         const ids = results.map(r => r.id);
@@ -749,7 +761,7 @@ export class UnifiedMemoryManager {
             const filteredResults = [];
             for (const result of results) {
                 const row = metadataMap.get(result.id);
-                if (row && row.namespace === namespace) {
+                if (row && row.namespace === namespace && (!keyPrefix || result.id.startsWith(keyPrefix))) {
                     filteredResults.push({
                         id: result.id, score: result.score,
                         metadata: row.metadata ? safeJsonParse(row.metadata) : undefined,
@@ -760,7 +772,10 @@ export class UnifiedMemoryManager {
             }
             return filteredResults;
         }
-        return results.slice(0, k).map(result => {
+        const scopedResults = keyPrefix
+            ? results.filter(result => result.id.startsWith(keyPrefix)).slice(0, k)
+            : results.slice(0, k);
+        return scopedResults.map(result => {
             const row = metadataMap.get(result.id);
             return {
                 id: result.id, score: result.score,

package/dist/learning/real-embeddings.js

@@ -137,7 +137,7 @@ async function initializeModel(config = {}) {
             catch {
                 throw new Error('In-process embeddings require the optional package "@huggingface/transformers", ' +
                     'which is not installed. Either run `npm install @huggingface/transformers`, or ' +
-                    'configure an embedding endpoint (EmbeddingConfig.endpoint / AQE_EMBEDDING_ENDPOINT) ' +
+                    'configure an embedding endpoint (EmbeddingConfig.endpoint / AQE_EMBEDDER_ENDPOINT) ' +
                     'so no local model is loaded.');
             }
             pipeline = transformers.pipeline;

package/dist/learning/sqlite-persistence.d.ts

@@ -224,8 +224,9 @@ export declare class SQLitePatternStore {
     };
     /**
      * Backfill embeddings for patterns that don't have them.
-     * Uses real all-MiniLM-L6-v2 transformer embeddings via @xenova/transformers.
-     * Falls back to hash-based embeddings if ONNX is unavailable.
+     * Uses real all-MiniLM-L6-v2 transformer embeddings via @huggingface/transformers
+     * or the configured external endpoint. Refuses hash proxies because mixing
+     * embedding spaces makes semantic retrieval results invalid.
      * Skips bench/test patterns (id LIKE 'bench-%').
      *
      * @param batchSize - Patterns per inference batch (default: 32, matches model batch size)

package/dist/learning/sqlite-persistence.js

@@ -923,8 +923,9 @@ export class SQLitePatternStore {
     }
     /**
      * Backfill embeddings for patterns that don't have them.
-     * Uses real all-MiniLM-L6-v2 transformer embeddings via @xenova/transformers.
-     * Falls back to hash-based embeddings if ONNX is unavailable.
+     * Uses real all-MiniLM-L6-v2 transformer embeddings via @huggingface/transformers
+     * or the configured external endpoint. Refuses hash proxies because mixing
+     * embedding spaces makes semantic retrieval results invalid.
      * Skips bench/test patterns (id LIKE 'bench-%').
      *
      * @param batchSize - Patterns per inference batch (default: 32, matches model batch size)
@@ -957,7 +958,7 @@ export class SQLitePatternStore {
         let processed = 0;
         let skipped = 0;
         let errors = 0;
-        let method = 'transformer';
+        const method = 'transformer';
         // Process in batches: compute embeddings async, then insert in sync transaction
         for (let i = 0; i < patternsWithout.length; i += batchSize) {
             const batch = patternsWithout.slice(i, i + batchSize);
@@ -996,11 +997,9 @@ export class SQLitePatternStore {
                     throw new Error(`[SQLitePatternStore] external embedder endpoint failed during backfill; ` +
                         `aborting to protect HNSW index. Original error: ${toErrorMessage(e)}`);
                 }
-                // In-process transformer path: hash fallback is acceptable because the
-                // entire index in this mode is hash-based anyway.
-                console.warn(`[SQLitePatternStore] Transformer unavailable, falling back to hash embeddings: ${toErrorMessage(e)}`);
-                method = 'hash-fallback';
-                embeddings = textsWithIds.map(t => hashEmbedding(t.text, dimension));
+                throw new Error(`[SQLitePatternStore] semantic embedding unavailable; refusing to write hash proxies. ` +
+                    `Install @huggingface/transformers or configure AQE_EMBEDDER_ENDPOINT. ` +
+                    `Original error: ${toErrorMessage(e)}`);
             }
             // Insert computed embeddings in a sync transaction
             const embeddingTag = method === 'transformer' ? 'transformer-backfill' : 'hash-backfill';