agentic-qe 3.14.1 → 3.14.3

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

@@ -13,6 +13,8 @@ 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';
+import { getTestRunnerExecutionError, TestRunnerExecutionError } from '../../../shared/test-runner-verdict.js';
+import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
 const DEFAULT_CONFIG = {
     simulateForTesting: false,
     simulatedTestsPerFile: 5,
@@ -340,6 +342,9 @@ Provide:
         // Production mode: spawn actual test runner process
         const result = await this.spawnTestRunner(files, framework, timeout);
         if (result.success === false) {
+            // Runner/suite errors have no trustworthy assertion receipt to aggregate.
+            if (result.error instanceof TestRunnerExecutionError)
+                throw result.error;
             // Return as a failed test rather than throwing — allows other files to still run
             return {
                 total: files.length,
@@ -368,12 +373,16 @@ Provide:
             return err(new Error(`Test file not found: ${missingFile}`));
         }
         // Build command based on framework
-        const { command, args } = this.buildTestCommand(files, framework);
+        const { command, args, report } = this.buildTestCommand(files, framework);
         const fileLabel = files.join(', ');
         return new Promise((resolve) => {
             let stdout = '';
             let stderr = '';
             let killed = false;
+            const finish = (result) => {
+                report?.cleanup();
+                resolve(result);
+            };
             // Spawn the test runner process
             // Note: shell: false (default) to prevent command injection (CWE-78)
             // Arguments are passed as array to avoid shell interpretation
@@ -389,7 +398,7 @@ Provide:
             const timeoutId = setTimeout(() => {
                 killed = true;
                 proc.kill('SIGTERM');
-                resolve(err(new Error(`Test execution timed out after ${timeout}ms for files: ${fileLabel}`)));
+                finish(err(new Error(`Test execution timed out after ${timeout}ms for files: ${fileLabel}`)));
             }, timeout);
             proc.stdout?.on('data', (data) => {
                 stdout += data.toString();
@@ -402,8 +411,10 @@ Provide:
                 if (killed) {
                     return; // Already handled by timeout
                 }
-                // Parse results based on framework
-                const parseResult = this.parseTestOutput(stdout, stderr, fileLabel, framework, code);
+                // Parse results based on framework. Vitest 5 writes the JSON report to
+                // a file instead of stdout, so read it back through the report handle.
+                const reportText = report ? report.read(stdout) : stdout;
+                const parseResult = this.parseTestOutput(reportText, 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 && ['vitest', 'jest'].includes(framework.toLowerCase())) {
@@ -415,11 +426,11 @@ Provide:
                         }
                     }
                 }
-                resolve(parseResult);
+                finish(parseResult);
             });
             proc.on('error', (error) => {
                 clearTimeout(timeoutId);
-                resolve(err(new Error(`Failed to spawn test runner: ${error.message}. Is '${command}' installed?`)));
+                finish(err(new Error(`Failed to spawn test runner: ${error.message}. Is '${command}' installed?`)));
             });
         });
     }
@@ -429,11 +440,16 @@ Provide:
     buildTestCommand(fileOrFiles, framework) {
         const files = Array.isArray(fileOrFiles) ? fileOrFiles : [fileOrFiles];
         switch (framework.toLowerCase()) {
-            case 'vitest':
+            case 'vitest': {
+                // --outputFile makes Vitest 4 and 5 both write the JSON report to a
+                // file we own; Vitest 5 no longer prints it to stdout.
+                const report = createVitestJsonReport();
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color'],
+                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color', ...report.args],
+                    report,
                 };
+            }
             case 'jest':
                 return {
                     command: 'npx',
@@ -452,12 +468,15 @@ Provide:
                     command: process.execPath,
                     args: ['--test', ...files],
                 };
-            default:
+            default: {
                 // Default to vitest
+                const report = createVitestJsonReport();
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color'],
+                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color', ...report.args],
+                    report,
                 };
+            }
         }
     }
     /**
@@ -555,11 +574,14 @@ Provide:
                                 duration: assertion.duration || 0,
                             });
                         }
-                        else if (assertion.status === 'skipped' || assertion.status === 'pending') {
+                        else if (assertion.status === 'skipped' || assertion.status === 'pending' || assertion.status === 'todo') {
                             skipped++;
                         }
                     }
                 }
+                const executionError = getTestRunnerExecutionError('vitest', file, exitCode, { passed, failed, skipped }, stderr + '\n' + stdout, json);
+                if (executionError)
+                    return err(executionError);
                 const covData = this.extractCoverageFromJson(json);
                 return ok({
                     total: passed + failed + skipped,
@@ -606,11 +628,14 @@ Provide:
                             duration: assertion.duration || 0,
                         });
                     }
-                    else if (assertion.status === 'skipped' || assertion.status === 'pending') {
+                    else if (assertion.status === 'skipped' || assertion.status === 'pending' || assertion.status === 'todo') {
                         skipped++;
                     }
                 }
             }
+            const executionError = getTestRunnerExecutionError('jest', file, exitCode, { passed, failed, skipped }, stderr + '\n' + stdout, json);
+            if (executionError)
+                return err(executionError);
             const covData = this.extractCoverageFromJson(json);
             return ok({
                 total: passed + failed + skipped,
@@ -646,6 +671,9 @@ Provide:
                     duration: failure.duration || 0,
                 });
             }
+            const executionError = getTestRunnerExecutionError('mocha', file, exitCode, { passed, failed, skipped }, stderr + '\n' + stdout);
+            if (executionError)
+                return err(executionError);
             return ok({
                 total: passed + failed + skipped,
                 passed,
@@ -673,6 +701,9 @@ Provide:
             const passed = parseInt(vitestMatch[1], 10) || 0;
             const failed = parseInt(vitestMatch[2], 10) || 0;
             const skipped = parseInt(vitestMatch[3], 10) || 0;
+            const executionError = getTestRunnerExecutionError('Test runner', file, exitCode, { passed, failed, skipped }, combinedOutput);
+            if (executionError)
+                return err(executionError);
             return ok({
                 total: passed + failed + skipped,
                 passed,
@@ -688,6 +719,9 @@ Provide:
             const failed = parseInt(jestMatch[1], 10) || 0;
             const skipped = parseInt(jestMatch[2], 10) || 0;
             const passed = parseInt(jestMatch[3], 10) || 0;
+            const executionError = getTestRunnerExecutionError('Test runner', file, exitCode, { passed, failed, skipped }, combinedOutput);
+            if (executionError)
+                return err(executionError);
             return ok({
                 total: passed + failed + skipped,
                 passed,

package/dist/init/init-wizard-hooks.js

@@ -406,9 +406,9 @@ mcp__agentic-qe__test_generate_enhanced({
   detectAntiPatterns: true
 })
 
-// Parallel test execution with retry
+// Parallel test execution with retry (concrete paths; expand globs before calling)
 mcp__agentic-qe__test_execute_parallel({
-  testFiles: ["tests/**/*.test.ts"],
+  testFiles: ["tests/auth.test.ts", "tests/session.test.ts"],
   parallelism: 4,
   retryFailures: true,
   maxRetries: 3,

package/dist/integrations/agentic-flow/reasoning-bank/index.js

@@ -155,15 +155,6 @@ export class EnhancedReasoningBankAdapter {
                         ...guidance.suggestedActions.map(a => `Action: ${a}`),
                         ...result.guidance,
                     ];
-                    this.stats.tokensSavedEstimate += guidance.estimatedTokenSavings;
-                    this.stats.experiencesApplied++;
-                    // Record application of each source experience for reuse tracking
-                    for (const src of guidance.sourceExperiences) {
-                        this.experienceReplay.recordApplication(src.id, request.task, true, // success=true at routing time; updated later via recordOutcome
-                        Math.round(guidance.estimatedTokenSavings)).catch(err => {
-                            console.warn(`[EnhancedAdapter] Failed to record experience application: ${err}`);
-                        });
-                    }
                 }
             }
             // Find similar past trajectories
@@ -265,17 +256,8 @@ export class EnhancedReasoningBankAdapter {
         if (!this.experienceReplay) {
             return null;
         }
-        const guidance = await this.experienceReplay.getGuidance(task, domain);
-        if (guidance) {
-            this.stats.experiencesApplied++;
-            // Record application for reuse tracking (experience_applications table)
-            for (const src of guidance.sourceExperiences) {
-                this.experienceReplay.recordApplication(src.id, task, true, Math.round(guidance.estimatedTokenSavings)).catch(err => {
-                    console.warn(`[EnhancedAdapter] Failed to record experience application: ${err}`);
-                });
-            }
-        }
-        return guidance;
+        // Retrieving guidance does not establish that it was applied successfully.
+        return this.experienceReplay.getGuidance(task, domain);
     }
     /**
      * Record that an experience was applied
@@ -290,6 +272,7 @@ export class EnhancedReasoningBankAdapter {
         if (!this.experienceReplay)
             return;
         await this.experienceReplay.recordApplication(experienceId, task, success, tokensSaved);
+        this.stats.experiencesApplied++;
         this.stats.tokensSavedEstimate += tokensSaved;
     }
     // ============================================================================

package/dist/integrations/coherence/engines/cohomology-adapter.js

@@ -19,6 +19,10 @@ import { WasmNotLoadedError, DEFAULT_COHERENCE_LOGGER } from '../types.js';
 // ============================================================================
 // WASM Engine Wrapper
 // ============================================================================
+// Dense restriction maps are copied into WASM. Bound each native call to
+// 32 MiB of matrix cells and 256 MiB of cumulative cells per operation.
+const MAX_NATIVE_BATCH_CELLS = 4 * 1024 * 1024;
+const MAX_NATIVE_TOTAL_CELLS = 32 * 1024 * 1024;
 /**
  * Creates an ICohomologyEngine wrapper around the raw WASM engine
  * Translates from snake_case adapter interface to camelCase WASM API
@@ -53,19 +57,78 @@ function createCohomologyEngineWrapper(rawEngine) {
     // WASM sheaf cohomology expects:
     // { nodes: [{id: number, label: string, section: number[], weight: number}], edges: [...] }
     // "section" is the sheaf theory term for local data at each stalk
-    const buildGraph = () => ({
-        nodes: Array.from(nodes.entries()).map(([id, data]) => ({
-            id: getOrCreateIndex(id), // Convert string ID to numeric index
-            label: id, // Original string ID as label
-            section: Array.from(data.embedding), // Sheaf section = the embedding data
-            weight: 1.0, // Node weight (importance) - default to 1.0
-        })),
-        edges: edges.map(e => ({
-            source: getOrCreateIndex(e.source), // Convert to numeric
-            target: getOrCreateIndex(e.target), // Convert to numeric
-            weight: e.weight,
-        })),
-    });
+    function* buildGraphs() {
+        // Native edge endpoints address the current nodes array by position, not
+        // node.id. Rebuild indices after removals or edges added before nodes.
+        stringToIndex.clear();
+        indexToString.clear();
+        nextIndex = 0;
+        const dimension = nodes.values().next().value?.embedding.length;
+        const graphNodes = Array.from(nodes.entries()).map(([id, data]) => {
+            if (data.embedding.length !== dimension) {
+                throw new RangeError('Cohomology graphs require matching embedding dimensions');
+            }
+            return {
+                id: getOrCreateIndex(id),
+                label: id,
+                section: Array.from(data.embedding),
+                weight: 1.0,
+            };
+        });
+        // Validate the complete operation before allocating any dense matrices or
+        // calling WASM. A rejected graph must never yield partial energy/results.
+        let totalCells = 0;
+        const preparedEdges = edges.map(edge => {
+            const source = nodes.get(edge.source);
+            const target = nodes.get(edge.target);
+            if (!source || !target) {
+                throw new Error(`Cohomology edge references an unknown node: ${edge.source} -> ${edge.target}`);
+            }
+            const dimension = source.embedding.length;
+            const cells = dimension * dimension;
+            if (cells > MAX_NATIVE_BATCH_CELLS) {
+                throw new RangeError(`Cohomology restriction map exceeds ${MAX_NATIVE_BATCH_CELLS} cells`);
+            }
+            totalCells += cells;
+            if (totalCells > MAX_NATIVE_TOTAL_CELLS) {
+                throw new RangeError(`Cohomology graph exceeds ${MAX_NATIVE_TOTAL_CELLS} restriction-map cells`);
+            }
+            return { ...edge, dimension, cells };
+        });
+        let batch = [];
+        let batchCells = 0;
+        const restrictionMaps = new Map();
+        for (const edge of preparedEdges) {
+            if (batchCells + edge.cells > MAX_NATIVE_BATCH_CELLS) {
+                yield { nodes: graphNodes, edges: batch };
+                batch = [];
+                batchCells = 0;
+                restrictionMaps.clear();
+            }
+            let restrictionMap = restrictionMaps.get(edge.dimension);
+            if (!restrictionMap) {
+                // Sections share embedding coordinates; use a row-major identity map.
+                // Sharing the read-only JS matrix avoids per-edge JS allocations.
+                restrictionMap = Array(edge.cells).fill(0);
+                for (let i = 0; i < edge.dimension; i++) {
+                    restrictionMap[i * edge.dimension + i] = 1;
+                }
+                restrictionMaps.set(edge.dimension, restrictionMap);
+            }
+            batch.push({
+                source: stringToIndex.get(edge.source),
+                target: stringToIndex.get(edge.target),
+                weight: edge.weight,
+                restriction_map: restrictionMap,
+                source_dim: edge.dimension,
+                target_dim: edge.dimension,
+            });
+            batchCells += edge.cells;
+        }
+        if (batch.length > 0 || preparedEdges.length === 0) {
+            yield { nodes: graphNodes, edges: batch };
+        }
+    }
     return {
         add_node(id, embedding) {
             nodes.set(id, { embedding });
@@ -79,8 +142,7 @@ function createCohomologyEngineWrapper(rawEngine) {
         },
         remove_node(id) {
             nodes.delete(id);
-            // Note: We don't remove from index mappings to maintain consistency
-            // (indices are reused to avoid graph corruption)
+            // Native indices are rebuilt from current node order on serialization.
             // Remove associated edges
             for (let i = edges.length - 1; i >= 0; i--) {
                 if (edges[i].source === id || edges[i].target === id) {
@@ -94,22 +156,30 @@ function createCohomologyEngineWrapper(rawEngine) {
                 edges.splice(idx, 1);
         },
         sheaf_laplacian_energy() {
-            const graph = buildGraph();
-            return rawEngine.consistencyEnergy(graph);
+            // Native consistency energy is the sum of independent edge energies.
+            let energy = 0;
+            for (const graph of buildGraphs()) {
+                energy += rawEngine.consistencyEnergy(graph);
+            }
+            return energy;
         },
         detect_contradictions(threshold) {
-            const graph = buildGraph();
-            const obstructions = rawEngine.detectObstructions(graph);
-            if (!obstructions)
-                return [];
-            return obstructions
-                .filter(o => o.energy > threshold)
-                .map(o => ({
-                node1: getStringId(o.node1), // Convert back to string ID
-                node2: getStringId(o.node2), // Convert back to string ID
-                severity: o.energy,
-                distance: o.energy,
-            }));
+            const contradictions = [];
+            for (const graph of buildGraphs()) {
+                const obstructions = rawEngine.detectObstructions(graph);
+                for (const obstruction of obstructions ?? []) {
+                    if (obstruction.magnitude > threshold) {
+                        contradictions.push({
+                            node1: getStringId(obstruction.source_node),
+                            node2: getStringId(obstruction.target_node),
+                            severity: obstruction.magnitude,
+                            distance: obstruction.magnitude,
+                        });
+                    }
+                }
+            }
+            // Preserve the native global descending-magnitude order across batches.
+            return contradictions.sort((a, b) => b.distance - a.distance);
         },
         clear() {
             nodes.clear();
@@ -297,7 +367,7 @@ export class CohomologyAdapter {
             nodeIds: [raw.node1, raw.node2],
             severity: this.severityFromDistance(raw.severity),
             description: this.generateContradictionDescription(raw),
-            confidence: 1 - raw.distance, // Higher distance = lower confidence it's a true contradiction
+            confidence: Math.max(0, 1 - raw.distance), // Native magnitudes can exceed one
             resolution: this.suggestResolution(raw),
         };
     }