agentic-qe 3.9.31 → 3.9.33

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

@@ -9,7 +9,7 @@
  * This is a facade over UnifiedMemoryManager that maintains
  * backward compatibility with existing MemoryBackend interface.
  */
-import { MemoryBackend, StoreOptions, VectorSearchResult } from './interfaces';
+import { MemoryBackend, StoreOptions, RetrieveOptions, VectorSearchResult } from './interfaces';
 import { UnifiedMemoryManager } from './unified-memory';
 /**
  * SQLite connection configuration (legacy - kept for API compatibility)
@@ -83,21 +83,31 @@ export declare class HybridMemoryBackend implements MemoryBackend {
      */
     set<T>(key: string, value: T, options?: StoreOptions): Promise<void>;
     /**
-     * Retrieve a value
+     * Retrieve a value.
+     *
+     * #491 Bug 2: previously this method hard-coded `defaultNamespace`, so
+     * any caller that wrote with `set(k, v, {namespace:'foo'})` could not
+     * read its own data back. The whole LearningCoordinator read path
+     * (`getExperiencesByDomainAndTime` etc.) was broken by this — writes
+     * landed in `learning-optimization`, reads queried `default`, and
+     * `mineExperiences` mined 0 for every domain even on installs with
+     * hundreds of indexed experiences. Honor the namespace; default
+     * preserves the historical behavior for the many call sites that
+     * still pass no option.
      */
-    get<T>(key: string): Promise<T | undefined>;
+    get<T>(key: string, options?: RetrieveOptions): Promise<T | undefined>;
     /**
      * Delete a value
      */
-    delete(key: string): Promise<boolean>;
+    delete(key: string, options?: RetrieveOptions): Promise<boolean>;
     /**
      * Check if key exists
      */
-    has(key: string): Promise<boolean>;
+    has(key: string, options?: RetrieveOptions): Promise<boolean>;
     /**
-     * Search for keys matching pattern
+     * Search for keys matching pattern. See `get` for the namespace rationale.
      */
-    search(pattern: string, limit?: number): Promise<string[]>;
+    search(pattern: string, limit?: number, options?: RetrieveOptions): Promise<string[]>;
     /**
      * Vector similarity search
      * Now uses unified memory's persistent vector storage

package/dist/kernel/hybrid-backend.js

@@ -92,19 +92,31 @@ export class HybridMemoryBackend {
         await this.unifiedMemory.kvSet(key, value, namespace, options?.ttl);
     }
     /**
-     * Retrieve a value
+     * Retrieve a value.
+     *
+     * #491 Bug 2: previously this method hard-coded `defaultNamespace`, so
+     * any caller that wrote with `set(k, v, {namespace:'foo'})` could not
+     * read its own data back. The whole LearningCoordinator read path
+     * (`getExperiencesByDomainAndTime` etc.) was broken by this — writes
+     * landed in `learning-optimization`, reads queried `default`, and
+     * `mineExperiences` mined 0 for every domain even on installs with
+     * hundreds of indexed experiences. Honor the namespace; default
+     * preserves the historical behavior for the many call sites that
+     * still pass no option.
      */
-    async get(key) {
+    async get(key, options) {
         this.ensureInitialized();
-        return this.unifiedMemory.kvGet(key, this.config.defaultNamespace);
+        const namespace = options?.namespace ?? this.config.defaultNamespace;
+        return this.unifiedMemory.kvGet(key, namespace);
     }
     /**
      * Delete a value
      */
-    async delete(key) {
+    async delete(key, options) {
         this.ensureInitialized();
+        const namespace = options?.namespace ?? this.config.defaultNamespace;
         // Delete from KV store
-        const kvDeleted = await this.unifiedMemory.kvDelete(key, this.config.defaultNamespace);
+        const kvDeleted = await this.unifiedMemory.kvDelete(key, namespace);
         // Also try to delete from vectors (in case it's a vector key)
         const vectorDeleted = await this.unifiedMemory.vectorDelete(key);
         return kvDeleted || vectorDeleted;
@@ -112,16 +124,18 @@ export class HybridMemoryBackend {
     /**
      * Check if key exists
      */
-    async has(key) {
+    async has(key, options) {
         this.ensureInitialized();
-        return this.unifiedMemory.kvExists(key, this.config.defaultNamespace);
+        const namespace = options?.namespace ?? this.config.defaultNamespace;
+        return this.unifiedMemory.kvExists(key, namespace);
     }
     /**
-     * Search for keys matching pattern
+     * Search for keys matching pattern. See `get` for the namespace rationale.
      */
-    async search(pattern, limit = 100) {
+    async search(pattern, limit = 100, options) {
         this.ensureInitialized();
-        return this.unifiedMemory.kvSearch(pattern, this.config.defaultNamespace, limit);
+        const namespace = options?.namespace ?? this.config.defaultNamespace;
+        return this.unifiedMemory.kvSearch(pattern, namespace, limit);
     }
     /**
      * Vector similarity search

package/dist/kernel/interfaces.d.ts

@@ -200,14 +200,21 @@ export interface PluginLoader {
 export interface MemoryBackend extends Initializable, Disposable {
     /** Store a value */
     set<T>(key: string, value: T, options?: StoreOptions): Promise<void>;
-    /** Retrieve a value */
-    get<T>(key: string): Promise<T | undefined>;
+    /**
+     * Retrieve a value.
+     *
+     * `options.namespace` lets callers read from a non-default namespace.
+     * Without this, a caller that wrote with `set(k, v, {namespace:'foo'})`
+     * could not read its own data back — `get` would silently fall through
+     * to the default namespace and return undefined (issue #491 Bug 2).
+     */
+    get<T>(key: string, options?: RetrieveOptions): Promise<T | undefined>;
     /** Delete a value */
-    delete(key: string): Promise<boolean>;
+    delete(key: string, options?: RetrieveOptions): Promise<boolean>;
     /** Check if key exists */
-    has(key: string): Promise<boolean>;
-    /** Search by pattern */
-    search(pattern: string, limit?: number): Promise<string[]>;
+    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[]>;
     /** Store vector embedding */
@@ -230,6 +237,14 @@ export interface StoreOptions {
     namespace?: string;
     persist?: boolean;
 }
+/**
+ * Options for memory read operations. Symmetric with `StoreOptions.namespace`
+ * so a caller can read back exactly what it wrote into a non-default
+ * namespace (issue #491 Bug 2).
+ */
+export interface RetrieveOptions {
+    namespace?: string;
+}
 export interface VectorSearchResult {
     key: string;
     score: number;

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

@@ -2,7 +2,7 @@
  * Agentic QE v3 - Memory Backend
  * Hybrid memory implementation (in-memory + optional persistence)
  */
-import { MemoryBackend, StoreOptions, VectorSearchResult } from './interfaces';
+import { MemoryBackend, StoreOptions, RetrieveOptions, VectorSearchResult } from './interfaces';
 export declare class InMemoryBackend implements MemoryBackend {
     private store;
     private vectors;
@@ -10,10 +10,10 @@ export declare class InMemoryBackend implements MemoryBackend {
     initialize(): Promise<void>;
     dispose(): Promise<void>;
     set<T>(key: string, value: T, options?: StoreOptions): Promise<void>;
-    get<T>(key: string, namespace?: string): Promise<T | undefined>;
-    delete(key: string, namespace?: string): Promise<boolean>;
-    has(key: string, namespace?: string): Promise<boolean>;
-    search(pattern: string, limit?: number): Promise<string[]>;
+    get<T>(key: string, options?: RetrieveOptions): Promise<T | undefined>;
+    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[]>;
     storeVector(key: string, embedding: number[], metadata?: unknown): Promise<void>;
     private buildKey;

package/dist/kernel/memory-backend.js

@@ -34,8 +34,8 @@ export class InMemoryBackend {
         const fullKey = this.buildKey(key, options?.namespace);
         this.store.set(fullKey, entry);
     }
-    async get(key, namespace) {
-        const fullKey = this.buildKey(key, namespace);
+    async get(key, options) {
+        const fullKey = this.buildKey(key, options?.namespace);
         const entry = this.store.get(fullKey);
         if (!entry) {
             return undefined;
@@ -47,20 +47,27 @@ export class InMemoryBackend {
         }
         return entry.value;
     }
-    async delete(key, namespace) {
-        const fullKey = this.buildKey(key, namespace);
+    async delete(key, options) {
+        const fullKey = this.buildKey(key, options?.namespace);
         return this.store.delete(fullKey);
     }
-    async has(key, namespace) {
-        const value = await this.get(key, namespace);
+    async has(key, options) {
+        const value = await this.get(key, options);
         return value !== undefined;
     }
-    async search(pattern, limit = MEMORY_CONSTANTS.DEFAULT_SEARCH_LIMIT) {
+    async search(pattern, limit = MEMORY_CONSTANTS.DEFAULT_SEARCH_LIMIT, options) {
         // Escape regex-special chars first, then convert glob wildcards to regex
         const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
         const regex = new RegExp(escaped.replace(/\*/g, '.*'));
         const results = [];
+        // When a namespace is supplied, scope the scan to that prefix. Matches
+        // HybridBackend's namespace-aware search and lets LearningCoordinator's
+        // namespaced reads behave identically under unit tests that swap in the
+        // in-memory backend (#491 Bug 2).
+        const nsPrefix = options?.namespace ? `${options.namespace}:` : undefined;
         for (const key of this.store.keys()) {
+            if (nsPrefix && !key.startsWith(nsPrefix))
+                continue;
             if (regex.test(key)) {
                 results.push(key);
                 if (results.length >= limit)

package/dist/learning/real-embeddings.js

@@ -58,7 +58,7 @@ async function initializeModel(config = {}) {
     initPromise = (async () => {
         try {
             // Dynamic import to avoid issues if transformers not available
-            const transformers = await import('@xenova/transformers');
+            const transformers = await import('@huggingface/transformers');
             pipeline = transformers.pipeline;
             console.log(`[RealEmbeddings] Loading model: ${fullConfig.modelName}`);
             const startTime = performance.now();