agentic-qe 3.9.30 → 3.9.32

package/dist/cli/commands/learning.js

@@ -65,6 +65,7 @@ Examples:
     registerDreamCommand(learning);
     registerRepairCommand(learning);
     registerHealthCommand(learning);
+    registerLoopHealthCommand(learning);
     return learning;
 }
 // ============================================================================
@@ -1414,6 +1415,199 @@ function registerHealthCommand(learning) {
     });
 }
 // ============================================================================
+// Subcommand: loop-health (#488 B.2)
+// ============================================================================
+/**
+ * Component staleness thresholds (ms). Each component has its own expected
+ * cadence — the bridge polls every 5s, the learning worker ticks every 30
+ * min, the dream scheduler is variable. Anything older than ~2x its cadence
+ * counts as stale and operators should investigate.
+ */
+const COMPONENT_STALE_THRESHOLDS = {
+    bridge: 30_000, // 5s poll → stale at 30s
+    learningWorker: 2 * 3600_000, // 30 min tick → stale at 2h
+    dreamScheduler: 2 * 3600_000, // similar cadence to worker
+};
+function registerLoopHealthCommand(learning) {
+    learning
+        .command('loop-health')
+        .description('Show pipeline component liveness for the self-learning loop')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const projectRoot = findProjectRoot();
+            const dbPath = path.join(projectRoot, '.agentic-qe', 'memory.db');
+            if (!existsSync(dbPath)) {
+                throw new Error('Database not found. Run "aqe init --auto" first.');
+            }
+            const db = openDatabase(dbPath, { readonly: true });
+            let raw;
+            try {
+                // Try the unified kv_store first (kernel-owned key).
+                const row = db
+                    .prepare(`SELECT value FROM kv_store WHERE key = 'learning:loop-health' LIMIT 1`)
+                    .get();
+                raw = row?.value;
+            }
+            catch {
+                // kv_store may not exist yet on a freshly-init'd shop.
+            }
+            // ADR-095: routing diversification stats (7-day rolling window)
+            let routingStats = null;
+            try {
+                const colCheck = db
+                    .prepare("PRAGMA table_info(routing_outcomes)")
+                    .all();
+                const hasExploration = colCheck.some((c) => c.name === 'exploration');
+                if (hasExploration) {
+                    const totals = db
+                        .prepare(`SELECT
+                   COUNT(*) AS total,
+                   SUM(CASE WHEN exploration = 1 THEN 1 ELSE 0 END) AS explore,
+                   AVG(criticality) AS avgCrit,
+                   AVG(q_weight) AS avgQ
+                 FROM routing_outcomes
+                 WHERE created_at >= datetime('now', '-7 days')`)
+                        .get();
+                    const total = totals.total ?? 0;
+                    const explore = totals.explore ?? 0;
+                    const exploit = total - explore;
+                    const exploitQ = db
+                        .prepare(`SELECT AVG(quality_score) AS avgQ FROM routing_outcomes
+                  WHERE exploration = 0 AND quality_score >= 0
+                    AND created_at >= datetime('now', '-7 days')`)
+                        .get();
+                    const exploreQ = db
+                        .prepare(`SELECT AVG(quality_score) AS avgQ FROM routing_outcomes
+                  WHERE exploration = 1 AND quality_score >= 0
+                    AND created_at >= datetime('now', '-7 days')`)
+                        .get();
+                    routingStats = {
+                        totalDecisions: total,
+                        explorationCount: explore,
+                        exploitCount: exploit,
+                        explorationRate: total > 0 ? explore / total : 0,
+                        avgQualityExploit: exploitQ.avgQ,
+                        avgQualityExplore: exploreQ.avgQ,
+                        avgCriticality: totals.avgCrit,
+                        avgQWeight: totals.avgQ,
+                    };
+                }
+            }
+            catch {
+                // routing_outcomes missing or pre-ADR-095 schema — skip silently.
+            }
+            db.close();
+            let health = null;
+            if (raw) {
+                try {
+                    health = safeJsonParse(raw);
+                }
+                catch {
+                    health = null;
+                }
+            }
+            const now = Date.now();
+            const verdict = (componentKey, c) => {
+                const threshold = COMPONENT_STALE_THRESHOLDS[componentKey] ?? 600_000;
+                if (!c || !c.lastSuccessAt)
+                    return 'never-ran';
+                const age = now - new Date(c.lastSuccessAt).getTime();
+                return age > threshold ? 'stale' : 'live';
+            };
+            if (options.json) {
+                if (!health) {
+                    printJson({
+                        overallLastSuccess: null,
+                        bootedAt: null,
+                        components: {},
+                        verdicts: {},
+                        routingDiversification: routingStats,
+                        note: 'No loop-health record yet. Workers must run at least once for this to populate.',
+                    });
+                    return;
+                }
+                const verdicts = {};
+                for (const key of Object.keys(health.components)) {
+                    verdicts[key] = verdict(key, health.components[key]);
+                }
+                printJson({ ...health, verdicts, routingDiversification: routingStats });
+                return;
+            }
+            console.log('');
+            console.log(chalk.bold('Self-Learning Loop Health'));
+            console.log('');
+            if (!health) {
+                console.log(chalk.dim('  No loop-health record yet.'));
+                console.log(chalk.dim('  Workers must run at least once to populate.'));
+                console.log(chalk.dim('  Start the daemon: aqe daemon start'));
+                // FALL THROUGH (no early return): routing-diversification stats may
+                // still be available even when loop-health components haven't ticked
+                // yet (e.g., routing happened via hook handlers but daemon-side
+                // workers never ran). Operators need both signals visible.
+            }
+            else {
+                console.log(`  Booted at:           ${chalk.dim(health.bootedAt)}`);
+                console.log(`  Last success (any):  ${health.overallLastSuccess || chalk.dim('(none yet)')}`);
+                console.log('');
+                console.log(chalk.bold('  Components:'));
+                const known = [
+                    ['bridge', 'CapturedExperienceBridge'],
+                    ['learningWorker', 'LearningConsolidationWorker'],
+                    ['dreamScheduler', 'DreamScheduler'],
+                ];
+                for (const [key, label] of known) {
+                    const c = health.components[key];
+                    const v = verdict(key, c);
+                    const colored = v === 'live'
+                        ? chalk.green('● live')
+                        : v === 'stale'
+                            ? chalk.yellow('● stale')
+                            : chalk.dim('○ never-ran');
+                    const lastSuccess = c?.lastSuccessAt || chalk.dim('(never)');
+                    const ticks = c
+                        ? `${c.successesSinceBoot}/${c.ticksSinceBoot} ticks ok`
+                        : chalk.dim('no ticks');
+                    console.log(`    ${label.padEnd(32)} ${colored.padEnd(20)} ${ticks}`);
+                    console.log(`      ${chalk.dim('last success:')} ${lastSuccess}`);
+                    if (c?.lastError) {
+                        console.log(`      ${chalk.red('last error:')} ${c.lastError.message} ${chalk.dim('(at ' + c.lastError.at + ')')}`);
+                    }
+                }
+                const stale = known.filter(([k, _]) => verdict(k, health.components[k]) === 'stale');
+                if (stale.length > 0) {
+                    console.log('');
+                    console.log(chalk.yellow(`  Warning: ${stale.length} component(s) stale — daemon may not be running or the loop is wedged.`));
+                }
+            }
+            // ADR-095: routing diversification dashboard
+            if (routingStats && routingStats.totalDecisions > 0) {
+                console.log('');
+                console.log(chalk.bold('  Routing diversification (last 7 days):'));
+                const ratePct = (routingStats.explorationRate * 100).toFixed(1);
+                console.log(`    Decisions:           ${routingStats.totalDecisions} (${routingStats.exploitCount} exploit, ${routingStats.explorationCount} explore = ${ratePct}%)`);
+                if (routingStats.avgQualityExploit !== null && routingStats.avgQualityExplore !== null) {
+                    const delta = routingStats.avgQualityExplore - routingStats.avgQualityExploit;
+                    const deltaStr = delta >= 0 ? chalk.green(`+${delta.toFixed(3)}`) : chalk.red(delta.toFixed(3));
+                    console.log(`    Avg quality:         exploit=${routingStats.avgQualityExploit.toFixed(3)}, explore=${routingStats.avgQualityExplore.toFixed(3)} (Δ ${deltaStr})`);
+                }
+                if (routingStats.avgCriticality !== null) {
+                    console.log(`    Avg mincut multiplier:  ${routingStats.avgCriticality.toFixed(2)} (1.0=full rate, 0.2=critical-topology dampening)`);
+                }
+                if (routingStats.avgQWeight !== null && routingStats.avgQWeight > 0) {
+                    console.log(`    Avg Q-weight:        ${routingStats.avgQWeight.toFixed(3)} (0=cold start, ${0.4} max)`);
+                }
+            }
+            console.log('');
+            return;
+        }
+        catch (error) {
+            printError(`loop-health failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            throw error;
+        }
+    });
+}
+// ============================================================================
 // Exports
 // ============================================================================
 export { initializeLearningSystem } from './learning-helpers.js';

package/dist/domains/learning-optimization/services/learning-coordinator.js

@@ -22,6 +22,14 @@ const DEFAULT_CONFIG = {
  * Implements pattern learning and experience mining capabilities
  */
 const logger = LoggerFactory.create('learning-optimization/learning-coordinator');
+/**
+ * #491 Bug 2: every read in this file must pass this namespace to match
+ * the writes (which already specify `namespace: 'learning-optimization'`).
+ * Without it, HybridBackend defaults to `default` and the coordinator
+ * cannot read its own data — `mineExperiences` returned 0 for every
+ * domain even on installs with hundreds of indexed experiences.
+ */
+const LEARNING_NS = { namespace: 'learning-optimization' };
 export class LearningCoordinatorService {
     config;
     memory;
@@ -245,9 +253,9 @@ Provide:
     async findMatchingPatterns(context, limit = 10) {
         try {
             const patterns = [];
-            const keys = await this.memory.search('learning:pattern:*', 100);
+            const keys = await this.memory.search('learning:pattern:*', 100, LEARNING_NS);
             for (const key of keys) {
-                const pattern = await this.memory.get(key);
+                const pattern = await this.memory.get(key, LEARNING_NS);
                 if (pattern && this.matchesContext(pattern, context)) {
                     patterns.push(pattern);
                 }
@@ -292,7 +300,7 @@ Provide:
     async updatePatternFeedback(patternId, success) {
         try {
             const key = `learning:pattern:${patternId}`;
-            const pattern = await this.memory.get(key);
+            const pattern = await this.memory.get(key, LEARNING_NS);
             if (!pattern) {
                 return err(new Error(`Pattern ${patternId} not found`));
             }
@@ -329,7 +337,7 @@ Provide:
             }
             const patterns = [];
             for (const id of patternIds) {
-                const pattern = await this.memory.get(`learning:pattern:${id}`);
+                const pattern = await this.memory.get(`learning:pattern:${id}`, LEARNING_NS);
                 if (pattern) {
                     patterns.push(pattern);
                 }
@@ -377,10 +385,10 @@ Provide:
      */
     async getPatternStats(domain) {
         try {
-            const keys = await this.memory.search('learning:pattern:*', 500);
+            const keys = await this.memory.search('learning:pattern:*', 500, LEARNING_NS);
             const patterns = [];
             for (const key of keys) {
-                const pattern = await this.memory.get(key);
+                const pattern = await this.memory.get(key, LEARNING_NS);
                 if (pattern && (!domain || pattern.domain === domain)) {
                     patterns.push(pattern);
                 }
@@ -525,12 +533,12 @@ Provide:
      */
     async getReplayBuffer(agentId, limit = 100) {
         try {
-            const keys = await this.memory.search(`learning:experience:index:agent:${agentId.value}:*`, limit);
+            const keys = await this.memory.search(`learning:experience:index:agent:${agentId.value}:*`, limit, LEARNING_NS);
             const experiences = [];
             for (const key of keys) {
-                const experienceId = await this.memory.get(key);
+                const experienceId = await this.memory.get(key, LEARNING_NS);
                 if (experienceId) {
-                    const experience = await this.memory.get(`learning:experience:${experienceId}`);
+                    const experience = await this.memory.get(`learning:experience:${experienceId}`, LEARNING_NS);
                     if (experience) {
                         experiences.push(experience);
                     }
@@ -601,18 +609,18 @@ Provide:
     }
     async archivePattern(patternId) {
         const key = `learning:pattern:${patternId}`;
-        const pattern = await this.memory.get(key);
+        const pattern = await this.memory.get(key, LEARNING_NS);
         if (pattern) {
             await this.memory.set(`learning:pattern:archived:${patternId}`, pattern, {
                 namespace: 'learning-optimization',
                 persist: true,
             });
-            await this.memory.delete(key);
+            await this.memory.delete(key, LEARNING_NS);
         }
     }
     async updatePatternUsage(patternId) {
         const key = `learning:pattern:${patternId}`;
-        const pattern = await this.memory.get(key);
+        const pattern = await this.memory.get(key, LEARNING_NS);
         if (pattern) {
             const updated = {
                 ...pattern,
@@ -639,14 +647,26 @@ Provide:
         await this.memory.set(`learning:experience:index:domain:${experience.domain}:${experience.id}`, experience.id, { namespace: 'learning-optimization', ttl: 86400 * 30 });
     }
     async getExperiencesByDomainAndTime(domain, timeRange) {
-        const keys = await this.memory.search(`learning:experience:index:domain:${domain}:*`, 1000);
+        const keys = await this.memory.search(`learning:experience:index:domain:${domain}:*`, 1000, LEARNING_NS);
         const experiences = [];
         for (const key of keys) {
-            const experienceId = await this.memory.get(key);
+            const experienceId = await this.memory.get(key, LEARNING_NS);
             if (experienceId) {
-                const experience = await this.memory.get(`learning:experience:${experienceId}`);
-                if (experience && timeRange.contains(experience.timestamp)) {
-                    experiences.push(experience);
+                const experience = await this.memory.get(`learning:experience:${experienceId}`, LEARNING_NS);
+                if (experience) {
+                    // #491 Bug 3: kv stores Date via JSON.stringify (→ ISO string)
+                    // but JSON.parse does not re-hydrate. `TimeRange.contains` does
+                    // `date >= start`; in `string >= Date`, the string coerces to
+                    // NaN and every comparison is false — so every experience was
+                    // silently dropped by the time-window filter, leaving
+                    // `mineExperiences` mining 0 for every domain. Coerce at the
+                    // boundary; downstream code expects a real Date.
+                    const ts = experience.timestamp instanceof Date
+                        ? experience.timestamp
+                        : new Date(experience.timestamp);
+                    if (timeRange.contains(ts)) {
+                        experiences.push({ ...experience, timestamp: ts });
+                    }
                 }
             }
         }

package/dist/init/phases/10-workers.js

@@ -121,12 +121,30 @@ if (existsSync(pidFile)) {
 const ts = new Date().toISOString();
 appendFileSync(logFile, '[' + ts + '] Starting AQE v3 Worker Daemon...\\n');
 
-// Find the best way to run aqe-mcp
+// Find the best way to run aqe-mcp.
+//
+// #488 B.1: candidate ordering matters for the pidfile contract. When we
+// spawn the real MCP binary directly, child.pid is the long-lived process
+// — \`process.kill(pid, 0)\` against the pidfile correctly reports liveness.
+// When we fall back to \`npx --yes agentic-qe mcp\`, child.pid is the npx
+// wrapper PID, which exits as soon as it has forked the real bundle. The
+// pidfile then points at a dead process and idempotency checks misbehave.
+//
+// We try in order: local .bin → local node_modules bundle → global install
+// via require.resolve → npx wrapper (last resort, with the caveat above).
 const candidates = [
   join(projectRoot, 'node_modules', '.bin', 'aqe-mcp'),
   join(projectRoot, 'node_modules', 'agentic-qe', 'dist', 'mcp', 'bundle.js'),
 ];
 
+// Probe globally-installed agentic-qe (npm install -g) via require.resolve.
+// This is the case the npx fallback used to silently cover with a bad PID.
+try {
+  candidates.push(require.resolve('agentic-qe/dist/mcp/bundle.js'));
+} catch {
+  // Not globally installed — fall through to npx fallback below.
+}
+
 let mcpCmd, mcpArgs;
 const binCandidate = candidates.find(c => existsSync(c));
 
@@ -139,6 +157,7 @@ if (binCandidate && binCandidate.endsWith('bundle.js')) {
 } else {
   mcpCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
   mcpArgs = ['--yes', 'agentic-qe', 'mcp'];
+  appendFileSync(logFile, '[' + ts + '] WARNING: using npx fallback — daemon.pid will point at the npx wrapper, not the MCP server. \`aqe daemon status\` may misreport liveness after the wrapper exits.\\n');
 }
 
 appendFileSync(logFile, '[' + ts + '] Using: ' + mcpCmd + ' ' + mcpArgs.join(' ') + '\\n');

package/dist/kernel/hybrid-backend.d.ts

@@ -9,7 +9,7 @@
  * This is a facade over UnifiedMemoryManager that maintains
  * backward compatibility with existing MemoryBackend interface.
  */
-import { MemoryBackend, StoreOptions, VectorSearchResult } from './interfaces';
+import { MemoryBackend, StoreOptions, RetrieveOptions, VectorSearchResult } from './interfaces';
 import { UnifiedMemoryManager } from './unified-memory';
 /**
  * SQLite connection configuration (legacy - kept for API compatibility)
@@ -83,21 +83,31 @@ export declare class HybridMemoryBackend implements MemoryBackend {
      */
     set<T>(key: string, value: T, options?: StoreOptions): Promise<void>;
     /**
-     * Retrieve a value
+     * Retrieve a value.
+     *
+     * #491 Bug 2: previously this method hard-coded `defaultNamespace`, so
+     * any caller that wrote with `set(k, v, {namespace:'foo'})` could not
+     * read its own data back. The whole LearningCoordinator read path
+     * (`getExperiencesByDomainAndTime` etc.) was broken by this — writes
+     * landed in `learning-optimization`, reads queried `default`, and
+     * `mineExperiences` mined 0 for every domain even on installs with
+     * hundreds of indexed experiences. Honor the namespace; default
+     * preserves the historical behavior for the many call sites that
+     * still pass no option.
      */
-    get<T>(key: string): Promise<T | undefined>;
+    get<T>(key: string, options?: RetrieveOptions): Promise<T | undefined>;
     /**
      * Delete a value
      */
-    delete(key: string): Promise<boolean>;
+    delete(key: string, options?: RetrieveOptions): Promise<boolean>;
     /**
      * Check if key exists
      */
-    has(key: string): Promise<boolean>;
+    has(key: string, options?: RetrieveOptions): Promise<boolean>;
     /**
-     * Search for keys matching pattern
+     * Search for keys matching pattern. See `get` for the namespace rationale.
      */
-    search(pattern: string, limit?: number): Promise<string[]>;
+    search(pattern: string, limit?: number, options?: RetrieveOptions): Promise<string[]>;
     /**
      * Vector similarity search
      * Now uses unified memory's persistent vector storage

package/dist/kernel/hybrid-backend.js

@@ -92,19 +92,31 @@ export class HybridMemoryBackend {
         await this.unifiedMemory.kvSet(key, value, namespace, options?.ttl);
     }
     /**
-     * Retrieve a value
+     * Retrieve a value.
+     *
+     * #491 Bug 2: previously this method hard-coded `defaultNamespace`, so
+     * any caller that wrote with `set(k, v, {namespace:'foo'})` could not
+     * read its own data back. The whole LearningCoordinator read path
+     * (`getExperiencesByDomainAndTime` etc.) was broken by this — writes
+     * landed in `learning-optimization`, reads queried `default`, and
+     * `mineExperiences` mined 0 for every domain even on installs with
+     * hundreds of indexed experiences. Honor the namespace; default
+     * preserves the historical behavior for the many call sites that
+     * still pass no option.
      */
-    async get(key) {
+    async get(key, options) {
         this.ensureInitialized();
-        return this.unifiedMemory.kvGet(key, this.config.defaultNamespace);
+        const namespace = options?.namespace ?? this.config.defaultNamespace;
+        return this.unifiedMemory.kvGet(key, namespace);
     }
     /**
      * Delete a value
      */
-    async delete(key) {
+    async delete(key, options) {
         this.ensureInitialized();
+        const namespace = options?.namespace ?? this.config.defaultNamespace;
         // Delete from KV store
-        const kvDeleted = await this.unifiedMemory.kvDelete(key, this.config.defaultNamespace);
+        const kvDeleted = await this.unifiedMemory.kvDelete(key, namespace);
         // Also try to delete from vectors (in case it's a vector key)
         const vectorDeleted = await this.unifiedMemory.vectorDelete(key);
         return kvDeleted || vectorDeleted;
@@ -112,16 +124,18 @@ export class HybridMemoryBackend {
     /**
      * Check if key exists
      */
-    async has(key) {
+    async has(key, options) {
         this.ensureInitialized();
-        return this.unifiedMemory.kvExists(key, this.config.defaultNamespace);
+        const namespace = options?.namespace ?? this.config.defaultNamespace;
+        return this.unifiedMemory.kvExists(key, namespace);
     }
     /**
-     * Search for keys matching pattern
+     * Search for keys matching pattern. See `get` for the namespace rationale.
      */
-    async search(pattern, limit = 100) {
+    async search(pattern, limit = 100, options) {
         this.ensureInitialized();
-        return this.unifiedMemory.kvSearch(pattern, this.config.defaultNamespace, limit);
+        const namespace = options?.namespace ?? this.config.defaultNamespace;
+        return this.unifiedMemory.kvSearch(pattern, namespace, limit);
     }
     /**
      * Vector similarity search

package/dist/kernel/interfaces.d.ts

@@ -200,14 +200,21 @@ export interface PluginLoader {
 export interface MemoryBackend extends Initializable, Disposable {
     /** Store a value */
     set<T>(key: string, value: T, options?: StoreOptions): Promise<void>;
-    /** Retrieve a value */
-    get<T>(key: string): Promise<T | undefined>;
+    /**
+     * Retrieve a value.
+     *
+     * `options.namespace` lets callers read from a non-default namespace.
+     * Without this, a caller that wrote with `set(k, v, {namespace:'foo'})`
+     * could not read its own data back — `get` would silently fall through
+     * to the default namespace and return undefined (issue #491 Bug 2).
+     */
+    get<T>(key: string, options?: RetrieveOptions): Promise<T | undefined>;
     /** Delete a value */
-    delete(key: string): Promise<boolean>;
+    delete(key: string, options?: RetrieveOptions): Promise<boolean>;
     /** Check if key exists */
-    has(key: string): Promise<boolean>;
-    /** Search by pattern */
-    search(pattern: string, limit?: number): Promise<string[]>;
+    has(key: string, options?: RetrieveOptions): Promise<boolean>;
+    /** Search by pattern (`options.namespace` mirrors `get`). */
+    search(pattern: string, limit?: number, options?: RetrieveOptions): Promise<string[]>;
     /** Vector similarity search (HNSW) */
     vectorSearch(embedding: number[], k: number): Promise<VectorSearchResult[]>;
     /** Store vector embedding */
@@ -230,6 +237,14 @@ export interface StoreOptions {
     namespace?: string;
     persist?: boolean;
 }
+/**
+ * Options for memory read operations. Symmetric with `StoreOptions.namespace`
+ * so a caller can read back exactly what it wrote into a non-default
+ * namespace (issue #491 Bug 2).
+ */
+export interface RetrieveOptions {
+    namespace?: string;
+}
 export interface VectorSearchResult {
     key: string;
     score: number;
@@ -297,6 +312,18 @@ export interface KernelConfig {
      * can set false to skip the plugin-load cost.
      */
     enableExperienceBridge?: boolean;
+    /**
+     * Whether to start the DreamScheduler during initialize() (ADR-094).
+     * When true (default), dream cycles run inside the long-lived kernel
+     * process instead of hook subprocesses. Hook subprocesses keep only
+     * `incrementDreamExperience` — the kernel-side scheduler is the
+     * authoritative trigger.
+     *
+     * Long-lived processes (MCP server, daemon) want this true.
+     * Short-lived CLI commands that complete in <1s can set false to skip
+     * DreamEngine init cost.
+     */
+    enableDreamScheduler?: boolean;
 }
 /**
  * Event middleware interface for anti-drift and other event processing (ADR-060)

package/dist/kernel/kernel.d.ts

@@ -21,6 +21,7 @@ export declare class QEKernelImpl implements QEKernel {
     private _initialized;
     private _loopTracker;
     private _experienceBridge?;
+    private _dreamScheduler?;
     constructor(config?: Partial<KernelConfig>);
     get eventBus(): EventBus;
     get coordinator(): AgentCoordinator;

package/dist/kernel/kernel.js

@@ -19,6 +19,8 @@ import * as fs from 'fs';
 import { PluginLifecycleManager } from '../plugins/lifecycle';
 import { PluginCache } from '../plugins/cache';
 import { CapturedExperienceBridge } from '../bridge/captured-experience-bridge.js';
+import { DreamScheduler } from '../learning/dream/dream-scheduler.js';
+import { createDreamEngine } from '../learning/dream/dream-engine.js';
 // Import domain plugin factories
 import { createTestGenerationPlugin } from '../domains/test-generation/plugin';
 import { createTestExecutionPlugin } from '../domains/test-execution/plugin';
@@ -69,6 +71,10 @@ const DEFAULT_CONFIG = {
     // working out of the box. CLI commands that don't need event-driven
     // domain reactions opt out by passing `enableExperienceBridge: false`.
     enableExperienceBridge: true,
+    // ADR-094: kernel-side dream cycles. Defaults match the bridge — long-lived
+    // processes start the scheduler so dream cycles run in the kernel rather
+    // than inside hook subprocesses. Short-lived CLIs opt out.
+    enableDreamScheduler: true,
 };
 export class QEKernelImpl {
     _eventBus;
@@ -83,6 +89,10 @@ export class QEKernelImpl {
     // Issue #479: drains captured_experiences into the eventBus so hook-driven
     // activity reaches the 13 domain plugins' subscribeToEvents() handlers.
     _experienceBridge;
+    // ADR-094: kernel-side dream cycles. Replaces the in-hook
+    // checkAndTriggerDream path so 10-second SQLite write transactions move
+    // out of short-lived hook subprocesses into the long-lived kernel.
+    _dreamScheduler;
     constructor(config = {}) {
         this._config = { ...DEFAULT_CONFIG, ...config };
         this._startTime = new Date();
@@ -262,9 +272,56 @@ export class QEKernelImpl {
                 this._experienceBridge = undefined;
             }
         }
+        // ADR-094: Start the kernel-side DreamScheduler so dream cycles run in
+        // the long-lived process. Hook subprocesses no longer trigger dreams —
+        // they only bump the experience counter (incrementDreamExperience).
+        // The scheduler subscribes to its own event triggers (quality-gate
+        // failure, domain milestones) and runs time-based dreams on its own
+        // cadence (default 1h). DreamEngine.ensureConceptsLoaded() auto-loads
+        // patterns from qe_patterns, so no separate ReasoningBank is needed here.
+        if (this._config.enableDreamScheduler !== false) {
+            try {
+                const dreamEngine = createDreamEngine({
+                    maxDurationMs: 10_000,
+                    minConceptsRequired: 3,
+                });
+                await dreamEngine.initialize();
+                this._dreamScheduler = new DreamScheduler({
+                    dreamEngine,
+                    eventBus: this._eventBus,
+                    memoryBackend: this._memory,
+                });
+                await this._dreamScheduler.initialize();
+                this._dreamScheduler.start();
+            }
+            catch (err) {
+                console.warn('[QEKernel] DreamScheduler failed to start:', err instanceof Error ? err.message : err);
+                // Tear down anything we partially constructed so we don't leak a
+                // half-initialized scheduler (e.g., engine init succeeded but
+                // scheduler.start threw).
+                if (this._dreamScheduler) {
+                    try {
+                        await this._dreamScheduler.dispose();
+                    }
+                    catch { /* swallow during cleanup */ }
+                }
+                this._dreamScheduler = undefined;
+            }
+        }
         this._initialized = true;
     }
     async dispose() {
+        // ADR-094: Stop the dream scheduler first so a dream-in-progress doesn't
+        // try to write to a disposed memory backend.
+        if (this._dreamScheduler) {
+            try {
+                await this._dreamScheduler.dispose();
+            }
+            catch (err) {
+                console.warn('[QEKernel] DreamScheduler dispose failed:', err instanceof Error ? err.message : err);
+            }
+            this._dreamScheduler = undefined;
+        }
         // Stop the bridge first so it doesn't try to publish to a disposed bus.
         if (this._experienceBridge) {
             await this._experienceBridge.stop();

package/dist/kernel/memory-backend.d.ts

@@ -2,7 +2,7 @@
  * Agentic QE v3 - Memory Backend
  * Hybrid memory implementation (in-memory + optional persistence)
  */
-import { MemoryBackend, StoreOptions, VectorSearchResult } from './interfaces';
+import { MemoryBackend, StoreOptions, RetrieveOptions, VectorSearchResult } from './interfaces';
 export declare class InMemoryBackend implements MemoryBackend {
     private store;
     private vectors;
@@ -10,10 +10,10 @@ export declare class InMemoryBackend implements MemoryBackend {
     initialize(): Promise<void>;
     dispose(): Promise<void>;
     set<T>(key: string, value: T, options?: StoreOptions): Promise<void>;
-    get<T>(key: string, namespace?: string): Promise<T | undefined>;
-    delete(key: string, namespace?: string): Promise<boolean>;
-    has(key: string, namespace?: string): Promise<boolean>;
-    search(pattern: string, limit?: number): Promise<string[]>;
+    get<T>(key: string, options?: RetrieveOptions): Promise<T | undefined>;
+    delete(key: string, options?: RetrieveOptions): Promise<boolean>;
+    has(key: string, options?: RetrieveOptions): Promise<boolean>;
+    search(pattern: string, limit?: number, options?: RetrieveOptions): Promise<string[]>;
     vectorSearch(embedding: number[], k: number): Promise<VectorSearchResult[]>;
     storeVector(key: string, embedding: number[], metadata?: unknown): Promise<void>;
     private buildKey;