agentic-qe 3.14.7 → 3.14.8

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

@@ -4,7 +4,8 @@
  */
 import { LoggerFactory } from '../../../logging/index.js';
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../../shared/types/index.js';
@@ -16,6 +17,7 @@ import { writeQualityEvidence } from '../../quality-assessment/quality-evidence.
 import { getTestRunnerExecutionError, TestRunnerExecutionError } from '../../../shared/test-runner-verdict.js';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
+import { terminateTestRunner, trackTestRunnerExit } from '../../../shared/test-runner-process.js';
 const DEFAULT_CONFIG = {
     simulateForTesting: false,
     simulatedTestsPerFile: 5,
@@ -368,19 +370,29 @@ Provide:
             return err(new Error(`Test file not found: ${missingFile}`));
         }
         // Build command based on framework
-        const { command, args, report } = this.buildTestCommand(files, framework);
+        const { command, args, report, coverageDirectory } = this.buildTestCommand(files, framework);
         const fileLabel = files.join(', ');
         return new Promise((resolve) => {
             let stdout = '';
             let stderr = '';
             let killed = false;
+            let termination;
             let settled = false;
+            const cleanupArtifacts = () => {
+                report?.cleanup();
+                if (coverageDirectory) {
+                    try {
+                        rmSync(coverageDirectory, { recursive: true, force: true });
+                    }
+                    catch { /* Best effort. */ }
+                }
+            };
             const finish = (result, cleanup = true) => {
                 if (settled)
                     return;
                 settled = true;
                 if (cleanup)
-                    report?.cleanup();
+                    cleanupArtifacts();
                 resolve(result);
             };
             // Spawn the test runner process
@@ -390,6 +402,7 @@ Provide:
             try {
                 proc = spawn(command, args, {
                     cwd: process.cwd(),
+                    detached: process.platform !== 'win32',
                     env: {
                         ...process.env,
                         FORCE_COLOR: '0', // Disable color codes for easier parsing
@@ -401,10 +414,15 @@ Provide:
                 finish(err(new Error(`Failed to spawn test runner: ${toErrorMessage(error)}. Is '${command}' installed?`)));
                 return;
             }
+            const untrackExit = trackTestRunnerExit(proc);
             // Set timeout
             const timeoutId = setTimeout(() => {
                 killed = true;
-                proc.kill('SIGTERM');
+                termination = terminateTestRunner(proc);
+                // Keep the timeout outcome immediate; cleanup waits for the owned
+                // group, rather than treating the root's close as descendant exit.
+                termination.catch(error => logger.warn(`Test runner cleanup failed: ${toErrorMessage(error)}`));
+                termination.then(untrackExit, () => undefined);
                 finish(err(new Error(`Test execution timed out after ${timeout}ms for files: ${fileLabel}`)), false);
             }, timeout);
             proc.stdout?.on('data', (data) => {
@@ -416,9 +434,12 @@ Provide:
             proc.on('close', (code) => {
                 clearTimeout(timeoutId);
                 if (killed) {
-                    report?.cleanup();
-                    return; // Timeout result was already returned; child has now closed.
+                    // Coverage and JSON reports belong to this run; clean both only
+                    // after the entire owned process group has stopped.
+                    termination?.then(() => cleanupArtifacts(), () => undefined);
+                    return; // The timeout result has already been returned.
                 }
+                untrackExit();
                 // 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.
                 let reportText;
@@ -434,10 +455,10 @@ Provide:
                     return;
                 }
                 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())) {
-                    const diskCoverage = this.readCoverageFromDisk();
+                // Read only this invocation's coverage artifacts. A previous or
+                // concurrent run's project coverage directory is not evidence.
+                if (parseResult.success && !parseResult.value.coverage && coverageDirectory) {
+                    const diskCoverage = this.readCoverageFromDisk(coverageDirectory);
                     if (diskCoverage) {
                         parseResult.value.coverage = diskCoverage.summary;
                         if (diskCoverage.perFile.length > 0) {
@@ -451,6 +472,7 @@ Provide:
                 clearTimeout(timeoutId);
                 if (killed)
                     return;
+                untrackExit();
                 finish(err(new Error(`Failed to spawn test runner: ${error.message}. Is '${command}' installed?`)));
             });
         });
@@ -460,22 +482,35 @@ Provide:
      */
     buildTestCommand(fileOrFiles, framework) {
         const files = Array.isArray(fileOrFiles) ? fileOrFiles : [fileOrFiles];
+        const createCoverageDirectory = () => mkdtempSync(join(tmpdir(), 'aqe-test-coverage-'));
         switch (framework.toLowerCase()) {
             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();
+                const coverageDirectory = createCoverageDirectory();
+                let report;
+                try {
+                    report = createVitestJsonReport();
+                }
+                catch (error) {
+                    rmSync(coverageDirectory, { recursive: true, force: true });
+                    throw error;
+                }
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color', ...report.args],
+                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color', ...report.args, `--coverage.reportsDirectory=${coverageDirectory}`],
                     report,
+                    coverageDirectory,
                 };
             }
-            case 'jest':
+            case 'jest': {
+                const coverageDirectory = createCoverageDirectory();
                 return {
                     command: 'npx',
-                    args: ['jest', ...files, '--json', '--no-colors', '--testLocationInResults'],
+                    args: ['jest', ...files, '--json', '--no-colors', '--testLocationInResults', `--coverageDirectory=${coverageDirectory}`],
+                    coverageDirectory,
                 };
+            }
             case 'mocha':
                 // Note: mocha has no built-in coverage — requires external nyc/c8 wrapper.
                 // Coverage data will be unavailable for mocha-based test runs.
@@ -491,11 +526,20 @@ Provide:
                 };
             default: {
                 // Default to vitest
-                const report = createVitestJsonReport();
+                const coverageDirectory = createCoverageDirectory();
+                let report;
+                try {
+                    report = createVitestJsonReport();
+                }
+                catch (error) {
+                    rmSync(coverageDirectory, { recursive: true, force: true });
+                    throw error;
+                }
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color', ...report.args],
+                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color', ...report.args, `--coverage.reportsDirectory=${coverageDirectory}`],
                     report,
+                    coverageDirectory,
                 };
             }
         }
@@ -1003,16 +1047,16 @@ Provide:
         return { perFile };
     }
     /**
-     * Read coverage from disk files written by vitest/jest.
-     * Both runners write coverage-summary.json to a coverage/ directory when
-     * --coverage is passed, rather than embedding it in stdout JSON.
+     * Read coverage from the private output directory of a completed runner.
+     * Setting the directory does not enable coverage; project configuration
+     * still decides whether coverage is collected.
      */
-    readCoverageFromDisk() {
+    readCoverageFromDisk(coverageDirectory) {
         try {
             // Check common coverage output paths
             const candidates = [
-                join(process.cwd(), 'coverage', 'coverage-summary.json'),
-                join(process.cwd(), 'coverage', 'coverage-final.json'),
+                join(coverageDirectory, 'coverage-summary.json'),
+                join(coverageDirectory, 'coverage-final.json'),
             ];
             for (const filePath of candidates) {
                 if (!existsSync(filePath))

package/dist/init/fleet-integration.js

@@ -122,12 +122,13 @@ export class FleetInitEnhancer {
                 enableVectorEmbeddings: true,
             });
             // Find all source files
-            const glob = await import('fast-glob');
-            const files = await glob.default([
+            const { glob } = await import('tinyglobby');
+            const files = await glob([
                 '**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py'
             ], {
                 cwd: this.projectRoot,
                 ignore: ['node_modules/**', 'dist/**', 'coverage/**', '.agentic-qe/**'],
+                expandDirectories: false,
             });
             console.log(chalk.gray(`  Indexing ${files.length} files...`));
             // Index files

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

@@ -200,12 +200,13 @@ export async function runCodeIntelligenceScan(projectPath) {
             namespace: 'code-intelligence:kg',
             enableVectorEmbeddings: true,
         });
-        const glob = await import('fast-glob');
-        const files = await glob.default([
+        const { glob } = await import('tinyglobby');
+        const files = await glob([
             '**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py'
         ], {
             cwd: projectPath,
             ignore: ['node_modules/**', 'dist/**', 'coverage/**', '.agentic-qe/**'],
+            expandDirectories: false,
         });
         const result = await kgService.index({
             paths: files.map(f => join(projectPath, f)),

package/dist/init/phases/06-code-intelligence.js

@@ -230,12 +230,13 @@ export class CodeIntelligencePhase extends BasePhase {
                 filesToIndex = changedFiles;
             }
             else {
-                const glob = await import('fast-glob');
-                const files = await glob.default([
+                const { glob } = await import('tinyglobby');
+                const files = await glob([
                     '**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py'
                 ], {
                     cwd: projectRoot,
                     ignore: SCAN_IGNORE_PATTERNS,
+                    expandDirectories: false,
                 });
                 filesToIndex = files.map(f => join(projectRoot, f));
             }
@@ -439,12 +440,13 @@ export class CodeIntelligencePhase extends BasePhase {
      * Find files modified since the given date
      */
     async findChangedFiles(projectRoot, since) {
-        const glob = await import('fast-glob');
-        const files = await glob.default([
+        const { glob } = await import('tinyglobby');
+        const files = await glob([
             '**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py'
         ], {
             cwd: projectRoot,
             ignore: SCAN_IGNORE_PATTERNS,
+            expandDirectories: false,
         });
         const sinceMs = since.getTime();
         const changed = [];

package/dist/integrations/ruvector/sona-persistence.d.ts

@@ -95,6 +95,7 @@ export declare class PersistentSONAEngine {
     private initPromise;
     private pendingSaves;
     private saveTimer;
+    private consecutiveSaveFailures;
     private serverClient;
     constructor(config: PersistentSONAConfig);
     /**

package/dist/integrations/ruvector/sona-persistence.js

@@ -112,6 +112,7 @@ export class PersistentSONAEngine {
     initPromise = null;
     pendingSaves = new Map();
     saveTimer = null;
+    consecutiveSaveFailures = 0;
     serverClient = null;
     constructor(config) {
         this.config = {
@@ -270,8 +271,6 @@ export class PersistentSONAEngine {
         ON CONFLICT(id) DO UPDATE SET
           confidence = excluded.confidence,
           usage_count = excluded.usage_count,
-          success_count = excluded.success_count,
-          failure_count = excluded.failure_count,
           metadata = excluded.metadata,
           updated_at = datetime('now'),
           last_used_at = excluded.last_used_at
@@ -288,6 +287,8 @@ export class PersistentSONAEngine {
         SET confidence = ?,
             success_count = success_count + ?,
             failure_count = failure_count + ?,
+            usage_count = usage_count + 1,
+            last_used_at = datetime('now'),
             updated_at = datetime('now')
         WHERE id = ?
       `));
@@ -432,6 +433,13 @@ export class PersistentSONAEngine {
             // Get updated pattern and persist confidence change
             const pattern = this.getPattern(patternId);
             if (pattern) {
+                // Feedback needs a durable row before incrementing its counters.
+                // Remove the queued snapshot only after its write succeeds.
+                const pending = this.pendingSaves.get(patternId);
+                if (pending) {
+                    this.savePatternToDb(pending);
+                    this.pendingSaves.delete(patternId);
+                }
                 this.persistPatternConfidenceUpdate(patternId, pattern.confidence, success ? 1 : 0, success ? 0 : 1);
             }
         }
@@ -548,19 +556,27 @@ export class PersistentSONAEngine {
         if (!stmt)
             throw new Error('Statement not prepared');
         const result = stmt.run(patternId);
-        return result.changes > 0;
+        // Delete queued writes too: otherwise the next batch or sync restores it.
+        const pending = this.pendingSaves.delete(patternId);
+        const cached = this.baseEngine.deletePattern(patternId);
+        return result.changes > 0 || pending || cached;
     }
     /**
      * Clear all patterns for this domain
      */
     clearDomainPatterns() {
         this.ensureInitialized();
-        // Clear in base engine
-        this.baseEngine.clear();
-        // Clear in SQLite for this domain
+        // Finish the durable delete first so a failed statement preserves memory.
         const stmt = this.prepared.get('deleteByDomain');
-        if (stmt) {
-            stmt.run(this.config.domain);
+        if (!stmt)
+            throw new Error('Statement not prepared');
+        stmt.run(this.config.domain);
+        for (const pattern of this.baseEngine.getPatternsByDomain(this.config.domain)) {
+            this.baseEngine.deletePattern(pattern.id);
+        }
+        for (const [id, pattern] of this.pendingSaves) {
+            if (pattern.domain === this.config.domain)
+                this.pendingSaves.delete(id);
         }
     }
     /**
@@ -791,10 +807,19 @@ export class PersistentSONAEngine {
             this.saveTimer = null;
         }
         if (this.pendingSaves.size > 0) {
+            const failures = [];
             for (const pattern of this.pendingSaves.values()) {
-                this.savePatternToDb(pattern);
+                try {
+                    this.savePatternToDb(pattern);
+                    this.pendingSaves.delete(pattern.id);
+                }
+                catch (error) {
+                    failures.push(new Error(toErrorMessage(error)));
+                }
+            }
+            if (failures.length > 0) {
+                throw new AggregateError(failures, `Deferred SONA saves failed: ${failures.map(error => error.message).join('; ')}`);
             }
-            this.pendingSaves.clear();
         }
         // A10 fix: checkpoint the request counter once per process lifetime
         // (cheap — not on the instantAdapt hot path) so short-lived CLI/MCP
@@ -813,6 +838,8 @@ export class PersistentSONAEngine {
         this.db = null;
         this.persistence = null;
         this.initialized = false;
+        // A completed initialization promise belongs to the closed lifecycle.
+        this.initPromise = null;
         console.log(`[PersistentSONAEngine] Closed: domain=${this.config.domain}`);
     }
     // ==========================================================================
@@ -1018,6 +1045,8 @@ export class PersistentSONAEngine {
         else {
             // Batch saves
             this.pendingSaves.set(pattern.id, pattern);
+            // New explicit work starts a fresh, bounded recovery cycle.
+            this.consecutiveSaveFailures = 0;
             this.scheduleSave();
         }
     }
@@ -1034,11 +1063,12 @@ export class PersistentSONAEngine {
         const actionEmbedding = pattern.action?.value && Array.isArray(pattern.action.value)
             ? this.floatArrayToBuffer(pattern.action.value)
             : null;
-        const actionValue = typeof pattern.action?.value === 'string'
-            ? pattern.action.value
-            : pattern.action?.value !== undefined
-                ? JSON.stringify(pattern.action.value)
-                : null;
+        // Encode strings too: the reader parses JSON, so raw "123"/"false"
+        // would otherwise change the action type after restarting. Legacy raw
+        // non-JSON strings remain readable through rowToPattern's fallback.
+        const actionValue = pattern.action?.value !== undefined
+            ? JSON.stringify(pattern.action.value)
+            : null;
         stmt.run(pattern.id, pattern.type, pattern.domain, stateEmbedding, actionEmbedding, pattern.action?.type ?? 'unknown', actionValue, pattern.outcome?.reward ?? 0, pattern.outcome?.success ? 1 : 0, pattern.outcome?.quality ?? 0, pattern.confidence, pattern.usageCount, 0, // success_count (tracked separately from usageCount)
         0, // failure_count
         pattern.metadata ? JSON.stringify(pattern.metadata) : null, pattern.createdAt?.toISOString() ?? new Date().toISOString(), pattern.lastUsedAt?.toISOString() ?? null);
@@ -1046,17 +1076,41 @@ export class PersistentSONAEngine {
     /**
      * Schedule batched save
      */
-    scheduleSave() {
-        if (this.saveTimer)
+    scheduleSave(delayMs = this.config.autoSaveInterval) {
+        if (this.saveTimer) {
+            // New explicit work must survive natural exit, even during a retry delay.
+            if (this.consecutiveSaveFailures === 0)
+                this.saveTimer.ref();
             return;
+        }
         this.saveTimer = setTimeout(() => {
             this.saveTimer = null;
             const patterns = Array.from(this.pendingSaves.values());
-            this.pendingSaves.clear();
             for (const pattern of patterns) {
-                this.savePatternToDb(pattern);
+                try {
+                    this.savePatternToDb(pattern);
+                    this.pendingSaves.delete(pattern.id);
+                }
+                catch (error) {
+                    logger.warn('Deferred SONA save failed; retaining pending pattern', {
+                        patternId: pattern.id, error: toErrorMessage(error),
+                    });
+                }
+            }
+            if (this.pendingSaves.size > 0) {
+                this.consecutiveSaveFailures++;
+                // Stop after five failed batches; close() can still flush retained rows.
+                if (this.consecutiveSaveFailures < 5 && this.db?.open) {
+                    this.scheduleSave(Math.min(60000, Math.max(1000, this.config.autoSaveInterval) * 2 ** (this.consecutiveSaveFailures - 1)));
+                }
+            }
+            else {
+                this.consecutiveSaveFailures = 0;
             }
-        }, this.config.autoSaveInterval);
+        }, delayMs);
+        // The initial batch must flush on natural exit; only failure retries are optional.
+        if (this.consecutiveSaveFailures > 0)
+            this.saveTimer.unref();
     }
     /**
      * Update pattern usage in SQLite

package/dist/integrations/ruvector/sona-wrapper.d.ts

@@ -199,6 +199,8 @@ export declare class QESONA {
      * Get statistics
      */
     getStats(): QESONAStats;
+    /** Stop recalling a pattern without resetting learned model weights. */
+    deletePattern(patternId: string): boolean;
     /**
      * Clear all patterns
      */

package/dist/integrations/ruvector/sona-wrapper.js

@@ -108,6 +108,15 @@ class QESONAPatternRegistry {
     getByDomain(domain) {
         return Array.from(this.patterns.values()).filter(p => p.domain === domain);
     }
+    /** Remove a pattern and its trajectory associations from the registry. */
+    delete(id) {
+        const removed = this.patterns.delete(id);
+        for (const [trajectoryId, patternId] of this.trajectoryMap) {
+            if (patternId === id)
+                this.trajectoryMap.delete(trajectoryId);
+        }
+        return removed;
+    }
     /**
      * Clear all patterns
      */
@@ -380,6 +389,10 @@ export class QESONA {
             engineStats,
         };
     }
+    /** Stop recalling a pattern without resetting learned model weights. */
+    deletePattern(patternId) {
+        return this.registry.delete(patternId);
+    }
     /**
      * Clear all patterns
      */

package/dist/kernel/memory-backend.js

@@ -56,9 +56,9 @@ export class InMemoryBackend {
         return value !== undefined;
     }
     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, '.*'));
+        // Match the same whole-key glob contract as persistent memory.
+        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`^${escaped.replace(/\*/g, '.*').replace(/\?/g, '.')}$`, 'su');
         const results = [];
         // When a namespace is supplied, scope the scan to that prefix. Matches
         // HybridBackend's namespace-aware search and lets LearningCoordinator's
@@ -68,7 +68,8 @@ export class InMemoryBackend {
         for (const key of this.store.keys()) {
             if (nsPrefix && !key.startsWith(nsPrefix))
                 continue;
-            if (regex.test(key)) {
+            const searchableKey = nsPrefix ? key.slice(nsPrefix.length) : key;
+            if (regex.test(searchableKey)) {
                 results.push(key);
                 if (results.length >= limit)
                     break;

package/dist/kernel/unified-memory.js

@@ -582,10 +582,11 @@ export class UnifiedMemoryManager {
     }
     async kvSearch(pattern, namespace = 'default', limit = 100) {
         this.ensureInitialized();
-        const sqlPattern = pattern.replace(/\*/g, '%').replace(/\?/g, '_');
+        // Only glob wildcards are special; SQL LIKE's own wildcard/escape bytes are literal.
+        const sqlPattern = pattern.replace(/[!%_]/g, '!$&').replace(/\*/g, '%').replace(/\?/g, '_');
         const rows = this.db.prepare(`
       SELECT key FROM kv_store
-      WHERE namespace = ? AND key LIKE ?
+      WHERE namespace = ? AND key LIKE ? ESCAPE '!'
         AND (expires_at IS NULL OR expires_at > ?)
       LIMIT ?
     `).all(namespace, sqlPattern, Date.now(), limit);

package/dist/learning/aqe-learning-engine.js

@@ -752,7 +752,7 @@ export class AQELearningEngine {
      */
     async localAnalyze(targetPath, depth) {
         try {
-            const glob = await import('fast-glob');
+            const { glob } = await import('tinyglobby');
             const { existsSync, readFileSync } = await import('fs');
             const { join } = await import('path');
             // Scan patterns based on depth
@@ -762,9 +762,10 @@ export class AQELearningEngine {
                     ? ['**/*.ts', '**/*.js', '**/*.json', '**/*.py']
                     : ['**/*'];
             const ignore = ['node_modules/**', 'dist/**', 'coverage/**', '.git/**'];
-            const files = await glob.default(patterns, {
+            const files = await glob(patterns, {
                 cwd: targetPath,
                 ignore,
+                expandDirectories: false,
                 onlyFiles: true,
             });
             // Detect languages and frameworks