agentic-qe 3.15.8 → 3.15.10

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

@@ -14,10 +14,18 @@
  * `getPendingInsights` target and vector embeddings (if attached) grow
  * unbounded.
  *
- * Strategy: delete only insights that:
+ * Strategy: move out of `dream_insights` only insights that:
  *   - have never been applied (`applied = 0`), AND
  *   - are older than the retention window (default 30 days)
  *
+ * #1066: rows are archived, not lost. In one write transaction (BEGIN
+ * IMMEDIATE, so it waits on busy_timeout instead of failing on lock upgrade)
+ * each qualifying row is copied to `dream_insights_archive`, the copies are
+ * read back, and only rows whose copy is present are deleted. If the
+ * read-back does not match, the transaction rolls back and nothing is
+ * deleted. The archive has its own key, so an insight swept twice keeps both
+ * copies.
+ *
  * Applied insights stay forever — they're part of the audit trail for
  * pattern changes. Recently-created insights stay regardless of applied
  * state — they might still be picked up by a future `applyInsight` pass.
@@ -26,12 +34,22 @@
  * 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;
+// #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);
+}
 /**
- * Delete stale unapplied insights. Idempotent — safe to call on every tick.
+ * Archive, then delete, stale unapplied insights. Idempotent — safe to call
+ * on every tick.
  *
- * Returns `{ pruned: 0 }` if the table doesn't exist (init hasn't created
- * the dream schema yet) or if no rows qualify.
+ * Returns `{ pruned: 0, archived: 0, 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.
  */
 export function pruneStaleDreamInsights(db, options = {}) {
     const retentionDays = options.retentionDays ?? DEFAULT_RETENTION_DAYS;
@@ -41,13 +59,69 @@ export function pruneStaleDreamInsights(db, options = {}) {
         .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='dream_insights'")
         .get();
     if (!tableExists) {
-        return { pruned: 0 };
+        return { pruned: 0, archived: 0, skippedNullId: 0 };
     }
-    const result = db
-        .prepare(`DELETE FROM dream_insights
-         WHERE applied = 0
-           AND created_at < datetime('now', ?)`)
-        .run(`-${retentionDays} days`);
-    return { pruned: result.changes };
+    // One cutoff for every statement below, so the copy, the check and the
+    // delete all see the same set of rows.
+    const { cutoff } = db
+        .prepare(`SELECT datetime('now', ?) AS cutoff`)
+        .get(`-${retentionDays} days`);
+    // #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, skippedNullId };
+        db.exec(CREATE_ARCHIVE_SQL);
+        const archiveColumns = new Set(columnNames(db, DREAM_INSIGHTS_ARCHIVE_TABLE));
+        if (!archiveColumns.has('archive_id')) {
+            throw new Error(`${DREAM_INSIGHTS_ARCHIVE_TABLE} has no archive_id column; nothing deleted`);
+        }
+        // Copy the columns both tables have; older databases may lack some.
+        const shared = columnNames(db, 'dream_insights').filter((name) => name !== 'archived_at' && name !== 'archive_id' && archiveColumns.has(name));
+        const list = shared.map((name) => `"${name}"`).join(', ');
+        // Copies made by this sweep have archive_id above this mark.
+        const { mark } = db
+            .prepare(`SELECT COALESCE(MAX(archive_id), 0) AS mark FROM ${DREAM_INSIGHTS_ARCHIVE_TABLE}`)
+            .get();
+        const archived = db
+            .prepare(`INSERT INTO ${DREAM_INSIGHTS_ARCHIVE_TABLE} (${list}, archived_at)
+           SELECT ${shared.map((name) => `d."${name}"`).join(', ')}, datetime('now')
+             FROM dream_insights d WHERE ${stale}`)
+            .run(cutoff).changes;
+        // Read back: every row about to be deleted must have a copy from this sweep.
+        const copied = db
+            .prepare(`SELECT COUNT(*) AS n FROM dream_insights d
+          WHERE ${stale}
+            AND EXISTS (SELECT 1 FROM ${DREAM_INSIGHTS_ARCHIVE_TABLE} a
+                         WHERE a.id = d.id AND a.archive_id > ?)`)
+            .get(cutoff, mark).n;
+        if (copied !== candidates) {
+            throw new Error(`dream_insights archive check failed: ${copied} of ${candidates} rows copied; nothing deleted`);
+        }
+        const pruned = db
+            .prepare(`DELETE FROM dream_insights
+          WHERE applied = 0 AND created_at < ? AND id 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.
+        const left = db
+            .prepare(`SELECT COUNT(*) AS n FROM dream_insights d WHERE ${stale}`)
+            .get(cutoff).n;
+        if (pruned !== candidates || left !== 0) {
+            throw new Error(`dream_insights delete check failed: deleted ${pruned} of ${candidates}, ${left} left; rolled back`);
+        }
+        return { pruned, archived, 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
+    // a read and fails at once with SQLITE_BUSY when it upgrades to write.
+    return sweep.immediate();
 }
 //# sourceMappingURL=dream-insights-pruner.js.map

package/dist/learning/dream/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/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