agentic-qe 3.15.9 → 3.15.11

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

@@ -34,31 +34,12 @@
  * the 30-min worker tick. Failures are non-fatal — the worker continues
  * with the rest of its lifecycle work.
  */
+import { DREAM_INSIGHTS_ARCHIVE_TABLE, DREAM_INSIGHTS_ARCHIVE_TABLE_SQL as CREATE_ARCHIVE_SQL, } from '../../migrations/20261018_add_dream_insights_archive.js';
 const DEFAULT_RETENTION_DAYS = 30;
-/** Table that keeps every insight the sweep removes from `dream_insights`. */
-export const DREAM_INSIGHTS_ARCHIVE_TABLE = 'dream_insights_archive';
-// Same columns as dream_insights plus archive_id and archived_at. `id` is not
-// unique here: an insight that comes back (for example from a brain import)
-// and is swept again gets a second row instead of replacing the first. No
-// foreign key, so deleting a dream cycle does not cascade into the archive.
-const CREATE_ARCHIVE_SQL = `
-  CREATE TABLE IF NOT EXISTS ${DREAM_INSIGHTS_ARCHIVE_TABLE} (
-    archive_id INTEGER PRIMARY KEY AUTOINCREMENT,
-    id TEXT NOT NULL,
-    cycle_id TEXT,
-    insight_type TEXT,
-    source_concepts TEXT,
-    description TEXT,
-    novelty_score REAL,
-    confidence_score REAL,
-    actionable INTEGER,
-    applied INTEGER,
-    suggested_action TEXT,
-    pattern_id TEXT,
-    created_at TEXT,
-    archived_at TEXT NOT NULL DEFAULT (datetime('now'))
-  )
-`;
+// #1116: the archive table is part of the versioned schema (v14). The sweep
+// still runs the same idempotent CREATE first, for a database whose schema
+// was not migrated by this version (for example opened directly by a test).
+export { DREAM_INSIGHTS_ARCHIVE_TABLE };
 function columnNames(db, table) {
     return db.prepare(`PRAGMA table_info(${table})`).all().map((c) => c.name);
 }
@@ -66,7 +47,7 @@ function columnNames(db, table) {
  * Archive, then delete, stale unapplied insights. Idempotent — safe to call
  * on every tick.
  *
- * Returns `{ pruned: 0, archived: 0 }` if the table doesn't exist (init hasn't
+ * Returns `{ pruned: 0, archived: 0, skippedNullId: 0 }` if the table doesn't exist (init hasn't
  * created the dream schema yet) or if no rows qualify. Throws, with nothing
  * deleted, if the archive copy cannot be verified.
  */
@@ -78,20 +59,25 @@ export function pruneStaleDreamInsights(db, options = {}) {
         .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='dream_insights'")
         .get();
     if (!tableExists) {
-        return { pruned: 0, archived: 0 };
+        return { pruned: 0, archived: 0, skippedNullId: 0 };
     }
     // One cutoff for every statement below, so the copy, the check and the
     // delete all see the same set of rows.
     const { cutoff } = db
         .prepare(`SELECT datetime('now', ?) AS cutoff`)
         .get(`-${retentionDays} days`);
-    const stale = 'd.applied = 0 AND d.created_at < ?';
+    // #1116: a NULL id cannot be archived or matched for the delete; such rows
+    // stay where they are and are counted instead of failing the sweep.
+    const stale = 'd.applied = 0 AND d.created_at < ? AND d.id IS NOT NULL';
+    const skippedNullId = db
+        .prepare(`SELECT COUNT(*) AS n FROM dream_insights d WHERE d.applied = 0 AND d.created_at < ? AND d.id IS NULL`)
+        .get(cutoff).n;
     const sweep = db.transaction(() => {
         const candidates = db
             .prepare(`SELECT COUNT(*) AS n FROM dream_insights d WHERE ${stale}`)
             .get(cutoff).n;
         if (candidates === 0)
-            return { pruned: 0, archived: 0 };
+            return { pruned: 0, archived: 0, skippedNullId };
         db.exec(CREATE_ARCHIVE_SQL);
         const archiveColumns = new Set(columnNames(db, DREAM_INSIGHTS_ARCHIVE_TABLE));
         if (!archiveColumns.has('archive_id')) {
@@ -121,7 +107,7 @@ export function pruneStaleDreamInsights(db, options = {}) {
         }
         const pruned = db
             .prepare(`DELETE FROM dream_insights
-          WHERE applied = 0 AND created_at < ?
+          WHERE applied = 0 AND created_at < ? AND id IS NOT NULL
             AND id IN (SELECT id FROM ${DREAM_INSIGHTS_ARCHIVE_TABLE} WHERE archive_id > ?)`)
             .run(cutoff, mark).changes;
         // Read back: the stale rows are gone and none was deleted uncopied.
@@ -131,7 +117,7 @@ export function pruneStaleDreamInsights(db, options = {}) {
         if (pruned !== candidates || left !== 0) {
             throw new Error(`dream_insights delete check failed: deleted ${pruned} of ${candidates}, ${left} left; rolled back`);
         }
-        return { pruned, archived };
+        return { pruned, archived, skippedNullId };
     });
     // #1066 review: IMMEDIATE takes the write lock up front, so a busy database
     // makes the sweep wait on busy_timeout. A deferred transaction starts with

package/dist/learning/dream/index.d.ts

@@ -53,9 +53,10 @@ export { DEFAULT_CONCEPT_GRAPH_CONFIG } from './types.js';
 export { ConceptGraph, createConceptGraph } from './concept-graph.js';
 export { SpreadingActivation, type ActivationConfig, type ActivationResult, DEFAULT_ACTIVATION_CONFIG, MAX_ACTIVATION_HISTORY_ENTRIES, MAX_COACTIVATION_ENTRIES, HISTORY_TRIM_TARGET_RATIO, } from './spreading-activation.js';
 export { InsightGenerator, type InsightConfig, type DreamInsight as GeneratedInsight, type PatternTemplate, DEFAULT_INSIGHT_CONFIG, } from './insight-generator.js';
-export { DreamEngine, createDreamEngine, type DreamConfig, type DreamCycleResult as EngineResult, type ApplyInsightResult, DEFAULT_DREAM_CONFIG, } from './dream-engine.js';
+export { DreamEngine, createDreamEngine, type DreamConfig, type DreamCycleResult as EngineResult, type ApplyInsightResult, type DreamRunOptions, DreamAlreadyRunningError, DEFAULT_DREAM_CONFIG, } from './dream-engine.js';
+export { commitDream, markAbandonedCycles, ABANDONED_CYCLE_GRACE_MS, type ComputedDream, type DreamCommitResult, } from './dream-commit.js';
 export { DreamScheduler, createDreamScheduler, type DreamSchedulerConfig, type DreamSchedulerDependencies, type DreamSchedulerStatus, type TaskExperience, DEFAULT_DREAM_SCHEDULER_CONFIG, } from './dream-scheduler.js';
 export { RVCOWBranchManager, type Branch, type QualityBaseline, type ValidationResult, type ValidationThresholds, type BranchEvent, type BranchEventListener, DEFAULT_VALIDATION_THRESHOLDS, } from './rvcow-branch-manager.js';
-export { SpeculativeDreamer, type DreamStrategy, type StrategyResult, type SpeculativeDreamResult, type DreamExecutor, BUILT_IN_STRATEGIES, } from './speculative-dreamer.js';
+export { SpeculativeDreamer, type DreamStrategy, type StrategyResult, type SpeculativeDreamResult, type SpeculativeDreamOptions, BUILT_IN_STRATEGIES, } from './speculative-dreamer.js';
 export { default } from './dream-engine.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/learning/dream/index.js

@@ -66,7 +66,9 @@ export { InsightGenerator, DEFAULT_INSIGHT_CONFIG, } from './insight-generator.j
 // ============================================================================
 // DreamEngine
 // ============================================================================
-export { DreamEngine, createDreamEngine, DEFAULT_DREAM_CONFIG, } from './dream-engine.js';
+export { DreamEngine, createDreamEngine, DreamAlreadyRunningError, DEFAULT_DREAM_CONFIG, } from './dream-engine.js';
+// #1060: compute-then-commit of a dream cycle
+export { commitDream, markAbandonedCycles, ABANDONED_CYCLE_GRACE_MS, } from './dream-commit.js';
 // ============================================================================
 // DreamScheduler
 // ============================================================================

package/dist/learning/dream/insight-generator.js

@@ -14,6 +14,7 @@
  * @module learning/dream/insight-generator
  */
 import { randomUUID } from 'crypto';
+import { getOwn, setOwn } from '../../shared/utils/safe-record.js';
 /**
  * Default insight configuration
  */
@@ -320,10 +321,10 @@ export class InsightGenerator {
         };
         for (const node of activeNodes) {
             const typeKey = node.conceptType ?? 'pattern';
-            if (!byType[typeKey]) {
-                byType[typeKey] = [];
-            }
-            byType[typeKey].push(node);
+            // #1157: concept types come from stored nodes; own buckets only.
+            const bucket = getOwn(byType, typeKey) ?? [];
+            setOwn(byType, typeKey, bucket);
+            bucket.push(node);
         }
         // Gap: Error without resolution
         for (const errorNode of byType.error ?? []) {

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

@@ -19,7 +19,9 @@
  * process-wide shared connection, foreground writes made in the meantime
  * (memory_store and other acknowledged writes) join the savepoint and are
  * rolled back by a discard, or lost if the connection closes before
- * RELEASE. DreamEngine therefore defaults `enableBranching` to false.
+ * RELEASE. Since #1060 neither DreamEngine nor SpeculativeDreamer branches:
+ * a dream is computed in memory and committed in one short transaction
+ * (dream-commit.ts).
  *
  * @module learning/dream/rvcow-branch-manager
  */
@@ -102,6 +104,10 @@ export type BranchEventListener = (event: BranchEvent, branch: Branch, detail?:
  *   manager.discardBranch(branch);
  * }
  * ```
+ *
+ * @deprecated #1060: no dream path uses branching any more. A SAVEPOINT on
+ * the process-wide shared connection captures every foreground write made
+ * while it is open; do not reintroduce it there.
  */
 export declare class RVCOWBranchManager {
     private readonly db;
@@ -131,6 +137,7 @@ export declare class RVCOWBranchManager {
      * @param name - Unique branch name (used as savepoint identifier)
      * @returns The created Branch
      * @throws If a branch with this name already exists
+     * @deprecated #1060: see the class note; never open this on the shared connection.
      */
     createBranch(name: string): Branch;
     /**

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

@@ -19,7 +19,9 @@
  * process-wide shared connection, foreground writes made in the meantime
  * (memory_store and other acknowledged writes) join the savepoint and are
  * rolled back by a discard, or lost if the connection closes before
- * RELEASE. DreamEngine therefore defaults `enableBranching` to false.
+ * RELEASE. Since #1060 neither DreamEngine nor SpeculativeDreamer branches:
+ * a dream is computed in memory and committed in one short transaction
+ * (dream-commit.ts).
  *
  * @module learning/dream/rvcow-branch-manager
  */
@@ -48,6 +50,10 @@ export const DEFAULT_VALIDATION_THRESHOLDS = {
  *   manager.discardBranch(branch);
  * }
  * ```
+ *
+ * @deprecated #1060: no dream path uses branching any more. A SAVEPOINT on
+ * the process-wide shared connection captures every foreground write made
+ * while it is open; do not reintroduce it there.
  */
 export class RVCOWBranchManager {
     db;
@@ -97,6 +103,7 @@ export class RVCOWBranchManager {
      * @param name - Unique branch name (used as savepoint identifier)
      * @returns The created Branch
      * @throws If a branch with this name already exists
+     * @deprecated #1060: see the class note; never open this on the shared connection.
      */
     createBranch(name) {
         if (this.activeBranches.has(name)) {

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

@@ -1,20 +1,26 @@
 /**
- * SpeculativeDreamer - Parallel Dream Strategies with Branch Selection
- * ADR-069: RVCOW Dream Cycle Branching
+ * SpeculativeDreamer - Competing Dream Strategies, Best One Committed
+ * ADR-069 (reworked for #1060)
  *
- * Runs 2-3 dream strategies in parallel RVCOW branches, each with
- * different parameters (decay rates, spread factors, noise levels).
- * After all strategies complete, compares validation scores and merges
- * the best-performing branch. All other branches are discarded.
+ * Runs 2-3 dream strategies, each with different parameters (decay rates,
+ * spread factors, noise levels), scores their results and commits only the
+ * best one. All others are dropped.
  *
  * This implements the "adversarial dream" concept from the Six Thinking
  * Hats analysis, where diverse strategies compete and the best wins.
  *
+ * #1060: each strategy runs as `DreamEngine.dream(…, { commit: false })`,
+ * which computes the dream in memory and writes nothing. The winner is then
+ * written with `DreamEngine.commitDreamResult()`, the same single synchronous
+ * transaction a normal dream commits with. No SAVEPOINT is held across an
+ * `await`, so foreground writes on the shared connection are never rolled
+ * back with a losing strategy. (Before #1060 each strategy ran inside an RVCOW
+ * savepoint on the shared connection, and the winner was re-executed.)
+ *
  * @module learning/dream/speculative-dreamer
  */
-import type { Database as DatabaseType } from 'better-sqlite3';
 import type { ActivationConfig } from './spreading-activation.js';
-import { RVCOWBranchManager, type Branch, type ValidationResult, type ValidationThresholds } from './rvcow-branch-manager.js';
+import type { DreamEngine, DreamCycleResult } from './dream-engine.js';
 /**
  * A named dream strategy with custom activation parameters.
  */
@@ -27,16 +33,18 @@ export interface DreamStrategy {
     description?: string;
 }
 /**
- * Result of a single speculative dream branch.
+ * Result of a single speculative dream strategy.
  */
 export interface StrategyResult {
     /** The strategy that was executed */
     strategy: DreamStrategy;
-    /** The branch used */
-    branch: Branch;
-    /** Validation result against baseline */
-    validation: ValidationResult;
-    /** Whether this strategy was selected as the winner */
+    /** The strategy's dream result (null if the dream failed) */
+    result: DreamCycleResult | null;
+    /** Score used to pick the winner (higher is better; -Infinity on failure) */
+    score: number;
+    /** Why the dream failed, if it did */
+    error?: string;
+    /** Whether this strategy was selected and committed */
     selected: boolean;
     /** Execution duration in milliseconds */
     durationMs: number;
@@ -47,91 +55,59 @@ export interface StrategyResult {
 export interface SpeculativeDreamResult {
     /** All strategy results, including winner and losers */
     strategies: StrategyResult[];
-    /** The winning strategy (or null if all failed validation) */
+    /** The committed strategy (or null if every strategy failed) */
     winner: StrategyResult | null;
     /** Total wall-clock time */
     totalDurationMs: number;
+    /** How long the winner's commit transaction took, in ms */
+    commitDurationMs?: number;
+    /**
+     * True when DreamEngine.cancelDream() was called during the run: the
+     * remaining strategies were not run and nothing was committed.
+     */
+    cancelled: boolean;
+}
+/** Options for SpeculativeDreamer.dream(). */
+export interface SpeculativeDreamOptions {
+    /** Duration of each strategy's dream (default: the engine's maxDurationMs) */
+    durationMs?: number;
 }
-/**
- * Callback that executes a dream cycle with the given activation config.
- * The implementation should use the provided config overrides when running
- * spreading activation. It returns the number of insights generated.
- */
-export type DreamExecutor = (activationConfigOverrides: Partial<ActivationConfig>) => Promise<number>;
 /**
  * Predefined dream strategies with different parameter profiles.
  */
 export declare const BUILT_IN_STRATEGIES: DreamStrategy[];
 /**
- * Runs multiple dream strategies in separate RVCOW branches and selects the best.
- *
- * Because SQLite savepoints are sequential (not truly parallel), strategies
- * are executed one at a time but each in its own savepoint. The branch manager
- * ensures that failed strategies leave no trace in the database.
+ * Runs multiple dream strategies against one DreamEngine and commits the best.
  *
- * WARNING (#1060): a SAVEPOINT covers every write on its connection, not just
- * the dream's. Use an isolated connection, or keep the branch open only
- * across synchronous work. If it stays open across `await`s on the
- * process-wide shared connection, foreground writes made in the meantime
- * (memory_store and other acknowledged writes) join the savepoint and are
- * rolled back by a discard, or lost if the connection closes before
- * RELEASE. DreamEngine therefore defaults `enableBranching` to false.
+ * Strategies run one at a time (an engine runs one dream at a time). Each
+ * computes its dream in memory without writing; only the winner is committed.
  *
  * @example
  * ```typescript
- * const dreamer = new SpeculativeDreamer(db);
- * const result = await dreamer.dream(
- *   BUILT_IN_STRATEGIES,
- *   async (configOverrides) => {
- *     // Run dream with configOverrides applied
- *     return insightCount;
- *   }
- * );
+ * const dreamer = new SpeculativeDreamer(engine);
+ * const result = await dreamer.dream(BUILT_IN_STRATEGIES, { durationMs: 5000 });
  * if (result.winner) {
  *   console.log(`Best strategy: ${result.winner.strategy.name}`);
  * }
  * ```
  */
 export declare class SpeculativeDreamer {
-    private readonly db;
-    private readonly branchManager;
-    constructor(db: DatabaseType, thresholds?: ValidationThresholds);
+    private readonly engine;
+    constructor(engine: DreamEngine);
     /**
-     * Run multiple dream strategies sequentially in separate RVCOW branches,
-     * then merge the best-performing one and discard the rest.
+     * Run each strategy without committing, then commit the best-scoring one.
      *
-     * Strategy execution flow:
-     * 1. Capture baseline before any strategy runs
-     * 2. For each strategy:
-     *    a. Create branch (SAVEPOINT)
-     *    b. Execute dream with strategy params
-     *    c. Validate branch against baseline
-     *    d. Discard branch (ROLLBACK) -- we keep results in memory only
-     * 3. Replay the winning strategy in a final branch and merge it
-     *
-     * Note: Because we must discard each branch before starting the next
-     * (SQLite savepoint semantics), the winning strategy is re-executed
-     * in step 3. This is acceptable because dream cycles are deterministic
-     * given the same input state and parameters.
-     *
-     * @param strategies - 2-3 strategies to compete
-     * @param executor - Callback that runs the dream with given config
+     * @param strategies - 1-5 strategies to compete
+     * @param options - Per-strategy dream duration
      * @returns Result with winner and all strategy details
      */
-    dream(strategies: DreamStrategy[], executor: DreamExecutor): Promise<SpeculativeDreamResult>;
-    /**
-     * Get the underlying branch manager (for event subscription).
-     */
-    getBranchManager(): RVCOWBranchManager;
-    /**
-     * Execute a single strategy in a branch, validate, then discard.
-     * We discard because we need to try all strategies from the same baseline.
-     */
+    dream(strategies: DreamStrategy[], options?: SpeculativeDreamOptions): Promise<SpeculativeDreamResult>;
+    /** Run one strategy without committing anything. */
     private executeStrategy;
     /**
-     * Score a validation result for comparison.
-     * Higher score = better dream result.
+     * Score a strategy's dream. Higher = better: insights weighted by their
+     * confidence and novelty, then the novel associations found.
      */
-    private scoreValidation;
+    private scoreResult;
 }
 //# sourceMappingURL=speculative-dreamer.d.ts.map

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

@@ -1,18 +1,25 @@
 /**
- * SpeculativeDreamer - Parallel Dream Strategies with Branch Selection
- * ADR-069: RVCOW Dream Cycle Branching
+ * SpeculativeDreamer - Competing Dream Strategies, Best One Committed
+ * ADR-069 (reworked for #1060)
  *
- * Runs 2-3 dream strategies in parallel RVCOW branches, each with
- * different parameters (decay rates, spread factors, noise levels).
- * After all strategies complete, compares validation scores and merges
- * the best-performing branch. All other branches are discarded.
+ * Runs 2-3 dream strategies, each with different parameters (decay rates,
+ * spread factors, noise levels), scores their results and commits only the
+ * best one. All others are dropped.
  *
  * This implements the "adversarial dream" concept from the Six Thinking
  * Hats analysis, where diverse strategies compete and the best wins.
  *
+ * #1060: each strategy runs as `DreamEngine.dream(…, { commit: false })`,
+ * which computes the dream in memory and writes nothing. The winner is then
+ * written with `DreamEngine.commitDreamResult()`, the same single synchronous
+ * transaction a normal dream commits with. No SAVEPOINT is held across an
+ * `await`, so foreground writes on the shared connection are never rolled
+ * back with a losing strategy. (Before #1060 each strategy ran inside an RVCOW
+ * savepoint on the shared connection, and the winner was re-executed.)
+ *
  * @module learning/dream/speculative-dreamer
  */
-import { RVCOWBranchManager, DEFAULT_VALIDATION_THRESHOLDS, } from './rvcow-branch-manager.js';
+import { toErrorMessage } from '../../shared/error-utils.js';
 // ============================================================================
 // Built-in Strategies
 // ============================================================================
@@ -55,65 +62,33 @@ export const BUILT_IN_STRATEGIES = [
 // SpeculativeDreamer
 // ============================================================================
 /**
- * Runs multiple dream strategies in separate RVCOW branches and selects the best.
- *
- * Because SQLite savepoints are sequential (not truly parallel), strategies
- * are executed one at a time but each in its own savepoint. The branch manager
- * ensures that failed strategies leave no trace in the database.
+ * Runs multiple dream strategies against one DreamEngine and commits the best.
  *
- * WARNING (#1060): a SAVEPOINT covers every write on its connection, not just
- * the dream's. Use an isolated connection, or keep the branch open only
- * across synchronous work. If it stays open across `await`s on the
- * process-wide shared connection, foreground writes made in the meantime
- * (memory_store and other acknowledged writes) join the savepoint and are
- * rolled back by a discard, or lost if the connection closes before
- * RELEASE. DreamEngine therefore defaults `enableBranching` to false.
+ * Strategies run one at a time (an engine runs one dream at a time). Each
+ * computes its dream in memory without writing; only the winner is committed.
  *
  * @example
  * ```typescript
- * const dreamer = new SpeculativeDreamer(db);
- * const result = await dreamer.dream(
- *   BUILT_IN_STRATEGIES,
- *   async (configOverrides) => {
- *     // Run dream with configOverrides applied
- *     return insightCount;
- *   }
- * );
+ * const dreamer = new SpeculativeDreamer(engine);
+ * const result = await dreamer.dream(BUILT_IN_STRATEGIES, { durationMs: 5000 });
  * if (result.winner) {
  *   console.log(`Best strategy: ${result.winner.strategy.name}`);
  * }
  * ```
  */
 export class SpeculativeDreamer {
-    db;
-    branchManager;
-    constructor(db, thresholds) {
-        this.db = db;
-        this.branchManager = new RVCOWBranchManager(db, thresholds ?? DEFAULT_VALIDATION_THRESHOLDS);
+    engine;
+    constructor(engine) {
+        this.engine = engine;
     }
     /**
-     * Run multiple dream strategies sequentially in separate RVCOW branches,
-     * then merge the best-performing one and discard the rest.
-     *
-     * Strategy execution flow:
-     * 1. Capture baseline before any strategy runs
-     * 2. For each strategy:
-     *    a. Create branch (SAVEPOINT)
-     *    b. Execute dream with strategy params
-     *    c. Validate branch against baseline
-     *    d. Discard branch (ROLLBACK) -- we keep results in memory only
-     * 3. Replay the winning strategy in a final branch and merge it
-     *
-     * Note: Because we must discard each branch before starting the next
-     * (SQLite savepoint semantics), the winning strategy is re-executed
-     * in step 3. This is acceptable because dream cycles are deterministic
-     * given the same input state and parameters.
+     * Run each strategy without committing, then commit the best-scoring one.
      *
-     * @param strategies - 2-3 strategies to compete
-     * @param executor - Callback that runs the dream with given config
+     * @param strategies - 1-5 strategies to compete
+     * @param options - Per-strategy dream duration
      * @returns Result with winner and all strategy details
      */
-    async dream(strategies, executor) {
+    async dream(strategies, options = {}) {
         if (strategies.length < 1) {
             throw new Error('At least one strategy is required');
         }
@@ -121,34 +96,32 @@ export class SpeculativeDreamer {
             throw new Error('Maximum 5 strategies allowed to limit resource usage');
         }
         const totalStart = Date.now();
-        const baseline = this.branchManager.captureBaseline();
         const results = [];
-        // Execute each strategy in its own branch, collect validation results
+        // #1060: a cancel stops the whole speculative run, not only the strategy
+        // that happens to be running; nothing further runs or is committed.
+        const cancelsAtStart = this.engine.cancelCount;
+        const cancelled = () => this.engine.cancelCount !== cancelsAtStart;
         for (const strategy of strategies) {
-            const result = await this.executeStrategy(strategy, baseline, executor);
-            results.push(result);
+            if (cancelled())
+                break;
+            results.push(await this.executeStrategy(strategy, options.durationMs));
+        }
+        if (cancelled()) {
+            return { strategies: results, winner: null, totalDurationMs: Date.now() - totalStart, cancelled: true };
         }
-        // Find the best passing strategy
-        const passingResults = results.filter(r => r.validation.passed);
         let winner = null;
-        if (passingResults.length > 0) {
-            // Score strategies: prefer higher confidence delta, then more patterns
-            winner = passingResults.reduce((best, current) => {
-                const bestScore = this.scoreValidation(best.validation);
-                const currentScore = this.scoreValidation(current.validation);
-                return currentScore > bestScore ? current : best;
-            });
-            // Re-execute the winning strategy and merge it
-            const finalBranch = this.branchManager.createBranch(`dream-final-${winner.strategy.name}-${Date.now()}`);
+        for (const candidate of results) {
+            if (candidate.result && (!winner || candidate.score > winner.score))
+                winner = candidate;
+        }
+        let commitDurationMs;
+        if (winner?.result) {
             try {
-                await executor(winner.strategy.activationConfig);
-                this.branchManager.mergeBranch(finalBranch);
+                commitDurationMs = this.engine.commitDreamResult(winner.result);
                 winner.selected = true;
             }
-            catch {
-                // If re-execution fails, discard and report no winner
-                this.branchManager.discardBranch(finalBranch);
-                winner.selected = false;
+            catch (error) {
+                winner.error = toErrorMessage(error);
                 winner = null;
             }
         }
@@ -156,67 +129,47 @@ export class SpeculativeDreamer {
             strategies: results,
             winner,
             totalDurationMs: Date.now() - totalStart,
+            commitDurationMs,
+            cancelled: false,
         };
     }
-    /**
-     * Get the underlying branch manager (for event subscription).
-     */
-    getBranchManager() {
-        return this.branchManager;
-    }
     // --------------------------------------------------------------------------
     // Private Helpers
     // --------------------------------------------------------------------------
-    /**
-     * Execute a single strategy in a branch, validate, then discard.
-     * We discard because we need to try all strategies from the same baseline.
-     */
-    async executeStrategy(strategy, baseline, executor) {
-        const branchName = `dream-spec-${strategy.name}-${Date.now()}`;
-        const branch = this.branchManager.createBranch(branchName);
+    /** Run one strategy without committing anything. */
+    async executeStrategy(strategy, durationMs) {
         const start = Date.now();
         try {
-            await executor(strategy.activationConfig);
-            const validation = this.branchManager.validateBranch(branch, baseline);
-            // Discard so next strategy starts from same baseline
-            this.branchManager.discardBranch(branch);
+            const result = await this.engine.dream(durationMs, {
+                activationConfig: strategy.activationConfig,
+                commit: false,
+            });
             return {
                 strategy,
-                branch,
-                validation,
+                result,
+                score: this.scoreResult(result),
                 selected: false,
                 durationMs: Date.now() - start,
             };
         }
-        catch {
-            // Dream execution failed -- discard and mark as failed
-            this.branchManager.discardBranch(branch);
+        catch (error) {
             return {
                 strategy,
-                branch,
-                validation: {
-                    passed: false,
-                    reason: 'Dream execution threw an error',
-                    patternCountDelta: 0,
-                    avgConfidenceDelta: 0,
-                    highConfidenceLost: 0,
-                    postDreamMetrics: baseline,
-                },
+                result: null,
+                score: Number.NEGATIVE_INFINITY,
+                error: toErrorMessage(error),
                 selected: false,
                 durationMs: Date.now() - start,
             };
         }
     }
     /**
-     * Score a validation result for comparison.
-     * Higher score = better dream result.
+     * Score a strategy's dream. Higher = better: insights weighted by their
+     * confidence and novelty, then the novel associations found.
      */
-    scoreValidation(v) {
-        // Weighted scoring: confidence improvement matters most,
-        // then pattern growth, penalize high-confidence loss
-        return (v.avgConfidenceDelta * 100 +
-            v.patternCountDelta * 0.1 -
-            v.highConfidenceLost * 5);
+    scoreResult(result) {
+        const insightScore = result.insights.reduce((sum, insight) => sum + insight.confidenceScore * insight.noveltyScore, 0);
+        return insightScore + result.cycle.associationsFound * 0.01;
     }
 }
 //# sourceMappingURL=speculative-dreamer.js.map

package/dist/learning/dream/spreading-activation.d.ts

@@ -146,9 +146,10 @@ export declare class SpreadingActivation {
      * - Novel associations are discovered from unexpected co-activations
      *
      * @param durationMs - How long to dream in milliseconds
+     * @param signal - #1060: stops the dream early (engine closed, shutdown)
      * @returns Activation result from the dream cycle
      */
-    dream(durationMs: number): Promise<ActivationResult>;
+    dream(durationMs: number, signal?: AbortSignal): Promise<ActivationResult>;
     /**
      * Find novel associations from co-activated nodes.
      *