agentic-qe 3.15.8 → 3.15.9

package/dist/domains/test-execution/services/test-executor.js

@@ -17,6 +17,7 @@ import { secureRandom, secureRandomInt } from '../../../shared/utils/crypto-rand
 import { writeTestRunEvidence } from '../../quality-assessment/quality-evidence.js';
 import { istanbulLineHits } from '../../../coordination/handlers/handler-utils.js';
 import { fileCoverageKey } from '../../coverage-analysis/collected-metrics.js';
+import { mergeTestCases, testCasesFromRunnerReport } from './runner-test-cases.js';
 import { getTestRunnerExecutionError, TestRunnerExecutionError } from '../../../shared/test-runner-verdict.js';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
 import { jestExactPathPattern, runnerFilePath } from '../../../shared/test-runner-args.js';
@@ -76,6 +77,7 @@ export class TestExecutorService {
                 skipped: results.skipped,
                 duration,
                 failedTests: results.failedTests,
+                ...(results.testCases ? { testCases: results.testCases } : {}),
                 coverage: results.coverage,
                 fileCoverages: results.fileCoverages,
             };
@@ -131,6 +133,7 @@ export class TestExecutorService {
                 skipped: aggregated.skipped,
                 duration,
                 failedTests: aggregated.failedTests,
+                ...(aggregated.testCases ? { testCases: aggregated.testCases } : {}),
                 coverage: aggregated.coverage,
                 fileCoverages: aggregated.fileCoverages,
             };
@@ -331,12 +334,14 @@ Provide:
             ? this.mergeSequentialCoverage(executionResults)
             : undefined;
         const separateRuns = testFiles.length > 1 && !this.config.simulateForTesting;
+        const testCases = mergeTestCases(executionResults);
         return {
             total: passed + failed + skipped,
             passed,
             failed,
             skipped,
             failedTests,
+            ...(testCases ? { testCases } : {}),
             coverage: separateRuns ? merged?.summary : this.aggregateCoverage(coverages),
             fileCoverages: separateRuns ? merged?.perFile
                 : allFileCoverages.length > 0 ? allFileCoverages : undefined,
@@ -502,7 +507,7 @@ Provide:
                     return;
                 }
                 if (reportText === undefined) {
-                    finish(err(new Error(`The current Vitest JSON report is missing for ${fileLabel}.`)));
+                    finish(err(new TestRunnerExecutionError(`The current Vitest JSON report is missing for ${fileLabel}.`)));
                     return;
                 }
                 const parseResult = this.parseTestOutput(reportText, stderr, fileLabel, framework, code);
@@ -702,12 +707,14 @@ Provide:
                 if (executionError)
                     return err(executionError);
                 const covData = this.extractCoverageFromJson(json);
+                const testCases = this.reportedTestCases(json, file, passed + failed + skipped);
                 return ok({
                     total: passed + failed + skipped,
                     passed,
                     failed,
                     skipped,
                     failedTests,
+                    ...(testCases ? { testCases } : {}),
                     coverage: covData.summary,
                     fileCoverages: covData.perFile.length > 0 ? covData.perFile : undefined,
                     rawCoverageMap: isRecord(json.coverageMap) && !json.coverageMap.total ? json.coverageMap : undefined,
@@ -721,6 +728,14 @@ Provide:
         // Example: "Tests  5 passed | 1 failed | 1 skipped (7)"
         return this.parseTestSummaryLine(stdout, stderr, file, exitCode);
     }
+    /**
+     * #1110: the report's per-test entries, kept only when they account for
+     * every counted test; a partial list would misstate the run.
+     */
+    reportedTestCases(json, file, total) {
+        const cases = testCasesFromRunnerReport(json, file);
+        return cases && cases.length === total ? cases : undefined;
+    }
     /**
      * Parse jest JSON output
      */
@@ -757,12 +772,14 @@ Provide:
             if (executionError)
                 return err(executionError);
             const covData = this.extractCoverageFromJson(json);
+            const testCases = this.reportedTestCases(json, file, passed + failed + skipped);
             return ok({
                 total: passed + failed + skipped,
                 passed,
                 failed,
                 skipped,
                 failedTests,
+                ...(testCases ? { testCases } : {}),
                 coverage: covData.summary,
                 fileCoverages: covData.perFile.length > 0 ? covData.perFile : undefined,
                 rawCoverageMap: isRecord(json.coverageMap) && !json.coverageMap.total ? json.coverageMap : undefined,
@@ -991,6 +1008,9 @@ Provide:
             aggregated.skipped += result.skipped;
             aggregated.failedTests.push(...result.failedTests);
         }
+        const testCases = mergeTestCases(results);
+        if (testCases)
+            aggregated.testCases = testCases;
         aggregated.coverage = this.aggregateCoverage(results.map(r => r.coverage).filter((c) => c !== undefined));
         // Collect per-file coverages from all worker results
         const allFileCoverages = results.flatMap(r => r.fileCoverages ?? []);
@@ -1182,7 +1202,9 @@ Provide:
         // #1028 N1: the record names the test files it ran, so per-test duration
         // is compared only between runs of the same test set.
         const files = testFiles && testFiles.length > 0 ? [...new Set(testFiles)].sort() : undefined;
-        await this.memory.set(`test-run:${runId}`, files ? { ...result, testFiles: files } : result, {
+        // Per-test entries are returned to the caller, not persisted with the run record.
+        const { testCases: _testCases, ...record } = result;
+        await this.memory.set(`test-run:${runId}`, files ? { ...record, testFiles: files } : record, {
             namespace: 'test-execution',
             persist: true,
         });

package/dist/init/fleet-integration.js

@@ -120,6 +120,8 @@ export class FleetInitEnhancer {
             const kgService = new KnowledgeGraphService(memory, {
                 namespace: 'code-intelligence:kg',
                 enableVectorEmbeddings: true,
+                // #1096: indexing is confined to the project being initialized.
+                projectRoot: this.projectRoot,
             });
             // Find all source files
             const { glob } = await import('tinyglobby');

package/dist/init/init-wizard-steps.js

@@ -199,6 +199,8 @@ export async function runCodeIntelligenceScan(projectPath) {
         const kgService = new KnowledgeGraphService(memory, {
             namespace: 'code-intelligence:kg',
             enableVectorEmbeddings: true,
+            // #1096: indexing is confined to the project being initialized.
+            projectRoot: projectPath,
         });
         const { glob } = await import('tinyglobby');
         const files = await glob([

package/dist/init/phases/06-code-intelligence.js

@@ -223,6 +223,8 @@ export class CodeIntelligencePhase extends BasePhase {
         const kgService = new KnowledgeGraphService(memory, {
             namespace: 'code-intelligence:kg',
             enableVectorEmbeddings: true,
+            // #1096: indexing is confined to the project being initialized.
+            projectRoot,
         });
         try {
             let filesToIndex;

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

@@ -204,7 +204,8 @@ if (binCandidate && binCandidate.endsWith('bundle.js')) {
 
 appendFileSync(logFile, '[' + ts + '] Using: ' + mcpCmd + ' ' + mcpArgs.join(' ') + '\\n');
 
-const env = { ...process.env, AQE_STORAGE_PATH: '.agentic-qe', AQE_LEARNING_ENABLED: 'true', AQE_WORKERS_ENABLED: 'true', AQE_HTTP_PORT: '0' };
+// #1066: keep a user's AQE_WORKERS_ENABLED (for example false) instead of forcing it on.
+const env = { ...process.env, AQE_STORAGE_PATH: '.agentic-qe', AQE_LEARNING_ENABLED: 'true', AQE_WORKERS_ENABLED: process.env.AQE_WORKERS_ENABLED ?? 'true', AQE_HTTP_PORT: '0' };
 const child = spawn(mcpCmd, mcpArgs, { cwd: projectRoot, env, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
 child.stdout.on('data', d => appendFileSync(logFile, d));
 child.stderr.on('data', d => appendFileSync(logFile, d));

package/dist/kernel/anti-drift-middleware.d.ts

@@ -110,7 +110,11 @@ export interface AntiDriftStats {
     readonly totalChecked: number;
     readonly driftCount: number;
     readonly averageSimilarity: number;
+    /** Events delivered without verification because the embedder failed. */
+    readonly unverifiedCount: number;
 }
+/** True when the event type is a lifecycle / control-plane event that must never be dropped. */
+export declare function isControlPlaneEvent(eventType: string): boolean;
 /**
  * Middleware enforcing semantic stability of domain events across agent-hop
  * boundaries. `onEmit` computes an embedding and attaches a SemanticFingerprint;
@@ -124,6 +128,15 @@ export declare class SemanticAntiDriftMiddleware implements EventMiddleware {
     private totalChecked;
     private driftCount;
     private similaritySum;
+    private unverifiedCount;
+    /** Suppressed drift warnings of keys evicted from the rate limiter, reported on the next warning. */
+    private evictedSuppressedWarnings;
+    /** Rate limit for drift warnings, keyed by event type and source. */
+    private readonly driftWarnings;
+    /** Payload text each fingerprint was computed from (same-process events only). */
+    private readonly emittedPayloadText;
+    private embeddingWarningAt;
+    private suppressedEmbeddingWarnings;
     constructor(config?: Partial<AntiDriftConfig>);
     /**
      * Compute the semantic embedding of the event payload and attach a
@@ -134,11 +147,13 @@ export declare class SemanticAntiDriftMiddleware implements EventMiddleware {
     onEmit(event: DomainEvent): Promise<DomainEvent>;
     /**
      * 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.
      */
     onReceive(event: DomainEvent): Promise<DomainEvent | null>;
     /** Returns recent drift check results (bounded by maxHistorySize). */
@@ -150,10 +165,34 @@ export declare class SemanticAntiDriftMiddleware implements EventMiddleware {
      * @returns ok(void) if valid, err(Error) otherwise.
      */
     validateConfig(): Result<void, Error>;
-    /** 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.
+     */
     private embed;
+    /**
+     * 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.
+     */
+    private embedForEvent;
     /** Map event type to threshold category via substring matching. */
     private resolveCategory;
+    /**
+     * 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.
+     */
+    private warnDrift;
+    /** Drop the least recently warned key, carrying its suppressed count forward. */
+    private evictOldestDriftWarning;
     /** Fire a SemanticDriftDetectedEvent via the configured callback. */
     private emitDriftEvent;
 }

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/learning/dream/dream-insights-pruner.d.ts

@@ -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.
@@ -38,12 +46,18 @@ export interface PruneStaleDreamInsightsOptions {
 export interface PruneResult {
     /** Number of rows deleted. Zero if the table is empty or no rows qualify. */
     pruned: number;
+    /** Number of rows copied to `dream_insights_archive` before the delete. */
+    archived: number;
 }
+/** Table that keeps every insight the sweep removes from `dream_insights`. */
+export declare const DREAM_INSIGHTS_ARCHIVE_TABLE = "dream_insights_archive";
 /**
- * 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 }` 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 declare function pruneStaleDreamInsights(db: DatabaseType, options?: PruneStaleDreamInsightsOptions): PruneResult;
 //# sourceMappingURL=dream-insights-pruner.d.ts.map

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.
@@ -27,11 +35,40 @@
  * with the rest of its lifecycle work.
  */
 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'))
+  )
+`;
+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 }` 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 +78,64 @@ 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 };
     }
-    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`);
+    const stale = 'd.applied = 0 AND d.created_at < ?';
+    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 };
+        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 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 };
+    });
+    // #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