agentic-qe 3.15.6 → 3.15.8

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

@@ -7,6 +7,7 @@ import { spawn } from 'node:child_process';
 import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../../shared/types/index.js';
 import { TEST_EXECUTION_CONSTANTS, LLM_ANALYSIS_CONSTANTS } from '../../constants.js';
@@ -305,11 +306,13 @@ Provide:
         const failedTests = [];
         const coverages = [];
         const allFileCoverages = [];
+        const executionResults = [];
         let passed = 0;
         let failed = 0;
         let skipped = 0;
         for (const file of testFiles) {
             const result = await this.executeTestFile(file, framework, timeout);
+            executionResults.push(result);
             passed += result.passed;
             failed += result.failed;
             skipped += result.skipped;
@@ -321,16 +324,61 @@ Provide:
                 allFileCoverages.push(...result.fileCoverages);
             }
         }
+        // Separate runner invocations each have their own coverage map. Averaging
+        // percentages double-counts source files and misses disjoint hits (#1030).
+        // If any run lacks raw counters, there is no honest combined measurement.
+        const merged = testFiles.length > 1 && !this.config.simulateForTesting
+            ? this.mergeSequentialCoverage(executionResults)
+            : undefined;
+        const separateRuns = testFiles.length > 1 && !this.config.simulateForTesting;
         return {
             total: passed + failed + skipped,
             passed,
             failed,
             skipped,
             failedTests,
-            coverage: this.aggregateCoverage(coverages),
-            fileCoverages: allFileCoverages.length > 0 ? allFileCoverages : undefined,
+            coverage: separateRuns ? merged?.summary : this.aggregateCoverage(coverages),
+            fileCoverages: separateRuns ? merged?.perFile
+                : allFileCoverages.length > 0 ? allFileCoverages : undefined,
         };
     }
+    mergeSequentialCoverage(results) {
+        if (results.some(result => !result.rawCoverageMap))
+            return undefined;
+        const merged = {};
+        for (const result of results) {
+            for (const [rawPath, entry] of Object.entries(result.rawCoverageMap)) {
+                if (!isRecord(entry) || !isRecord(entry.statementMap) || !isRecord(entry.fnMap)
+                    || !isRecord(entry.branchMap) || !isRecord(entry.s) || !isRecord(entry.f)
+                    || !isRecord(entry.b))
+                    return undefined;
+                const file = fileCoverageKey(rawPath);
+                const prior = merged[file];
+                if (prior) {
+                    if (!isDeepStrictEqual(prior.statementMap, entry.statementMap)
+                        || !isDeepStrictEqual(prior.fnMap, entry.fnMap)
+                        || !isDeepStrictEqual(prior.branchMap, entry.branchMap))
+                        return undefined;
+                    for (const counter of ['s', 'f', 'b']) {
+                        const hits = mergeHitCounts(prior[counter], entry[counter]);
+                        if (!hits)
+                            return undefined;
+                        prior[counter] = hits;
+                    }
+                }
+                else {
+                    const s = mergeHitCounts(entry.s, entry.s);
+                    const f = mergeHitCounts(entry.f, entry.f);
+                    const b = mergeHitCounts(entry.b, entry.b);
+                    if (!s || !f || !b)
+                        return undefined;
+                    merged[file] = { ...entry, path: file, s, f, b };
+                }
+            }
+        }
+        const coverage = this.extractCoverageFromJson({ coverageMap: merged });
+        return coverage.summary ? { summary: coverage.summary, perFile: coverage.perFile } : undefined;
+    }
     async executeTestFile(file, framework, timeout) {
         return this.executeTestFiles([file], framework, timeout);
     }
@@ -460,13 +508,14 @@ Provide:
                 const parseResult = this.parseTestOutput(reportText, stderr, fileLabel, framework, code);
                 // 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) {
+                if (parseResult.success && coverageDirectory) {
                     const diskCoverage = this.readCoverageFromDisk(coverageDirectory);
                     if (diskCoverage) {
-                        parseResult.value.coverage = diskCoverage.summary;
-                        if (diskCoverage.perFile.length > 0) {
+                        parseResult.value.coverage ??= diskCoverage.summary;
+                        if (!parseResult.value.fileCoverages && diskCoverage.perFile.length > 0) {
                             parseResult.value.fileCoverages = diskCoverage.perFile;
                         }
+                        parseResult.value.rawCoverageMap ??= diskCoverage.rawMap;
                     }
                 }
                 finish(parseResult);
@@ -661,6 +710,7 @@ Provide:
                     failedTests,
                     coverage: covData.summary,
                     fileCoverages: covData.perFile.length > 0 ? covData.perFile : undefined,
+                    rawCoverageMap: isRecord(json.coverageMap) && !json.coverageMap.total ? json.coverageMap : undefined,
                 });
             }
             catch {
@@ -715,6 +765,7 @@ Provide:
                 failedTests,
                 coverage: covData.summary,
                 fileCoverages: covData.perFile.length > 0 ? covData.perFile : undefined,
+                rawCoverageMap: isRecord(json.coverageMap) && !json.coverageMap.total ? json.coverageMap : undefined,
             });
         }
         catch {
@@ -1067,8 +1118,8 @@ Provide:
         try {
             // Check common coverage output paths
             const candidates = [
-                join(coverageDirectory, 'coverage-summary.json'),
                 join(coverageDirectory, 'coverage-final.json'),
+                join(coverageDirectory, 'coverage-summary.json'),
             ];
             for (const filePath of candidates) {
                 if (!existsSync(filePath))
@@ -1117,7 +1168,7 @@ Provide:
                 if (typeof json === 'object' && !json.total) {
                     const result = this.extractCoverageFromJson({ coverageMap: json });
                     if (result.summary) {
-                        return { summary: result.summary, perFile: result.perFile };
+                        return { summary: result.summary, perFile: result.perFile, rawMap: json };
                     }
                 }
             }
@@ -1216,4 +1267,33 @@ function summaryPct(metric) {
         return null;
     return metric.pct;
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** A test covers a counter if any invocation hit it. Reject incompatible maps. */
+function mergeHitCounts(left, right) {
+    if (!isRecord(left) || !isRecord(right))
+        return undefined;
+    const keys = Object.keys(left);
+    if (!isDeepStrictEqual(keys.sort(), Object.keys(right).sort()))
+        return undefined;
+    const merged = {};
+    for (const key of keys) {
+        const a = left[key];
+        const b = right[key];
+        if (typeof a === 'number' && Number.isFinite(a) && a >= 0
+            && typeof b === 'number' && Number.isFinite(b) && b >= 0) {
+            merged[key] = Math.max(a, b);
+        }
+        else if (Array.isArray(a) && Array.isArray(b) && a.length === b.length
+            && a.every(v => typeof v === 'number' && Number.isFinite(v) && v >= 0)
+            && b.every(v => typeof v === 'number' && Number.isFinite(v) && v >= 0)) {
+            merged[key] = a.map((v, i) => Math.max(v, b[i]));
+        }
+        else {
+            return undefined;
+        }
+    }
+    return merged;
+}
 //# sourceMappingURL=test-executor.js.map

package/dist/kernel/shared-dirs.js

@@ -145,14 +145,26 @@ export function ensureScratchRoot(dir, ctx = currentPlatformContext()) {
         writeOrigin(preferred, dir);
         return preferred;
     }
-    catch {
+    catch (preferredError) {
         const uid = typeof process.getuid === 'function' ? String(process.getuid()) : 'user';
         const fallbackBase = path.join(ctx.tmpdir || os.tmpdir(), `agentic-qe-scratch-${uid}`);
         const fallback = path.join(fallbackBase, path.basename(preferred));
-        ensurePrivateDir(fallbackBase);
-        ensurePrivateDir(fallback);
-        writeOrigin(fallback, dir);
-        return fallback;
+        try {
+            ensurePrivateDir(fallbackBase);
+            ensurePrivateDir(fallback);
+            writeOrigin(fallback, dir);
+            return fallback;
+        }
+        catch (fallbackError) {
+            // Never fall back to the shared directory itself: that would mix data
+            // from unrelated projects. Give callers a usable diagnosis instead of
+            // an opaque EEXIST/ENOTDIR from the final mkdir.
+            const reason = (error) => error instanceof Error ? error.message : String(error);
+            throw new Error(`Cannot create a private AQE scratch root for "${dir}". ` +
+                `User cache "${preferred}" failed: ${reason(preferredError)}. ` +
+                `Temporary fallback "${fallback}" failed: ${reason(fallbackError)}. ` +
+                'Set AQE_PROJECT_ROOT to a project directory or make the user cache writable.');
+        }
     }
 }
 function writeOrigin(root, dir) {

package/dist/learning/dream/dream-engine.d.ts

@@ -31,7 +31,21 @@ export interface DreamConfig {
     activationConfig: ActivationConfig;
     /** Insight generation configuration */
     insightConfig: InsightConfig;
-    /** Enable RVCOW branching for reversible dream cycles (ADR-069). Default: true */
+    /**
+     * Enable RVCOW branching for reversible dream cycles (ADR-069).
+     * Default: false (#1060).
+     *
+     * RISK — opt in only for an isolated database connection. The branch is a
+     * SQLite SAVEPOINT on the process-wide shared connection, and it stays open
+     * for the whole asynchronous dream (up to `maxDurationMs`). Every other
+     * write made on that connection in the meantime (memory_store, pattern
+     * updates, experience capture) joins the savepoint. A discard (failed
+     * validation, error, cancel) rolls those foreground writes back even though
+     * they were already acknowledged. Branch validation only inspects
+     * `qe_patterns`, which `dream()` does not write, so branching adds little
+     * protection to a dream cycle. A compute-then-commit rework is tracked in
+     * #1060.
+     */
     enableBranching: boolean;
     /** Validation thresholds for dream branch quality checks */
     branchValidationThresholds: ValidationThresholds;
@@ -104,6 +118,8 @@ export declare class DreamEngine {
     private graph;
     private db;
     private branchManager;
+    /** #1060: marks the in-flight dream cycle interrupted (set while dreaming). */
+    private interruptActiveDream;
     private currentCycle;
     private initialized;
     private cancelled;
@@ -138,6 +154,15 @@ export declare class DreamEngine {
      * @returns Dream cycle result with insights and statistics
      */
     dream(durationMs?: number): Promise<DreamCycleResult>;
+    /**
+     * #1060: build a synchronous handler that records a still-running cycle as
+     * 'interrupted'. It runs from close() and from a process store closer,
+     * which runs before the shared database closes (closers run newest first).
+     * When opt-in branching left a savepoint open, the savepoint is released
+     * first so foreground writes made on the shared connection during the
+     * dream are committed rather than lost with the connection.
+     */
+    private createCycleInterrupter;
     /**
      * Load patterns as concepts for dreaming.
      *
@@ -203,6 +228,7 @@ export declare class DreamEngine {
     getCurrentCycle(): DreamCycle | null;
     private saveCycle;
     private updateCycle;
+    private updateCycleSync;
     private saveInsight;
     private getInsightRowById;
     /**

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

@@ -21,6 +21,7 @@ import { LoggerFactory } from '../../logging/index.js';
 const dreamLogger = LoggerFactory.create('dream-engine');
 import { v4 as uuidv4 } from 'uuid';
 import { getUnifiedPersistence } from '../../kernel/unified-persistence.js';
+import { registerStoreCloser } from '../../kernel/process-lifecycle.js';
 import { ConceptGraph } from './concept-graph.js';
 import { SpreadingActivation, } from './spreading-activation.js';
 import { InsightGenerator, } from './insight-generator.js';
@@ -43,7 +44,8 @@ export const DEFAULT_DREAM_CONFIG = {
         minConfidence: 0.5,
         maxInsightsPerCycle: 10,
     },
-    enableBranching: true,
+    // #1060: off by default; see the RISK note on DreamConfig.enableBranching.
+    enableBranching: false,
     branchValidationThresholds: { ...DEFAULT_VALIDATION_THRESHOLDS },
 };
 // ============================================================================
@@ -206,6 +208,8 @@ export class DreamEngine {
     graph = null;
     db = null;
     branchManager = null;
+    /** #1060: marks the in-flight dream cycle interrupted (set while dreaming). */
+    interruptActiveDream = null;
     currentCycle = null;
     initialized = false;
     cancelled = false;
@@ -344,13 +348,18 @@ export class DreamEngine {
             status: 'running',
         };
         await this.saveCycle(this.currentCycle);
-        // ADR-069: Create RVCOW branch before dream consolidation
+        // ADR-069: Create RVCOW branch before dream consolidation (opt-in, #1060)
         let branch = null;
         if (this.branchManager) {
             const branchName = `dream-${this.currentCycle.id}-${Date.now()}`;
             branch = this.branchManager.createBranch(branchName);
             this.emitBranchEvent('dream:branch_created', branch);
         }
+        // #1060: if the engine closes or the process shuts down mid-dream, record
+        // the cycle as interrupted instead of leaving it 'running' forever.
+        const interrupt = this.createCycleInterrupter(this.currentCycle, startTime, () => branch);
+        this.interruptActiveDream = interrupt;
+        const unregisterShutdownGuard = registerStoreCloser(interrupt);
         try {
             // 1. Check we have enough concepts
             const allNodes = await this.graph.getActiveNodes(0);
@@ -458,6 +467,44 @@ export class DreamEngine {
             this.currentCycle = null;
             throw error;
         }
+        finally {
+            unregisterShutdownGuard();
+            if (this.interruptActiveDream === interrupt)
+                this.interruptActiveDream = null;
+        }
+    }
+    /**
+     * #1060: build a synchronous handler that records a still-running cycle as
+     * 'interrupted'. It runs from close() and from a process store closer,
+     * which runs before the shared database closes (closers run newest first).
+     * When opt-in branching left a savepoint open, the savepoint is released
+     * first so foreground writes made on the shared connection during the
+     * dream are committed rather than lost with the connection.
+     */
+    createCycleInterrupter(cycle, startTime, getBranch) {
+        return () => {
+            if (cycle.status !== 'running' || !this.db)
+                return;
+            const branch = getBranch();
+            if (branch && this.branchManager) {
+                try {
+                    this.branchManager.mergeBranch(branch);
+                }
+                catch {
+                    // Branch already resolved; nothing to release
+                }
+            }
+            cycle.status = 'interrupted';
+            cycle.error = 'Interrupted: engine closed or process shut down during the dream cycle';
+            cycle.endTime = new Date();
+            cycle.durationMs = Date.now() - startTime;
+            try {
+                this.updateCycleSync(cycle);
+            }
+            catch {
+                // Best effort during shutdown
+            }
+        };
     }
     // ==========================================================================
     // Pattern Loading
@@ -753,6 +800,9 @@ export class DreamEngine {
         stmt.run(cycle.id, cycle.startTime.toISOString(), cycle.endTime?.toISOString() ?? null, cycle.durationMs ?? null, cycle.conceptsProcessed, cycle.associationsFound, cycle.insightsGenerated, cycle.status, cycle.error ?? null, cycle.startTime.toISOString());
     }
     async updateCycle(cycle) {
+        this.updateCycleSync(cycle);
+    }
+    updateCycleSync(cycle) {
         if (!this.db)
             return;
         const stmt = this.db.prepare(`
@@ -815,6 +865,10 @@ export class DreamEngine {
      * Release resources (does NOT close the shared database)
      */
     async close() {
+        // #1060: a dream still in flight is recorded as interrupted before the
+        // engine lets go of the database.
+        this.interruptActiveDream?.();
+        this.interruptActiveDream = null;
         if (this.graph) {
             await this.graph.close();
             this.graph = null;

package/dist/learning/dream/rvcow-branch-manager.d.ts

@@ -13,6 +13,14 @@
  *   - mergeBranch   -> RELEASE SAVEPOINT
  *   - discardBranch -> ROLLBACK TO SAVEPOINT
  *
+ * WARNING (#1060): a SAVEPOINT covers every write on its connection, not just
+ * the dream's. Use an isolated connection, or keep the branch open only
+ * across synchronous work. If it stays open across `await`s on the
+ * process-wide shared connection, foreground writes made in the meantime
+ * (memory_store and other acknowledged writes) join the savepoint and are
+ * rolled back by a discard, or lost if the connection closes before
+ * RELEASE. DreamEngine therefore defaults `enableBranching` to false.
+ *
  * @module learning/dream/rvcow-branch-manager
  */
 import type { Database as DatabaseType } from 'better-sqlite3';

package/dist/learning/dream/rvcow-branch-manager.js

@@ -13,6 +13,14 @@
  *   - mergeBranch   -> RELEASE SAVEPOINT
  *   - discardBranch -> ROLLBACK TO SAVEPOINT
  *
+ * WARNING (#1060): a SAVEPOINT covers every write on its connection, not just
+ * the dream's. Use an isolated connection, or keep the branch open only
+ * across synchronous work. If it stays open across `await`s on the
+ * process-wide shared connection, foreground writes made in the meantime
+ * (memory_store and other acknowledged writes) join the savepoint and are
+ * rolled back by a discard, or lost if the connection closes before
+ * RELEASE. DreamEngine therefore defaults `enableBranching` to false.
+ *
  * @module learning/dream/rvcow-branch-manager
  */
 import { existsSync, unlinkSync } from 'fs';

package/dist/learning/dream/speculative-dreamer.d.ts

@@ -69,6 +69,14 @@ export declare const BUILT_IN_STRATEGIES: DreamStrategy[];
  * are executed one at a time but each in its own savepoint. The branch manager
  * ensures that failed strategies leave no trace in the database.
  *
+ * WARNING (#1060): a SAVEPOINT covers every write on its connection, not just
+ * the dream's. Use an isolated connection, or keep the branch open only
+ * across synchronous work. If it stays open across `await`s on the
+ * process-wide shared connection, foreground writes made in the meantime
+ * (memory_store and other acknowledged writes) join the savepoint and are
+ * rolled back by a discard, or lost if the connection closes before
+ * RELEASE. DreamEngine therefore defaults `enableBranching` to false.
+ *
  * @example
  * ```typescript
  * const dreamer = new SpeculativeDreamer(db);

package/dist/learning/dream/speculative-dreamer.js

@@ -61,6 +61,14 @@ export const BUILT_IN_STRATEGIES = [
  * are executed one at a time but each in its own savepoint. The branch manager
  * ensures that failed strategies leave no trace in the database.
  *
+ * WARNING (#1060): a SAVEPOINT covers every write on its connection, not just
+ * the dream's. Use an isolated connection, or keep the branch open only
+ * across synchronous work. If it stays open across `await`s on the
+ * process-wide shared connection, foreground writes made in the meantime
+ * (memory_store and other acknowledged writes) join the savepoint and are
+ * rolled back by a discard, or lost if the connection closes before
+ * RELEASE. DreamEngine therefore defaults `enableBranching` to false.
+ *
  * @example
  * ```typescript
  * const dreamer = new SpeculativeDreamer(db);

package/dist/mcp/background-workers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Agentic QE v3 - MCP background worker startup (IMP-10, #1061)
+ *
+ * Starts the worker daemon and the QualityDaemon for the MCP server, unless
+ * `AQE_WORKERS_ENABLED` is set to a falsy value (`false`, `0`, `off`, `no`).
+ * `aqe init --no-database` writes `AQE_WORKERS_ENABLED=false` (#533); before
+ * #1061 the variable was written but never read.
+ *
+ * All output goes through `log`, which the MCP entry binds to the original
+ * stderr writer so stdout stays reserved for JSON-RPC.
+ */
+import { type WorkerEnv } from '../workers/worker-env.js';
+export type BackgroundWorkersOutcome = 'disabled' | 'started' | 'failed';
+export declare function startBackgroundWorkers(log: (message: string) => void, env?: WorkerEnv): Promise<BackgroundWorkersOutcome>;
+//# sourceMappingURL=background-workers.d.ts.map

package/dist/mcp/background-workers.js

@@ -0,0 +1,71 @@
+/**
+ * Agentic QE v3 - MCP background worker startup (IMP-10, #1061)
+ *
+ * Starts the worker daemon and the QualityDaemon for the MCP server, unless
+ * `AQE_WORKERS_ENABLED` is set to a falsy value (`false`, `0`, `off`, `no`).
+ * `aqe init --no-database` writes `AQE_WORKERS_ENABLED=false` (#533); before
+ * #1061 the variable was written but never read.
+ *
+ * All output goes through `log`, which the MCP entry binds to the original
+ * stderr writer so stdout stays reserved for JSON-RPC.
+ */
+import { isWorkersEnabled } from '../workers/worker-env.js';
+export async function startBackgroundWorkers(log, env = process.env) {
+    if (!isWorkersEnabled(env)) {
+        log(`[MCP] Background workers disabled (AQE_WORKERS_ENABLED=${env.AQE_WORKERS_ENABLED}); ` +
+            'worker daemon and quality daemon not started\n');
+        return 'disabled';
+    }
+    // In database-free mode the workers run against the in-memory unified
+    // store, so they persist nothing to disk while keeping QualityDaemon/health
+    // functional.
+    try {
+        const { getDaemon } = await import('../workers/daemon.js');
+        // ADR-001 Bug A fix: use the canonical getDaemon() default. Passing
+        // `{ autoStart: false }` here would neuter workerManager.startAll() —
+        // the only call path that schedules per-worker setInterval timers, so
+        // workers would register but never tick. DEFAULT_CONFIG.autoStart=true
+        // (workers/daemon.ts) is the contracted default; matches the
+        // shutdownDaemon() call site in entry.ts.
+        const daemon = getDaemon();
+        await daemon.start();
+        const status = daemon.getStatus();
+        log(`[MCP] Background workers started (${status.workerManager.totalWorkers} workers)\n`);
+        // IMP-10: Start QualityDaemon with persistent memory (Finding 1 & 2 resolution)
+        try {
+            const { UnifiedMemoryManager } = await import('../kernel/unified-memory.js');
+            const { PersistentWorkerMemory } = await import('../workers/quality-daemon/persistent-memory.js');
+            const { isPrivateIp } = await import('../hooks/security/ssrf-guard.js');
+            const unifiedMemory = await UnifiedMemoryManager.getInstanceAsync();
+            const persistentMemory = new PersistentWorkerMemory(unifiedMemory);
+            const qualityDaemon = daemon.getQualityDaemon({
+                notifications: {
+                    // IMP-07 SSRF guard: block private IPs in webhook URLs (Finding 5)
+                    urlValidator: (url) => {
+                        try {
+                            const parsed = new URL(url);
+                            const hostname = parsed.hostname.replace(/^\[|\]$/g, '');
+                            return !isPrivateIp(hostname);
+                        }
+                        catch {
+                            return false;
+                        }
+                    },
+                },
+            });
+            await qualityDaemon.start(persistentMemory);
+            log(`[MCP] Quality daemon started\n`);
+        }
+        catch (qdError) {
+            log(`[MCP] WARNING: Quality daemon failed to start: ${qdError}\n`);
+            // Non-fatal — MCP continues without quality daemon
+        }
+        return 'started';
+    }
+    catch (daemonError) {
+        log(`[MCP] WARNING: Background workers failed to start: ${daemonError}\n`);
+        // Non-fatal — MCP server continues without background workers
+        return 'failed';
+    }
+}
+//# sourceMappingURL=background-workers.js.map