agentic-qe 3.9.0 → 3.9.2

package/dist/integrations/ruvector/hdc-fingerprint.js

@@ -16,6 +16,7 @@
  * @module integrations/ruvector/hdc-fingerprint
  */
 import { Xorshift128 } from '../../shared/utils/xorshift128.js';
+import { isHDCFingerprintingEnabled } from './feature-flags.js';
 // ============================================================================
 // Constants
 // ============================================================================
@@ -68,6 +69,213 @@ function hexDigest(bytes) {
     return hex;
 }
 // ============================================================================
+// Standalone HDC Algebra Functions
+// ============================================================================
+/**
+ * Generate a random binary hypervector using crypto-quality randomness.
+ * @param dimensions Number of bits. Default: 10000
+ */
+export function createRandomHypervector(dimensions = DEFAULT_DIMENSIONS) {
+    const byteLen = Math.ceil(dimensions / 8);
+    const vector = new Uint8Array(byteLen);
+    // Use a time-seeded PRNG for non-deterministic random vectors
+    const seed = (Date.now() ^ (Math.random() * 0xffffffff)) >>> 0;
+    const rng = new Xorshift128(seed);
+    let idx = 0;
+    while (idx < byteLen) {
+        const rand = rng.next();
+        const count = Math.min(4, byteLen - idx);
+        for (let j = 0; j < count; j++) {
+            vector[idx++] = (rand >>> (j * 8)) & 0xff;
+        }
+    }
+    const trailingBits = dimensions % 8;
+    if (trailingBits > 0) {
+        vector[byteLen - 1] &= (1 << trailingBits) - 1;
+    }
+    return vector;
+}
+/**
+ * XOR binding — component-wise XOR of two packed-bit vectors.
+ * This is the key composition operation in HDC.
+ */
+export function bind(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Cannot bind vectors of different lengths: ${a.length} vs ${b.length}`);
+    }
+    const result = new Uint8Array(a.length);
+    for (let i = 0; i < a.length; i++) {
+        result[i] = a[i] ^ b[i];
+    }
+    return result;
+}
+/**
+ * Majority-rule bundling — creates a "superposition" of vectors.
+ * For each bit position, takes the majority value across all input vectors.
+ * Ties are broken by setting the bit to 1 (arbitrary but deterministic).
+ */
+export function bundle(vectors) {
+    if (vectors.length === 0) {
+        throw new Error('Cannot bundle zero vectors');
+    }
+    const byteLen = vectors[0].length;
+    for (let i = 1; i < vectors.length; i++) {
+        if (vectors[i].length !== byteLen) {
+            throw new Error(`Vector length mismatch at index ${i}: expected ${byteLen}, got ${vectors[i].length}`);
+        }
+    }
+    const result = new Uint8Array(byteLen);
+    const threshold = vectors.length / 2;
+    for (let byteIdx = 0; byteIdx < byteLen; byteIdx++) {
+        let resultByte = 0;
+        for (let bit = 0; bit < 8; bit++) {
+            let count = 0;
+            const mask = 1 << bit;
+            for (let v = 0; v < vectors.length; v++) {
+                if (vectors[v][byteIdx] & mask)
+                    count++;
+            }
+            // Majority rule: set bit if count > half, or count == half (tie-break to 1)
+            if (count >= threshold)
+                resultByte |= mask;
+        }
+        result[byteIdx] = resultByte;
+    }
+    return result;
+}
+/**
+ * Hamming distance between two packed-bit vectors, normalized to [0, 1].
+ * @param dimensions Total number of bits for normalization. If omitted, uses byteLength * 8.
+ */
+export function hammingDistance(a, b, dimensions) {
+    if (a.length !== b.length) {
+        throw new Error(`Cannot compute Hamming distance for vectors of different lengths: ${a.length} vs ${b.length}`);
+    }
+    let dist = 0;
+    for (let i = 0; i < a.length; i++) {
+        dist += POPCOUNT_TABLE[a[i] ^ b[i]];
+    }
+    const totalBits = dimensions ?? a.length * 8;
+    return totalBits > 0 ? dist / totalBits : 0;
+}
+/**
+ * Hamming similarity: 1 - hammingDistance. Returns value in [0, 1].
+ */
+export function hammingSimilarity(a, b, dimensions) {
+    return 1 - hammingDistance(a, b, dimensions);
+}
+/**
+ * Circular bit shift (permutation) for sequence encoding.
+ * Shifts the entire bit vector left by `shifts` positions, wrapping around.
+ */
+export function permute(v, shifts = 1) {
+    const totalBits = v.length * 8;
+    if (totalBits === 0)
+        return new Uint8Array(0);
+    // Normalize shift to [0, totalBits)
+    const s = ((shifts % totalBits) + totalBits) % totalBits;
+    if (s === 0)
+        return new Uint8Array(v);
+    const result = new Uint8Array(v.length);
+    for (let dst = 0; dst < totalBits; dst++) {
+        const src = (dst + s) % totalBits;
+        const srcByte = src >>> 3;
+        const srcBit = src & 7;
+        if (v[srcByte] & (1 << srcBit)) {
+            result[dst >>> 3] |= 1 << (dst & 7);
+        }
+    }
+    return result;
+}
+// ============================================================================
+// HDCPatternFingerprinter (Token-based)
+// ============================================================================
+/**
+ * Token-based HDC pattern fingerprinter.
+ *
+ * Maps string tokens deterministically to hypervectors, then composes
+ * them via XOR binding. Suitable for Agent Booster Tier 1 fingerprinting
+ * where tokens like "slow", "flaky", "database" are composed into a
+ * single concept fingerprint.
+ */
+export class HDCPatternFingerprinter {
+    dimensions;
+    baseSeed;
+    byteLen;
+    tokenCache = new Map();
+    constructor(config) {
+        this.dimensions = config?.dimensions ?? DEFAULT_DIMENSIONS;
+        this.baseSeed = config?.seed ?? DEFAULT_SEED;
+        this.byteLen = Math.ceil(this.dimensions / 8);
+        if (this.dimensions <= 0) {
+            throw new Error(`HDC dimensions must be positive, got ${this.dimensions}`);
+        }
+    }
+    /**
+     * Deterministic mapping from a string token to a hypervector.
+     * Uses seeded hash to generate bits. Results are cached.
+     */
+    tokenToHypervector(token) {
+        const cached = this.tokenCache.get(token);
+        if (cached)
+            return new Uint8Array(cached);
+        const seed = fnv1a(token) ^ this.baseSeed;
+        const vector = this.generateSeededVector(seed);
+        this.tokenCache.set(token, vector);
+        return new Uint8Array(vector);
+    }
+    /**
+     * Bind all tokens: token1 XOR token2 XOR ... tokenN.
+     * XOR is commutative and associative, so order does not matter.
+     * Returns a zero vector for an empty token list.
+     */
+    fingerprintPattern(tokens) {
+        if (tokens.length === 0)
+            return new Uint8Array(this.byteLen);
+        let result = this.tokenToHypervector(tokens[0]);
+        for (let i = 1; i < tokens.length; i++) {
+            result = bind(result, this.tokenToHypervector(tokens[i]));
+        }
+        return result;
+    }
+    /**
+     * Bind tokens, then bundle with a context fingerprint.
+     * Context tokens are fingerprinted separately (via XOR bind) and
+     * then bundled (majority-rule) with the main token fingerprint.
+     */
+    fingerprintWithContext(tokens, context) {
+        const tokenFp = this.fingerprintPattern(tokens);
+        if (context.length === 0)
+            return tokenFp;
+        const contextFp = this.fingerprintPattern(context);
+        return bundle([tokenFp, contextFp]);
+    }
+    /** Hamming similarity between two vectors, normalized to [0, 1]. */
+    similarity(a, b) {
+        return hammingSimilarity(a, b, this.dimensions);
+    }
+    // --------------------------------------------------------------------------
+    // Internal
+    // --------------------------------------------------------------------------
+    generateSeededVector(seed) {
+        const vector = new Uint8Array(this.byteLen);
+        const rng = new Xorshift128(seed);
+        let idx = 0;
+        while (idx < this.byteLen) {
+            const rand = rng.next();
+            const count = Math.min(4, this.byteLen - idx);
+            for (let j = 0; j < count; j++) {
+                vector[idx++] = (rand >>> (j * 8)) & 0xff;
+            }
+        }
+        const trailingBits = this.dimensions % 8;
+        if (trailingBits > 0) {
+            vector[this.byteLen - 1] &= (1 << trailingBits) - 1;
+        }
+        return vector;
+    }
+}
+// ============================================================================
 // HdcFingerprinter
 // ============================================================================
 /**
@@ -219,4 +427,13 @@ export class HdcFingerprinter {
 export function createHdcFingerprinter(config) {
     return new HdcFingerprinter(config);
 }
+/**
+ * Feature-flag-gated factory for HDCPatternFingerprinter.
+ * Returns null when isHDCFingerprintingEnabled() is false.
+ */
+export function createHDCFingerprinter(config) {
+    if (!isHDCFingerprintingEnabled())
+        return null;
+    return new HDCPatternFingerprinter(config);
+}
 //# sourceMappingURL=hdc-fingerprint.js.map

package/dist/integrations/ruvector/hyperbolic-hnsw.d.ts

@@ -0,0 +1,59 @@
+export interface HyperbolicConfig {
+    dimensions: number;
+    curvature: number;
+    maxElements: number;
+    efConstruction: number;
+    M: number;
+}
+export interface HyperbolicPoint {
+    id: string;
+    coordinates: Float32Array;
+    metadata?: Record<string, unknown>;
+}
+export interface HyperbolicSearchResult {
+    id: string;
+    distance: number;
+    point: HyperbolicPoint;
+}
+/** Pure math operations in the Poincare ball model of hyperbolic geometry. */
+export declare class PoincareOperations {
+    /** d(a,b) = acosh(1 + 2||a-b||^2 / ((1-||a||^2)(1-||b||^2))) */
+    static poincareDistance(a: Float32Array, b: Float32Array): number;
+    /** Mobius addition: a +_M b in Poincare ball. */
+    static mobiusAdd(a: Float32Array, b: Float32Array): Float32Array;
+    /** Exponential map from tangent space at base to Poincare ball. */
+    static expMap(base: Float32Array, tangent: Float32Array): Float32Array;
+    /** Project point to inside Poincare ball (clamp norm < 1-eps). */
+    static project(point: Float32Array): Float32Array;
+    /** Map Euclidean point to Poincare ball via tanh scaling. */
+    static euclideanToHyperbolic(point: Float32Array): Float32Array;
+}
+/** HNSW index operating in hyperbolic (Poincare ball) space. */
+export declare class HyperbolicHNSW {
+    private readonly config;
+    private readonly points;
+    constructor(config?: Partial<HyperbolicConfig>);
+    /** Insert a point, auto-projecting coordinates into the Poincare ball. */
+    insert(id: string, coordinates: Float32Array, metadata?: Record<string, unknown>): void;
+    /** k-NN search using Poincare distance, sorted ascending. */
+    search(query: Float32Array, k: number): HyperbolicSearchResult[];
+    /**
+     * Embed a tree hierarchy into hyperbolic space via BFS.
+     * Root near origin, leaves near boundary. Parent-child dist < sibling dist.
+     */
+    embedHierarchy(nodes: Array<{
+        id: string;
+        parentId?: string;
+        features: Float32Array;
+    }>): Map<string, Float32Array>;
+    getStats(): {
+        elementCount: number;
+        dimensions: number;
+        curvature: number;
+    };
+}
+/** Create a HyperbolicHNSW if the feature flag is enabled, otherwise null. */
+export declare function createHyperbolicHNSW(config?: Partial<HyperbolicConfig>): HyperbolicHNSW | null;
+/** Check if Hyperbolic HNSW feature flag is enabled. */
+export declare function isHyperbolicHnswEnabled(): boolean;
+//# sourceMappingURL=hyperbolic-hnsw.d.ts.map

package/dist/integrations/ruvector/hyperbolic-hnsw.js

@@ -0,0 +1,194 @@
+/**
+ * R14: Hyperbolic HNSW — Poincare Ball Embeddings for Hierarchical Data
+ *
+ * Maps tree-structured data into hyperbolic space where distances naturally
+ * preserve parent-child relationships. Root near origin, leaves near boundary.
+ * Numerically stable: all operations clamp norms and handle edge cases.
+ * TypeScript-only; no external dependencies.
+ *
+ * @module integrations/ruvector/hyperbolic-hnsw
+ */
+import { getRuVectorFeatureFlags } from './feature-flags.js';
+const DEFAULT_CONFIG = {
+    dimensions: 32, curvature: -1.0, maxElements: 10000, efConstruction: 200, M: 16,
+};
+const EPS = 1e-5;
+const MAX_NORM = 1 - EPS;
+// Vector helpers
+function dot(a, b) {
+    let s = 0;
+    for (let i = 0; i < a.length; i++)
+        s += a[i] * b[i];
+    return s;
+}
+function sqNorm(v) {
+    let s = 0;
+    for (let i = 0; i < v.length; i++)
+        s += v[i] * v[i];
+    return s;
+}
+function sub(a, b) {
+    const r = new Float32Array(a.length);
+    for (let i = 0; i < a.length; i++)
+        r[i] = a[i] - b[i];
+    return r;
+}
+/** Pure math operations in the Poincare ball model of hyperbolic geometry. */
+export class PoincareOperations {
+    /** d(a,b) = acosh(1 + 2||a-b||^2 / ((1-||a||^2)(1-||b||^2))) */
+    static poincareDistance(a, b) {
+        const diffSq = sqNorm(sub(a, b));
+        const denomA = Math.max(EPS, 1 - sqNorm(a));
+        const denomB = Math.max(EPS, 1 - sqNorm(b));
+        return Math.acosh(Math.max(1, 1 + 2 * diffSq / (denomA * denomB)));
+    }
+    /** Mobius addition: a +_M b in Poincare ball. */
+    static mobiusAdd(a, b) {
+        const d = dot(a, b), nA = sqNorm(a), nB = sqNorm(b);
+        const denom = Math.max(EPS, 1 + 2 * d + nA * nB);
+        const cA = 1 + 2 * d + nB, cB = 1 - nA;
+        const r = new Float32Array(a.length);
+        for (let i = 0; i < a.length; i++)
+            r[i] = (cA * a[i] + cB * b[i]) / denom;
+        return PoincareOperations.project(r);
+    }
+    /** Exponential map from tangent space at base to Poincare ball. */
+    static expMap(base, tangent) {
+        const lambda = 2 / Math.max(EPS, 1 - sqNorm(base));
+        const nT = Math.sqrt(sqNorm(tangent));
+        if (nT < EPS)
+            return new Float32Array(base);
+        const t = Math.tanh(lambda * nT / 2);
+        const s = new Float32Array(tangent.length);
+        for (let i = 0; i < tangent.length; i++)
+            s[i] = (t / nT) * tangent[i];
+        return PoincareOperations.mobiusAdd(base, s);
+    }
+    /** Project point to inside Poincare ball (clamp norm < 1-eps). */
+    static project(point) {
+        const n = Math.sqrt(sqNorm(point));
+        if (n <= MAX_NORM)
+            return new Float32Array(point);
+        const scale = MAX_NORM / n;
+        const r = new Float32Array(point.length);
+        for (let i = 0; i < point.length; i++)
+            r[i] = point[i] * scale;
+        return r;
+    }
+    /** Map Euclidean point to Poincare ball via tanh scaling. */
+    static euclideanToHyperbolic(point) {
+        const n = Math.sqrt(sqNorm(point));
+        if (n < EPS)
+            return new Float32Array(point.length);
+        const scale = Math.tanh(n) / n;
+        const r = new Float32Array(point.length);
+        for (let i = 0; i < point.length; i++)
+            r[i] = point[i] * scale;
+        return PoincareOperations.project(r);
+    }
+}
+/** HNSW index operating in hyperbolic (Poincare ball) space. */
+export class HyperbolicHNSW {
+    config;
+    points = new Map();
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        if (this.config.dimensions <= 0)
+            throw new Error(`dimensions must be positive, got ${this.config.dimensions}`);
+        if (this.config.curvature >= 0)
+            throw new Error(`curvature must be negative for hyperbolic space, got ${this.config.curvature}`);
+        if (this.config.maxElements <= 0)
+            throw new Error(`maxElements must be positive, got ${this.config.maxElements}`);
+    }
+    /** Insert a point, auto-projecting coordinates into the Poincare ball. */
+    insert(id, coordinates, metadata) {
+        if (coordinates.length !== this.config.dimensions)
+            throw new Error(`Dimension mismatch: expected ${this.config.dimensions}, got ${coordinates.length}`);
+        if (this.points.size >= this.config.maxElements)
+            throw new Error(`Maximum elements (${this.config.maxElements}) reached`);
+        this.points.set(id, {
+            id, coordinates: PoincareOperations.project(coordinates),
+            metadata: metadata ? { ...metadata } : undefined,
+        });
+    }
+    /** k-NN search using Poincare distance, sorted ascending. */
+    search(query, k) {
+        if (query.length !== this.config.dimensions)
+            throw new Error(`Query dimension mismatch: expected ${this.config.dimensions}, got ${query.length}`);
+        const proj = PoincareOperations.project(query);
+        const results = [];
+        for (const p of this.points.values())
+            results.push({ id: p.id, distance: PoincareOperations.poincareDistance(proj, p.coordinates), point: p });
+        results.sort((a, b) => a.distance - b.distance);
+        return results.slice(0, Math.max(0, k));
+    }
+    /**
+     * Embed a tree hierarchy into hyperbolic space via BFS.
+     * Root near origin, leaves near boundary. Parent-child dist < sibling dist.
+     */
+    embedHierarchy(nodes) {
+        const result = new Map();
+        if (nodes.length === 0)
+            return result;
+        const dims = this.config.dimensions;
+        const childrenOf = new Map();
+        const nodeMap = new Map();
+        const roots = [];
+        for (const node of nodes) {
+            nodeMap.set(node.id, node);
+            if (!node.parentId) {
+                roots.push(node.id);
+            }
+            else {
+                let ch = childrenOf.get(node.parentId);
+                if (!ch) {
+                    ch = [];
+                    childrenOf.set(node.parentId, ch);
+                }
+                ch.push(node.id);
+            }
+        }
+        const queue = roots.map((id, i) => ({
+            id, depth: 0,
+            angOff: (2 * Math.PI * i) / Math.max(1, roots.length),
+            angSpan: (2 * Math.PI) / Math.max(1, roots.length),
+        }));
+        while (queue.length > 0) {
+            const { id, depth, angOff, angSpan } = queue.shift();
+            const radius = Math.tanh(0.3 * (depth + 0.1));
+            const angle = angOff + angSpan / 2;
+            const coords = new Float32Array(dims);
+            coords[0] = radius * Math.cos(angle);
+            coords[1] = radius * Math.sin(angle);
+            const node = nodeMap.get(id);
+            if (node && node.features.length > 0) {
+                const fs = radius * 0.1;
+                for (let d = 2; d < dims && d - 2 < node.features.length; d++)
+                    coords[d] = node.features[d - 2] * fs;
+            }
+            const projected = PoincareOperations.project(coords);
+            result.set(id, projected);
+            this.points.set(id, { id, coordinates: projected, metadata: { depth, parentId: node?.parentId } });
+            const children = childrenOf.get(id) ?? [];
+            for (let c = 0; c < children.length; c++) {
+                const cs = angSpan / Math.max(1, children.length);
+                queue.push({ id: children[c], depth: depth + 1, angOff: angOff + c * cs, angSpan: cs });
+            }
+        }
+        return result;
+    }
+    getStats() {
+        return { elementCount: this.points.size, dimensions: this.config.dimensions, curvature: this.config.curvature };
+    }
+}
+/** Create a HyperbolicHNSW if the feature flag is enabled, otherwise null. */
+export function createHyperbolicHNSW(config) {
+    if (!isHyperbolicHnswEnabled())
+        return null;
+    return new HyperbolicHNSW(config);
+}
+/** Check if Hyperbolic HNSW feature flag is enabled. */
+export function isHyperbolicHnswEnabled() {
+    return getRuVectorFeatureFlags().useHyperbolicHnsw;
+}
+//# sourceMappingURL=hyperbolic-hnsw.js.map

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

@@ -86,7 +86,7 @@ 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, isHDCFingerprintingEnabled, isCusumDriftDetectionEnabled, isDeltaEventSourcingEnabled, isEwcPlusPlusEnabled, isGraphMAEEnabled, isHopfieldMemoryEnabled, isColdTierGNNEnabled, isMetaLearningEnabled, isSublinearSolverEnabled, isSpectralSparsificationEnabled, isReservoirReplayEnabled, isEpropOnlineLearningEnabled, isGrangerCausalityEnabled, DEFAULT_FEATURE_FLAGS, type RuVectorFeatureFlags, } from './feature-flags';
+export { getRuVectorFeatureFlags, setRuVectorFeatureFlags, resetRuVectorFeatureFlags, isSONAEnabled, isFlashAttentionEnabled, isGNNIndexEnabled, isTemporalCompressionEnabled, isCrossDomainTransferEnabled, shouldLogMigrationMetrics, initFeatureFlagsFromEnv, isHDCFingerprintingEnabled, isCusumDriftDetectionEnabled, isDeltaEventSourcingEnabled, isEwcPlusPlusEnabled, isGraphMAEEnabled, isHopfieldMemoryEnabled, isColdTierGNNEnabled, isMetaLearningEnabled, isSublinearSolverEnabled, isSpectralSparsificationEnabled, isReservoirReplayEnabled, isEpropOnlineLearningEnabled, isGrangerCausalityEnabled, isCognitiveRoutingEnabled, isHyperbolicHnswEnabled, 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';
@@ -101,9 +101,10 @@ 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 { HdcFingerprinter, createHdcFingerprinter, HDCPatternFingerprinter, createHDCFingerprinter, createRandomHypervector, bind, bundle, hammingDistance, hammingSimilarity, permute, 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 { VectorDeltaTracker, createVectorDeltaTracker, type PatternDelta, type SparseChange, type DeltaSnapshot, type VectorDeltaTrackerConfig, type VectorDeltaTrackerStats, } from './vector-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';
@@ -112,5 +113,7 @@ export { SpectralSparsifier, createSpectralSparsifier, type SparsifierGraph, typ
 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 { CognitiveRouter, MessagePredictor, OscillatoryRouter, createCognitiveRouter, type CognitiveRoutingConfig, type RoutedMessage, type RoutingStats, } from './cognitive-routing';
+export { HyperbolicHNSW, PoincareOperations, createHyperbolicHNSW, type HyperbolicConfig, type HyperbolicPoint, type HyperbolicSearchResult, } from './hyperbolic-hnsw';
 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

@@ -295,7 +295,9 @@ 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';
+isEpropOnlineLearningEnabled, isGrangerCausalityEnabled, 
+// Phase 5 Milestone 5 (ADR-087)
+isCognitiveRoutingEnabled, isHyperbolicHnswEnabled, DEFAULT_FEATURE_FLAGS, } from './feature-flags';
 // ============================================================================
 // Cross-Domain Transfer Learning (ADR-084, Task 2.3)
 // ============================================================================
@@ -338,11 +340,13 @@ export { CognitiveContainer, createCognitiveContainer, generateSigningKeyPair, }
 // Phase 5: Pattern Intelligence (ADR-087, Milestone 1)
 // ============================================================================
 // R1: HDC Pattern Fingerprinting
-export { HdcFingerprinter, createHdcFingerprinter, } from './hdc-fingerprint';
+export { HdcFingerprinter, createHdcFingerprinter, HDCPatternFingerprinter, createHDCFingerprinter, createRandomHypervector, bind, bundle, hammingDistance, hammingSimilarity, permute, } from './hdc-fingerprint';
 // R2: CUSUM Drift Detection
 export { CusumDetector, } from './cusum-detector';
 // R3: Delta Event Sourcing
 export { DeltaTracker, PATTERN_DELTAS_SCHEMA, } from './delta-tracker';
+// R3: Sparse Vector Delta Event Sourcing (ADR-087 Milestone 1)
+export { VectorDeltaTracker, createVectorDeltaTracker, } from './vector-delta-tracker';
 // ============================================================================
 // Phase 5: Graph Learning (ADR-087, Milestone 2)
 // ============================================================================
@@ -369,6 +373,13 @@ export { EpropNetwork, createEpropNetwork, } from './eprop-learner';
 // R12: Granger Causality for Test Failure Prediction
 export { GrangerAnalyzer, createGrangerAnalyzer, } from './temporal-causality';
 // ============================================================================
+// Phase 5: Routing & Geometry (ADR-087, Milestone 5)
+// ============================================================================
+// R13: Cognitive Routing
+export { CognitiveRouter, MessagePredictor, OscillatoryRouter, createCognitiveRouter, } from './cognitive-routing';
+// R14: Hyperbolic HNSW
+export { HyperbolicHNSW, PoincareOperations, createHyperbolicHNSW, } from './hyperbolic-hnsw';
+// ============================================================================
 // 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/shared-rvf-adapter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared RVF Adapter Singleton
+ *
+ * Provides a single RvfNativeAdapter instance for .agentic-qe/patterns.rvf.
+ * Used by both the kernel (agent branching) and DreamEngine (COW dreams)
+ * to avoid dual file handles to the same .rvf file.
+ *
+ * Returns null when native bindings are unavailable — callers degrade
+ * gracefully.
+ *
+ * @module integrations/ruvector/shared-rvf-adapter
+ */
+import type { RvfNativeAdapter } from './rvf-native-adapter.js';
+/**
+ * Get or create the shared RvfNativeAdapter singleton for patterns.rvf.
+ *
+ * @param dataDir - Data directory (default: .agentic-qe)
+ * @param dimensions - Vector dimensions (default: 384)
+ * @returns The shared adapter, or null if native bindings are unavailable
+ */
+export declare function getSharedRvfAdapter(dataDir?: string, dimensions?: number): RvfNativeAdapter | null;
+/** Close the shared adapter and reset the singleton. */
+export declare function resetSharedRvfAdapter(): void;
+//# sourceMappingURL=shared-rvf-adapter.d.ts.map

package/dist/integrations/ruvector/shared-rvf-adapter.js

@@ -0,0 +1,55 @@
+/**
+ * Shared RVF Adapter Singleton
+ *
+ * Provides a single RvfNativeAdapter instance for .agentic-qe/patterns.rvf.
+ * Used by both the kernel (agent branching) and DreamEngine (COW dreams)
+ * to avoid dual file handles to the same .rvf file.
+ *
+ * Returns null when native bindings are unavailable — callers degrade
+ * gracefully.
+ *
+ * @module integrations/ruvector/shared-rvf-adapter
+ */
+let sharedAdapter = null;
+let initAttempted = false;
+/**
+ * Get or create the shared RvfNativeAdapter singleton for patterns.rvf.
+ *
+ * @param dataDir - Data directory (default: .agentic-qe)
+ * @param dimensions - Vector dimensions (default: 384)
+ * @returns The shared adapter, or null if native bindings are unavailable
+ */
+export function getSharedRvfAdapter(dataDir = '.agentic-qe', dimensions = 384) {
+    if (initAttempted)
+        return sharedAdapter;
+    initAttempted = true;
+    try {
+        // Dynamic require to match the bundled build pattern used elsewhere
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { isRvfNativeAvailable, createRvfStore } = require('./rvf-native-adapter.js');
+        if (!isRvfNativeAvailable()) {
+            console.warn('[RVF] Native bindings unavailable — agent branching and dream COW disabled. ' +
+                'Install @ruvector/rvf-node to enable.');
+            return null;
+        }
+        const path = require('path');
+        sharedAdapter = createRvfStore(path.join(dataDir, 'patterns.rvf'), dimensions);
+        return sharedAdapter;
+    }
+    catch (error) {
+        console.warn('[RVF] Shared adapter init failed:', error instanceof Error ? error.message : error);
+        return null;
+    }
+}
+/** Close the shared adapter and reset the singleton. */
+export function resetSharedRvfAdapter() {
+    if (sharedAdapter) {
+        try {
+            sharedAdapter.close();
+        }
+        catch { /* best effort */ }
+        sharedAdapter = null;
+    }
+    initAttempted = false;
+}
+//# sourceMappingURL=shared-rvf-adapter.js.map

package/dist/integrations/ruvector/shared-rvf-dual-writer.d.ts

@@ -12,6 +12,7 @@
  * continue with SQLite-only operation.
  */
 import type { RvfDualWriter } from './rvf-dual-writer.js';
+import type { RvfMigrationAdapter } from '../../persistence/rvf-migration-adapter.js';
 /**
  * Get or create the shared RvfDualWriter singleton.
  *
@@ -31,6 +32,11 @@ export declare function getSharedRvfDualWriter(): Promise<RvfDualWriter | null>;
  * initialized or if native RVF is unavailable.
  */
 export declare function getSharedRvfDualWriterSync(): RvfDualWriter | null;
+/**
+ * Get the shared RvfMigrationAdapter (ADR-072).
+ * Returns null if migration stage < 2 or if initialization has not completed.
+ */
+export declare function getSharedMigrationAdapter(): RvfMigrationAdapter | null;
 /**
  * Reset the shared RvfDualWriter singleton.
  *