agentic-qe 3.15.7 → 3.15.9

package/dist/learning/dream/dream-insights-pruner.d.ts

@@ -14,10 +14,18 @@
  * `getPendingInsights` target and vector embeddings (if attached) grow
  * unbounded.
  *
- * Strategy: delete only insights that:
+ * Strategy: move out of `dream_insights` only insights that:
  *   - have never been applied (`applied = 0`), AND
  *   - are older than the retention window (default 30 days)
  *
+ * #1066: rows are archived, not lost. In one write transaction (BEGIN
+ * IMMEDIATE, so it waits on busy_timeout instead of failing on lock upgrade)
+ * each qualifying row is copied to `dream_insights_archive`, the copies are
+ * read back, and only rows whose copy is present are deleted. If the
+ * read-back does not match, the transaction rolls back and nothing is
+ * deleted. The archive has its own key, so an insight swept twice keeps both
+ * copies.
+ *
  * Applied insights stay forever — they're part of the audit trail for
  * pattern changes. Recently-created insights stay regardless of applied
  * state — they might still be picked up by a future `applyInsight` pass.
@@ -38,12 +46,18 @@ export interface PruneStaleDreamInsightsOptions {
 export interface PruneResult {
     /** Number of rows deleted. Zero if the table is empty or no rows qualify. */
     pruned: number;
+    /** Number of rows copied to `dream_insights_archive` before the delete. */
+    archived: number;
 }
+/** Table that keeps every insight the sweep removes from `dream_insights`. */
+export declare const DREAM_INSIGHTS_ARCHIVE_TABLE = "dream_insights_archive";
 /**
- * Delete stale unapplied insights. Idempotent — safe to call on every tick.
+ * Archive, then delete, stale unapplied insights. Idempotent — safe to call
+ * on every tick.
  *
- * Returns `{ pruned: 0 }` if the table doesn't exist (init hasn't created
- * the dream schema yet) or if no rows qualify.
+ * Returns `{ pruned: 0, archived: 0 }` if the table doesn't exist (init hasn't
+ * created the dream schema yet) or if no rows qualify. Throws, with nothing
+ * deleted, if the archive copy cannot be verified.
  */
 export declare function pruneStaleDreamInsights(db: DatabaseType, options?: PruneStaleDreamInsightsOptions): PruneResult;
 //# sourceMappingURL=dream-insights-pruner.d.ts.map

package/dist/learning/dream/dream-insights-pruner.js

@@ -14,10 +14,18 @@
  * `getPendingInsights` target and vector embeddings (if attached) grow
  * unbounded.
  *
- * Strategy: delete only insights that:
+ * Strategy: move out of `dream_insights` only insights that:
  *   - have never been applied (`applied = 0`), AND
  *   - are older than the retention window (default 30 days)
  *
+ * #1066: rows are archived, not lost. In one write transaction (BEGIN
+ * IMMEDIATE, so it waits on busy_timeout instead of failing on lock upgrade)
+ * each qualifying row is copied to `dream_insights_archive`, the copies are
+ * read back, and only rows whose copy is present are deleted. If the
+ * read-back does not match, the transaction rolls back and nothing is
+ * deleted. The archive has its own key, so an insight swept twice keeps both
+ * copies.
+ *
  * Applied insights stay forever — they're part of the audit trail for
  * pattern changes. Recently-created insights stay regardless of applied
  * state — they might still be picked up by a future `applyInsight` pass.
@@ -27,11 +35,40 @@
  * with the rest of its lifecycle work.
  */
 const DEFAULT_RETENTION_DAYS = 30;
+/** Table that keeps every insight the sweep removes from `dream_insights`. */
+export const DREAM_INSIGHTS_ARCHIVE_TABLE = 'dream_insights_archive';
+// Same columns as dream_insights plus archive_id and archived_at. `id` is not
+// unique here: an insight that comes back (for example from a brain import)
+// and is swept again gets a second row instead of replacing the first. No
+// foreign key, so deleting a dream cycle does not cascade into the archive.
+const CREATE_ARCHIVE_SQL = `
+  CREATE TABLE IF NOT EXISTS ${DREAM_INSIGHTS_ARCHIVE_TABLE} (
+    archive_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    id TEXT NOT NULL,
+    cycle_id TEXT,
+    insight_type TEXT,
+    source_concepts TEXT,
+    description TEXT,
+    novelty_score REAL,
+    confidence_score REAL,
+    actionable INTEGER,
+    applied INTEGER,
+    suggested_action TEXT,
+    pattern_id TEXT,
+    created_at TEXT,
+    archived_at TEXT NOT NULL DEFAULT (datetime('now'))
+  )
+`;
+function columnNames(db, table) {
+    return db.prepare(`PRAGMA table_info(${table})`).all().map((c) => c.name);
+}
 /**
- * Delete stale unapplied insights. Idempotent — safe to call on every tick.
+ * Archive, then delete, stale unapplied insights. Idempotent — safe to call
+ * on every tick.
  *
- * Returns `{ pruned: 0 }` if the table doesn't exist (init hasn't created
- * the dream schema yet) or if no rows qualify.
+ * Returns `{ pruned: 0, archived: 0 }` if the table doesn't exist (init hasn't
+ * created the dream schema yet) or if no rows qualify. Throws, with nothing
+ * deleted, if the archive copy cannot be verified.
  */
 export function pruneStaleDreamInsights(db, options = {}) {
     const retentionDays = options.retentionDays ?? DEFAULT_RETENTION_DAYS;
@@ -41,13 +78,64 @@ export function pruneStaleDreamInsights(db, options = {}) {
         .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='dream_insights'")
         .get();
     if (!tableExists) {
-        return { pruned: 0 };
+        return { pruned: 0, archived: 0 };
     }
-    const result = db
-        .prepare(`DELETE FROM dream_insights
-         WHERE applied = 0
-           AND created_at < datetime('now', ?)`)
-        .run(`-${retentionDays} days`);
-    return { pruned: result.changes };
+    // One cutoff for every statement below, so the copy, the check and the
+    // delete all see the same set of rows.
+    const { cutoff } = db
+        .prepare(`SELECT datetime('now', ?) AS cutoff`)
+        .get(`-${retentionDays} days`);
+    const stale = 'd.applied = 0 AND d.created_at < ?';
+    const sweep = db.transaction(() => {
+        const candidates = db
+            .prepare(`SELECT COUNT(*) AS n FROM dream_insights d WHERE ${stale}`)
+            .get(cutoff).n;
+        if (candidates === 0)
+            return { pruned: 0, archived: 0 };
+        db.exec(CREATE_ARCHIVE_SQL);
+        const archiveColumns = new Set(columnNames(db, DREAM_INSIGHTS_ARCHIVE_TABLE));
+        if (!archiveColumns.has('archive_id')) {
+            throw new Error(`${DREAM_INSIGHTS_ARCHIVE_TABLE} has no archive_id column; nothing deleted`);
+        }
+        // Copy the columns both tables have; older databases may lack some.
+        const shared = columnNames(db, 'dream_insights').filter((name) => name !== 'archived_at' && name !== 'archive_id' && archiveColumns.has(name));
+        const list = shared.map((name) => `"${name}"`).join(', ');
+        // Copies made by this sweep have archive_id above this mark.
+        const { mark } = db
+            .prepare(`SELECT COALESCE(MAX(archive_id), 0) AS mark FROM ${DREAM_INSIGHTS_ARCHIVE_TABLE}`)
+            .get();
+        const archived = db
+            .prepare(`INSERT INTO ${DREAM_INSIGHTS_ARCHIVE_TABLE} (${list}, archived_at)
+           SELECT ${shared.map((name) => `d."${name}"`).join(', ')}, datetime('now')
+             FROM dream_insights d WHERE ${stale}`)
+            .run(cutoff).changes;
+        // Read back: every row about to be deleted must have a copy from this sweep.
+        const copied = db
+            .prepare(`SELECT COUNT(*) AS n FROM dream_insights d
+          WHERE ${stale}
+            AND EXISTS (SELECT 1 FROM ${DREAM_INSIGHTS_ARCHIVE_TABLE} a
+                         WHERE a.id = d.id AND a.archive_id > ?)`)
+            .get(cutoff, mark).n;
+        if (copied !== candidates) {
+            throw new Error(`dream_insights archive check failed: ${copied} of ${candidates} rows copied; nothing deleted`);
+        }
+        const pruned = db
+            .prepare(`DELETE FROM dream_insights
+          WHERE applied = 0 AND created_at < ?
+            AND id IN (SELECT id FROM ${DREAM_INSIGHTS_ARCHIVE_TABLE} WHERE archive_id > ?)`)
+            .run(cutoff, mark).changes;
+        // Read back: the stale rows are gone and none was deleted uncopied.
+        const left = db
+            .prepare(`SELECT COUNT(*) AS n FROM dream_insights d WHERE ${stale}`)
+            .get(cutoff).n;
+        if (pruned !== candidates || left !== 0) {
+            throw new Error(`dream_insights delete check failed: deleted ${pruned} of ${candidates}, ${left} left; rolled back`);
+        }
+        return { pruned, archived };
+    });
+    // #1066 review: IMMEDIATE takes the write lock up front, so a busy database
+    // makes the sweep wait on busy_timeout. A deferred transaction starts with
+    // a read and fails at once with SQLITE_BUSY when it upgrades to write.
+    return sweep.immediate();
 }
 //# sourceMappingURL=dream-insights-pruner.js.map

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/learning/skill-validation-learner.d.ts

@@ -252,6 +252,8 @@ export declare class SkillValidationLearner {
      */
     extractLearnedPatterns(skillName: string): Promise<ValidationPattern[]>;
     private createEmptyConfidence;
+    /** Preserve data keys such as __proto__ without giving parsed records a prototype. */
+    private parseCrossModelAnalysis;
     private createEmptyCrossModelAnalysis;
     private calculateAvgReasoningQuality;
     private calculateTrend;

package/dist/learning/skill-validation-learner.js

@@ -24,6 +24,7 @@
  * @see .claude/skills/.validation/skill-validation-mcp-integration.md
  */
 import { safeJsonParse } from '../shared/safe-json.js';
+import { createSafeRecord, getOwn, setOwn } from '../shared/utils/safe-record.js';
 import { LoggerFactory } from '../logging/index.js';
 const logger = LoggerFactory.create('skill-validation-learner');
 // ============================================================================
@@ -207,14 +208,8 @@ export class SkillValidationLearner {
                 const pattern = existingPatterns.value[0].pattern;
                 const templateContent = pattern.template?.content;
                 if (templateContent) {
-                    const parsed = safeJsonParse(templateContent);
-                    // Validate that it has the expected structure
-                    if (parsed && typeof parsed === 'object' && typeof parsed.models === 'object') {
-                        crossModel = parsed;
-                    }
-                    else {
-                        crossModel = this.createEmptyCrossModelAnalysis();
-                    }
+                    crossModel = this.parseCrossModelAnalysis(templateContent)
+                        ?? this.createEmptyCrossModelAnalysis();
                 }
                 else {
                     crossModel = this.createEmptyCrossModelAnalysis();
@@ -230,18 +225,16 @@ export class SkillValidationLearner {
         }
         // Ensure models object exists (defensive)
         if (!crossModel.models) {
-            crossModel.models = {};
+            crossModel.models = createSafeRecord();
         }
         // Initialize model data if needed
-        if (!crossModel.models[outcome.model]) {
-            crossModel.models[outcome.model] = {
-                scores: [],
-                passRate: 0,
-                avgReasoningQuality: 0,
-                sampleCount: 0,
-            };
-        }
-        const modelData = crossModel.models[outcome.model];
+        const modelData = getOwn(crossModel.models, outcome.model) ?? {
+            scores: [],
+            passRate: 0,
+            avgReasoningQuality: 0,
+            sampleCount: 0,
+        };
+        setOwn(crossModel.models, outcome.model, modelData);
         modelData.scores.push(outcome.score);
         modelData.sampleCount++;
         // Keep last 50 scores per model
@@ -336,7 +329,7 @@ export class SkillValidationLearner {
             try {
                 const templateContent = patterns.value[0].pattern.template?.content;
                 if (templateContent) {
-                    return safeJsonParse(templateContent);
+                    return this.parseCrossModelAnalysis(templateContent);
                 }
             }
             catch (e) {
@@ -367,7 +360,7 @@ export class SkillValidationLearner {
         if (!confidence)
             return null;
         // Calculate by-model trends
-        const byModel = {};
+        const byModel = createSafeRecord();
         if (crossModel) {
             for (const model of Object.keys(crossModel.models)) {
                 const modelOutcomes = confidence.outcomes
@@ -466,9 +459,24 @@ export class SkillValidationLearner {
             lastUpdated: new Date(),
         };
     }
+    /** Preserve data keys such as __proto__ without giving parsed records a prototype. */
+    parseCrossModelAnalysis(content) {
+        // The generic safe parser strips __proto__, which would discard a legitimate
+        // model's history. This reviver copies every record into a null-prototype
+        // dictionary instead, including nested records; it never invokes setters.
+        const parsed = JSON.parse(content, (_key, value) => {
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                return Object.assign(createSafeRecord(), value);
+            }
+            return value;
+        });
+        return parsed && typeof parsed === 'object' && parsed.models
+            && typeof parsed.models === 'object' && !Array.isArray(parsed.models)
+            ? parsed : null;
+    }
     createEmptyCrossModelAnalysis() {
         return {
-            models: {},
+            models: createSafeRecord(),
             variance: 0,
             hasAnomalies: false,
             lastUpdated: new Date(),

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,77 @@
+/**
+ * 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();
+        // #1066: start() runs every worker's first tick one after another, which
+        // can take minutes. Let it finish in the background so the QualityDaemon
+        // (and the HTTP server after us) do not wait for it.
+        void daemon.start().catch((startError) => {
+            log(`[MCP] WARNING: Background workers failed to start: ${startError}\n`);
+        });
+        const status = daemon.getStatus();
+        log(`[MCP] Background workers started (${status.workerManager.totalWorkers} workers; ` +
+            'first runs continue in the background)\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