agentic-qe 3.7.21 → 3.8.0

package/dist/integrations/ruvector/hnsw-health-monitor.js

@@ -0,0 +1,394 @@
+/**
+ * HNSW Health Monitor - Spectral Health Monitoring
+ *
+ * Monitors the structural health of HNSW indexes using spectral graph
+ * theory metrics. Computes Fiedler value (algebraic connectivity),
+ * spectral gap, effective resistance, and a combined coherence score.
+ *
+ * Uses TypeScript power iteration and sample-based estimation for
+ * spectral computation. No native package exists for this — the
+ * TypeScript implementation is the production implementation.
+ *
+ * @see Task 3.4: HNSW Health Monitoring
+ * @module integrations/ruvector/hnsw-health-monitor
+ */
+// Re-export spectral math utilities for backward compatibility
+export { buildLaplacian, laplacianMultiply, vectorNorm, normalizeInPlace, deflateVector, approximateFiedlerValue, approximateSpectralGap, estimateEffectiveResistance, computeCoherenceScore, } from './spectral-math.js';
+import { approximateFiedlerValue, approximateSpectralGap, estimateEffectiveResistance, computeCoherenceScore, } from './spectral-math.js';
+/**
+ * Default health monitor configuration.
+ */
+export const DEFAULT_HNSW_HEALTH_CONFIG = {
+    fiedlerThreshold: 0.01,
+    spectralGapThreshold: 0.1,
+    resistanceThreshold: 10.0,
+    coherenceThreshold: 0.3,
+    maxPowerIterations: 100,
+    convergenceTolerance: 1e-6,
+    resistanceSampleSize: 50,
+    maxHistoryEntries: 200,
+    minIndexSize: 3,
+};
+// ============================================================================
+// Thresholds (exported for tests)
+// ============================================================================
+export const ALERT_THRESHOLDS = {
+    FragileIndex: 0.01,
+    PoorExpansion: 0.1,
+    HighResistance: 10.0,
+    LowCoherence: 0.3,
+};
+let nativeCoherence = null;
+let nativeLoadAttempted = false;
+/**
+ * Check for native coherence module.
+ * No native package exists — always returns null.
+ * The TypeScript power iteration implementation is used.
+ */
+function loadNativeCoherence() {
+    if (nativeLoadAttempted)
+        return nativeCoherence;
+    nativeLoadAttempted = true;
+    nativeCoherence = null;
+    return null;
+}
+/** Reset native loader state (for testing) */
+export function _resetNativeLoader() {
+    nativeCoherence = null;
+    nativeLoadAttempted = false;
+}
+/**
+ * Build an adjacency list from an HNSW-like index by using similarity
+ * between stored vectors. When stored vectors are provided, each vector
+ * is searched against the index to discover real neighbors. Otherwise,
+ * falls back to a circular approximation.
+ *
+ * @param index - The HNSW index provider
+ * @param maxNeighbors - Maximum neighbors per node to consider
+ * @param storedVectors - Optional map of id to vector for real neighbor discovery
+ * @returns Adjacency list, node count, and adjacency source
+ */
+export function buildAdjacencyFromIndex(index, maxNeighbors = 16, storedVectors) {
+    const n = index.size();
+    if (n === 0)
+        return { adjacency: [], nodeCount: 0, adjacencySource: 'approximate' };
+    const adjacency = Array.from({ length: n }, () => []);
+    const k = Math.min(maxNeighbors, n - 1);
+    if (k === 0)
+        return { adjacency, nodeCount: n, adjacencySource: 'approximate' };
+    // If stored vectors are provided and non-empty, use real search
+    if (storedVectors && storedVectors.size > 0) {
+        // Build a mapping from vector IDs to adjacency indices (0..n-1)
+        const ids = Array.from(storedVectors.keys()).slice(0, n);
+        const idToIdx = new Map();
+        for (let i = 0; i < ids.length; i++) {
+            idToIdx.set(ids[i], i);
+        }
+        for (let i = 0; i < ids.length; i++) {
+            const vec = storedVectors.get(ids[i]);
+            if (!vec)
+                continue;
+            // Search for k+1 neighbors (the query itself may be returned)
+            const results = index.search(vec, k + 1);
+            for (const result of results) {
+                // Skip self
+                if (result.id === ids[i])
+                    continue;
+                const neighborIdx = idToIdx.get(result.id);
+                if (neighborIdx === undefined)
+                    continue;
+                // Add bidirectional edge
+                if (!adjacency[i].includes(neighborIdx)) {
+                    adjacency[i].push(neighborIdx);
+                }
+                if (!adjacency[neighborIdx].includes(i)) {
+                    adjacency[neighborIdx].push(i);
+                }
+            }
+        }
+        return { adjacency, nodeCount: n, adjacencySource: 'actual-search' };
+    }
+    // Fallback: circular approximation when no stored vectors available
+    console.warn('[HnswHealthMonitor] No stored vectors provided — using approximate circular adjacency. ' +
+        'Pass stored vectors for accurate health metrics.');
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < k; j++) {
+            const neighbor = (i + j + 1) % n;
+            if (!adjacency[i].includes(neighbor)) {
+                adjacency[i].push(neighbor);
+            }
+            if (!adjacency[neighbor].includes(i)) {
+                adjacency[neighbor].push(i);
+            }
+        }
+    }
+    return { adjacency, nodeCount: n, adjacencySource: 'approximate' };
+}
+// ============================================================================
+// HnswHealthMonitor
+// ============================================================================
+/**
+ * HNSW Health Monitor
+ *
+ * Monitors the spectral health of HNSW indexes by computing graph-theoretic
+ * metrics. Uses ruvector-coherence for native computation when available,
+ * falling back to TypeScript approximations.
+ *
+ * Health checks are designed to be lightweight enough for periodic use
+ * without blocking search operations.
+ *
+ * @example
+ * ```typescript
+ * const monitor = new HnswHealthMonitor();
+ * const report = monitor.checkHealth(hnswIndex);
+ * if (!report.healthy) {
+ *   console.warn('HNSW index unhealthy:', report.alerts);
+ * }
+ * ```
+ */
+export class HnswHealthMonitor {
+    config;
+    alerts = [];
+    history = [];
+    lastReport = null;
+    useNative = false;
+    nativeChecked = false;
+    constructor(config) {
+        this.config = { ...DEFAULT_HNSW_HEALTH_CONFIG, ...config };
+    }
+    /**
+     * Perform a health check on an HNSW index.
+     *
+     * Computes spectral metrics and generates alerts if thresholds are
+     * exceeded. Results are recorded in the metrics history.
+     *
+     * @param index - The HNSW index to check
+     * @returns Health report with metrics and alerts
+     */
+    checkHealth(index) {
+        const start = performance.now();
+        const indexSize = index.size();
+        // Too small for meaningful spectral analysis
+        if (indexSize < this.config.minIndexSize) {
+            return this.createSmallIndexReport(indexSize, performance.now() - start);
+        }
+        // Try native backend on first call
+        if (!this.nativeChecked) {
+            this.nativeChecked = true;
+            this.useNative = loadNativeCoherence() !== null;
+        }
+        // Build adjacency from index
+        const { adjacency, nodeCount, adjacencySource } = buildAdjacencyFromIndex(index);
+        // Compute spectral metrics
+        const metrics = this.useNative
+            ? this.computeNativeMetrics(adjacency)
+            : this.computeApproximateMetrics(adjacency, nodeCount);
+        // Generate alerts
+        const newAlerts = this.generateAlerts(metrics);
+        // Update persistent alerts list
+        this.alerts.length = 0;
+        this.alerts.push(...newAlerts);
+        const elapsed = performance.now() - start;
+        const report = {
+            healthy: newAlerts.length === 0,
+            metrics,
+            alerts: newAlerts,
+            indexSize,
+            usedNativeBackend: this.useNative,
+            adjacencySource,
+            checkDurationMs: elapsed,
+            checkedAt: new Date(),
+        };
+        // Record in history
+        this.addHistoryPoint({
+            coherenceScore: metrics.coherenceScore,
+            fiedlerValue: metrics.fiedlerValue,
+            indexSize,
+            healthy: report.healthy,
+            timestamp: report.checkedAt,
+        });
+        this.lastReport = report;
+        return report;
+    }
+    /**
+     * Get current active alerts.
+     *
+     * @returns Array of active health alerts
+     */
+    getAlerts() {
+        return [...this.alerts];
+    }
+    /**
+     * Get health metrics history.
+     *
+     * @param limit - Maximum entries to return (most recent)
+     * @returns Array of metric points, most recent last
+     */
+    getMetricsHistory(limit) {
+        const entries = [...this.history];
+        if (limit !== undefined && limit < entries.length) {
+            return entries.slice(-limit);
+        }
+        return entries;
+    }
+    /**
+     * Check whether the index is currently healthy (no alerts).
+     *
+     * If no health check has been performed yet, returns true (optimistic).
+     *
+     * @returns true if the last health check found no alerts
+     */
+    isHealthy() {
+        if (this.lastReport === null)
+            return true;
+        return this.lastReport.healthy;
+    }
+    /**
+     * Get the last health report, or null if no check has been performed.
+     */
+    getLastReport() {
+        return this.lastReport;
+    }
+    /**
+     * Clear all history and alerts.
+     */
+    clearHistory() {
+        this.history.length = 0;
+        this.alerts.length = 0;
+        this.lastReport = null;
+    }
+    // ==========================================================================
+    // Private: Metric Computation
+    // ==========================================================================
+    /**
+     * Compute metrics using the native ruvector-coherence module.
+     */
+    computeNativeMetrics(adjacency) {
+        const native = nativeCoherence;
+        const fiedlerValue = native.computeFiedlerValue(adjacency);
+        const spectralGap = native.computeSpectralGap(adjacency);
+        const effectiveResistance = native.computeEffectiveResistance(adjacency);
+        const coherenceScore = computeCoherenceScore(fiedlerValue, spectralGap, effectiveResistance);
+        return { fiedlerValue, spectralGap, effectiveResistance, coherenceScore };
+    }
+    /**
+     * Compute metrics using TypeScript approximations.
+     */
+    computeApproximateMetrics(adjacency, n) {
+        const fiedlerValue = approximateFiedlerValue(adjacency, n, this.config.maxPowerIterations, this.config.convergenceTolerance);
+        const spectralGap = approximateSpectralGap(adjacency, n, this.config.maxPowerIterations, this.config.convergenceTolerance);
+        const effectiveResistance = estimateEffectiveResistance(adjacency, n, this.config.resistanceSampleSize, fiedlerValue);
+        const coherenceScore = computeCoherenceScore(fiedlerValue, spectralGap, effectiveResistance);
+        return { fiedlerValue, spectralGap, effectiveResistance, coherenceScore };
+    }
+    // ==========================================================================
+    // Private: Alert Generation
+    // ==========================================================================
+    /**
+     * Generate alerts based on metric thresholds.
+     */
+    generateAlerts(metrics) {
+        const alerts = [];
+        const now = new Date();
+        if (metrics.fiedlerValue < this.config.fiedlerThreshold) {
+            alerts.push({
+                type: 'FragileIndex',
+                message: `Fiedler value ${metrics.fiedlerValue.toFixed(6)} is below ` +
+                    `threshold ${this.config.fiedlerThreshold}. ` +
+                    `The index graph has weak algebraic connectivity.`,
+                value: metrics.fiedlerValue,
+                threshold: this.config.fiedlerThreshold,
+                timestamp: now,
+            });
+        }
+        if (metrics.spectralGap < this.config.spectralGapThreshold) {
+            alerts.push({
+                type: 'PoorExpansion',
+                message: `Spectral gap ${metrics.spectralGap.toFixed(6)} is below ` +
+                    `threshold ${this.config.spectralGapThreshold}. ` +
+                    `The index graph has poor expansion properties.`,
+                value: metrics.spectralGap,
+                threshold: this.config.spectralGapThreshold,
+                timestamp: now,
+            });
+        }
+        if (metrics.effectiveResistance > this.config.resistanceThreshold) {
+            alerts.push({
+                type: 'HighResistance',
+                message: `Average effective resistance ${metrics.effectiveResistance.toFixed(4)} ` +
+                    `exceeds threshold ${this.config.resistanceThreshold}. ` +
+                    `Nodes are poorly connected.`,
+                value: metrics.effectiveResistance,
+                threshold: this.config.resistanceThreshold,
+                timestamp: now,
+            });
+        }
+        if (metrics.coherenceScore < this.config.coherenceThreshold) {
+            alerts.push({
+                type: 'LowCoherence',
+                message: `Coherence score ${metrics.coherenceScore.toFixed(4)} is below ` +
+                    `threshold ${this.config.coherenceThreshold}. ` +
+                    `Overall index health is degraded.`,
+                value: metrics.coherenceScore,
+                threshold: this.config.coherenceThreshold,
+                timestamp: now,
+            });
+        }
+        return alerts;
+    }
+    // ==========================================================================
+    // Private: Helpers
+    // ==========================================================================
+    /**
+     * Create a report for indexes too small for spectral analysis.
+     */
+    createSmallIndexReport(indexSize, durationMs) {
+        const metrics = {
+            fiedlerValue: indexSize > 0 ? 1.0 : 0,
+            spectralGap: indexSize > 0 ? 1.0 : 0,
+            effectiveResistance: indexSize > 0 ? 0.5 : 0,
+            coherenceScore: indexSize > 0 ? 1.0 : 0,
+        };
+        const report = {
+            healthy: true,
+            metrics,
+            alerts: [],
+            indexSize,
+            usedNativeBackend: false,
+            adjacencySource: 'approximate',
+            checkDurationMs: durationMs,
+            checkedAt: new Date(),
+        };
+        this.addHistoryPoint({
+            coherenceScore: metrics.coherenceScore,
+            fiedlerValue: metrics.fiedlerValue,
+            indexSize,
+            healthy: true,
+            timestamp: report.checkedAt,
+        });
+        this.lastReport = report;
+        return report;
+    }
+    /**
+     * Add a history point, trimming if over limit.
+     */
+    addHistoryPoint(point) {
+        this.history.push(point);
+        if (this.history.length > this.config.maxHistoryEntries) {
+            this.history.splice(0, this.history.length - this.config.maxHistoryEntries);
+        }
+    }
+}
+// ============================================================================
+// Factory
+// ============================================================================
+/**
+ * Create an HnswHealthMonitor instance.
+ *
+ * @param config - Optional configuration overrides
+ * @returns A new HnswHealthMonitor
+ */
+export function createHnswHealthMonitor(config) {
+    return new HnswHealthMonitor(config);
+}
+//# sourceMappingURL=hnsw-health-monitor.js.map

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

@@ -46,7 +46,8 @@ export { RuVectorDiffRiskClassifier, type RiskPatterns } from './diff-risk-class
 export { RuVectorCoverageRouter, type CoverageThresholds } from './coverage-router';
 export { RuVectorGraphBoundariesAnalyzer, type GraphConfig } from './graph-boundaries';
 export { PersistentQLearningRouter, DEFAULT_EWC_CONFIG, DEFAULT_PERSISTENT_CONFIG, type EWCConfig, type PersistentQLearningRouterConfig, } from './persistent-q-router';
-export { PersistentSONAEngine, DEFAULT_PERSISTENT_SONA_CONFIG, SONA_PATTERNS_SCHEMA, type PersistentSONAConfig, } from './sona-persistence';
+export { PersistentSONAEngine, DEFAULT_PERSISTENT_SONA_CONFIG, SONA_PATTERNS_SCHEMA, SONA_FISHER_SCHEMA, type PersistentSONAConfig, } from './sona-persistence';
+export { SONAThreeLoopEngine, MicroLoRA, EWCPlusPlus, createSONAThreeLoopEngine, DEFAULT_THREE_LOOP_CONFIG, type AdaptationResult, type ConsolidationResult, type PeerState, type EWCMetrics, type ThreeLoopConfig, } from './sona-three-loop';
 export { FallbackQLearningRouter, FallbackASTComplexityAnalyzer, FallbackDiffRiskClassifier, FallbackCoverageRouter, FallbackGraphBoundariesAnalyzer, } from './fallback';
 import type { RuVectorConfig, RuVectorClient } from './interfaces';
 /**
@@ -85,7 +86,11 @@ 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, shouldLogMigrationMetrics, initFeatureFlagsFromEnv, DEFAULT_FEATURE_FLAGS, type RuVectorFeatureFlags, } from './feature-flags';
+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 { 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';
 export { HypergraphSchemaManager, nodeToRow, rowToNode, edgeToRow, rowToEdge, generateEdgeId, NODE_TYPES, EDGE_TYPES, type HypergraphNode, type HypergraphEdge, type HypergraphNodeRow, type HypergraphEdgeRow, type NodeType, type EdgeType, } from './hypergraph-schema';
 export { HypergraphEngine, createHypergraphEngine, createHypergraphEngineSync, DEFAULT_HYPERGRAPH_ENGINE_CONFIG, type HypergraphEngineConfig, type NodeCriteria, type EdgeCriteria, type TraversalResult, type ModuleDependencyResult, type BuildResult, type SyncResult, type HypergraphStats, type CodeIndexResult, } from './hypergraph-engine';
 export { RuVectorObservability, getRuVectorObservability, recordMLUsage, recordFallback, getObservabilityReport, type RuVectorComponent, type FallbackReason, type ComponentMetrics, type MLObservabilityMetrics, type MLUsageAlert, type MLObservabilityConfig, type ObservabilityReport, } from './observability';
@@ -95,5 +100,6 @@ export type { RvfNativeAdapter, RvfSearchResult as RvfNativeSearchResult, RvfSta
 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 { 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

@@ -57,7 +57,9 @@ export { RuVectorGraphBoundariesAnalyzer } from './graph-boundaries';
 // Persistent Q-Learning Router (ADR-046: Q-value persistence)
 export { PersistentQLearningRouter, DEFAULT_EWC_CONFIG, DEFAULT_PERSISTENT_CONFIG, } from './persistent-q-router';
 // Persistent SONA Engine (ADR-046: SONA pattern persistence)
-export { PersistentSONAEngine, DEFAULT_PERSISTENT_SONA_CONFIG, SONA_PATTERNS_SCHEMA, } from './sona-persistence';
+export { PersistentSONAEngine, DEFAULT_PERSISTENT_SONA_CONFIG, SONA_PATTERNS_SCHEMA, SONA_FISHER_SCHEMA, } from './sona-persistence';
+// SONA Three-Loop Engine (Task 2.2: EWC++ & MicroLoRA)
+export { SONAThreeLoopEngine, MicroLoRA, EWCPlusPlus, createSONAThreeLoopEngine, DEFAULT_THREE_LOOP_CONFIG, } from './sona-three-loop';
 // Fallback implementations
 export { FallbackQLearningRouter, FallbackASTComplexityAnalyzer, FallbackDiffRiskClassifier, FallbackCoverageRouter, FallbackGraphBoundariesAnalyzer, } from './fallback';
 import { DEFAULT_RUVECTOR_CONFIG, RuVectorUnavailableError } from './interfaces';
@@ -285,7 +287,17 @@ export { RuVectorServiceProvider, getDomainRuVectorServices, getRuVectorProvider
 // ============================================================================
 // Feature Flags
 // ============================================================================
-export { getRuVectorFeatureFlags, setRuVectorFeatureFlags, resetRuVectorFeatureFlags, isSONAEnabled, isFlashAttentionEnabled, isGNNIndexEnabled, shouldLogMigrationMetrics, initFeatureFlagsFromEnv, DEFAULT_FEATURE_FLAGS, } from './feature-flags';
+export { getRuVectorFeatureFlags, setRuVectorFeatureFlags, resetRuVectorFeatureFlags, isSONAEnabled, isFlashAttentionEnabled, isGNNIndexEnabled, isTemporalCompressionEnabled, isCrossDomainTransferEnabled, shouldLogMigrationMetrics, initFeatureFlagsFromEnv, 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 { TransferCoherenceStub, createTransferCoherenceGate, } from './transfer-coherence-stub';
+export { TransferVerifier, createTransferVerifier, DEFAULT_VERIFICATION_CONFIG, } from './transfer-verification';
+// ============================================================================
+// Temporal Tensor Compression (ADR-085)
+// ============================================================================
+export { TemporalCompressionService, getTemporalCompressionService, createTemporalCompressionService, resetTemporalCompressionService, cosineSimilarity, TIER_CONFIG, THEORETICAL_COMPRESSION_RATIOS, ACTUAL_FALLBACK_RATIO, EXPECTED_COMPRESSION_RATIOS, HOT_THRESHOLD_DAYS, WARM_THRESHOLD_DAYS, } from './temporal-compression';
 // ============================================================================
 // Hypergraph Schema (Neural Backbone)
 // ============================================================================
@@ -309,6 +321,10 @@ export { createRvfStore, openRvfStore, isRvfNativeAvailable } from './rvf-native
 export { RvfDualWriter, createDualWriter } from './rvf-dual-writer.js';
 export { getSharedRvfDualWriter, getSharedRvfDualWriterSync, resetSharedRvfDualWriter, } from './shared-rvf-dual-writer.js';
 // ============================================================================
+// Cognitive Container Export/Import (Task 4.1: RVF v2)
+// ============================================================================
+export { CognitiveContainer, createCognitiveContainer, generateSigningKeyPair, } from './cognitive-container';
+// ============================================================================
 // 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/interfaces.d.ts

@@ -493,4 +493,44 @@ export declare class RuVectorTimeoutError extends RuVectorError {
 export declare class RuVectorConfigError extends RuVectorError {
     constructor(message: string, cause?: Error);
 }
+/**
+ * Supported filter comparison operators
+ */
+export type FilterOperator = 'eq' | 'gt' | 'lt' | 'gte' | 'lte' | 'in' | 'contains' | 'between';
+/**
+ * A FIELD-level filter expression that tests a single field
+ */
+export interface FieldFilterExpression {
+    type: 'FIELD';
+    /** Dot-separated field path (e.g., "qeDomain", "confidence", "context.tags") */
+    field: string;
+    /** Comparison operator */
+    operator: FilterOperator;
+    /** Value to compare against */
+    value: unknown;
+}
+/**
+ * Composable filter expression supporting AND/OR/NOT/FIELD.
+ *
+ * Examples:
+ * - Single field: { type: 'FIELD', field: 'qeDomain', operator: 'eq', value: 'test-generation' }
+ * - AND: { type: 'AND', children: [fieldFilter1, fieldFilter2] }
+ * - OR: { type: 'OR', children: [fieldFilter1, fieldFilter2] }
+ * - NOT: { type: 'NOT', child: fieldFilter }
+ * - Nested: { type: 'AND', children: [{ type: 'OR', children: [...] }, fieldFilter] }
+ */
+export interface FilterExpression {
+    /** Expression type: AND, OR, NOT, or FIELD */
+    type: 'AND' | 'OR' | 'NOT' | 'FIELD';
+    /** Child expressions for AND/OR composites */
+    children?: FilterExpression[];
+    /** Child expression for NOT */
+    child?: FilterExpression;
+    /** Field path for FIELD type (dot-separated, e.g., "context.tags") */
+    field?: string;
+    /** Comparison operator for FIELD type */
+    operator?: FilterOperator;
+    /** Comparison value for FIELD type */
+    value?: unknown;
+}
 //# sourceMappingURL=interfaces.d.ts.map

package/dist/integrations/ruvector/sona-persistence.d.ts

@@ -30,6 +30,10 @@ import type { RuVectorServerClient } from './server-client.js';
  * SONA patterns table schema - for documentation and migrations
  */
 export declare const SONA_PATTERNS_SCHEMA = "\n  -- SONA Patterns table (ADR-046: Pattern Persistence)\n  CREATE TABLE IF NOT EXISTS sona_patterns (\n    id TEXT PRIMARY KEY,\n    type TEXT NOT NULL,\n    domain TEXT NOT NULL,\n    state_embedding BLOB,\n    action_embedding BLOB,\n    action_type TEXT NOT NULL,\n    action_value TEXT,\n    outcome_reward REAL NOT NULL DEFAULT 0.0,\n    outcome_success INTEGER NOT NULL DEFAULT 0,\n    outcome_quality REAL NOT NULL DEFAULT 0.0,\n    confidence REAL DEFAULT 0.5,\n    usage_count INTEGER DEFAULT 0,\n    success_count INTEGER DEFAULT 0,\n    failure_count INTEGER DEFAULT 0,\n    metadata TEXT,\n    created_at TEXT DEFAULT (datetime('now')),\n    updated_at TEXT DEFAULT (datetime('now')),\n    last_used_at TEXT\n  );\n  CREATE INDEX IF NOT EXISTS idx_sona_patterns_type ON sona_patterns(type);\n  CREATE INDEX IF NOT EXISTS idx_sona_patterns_domain ON sona_patterns(domain);\n  CREATE INDEX IF NOT EXISTS idx_sona_patterns_confidence ON sona_patterns(confidence DESC);\n  CREATE INDEX IF NOT EXISTS idx_sona_patterns_updated ON sona_patterns(updated_at DESC);\n";
+/**
+ * SONA Fisher matrices table schema - stores EWC++ state per domain
+ */
+export declare const SONA_FISHER_SCHEMA = "\n  -- SONA Fisher Information Matrices (Task 2.2: EWC++ Persistence)\n  CREATE TABLE IF NOT EXISTS sona_fisher_matrices (\n    domain TEXT PRIMARY KEY,\n    fisher_diagonal BLOB NOT NULL,\n    optimal_params BLOB NOT NULL,\n    base_weights BLOB,\n    dimension INTEGER NOT NULL,\n    task_boundaries INTEGER NOT NULL DEFAULT 0,\n    consolidation_cycles INTEGER NOT NULL DEFAULT 0,\n    request_count INTEGER NOT NULL DEFAULT 0,\n    ewc_lambda REAL NOT NULL DEFAULT 1000.0,\n    created_at TEXT DEFAULT (datetime('now')),\n    updated_at TEXT DEFAULT (datetime('now'))\n  );\n";
 /**
  * Configuration for persistent SONA engine
  */
@@ -263,6 +267,48 @@ export declare class PersistentSONAEngine {
      * Close the engine
      */
     close(): Promise<void>;
+    /**
+     * Save Fisher Information Matrix and optimal parameters to SQLite.
+     *
+     * Persists the EWC++ state for a domain so it survives across sessions.
+     * This includes the Fisher diagonal, optimal parameters, base weights,
+     * and metadata about task boundaries and consolidation cycles.
+     *
+     * @param domain - Domain identifier for the Fisher state
+     * @param fisherDiagonal - Fisher Information Matrix diagonal
+     * @param optimalParams - Optimal parameters at last task boundary
+     * @param baseWeights - Current base weights (optional)
+     * @param metadata - Additional metadata (task boundaries, cycles, etc.)
+     */
+    saveFisherMatrix(domain: string, fisherDiagonal: Float32Array, optimalParams: Float32Array, baseWeights?: Float32Array, metadata?: {
+        taskBoundaries?: number;
+        consolidationCycles?: number;
+        requestCount?: number;
+        ewcLambda?: number;
+    }): void;
+    /**
+     * Load Fisher Information Matrix and optimal parameters from SQLite.
+     *
+     * @param domain - Domain identifier to load Fisher state for
+     * @returns Fisher state or null if not found
+     */
+    loadFisherMatrix(domain: string): {
+        fisherDiagonal: Float32Array;
+        optimalParams: Float32Array;
+        baseWeights: Float32Array | null;
+        dimension: number;
+        taskBoundaries: number;
+        consolidationCycles: number;
+        requestCount: number;
+        ewcLambda: number;
+    } | null;
+    /**
+     * Delete Fisher matrix for a domain.
+     *
+     * @param domain - Domain identifier
+     * @returns true if a row was deleted
+     */
+    deleteFisherMatrix(domain: string): boolean;
     /**
      * Set or update the server client for cross-process pattern sharing
      */
@@ -319,6 +365,14 @@ export declare class PersistentSONAEngine {
      * Convert buffer to float array
      */
     private bufferToFloatArray;
+    /**
+     * Convert Float32Array to Buffer (for Fisher matrix persistence)
+     */
+    private float32ToBuffer;
+    /**
+     * Convert Buffer to Float32Array (for Fisher matrix loading)
+     */
+    private bufferToFloat32;
 }
 /**
  * Create a persistent SONA engine