agentic-qe 3.15.8 → 3.15.10

package/dist/shared/utils/namespaced-search.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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.
+ */
+import type { MemoryBackend, RetrieveOptions } from '../../kernel/interfaces.js';
+/**
+ * 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;
+/** First request size for `searchAllKeys`. Each further request doubles it. */
+export declare const DEFAULT_KEY_SCAN_PAGE_SIZE = 10000;
+export interface SearchAllKeysOptions {
+    /** Namespace for the scan. Omit for the backend default. */
+    retrieve?: RetrieveOptions;
+    /** First request size (tests). Defaults to `DEFAULT_KEY_SCAN_PAGE_SIZE`. */
+    pageSize?: number;
+}
+/**
+ * Most `search()` requests one scan may make (#1106). The limit doubles each
+ * time, so this covers more keys than any store holds (2^31 x the first page)
+ * while still guaranteeing the loop ends for a backend that never returns a
+ * short page.
+ */
+export declare const MAX_KEY_SCAN_REQUESTS = 32;
+/**
+ * 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.
+ *
+ * #1106: a backend that always returns at least `limit` keys (for example
+ * one that pads or repeats results) never gives a short page. After
+ * MAX_KEY_SCAN_REQUESTS this throws instead of looping forever or returning a
+ * list that may be incomplete, because callers select patterns to archive
+ * from it. A backend that ignores `limit` and returns every key still ends:
+ * the limit doubles past the key count.
+ */
+export declare function searchAllKeys(memory: MemoryBackend, pattern: string, options?: SearchAllKeysOptions): Promise<string[]>;
+//# sourceMappingURL=namespaced-search.d.ts.map

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

@@ -0,0 +1,71 @@
+/**
+ * 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;
+/**
+ * Most `search()` requests one scan may make (#1106). The limit doubles each
+ * time, so this covers more keys than any store holds (2^31 x the first page)
+ * while still guaranteeing the loop ends for a backend that never returns a
+ * short page.
+ */
+export const MAX_KEY_SCAN_REQUESTS = 32;
+/**
+ * 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.
+ *
+ * #1106: a backend that always returns at least `limit` keys (for example
+ * one that pads or repeats results) never gives a short page. After
+ * MAX_KEY_SCAN_REQUESTS this throws instead of looping forever or returning a
+ * list that may be incomplete, because callers select patterns to archive
+ * from it. A backend that ignores `limit` and returns every key still ends:
+ * the limit doubles past the key count.
+ */
+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);
+    for (let requests = 1; found.length >= limit; requests++) {
+        if (requests >= MAX_KEY_SCAN_REQUESTS) {
+            throw new Error(`searchAllKeys('${pattern}'): the backend never returned a short page after ${requests} requests ` +
+                `(last limit ${limit}); refusing to return a possibly incomplete key list`);
+        }
+        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/shared/utils/safe-expression-evaluator.js

@@ -243,8 +243,9 @@ class Parser {
     parseIdentifier() {
         let value = this.context;
         const name = this.advance().value;
-        // Get initial value from context
-        if (typeof value === 'object' && value !== null && name in value) {
+        // Get initial value from context. #1136: own properties only, so an
+        // identifier such as `constructor` does not read an inherited member.
+        if (typeof value === 'object' && value !== null && Object.hasOwn(value, name)) {
             value = value[name];
         }
         else {
@@ -254,7 +255,7 @@ class Parser {
         while (this.current().type === 'DOT') {
             this.advance(); // consume dot
             const prop = this.expect('IDENTIFIER').value;
-            if (value !== null && value !== undefined && typeof value === 'object') {
+            if (value !== null && value !== undefined && typeof value === 'object' && Object.hasOwn(value, prop)) {
                 value = value[prop];
             }
             else {

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/strange-loop/infra-healing/recovery-playbook.js

@@ -59,7 +59,11 @@ export class RecoveryPlaybook {
     getRecoveryPlan(serviceName) {
         if (!this.config)
             return undefined;
-        return this.config.services[serviceName];
+        // Own-property lookup only: a name like `constructor` or `toString` must
+        // not resolve to an Object.prototype member (#1118).
+        return Object.hasOwn(this.config.services, serviceName)
+            ? this.config.services[serviceName]
+            : undefined;
     }
     /**
      * List all service names defined in the playbook.
@@ -89,7 +93,9 @@ export class RecoveryPlaybook {
         const defaultTimeoutMs = defaults.timeoutMs ?? 10_000;
         const defaultMaxRetries = defaults.maxRetries ?? 3;
         const defaultBackoffMs = defaults.backoffMs ?? [2000, 5000, 10_000];
-        const services = {};
+        // Null-prototype map so a service named `__proto__` is stored as an own
+        // key instead of silently replacing the prototype (#1118).
+        const services = Object.create(null);
         if (raw.services) {
             for (const [name, rawService] of Object.entries(raw.services)) {
                 services[name] = this.parseService(name, rawService, defaultTimeoutMs, defaultMaxRetries, defaultBackoffMs);
@@ -137,7 +143,11 @@ export class RecoveryPlaybook {
      */
     interpolate(template) {
         return template.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
-            return this.variables[varName] ?? _match;
+            // Own properties only: `${constructor}` must stay unresolved rather
+            // than expand to Object's function source (#1118).
+            return Object.hasOwn(this.variables, varName)
+                ? (this.variables[varName] ?? _match)
+                : _match;
         });
     }
 }

package/dist/validation/gate-reexecute.js

@@ -26,6 +26,7 @@ import { createHash } from 'node:crypto';
 import { meetsNoRegression } from './anchor-set.js';
 import { tierAllowsPromotion } from '../learning/provenance-tier.js';
 import { bootstrapDeltaCILow, pairedDeltas } from './paired-bootstrap.js';
+import { getOwn } from '../shared/utils/safe-record.js';
 /** Tag domain-separating the rule fingerprint hash. */
 const RULE_TAG = 'aqe:accept-rule:v1+sig';
 /**
@@ -137,14 +138,16 @@ export function sealedHash(sealed) {
  * unknown version so a missing rule can never silently pass verification.
  */
 export function gateFingerprint(ruleVersion) {
-    if (!(ruleVersion in ACCEPTANCE_RULES)) {
+    // #1136: own entries only; `constructor` is not a registered rule.
+    if (!Object.hasOwn(ACCEPTANCE_RULES, ruleVersion)) {
         throw new Error(`Unknown acceptance rule version '${ruleVersion}' — cannot fingerprint an unregistered rule.`);
     }
     return createHash('sha256').update(RULE_TAG).update('\0').update(ruleVersion).digest('hex');
 }
 /** Re-execute a frozen rule on sealed inputs. Throws for an unknown version. */
 export function reExecuteGate(ruleVersion, sealed) {
-    const rule = ACCEPTANCE_RULES[ruleVersion];
+    // #1136: an inherited member (`constructor` is Object) is not a rule.
+    const rule = getOwn(ACCEPTANCE_RULES, ruleVersion);
     if (!rule) {
         throw new Error(`Unknown acceptance rule version '${ruleVersion}' — refusing to re-execute an unregistered rule.`);
     }
@@ -260,14 +263,14 @@ export function pathSealedHash(sealed) {
 }
 /** Fingerprint of a path-rule VERSION. Throws for an unregistered rule. */
 export function pathGateFingerprint(ruleVersion) {
-    if (!(ruleVersion in PROMOTION_PATH_RULES)) {
+    if (!Object.hasOwn(PROMOTION_PATH_RULES, ruleVersion)) {
         throw new Error(`Unknown promotion-path rule version '${ruleVersion}' — cannot fingerprint an unregistered rule.`);
     }
     return createHash('sha256').update(PATH_RULE_TAG).update('\0').update(ruleVersion).digest('hex');
 }
 /** Re-execute a frozen path rule on sealed inputs. Throws for an unknown version. */
 export function reExecutePathGate(ruleVersion, sealed) {
-    const rule = PROMOTION_PATH_RULES[ruleVersion];
+    const rule = getOwn(PROMOTION_PATH_RULES, ruleVersion);
     if (!rule) {
         throw new Error(`Unknown promotion-path rule version '${ruleVersion}' — refusing to re-execute an unregistered rule.`);
     }

package/dist/workers/daemon.d.ts

@@ -35,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

@@ -30,11 +30,14 @@ export class QEDaemon {
     workerManager;
     config;
     _qualityDaemon;
+    /** #1066: `AQE_DISABLED_WORKERS` ids that match no worker. */
+    unknownDisabledIds = [];
     constructor(config) {
         this.config = {
             ...DEFAULT_CONFIG,
             ...config,
-            disabledWorkers: config?.disabledWorkers ?? parseDisabledWorkers(),
+            // #1066: ids are matched without regard to case.
+            disabledWorkers: (config?.disabledWorkers ?? parseDisabledWorkers()).map((id) => id.toLowerCase()),
         };
         this.workerManager = new WorkerManagerImpl();
         this.registerWorkers();
@@ -56,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
@@ -66,7 +74,19 @@ export class QEDaemon {
         this._healthCheckTimer.unref?.();
         // Auto-start workers if configured
         if (this.config.autoStart) {
-            await this.workerManager.startAll();
+            try {
+                await this.workerManager.startAll();
+            }
+            catch (error) {
+                // #1116: a failed start must not leave the daemon reporting running.
+                this._running = false;
+                this._startedAt = undefined;
+                if (this._healthCheckTimer)
+                    clearInterval(this._healthCheckTimer);
+                this._healthCheckTimer = undefined;
+                await this.workerManager.stopAll().catch(() => undefined);
+                throw error;
+            }
             console.info('[Daemon] All workers started');
         }
         // Log registered workers
@@ -174,10 +194,7 @@ export class QEDaemon {
             }
         }
         const knownIds = new Set(allWorkers.map((worker) => worker.config.id));
-        const unknownIds = this.config.disabledWorkers.filter((id) => !knownIds.has(id));
-        if (unknownIds.length > 0) {
-            console.warn(`[AQE] WARN AQE_DISABLED_WORKERS: unknown worker id(s) ignored: ${unknownIds.join(', ')}`);
-        }
+        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/quality-daemon/git-watcher.js

@@ -6,12 +6,12 @@
  * 'next' priority analysis tasks into the daemon queue.
  */
 import { watch } from 'fs';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
 import { resolve, join } from 'path';
 import { existsSync, readFileSync } from 'fs';
 import { getGitRefError } from '../../shared/git/ref-validation.js';
-const execFileAsync = promisify(execFile);
+import { runGit } from '../../shared/git/git-process.js';
+/** A hung git must not stall the watcher; its process group is stopped (#1115). */
+const GIT_TIMEOUT_MS = 10_000;
 const DEFAULTS = {
     repoRoot: process.cwd(),
     debounceMs: 500,
@@ -100,11 +100,11 @@ export class GitWatcher {
         this._polling = true;
         const changedBranches = [];
         try {
-            const { stdout } = await execFileAsync('git', [
+            const stdout = await runGit([
                 'for-each-ref',
                 '--format=%(refname:short) %(objectname:short)',
                 'refs/heads/',
-            ], { cwd: this.options.repoRoot });
+            ], { cwd: this.options.repoRoot, timeout: GIT_TIMEOUT_MS });
             for (const line of stdout.trim().split('\n')) {
                 if (!line)
                     continue;
@@ -162,13 +162,13 @@ export class GitWatcher {
             return;
         let changedFiles = [];
         try {
-            const { stdout } = await execFileAsync('git', [
+            const stdout = await runGit([
                 'diff-tree',
                 '--no-commit-id',
                 '--name-only',
                 '-r',
                 commitHash,
-            ], { cwd: this.options.repoRoot });
+            ], { cwd: this.options.repoRoot, timeout: GIT_TIMEOUT_MS });
             changedFiles = stdout
                 .trim()
                 .split('\n')
@@ -196,11 +196,11 @@ export class GitWatcher {
     }
     async snapshotHeads() {
         try {
-            const { stdout } = await execFileAsync('git', [
+            const stdout = await runGit([
                 'for-each-ref',
                 '--format=%(refname:short) %(objectname:short)',
                 'refs/heads/',
-            ], { cwd: this.options.repoRoot });
+            ], { cwd: this.options.repoRoot, timeout: GIT_TIMEOUT_MS });
             for (const line of stdout.trim().split('\n')) {
                 if (!line)
                     continue;

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

@@ -9,10 +9,13 @@
  *   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`).
+ *   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` or `off` disables the sweep.
- *   Invalid values are rejected with a warning and fall back to the default.
+ *   `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). */
@@ -23,8 +26,9 @@ export declare const DEFAULT_DREAM_INSIGHTS_RETENTION_DAYS = 30;
  */
 export declare function isWorkersEnabled(env?: WorkerEnv): boolean;
 /**
- * Worker ids listed in `AQE_DISABLED_WORKERS`, trimmed, de-duplicated and
- * with empty entries removed.
+ * 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 {
@@ -36,10 +40,14 @@ export interface DreamInsightsRetention {
 /**
  * Resolve `AQE_DREAM_INSIGHTS_RETENTION_DAYS`.
  *
- * - unset / empty: default (30 days)
- * - `0` or `off`: sweep disabled (`retentionDays: null`)
+ * - 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: default, with a warning describing the rejected value
+ * - 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

@@ -9,12 +9,20 @@
  *   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`).
+ *   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` or `off` disables the sweep.
- *   Invalid values are rejected with a warning and fall back to the default.
+ *   `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). */
@@ -30,8 +38,9 @@ export function isWorkersEnabled(env = process.env) {
     return !FALSY_VALUES.has(raw.trim().toLowerCase());
 }
 /**
- * Worker ids listed in `AQE_DISABLED_WORKERS`, trimmed, de-duplicated and
- * with empty entries removed.
+ * 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;
@@ -39,17 +48,21 @@ export function parseDisabledWorkers(env = process.env) {
         return [];
     const ids = raw
         .split(',')
-        .map((id) => id.trim())
+        .map((id) => id.trim().toLowerCase())
         .filter((id) => id.length > 0);
     return Array.from(new Set(ids));
 }
 /**
  * Resolve `AQE_DREAM_INSIGHTS_RETENTION_DAYS`.
  *
- * - unset / empty: default (30 days)
- * - `0` or `off`: sweep disabled (`retentionDays: null`)
+ * - 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: default, with a warning describing the rejected value
+ * - 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;
@@ -57,7 +70,7 @@ export function resolveDreamInsightsRetention(env = process.env) {
         return { retentionDays: DEFAULT_DREAM_INSIGHTS_RETENTION_DAYS };
     }
     const value = raw.trim().toLowerCase();
-    if (value === 'off' || value === '0') {
+    if (RETENTION_OFF_VALUES.has(value)) {
         return { retentionDays: null };
     }
     if (/^\d+$/.test(value)) {
@@ -67,10 +80,10 @@ export function resolveDreamInsightsRetention(env = process.env) {
         }
     }
     return {
-        retentionDays: DEFAULT_DREAM_INSIGHTS_RETENTION_DAYS,
+        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". Using the default of ${DEFAULT_DREAM_INSIGHTS_RETENTION_DAYS} 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);
             }