agentic-qe 3.13.4 → 3.13.6

package/dist/domains/test-generation/generators/jest-vitest-generator.js

@@ -214,16 +214,6 @@ ${importStatement}
                     code += `      expect(() => instance.${method.name}(${paramsWithUndefined})).toThrow();\n`;
                     code += `    });\n`;
                 }
-                else {
-                    // Use try-catch to handle both throwing (TypeError from property access) and non-throwing
-                    code += `\n    it('should handle undefined ${param.name}', ${asyncPrefix}() => {\n`;
-                    code += `      try {\n`;
-                    code += `        ${method.isAsync ? 'await ' : ''}instance.${method.name}(${paramsWithUndefined});\n`;
-                    code += `      } catch (e) {\n`;
-                    code += `        expect(e).toBeInstanceOf(Error);\n`;
-                    code += `      }\n`;
-                    code += `    });\n`;
-                }
             }
         }
         code += `  });\n\n`;
@@ -235,9 +225,10 @@ ${importStatement}
     generateStubTests(context) {
         const { moduleName, importPath, testType, patterns, dependencies, similarCode } = context;
         const patternComment = this.generatePatternComment(patterns);
-        const basicOpsTest = this.generateBasicOpsTest(moduleName, patterns);
-        const edgeCaseTest = this.generateEdgeCaseTest(moduleName, patterns);
-        const errorHandlingTest = this.generateErrorHandlingTest(moduleName, patterns);
+        const moduleIdentifier = 'moduleUnderTest';
+        const basicOpsTest = this.generateBasicOpsTest(moduleIdentifier, patterns);
+        const edgeCaseTest = this.generateEdgeCaseTest(moduleIdentifier, patterns);
+        const errorHandlingTest = this.generateErrorHandlingTest(moduleIdentifier, patterns);
         // KG: Generate mock declarations for external (non-relative) dependencies only
         let mockDeclarations = '';
         if (dependencies && dependencies.imports.length > 0) {
@@ -264,9 +255,9 @@ ${importStatement}
         if (dependencies && dependencies.imports.length > 0) {
             depTest += `\n    it('should interact with dependencies correctly', () => {\n`;
             depTest += `      // KG-informed: module depends on ${dependencies.imports.length} imports\n`;
-            depTest += `      const instance = typeof ${moduleName} === 'function'\n`;
-            depTest += `        ? new ${moduleName}()\n`;
-            depTest += `        : ${moduleName};\n`;
+            depTest += `      const instance = typeof ${moduleIdentifier} === 'function'\n`;
+            depTest += `        ? new ${moduleIdentifier}()\n`;
+            depTest += `        : ${moduleIdentifier};\n`;
             depTest += `      expect(instance).toBeDefined();\n`;
             depTest += `    });\n`;
         }
@@ -275,21 +266,21 @@ ${importStatement}
         if (dependencies && dependencies.importedBy.length > 0) {
             callerTest += `\n    it('should expose stable API for ${dependencies.importedBy.length} consumers', () => {\n`;
             callerTest += `      // KG-informed: used by ${dependencies.importedBy.slice(0, 3).join(', ')}\n`;
-            callerTest += `      const publicKeys = Object.keys(typeof ${moduleName} === 'function'\n`;
-            callerTest += `        ? ${moduleName}.prototype || {}\n`;
-            callerTest += `        : ${moduleName});\n`;
+            callerTest += `      const publicKeys = Object.keys(typeof ${moduleIdentifier} === 'function'\n`;
+            callerTest += `        ? ${moduleIdentifier}.prototype || {}\n`;
+            callerTest += `        : ${moduleIdentifier});\n`;
             callerTest += `      expect(publicKeys.length).toBeGreaterThan(0);\n`;
             callerTest += `    });\n`;
         }
         const stubImportSource = this.framework === 'vitest' ? 'vitest' : '@jest/globals';
         const stubMockImport = this.framework === 'vitest' ? ', vi' : ', jest';
-        return `${patternComment}import { describe, it, expect, beforeEach${stubMockImport} } from '${stubImportSource}';
-import { ${moduleName} } from '${importPath}';
-${mockDeclarations}
-describe('${moduleName}', () => {
-${similarityComment}  describe('${testType} tests', () => {
-    it('should be defined', () => {
-      expect(${moduleName}).toBeDefined();
+        return `${patternComment}import { describe, it, expect, beforeEach${stubMockImport} } from '${stubImportSource}';
+import * as ${moduleIdentifier} from '${importPath}';
+${mockDeclarations}
+describe('${moduleName}', () => {
+${similarityComment}  describe('${testType} tests', () => {
+    it('should be defined', () => {
+      expect(${moduleIdentifier}).toBeDefined();
     });
 
 ${basicOpsTest}

package/dist/domains/test-generation/services/test-generator.js

@@ -20,6 +20,7 @@ import { TestDataGeneratorService } from './test-data-generator';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { TestQualityGate } from '../gates/index.js';
+import { getGeneratedTestSyntaxIssues } from '../gates/test-quality-gate.js';
 import { EdgeCaseInjector } from '../pattern-injection/index.js';
 import { treeSitterRegistry } from '../../../shared/parsers/multi-language-parser.js';
 import { getLanguageFromExtension } from '../../../shared/types/test-frameworks.js';
@@ -127,7 +128,7 @@ export class TestGeneratorService {
      * Enhance generated test code using LLM
      * Adds edge cases, improves assertions, and adds documentation
      */
-    async enhanceTestWithLLM(testCode, sourceCode, analysis, context) {
+    async enhanceTestWithLLM(testCode, sourceCode, analysis, sourceFilePath, context) {
         if (!this.llmRouter)
             return { code: testCode, enhanced: false };
         try {
@@ -202,6 +203,10 @@ Return ONLY the enhanced test code, no explanations.`,
                 if (codeMatch) {
                     enhancedCode = codeMatch[1].trim();
                 }
+                if (getGeneratedTestSyntaxIssues(enhancedCode, sourceFilePath).length > 0) {
+                    logger.warn('LLM enhancement produced invalid syntax, using deterministic template');
+                    return { code: testCode, enhanced: false };
+                }
                 // #567: only claim enhancement when the model actually returned code.
                 // An empty/unusable response falls back to the template, and the caller
                 // must be told that is what happened.
@@ -465,7 +470,7 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
         // report AI-enhanced output it did not produce.
         let llmEnhanced = false;
         if (this.isLLMEnhancementAvailable() && sourceContent) {
-            const result = await this.enhanceTestWithLLM(testCode, sourceContent, codeAnalysis, context);
+            const result = await this.enhanceTestWithLLM(testCode, sourceContent, codeAnalysis, sourceFile, context);
             testCode = result.code;
             llmEnhanced = result.enhanced;
         }

package/dist/init/orchestrator.js

@@ -51,6 +51,7 @@ export class ModularInitOrchestrator {
                 noGovernance: options.noGovernance,
                 noMcp: options.noMcp,
                 noClaude: options.noClaude,
+                noStatusLine: options.noStatusLine,
                 memoryBackend: options.memoryBackend,
             },
             config: {},

package/dist/init/phases/07-hooks.js

@@ -85,7 +85,9 @@ export class HooksPhase extends BasePhase {
         //  - statusLine / includeCoAuthoredBy preserved when user-set (#362 follow-up)
         //  - AQE-owned sections deep-merged so user additions survive
         const v3Sections = generateV3SettingsSections(config, projectRoot);
-        applyV3Sections(settings, v3Sections);
+        applyV3Sections(settings, v3Sections, {
+            statusLine: !context.options.noStatusLine,
+        });
         // Enable MCP servers (deduplicate, replace old 'aqe' with 'agentic-qe')
         let existingMcp = settings.enabledMcpjsonServers || [];
         // Remove legacy 'aqe' entry if present (renamed to 'agentic-qe')

package/dist/init/phases/phase-interface.d.ts

@@ -139,6 +139,8 @@ export interface InitOptions {
      * unchanged. Pairs naturally with `--no-database`.
      */
     noClaude?: boolean;
+    /** Skip AQE's Claude Code status line and remove a previously AQE-owned one. */
+    noStatusLine?: boolean;
     /** @deprecated Use default behavior instead — MCP is now enabled by default */
     withMcp?: boolean;
     /**

package/dist/init/settings-merge.d.ts

@@ -70,7 +70,9 @@ export declare function isAqeStatusLine(statusLine: unknown): boolean;
  *
  * Mutates and returns `settings`.
  */
-export declare function applyV3Sections(settings: Record<string, unknown>, sections: Record<string, unknown>): Record<string, unknown>;
+export declare function applyV3Sections(settings: Record<string, unknown>, sections: Record<string, unknown>, options?: {
+    statusLine?: boolean;
+}): Record<string, unknown>;
 /**
  * Generate v3-specific settings sections for settings.json.
  * These sections enable the self-learning system, status line, and permissions.

package/dist/init/settings-merge.js

@@ -173,7 +173,7 @@ function isPlainObject(value) {
  *
  * Mutates and returns `settings`.
  */
-export function applyV3Sections(settings, sections) {
+export function applyV3Sections(settings, sections, options = {}) {
     for (const [key, value] of Object.entries(sections)) {
         if (key === '_aqePermissions') {
             const existingPerms = settings.permissions || {};
@@ -182,6 +182,14 @@ export function applyV3Sections(settings, sections) {
             settings.permissions = { ...existingPerms, allow: merged };
         }
         else if (key === 'statusLine') {
+            if (options.statusLine === false) {
+                // Opting out removes only AQE-owned configuration. A status line from
+                // the user or another tool remains outside AQE's ownership boundary.
+                if (isAqeStatusLine(settings.statusLine)) {
+                    delete settings.statusLine;
+                }
+                continue;
+            }
             // Preserve a user's (or another tool's) custom status line.
             if (settings.statusLine === undefined || isAqeStatusLine(settings.statusLine)) {
                 settings.statusLine = value;
@@ -215,8 +223,6 @@ export function generateV3SettingsSections(config, projectRoot) {
         statusLine: {
             type: 'command',
             command: 'sh -c \'node "${CLAUDE_PROJECT_DIR:-.}/.claude/helpers/statusline-v3.cjs" 2>/dev/null || echo "▊ Agentic QE v3"\'',
-            refreshMs: 5000,
-            enabled: true,
         },
         // permissions are union-merged in 07-hooks.ts — not set here to avoid overwriting user entries (#362)
         _aqePermissions: [

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

@@ -112,6 +112,7 @@ export declare class ExperienceReplay {
     private db;
     private prepared;
     private initialized;
+    private initializationPromise;
     private hnswIndex;
     private idToExperienceId;
     private experienceIdToHnswId;
@@ -124,6 +125,7 @@ export declare class ExperienceReplay {
      * Initialize with SQLite persistence
      */
     initialize(): Promise<void>;
+    private initializeOnce;
     /**
      * Ensure required schema exists.
      * Uses captured_experiences as the canonical table (written by experience-capture-middleware).

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/integrations/embeddings/index/HNSWIndex.js

@@ -9,6 +9,8 @@
  *
  * @module integrations/embeddings/index/HNSWIndex
  */
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
 let cachedHnswlibCtor = null;
 function loadHnswlibConstructor() {
     if (cachedHnswlibCtor)

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;
@@ -237,6 +237,22 @@ export async function computeBatchEmbeddings(texts, config = {}) {
     const uncachedTexts = [];
     const uncachedIndices = [];
     const results = new Array(texts.length).fill(null);
+    // Match computeRealEmbedding(): non-semantic inputs are represented by a
+    // zero vector and must never reach the model or its cache (#585).
+    const semanticIndices = [];
+    for (let i = 0; i < texts.length; i++) {
+        if (isNonSemanticText(texts[i])) {
+            results[i] = new Array(getEmbeddingDimension()).fill(0);
+        }
+        else {
+            semanticIndices.push(i);
+        }
+    }
+    // Preserve the single-item API's no-initialization behavior when every
+    // input is non-semantic.
+    if (semanticIndices.length === 0) {
+        return results;
+    }
     // Init BEFORE cache lookup so the cache key namespace is stable.
     if (!embeddingModel) {
         await initializeModel(config);
@@ -245,7 +261,7 @@ export async function computeBatchEmbeddings(texts, config = {}) {
         throw new Error('Embedding model failed to initialize');
     }
     if (fullConfig.enableCache) {
-        for (let i = 0; i < texts.length; i++) {
+        for (const i of semanticIndices) {
             const cached = embeddingCache.get(cacheKey(texts[i]));
             if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
                 results[i] = cached.embedding;
@@ -257,8 +273,8 @@ export async function computeBatchEmbeddings(texts, config = {}) {
         }
     }
     else {
-        uncachedTexts.push(...texts);
-        for (let i = 0; i < texts.length; i++) {
+        for (const i of semanticIndices) {
+            uncachedTexts.push(texts[i]);
             uncachedIndices.push(i);
         }
     }

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