agentic-qe 3.15.7 → 3.15.9

package/dist/shared/utils/namespaced-search.js

@@ -0,0 +1,53 @@
+/**
+ * Agentic QE v3 - namespaced kv key scans (#1049, #1071)
+ *
+ * Two problems with reading every key of a family through
+ * `MemoryBackend.search()`:
+ *
+ * 1. Kernel backends disagree on what a namespaced `search` returns: the
+ *    hybrid (sqlite) backend returns bare keys, the in-memory backend returns
+ *    `<namespace>:<key>`. A caller that passes a result straight back to
+ *    `get(key, { namespace })` double-prefixes the key and reads nothing.
+ * 2. `search()` takes a row limit and has no offset or ordering, so a single
+ *    call with a fixed cap silently drops every key past the cap.
+ *
+ * `searchAllKeys` addresses both: it returns every matching key, bare and in
+ * a stable order.
+ */
+function globToRegExp(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`^${escaped.replace(/\*/g, '.*').replace(/\?/g, '.')}$`, 's');
+}
+/**
+ * The bare key for a key returned by `search(pattern, limit, { namespace })`.
+ * A result that already matches `pattern` is bare (keys may legitimately start
+ * with the namespace name, e.g. `defect-intelligence:predictor:…`); otherwise a
+ * leading `<namespace>:` is the backend's prefix and is removed.
+ */
+export function bareSearchKey(found, namespace, pattern) {
+    if (globToRegExp(pattern).test(found))
+        return found;
+    return found.startsWith(`${namespace}:`) ? found.slice(namespace.length + 1) : found;
+}
+/** First request size for `searchAllKeys`. Each further request doubles it. */
+export const DEFAULT_KEY_SCAN_PAGE_SIZE = 10_000;
+/**
+ * Every key matching `pattern`, bare (usable with `get(key, retrieve)`),
+ * de-duplicated and sorted.
+ *
+ * `search()` has no offset, so this widens the request until the backend
+ * returns fewer keys than were asked for. That is the only point at which the
+ * result is known to be complete; no cap ever truncates it.
+ */
+export async function searchAllKeys(memory, pattern, options = {}) {
+    let limit = Math.max(1, Math.floor(options.pageSize ?? DEFAULT_KEY_SCAN_PAGE_SIZE));
+    let found = await memory.search(pattern, limit, options.retrieve);
+    while (found.length >= limit) {
+        limit *= 2;
+        found = await memory.search(pattern, limit, options.retrieve);
+    }
+    const namespace = options.retrieve?.namespace;
+    const keys = namespace ? found.map((key) => bareSearchKey(key, namespace, pattern)) : found;
+    return [...new Set(keys)].sort();
+}
+//# sourceMappingURL=namespaced-search.js.map

package/dist/strange-loop/infra-healing/infra-action-executor.js

@@ -9,6 +9,7 @@
  * CompositeActionExecutor delegates to for infrastructure-specific actions.
  */
 import { createEmptyStats } from './types.js';
+import { getOwn, setOwn } from '../../shared/utils/safe-record.js';
 // ============================================================================
 // NoOp Command Runner (for testing)
 // ============================================================================
@@ -242,10 +243,13 @@ export class InfraActionExecutor {
         };
     }
     updateServiceStats(serviceName, field) {
-        if (!this.stats.byService[serviceName]) {
-            this.stats.byService[serviceName] = { failures: 0, recoveries: 0, successes: 0 };
+        // Service names come from the playbook: `constructor` must be just a name (#978).
+        let serviceStats = getOwn(this.stats.byService, serviceName);
+        if (!serviceStats) {
+            serviceStats = { failures: 0, recoveries: 0, successes: 0 };
+            setOwn(this.stats.byService, serviceName, serviceStats);
         }
-        this.stats.byService[serviceName][field]++;
+        serviceStats[field]++;
     }
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));

package/dist/strange-loop/infra-healing/infra-healing-orchestrator.js

@@ -13,6 +13,7 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import { DEFAULT_INFRA_HEALING_CONFIG, createEmptyStats } from './types.js';
+import { getOwn, setOwn } from '../../shared/utils/safe-record.js';
 import { createTestOutputObserver } from './test-output-observer.js';
 import { createRecoveryPlaybook } from './recovery-playbook.js';
 import { createCoordinationLock } from './coordination-lock.js';
@@ -59,10 +60,10 @@ export class InfraHealingOrchestrator {
         // Update per-service failure counts
         for (const failure of observation.infraFailures) {
             if (failure.serviceName) {
-                if (!this.stats.byService[failure.serviceName]) {
-                    this.stats.byService[failure.serviceName] = { failures: 0, recoveries: 0, successes: 0 };
-                }
-                this.stats.byService[failure.serviceName].failures++;
+                const bucket = getOwn(this.stats.byService, failure.serviceName)
+                    ?? { failures: 0, recoveries: 0, successes: 0 };
+                bucket.failures++;
+                setOwn(this.stats.byService, failure.serviceName, bucket);
             }
         }
     }
@@ -171,11 +172,11 @@ export class InfraHealingOrchestrator {
         this.stats.recoveriesFailed = execStats.recoveriesFailed;
         // Merge per-service recovery stats from executor
         for (const [service, execServiceStats] of Object.entries(execStats.byService)) {
-            if (!this.stats.byService[service]) {
-                this.stats.byService[service] = { failures: 0, recoveries: 0, successes: 0 };
-            }
-            this.stats.byService[service].recoveries = execServiceStats.recoveries;
-            this.stats.byService[service].successes = execServiceStats.successes;
+            const bucket = getOwn(this.stats.byService, service)
+                ?? { failures: 0, recoveries: 0, successes: 0 };
+            bucket.recoveries = execServiceStats.recoveries;
+            bucket.successes = execServiceStats.successes;
+            setOwn(this.stats.byService, service, bucket);
         }
     }
 }

package/dist/workers/daemon.d.ts

@@ -15,6 +15,11 @@ export interface DaemonConfig {
     autoStart?: boolean;
     /** Workers to enable (defaults to all) */
     enabledWorkers?: string[];
+    /**
+     * Workers to skip even when enabled (#1061). Defaults to the comma list in
+     * `AQE_DISABLED_WORKERS`.
+     */
+    disabledWorkers?: string[];
     /** Log level */
     logLevel?: 'debug' | 'info' | 'warn' | 'error';
     /** Health check interval (ms) */
@@ -30,6 +35,8 @@ export declare class QEDaemon implements IDaemon {
     private workerManager;
     private config;
     private _qualityDaemon?;
+    /** #1066: `AQE_DISABLED_WORKERS` ids that match no worker. */
+    private unknownDisabledIds;
     constructor(config?: DaemonConfig);
     get running(): boolean;
     get uptime(): number;

package/dist/workers/daemon.js

@@ -9,12 +9,14 @@ import { WorkerManagerImpl } from './worker-manager.js';
 // Import all QE workers (ADR-014)
 import { TestHealthWorker, CoverageTrackerWorker, FlakyDetectorWorker, SecurityScanWorker, QualityGateWorker, LearningConsolidationWorker, DefectPredictorWorker, RegressionMonitorWorker, PerformanceBaselineWorker, ComplianceCheckerWorker, HeartbeatSchedulerWorker, } from './workers/index.js';
 import { QualityDaemon } from './quality-daemon/index.js';
+import { parseDisabledWorkers } from './worker-env.js';
 /**
  * Default daemon configuration
  */
 const DEFAULT_CONFIG = {
     autoStart: true,
     enabledWorkers: [],
+    disabledWorkers: [],
     logLevel: 'info',
     healthCheckIntervalMs: 60000,
 };
@@ -28,8 +30,15 @@ export class QEDaemon {
     workerManager;
     config;
     _qualityDaemon;
+    /** #1066: `AQE_DISABLED_WORKERS` ids that match no worker. */
+    unknownDisabledIds = [];
     constructor(config) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...config,
+            // #1066: ids are matched without regard to case.
+            disabledWorkers: (config?.disabledWorkers ?? parseDisabledWorkers()).map((id) => id.toLowerCase()),
+        };
         this.workerManager = new WorkerManagerImpl();
         this.registerWorkers();
     }
@@ -50,6 +59,11 @@ export class QEDaemon {
             return;
         }
         console.info('[Daemon] Starting QE Background Workers...');
+        // #1066: reported on start, not construction. fleet_init and shutdown
+        // construct the daemon even when AQE_WORKERS_ENABLED=false.
+        if (this.unknownDisabledIds.length > 0) {
+            console.warn(`[AQE] WARN AQE_DISABLED_WORKERS: unknown worker id(s) ignored: ${this.unknownDisabledIds.join(', ')}`);
+        }
         this._running = true;
         this._startedAt = new Date();
         // Start health check timer
@@ -158,12 +172,17 @@ export class QEDaemon {
             new HeartbeatSchedulerWorker(), // 30 min - Token-free heartbeat
         ];
         for (const worker of allWorkers) {
-            // Check if worker is enabled
+            // Check if worker is enabled and not explicitly disabled (#1061)
+            if (this.config.disabledWorkers.includes(worker.config.id)) {
+                continue;
+            }
             if (this.config.enabledWorkers.length === 0 ||
                 this.config.enabledWorkers.includes(worker.config.id)) {
                 this.workerManager.register(worker);
             }
         }
+        const knownIds = new Set(allWorkers.map((worker) => worker.config.id));
+        this.unknownDisabledIds = this.config.disabledWorkers.filter((id) => !knownIds.has(id));
     }
     performHealthCheck() {
         const health = this.workerManager.getHealth();

package/dist/workers/namespaced-keys.d.ts

@@ -5,12 +5,9 @@
  * hybrid (sqlite) backend returns bare keys, the in-memory backend returns
  * `<namespace>:<key>`. A worker that passes a search result straight back to
  * `get(key, { namespace })` then double-prefixes the key and reads nothing.
+ *
+ * The helper lives in `shared/utils/namespaced-search` so domain services can
+ * use it too (#1071); it is re-exported here for the workers.
  */
-/**
- * The bare key for a key returned by `search(pattern, limit, { namespace })`.
- * A result that already matches `pattern` is bare (keys may legitimately start
- * with the namespace name, e.g. `defect-intelligence:predictor:…`); otherwise a
- * leading `<namespace>:` is the backend's prefix and is removed.
- */
-export declare function bareSearchKey(found: string, namespace: string, pattern: string): string;
+export { bareSearchKey } from '../shared/utils/namespaced-search.js';
 //# sourceMappingURL=namespaced-keys.d.ts.map

package/dist/workers/namespaced-keys.js

@@ -5,20 +5,9 @@
  * hybrid (sqlite) backend returns bare keys, the in-memory backend returns
  * `<namespace>:<key>`. A worker that passes a search result straight back to
  * `get(key, { namespace })` then double-prefixes the key and reads nothing.
+ *
+ * The helper lives in `shared/utils/namespaced-search` so domain services can
+ * use it too (#1071); it is re-exported here for the workers.
  */
-function globToRegExp(pattern) {
-    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-    return new RegExp(`^${escaped.replace(/\*/g, '.*').replace(/\?/g, '.')}$`, 's');
-}
-/**
- * The bare key for a key returned by `search(pattern, limit, { namespace })`.
- * A result that already matches `pattern` is bare (keys may legitimately start
- * with the namespace name, e.g. `defect-intelligence:predictor:…`); otherwise a
- * leading `<namespace>:` is the backend's prefix and is removed.
- */
-export function bareSearchKey(found, namespace, pattern) {
-    if (globToRegExp(pattern).test(found))
-        return found;
-    return found.startsWith(`${namespace}:`) ? found.slice(namespace.length + 1) : found;
-}
+export { bareSearchKey } from '../shared/utils/namespaced-search.js';
 //# sourceMappingURL=namespaced-keys.js.map

package/dist/workers/quality-daemon/ci-monitor.js

@@ -7,6 +7,7 @@
  */
 import { execFile } from 'child_process';
 import { promisify } from 'util';
+import { createSafeRecord, getOwn, setOwn } from '../../shared/utils/safe-record.js';
 const execFileAsync = promisify(execFile);
 const DEFAULTS = {
     runsPerWorkflow: 10,
@@ -95,16 +96,19 @@ export class CIMonitor {
         }
     }
     groupByWorkflow(runs) {
-        const grouped = {};
+        // Workflow names come from GitHub: no prototype, so `constructor` is just a name (#978).
+        const grouped = createSafeRecord();
         for (const run of runs) {
-            if (!grouped[run.name]) {
-                grouped[run.name] = [];
+            let bucket = getOwn(grouped, run.name);
+            if (!bucket) {
+                bucket = [];
+                setOwn(grouped, run.name, bucket);
             }
-            grouped[run.name].push(run);
+            bucket.push(run);
         }
         // Limit per workflow
         for (const name of Object.keys(grouped)) {
-            grouped[name] = grouped[name].slice(0, this.options.runsPerWorkflow);
+            setOwn(grouped, name, getOwn(grouped, name).slice(0, this.options.runsPerWorkflow));
         }
         return grouped;
     }

package/dist/workers/worker-env.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Agentic QE v3 - Background worker environment switches (#1061)
+ *
+ * Parses the environment variables that control the background worker
+ * daemon hosted by the MCP server:
+ *
+ * - `AQE_WORKERS_ENABLED`: `false` / `0` / `off` / `no` disables the whole
+ *   worker daemon, including the QualityDaemon. Unset, empty or any other
+ *   value keeps the default behaviour (workers on). `aqe init` writes `true`
+ *   for normal installs and `false` for `--no-database` installs (#533).
+ * - `AQE_DISABLED_WORKERS`: comma-separated worker ids that are not
+ *   registered (for example `learning-consolidation`). Matched without
+ *   regard to case (#1066).
+ * - `AQE_DREAM_INSIGHTS_RETENTION_DAYS`: retention window for unapplied
+ *   `dream_insights` rows. Default 30. `0`, `off`, `false`, `no`, `disabled`,
+ *   `none` or `never` disables the sweep. Any other value that is not a whole
+ *   number of days is rejected with a warning and also disables the sweep, so
+ *   a typo never deletes anything (#1066).
+ */
+export type WorkerEnv = Readonly<Record<string, string | undefined>>;
+/** Default retention window for unapplied dream insights (days). */
+export declare const DEFAULT_DREAM_INSIGHTS_RETENTION_DAYS = 30;
+/**
+ * Whether background workers should start. Only an explicit falsy value
+ * disables them, so existing installs keep today's behaviour.
+ */
+export declare function isWorkersEnabled(env?: WorkerEnv): boolean;
+/**
+ * Worker ids listed in `AQE_DISABLED_WORKERS`, trimmed, lower-cased,
+ * de-duplicated and with empty entries removed. Worker ids are lower-case, so
+ * `Learning-Consolidation` disables `learning-consolidation` (#1066).
+ */
+export declare function parseDisabledWorkers(env?: WorkerEnv): string[];
+export interface DreamInsightsRetention {
+    /** Retention window in days, or `null` when the sweep is disabled. */
+    retentionDays: number | null;
+    /** Set when the configured value was rejected (default applied). */
+    warning?: string;
+}
+/**
+ * Resolve `AQE_DREAM_INSIGHTS_RETENTION_DAYS`.
+ *
+ * - unset, empty or whitespace only: default (30 days). Blanking the
+ *   variable means "unset", not "off" (documented in configuration.md).
+ * - `0`, `off`, `false`, `no`, `disabled`, `none`, `never`: sweep disabled
+ *   (`retentionDays: null`)
+ * - a whole number from 1 to 36500: that many days
+ * - anything else: sweep disabled, with a warning describing the rejected
+ *   value. The sweep deletes user data, so an unreadable setting fails safe
+ *   (#1066).
+ */
+export declare function resolveDreamInsightsRetention(env?: WorkerEnv): DreamInsightsRetention;
+//# sourceMappingURL=worker-env.d.ts.map

package/dist/workers/worker-env.js

@@ -0,0 +1,89 @@
+/**
+ * Agentic QE v3 - Background worker environment switches (#1061)
+ *
+ * Parses the environment variables that control the background worker
+ * daemon hosted by the MCP server:
+ *
+ * - `AQE_WORKERS_ENABLED`: `false` / `0` / `off` / `no` disables the whole
+ *   worker daemon, including the QualityDaemon. Unset, empty or any other
+ *   value keeps the default behaviour (workers on). `aqe init` writes `true`
+ *   for normal installs and `false` for `--no-database` installs (#533).
+ * - `AQE_DISABLED_WORKERS`: comma-separated worker ids that are not
+ *   registered (for example `learning-consolidation`). Matched without
+ *   regard to case (#1066).
+ * - `AQE_DREAM_INSIGHTS_RETENTION_DAYS`: retention window for unapplied
+ *   `dream_insights` rows. Default 30. `0`, `off`, `false`, `no`, `disabled`,
+ *   `none` or `never` disables the sweep. Any other value that is not a whole
+ *   number of days is rejected with a warning and also disables the sweep, so
+ *   a typo never deletes anything (#1066).
+ */
+const FALSY_VALUES = new Set(['false', '0', 'off', 'no']);
+/**
+ * Values of `AQE_DREAM_INSIGHTS_RETENTION_DAYS` that turn the sweep off: the
+ * `AQE_WORKERS_ENABLED` falsy set plus a few spellings people use for "keep".
+ */
+const RETENTION_OFF_VALUES = new Set([...FALSY_VALUES, 'disabled', 'disable', 'none', 'never']);
+/** Default retention window for unapplied dream insights (days). */
+export const DEFAULT_DREAM_INSIGHTS_RETENTION_DAYS = 30;
+/** Upper bound accepted for the retention window (100 years). */
+const MAX_DREAM_INSIGHTS_RETENTION_DAYS = 36500;
+/**
+ * Whether background workers should start. Only an explicit falsy value
+ * disables them, so existing installs keep today's behaviour.
+ */
+export function isWorkersEnabled(env = process.env) {
+    const raw = env.AQE_WORKERS_ENABLED;
+    if (raw === undefined)
+        return true;
+    return !FALSY_VALUES.has(raw.trim().toLowerCase());
+}
+/**
+ * Worker ids listed in `AQE_DISABLED_WORKERS`, trimmed, lower-cased,
+ * de-duplicated and with empty entries removed. Worker ids are lower-case, so
+ * `Learning-Consolidation` disables `learning-consolidation` (#1066).
+ */
+export function parseDisabledWorkers(env = process.env) {
+    const raw = env.AQE_DISABLED_WORKERS;
+    if (!raw)
+        return [];
+    const ids = raw
+        .split(',')
+        .map((id) => id.trim().toLowerCase())
+        .filter((id) => id.length > 0);
+    return Array.from(new Set(ids));
+}
+/**
+ * Resolve `AQE_DREAM_INSIGHTS_RETENTION_DAYS`.
+ *
+ * - unset, empty or whitespace only: default (30 days). Blanking the
+ *   variable means "unset", not "off" (documented in configuration.md).
+ * - `0`, `off`, `false`, `no`, `disabled`, `none`, `never`: sweep disabled
+ *   (`retentionDays: null`)
+ * - a whole number from 1 to 36500: that many days
+ * - anything else: sweep disabled, with a warning describing the rejected
+ *   value. The sweep deletes user data, so an unreadable setting fails safe
+ *   (#1066).
+ */
+export function resolveDreamInsightsRetention(env = process.env) {
+    const raw = env.AQE_DREAM_INSIGHTS_RETENTION_DAYS;
+    if (raw === undefined || raw.trim() === '') {
+        return { retentionDays: DEFAULT_DREAM_INSIGHTS_RETENTION_DAYS };
+    }
+    const value = raw.trim().toLowerCase();
+    if (RETENTION_OFF_VALUES.has(value)) {
+        return { retentionDays: null };
+    }
+    if (/^\d+$/.test(value)) {
+        const days = Number(value);
+        if (days >= 1 && days <= MAX_DREAM_INSIGHTS_RETENTION_DAYS) {
+            return { retentionDays: days };
+        }
+    }
+    return {
+        retentionDays: null,
+        warning: `Invalid AQE_DREAM_INSIGHTS_RETENTION_DAYS=${JSON.stringify(raw)}; ` +
+            `expected a whole number of days (1-${MAX_DREAM_INSIGHTS_RETENTION_DAYS}), ` +
+            `0 or "off". The dream_insights retention sweep is off until this is fixed; nothing is deleted.`,
+    };
+}
+//# sourceMappingURL=worker-env.js.map

package/dist/workers/worker-manager.js

@@ -236,6 +236,10 @@ export class WorkerManagerImpl {
     async startAll() {
         this.running = true;
         for (const worker of Array.from(this.workers.values())) {
+            // #1066: startAll may run in the background (MCP startup), so a stop
+            // issued meanwhile must not be followed by more first runs.
+            if (!this.running)
+                break;
             if (worker.config.enabled) {
                 await this.startWorker(worker);
             }

package/dist/workers/workers/learning-consolidation.d.ts

@@ -14,15 +14,35 @@
  */
 import { BaseWorker } from '../base-worker';
 import { WorkerContext, WorkerResult } from '../interfaces';
+/**
+ * #488 C.2: retention window for `applied = 0` dream insights comes from
+ * `AQE_DREAM_INSIGHTS_RETENTION_DAYS` (default 30, `0`/`off` disables the
+ * sweep). See `resolveDreamInsightsRetention` in `../worker-env.ts`.
+ *
+ * #1061: the sweep never runs on the first tick after the worker is created.
+ * The worker manager runs every worker immediately on startup, so without this
+ * guard every short MCP session deleted rows within seconds of starting.
+ * Retries of the first tick (30 s apart) fall inside the same window.
+ */
 export declare class LearningConsolidationWorker extends BaseWorker {
     private lifecycleManager;
     private lastRunTimestamp;
+    /** #1061: the dream_insights sweep waits one full interval after creation. */
+    private readonly dreamInsightsPruneNotBefore;
+    /** #1061: an invalid retention value is reported once per process. */
+    private retentionWarningLogged;
     constructor();
     /**
      * Initialize or get the pattern lifecycle manager
      */
     private getLifecycleManager;
     protected doExecute(context: WorkerContext): Promise<WorkerResult>;
+    /**
+     * #488 C.2 / #1061: run the dream_insights retention sweep when it is
+     * enabled and the first tick after startup has passed. Returns the number
+     * of rows moved to the archive table.
+     */
+    private pruneDreamInsights;
     /**
      * Phase 7: Run the continuous learning loop
      *

package/dist/workers/workers/learning-consolidation.js

@@ -21,7 +21,8 @@ import { getUnifiedMemory, findProjectRoot } from '../../kernel/unified-memory.j
 import { toErrorMessage } from '../../shared/error-utils.js';
 import { ExperienceConsolidator } from '../../learning/experience-consolidation.js';
 import { recordLoopHealth } from '../../learning/loop-health.js';
-import { pruneStaleDreamInsights } from '../../learning/dream/dream-insights-pruner.js';
+import { pruneStaleDreamInsights, DREAM_INSIGHTS_ARCHIVE_TABLE, } from '../../learning/dream/dream-insights-pruner.js';
+import { resolveDreamInsightsRetention } from '../worker-env.js';
 import { createLearningMetricsTracker } from '../../learning/metrics-tracker.js';
 const CONFIG = {
     id: 'learning-consolidation',
@@ -44,13 +45,22 @@ const CONFIG = {
 const CONSOLIDATION_CURSOR_PREFIX = 'learning:consolidation-cursor:';
 const DEFAULT_LOOKBACK_DAYS = 1;
 /**
- * #488 C.2: retention window for `applied = 0` dream insights. Matches the
- * `staleDaysThreshold` used by `pattern-lifecycle.ts` for consistency.
+ * #488 C.2: retention window for `applied = 0` dream insights comes from
+ * `AQE_DREAM_INSIGHTS_RETENTION_DAYS` (default 30, `0`/`off` disables the
+ * sweep). See `resolveDreamInsightsRetention` in `../worker-env.ts`.
+ *
+ * #1061: the sweep never runs on the first tick after the worker is created.
+ * The worker manager runs every worker immediately on startup, so without this
+ * guard every short MCP session deleted rows within seconds of starting.
+ * Retries of the first tick (30 s apart) fall inside the same window.
  */
-const DREAM_INSIGHTS_RETENTION_DAYS = 30;
 export class LearningConsolidationWorker extends BaseWorker {
     lifecycleManager = null;
     lastRunTimestamp = 0;
+    /** #1061: the dream_insights sweep waits one full interval after creation. */
+    dreamInsightsPruneNotBefore = Date.now() + CONFIG.intervalMs;
+    /** #1061: an invalid retention value is reported once per process. */
+    retentionWarningLogged = false;
     constructor() {
         super(CONFIG);
     }
@@ -224,6 +234,46 @@ export class LearningConsolidationWorker extends BaseWorker {
             }
         }
     }
+    /**
+     * #488 C.2 / #1061: run the dream_insights retention sweep when it is
+     * enabled and the first tick after startup has passed. Returns the number
+     * of rows moved to the archive table.
+     */
+    pruneDreamInsights(findings) {
+        const retention = resolveDreamInsightsRetention();
+        if (retention.warning && !this.retentionWarningLogged) {
+            this.retentionWarningLogged = true;
+            process.stderr.write(`[AQE] WARN ${retention.warning}\n`);
+        }
+        const retentionDays = retention.retentionDays;
+        if (retentionDays === null)
+            return 0;
+        if (Date.now() < this.dreamInsightsPruneNotBefore)
+            return 0;
+        const db = getUnifiedMemory().getDatabase();
+        // #1066: rows are copied to dream_insights_archive and verified first.
+        const { pruned, archived } = pruneStaleDreamInsights(db, { retentionDays });
+        if (pruned > 0) {
+            // Default log level, stderr only: MCP stdout carries JSON-RPC.
+            process.stderr.write(`[AQE] dream_insights retention: moved ${pruned} unapplied insight(s) ` +
+                `older than ${retentionDays} days to ${DREAM_INSIGHTS_ARCHIVE_TABLE} ` +
+                `(set AQE_DREAM_INSIGHTS_RETENTION_DAYS=off to keep them in place)\n`);
+            findings.push({
+                type: 'dream-insights-pruned',
+                severity: 'info',
+                domain: 'learning-optimization',
+                title: 'Stale Dream Insights Archived',
+                description: `${pruned} unapplied dream insights older than ${retentionDays} days ` +
+                    `moved to ${DREAM_INSIGHTS_ARCHIVE_TABLE}`,
+                context: {
+                    pruned,
+                    archived,
+                    retentionDays,
+                },
+            });
+        }
+        return pruned;
+    }
     /**
      * Phase 7: Run the continuous learning loop
      *
@@ -367,26 +417,10 @@ export class LearningConsolidationWorker extends BaseWorker {
             // Step 8 (#488 C.2): prune stale unapplied dream_insights so the
             // table doesn't grow unbounded. Applied insights are part of the
             // pattern-change audit trail and stay forever.
+            // #1061: configurable, skipped on the first tick, logged to stderr.
+            // Follow-up: archive rows instead of hard-deleting them.
             try {
-                const unifiedMemory = getUnifiedMemory();
-                const db = unifiedMemory.getDatabase();
-                const pruneResult = pruneStaleDreamInsights(db, {
-                    retentionDays: DREAM_INSIGHTS_RETENTION_DAYS,
-                });
-                dreamInsightsPruned = pruneResult.pruned;
-                if (dreamInsightsPruned > 0) {
-                    findings.push({
-                        type: 'dream-insights-pruned',
-                        severity: 'info',
-                        domain: 'learning-optimization',
-                        title: 'Stale Dream Insights Pruned',
-                        description: `${dreamInsightsPruned} unapplied dream insights older than ${DREAM_INSIGHTS_RETENTION_DAYS} days deleted`,
-                        context: {
-                            pruned: dreamInsightsPruned,
-                            retentionDays: DREAM_INSIGHTS_RETENTION_DAYS,
-                        },
-                    });
-                }
+                dreamInsightsPruned = this.pruneDreamInsights(findings);
             }
             catch (pruneError) {
                 context.logger.warn('Dream insights pruning failed', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.15.7",
+  "version": "3.15.9",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 60 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "type": "module",
   "main": "./dist/index.js",

package/dist/cli/chunks/adapter-PEOUNYXJ.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.7");process.exit(0)}
-import{a,b,c}from"./chunk-56ZKQYZY.js";import"./chunk-YFOBQSOW.js";import"./chunk-YUC7RJGR.js";import"./chunk-4G2VNW4C.js";import"./chunk-LVEX4GID.js";import"./chunk-HSDOOFV7.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};

package/dist/cli/chunks/aqe-learning-engine-DHKZI5RX.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.7");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-NZQPP533.js";import"./chunk-CWPRU7ZI.js";import"./chunk-IC2WSSD5.js";import"./chunk-EV2BYY6T.js";import"./chunk-DCJW2DPL.js";import"./chunk-ZRLNACPY.js";import"./chunk-V2SAEMZY.js";import"./chunk-G7YTZTGU.js";import"./chunk-Y4SAWE45.js";import"./chunk-XEWXYGJI.js";import"./chunk-634D2ENF.js";import"./chunk-J43DV3ME.js";import"./chunk-5KCBX225.js";import"./chunk-RCYLCA7E.js";import"./chunk-BB7OLQKO.js";import"./chunk-N4PMPSJJ.js";import"./chunk-ZLVQSEZK.js";import"./chunk-LMEU64TR.js";import"./chunk-4G2VNW4C.js";import"./chunk-7EX4DEQR.js";import"./chunk-QNQSM2OG.js";import"./chunk-F62EKVVC.js";import"./chunk-HTWIGQL4.js";import"./chunk-ONVALAZN.js";import"./chunk-ZTMZFF25.js";import"./chunk-Q2T5FXEA.js";import"./chunk-C2MDBBFF.js";import"./chunk-RNYX4CPI.js";import"./chunk-FTTFJ7SJ.js";import"./chunk-CG5DZCOZ.js";import"./chunk-WXI2STKQ.js";import"./chunk-VJRZFWR5.js";import"./chunk-JYXOFN3E.js";import"./chunk-KPOPBUUJ.js";import"./chunk-LVEX4GID.js";import"./chunk-LGBN7TKC.js";import"./chunk-MRHM4COP.js";import"./chunk-5Q22XPTH.js";import"./chunk-ZUMDDMDE.js";import"./chunk-44DPYNPE.js";import"./chunk-FVBFASOD.js";import"./chunk-IARSGAG7.js";import"./chunk-JVYPXW6Y.js";import"./chunk-HSDOOFV7.js";export{b as AQELearningEngine,a as DEFAULT_ENGINE_CONFIG,c as DEFAULT_META_LEARNING_CONFIG,d as MetaLearningEngine,e as createAQELearningEngine,f as createDefaultLearningEngine};

package/dist/cli/chunks/base-QZWK3D5P.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.7");process.exit(0)}
-import{a,b,c,d,e,f,g,h,i,j,k,l}from"./chunk-6FEQ73BF.js";import"./chunk-PXZKPUW6.js";import"./chunk-2RJYA6WK.js";import"./chunk-ZLVQSEZK.js";import"./chunk-LMEU64TR.js";import"./chunk-4G2VNW4C.js";import"./chunk-7EX4DEQR.js";import"./chunk-QNQSM2OG.js";import"./chunk-F62EKVVC.js";import"./chunk-HTWIGQL4.js";import"./chunk-ONVALAZN.js";import"./chunk-ZTMZFF25.js";import"./chunk-Q2T5FXEA.js";import"./chunk-RNYX4CPI.js";import"./chunk-FTTFJ7SJ.js";import"./chunk-WXI2STKQ.js";import"./chunk-VJRZFWR5.js";import"./chunk-JYXOFN3E.js";import"./chunk-KPOPBUUJ.js";import"./chunk-LVEX4GID.js";import"./chunk-LGBN7TKC.js";import"./chunk-5Q22XPTH.js";import"./chunk-ZUMDDMDE.js";import"./chunk-IARSGAG7.js";import"./chunk-JVYPXW6Y.js";import"./chunk-HSDOOFV7.js";export{l as MCPToolBase,k as defaultToolLogger,j as getKernel,i as getLLMRouter,e as getMemoryBackend,g as getSharedLLMRouter,c as getSharedMemoryBackend,a as isMemoryOnlyMode,b as registerRvfResetFn,h as resetSharedLLMRouter,d as resetSharedMemoryBackend,f as setSharedLLMRouter};

package/dist/cli/chunks/browser-workflow-ITPX72RX.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.7");process.exit(0)}
-import{a}from"./chunk-Z3VJLWRR.js";import"./chunk-6FEQ73BF.js";import"./chunk-PXZKPUW6.js";import"./chunk-2RJYA6WK.js";import"./chunk-ZLVQSEZK.js";import"./chunk-LMEU64TR.js";import"./chunk-4G2VNW4C.js";import"./chunk-7EX4DEQR.js";import"./chunk-QNQSM2OG.js";import"./chunk-F62EKVVC.js";import"./chunk-HTWIGQL4.js";import"./chunk-ONVALAZN.js";import"./chunk-ZTMZFF25.js";import"./chunk-Q2T5FXEA.js";import"./chunk-RNYX4CPI.js";import"./chunk-FTTFJ7SJ.js";import"./chunk-WXI2STKQ.js";import"./chunk-VJRZFWR5.js";import"./chunk-JYXOFN3E.js";import"./chunk-KPOPBUUJ.js";import"./chunk-LVEX4GID.js";import"./chunk-LGBN7TKC.js";import"./chunk-5Q22XPTH.js";import"./chunk-ZUMDDMDE.js";import"./chunk-IARSGAG7.js";import"./chunk-JVYPXW6Y.js";import"./chunk-HSDOOFV7.js";export{a as BrowserWorkflowTool};

package/dist/cli/chunks/chunk-CG5DZCOZ.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.7");process.exit(0)}
-var n=["test-generation","test-execution","coverage-analysis","quality-assessment","defect-intelligence","requirements-validation","code-intelligence","security-compliance","contract-testing","visual-accessibility","chaos-resilience","learning-optimization","enterprise-integration","coordination"];function t(e){return typeof e=="string"&&n.includes(e)}function r(e){return{success:!0,value:e}}function i(e){return{success:!1,error:e}}export{n as a,t as b,r as c,i as d};