agentic-qe 3.8.11 → 3.8.13

package/dist/integrations/ruvector/index.d.ts

@@ -86,8 +86,8 @@ export declare function getRuVectorStatus(config?: Partial<RuVectorConfig>): Pro
 }>;
 export * from './wrappers';
 export { RuVectorServiceProvider, getDomainRuVectorServices, getRuVectorProvider, getRuVectorServiceAvailability, type RuVectorServiceConfig, } from './provider';
-export { getRuVectorFeatureFlags, setRuVectorFeatureFlags, resetRuVectorFeatureFlags, isSONAEnabled, isFlashAttentionEnabled, isGNNIndexEnabled, isTemporalCompressionEnabled, isCrossDomainTransferEnabled, shouldLogMigrationMetrics, initFeatureFlagsFromEnv, DEFAULT_FEATURE_FLAGS, type RuVectorFeatureFlags, } from './feature-flags';
-export { DomainTransferEngine, ThompsonSampler, createDomainTransferEngine, DEFAULT_DOMAIN_TRANSFER_CONFIG, type TransferCandidate, type TransferResult, type TransferRecord, type DomainTransferConfig, } from './domain-transfer';
+export { getRuVectorFeatureFlags, setRuVectorFeatureFlags, resetRuVectorFeatureFlags, isSONAEnabled, isFlashAttentionEnabled, isGNNIndexEnabled, isTemporalCompressionEnabled, isCrossDomainTransferEnabled, shouldLogMigrationMetrics, initFeatureFlagsFromEnv, isHDCFingerprintingEnabled, isCusumDriftDetectionEnabled, isDeltaEventSourcingEnabled, isEwcPlusPlusEnabled, isGraphMAEEnabled, isHopfieldMemoryEnabled, isColdTierGNNEnabled, isMetaLearningEnabled, isSublinearSolverEnabled, isSpectralSparsificationEnabled, isReservoirReplayEnabled, isEpropOnlineLearningEnabled, isGrangerCausalityEnabled, DEFAULT_FEATURE_FLAGS, type RuVectorFeatureFlags, } from './feature-flags';
+export { DomainTransferEngine, ThompsonSampler, createDomainTransferEngine, DEFAULT_DOMAIN_TRANSFER_CONFIG, DecayingBeta, PlateauDetector, ParetoFront, CuriosityBonus, type TransferCandidate, type TransferResult, type TransferRecord, type DomainTransferConfig, type ParetoPoint, } from './domain-transfer';
 export { TransferCoherenceStub, createTransferCoherenceGate, type ITransferCoherenceGate, type CoherenceValidation, } from './transfer-coherence-stub';
 export { TransferVerifier, createTransferVerifier, DEFAULT_VERIFICATION_CONFIG, type DomainPerformanceSnapshot, type TransferResultForVerification, type VerificationResult, type TransferVerificationConfig, } from './transfer-verification';
 export { TemporalCompressionService, getTemporalCompressionService, createTemporalCompressionService, resetTemporalCompressionService, cosineSimilarity, TIER_CONFIG, THEORETICAL_COMPRESSION_RATIOS, ACTUAL_FALLBACK_RATIO, EXPECTED_COMPRESSION_RATIOS, HOT_THRESHOLD_DAYS, WARM_THRESHOLD_DAYS, type CompressionTier, type CompressedVector, type CompressionStats, } from './temporal-compression';
@@ -101,5 +101,16 @@ export { RvfDualWriter, createDualWriter } from './rvf-dual-writer.js';
 export type { DualWriteConfig, DualWriteResult, DivergenceReport } from './rvf-dual-writer.js';
 export { getSharedRvfDualWriter, getSharedRvfDualWriterSync, resetSharedRvfDualWriter, } from './shared-rvf-dual-writer.js';
 export { CognitiveContainer, createCognitiveContainer, generateSigningKeyPair, type ContainerSegment, type ContainerManifest, type ExportOptions, type ImportOptions, type ImportResult, type VerificationResult as CognitiveContainerVerificationResult, type ContainerInfo, type Ed25519KeyPair, } from './cognitive-container';
+export { HdcFingerprinter, createHdcFingerprinter, type HdcConfig, type PatternFingerprint, } from './hdc-fingerprint';
+export { CusumDetector, type CusumConfig, type CusumResult, type GateType, } from './cusum-detector';
+export { DeltaTracker, PATTERN_DELTAS_SCHEMA, type DeltaEvent, type DeltaTrackerConfig, type JsonPatch, } from './delta-tracker';
+export { GraphMAEEncoder, createGraphMAEEncoder, type GraphMAEConfig, type QEGraph, type GraphMAEResult, } from './graphmae-encoder';
+export { HopfieldMemory, createHopfieldMemory, type HopfieldConfig, type StoredPattern, type RecallResult, } from './hopfield-memory';
+export { ColdTierTrainer, InMemoryGraph, FileBackedGraph, createColdTierTrainer, type ColdTierConfig, type ColdTierGraph, type TrainingResult, type CacheStats, } from './cold-tier-trainer';
+export { PageRankSolver, createPageRankSolver, type PatternGraph, type ImportanceScore, type SolverConfig, } from './solver-adapter';
+export { SpectralSparsifier, createSpectralSparsifier, type SparsifierGraph, type SpectralValidation, type SparsifierConfig, } from './spectral-sparsifier';
+export { ReservoirReplayBuffer, createReservoirReplayBuffer, type ReservoirEntry, type ReservoirConfig, type ReservoirStats, type CoherenceTier, } from './reservoir-replay';
+export { EpropNetwork, createEpropNetwork, type EpropConfig, type EpropStats, } from './eprop-learner';
+export { GrangerAnalyzer, createGrangerAnalyzer, type TestExecutionHistory, type CausalLink, type GrangerConfig, } from './temporal-causality';
 export { initializeSharedMemory, getSharedServerClient as getFleetSharedClient, setSharedServerClient, isSharedMemoryAvailable, getSharedMemoryStatus, getLastInitResult, shutdownSharedMemory, resetSharedMemoryState, integrateWithFleet, DEFAULT_SHARED_MEMORY_CONFIG, type SharedMemoryConfig, type SharedMemoryResult, type SharedMemoryStatus, } from './shared-memory';
 //# sourceMappingURL=index.d.ts.map

package/dist/integrations/ruvector/index.js

@@ -287,11 +287,21 @@ export { RuVectorServiceProvider, getDomainRuVectorServices, getRuVectorProvider
 // ============================================================================
 // Feature Flags
 // ============================================================================
-export { getRuVectorFeatureFlags, setRuVectorFeatureFlags, resetRuVectorFeatureFlags, isSONAEnabled, isFlashAttentionEnabled, isGNNIndexEnabled, isTemporalCompressionEnabled, isCrossDomainTransferEnabled, shouldLogMigrationMetrics, initFeatureFlagsFromEnv, DEFAULT_FEATURE_FLAGS, } from './feature-flags';
+export { getRuVectorFeatureFlags, setRuVectorFeatureFlags, resetRuVectorFeatureFlags, isSONAEnabled, isFlashAttentionEnabled, isGNNIndexEnabled, isTemporalCompressionEnabled, isCrossDomainTransferEnabled, shouldLogMigrationMetrics, initFeatureFlagsFromEnv, 
+// Phase 5 Milestone 1 (ADR-087)
+isHDCFingerprintingEnabled, isCusumDriftDetectionEnabled, isDeltaEventSourcingEnabled, isEwcPlusPlusEnabled, 
+// Phase 5 Milestone 2 (ADR-087)
+isGraphMAEEnabled, isHopfieldMemoryEnabled, isColdTierGNNEnabled, 
+// Phase 5 Milestone 3 (ADR-087)
+isMetaLearningEnabled, isSublinearSolverEnabled, isSpectralSparsificationEnabled, isReservoirReplayEnabled, 
+// Phase 5 Milestone 4 (ADR-087)
+isEpropOnlineLearningEnabled, isGrangerCausalityEnabled, DEFAULT_FEATURE_FLAGS, } from './feature-flags';
 // ============================================================================
 // Cross-Domain Transfer Learning (ADR-084, Task 2.3)
 // ============================================================================
-export { DomainTransferEngine, ThompsonSampler, createDomainTransferEngine, DEFAULT_DOMAIN_TRANSFER_CONFIG, } from './domain-transfer';
+export { DomainTransferEngine, ThompsonSampler, createDomainTransferEngine, DEFAULT_DOMAIN_TRANSFER_CONFIG, 
+// R7: Meta-Learning Enhancements (ADR-087, Milestone 3)
+DecayingBeta, PlateauDetector, ParetoFront, CuriosityBonus, } from './domain-transfer';
 export { TransferCoherenceStub, createTransferCoherenceGate, } from './transfer-coherence-stub';
 export { TransferVerifier, createTransferVerifier, DEFAULT_VERIFICATION_CONFIG, } from './transfer-verification';
 // ============================================================================
@@ -325,6 +335,40 @@ export { getSharedRvfDualWriter, getSharedRvfDualWriterSync, resetSharedRvfDualW
 // ============================================================================
 export { CognitiveContainer, createCognitiveContainer, generateSigningKeyPair, } from './cognitive-container';
 // ============================================================================
+// Phase 5: Pattern Intelligence (ADR-087, Milestone 1)
+// ============================================================================
+// R1: HDC Pattern Fingerprinting
+export { HdcFingerprinter, createHdcFingerprinter, } from './hdc-fingerprint';
+// R2: CUSUM Drift Detection
+export { CusumDetector, } from './cusum-detector';
+// R3: Delta Event Sourcing
+export { DeltaTracker, PATTERN_DELTAS_SCHEMA, } from './delta-tracker';
+// ============================================================================
+// Phase 5: Graph Learning (ADR-087, Milestone 2)
+// ============================================================================
+// R4: GraphMAE Self-Supervised Learning
+export { GraphMAEEncoder, createGraphMAEEncoder, } from './graphmae-encoder';
+// R5: Modern Hopfield Networks
+export { HopfieldMemory, createHopfieldMemory, } from './hopfield-memory';
+// R6: Cold-Tier GNN Training
+export { ColdTierTrainer, InMemoryGraph, FileBackedGraph, createColdTierTrainer, } from './cold-tier-trainer';
+// ============================================================================
+// Phase 5: Scale & Optimization (ADR-087, Milestone 3)
+// ============================================================================
+// R8: PageRank Pattern Importance Solver
+export { PageRankSolver, createPageRankSolver, } from './solver-adapter';
+// R9: Spectral Graph Sparsification
+export { SpectralSparsifier, createSpectralSparsifier, } from './spectral-sparsifier';
+// R10: Reservoir Replay with Coherence Gating
+export { ReservoirReplayBuffer, createReservoirReplayBuffer, } from './reservoir-replay';
+// ============================================================================
+// Phase 5: Advanced Learning (ADR-087, Milestone 4)
+// ============================================================================
+// R11: E-prop Online Learning
+export { EpropNetwork, createEpropNetwork, } from './eprop-learner';
+// R12: Granger Causality for Test Failure Prediction
+export { GrangerAnalyzer, createGrangerAnalyzer, } from './temporal-causality';
+// ============================================================================
 // Shared Memory Integration (Fleet Integration)
 // ============================================================================
 export { initializeSharedMemory, getSharedServerClient as getFleetSharedClient, setSharedServerClient, isSharedMemoryAvailable, getSharedMemoryStatus, getLastInitResult, shutdownSharedMemory, resetSharedMemoryState, integrateWithFleet, DEFAULT_SHARED_MEMORY_CONFIG, } from './shared-memory';

package/dist/integrations/ruvector/mincut-wrapper.d.ts

@@ -168,6 +168,13 @@ export declare class QEMinCutService {
      * @returns Health report with lambda, weak points, and suggestions
      */
     getStructuralHealth(graph: TaskGraph): HealthReport;
+    /**
+     * Optionally sparsify a large task graph before mincut analysis.
+     * Only activates when the useSpectralSparsification feature flag is enabled
+     * AND the graph has more than 100 edges (below that, sparsification costs
+     * more than it saves).
+     */
+    private maybeSparsify;
     /**
      * Convert a TaskGraph to a SwarmGraph for use with MinCutCalculator
      */

package/dist/integrations/ruvector/mincut-wrapper.js

@@ -11,6 +11,8 @@
  */
 import { MinCutCalculator } from '../../coordination/mincut/mincut-calculator.js';
 import { SwarmGraph } from '../../coordination/mincut/swarm-graph.js';
+import { getRuVectorFeatureFlags } from './feature-flags.js';
+import { SpectralSparsifier } from './spectral-sparsifier.js';
 // ============================================================================
 // QEMinCutService
 // ============================================================================
@@ -49,7 +51,8 @@ export class QEMinCutService {
      * @returns The min-cut lambda value (0 if graph is empty/disconnected)
      */
     computeLambda(graph) {
-        const swarmGraph = this.toSwarmGraph(graph);
+        const effective = this.maybeSparsify(graph);
+        const swarmGraph = this.toSwarmGraph(effective);
         return this.calculator.getMinCutValue(swarmGraph);
     }
     /**
@@ -99,7 +102,8 @@ export class QEMinCutService {
      * @returns Health report with lambda, weak points, and suggestions
      */
     getStructuralHealth(graph) {
-        const swarmGraph = this.toSwarmGraph(graph);
+        const effective = this.maybeSparsify(graph);
+        const swarmGraph = this.toSwarmGraph(effective);
         if (swarmGraph.isEmpty()) {
             return this.emptyHealthReport();
         }
@@ -129,6 +133,54 @@ export class QEMinCutService {
         };
     }
     // ==========================================================================
+    // Spectral Sparsification (R9, ADR-087)
+    // ==========================================================================
+    /**
+     * Optionally sparsify a large task graph before mincut analysis.
+     * Only activates when the useSpectralSparsification feature flag is enabled
+     * AND the graph has more than 100 edges (below that, sparsification costs
+     * more than it saves).
+     */
+    maybeSparsify(graph) {
+        if (!getRuVectorFeatureFlags().useSpectralSparsification)
+            return graph;
+        if (graph.edges.length <= 100)
+            return graph;
+        // Build node ID→index map
+        const nodeIndex = new Map();
+        graph.nodes.forEach((n, i) => nodeIndex.set(n.id, i));
+        // Convert to SparsifierGraph (undirected, weighted)
+        const sparsifierEdges = [];
+        for (const e of graph.edges) {
+            const si = nodeIndex.get(e.source);
+            const ti = nodeIndex.get(e.target);
+            if (si !== undefined && ti !== undefined) {
+                sparsifierEdges.push([si, ti, e.weight]);
+            }
+        }
+        const sparsifierGraph = {
+            nodeCount: graph.nodes.length,
+            edges: sparsifierEdges,
+        };
+        const sparsifier = new SpectralSparsifier({ epsilon: 0.3 });
+        const sparsified = sparsifier.sparsify(sparsifierGraph);
+        // Convert back to TaskGraph edges
+        const sparsifiedEdges = [];
+        for (const [u, v, w] of sparsified.edges) {
+            const sourceNode = graph.nodes[u];
+            const targetNode = graph.nodes[v];
+            if (sourceNode && targetNode) {
+                sparsifiedEdges.push({
+                    source: sourceNode.id,
+                    target: targetNode.id,
+                    weight: w,
+                    edgeType: 'coordination',
+                });
+            }
+        }
+        return { nodes: graph.nodes, edges: sparsifiedEdges };
+    }
+    // ==========================================================================
     // Graph Conversion
     // ==========================================================================
     /**

package/dist/integrations/ruvector/reservoir-replay.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Reservoir Replay Buffer with Coherence Gating (R10, Phase 5 Milestone 3)
+ *
+ * A standalone reservoir sampling buffer that uses coherence-gated admission
+ * to prioritize high-quality experiences for replay. Integrates with the
+ * CUSUM drift detector (R2) for drift-aware admission control.
+ *
+ * Algorithm:
+ *   - Reservoir sampling inspired by Algorithm R (Vitter 1985), with
+ *     coherence-weighted admission bias — high-coherence entries get a
+ *     higher effective chance of replacing existing entries. This is NOT
+ *     pure Algorithm R (which is unbiased); the tier weighting and
+ *     low-coherence-preferring eviction are intentional design choices.
+ *   - Coherence tiers (high/medium/low) with weighted sampling
+ *   - CUSUM-based drift detection tightens admission during quality degradation
+ *
+ * @module integrations/ruvector/reservoir-replay
+ * @see ADR-087-ruvector-advanced-capabilities.md
+ */
+import { type CusumResult, type GateType } from './cusum-detector.js';
+/** Coherence tier classification */
+export type CoherenceTier = 'high' | 'medium' | 'low';
+/** An experience entry in the reservoir */
+export interface ReservoirEntry<T = unknown> {
+    /** Unique entry ID */
+    id: string;
+    /** The stored data */
+    data: T;
+    /** Coherence score at admission time (0-1) */
+    coherenceScore: number;
+    /** Classified coherence tier */
+    tier: CoherenceTier;
+    /** Timestamp of admission */
+    admittedAt: number;
+    /** Number of times this entry has been sampled for replay */
+    replayCount: number;
+}
+/** Configuration for the reservoir */
+export interface ReservoirConfig {
+    /** Maximum buffer capacity (default: 10000) */
+    capacity: number;
+    /** Minimum coherence score for admission (default: 0.3) */
+    minCoherenceThreshold: number;
+    /** Coherence threshold for 'high' tier (default: 0.8) */
+    highTierThreshold: number;
+    /** Coherence threshold for 'medium' tier (default: 0.5) */
+    mediumTierThreshold: number;
+    /** Sampling weight multiplier for high-coherence entries (default: 3.0) */
+    highTierWeight: number;
+    /** Sampling weight multiplier for medium-coherence entries (default: 1.5) */
+    mediumTierWeight: number;
+    /** Sampling weight multiplier for low-coherence entries (default: 1.0) */
+    lowTierWeight: number;
+    /** CUSUM config for drift-aware gating */
+    cusumConfig?: {
+        threshold?: number;
+        slack?: number;
+    };
+}
+/** Statistics about the reservoir buffer */
+export interface ReservoirStats {
+    /** Current number of entries */
+    size: number;
+    /** Maximum capacity */
+    capacity: number;
+    /** Total entries admitted */
+    totalAdmitted: number;
+    /** Total entries rejected (below threshold) */
+    totalRejected: number;
+    /** Total entries evicted (reservoir overflow) */
+    totalEvicted: number;
+    /** Breakdown by coherence tier */
+    tierCounts: Record<CoherenceTier, number>;
+    /** Total samples drawn */
+    totalSampled: number;
+}
+/**
+ * A fixed-capacity replay buffer with coherence-gated admission and
+ * tier-weighted sampling. Uses Algorithm R for reservoir sampling
+ * and integrates CUSUM drift detection for adaptive admission control.
+ *
+ * Usage:
+ * ```typescript
+ * const buffer = new ReservoirReplayBuffer({ capacity: 1000 });
+ * buffer.admit('exp-1', myData, 0.85); // high coherence
+ * buffer.admit('exp-2', myData, 0.10); // rejected (below threshold)
+ * const batch = buffer.sample(32);     // weighted toward high-coherence
+ * ```
+ */
+export declare class ReservoirReplayBuffer<T = unknown> {
+    private readonly config;
+    private readonly cusumDetector;
+    private readonly buffer;
+    /** Total number of items that have been offered for admission (including rejected) */
+    private totalSeen;
+    /** Total items actually admitted into the buffer */
+    private totalAdmitted;
+    /** Total items rejected at the coherence gate */
+    private totalRejected;
+    /** Total items evicted by reservoir replacement */
+    private totalEvicted;
+    /** Total individual samples drawn */
+    private totalSampled;
+    constructor(config?: Partial<ReservoirConfig>);
+    /**
+     * Attempt to admit an experience to the reservoir.
+     *
+     * Uses coherence-gated admission:
+     * 1. Reject if coherence < minCoherenceThreshold (adjusted by CUSUM drift)
+     * 2. If buffer has capacity, admit directly
+     * 3. If buffer is full, use Algorithm R reservoir sampling to decide eviction
+     * 4. High-coherence entries get a boost to their effective admission probability
+     *
+     * @param id - Unique entry identifier
+     * @param data - The data payload to store
+     * @param coherenceScore - Coherence score in [0, 1]
+     * @returns true if admitted, false if rejected
+     */
+    admit(id: string, data: T, coherenceScore: number): boolean;
+    /**
+     * Sample a batch from the reservoir with coherence-weighted probability.
+     * High-coherence entries are more likely to be sampled according to their
+     * tier weights.
+     *
+     * @param batchSize - Number of entries to sample
+     * @param minCoherence - Optional minimum coherence filter
+     * @returns Sampled entries (may be fewer than batchSize if buffer is small)
+     */
+    sample(batchSize: number, minCoherence?: number): ReservoirEntry<T>[];
+    /** Get current buffer size */
+    size(): number;
+    /** Get buffer statistics */
+    getStats(): ReservoirStats;
+    /** Get all entries in a specific coherence tier */
+    getByTier(tier: CoherenceTier): ReservoirEntry<T>[];
+    /** Clear the buffer and reset all statistics */
+    clear(): void;
+    /** Get the CUSUM detector state for a gate type */
+    getCusumState(gateType: GateType): CusumResult;
+    /**
+     * Feed a coherence observation to the CUSUM detector.
+     * When drift is detected, the admission threshold is temporarily tightened.
+     */
+    observeCoherence(gateType: GateType, value: number): CusumResult;
+    /**
+     * Classify a coherence score into a tier.
+     */
+    private classifyTier;
+    /**
+     * Get the sampling/admission weight for a tier.
+     */
+    private getTierWeight;
+    /**
+     * Get the effective admission threshold, tightened during drift.
+     *
+     * When CUSUM detects drift on any gate, we raise the minimum coherence
+     * threshold by 50% (capped at 0.9) to reject more marginal entries.
+     */
+    private getEffectiveThreshold;
+    /**
+     * Select an eviction target, preferring low-coherence entries.
+     *
+     * Given a candidate index from reservoir sampling, look for a nearby
+     * low-coherence entry to evict instead (within a small window).
+     */
+    private selectEvictionTarget;
+}
+/**
+ * Create a ReservoirReplayBuffer instance with optional configuration.
+ */
+export declare function createReservoirReplayBuffer<T = unknown>(config?: Partial<ReservoirConfig>): ReservoirReplayBuffer<T>;
+//# sourceMappingURL=reservoir-replay.d.ts.map