agentic-qe 3.8.14 → 3.9.1

package/dist/learning/aqe-learning-engine.js

@@ -880,6 +880,140 @@ export class AQELearningEngine {
         this.initialized = false;
     }
 }
+/**
+ * Default meta-learning configuration.
+ */
+export const DEFAULT_META_LEARNING_CONFIG = {
+    enabled: false,
+    snapshotIntervalMs: 300_000,
+    minSnapshotsForAnalysis: 5,
+    autoApplyThreshold: 0.8,
+};
+/**
+ * Meta-Learning Engine — closed-loop meta-optimization (ADR-062).
+ *
+ * Analyses a time-series of `UnifiedMetricsSnapshot`s to detect
+ * token-waste, quality plateaus, learning stalls, and performance
+ * regressions.  Guarded by the `AQE_META_LEARNING_ENABLED` env var
+ * (opt-in, default `false`).
+ */
+export class MetaLearningEngine {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_META_LEARNING_CONFIG, ...config };
+    }
+    /**
+     * Run a single meta-learning analysis cycle.
+     *
+     * Trend detection strategy: compare the first half of snapshots to the
+     * second half using simple averages.  This keeps the implementation
+     * lightweight and predictable.
+     *
+     * @param snapshots - Ordered (oldest → newest) unified metric snapshots
+     * @returns Detected meta-insights (may be empty)
+     */
+    runMetaLearningCycle(snapshots) {
+        // Feature-flag gate
+        if (process.env.AQE_META_LEARNING_ENABLED !== 'true') {
+            return [];
+        }
+        if (!this.config.enabled) {
+            return [];
+        }
+        if (snapshots.length < this.config.minSnapshotsForAnalysis) {
+            return [];
+        }
+        const mid = Math.floor(snapshots.length / 2);
+        const firstHalf = snapshots.slice(0, mid);
+        const secondHalf = snapshots.slice(mid);
+        const insights = [];
+        const now = Date.now();
+        // --- Token waste: cost increasing but savings flat ---
+        const avgCostFirst = avg(firstHalf.map(s => s.tokenMetrics.costUsd));
+        const avgCostSecond = avg(secondHalf.map(s => s.tokenMetrics.costUsd));
+        const avgSavingsFirst = avg(firstHalf.map(s => s.tokenMetrics.savingsUsd));
+        const avgSavingsSecond = avg(secondHalf.map(s => s.tokenMetrics.savingsUsd));
+        if (avgCostSecond > avgCostFirst * 1.1 && avgSavingsSecond <= avgSavingsFirst * 1.05) {
+            const confidence = Math.min(1, (avgCostSecond - avgCostFirst) / (avgCostFirst || 1));
+            insights.push({
+                id: `meta-tw-${now}`,
+                type: 'token-waste',
+                description: `Token cost increased by ${((avgCostSecond / (avgCostFirst || 1) - 1) * 100).toFixed(1)}% while savings remained flat`,
+                confidence: clamp01(confidence),
+                suggestedAction: 'Review cache configuration and increase pattern reuse thresholds',
+                detectedAt: now,
+            });
+        }
+        // --- Quality plateau: gatePassRate flat ---
+        const avgGateFirst = avg(firstHalf.map(s => s.qualityMetrics.gatePassRate));
+        const avgGateSecond = avg(secondHalf.map(s => s.qualityMetrics.gatePassRate));
+        const gateDelta = Math.abs(avgGateSecond - avgGateFirst);
+        if (gateDelta < 0.02 && snapshots.length >= this.config.minSnapshotsForAnalysis) {
+            insights.push({
+                id: `meta-qp-${now}`,
+                type: 'quality-plateau',
+                description: `Gate pass rate has been flat at ${(avgGateSecond * 100).toFixed(1)}% across ${snapshots.length} snapshots`,
+                confidence: clamp01(0.6 + (snapshots.length - this.config.minSnapshotsForAnalysis) * 0.05),
+                suggestedAction: 'Consider reviewing quality thresholds or adding new test coverage domains',
+                detectedAt: now,
+            });
+        }
+        // --- Learning stall: patternCount flat AND confidence flat ---
+        const avgPatFirst = avg(firstHalf.map(s => s.learningMetrics.patternCount));
+        const avgPatSecond = avg(secondHalf.map(s => s.learningMetrics.patternCount));
+        const avgConfFirst = avg(firstHalf.map(s => s.learningMetrics.averageConfidence));
+        const avgConfSecond = avg(secondHalf.map(s => s.learningMetrics.averageConfidence));
+        const patDelta = Math.abs(avgPatSecond - avgPatFirst);
+        const confDelta = Math.abs(avgConfSecond - avgConfFirst);
+        if (patDelta < 1 && confDelta < 0.02) {
+            insights.push({
+                id: `meta-ls-${now}`,
+                type: 'learning-stall',
+                description: `Pattern count (~${Math.round(avgPatSecond)}) and confidence (~${avgConfSecond.toFixed(2)}) have stagnated`,
+                confidence: clamp01(0.65 + (snapshots.length - this.config.minSnapshotsForAnalysis) * 0.04),
+                suggestedAction: 'Expand to new QE domains or lower pattern creation thresholds to encourage exploration',
+                detectedAt: now,
+            });
+        }
+        // --- Performance regression: p95 latency increasing ---
+        const avgP95First = avg(firstHalf.map(s => s.performanceMetrics.p95LatencyMs));
+        const avgP95Second = avg(secondHalf.map(s => s.performanceMetrics.p95LatencyMs));
+        if (avgP95Second > avgP95First * 1.2 && avgP95First > 0) {
+            const confidence = Math.min(1, (avgP95Second - avgP95First) / (avgP95First || 1));
+            insights.push({
+                id: `meta-pr-${now}`,
+                type: 'performance-regression',
+                description: `P95 latency increased from ${avgP95First.toFixed(0)}ms to ${avgP95Second.toFixed(0)}ms`,
+                confidence: clamp01(confidence),
+                suggestedAction: 'Profile hot paths and consider HNSW index tuning or batch size reduction',
+                detectedAt: now,
+            });
+        }
+        return insights;
+    }
+    /**
+     * Determine whether an insight should be auto-applied.
+     *
+     * @param insight - The insight to evaluate
+     * @param config  - Meta-learning config with the auto-apply threshold
+     * @returns `true` if the insight's confidence meets or exceeds the threshold
+     */
+    shouldAutoApply(insight, config) {
+        const threshold = (config ?? this.config).autoApplyThreshold;
+        return insight.confidence >= threshold;
+    }
+}
+// --- Helpers -----------------------------------------------------------------
+/** Arithmetic mean; returns 0 for empty arrays. */
+function avg(values) {
+    if (values.length === 0)
+        return 0;
+    return values.reduce((a, b) => a + b, 0) / values.length;
+}
+/** Clamp a number into [0, 1]. */
+function clamp01(v) {
+    return Math.max(0, Math.min(1, v));
+}
 // ============================================================================
 // Factory Functions
 // ============================================================================

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

@@ -106,6 +106,9 @@ export declare class DreamEngine {
     /** Optional witness chain for audit trail of dream decisions (ADR-070) */
     private _witnessChain;
     set witnessChain(wc: WitnessChain | null);
+    /** Optional RVF adapter for COW branching (ADR-069). Set externally to share with PatternStore. */
+    private _rvfAdapter;
+    set rvfAdapter(adapter: any);
     constructor(config?: Partial<DreamConfig>);
     /**
      * Initialize using unified persistence
@@ -203,7 +206,9 @@ export declare class DreamEngine {
     private rowToInsight;
 }
 /**
- * Create a new DreamEngine instance
+ * Create a new DreamEngine instance.
+ * When useRVFPatternStore is enabled, auto-wires the RVF adapter for
+ * COW branching (ADR-069) so callers don't need to set it manually.
  */
 export declare function createDreamEngine(config?: Partial<DreamConfig>): DreamEngine;
 export default DreamEngine;

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

@@ -212,6 +212,11 @@ export class DreamEngine {
     /** Optional witness chain for audit trail of dream decisions (ADR-070) */
     _witnessChain = null;
     set witnessChain(wc) { this._witnessChain = wc; }
+    /** Optional RVF adapter for COW branching (ADR-069). Set externally to share with PatternStore. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _rvfAdapter = null;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    set rvfAdapter(adapter) { this._rvfAdapter = adapter; }
     constructor(config) {
         this.config = { ...DEFAULT_DREAM_CONFIG, ...config };
     }
@@ -238,6 +243,12 @@ export class DreamEngine {
             // Initialize RVCOW branch manager (ADR-069)
             if (this.config.enableBranching) {
                 this.branchManager = new RVCOWBranchManager(this.db, this.config.branchValidationThresholds);
+                // ADR-069: Wire RVF adapter for true COW branching when available
+                // Uses externally-provided adapter to avoid duplicate file handles
+                if (this._rvfAdapter) {
+                    this.branchManager.setRvfAdapter(this._rvfAdapter, true);
+                    console.log('[DreamEngine] RVF COW branching activated (ADR-069)');
+                }
             }
             this.initialized = true;
             console.log(`[DreamEngine] Initialized: ${this.persistence.getDbPath()}`);
@@ -710,10 +721,34 @@ export class DreamEngine {
 // Factory Function
 // ============================================================================
 /**
- * Create a new DreamEngine instance
+ * Create a new DreamEngine instance.
+ * When useRVFPatternStore is enabled, auto-wires the RVF adapter for
+ * COW branching (ADR-069) so callers don't need to set it manually.
  */
 export function createDreamEngine(config) {
-    return new DreamEngine(config);
+    const engine = new DreamEngine(config);
+    // ADR-069: Auto-wire RVF adapter from the shared singleton (M4 fix).
+    // Uses the same adapter instance as the kernel to avoid dual file handles.
+    // Dynamic import() for ESM compatibility — wiring resolves before
+    // engine.initialize() is called since callers always await that.
+    import('../../integrations/ruvector/feature-flags.js')
+        .then(({ isRVFPatternStoreEnabled }) => {
+        if (!isRVFPatternStoreEnabled())
+            return null;
+        return import('../../integrations/ruvector/shared-rvf-adapter.js');
+    })
+        .then((mod) => {
+        if (!mod)
+            return;
+        const adapter = mod.getSharedRvfAdapter();
+        if (adapter) {
+            engine.rvfAdapter = adapter;
+        }
+    })
+        .catch(() => {
+        // RVF adapter wiring is best-effort — DreamEngine works without it
+    });
+    return engine;
 }
 export default DreamEngine;
 //# sourceMappingURL=dream-engine.js.map

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

@@ -14,6 +14,7 @@
  */
 import type { EventBus, MemoryBackend } from '../../kernel/interfaces.js';
 import type { DreamEngine, DreamCycleResult } from './dream-engine.js';
+import { type MetaInsight } from '../aqe-learning-engine.js';
 /**
  * Configuration for the DreamScheduler
  */
@@ -150,6 +151,13 @@ export declare class DreamScheduler {
     private totalDreamsCompleted;
     private subscriptions;
     private lastDreamResult;
+    private readonly metaLearningEngine;
+    private readonly metaLearningSnapshots;
+    private metricsTracker;
+    private static readonly MAX_META_SNAPSHOTS;
+    /** Queryable store of detected meta-learning insights (Gap 1: persist, not just log) */
+    private readonly detectedInsights;
+    private static readonly MAX_DETECTED_INSIGHTS;
     /**
      * Create a new DreamScheduler instance.
      *
@@ -231,6 +239,17 @@ export declare class DreamScheduler {
      * @returns Last dream result or null
      */
     getLastDreamResult(): DreamCycleResult | null;
+    /**
+     * Return all detected meta-learning insights (most recent first).
+     *
+     * Gap 1 fix: insights are now stored in-memory rather than only logged,
+     * making them queryable by other subsystems (e.g., PatternStore consumers,
+     * quality gates, or dashboards).
+     *
+     * @param limit - Maximum number of insights to return (default: all)
+     * @returns Array of MetaInsight objects, newest first
+     */
+    getMetaInsights(limit?: number): MetaInsight[];
     /**
      * Execute a dream cycle with the specified duration.
      */
@@ -239,6 +258,12 @@ export declare class DreamScheduler {
      * Auto-apply insights that meet the confidence threshold.
      */
     private autoApplyInsights;
+    /**
+     * Collect a metrics snapshot and, if enough have accumulated, run a
+     * meta-learning analysis cycle to detect token-waste, quality plateaus,
+     * learning stalls, and performance regressions.
+     */
+    private runPostDreamMetaLearning;
     /**
      * Schedule the next automatic dream.
      */

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

@@ -14,6 +14,9 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import { LoggerFactory } from '../../logging/index.js';
+// ADR-062: Meta-learning integration
+import { MetaLearningEngine, DEFAULT_META_LEARNING_CONFIG, } from '../aqe-learning-engine.js';
+import { LearningMetricsTracker, } from '../metrics-tracker.js';
 const logger = LoggerFactory.create('DreamScheduler');
 /**
  * Default DreamScheduler configuration
@@ -94,6 +97,14 @@ export class DreamScheduler {
     subscriptions = [];
     // Last result
     lastDreamResult = null;
+    // ADR-062: Meta-learning integration
+    metaLearningEngine;
+    metaLearningSnapshots = [];
+    metricsTracker = null;
+    static MAX_META_SNAPSHOTS = 20;
+    /** Queryable store of detected meta-learning insights (Gap 1: persist, not just log) */
+    detectedInsights = [];
+    static MAX_DETECTED_INSIGHTS = 100;
     /**
      * Create a new DreamScheduler instance.
      *
@@ -113,6 +124,8 @@ export class DreamScheduler {
         this.eventBus = dependencies.eventBus;
         this.memoryBackend = dependencies.memoryBackend;
         this.config = { ...DEFAULT_DREAM_SCHEDULER_CONFIG, ...config };
+        // ADR-062: Initialize meta-learning engine
+        this.metaLearningEngine = new MetaLearningEngine();
     }
     // ==========================================================================
     // Lifecycle Methods
@@ -177,6 +190,11 @@ export class DreamScheduler {
             subscription.unsubscribe();
         }
         this.subscriptions = [];
+        // Close meta-learning metrics tracker if initialized
+        if (this.metricsTracker) {
+            this.metricsTracker.close();
+            this.metricsTracker = null;
+        }
         // Save state before disposing
         await this.saveState();
         this.initialized = false;
@@ -288,6 +306,21 @@ export class DreamScheduler {
     getLastDreamResult() {
         return this.lastDreamResult;
     }
+    /**
+     * Return all detected meta-learning insights (most recent first).
+     *
+     * Gap 1 fix: insights are now stored in-memory rather than only logged,
+     * making them queryable by other subsystems (e.g., PatternStore consumers,
+     * quality gates, or dashboards).
+     *
+     * @param limit - Maximum number of insights to return (default: all)
+     * @returns Array of MetaInsight objects, newest first
+     */
+    getMetaInsights(limit) {
+        // Return newest first (reverse of insertion order)
+        const reversed = [...this.detectedInsights].reverse();
+        return limit !== undefined ? reversed.slice(0, limit) : reversed;
+    }
     // ==========================================================================
     // Private: Dream Execution
     // ==========================================================================
@@ -320,6 +353,18 @@ export class DreamScheduler {
             }
             // Publish dream completed event
             await this.publishDreamCompletedEvent(result);
+            // ADR-062: Run meta-learning analysis after dream cycle
+            if (process.env.AQE_META_LEARNING_ENABLED === 'true') {
+                try {
+                    await this.runPostDreamMetaLearning();
+                }
+                catch (metaErr) {
+                    // Meta-learning failure must never break dream cycles
+                    logger.warn('Post-dream meta-learning failed (non-critical)', {
+                        error: metaErr instanceof Error ? metaErr.message : String(metaErr),
+                    });
+                }
+            }
             // Reschedule next dream if running
             if (this.running) {
                 this.scheduleNextDream();
@@ -350,6 +395,81 @@ export class DreamScheduler {
         }
     }
     // ==========================================================================
+    // Private: Meta-Learning (ADR-062)
+    // ==========================================================================
+    /**
+     * Collect a metrics snapshot and, if enough have accumulated, run a
+     * meta-learning analysis cycle to detect token-waste, quality plateaus,
+     * learning stalls, and performance regressions.
+     */
+    async runPostDreamMetaLearning() {
+        // Lazily initialize the metrics tracker
+        if (!this.metricsTracker) {
+            this.metricsTracker = new LearningMetricsTracker();
+            await this.metricsTracker.initialize();
+        }
+        // Collect a unified snapshot
+        const snapshot = await this.metricsTracker.collectUnifiedSnapshot();
+        this.metaLearningSnapshots.push(snapshot);
+        // Cap the buffer at MAX_META_SNAPSHOTS (keep most recent)
+        while (this.metaLearningSnapshots.length > DreamScheduler.MAX_META_SNAPSHOTS) {
+            this.metaLearningSnapshots.shift();
+        }
+        // Run meta-learning if we have enough snapshots
+        const minRequired = DEFAULT_META_LEARNING_CONFIG.minSnapshotsForAnalysis;
+        if (this.metaLearningSnapshots.length >= minRequired) {
+            const insights = this.metaLearningEngine.runMetaLearningCycle(this.metaLearningSnapshots);
+            if (insights.length > 0) {
+                logger.info('Meta-learning insights detected', {
+                    count: insights.length,
+                    types: insights.map(i => i.type),
+                });
+                // Gap 1: Store insights in queryable in-memory buffer (not just logs)
+                for (const insight of insights) {
+                    logger.info(`Meta-insight [${insight.type}]: ${insight.description}`, {
+                        confidence: insight.confidence.toFixed(2),
+                        suggestedAction: insight.suggestedAction,
+                    });
+                    this.detectedInsights.push(insight);
+                }
+                // Cap the insights buffer at MAX_DETECTED_INSIGHTS (keep most recent)
+                while (this.detectedInsights.length > DreamScheduler.MAX_DETECTED_INSIGHTS) {
+                    this.detectedInsights.shift();
+                }
+                // Publish event so other subsystems can react to meta-learning insights
+                try {
+                    this.eventBus.publish({
+                        id: uuidv4(),
+                        type: 'meta-learning.insight-detected',
+                        timestamp: new Date(),
+                        source: 'learning-optimization',
+                        payload: {
+                            count: insights.length,
+                            insights: insights.map(i => ({
+                                id: i.id,
+                                type: i.type,
+                                description: i.description,
+                                confidence: i.confidence,
+                                suggestedAction: i.suggestedAction,
+                                detectedAt: i.detectedAt,
+                            })),
+                        },
+                    });
+                }
+                catch {
+                    // Event publishing is best-effort; insight storage above is the primary mechanism
+                    logger.debug('Failed to publish meta-learning insight event');
+                }
+            }
+        }
+        else {
+            logger.debug('Meta-learning: accumulating snapshots', {
+                current: this.metaLearningSnapshots.length,
+                required: minRequired,
+            });
+        }
+    }
+    // ==========================================================================
     // Private: Scheduling
     // ==========================================================================
     /**

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

@@ -102,7 +102,8 @@ export declare class RVCOWBranchManager {
     private listeners;
     /** Optional RVF native adapter for COW fork snapshots of dream state */
     private rvfAdapter?;
-    /** When true and rvfAdapter is set, createBranch() also forks an RVF snapshot */
+    /** When true and rvfAdapter is set, createBranch() also forks an RVF snapshot.
+     *  Driven by isRVFPatternStoreEnabled() feature flag when adapter is present. */
     private useRvfFork;
     /** Optional witness chain for audit trail of branch operations (ADR-070) */
     private _witnessChain;
@@ -110,8 +111,8 @@ export declare class RVCOWBranchManager {
     constructor(db: DatabaseType, thresholds?: ValidationThresholds);
     /**
      * Set an RVF native adapter for supplementary COW fork snapshots.
-     * When set with useRvfFork=true, createBranch() will additionally
-     * fork a portable .rvf snapshot alongside the SQLite savepoint.
+     * When set, useRvfFork is driven by the isRVFPatternStoreEnabled()
+     * feature flag (defaults to the explicit param if flag check fails).
      * SQLite savepoints remain the primary branching mechanism.
      */
     setRvfAdapter(adapter: any, useRvfFork?: boolean): void;
@@ -168,6 +169,8 @@ export declare class RVCOWBranchManager {
      */
     captureBaseline(): QualityBaseline;
     private ensureBranchActive;
+    /** Clean up RVF branch file and child adapter (ADR-069) */
+    private cleanupRvfBranch;
     private sanitizeSavepointName;
     private emit;
 }

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

@@ -15,6 +15,7 @@
  *
  * @module learning/dream/rvcow-branch-manager
  */
+import { existsSync, unlinkSync } from 'fs';
 /** Default validation thresholds */
 export const DEFAULT_VALIDATION_THRESHOLDS = {
     maxPatternCountDrop: 0.05,
@@ -48,7 +49,8 @@ export class RVCOWBranchManager {
     /** Optional RVF native adapter for COW fork snapshots of dream state */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     rvfAdapter;
-    /** When true and rvfAdapter is set, createBranch() also forks an RVF snapshot */
+    /** When true and rvfAdapter is set, createBranch() also forks an RVF snapshot.
+     *  Driven by isRVFPatternStoreEnabled() feature flag when adapter is present. */
     useRvfFork = false;
     /** Optional witness chain for audit trail of branch operations (ADR-070) */
     _witnessChain = null;
@@ -59,14 +61,23 @@ export class RVCOWBranchManager {
     }
     /**
      * Set an RVF native adapter for supplementary COW fork snapshots.
-     * When set with useRvfFork=true, createBranch() will additionally
-     * fork a portable .rvf snapshot alongside the SQLite savepoint.
+     * When set, useRvfFork is driven by the isRVFPatternStoreEnabled()
+     * feature flag (defaults to the explicit param if flag check fails).
      * SQLite savepoints remain the primary branching mechanism.
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     setRvfAdapter(adapter, useRvfFork = true) {
         this.rvfAdapter = adapter;
+        // ADR-069: Link to feature flag so RVF fork follows the same toggle.
+        // Use dynamic import() for ESM safety; fall back to explicit param.
         this.useRvfFork = useRvfFork;
+        import('../../integrations/ruvector/feature-flags.js')
+            .then(({ isRVFPatternStoreEnabled }) => {
+            this.useRvfFork = isRVFPatternStoreEnabled();
+        })
+            .catch(() => {
+            // Keep the explicit useRvfFork param value
+        });
     }
     // --------------------------------------------------------------------------
     // Branch Lifecycle
@@ -95,10 +106,15 @@ export class RVCOWBranchManager {
             status: 'active',
             baselineSnapshot: baseline,
         };
-        // Supplementary RVF fork for portable brain snapshots (when configured)
+        // ADR-069: RVF COW branch for true isolation (when configured)
+        // Creates a lightweight derived .rvf alongside the SQLite savepoint
         if (this.rvfAdapter && this.useRvfFork) {
             try {
-                this.rvfAdapter.fork(`/tmp/dream-branch-${name}.rvf`);
+                const branchPath = `/tmp/dream-branch-${safeName}.rvf`;
+                const childAdapter = this.rvfAdapter.derive(branchPath);
+                const branchExt = branch;
+                branchExt._rvfBranchPath = branchPath;
+                branchExt._rvfChildAdapter = childAdapter;
             }
             catch {
                 // RVF fork is best-effort — SQLite savepoint is the primary mechanism
@@ -153,6 +169,25 @@ export class RVCOWBranchManager {
                     `(${(lossFraction * 100).toFixed(1)}%, threshold: ${(this.thresholds.maxHighConfidenceLoss * 100).toFixed(1)}%)`);
             }
         }
+        // Check 4 (ADR-069): Search recall comparison — verify dream didn't degrade retrieval
+        if (this.rvfAdapter && this.useRvfFork && base.patternCount > 0) {
+            try {
+                const dim = this.rvfAdapter.dimension?.() ?? 384;
+                // Run a benchmark query with a random-ish vector
+                const benchQuery = new Float32Array(dim);
+                for (let i = 0; i < dim; i++)
+                    benchQuery[i] = Math.sin(i * 0.1);
+                const preResults = this.rvfAdapter.search?.(benchQuery, 10) ?? [];
+                // If search returns fewer results post-dream, recall may have degraded
+                if (preResults.length < Math.min(5, base.patternCount)) {
+                    reasons.push(`Search recall degraded: only ${preResults.length} results returned (expected ≥${Math.min(5, base.patternCount)})`);
+                    // Advisory — don't fail the gate for recall alone
+                }
+            }
+            catch {
+                // Recall check is advisory — don't block on errors
+            }
+        }
         const reason = passed
             ? 'All quality checks passed'
             : `Validation failed: ${reasons.join('; ')}`;
@@ -177,6 +212,7 @@ export class RVCOWBranchManager {
         this.db.exec(`RELEASE SAVEPOINT "${safeName}"`);
         branch.status = 'merged';
         this.activeBranches.delete(branch.name);
+        this.cleanupRvfBranch(branch);
         this.emit('dream:branch_merged', branch);
         try {
             this._witnessChain?.append('BRANCH_MERGE', {
@@ -199,6 +235,7 @@ export class RVCOWBranchManager {
         this.db.exec(`RELEASE SAVEPOINT "${safeName}"`);
         branch.status = 'discarded';
         this.activeBranches.delete(branch.name);
+        this.cleanupRvfBranch(branch);
         this.emit('dream:branch_discarded', branch);
     }
     /**
@@ -254,6 +291,24 @@ export class RVCOWBranchManager {
             throw new Error(`Branch '${name}' is ${branch.status}, not active`);
         }
     }
+    /** Clean up RVF branch file and child adapter (ADR-069) */
+    cleanupRvfBranch(branch) {
+        const ext = branch;
+        // Close child adapter if present
+        try {
+            const child = ext._rvfChildAdapter;
+            child?.close?.();
+        }
+        catch { /* best effort */ }
+        // Delete the temp .rvf file
+        try {
+            const branchPath = ext._rvfBranchPath;
+            if (branchPath && existsSync(branchPath)) {
+                unlinkSync(branchPath);
+            }
+        }
+        catch { /* best effort */ }
+    }
     sanitizeSavepointName(name) {
         // Replace non-alphanumeric characters (except hyphens/underscores) with underscores
         return name.replace(/[^a-zA-Z0-9_-]/g, '_');

package/dist/learning/experience-capture.d.ts

@@ -16,7 +16,7 @@ import type { MemoryBackend, EventBus } from '../kernel/interfaces.js';
 import type { Result } from '../shared/types/index.js';
 import type { WitnessChain } from '../governance/witness-chain.js';
 import type { QEDomain } from './qe-patterns.js';
-import type { PatternStore } from './pattern-store.js';
+import type { IPatternStore } from './pattern-store.js';
 /**
  * Test outcome categories for binary reward assignment (GRPO-inspired).
  * Maps discrete test outcomes to reward signals for pattern learning.
@@ -169,7 +169,7 @@ export declare class ExperienceCaptureService {
     private sessionCaptureCount;
     /** Optional witness chain for attaching audit receipts to experiences */
     private witnessChain?;
-    constructor(memory: MemoryBackend, patternStore?: PatternStore | undefined, eventBus?: EventBus | undefined, config?: Partial<ExperienceCaptureConfig>);
+    constructor(memory: MemoryBackend, patternStore?: IPatternStore | undefined, eventBus?: EventBus | undefined, config?: Partial<ExperienceCaptureConfig>);
     /**
      * Set the witness chain for attaching audit receipts to captured experiences.
      * Only creates witness records when the useWitnessChain feature flag is enabled.
@@ -324,5 +324,5 @@ export declare class ExperienceCaptureService {
 /**
  * Create experience capture service
  */
-export declare function createExperienceCaptureService(memory: MemoryBackend, patternStore?: PatternStore, eventBus?: EventBus, config?: Partial<ExperienceCaptureConfig>): ExperienceCaptureService;
+export declare function createExperienceCaptureService(memory: MemoryBackend, patternStore?: IPatternStore, eventBus?: EventBus, config?: Partial<ExperienceCaptureConfig>): ExperienceCaptureService;
 //# sourceMappingURL=experience-capture.d.ts.map