agentic-qe 3.13.4 → 3.13.5

package/dist/domains/test-execution/services/test-executor.js

@@ -12,6 +12,7 @@ import { TEST_EXECUTION_CONSTANTS, LLM_ANALYSIS_CONSTANTS } from '../../constant
 import { toErrorMessage, toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { secureRandom, secureRandomInt } from '../../../shared/utils/crypto-random.js';
+import { writeQualityEvidence } from '../../quality-assessment/quality-evidence.js';
 const DEFAULT_CONFIG = {
     simulateForTesting: false,
     simulatedTestsPerFile: 5,
@@ -102,8 +103,10 @@ export class TestExecutorService {
                 return err(validation.error);
             }
             const { workers, sharding = 'file', isolation = 'process' } = request;
+            const runnerOwnsParallelism = ['vitest', 'jest'].includes(request.framework.toLowerCase());
+            const processWorkers = runnerOwnsParallelism ? 1 : workers;
             // Shard tests across workers
-            const shards = this.shardTests(request.testFiles, workers, sharding);
+            const shards = this.shardTests(request.testFiles, processWorkers, sharding);
             // Execute shards in parallel
             const shardResults = await Promise.all(shards.map((shard, index) => this.executeWorker(shard, index, isolation, request)));
             // Aggregate results
@@ -132,7 +135,7 @@ export class TestExecutorService {
                 endTime,
                 duration,
                 testsPerSecond: aggregated.total / (duration / 1000),
-                workers,
+                workers: processWorkers,
                 memoryUsage: process.memoryUsage?.().heapUsed ?? 0,
             };
             this.runStats.set(runId, stats);
@@ -327,26 +330,29 @@ Provide:
         };
     }
     async executeTestFile(file, framework, timeout) {
+        return this.executeTestFiles([file], framework, timeout);
+    }
+    async executeTestFiles(files, framework, timeout) {
         // In simulation mode (for unit testing), use random behavior
         if (this.config.simulateForTesting) {
-            return this.simulateTestExecution(file);
+            return this.aggregateResults(files.map(file => this.simulateTestExecution(file)));
         }
         // Production mode: spawn actual test runner process
-        const result = await this.spawnTestRunner(file, framework, timeout);
+        const result = await this.spawnTestRunner(files, framework, timeout);
         if (result.success === false) {
             // Return as a failed test rather than throwing — allows other files to still run
             return {
-                total: 1,
+                total: files.length,
                 passed: 0,
-                failed: 1,
+                failed: files.length,
                 skipped: 0,
-                failedTests: [{
-                        testId: file,
-                        testName: file,
-                        file,
-                        error: result.error.message,
-                        duration: 0,
-                    }],
+                failedTests: files.map(file => ({
+                    testId: file,
+                    testName: file,
+                    file,
+                    error: result.error.message,
+                    duration: 0,
+                })),
                 coverage: this.aggregateCoverage([]),
             };
         }
@@ -355,13 +361,15 @@ Provide:
     /**
      * Spawn actual test runner process (vitest, jest, mocha)
      */
-    async spawnTestRunner(file, framework, timeout) {
+    async spawnTestRunner(files, framework, timeout) {
         // Verify test file exists
-        if (!existsSync(file)) {
-            return err(new Error(`Test file not found: ${file}`));
+        const missingFile = files.find(file => !existsSync(file));
+        if (missingFile) {
+            return err(new Error(`Test file not found: ${missingFile}`));
         }
         // Build command based on framework
-        const { command, args } = this.buildTestCommand(file, framework);
+        const { command, args } = this.buildTestCommand(files, framework);
+        const fileLabel = files.join(', ');
         return new Promise((resolve) => {
             let stdout = '';
             let stderr = '';
@@ -381,7 +389,7 @@ Provide:
             const timeoutId = setTimeout(() => {
                 killed = true;
                 proc.kill('SIGTERM');
-                resolve(err(new Error(`Test execution timed out after ${timeout}ms for file: ${file}`)));
+                resolve(err(new Error(`Test execution timed out after ${timeout}ms for files: ${fileLabel}`)));
             }, timeout);
             proc.stdout?.on('data', (data) => {
                 stdout += data.toString();
@@ -395,10 +403,10 @@ Provide:
                     return; // Already handled by timeout
                 }
                 // Parse results based on framework
-                const parseResult = this.parseTestOutput(stdout, stderr, file, framework, code);
+                const parseResult = this.parseTestOutput(stdout, stderr, fileLabel, framework, code);
                 // If no coverage in stdout JSON, try reading from disk
                 // (vitest/jest write coverage to coverage/coverage-summary.json)
-                if (parseResult.success && !parseResult.value.coverage) {
+                if (parseResult.success && !parseResult.value.coverage && ['vitest', 'jest'].includes(framework.toLowerCase())) {
                     const diskCoverage = this.readCoverageFromDisk();
                     if (diskCoverage) {
                         parseResult.value.coverage = diskCoverage.summary;
@@ -418,33 +426,37 @@ Provide:
     /**
      * Build test command based on framework
      */
-    buildTestCommand(file, framework) {
+    buildTestCommand(fileOrFiles, framework) {
+        const files = Array.isArray(fileOrFiles) ? fileOrFiles : [fileOrFiles];
         switch (framework.toLowerCase()) {
             case 'vitest':
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', file, '--reporter=json', '--no-color',
-                        '--coverage', '--coverage.reporter=json'],
+                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color'],
                 };
             case 'jest':
                 return {
                     command: 'npx',
-                    args: ['jest', file, '--json', '--no-colors', '--testLocationInResults',
-                        '--coverage', '--coverageReporters=json'],
+                    args: ['jest', ...files, '--json', '--no-colors', '--testLocationInResults'],
                 };
             case 'mocha':
                 // Note: mocha has no built-in coverage — requires external nyc/c8 wrapper.
                 // Coverage data will be unavailable for mocha-based test runs.
                 return {
                     command: 'npx',
-                    args: ['mocha', file, '--reporter=json'],
+                    args: ['mocha', ...files, '--reporter=json'],
+                };
+            case 'node':
+            case 'node-test':
+                return {
+                    command: process.execPath,
+                    args: ['--test', ...files],
                 };
             default:
                 // Default to vitest
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', file, '--reporter=json', '--no-color',
-                        '--coverage', '--coverage.reporter=json'],
+                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color'],
                 };
         }
     }
@@ -460,6 +472,9 @@ Provide:
                     return this.parseJestOutput(stdout, stderr, file, exitCode);
                 case 'mocha':
                     return this.parseMochaOutput(stdout, stderr, file, exitCode);
+                case 'node':
+                case 'node-test':
+                    return this.parseNodeTestOutput(stdout, stderr, file, exitCode);
                 default:
                     return this.parseVitestOutput(stdout, stderr, file, exitCode);
             }
@@ -469,6 +484,47 @@ Provide:
                 `stdout: ${stdout.slice(0, 500)}\nstderr: ${stderr.slice(0, 500)}`));
         }
     }
+    /**
+     * Parse the TAP or spec summary emitted by Node's built-in test runner.
+     */
+    parseNodeTestOutput(stdout, stderr, file, exitCode) {
+        const output = `${stdout}\n${stderr}`;
+        const summary = new Map();
+        for (const match of output.matchAll(/^(?:#|ℹ) (tests|pass|fail|cancelled|skipped|todo) (\d+)\s*$/gm)) {
+            summary.set(match[1], Number(match[2]));
+        }
+        const total = summary.get('tests') ?? 0;
+        if (total === 0) {
+            return err(new Error(`node:test reported zero tests for ${file}`));
+        }
+        const passed = summary.get('pass') ?? 0;
+        const failed = summary.get('fail') ?? 0;
+        const skipped = (summary.get('skipped') ?? 0) +
+            (summary.get('cancelled') ?? 0) +
+            (summary.get('todo') ?? 0);
+        if (exitCode !== 0 && failed === 0) {
+            return err(new Error(`node:test exited with code ${exitCode ?? 'unknown'} for ${file}`));
+        }
+        const failedNames = [
+            ...Array.from(output.matchAll(/^not ok \d+ - (.+)$/gm), match => match[1].trim()),
+            ...Array.from(output.matchAll(/^✖ (.+?)(?: \(|$)/gm), match => match[1].trim()),
+        ];
+        const failedTests = Array.from({ length: failed }, (_, index) => ({
+            testId: uuidv4(),
+            testName: failedNames[index] ?? `node:test failure ${index + 1}`,
+            file,
+            error: stderr.trim() || failedNames[index] || 'Test failed',
+            duration: 0,
+        }));
+        return ok({
+            total,
+            passed,
+            failed,
+            skipped,
+            failedTests,
+            coverage: undefined,
+        });
+    }
     /**
      * Parse vitest JSON output
      */
@@ -762,8 +818,7 @@ Provide:
         return shards;
     }
     async executeWorker(files, _workerIndex, _isolation, request) {
-        const results = await Promise.all(files.map(file => this.executeTestFile(file, request.framework, request.timeout ?? 30000)));
-        return this.aggregateResults(results);
+        return this.executeTestFiles(files, request.framework, request.timeout ?? 30000);
     }
     aggregateResults(results) {
         const aggregated = {
@@ -973,6 +1028,14 @@ Provide:
                     statement: result.coverage.statement ?? 0,
                     files: result.fileCoverages?.length ?? 0,
                 }, { persist: true });
+                if (Number.isFinite(result.coverage.line)) {
+                    await writeQualityEvidence(this.memory, {
+                        coverage: result.coverage.line,
+                    }, {
+                        measuredAt: new Date().toISOString(),
+                        source: 'test-execution coverage',
+                    });
+                }
                 // Store per-file coverage via memory.set() (not storeVector) so that
                 // quality-analyzer's getStoredCoverage() can read it with memory.get()
                 if (result.fileCoverages) {

package/dist/domains/test-generation/gates/test-quality-gate.d.ts

@@ -8,9 +8,9 @@
  * 3. Empty test bodies - it('...', () => {}) with no assertions
  * 4. Mirrored assertions - expected values copy-pasted from source literals
  *
- * All detection is regex-based, no LLM calls.
+ * Detection is deterministic (TypeScript parser plus structural checks), with no LLM calls.
  */
-export type TestQualityIssueType = 'no-source-import' | 'tautological-assertion' | 'empty-test-body' | 'mirrored-assertion';
+export type TestQualityIssueType = 'syntax-error' | 'no-assertions' | 'no-source-import' | 'tautological-assertion' | 'empty-test-body' | 'mirrored-assertion';
 export interface TestQualityIssue {
     type: TestQualityIssueType;
     severity: 'error' | 'warning';
@@ -35,6 +35,12 @@ export interface TestQualityGateConfig {
     /** Minimum score to pass (default: 60) */
     minPassScore: number;
 }
+/**
+ * Return parser errors for generated JavaScript/TypeScript.
+ * This is deliberately exported so generation can reject malformed LLM output
+ * before replacing a valid deterministic template.
+ */
+export declare function getGeneratedTestSyntaxIssues(testCode: string, sourceFilePath: string): TestQualityIssue[];
 export declare class TestQualityGate {
     private readonly config;
     constructor(config?: Partial<TestQualityGateConfig>);

package/dist/domains/test-generation/gates/test-quality-gate.js

@@ -8,8 +8,87 @@
  * 3. Empty test bodies - it('...', () => {}) with no assertions
  * 4. Mirrored assertions - expected values copy-pasted from source literals
  *
- * All detection is regex-based, no LLM calls.
+ * Detection is deterministic (TypeScript parser plus structural checks), with no LLM calls.
  */
+import ts from 'typescript';
+function scriptKindFor(filePath) {
+    if (/\.(?:jsx)$/i.test(filePath))
+        return ts.ScriptKind.JSX;
+    if (/\.(?:tsx)$/i.test(filePath))
+        return ts.ScriptKind.TSX;
+    if (/\.(?:js|mjs|cjs)$/i.test(filePath))
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+function isJavaScriptFamily(filePath) {
+    return /\.(?:tsx?|jsx?|mjs|cjs|mts|cts)$/i.test(filePath);
+}
+function parseGeneratedTest(testCode, sourceFilePath) {
+    const extension = sourceFilePath.match(/\.(?:tsx?|jsx?|mjs|cjs|mts|cts)$/i)?.[0] ?? '.ts';
+    return ts.createSourceFile(`generated.test${extension}`, testCode, ts.ScriptTarget.Latest, true, scriptKindFor(sourceFilePath));
+}
+/**
+ * Return parser errors for generated JavaScript/TypeScript.
+ * This is deliberately exported so generation can reject malformed LLM output
+ * before replacing a valid deterministic template.
+ */
+export function getGeneratedTestSyntaxIssues(testCode, sourceFilePath) {
+    if (!isJavaScriptFamily(sourceFilePath))
+        return [];
+    const diagnostics = ts.transpileModule(testCode, {
+        fileName: sourceFilePath,
+        reportDiagnostics: true,
+        compilerOptions: {
+            jsx: ts.JsxEmit.Preserve,
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.Latest,
+        },
+    }).diagnostics ?? [];
+    return diagnostics.map((diagnostic) => {
+        const position = diagnostic.file?.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
+        return {
+            type: 'syntax-error',
+            severity: 'error',
+            line: position ? position.line + 1 : undefined,
+            description: `Generated test has invalid syntax: ${ts.flattenDiagnosticMessageText(diagnostic.messageText, ' ')}`,
+            suggestion: 'Repair the generated test syntax before accepting or executing it.',
+        };
+    });
+}
+function hasExecutableAssertion(testCode, sourceFilePath) {
+    if (!isJavaScriptFamily(sourceFilePath)) {
+        return /\b(?:assert\w*|expect)\s*(?:[.(])/i.test(testCode);
+    }
+    const sourceFile = parseGeneratedTest(testCode, sourceFilePath);
+    let found = false;
+    const visit = (node) => {
+        if (found)
+            return;
+        if (ts.isCallExpression(node)) {
+            const expression = node.expression;
+            if (ts.isIdentifier(expression)) {
+                found = expression.text === 'expect' || expression.text === 'assert';
+            }
+            else if (ts.isPropertyAccessExpression(expression)) {
+                let root = expression.expression;
+                while (ts.isPropertyAccessExpression(root))
+                    root = root.expression;
+                if (ts.isIdentifier(root) && root.text === 'assert') {
+                    found = true;
+                }
+                else if (ts.isIdentifier(root)
+                    && root.text === 'expect'
+                    && expression.name.text !== 'assertions'
+                    && expression.name.text !== 'hasAssertions') {
+                    found = true;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return found;
+}
 const DEFAULT_CONFIG = {
     checkSourceImports: true,
     checkTautologicalAssertions: true,
@@ -34,7 +113,15 @@ export class TestQualityGate {
      * @returns Gate result with pass/fail, issues, and score
      */
     validate(testCode, sourceFilePath, sourceCode) {
-        const issues = [];
+        const issues = getGeneratedTestSyntaxIssues(testCode, sourceFilePath);
+        if (!hasExecutableAssertion(testCode, sourceFilePath)) {
+            issues.push({
+                type: 'no-assertions',
+                severity: 'error',
+                description: 'Generated test contains no executable assertions.',
+                suggestion: 'Add at least one assertion that observes behavior from the source under test.',
+            });
+        }
         if (this.config.checkSourceImports) {
             issues.push(...this.detectMissingSourceImports(testCode, sourceFilePath));
         }
@@ -47,8 +134,10 @@ export class TestQualityGate {
         if (this.config.checkMirroredAssertions && sourceCode) {
             issues.push(...this.detectMirroredAssertions(testCode, sourceCode));
         }
-        const score = this.calculateScore(issues);
-        const passed = score >= this.config.minPassScore;
+        const mechanicallyInvalid = issues.some(issue => issue.type === 'syntax-error' || issue.type === 'no-assertions');
+        const hasError = issues.some(issue => issue.severity === 'error');
+        const score = mechanicallyInvalid ? 0 : this.calculateScore(issues);
+        const passed = !hasError && score >= this.config.minPassScore;
         return { passed, issues, score };
     }
     // ============================================================================

package/dist/domains/test-generation/generators/base-test-generator.js

@@ -157,21 +157,6 @@ export class BaseTestGenerator {
                         assertion: 'expect(action).toThrow();',
                     });
                 }
-                else {
-                    // Function has no explicit throw — but may still crash on property access.
-                    // Use try-catch pattern that accepts either behavior.
-                    const undefinedCall = fn.isAsync
-                        ? `await ${fn.name}(${paramsWithUndefined})`
-                        : `${fn.name}(${paramsWithUndefined})`;
-                    testCases.push({
-                        description: `should handle undefined ${param.name}`,
-                        type: 'edge-case',
-                        action: fn.isAsync
-                            ? `let threw = false;\n    try {\n      await ${fn.name}(${paramsWithUndefined});\n    } catch (e) {\n      threw = true;\n      expect(e).toBeInstanceOf(Error);\n    }`
-                            : `let threw = false;\n    try {\n      ${fn.name}(${paramsWithUndefined});\n    } catch (e) {\n      threw = true;\n      expect(e).toBeInstanceOf(Error);\n    }`,
-                        assertion: `expect(true).toBe(true); // function either handles undefined or throws TypeError`,
-                    });
-                }
             }
             // Type-specific boundary tests
             testCases.push(...this.generateBoundaryTestCases(fn, param));

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/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/learning/real-embeddings.js

@@ -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);
         }
     }