agentic-qe 3.9.0 → 3.9.2

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

package/dist/learning/hyperbolic-pattern-index.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Hyperbolic Pattern Index — HyperbolicHNSW wrapper for pattern search
+ * ADR-087, R14: Poincare ball embeddings for hierarchical pattern data
+ *
+ * Provides an optional hyperbolic search backend for PatternStore.
+ * When enabled (via feature flag), patterns with embeddings are indexed
+ * into a Poincare ball HNSW structure that naturally preserves
+ * parent-child / hierarchical relationships in distance metrics.
+ *
+ * This is a standalone wrapper to avoid conflicts with other PatternStore
+ * modifications (HDC fingerprinting, delta event sourcing, etc.).
+ */
+import { type HyperbolicConfig } from '../integrations/ruvector/hyperbolic-hnsw.js';
+export interface HyperbolicPatternResult {
+    /** Pattern ID */
+    patternId: string;
+    /** Hyperbolic (Poincare) distance — lower is more similar */
+    distance: number;
+    /** Metadata stored alongside the point */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Wraps HyperbolicHNSW for pattern-store integration.
+ *
+ * Lazy-initialized: the underlying HNSW index is only created when the
+ * feature flag `useHyperbolicHnsw` is true. All public methods are
+ * safe to call when disabled — they return empty results or no-op.
+ */
+export declare class HyperbolicPatternIndex {
+    private index;
+    private initialized;
+    private readonly config;
+    constructor(config?: Partial<HyperbolicConfig>);
+    /**
+     * Lazily initialize the hyperbolic index if the feature flag is enabled.
+     * Safe to call multiple times — only initializes once.
+     *
+     * @returns true if the index is available for use
+     */
+    ensureInitialized(): boolean;
+    /**
+     * Whether the hyperbolic index is currently available.
+     */
+    get isAvailable(): boolean;
+    /**
+     * Index a pattern's embedding into the hyperbolic space.
+     *
+     * The embedding is projected from Euclidean into the Poincare ball
+     * automatically by HyperbolicHNSW.insert().
+     *
+     * @param patternId - Unique pattern identifier
+     * @param embedding - Euclidean embedding vector (will be projected to Poincare ball)
+     * @param metadata - Optional metadata to store alongside the point
+     */
+    indexPattern(patternId: string, embedding: number[] | Float32Array, metadata?: Record<string, unknown>): void;
+    /**
+     * Search for nearest patterns in hyperbolic space.
+     *
+     * @param query - Query embedding (Euclidean; will be projected to Poincare ball)
+     * @param k - Number of nearest neighbors to return
+     * @returns Array of results sorted by ascending hyperbolic distance
+     */
+    search(query: Float32Array | number[], k: number): HyperbolicPatternResult[];
+    /**
+     * Get index statistics.
+     */
+    getStats(): {
+        elementCount: number;
+        dimensions: number;
+        curvature: number;
+    } | null;
+    /**
+     * Reset the index (for testing / dispose).
+     */
+    reset(): void;
+}
+/**
+ * Create a HyperbolicPatternIndex with the given config.
+ * The index is lazy — it won't allocate until ensureInitialized() is called.
+ */
+export declare function createHyperbolicPatternIndex(config?: Partial<HyperbolicConfig>): HyperbolicPatternIndex;
+//# sourceMappingURL=hyperbolic-pattern-index.d.ts.map

package/dist/learning/hyperbolic-pattern-index.js

@@ -0,0 +1,142 @@
+/**
+ * Hyperbolic Pattern Index — HyperbolicHNSW wrapper for pattern search
+ * ADR-087, R14: Poincare ball embeddings for hierarchical pattern data
+ *
+ * Provides an optional hyperbolic search backend for PatternStore.
+ * When enabled (via feature flag), patterns with embeddings are indexed
+ * into a Poincare ball HNSW structure that naturally preserves
+ * parent-child / hierarchical relationships in distance metrics.
+ *
+ * This is a standalone wrapper to avoid conflicts with other PatternStore
+ * modifications (HDC fingerprinting, delta event sourcing, etc.).
+ */
+import { createHyperbolicHNSW, PoincareOperations, } from '../integrations/ruvector/hyperbolic-hnsw.js';
+import { isHyperbolicHnswEnabled } from '../integrations/ruvector/feature-flags.js';
+// ============================================================================
+// Hyperbolic Pattern Index
+// ============================================================================
+/**
+ * Wraps HyperbolicHNSW for pattern-store integration.
+ *
+ * Lazy-initialized: the underlying HNSW index is only created when the
+ * feature flag `useHyperbolicHnsw` is true. All public methods are
+ * safe to call when disabled — they return empty results or no-op.
+ */
+export class HyperbolicPatternIndex {
+    index = null;
+    initialized = false;
+    config;
+    constructor(config) {
+        this.config = config ?? {};
+    }
+    /**
+     * Lazily initialize the hyperbolic index if the feature flag is enabled.
+     * Safe to call multiple times — only initializes once.
+     *
+     * @returns true if the index is available for use
+     */
+    ensureInitialized() {
+        if (this.initialized) {
+            return this.index !== null;
+        }
+        this.initialized = true;
+        if (!isHyperbolicHnswEnabled()) {
+            return false;
+        }
+        try {
+            this.index = createHyperbolicHNSW(this.config);
+            return this.index !== null;
+        }
+        catch (error) {
+            console.warn('[HyperbolicPatternIndex] Failed to create HyperbolicHNSW:', error instanceof Error ? error.message : error);
+            this.index = null;
+            return false;
+        }
+    }
+    /**
+     * Whether the hyperbolic index is currently available.
+     */
+    get isAvailable() {
+        return this.index !== null;
+    }
+    /**
+     * Index a pattern's embedding into the hyperbolic space.
+     *
+     * The embedding is projected from Euclidean into the Poincare ball
+     * automatically by HyperbolicHNSW.insert().
+     *
+     * @param patternId - Unique pattern identifier
+     * @param embedding - Euclidean embedding vector (will be projected to Poincare ball)
+     * @param metadata - Optional metadata to store alongside the point
+     */
+    indexPattern(patternId, embedding, metadata) {
+        if (!this.ensureInitialized() || !this.index)
+            return;
+        try {
+            const coords = embedding instanceof Float32Array
+                ? embedding
+                : new Float32Array(embedding);
+            // Project Euclidean embedding into Poincare ball before insertion
+            const hyperbolicCoords = PoincareOperations.euclideanToHyperbolic(coords);
+            this.index.insert(patternId, hyperbolicCoords, metadata);
+        }
+        catch (error) {
+            // Non-fatal: dimension mismatch or capacity exceeded
+            console.debug(`[HyperbolicPatternIndex] Failed to index pattern ${patternId}:`, error instanceof Error ? error.message : error);
+        }
+    }
+    /**
+     * Search for nearest patterns in hyperbolic space.
+     *
+     * @param query - Query embedding (Euclidean; will be projected to Poincare ball)
+     * @param k - Number of nearest neighbors to return
+     * @returns Array of results sorted by ascending hyperbolic distance
+     */
+    search(query, k) {
+        if (!this.ensureInitialized() || !this.index)
+            return [];
+        try {
+            const coords = query instanceof Float32Array
+                ? query
+                : new Float32Array(query);
+            // Project query into Poincare ball
+            const hyperbolicQuery = PoincareOperations.euclideanToHyperbolic(coords);
+            const results = this.index.search(hyperbolicQuery, k);
+            return results.map(r => ({
+                patternId: r.id,
+                distance: r.distance,
+                metadata: r.point.metadata,
+            }));
+        }
+        catch (error) {
+            console.warn('[HyperbolicPatternIndex] Search failed:', error instanceof Error ? error.message : error);
+            return [];
+        }
+    }
+    /**
+     * Get index statistics.
+     */
+    getStats() {
+        if (!this.index)
+            return null;
+        return this.index.getStats();
+    }
+    /**
+     * Reset the index (for testing / dispose).
+     */
+    reset() {
+        this.index = null;
+        this.initialized = false;
+    }
+}
+// ============================================================================
+// Factory
+// ============================================================================
+/**
+ * Create a HyperbolicPatternIndex with the given config.
+ * The index is lazy — it won't allocate until ensureInitialized() is called.
+ */
+export function createHyperbolicPatternIndex(config) {
+    return new HyperbolicPatternIndex(config);
+}
+//# sourceMappingURL=hyperbolic-pattern-index.js.map

package/dist/learning/index.d.ts

@@ -61,8 +61,8 @@ export { TokenMetricsCollector, TokenMetricsCollectorImpl, formatCostUsd, estima
 export type { TokenUsage, TaskTokenMetric, AgentTokenMetrics, SessionTokenSummary, TokenEfficiencyReport, Timeframe, TokenCostConfig, } from './token-tracker.js';
 export { ConceptGraph, createConceptGraph, DEFAULT_CONCEPT_GRAPH_CONFIG, } from './dream/index.js';
 export type { ConceptType, EdgeType, InsightType, DreamCycleStatus, ConceptNode, CreateConceptNodeInput, ConceptEdge, CreateEdgeInput, DreamCycle, DreamInsight, ConceptGraphStats, ConceptGraphConfig, PatternImportData, NeighborResult, } from './dream/index.js';
-export { AQELearningEngine, createAQELearningEngine, createDefaultLearningEngine, DEFAULT_ENGINE_CONFIG, } from './aqe-learning-engine.js';
-export type { AQELearningEngineConfig, AQELearningEngineStatus, AQELearningEngineStats, TaskExecution, TaskStep, } from './aqe-learning-engine.js';
+export { AQELearningEngine, createAQELearningEngine, createDefaultLearningEngine, DEFAULT_ENGINE_CONFIG, MetaLearningEngine, DEFAULT_META_LEARNING_CONFIG, } from './aqe-learning-engine.js';
+export type { AQELearningEngineConfig, AQELearningEngineStatus, AQELearningEngineStats, TaskExecution, TaskStep, MetaLearningConfig, MetaInsight, } from './aqe-learning-engine.js';
 export { ExperienceCaptureService, createExperienceCaptureService, DEFAULT_EXPERIENCE_CONFIG, } from './experience-capture.js';
 export type { TaskExperience, ExperienceStep, ExperienceCaptureConfig, ExperienceCaptureStats, PatternExtractionResult, } from './experience-capture.js';
 export { CausalVerifier, createCausalVerifier, createUninitializedCausalVerifier, } from './causal-verifier.js';
@@ -76,7 +76,7 @@ export type { PatternLifecycleConfig, ExperienceAggregate, PatternCandidate, Pro
 export { generateRemediationHints, findCommonKeywords, } from './opd-remediation.js';
 export type { RemediationHint, RemediationCategory, RemediationConfig, PatternInput, ExecutionRecord, } from './opd-remediation.js';
 export { LearningMetricsTracker, createLearningMetricsTracker, } from './metrics-tracker.js';
-export type { LearningMetricsSnapshot, DashboardData, } from './metrics-tracker.js';
+export type { LearningMetricsSnapshot, DashboardData, UnifiedMetricsSnapshot, } from './metrics-tracker.js';
 export { RegretTracker, createRegretTracker, linearRegressionSlope, } from './regret-tracker.js';
 export type { RegretPoint, GrowthRate, DomainHealthSummary, RegretAlert, RegretAlertCallback, } from './regret-tracker.js';
 export { DailyLogger } from './daily-log.js';

package/dist/learning/index.js

@@ -112,7 +112,7 @@ DEFAULT_CONCEPT_GRAPH_CONFIG, } from './dream/index.js';
 // ============================================================================
 // Unified AQE Learning Engine (Standalone with CF Enhancement)
 // ============================================================================
-export { AQELearningEngine, createAQELearningEngine, createDefaultLearningEngine, DEFAULT_ENGINE_CONFIG, } from './aqe-learning-engine.js';
+export { AQELearningEngine, createAQELearningEngine, createDefaultLearningEngine, DEFAULT_ENGINE_CONFIG, MetaLearningEngine, DEFAULT_META_LEARNING_CONFIG, } from './aqe-learning-engine.js';
 // ============================================================================
 // Experience Capture (Phase 4: Self-Learning)
 // ============================================================================

package/dist/learning/metrics-tracker.d.ts

@@ -14,6 +14,42 @@
  */
 import type { QEDomain } from './qe-patterns.js';
 import type { DomainHealthSummary } from './regret-tracker.js';
+/**
+ * Unified metrics snapshot across all AQE subsystems (ADR-062 Tier 3 Action 6).
+ *
+ * Gathers token, quality, learning, and performance metrics into a single
+ * point-in-time structure for meta-learning trend analysis.
+ */
+export interface UnifiedMetricsSnapshot {
+    /** Epoch-ms timestamp when the snapshot was taken */
+    timestamp: number;
+    /** Token usage and cost metrics */
+    tokenMetrics: {
+        totalTokens: number;
+        costUsd: number;
+        savingsUsd: number;
+        cacheHitRate: number;
+    };
+    /** Quality gate metrics */
+    qualityMetrics: {
+        gatePassRate: number;
+        averageScore: number;
+        ratchetLevel: number;
+    };
+    /** Learning / pattern-store metrics */
+    learningMetrics: {
+        patternCount: number;
+        averageConfidence: number;
+        quarantinedCount: number;
+        transferSuccessRate: number;
+    };
+    /** Runtime performance metrics */
+    performanceMetrics: {
+        avgLatencyMs: number;
+        p95LatencyMs: number;
+        errorRate: number;
+    };
+}
 /**
  * Learning metrics snapshot
  */
@@ -132,6 +168,14 @@ export declare class LearningMetricsTracker {
      * @returns Dashboard data with regret health attached
      */
     getDashboardDataWithRegret(regretHealth?: DomainHealthSummary[]): Promise<DashboardData>;
+    /**
+     * Collect a unified metrics snapshot across all subsystems (ADR-062).
+     *
+     * Gathers token, quality, learning, and performance data into a single
+     * point-in-time structure suitable for meta-learning trend analysis.
+     * Uses sensible zero-defaults when a subsystem is unavailable.
+     */
+    collectUnifiedSnapshot(): Promise<UnifiedMetricsSnapshot>;
     /**
      * Close the database connection
      */