agentic-qe 3.15.8 → 3.15.10

package/dist/kernel/anti-drift-middleware.js

@@ -166,6 +166,26 @@ const DEFAULT_CONFIG = {
     maxHistorySize: 200,
     fallbackDimension: 64,
 };
+/**
+ * Control-plane (task/agent/workflow lifecycle) events, matched on the last
+ * dot-separated segment of the event type:
+ * - every `Queen*` event (QueenCoordinator prefixes all of its events),
+ * - `Task*`, `Agent*`, `Workflow*`, `Step*`, `Protocol*` and `Action*` events
+ *   (TaskCompleted, TaskFailed, workflow.StepCompleted, coordination.ProtocolFailed, ...).
+ * The Queen, the workflow orchestrator and the protocol executor count slots
+ * and advance state machines on these events, so losing one leaks a slot or
+ * hangs a run (#1070, #1077).
+ */
+const CONTROL_PLANE_EVENT_RE = /^(?:Queen[A-Z]|(?:Task|Agent|Workflow|Step|Protocol|Action)[A-Z])/;
+/** True when the event type is a lifecycle / control-plane event that must never be dropped. */
+export function isControlPlaneEvent(eventType) {
+    const name = eventType.slice(eventType.lastIndexOf('.') + 1);
+    return CONTROL_PLANE_EVENT_RE.test(name);
+}
+/** One warning per event type and source per window; later drops in the window are counted. */
+const DRIFT_WARN_WINDOW_MS = 60_000;
+/** Bound on distinct (type, source) keys tracked for warning rate limiting. */
+const DRIFT_WARN_MAX_KEYS = 256;
 /**
  * Deterministic pseudo-embedding via FNV-1a-inspired hash spread.
  * Not semantically meaningful but sufficient for detecting payload mutations.
@@ -241,6 +261,15 @@ export class SemanticAntiDriftMiddleware {
     totalChecked = 0;
     driftCount = 0;
     similaritySum = 0;
+    unverifiedCount = 0;
+    /** Suppressed drift warnings of keys evicted from the rate limiter, reported on the next warning. */
+    evictedSuppressedWarnings = 0;
+    /** Rate limit for drift warnings, keyed by event type and source. */
+    driftWarnings = new Map();
+    /** Payload text each fingerprint was computed from (same-process events only). */
+    emittedPayloadText = new WeakMap();
+    embeddingWarningAt = -Infinity;
+    suppressedEmbeddingWarnings = 0;
     constructor(config) {
         this.config = {
             ...DEFAULT_CONFIG,
@@ -256,7 +285,9 @@ export class SemanticAntiDriftMiddleware {
      */
     async onEmit(event) {
         const payloadText = JSON.stringify(event.payload);
-        const embedding = await this.embed(payloadText);
+        const embedding = await this.embedForEvent(payloadText, event, 'emit');
+        if (embedding === null)
+            return event;
         const category = this.resolveCategory(event.type);
         const threshold = this.config.thresholds[category] ?? this.config.thresholds['default'];
         const fingerprint = {
@@ -266,23 +297,38 @@ export class SemanticAntiDriftMiddleware {
             hopCount: 0,
             emittedAt: Date.now(),
         };
+        this.emittedPayloadText.set(fingerprint, payloadText);
         return { ...event, semanticFingerprint: fingerprint };
     }
     /**
      * Re-embed the payload and compare with the original fingerprint.
-     * If drift exceeds threshold the event is dropped (returns null) and a
-     * SemanticDriftDetectedEvent is emitted. Events without a fingerprint
-     * pass through unchanged.
+     * If drift exceeds threshold a warning is logged, a SemanticDriftDetectedEvent
+     * is emitted, and a data event is dropped (returns null). Control-plane
+     * events (see {@link isControlPlaneEvent}) are delivered anyway: dropping a
+     * lifecycle event leaks Queen slots (#1070, #1077). Events without a
+     * fingerprint pass through unchanged.
      * @param event - The incoming domain event.
-     * @returns The event with incremented hopCount, or null if drifted.
+     * @returns The event with incremented hopCount, or null if a drifted data event.
      */
     async onReceive(event) {
         const fp = event.semanticFingerprint;
         if (!fp)
             return event;
         const payloadText = JSON.stringify(event.payload);
-        const currentEmbedding = await this.embed(payloadText);
-        const similarity = cosineSimilarity(currentEmbedding, fp.embedding);
+        // A payload whose text is byte-identical to the text this instance
+        // fingerprinted at emit time has similarity 1 by construction; skip the
+        // second model inference (#1077).
+        let similarity = 1;
+        const emittedText = this.emittedPayloadText.get(fp);
+        // Release the cached text now: bus history keeps the emitted fingerprint
+        // alive for up to 10k events.
+        this.emittedPayloadText.delete(fp);
+        if (emittedText !== payloadText) {
+            const currentEmbedding = await this.embedForEvent(payloadText, event, 'receive');
+            if (currentEmbedding === null)
+                return event;
+            similarity = cosineSimilarity(currentEmbedding, fp.embedding);
+        }
         const distance = 1 - similarity;
         const drifted = distance > fp.driftThreshold;
         this.totalChecked++;
@@ -300,8 +346,11 @@ export class SemanticAntiDriftMiddleware {
             this.history.shift();
         if (drifted) {
             this.driftCount++;
+            const deliver = isControlPlaneEvent(event.type);
+            this.warnDrift(event, checkResult, deliver);
             await this.emitDriftEvent(event, checkResult);
-            return null;
+            if (!deliver)
+                return null;
         }
         const updatedFingerprint = { ...fp, hopCount: fp.hopCount + 1 };
         return { ...event, semanticFingerprint: updatedFingerprint };
@@ -316,6 +365,7 @@ export class SemanticAntiDriftMiddleware {
             totalChecked: this.totalChecked,
             driftCount: this.driftCount,
             averageSimilarity: this.totalChecked > 0 ? this.similaritySum / this.totalChecked : 0,
+            unverifiedCount: this.unverifiedCount,
         };
     }
     /**
@@ -334,13 +384,57 @@ export class SemanticAntiDriftMiddleware {
             return err(new Error('fallbackDimension must be positive'));
         return ok(undefined);
     }
-    /** Compute embedding, preferring transformer pipeline with hash fallback. */
+    /**
+     * Compute embedding, preferring transformer pipeline with hash fallback.
+     * The transformer returns a zero vector for text it treats as non-semantic
+     * (JSON with a "metrics" key, raw arrays, mostly numeric strings). A zero
+     * vector has no direction, so the cosine check read it as total drift and
+     * silently dropped the event, e.g. every quality_assess TaskCompleted (#1070).
+     * Such text gets a hash embedding of the same length instead, which still
+     * detects a mutated payload.
+     */
     async embed(text) {
         const hasTransformer = await probeTransformer();
-        if (hasTransformer && _computeRealEmbedding)
-            return _computeRealEmbedding(text);
+        if (hasTransformer && _computeRealEmbedding) {
+            const embedding = await _computeRealEmbedding(text);
+            if (embedding.some(v => v !== 0))
+                return embedding;
+            return hashBasedEmbedding(text, embedding.length || this.config.fallbackDimension);
+        }
         return hashBasedEmbedding(text, this.config.fallbackDimension);
     }
+    /**
+     * Fingerprinting is advisory infrastructure, not an event-delivery dependency.
+     * A transformer can fail after its cached availability probe succeeded. Do not
+     * switch vector spaces mid-event: an old semantic vector and a new hash vector
+     * cannot be compared. Deliver this event without claiming a completed check;
+     * later events still try the transformer normally.
+     */
+    async embedForEvent(text, event, stage) {
+        try {
+            return await this.embed(text);
+        }
+        catch {
+            // Counted even when the warning below is rate limited, so an outage
+            // stays visible in getStats().
+            this.unverifiedCount++;
+            const now = Date.now();
+            if (now - this.embeddingWarningAt < DRIFT_WARN_WINDOW_MS) {
+                this.suppressedEmbeddingWarnings++;
+            }
+            else {
+                logger.warn('Anti-drift embedding unavailable; event delivered without verification', {
+                    eventType: event.type, source: event.source, stage,
+                    suppressedSinceLastWarning: this.suppressedEmbeddingWarnings,
+                });
+                this.embeddingWarningAt = now;
+                this.suppressedEmbeddingWarnings = 0;
+            }
+            // Never log the payload or provider's error text (it may contain input or
+            // credentials), and never count an unavailable check as successful/drifted.
+            return null;
+        }
+    }
     /** Map event type to threshold category via substring matching. */
     resolveCategory(eventType) {
         const lower = eventType.toLowerCase();
@@ -350,6 +444,48 @@ export class SemanticAntiDriftMiddleware {
         }
         return 'default';
     }
+    /**
+     * Log a drift detection to stderr (via the structured logger). Never logs
+     * payload contents. Rate limited per event type and source so a flood of
+     * drifted events produces one line per window plus a suppressed count.
+     */
+    warnDrift(event, check, delivered) {
+        const key = `${event.type}|${String(event.source)}`;
+        const now = Date.now();
+        const entry = this.driftWarnings.get(key);
+        if (entry && now - entry.lastAt < DRIFT_WARN_WINDOW_MS) {
+            entry.suppressed++;
+            return;
+        }
+        if (!entry && this.driftWarnings.size >= DRIFT_WARN_MAX_KEYS)
+            this.evictOldestDriftWarning();
+        const suppressed = entry?.suppressed ?? 0;
+        const evictedSuppressed = this.evictedSuppressedWarnings;
+        this.evictedSuppressedWarnings = 0;
+        // Re-insert so Map order tracks lastAt and the first key is the oldest.
+        this.driftWarnings.delete(key);
+        this.driftWarnings.set(key, { lastAt: now, suppressed: 0 });
+        logger.warn(delivered
+            ? 'Semantic drift detected on a control-plane event; delivered anyway'
+            : 'Semantic drift detected; event dropped', {
+            eventType: event.type,
+            source: event.source,
+            cosineSimilarity: Number(check.cosineSimilarity.toFixed(4)),
+            cosineDistance: Number((1 - check.cosineSimilarity).toFixed(4)),
+            threshold: check.threshold,
+            hopCount: check.hopCount,
+            ...(suppressed > 0 ? { suppressedSinceLastWarning: suppressed } : {}),
+            ...(evictedSuppressed > 0 ? { suppressedForEvictedKeys: evictedSuppressed } : {}),
+        });
+    }
+    /** Drop the least recently warned key, carrying its suppressed count forward. */
+    evictOldestDriftWarning() {
+        const oldest = this.driftWarnings.keys().next();
+        if (oldest.done)
+            return;
+        this.evictedSuppressedWarnings += this.driftWarnings.get(oldest.value)?.suppressed ?? 0;
+        this.driftWarnings.delete(oldest.value);
+    }
     /** Fire a SemanticDriftDetectedEvent via the configured callback. */
     async emitDriftEvent(originalEvent, check) {
         if (!this.config.onDriftDetected)

package/dist/kernel/interfaces.d.ts

@@ -33,6 +33,11 @@ export interface DomainPlugin extends Initializable, Disposable {
      * @returns true if domain can handle the task type
      */
     canHandleTask?(taskType: string): boolean;
+    /**
+     * Task types this domain executes through `executeTask` (#1075).
+     * Optional - used to tell callers which types a domain accepts.
+     */
+    getSupportedTaskTypes?(): string[];
 }
 export interface DomainHealth {
     /**

package/dist/kernel/unified-memory-schemas.d.ts

@@ -7,8 +7,9 @@
 import { HYPERGRAPH_SCHEMA } from '../migrations/20260120_add_hypergraph_tables.js';
 import { PATTERN_NULLS_SCHEMA } from '../migrations/20260611_add_pattern_nulls_table.js';
 import { LEARNING_EVIDENCE_SCHEMA } from '../migrations/20260830_add_learning_evidence_tables.js';
-export { HYPERGRAPH_SCHEMA, PATTERN_NULLS_SCHEMA, LEARNING_EVIDENCE_SCHEMA };
-export declare const SCHEMA_VERSION = 13;
+import { DREAM_INSIGHTS_ARCHIVE_SCHEMA } from '../migrations/20261018_add_dream_insights_archive.js';
+export { HYPERGRAPH_SCHEMA, PATTERN_NULLS_SCHEMA, LEARNING_EVIDENCE_SCHEMA, DREAM_INSIGHTS_ARCHIVE_SCHEMA };
+export declare const SCHEMA_VERSION = 14;
 export declare const SCHEMA_VERSION_TABLE = "\n  CREATE TABLE IF NOT EXISTS schema_version (\n    id INTEGER PRIMARY KEY CHECK (id = 1),\n    version INTEGER NOT NULL,\n    migrated_at TEXT DEFAULT (datetime('now'))\n  );\n";
 export declare const KV_STORE_SCHEMA = "\n  -- Key-Value Store (v2 compatible - same schema as HybridBackend)\n  CREATE TABLE IF NOT EXISTS kv_store (\n    key TEXT NOT NULL,\n    namespace TEXT NOT NULL,\n    value TEXT NOT NULL,\n    expires_at INTEGER,\n    created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),\n    PRIMARY KEY (namespace, key)\n  );\n  CREATE INDEX IF NOT EXISTS idx_kv_namespace ON kv_store(namespace);\n  CREATE INDEX IF NOT EXISTS idx_kv_expires ON kv_store(expires_at) WHERE expires_at IS NOT NULL;\n";
 export declare const VECTORS_SCHEMA = "\n  -- Vector Embeddings (new in v3 - replaces in-memory AgentDB)\n  CREATE TABLE IF NOT EXISTS vectors (\n    id TEXT PRIMARY KEY,\n    namespace TEXT NOT NULL DEFAULT 'default',\n    embedding BLOB NOT NULL,\n    dimensions INTEGER NOT NULL,\n    metadata TEXT,\n    created_at TEXT DEFAULT (datetime('now')),\n    updated_at TEXT DEFAULT (datetime('now'))\n  );\n  CREATE INDEX IF NOT EXISTS idx_vectors_namespace ON vectors(namespace);\n  CREATE INDEX IF NOT EXISTS idx_vectors_dimensions ON vectors(dimensions);\n";

package/dist/kernel/unified-memory-schemas.js

@@ -7,12 +7,13 @@
 import { HYPERGRAPH_SCHEMA } from '../migrations/20260120_add_hypergraph_tables.js';
 import { PATTERN_NULLS_SCHEMA } from '../migrations/20260611_add_pattern_nulls_table.js';
 import { LEARNING_EVIDENCE_SCHEMA } from '../migrations/20260830_add_learning_evidence_tables.js';
+import { DREAM_INSIGHTS_ARCHIVE_SCHEMA } from '../migrations/20261018_add_dream_insights_archive.js';
 // Re-export for convenience
-export { HYPERGRAPH_SCHEMA, PATTERN_NULLS_SCHEMA, LEARNING_EVIDENCE_SCHEMA };
+export { HYPERGRAPH_SCHEMA, PATTERN_NULLS_SCHEMA, LEARNING_EVIDENCE_SCHEMA, DREAM_INSIGHTS_ARCHIVE_SCHEMA };
 // ============================================================================
 // Schema Version for Migrations
 // ============================================================================
-export const SCHEMA_VERSION = 13; // v12: learning evidence; v13: embedding-space provenance (#633)
+export const SCHEMA_VERSION = 14; // v12: learning evidence; v13: embedding-space provenance (#633); v14: dream_insights_archive (#1116)
 export const SCHEMA_VERSION_TABLE = `
   CREATE TABLE IF NOT EXISTS schema_version (
     id INTEGER PRIMARY KEY CHECK (id = 1),

package/dist/kernel/unified-memory.js

@@ -41,7 +41,7 @@ export { BinaryHeap, UnifiedHnswIndex, createHnswIndex } from './unified-memory-
 // parity tests or benchmarks only.
 import { UnifiedHnswIndex } from './unified-memory-hnsw.js';
 // Import schemas
-import { SCHEMA_VERSION, SCHEMA_VERSION_TABLE, KV_STORE_SCHEMA, VECTORS_SCHEMA, RL_QVALUES_SCHEMA, GOAP_SCHEMA, DREAM_SCHEMA, QE_PATTERNS_SCHEMA, QE_PATTERNS_FTS_SCHEMA, QE_PATTERNS_SCHEMA_WITHOUT_FTS, MINCUT_SCHEMA, SONA_PATTERNS_SCHEMA, FEEDBACK_SCHEMA, HYPERGRAPH_SCHEMA, PATTERN_NULLS_SCHEMA, STATS_TABLES, } from './unified-memory-schemas.js';
+import { SCHEMA_VERSION, SCHEMA_VERSION_TABLE, KV_STORE_SCHEMA, VECTORS_SCHEMA, RL_QVALUES_SCHEMA, GOAP_SCHEMA, DREAM_SCHEMA, QE_PATTERNS_SCHEMA, QE_PATTERNS_FTS_SCHEMA, QE_PATTERNS_SCHEMA_WITHOUT_FTS, MINCUT_SCHEMA, SONA_PATTERNS_SCHEMA, FEEDBACK_SCHEMA, HYPERGRAPH_SCHEMA, PATTERN_NULLS_SCHEMA, DREAM_INSIGHTS_ARCHIVE_SCHEMA, STATS_TABLES, } from './unified-memory-schemas.js';
 import { ensurePatternFtsInSync } from './pattern-fts-self-heal.js';
 import { applyMigration as applyLearningEvidenceMigration } from '../migrations/20260830_add_learning_evidence_tables.js';
 // CRDT imports for distributed state synchronization
@@ -432,10 +432,20 @@ export class UnifiedMemoryManager {
         this.db.exec(SCHEMA_VERSION_TABLE);
         this.handleV2SchemaIncompatibilities();
         const versionRow = this.db.prepare('SELECT version FROM schema_version WHERE id = 1').get();
-        const currentVersion = versionRow?.version ?? 0;
-        if (currentVersion < SCHEMA_VERSION) {
-            console.log(`[UnifiedMemory] Migrating from v${currentVersion} to v${SCHEMA_VERSION}`);
+        const observedVersion = versionRow?.version ?? 0;
+        if (observedVersion < SCHEMA_VERSION) {
+            console.log(`[UnifiedMemory] Migrating from v${observedVersion} to v${SCHEMA_VERSION}`);
+            // #1116: IMMEDIATE takes the write lock before the first statement, so a
+            // concurrent opener waits on busy_timeout instead of failing with
+            // SQLITE_BUSY when a deferred read transaction has to upgrade (CREATE
+            // INDEX after a CREATE TABLE IF NOT EXISTS that only read). The version is
+            // read again under that lock: a process that waited applies only what the
+            // first one left, instead of re-running steps from a stale version.
             const migrate = this.db.transaction(() => {
+                const lockedRow = this.db.prepare('SELECT version FROM schema_version WHERE id = 1').get();
+                const currentVersion = lockedRow?.version ?? 0;
+                if (currentVersion >= SCHEMA_VERSION)
+                    return currentVersion;
                 if (currentVersion < 1)
                     this.db.exec(KV_STORE_SCHEMA);
                 if (currentVersion < 2)
@@ -472,13 +482,22 @@ export class UnifiedMemoryManager {
                     applyLearningEvidenceMigration(this.db);
                 if (currentVersion < 13)
                     this.migrateToV13EmbeddingSpace();
+                // #1116: additive; a table an earlier sweep created lazily is kept with its rows.
+                if (currentVersion < 14)
+                    this.db.exec(DREAM_INSIGHTS_ARCHIVE_SCHEMA);
                 this.db.prepare(`
           INSERT OR REPLACE INTO schema_version (id, version, migrated_at)
           VALUES (1, ?, datetime('now'))
         `).run(SCHEMA_VERSION);
+                return currentVersion;
             });
-            migrate();
-            console.log(`[UnifiedMemory] Migration complete`);
+            const migratedFrom = migrate.immediate();
+            if (migratedFrom >= SCHEMA_VERSION) {
+                console.log(`[UnifiedMemory] Another process completed the migration to v${SCHEMA_VERSION}`);
+            }
+            else {
+                console.log(`[UnifiedMemory] Migration complete`);
+            }
         }
     }
     /**

package/dist/learning/dream/dream-commit.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Dream commit (#1060): compute, then commit.
+ *
+ * A dream cycle is computed entirely in memory (spreading activation and
+ * insight generation never touch the database). Its results are then written
+ * here in ONE synchronous better-sqlite3 transaction: the activation levels,
+ * the insights and the final cycle row. There is no `await` inside the
+ * transaction, so no foreground write on the shared connection can join it,
+ * and no lock is held while asynchronous work runs. A cancelled, failed or
+ * interrupted dream commits nothing beyond its cycle row.
+ *
+ * Before #1060 the dream wrote its results one awaited statement at a time
+ * (and, with opt-in branching, inside a SAVEPOINT held across the whole
+ * asynchronous dream), so a discard or a shutdown mid-dream rolled back
+ * foreground writes that had already been acknowledged.
+ */
+import type { Database as DatabaseType } from 'better-sqlite3';
+import type { DreamCycle } from './types.js';
+import type { DreamInsight } from './insight-generator.js';
+/** Everything a dream cycle writes, computed before anything is written. */
+export interface ComputedDream {
+    cycle: DreamCycle;
+    /**
+     * Final activation level per concept node (clamped to [0, 1] on write),
+     * with the level the dream loaded. A node whose stored level no longer
+     * equals `loadedLevel` was written by someone else during the dream and is
+     * left alone. Omit `loadedLevel` to write unconditionally.
+     */
+    activations: ReadonlyArray<readonly [nodeId: string, level: number, loadedLevel?: number]>;
+    insights: readonly DreamInsight[];
+}
+export interface DreamCommitResult {
+    /** Wall-clock time the write transaction was open, in milliseconds. */
+    commitDurationMs: number;
+    /** Concept nodes updated (a node deleted meanwhile is skipped, not recreated). */
+    activationsWritten: number;
+    /** Activations skipped: the node vanished or a foreground write changed it. */
+    activationsSkipped: number;
+    insightsWritten: number;
+}
+/**
+ * Write a computed dream in one short synchronous transaction.
+ * Throws (and writes nothing) if any statement fails.
+ */
+export declare function commitDream(db: DatabaseType, dream: ComputedDream): DreamCommitResult;
+/**
+ * Margin added to the longest dream duration before a `running` cycle is
+ * treated as abandoned (covers graph loading and insight generation).
+ * DreamEngine.initialize() sweeps cycles older than
+ * max(config.maxDurationMs, 60 s) + this margin, 11 minutes by default.
+ * Library callers running longer dreams must raise maxDurationMs on every
+ * engine sharing the database (see DreamEngine.dream()).
+ */
+export declare const ABANDONED_CYCLE_GRACE_MS: number;
+/** Error recorded on a cycle the abandoned-cycle sweep marks interrupted. */
+export declare const ABANDONED_CYCLE_ERROR = "abandoned: process exited";
+/**
+ * Mark cycles a dead process left `running` as `interrupted` (#1060). Only a
+ * cycle that started more than `olderThanMs` ago is touched, so pass at least
+ * the longest dream duration plus ABANDONED_CYCLE_GRACE_MS: a cycle still
+ * running in another live process is then never marked. Rows are only
+ * updated, never deleted. Returns the number of cycles marked.
+ */
+export declare function markAbandonedCycles(db: DatabaseType, olderThanMs?: number, now?: number): number;
+//# sourceMappingURL=dream-commit.d.ts.map

package/dist/learning/dream/dream-commit.js

@@ -0,0 +1,104 @@
+/**
+ * Dream commit (#1060): compute, then commit.
+ *
+ * A dream cycle is computed entirely in memory (spreading activation and
+ * insight generation never touch the database). Its results are then written
+ * here in ONE synchronous better-sqlite3 transaction: the activation levels,
+ * the insights and the final cycle row. There is no `await` inside the
+ * transaction, so no foreground write on the shared connection can join it,
+ * and no lock is held while asynchronous work runs. A cancelled, failed or
+ * interrupted dream commits nothing beyond its cycle row.
+ *
+ * Before #1060 the dream wrote its results one awaited statement at a time
+ * (and, with opt-in branching, inside a SAVEPOINT held across the whole
+ * asynchronous dream), so a discard or a shutdown mid-dream rolled back
+ * foreground writes that had already been acknowledged.
+ */
+/**
+ * Write a computed dream in one short synchronous transaction.
+ * Throws (and writes nothing) if any statement fails.
+ */
+export function commitDream(db, dream) {
+    const updateActivation = db.prepare(`
+    UPDATE concept_nodes
+    SET activation_level = ?, last_activated = datetime('now')
+    WHERE id = ? AND (? IS NULL OR COALESCE(activation_level, 0) = ?)
+  `);
+    const insertInsight = db.prepare(`
+    INSERT INTO dream_insights
+    (id, cycle_id, insight_type, source_concepts, description, novelty_score,
+     confidence_score, actionable, applied, suggested_action, pattern_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?, NULL)
+  `);
+    // Upsert: a dream run with commit:false (SpeculativeDreamer) wrote no
+    // 'running' row up front, so its row is created here.
+    const upsertCycle = db.prepare(`
+    INSERT INTO dream_cycles
+    (id, start_time, end_time, duration_ms, concepts_processed, associations_found,
+     insights_generated, status, error)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      end_time = excluded.end_time, duration_ms = excluded.duration_ms,
+      concepts_processed = excluded.concepts_processed,
+      associations_found = excluded.associations_found,
+      insights_generated = excluded.insights_generated,
+      status = excluded.status, error = excluded.error
+  `);
+    const write = db.transaction(() => {
+        // The cycle row first: insights reference it.
+        const { cycle } = dream;
+        upsertCycle.run(cycle.id, cycle.startTime.toISOString(), cycle.endTime?.toISOString() ?? null, cycle.durationMs ?? null, cycle.conceptsProcessed, cycle.associationsFound, cycle.insightsGenerated, cycle.status, cycle.error ?? null);
+        let activationsWritten = 0;
+        for (const [nodeId, level, loadedLevel] of dream.activations) {
+            // Conflict rule: the foreground wins. A node removed since the dream
+            // loaded it is not recreated, and a node whose level changed since then
+            // is not overwritten; in both cases the UPDATE matches no row. The check
+            // compares values: a foreground write that set the node to exactly the
+            // level the dream loaded is indistinguishable and is overwritten.
+            const expected = loadedLevel ?? null;
+            activationsWritten += updateActivation.run(Math.max(0, Math.min(1, level)), nodeId, expected, expected).changes;
+        }
+        for (const insight of dream.insights) {
+            insertInsight.run(insight.id, insight.cycleId, insight.type, JSON.stringify(insight.sourceConcepts), insight.description, insight.noveltyScore, insight.confidenceScore, insight.actionable ? 1 : 0, insight.suggestedAction ?? null);
+        }
+        return {
+            activationsWritten,
+            activationsSkipped: dream.activations.length - activationsWritten,
+            insightsWritten: dream.insights.length,
+        };
+    });
+    const started = performance.now();
+    // IMMEDIATE takes the write lock up front, so the transaction waits on
+    // busy_timeout instead of failing at the read-to-write upgrade.
+    const counts = write.immediate();
+    return { ...counts, commitDurationMs: performance.now() - started };
+}
+/**
+ * Margin added to the longest dream duration before a `running` cycle is
+ * treated as abandoned (covers graph loading and insight generation).
+ * DreamEngine.initialize() sweeps cycles older than
+ * max(config.maxDurationMs, 60 s) + this margin, 11 minutes by default.
+ * Library callers running longer dreams must raise maxDurationMs on every
+ * engine sharing the database (see DreamEngine.dream()).
+ */
+export const ABANDONED_CYCLE_GRACE_MS = 10 * 60 * 1000;
+/** Error recorded on a cycle the abandoned-cycle sweep marks interrupted. */
+export const ABANDONED_CYCLE_ERROR = 'abandoned: process exited';
+/**
+ * Mark cycles a dead process left `running` as `interrupted` (#1060). Only a
+ * cycle that started more than `olderThanMs` ago is touched, so pass at least
+ * the longest dream duration plus ABANDONED_CYCLE_GRACE_MS: a cycle still
+ * running in another live process is then never marked. Rows are only
+ * updated, never deleted. Returns the number of cycles marked.
+ */
+export function markAbandonedCycles(db, olderThanMs = ABANDONED_CYCLE_GRACE_MS, now = Date.now()) {
+    const cutoff = new Date(now - olderThanMs).toISOString();
+    return db.prepare(`
+    UPDATE dream_cycles
+    SET status = 'interrupted',
+        error = ?,
+        end_time = COALESCE(end_time, ?)
+    WHERE status = 'running' AND start_time < ?
+  `).run(ABANDONED_CYCLE_ERROR, new Date(now).toISOString(), cutoff).changes;
+}
+//# sourceMappingURL=dream-commit.js.map