agentic-qe 3.8.14 → 3.9.1

package/dist/integrations/embeddings/index/HNSWIndex.d.ts

@@ -4,6 +4,9 @@
  * Shared HNSW indexing between QE and claude-flow per ADR-040.
  * Performance: 150x-12,500x faster than linear search
  *
+ * When useUnifiedHnsw feature flag is enabled (ADR-071), all namespaces
+ * are routed through the unified HnswAdapter backend instead of hnswlib-node.
+ *
  * @module integrations/embeddings/index/HNSWIndex
  */
 import type { IEmbedding, IHNSWConfig, EmbeddingNamespace, ISearchOptions } from '../base/types.js';
@@ -18,6 +21,8 @@ export declare class HNSWEmbeddingIndex {
     private config;
     private initialized;
     private nextId;
+    private unifiedAdapters;
+    private readonly useUnified;
     constructor(config?: Partial<IHNSWConfig>);
     /**
      * Initialize index for a namespace
@@ -51,11 +56,13 @@ export declare class HNSWEmbeddingIndex {
         metric: string;
     } | null;
     /**
-     * Save index to file
+     * Save index to file.
+     * Not supported when using unified backend (HnswAdapter manages persistence).
      */
     saveIndex(namespace: EmbeddingNamespace, path: string): Promise<void>;
     /**
-     * Load index from file
+     * Load index from file.
+     * Not supported when using unified backend (HnswAdapter manages persistence).
      */
     loadIndex(namespace: EmbeddingNamespace, path: string): Promise<void>;
     /**

package/dist/integrations/embeddings/index/HNSWIndex.js

@@ -4,12 +4,21 @@
  * Shared HNSW indexing between QE and claude-flow per ADR-040.
  * Performance: 150x-12,500x faster than linear search
  *
+ * When useUnifiedHnsw feature flag is enabled (ADR-071), all namespaces
+ * are routed through the unified HnswAdapter backend instead of hnswlib-node.
+ *
  * @module integrations/embeddings/index/HNSWIndex
  */
 // ESM/CJS interop: hnswlib-node is CommonJS, we import via default export
 // This pattern matches real-qe-reasoning-bank.ts for consistency
 import hnswlib from 'hnswlib-node';
 const { HierarchicalNSW } = hnswlib;
+// ADR-071 Phase 2C: Always use unified HnswAdapter backend.
+// The hnswlib-node legacy path below is retained as dead code for
+// emergency rollback only — production always takes the adapter path.
+function isUnifiedHnswActive() {
+    return true;
+}
 /**
  * HNSW index manager
  *
@@ -21,6 +30,9 @@ export class HNSWEmbeddingIndex {
     config;
     initialized;
     nextId;
+    // ADR-071: Unified backend adapters per namespace (when useUnifiedHnsw=true)
+    unifiedAdapters = null;
+    useUnified;
     constructor(config = {}) {
         this.config = {
             M: config.M || 16,
@@ -33,6 +45,10 @@ export class HNSWEmbeddingIndex {
         this.indexes = new Map();
         this.initialized = new Set();
         this.nextId = new Map();
+        this.useUnified = isUnifiedHnswActive();
+        if (this.useUnified) {
+            this.unifiedAdapters = new Map();
+        }
     }
     /**
      * Initialize index for a namespace
@@ -41,6 +57,28 @@ export class HNSWEmbeddingIndex {
         if (this.initialized.has(namespace)) {
             return;
         }
+        // ADR-071: Route through unified HnswAdapter when flag is enabled
+        if (this.useUnified && this.unifiedAdapters) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const { HnswAdapter } = require('../../../kernel/hnsw-adapter.js');
+                const adapter = new HnswAdapter(`embedding-${namespace}`, {
+                    dimensions: this.config.dimension,
+                    M: this.config.M,
+                    efConstruction: this.config.efConstruction,
+                    efSearch: this.config.efSearch,
+                    metric: this.config.metric === 'dotproduct' ? 'cosine' : this.config.metric,
+                });
+                this.unifiedAdapters.set(namespace, adapter);
+                this.initialized.add(namespace);
+                this.nextId.set(namespace, 0);
+                return;
+            }
+            catch {
+                // Fall through to hnswlib-node
+            }
+        }
+        // Legacy path: hnswlib-node
         // Map our metric names to hnswlib-node space names
         const spaceMap = {
             'cosine': 'cosine',
@@ -66,14 +104,23 @@ export class HNSWEmbeddingIndex {
         if (!this.initialized.has(namespace)) {
             this.initializeIndex(namespace);
         }
-        const index = this.indexes.get(namespace);
-        // Convert vector to float array
-        const vector = this.toFloatArray(embedding.vector);
         // Use provided ID or auto-increment
         const actualId = id ?? this.nextId.get(namespace);
         if (id === undefined) {
             this.nextId.set(namespace, actualId + 1);
         }
+        // ADR-071: Route through unified backend
+        const adapter = this.unifiedAdapters?.get(namespace);
+        if (adapter) {
+            const vector = embedding.vector instanceof Float32Array
+                ? embedding.vector
+                : new Float32Array(this.toFloatArray(embedding.vector));
+            adapter.add(actualId, vector);
+            return actualId;
+        }
+        // Legacy path
+        const index = this.indexes.get(namespace);
+        const vector = this.toFloatArray(embedding.vector);
         index.addPoint(vector, actualId);
         return actualId;
     }
@@ -81,33 +128,8 @@ export class HNSWEmbeddingIndex {
      * Add multiple embeddings to index
      */
     addEmbeddingsBatch(embeddings) {
-        const ids = [];
-        // Group by namespace
-        const byNamespace = new Map();
-        for (const item of embeddings) {
-            const ns = item.embedding.namespace;
-            if (!byNamespace.has(ns)) {
-                byNamespace.set(ns, []);
-            }
-            byNamespace.get(ns).push(item);
-        }
-        // Add to each namespace's index
-        for (const [namespace, items] of byNamespace.entries()) {
-            if (!this.initialized.has(namespace)) {
-                this.initializeIndex(namespace);
-            }
-            const index = this.indexes.get(namespace);
-            for (const item of items) {
-                const vector = this.toFloatArray(item.embedding.vector);
-                const actualId = item.id ?? this.nextId.get(namespace);
-                if (item.id === undefined) {
-                    this.nextId.set(namespace, actualId + 1);
-                }
-                index.addPoint(vector, actualId);
-                ids.push(actualId);
-            }
-        }
-        return ids;
+        // ADR-071: Route each item through addEmbedding() which handles unified routing
+        return embeddings.map(item => this.addEmbedding(item.embedding, item.id));
     }
     /**
      * Search for similar embeddings
@@ -117,11 +139,22 @@ export class HNSWEmbeddingIndex {
         if (!this.initialized.has(namespace)) {
             return [];
         }
-        const index = this.indexes.get(namespace);
         const k = options.limit || 10;
-        // Convert query vector
+        // ADR-071: Route through unified backend
+        const adapter = this.unifiedAdapters?.get(namespace);
+        if (adapter) {
+            const queryVector = query.vector instanceof Float32Array
+                ? query.vector
+                : new Float32Array(this.toFloatArray(query.vector));
+            const results = adapter.search(queryVector, k);
+            return results.map(r => ({
+                id: r.id,
+                distance: 1 - r.score, // convert similarity to distance
+            }));
+        }
+        // Legacy path
+        const index = this.indexes.get(namespace);
         const queryVector = this.toFloatArray(query.vector);
-        // Search
         const result = index.searchKnn(queryVector, k);
         // Convert hnswlib-node result format to our format
         return result.neighbors.map((id, i) => ({
@@ -136,6 +169,16 @@ export class HNSWEmbeddingIndex {
         if (!this.initialized.has(namespace)) {
             return null;
         }
+        // ADR-071: Use unified adapter stats
+        const adapter = this.unifiedAdapters?.get(namespace);
+        if (adapter) {
+            return {
+                size: adapter.size(),
+                maxElements: 10000,
+                dimension: adapter.dimensions(),
+                metric: this.config.metric,
+            };
+        }
         const index = this.indexes.get(namespace);
         return {
             size: index.getCurrentCount(), // Note: This may not be available in all versions
@@ -145,19 +188,33 @@ export class HNSWEmbeddingIndex {
         };
     }
     /**
-     * Save index to file
+     * Save index to file.
+     * Not supported when using unified backend (HnswAdapter manages persistence).
      */
     async saveIndex(namespace, path) {
         if (!this.initialized.has(namespace)) {
             throw new Error(`Namespace ${namespace} not initialized`);
         }
+        // ADR-071: Unified backend manages its own persistence
+        if (this.unifiedAdapters?.has(namespace)) {
+            console.warn(`[HNSWEmbeddingIndex] saveIndex() is a no-op for namespace '${namespace}' — ` +
+                `unified HnswAdapter manages persistence internally.`);
+            return;
+        }
         const index = this.indexes.get(namespace);
         await index.writeIndex(path);
     }
     /**
-     * Load index from file
+     * Load index from file.
+     * Not supported when using unified backend (HnswAdapter manages persistence).
      */
     async loadIndex(namespace, path) {
+        // ADR-071: Unified backend manages its own persistence
+        if (this.useUnified) {
+            console.warn(`[HNSWEmbeddingIndex] loadIndex() is a no-op for namespace '${namespace}' — ` +
+                `unified HnswAdapter manages persistence internally. Initialize via initializeIndex() instead.`);
+            return;
+        }
         const spaceMap = {
             'cosine': 'cosine',
             'euclidean': 'l2',
@@ -174,6 +231,12 @@ export class HNSWEmbeddingIndex {
      */
     clearIndex(namespace) {
         if (this.initialized.has(namespace)) {
+            // ADR-071: Clear unified adapter if present
+            const adapter = this.unifiedAdapters?.get(namespace);
+            if (adapter) {
+                adapter.clear?.();
+                this.unifiedAdapters.delete(namespace);
+            }
             this.indexes.delete(namespace);
             this.initialized.delete(namespace);
             this.nextId.delete(namespace);
@@ -183,6 +246,13 @@ export class HNSWEmbeddingIndex {
      * Clear all indexes
      */
     clearAll() {
+        // ADR-071: Clear all unified adapters
+        if (this.unifiedAdapters) {
+            for (const adapter of this.unifiedAdapters.values()) {
+                adapter.clear?.();
+            }
+            this.unifiedAdapters.clear();
+        }
         this.indexes.clear();
         this.initialized.clear();
         this.nextId.clear();
@@ -263,6 +333,11 @@ export class HNSWEmbeddingIndex {
         if (!this.initialized.has(namespace)) {
             return 0;
         }
+        // ADR-071: Use unified adapter size when available
+        const adapter = this.unifiedAdapters?.get(namespace);
+        if (adapter) {
+            return adapter.size();
+        }
         return this.nextId.get(namespace) || 0;
     }
 }

package/dist/integrations/ruvector/cognitive-routing.d.ts

@@ -0,0 +1,67 @@
+export interface CognitiveRoutingConfig {
+    predictionWindowSize: number;
+    compressionThreshold: number;
+    maxConcurrentStreams: number;
+    oscillationFrequencyMs: number;
+}
+export interface RoutedMessage {
+    streamId: string;
+    senderId: string;
+    receiverId: string;
+    payload: unknown;
+    compressed: boolean;
+    originalSize: number;
+    compressedSize: number;
+    timestamp: number;
+}
+export interface RoutingStats {
+    totalMessages: number;
+    compressedMessages: number;
+    bandwidthSavedBytes: number;
+    bandwidthReductionPercent: number;
+    activeStreams: number;
+}
+/** Sliding-window predictor: predicts next payload as copy of last seen. */
+export declare class MessagePredictor {
+    private readonly windowSize;
+    private readonly windows;
+    constructor(windowSize: number);
+    predict(streamId: string): Record<string, unknown> | null;
+    record(streamId: string, payload: unknown): void;
+    removeStream(streamId: string): void;
+}
+/** Round-robin multiplexer for concurrent message streams. */
+export declare class OscillatoryRouter {
+    private readonly maxStreams;
+    readonly cycleMs: number;
+    private readonly streamIds;
+    private currentIndex;
+    constructor(maxStreams: number, cycleMs: number);
+    addStream(streamId: string): boolean;
+    removeStream(streamId: string): boolean;
+    nextStream(): string | null;
+    getActiveStreams(): string[];
+    get activeCount(): number;
+}
+/** Combines MessagePredictor + OscillatoryRouter for bandwidth-efficient routing. */
+export declare class CognitiveRouter {
+    private readonly config;
+    private readonly predictor;
+    private readonly router;
+    private readonly lastPayloads;
+    private totalMessages;
+    private compressedMessages;
+    private totalOriginalBytes;
+    private totalCompressedBytes;
+    constructor(config?: Partial<CognitiveRoutingConfig>);
+    send(streamId: string, senderId: string, receiverId: string, payload: unknown): RoutedMessage;
+    receive(message: RoutedMessage): unknown;
+    getStats(): RoutingStats;
+    addStream(streamId: string): void;
+    removeStream(streamId: string): void;
+}
+/** Create a CognitiveRouter if the feature flag is enabled, otherwise null. */
+export declare function createCognitiveRouter(config?: Partial<CognitiveRoutingConfig>): CognitiveRouter | null;
+/** Check if Cognitive Routing feature flag is enabled. */
+export declare function isCognitiveRoutingEnabled(): boolean;
+//# sourceMappingURL=cognitive-routing.d.ts.map

package/dist/integrations/ruvector/cognitive-routing.js

@@ -0,0 +1,208 @@
+/**
+ * R13: Cognitive Routing — Predictive Coding for Agent Communication
+ *
+ * Bandwidth reduction via sliding-window prediction + delta-only transmission.
+ * Oscillatory routing multiplexes concurrent message streams round-robin.
+ * TypeScript-only; no external dependencies.
+ *
+ * @module integrations/ruvector/cognitive-routing
+ */
+import { getRuVectorFeatureFlags } from './feature-flags.js';
+const DEFAULT_CONFIG = {
+    predictionWindowSize: 10, compressionThreshold: 0.3,
+    maxConcurrentStreams: 8, oscillationFrequencyMs: 100,
+};
+function estimateSize(value) {
+    try {
+        return JSON.stringify(value).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function computeDelta(predicted, actual) {
+    const delta = {};
+    let hasChanges = false;
+    for (const key of Object.keys(actual)) {
+        if (JSON.stringify(predicted[key]) !== JSON.stringify(actual[key])) {
+            delta[key] = actual[key];
+            hasChanges = true;
+        }
+    }
+    for (const key of Object.keys(predicted)) {
+        if (!(key in actual)) {
+            delta[key] = undefined;
+            hasChanges = true;
+        }
+    }
+    return hasChanges ? delta : null;
+}
+function applyDelta(predicted, delta) {
+    const result = { ...predicted };
+    for (const [key, value] of Object.entries(delta)) {
+        if (value === undefined)
+            delete result[key];
+        else
+            result[key] = value;
+    }
+    return result;
+}
+/** Sliding-window predictor: predicts next payload as copy of last seen. */
+export class MessagePredictor {
+    windowSize;
+    windows = new Map();
+    constructor(windowSize) { this.windowSize = Math.max(1, windowSize); }
+    predict(streamId) {
+        const w = this.windows.get(streamId);
+        if (!w || w.length === 0)
+            return null;
+        const last = w[w.length - 1];
+        if (typeof last !== 'object' || last === null || Array.isArray(last))
+            return null;
+        return { ...last };
+    }
+    record(streamId, payload) {
+        let w = this.windows.get(streamId);
+        if (!w) {
+            w = [];
+            this.windows.set(streamId, w);
+        }
+        w.push(payload);
+        if (w.length > this.windowSize)
+            w.shift();
+    }
+    removeStream(streamId) { this.windows.delete(streamId); }
+}
+/** Round-robin multiplexer for concurrent message streams. */
+export class OscillatoryRouter {
+    maxStreams;
+    cycleMs;
+    streamIds = [];
+    currentIndex = 0;
+    constructor(maxStreams, cycleMs) {
+        this.maxStreams = Math.max(1, maxStreams);
+        this.cycleMs = Math.max(1, cycleMs);
+    }
+    addStream(streamId) {
+        if (this.streamIds.includes(streamId) || this.streamIds.length >= this.maxStreams)
+            return false;
+        this.streamIds.push(streamId);
+        return true;
+    }
+    removeStream(streamId) {
+        const idx = this.streamIds.indexOf(streamId);
+        if (idx === -1)
+            return false;
+        this.streamIds.splice(idx, 1);
+        if (this.currentIndex >= this.streamIds.length)
+            this.currentIndex = 0;
+        return true;
+    }
+    nextStream() {
+        if (this.streamIds.length === 0)
+            return null;
+        const s = this.streamIds[this.currentIndex];
+        this.currentIndex = (this.currentIndex + 1) % this.streamIds.length;
+        return s;
+    }
+    getActiveStreams() { return [...this.streamIds]; }
+    get activeCount() { return this.streamIds.length; }
+}
+/** Combines MessagePredictor + OscillatoryRouter for bandwidth-efficient routing. */
+export class CognitiveRouter {
+    config;
+    predictor;
+    router;
+    lastPayloads = new Map();
+    totalMessages = 0;
+    compressedMessages = 0;
+    totalOriginalBytes = 0;
+    totalCompressedBytes = 0;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.predictor = new MessagePredictor(this.config.predictionWindowSize);
+        this.router = new OscillatoryRouter(this.config.maxConcurrentStreams, this.config.oscillationFrequencyMs);
+    }
+    send(streamId, senderId, receiverId, payload) {
+        this.totalMessages++;
+        const originalSize = estimateSize(payload);
+        this.totalOriginalBytes += originalSize;
+        let compressed = false;
+        let transmittedPayload = payload;
+        let compressedSize = originalSize;
+        if (typeof payload === 'object' && payload !== null && !Array.isArray(payload)) {
+            const prediction = this.predictor.predict(streamId);
+            if (prediction) {
+                const delta = computeDelta(prediction, payload);
+                if (delta) {
+                    const deltaSize = estimateSize(delta);
+                    if (1 - deltaSize / Math.max(originalSize, 1) >= this.config.compressionThreshold) {
+                        transmittedPayload = { __delta: true, __changes: delta };
+                        compressedSize = estimateSize(transmittedPayload);
+                        compressed = true;
+                        this.compressedMessages++;
+                    }
+                }
+                else {
+                    transmittedPayload = { __delta: true, __changes: {} };
+                    compressedSize = estimateSize(transmittedPayload);
+                    compressed = true;
+                    this.compressedMessages++;
+                }
+            }
+        }
+        this.totalCompressedBytes += compressedSize;
+        this.predictor.record(streamId, payload);
+        this.lastPayloads.set(streamId, payload);
+        return { streamId, senderId, receiverId, payload: transmittedPayload,
+            compressed, originalSize, compressedSize, timestamp: Date.now() };
+    }
+    receive(message) {
+        if (!message.compressed || typeof message.payload !== 'object' || message.payload === null) {
+            this.lastPayloads.set(message.streamId, message.payload);
+            this.predictor.record(message.streamId, message.payload);
+            return message.payload;
+        }
+        const envelope = message.payload;
+        if (!envelope.__delta) {
+            this.lastPayloads.set(message.streamId, message.payload);
+            this.predictor.record(message.streamId, message.payload);
+            return message.payload;
+        }
+        const prediction = this.predictor.predict(message.streamId);
+        const changes = (envelope.__changes ?? {});
+        if (!prediction)
+            return changes;
+        const reconstructed = applyDelta(prediction, changes);
+        this.predictor.record(message.streamId, reconstructed);
+        this.lastPayloads.set(message.streamId, reconstructed);
+        return reconstructed;
+    }
+    getStats() {
+        const saved = this.totalOriginalBytes - this.totalCompressedBytes;
+        return {
+            totalMessages: this.totalMessages, compressedMessages: this.compressedMessages,
+            bandwidthSavedBytes: Math.max(0, saved),
+            bandwidthReductionPercent: this.totalOriginalBytes > 0
+                ? (Math.max(0, saved) / this.totalOriginalBytes) * 100 : 0,
+            activeStreams: this.router.activeCount,
+        };
+    }
+    addStream(streamId) { this.router.addStream(streamId); }
+    removeStream(streamId) {
+        this.router.removeStream(streamId);
+        this.predictor.removeStream(streamId);
+        this.lastPayloads.delete(streamId);
+    }
+}
+/** Create a CognitiveRouter if the feature flag is enabled, otherwise null. */
+export function createCognitiveRouter(config) {
+    if (!isCognitiveRoutingEnabled())
+        return null;
+    return new CognitiveRouter(config);
+}
+/** Check if Cognitive Routing feature flag is enabled. */
+export function isCognitiveRoutingEnabled() {
+    return getRuVectorFeatureFlags().useCognitiveRouting;
+}
+//# sourceMappingURL=cognitive-routing.js.map

package/dist/integrations/ruvector/feature-flags.d.ts

@@ -189,6 +189,42 @@ export interface RuVectorFeatureFlags {
      * @default true
      */
     useReasoningQEC: boolean;
+    /**
+     * Enable RVF-backed PatternStore (ADR-066)
+     * Replaces SQLite BLOB + in-memory HNSW rebuild with @ruvector/rvf-node
+     * persistent HNSW. Eliminates cold-start index rebuild, provides sub-ms
+     * search via native SIMD acceleration, and enables COW branching (ADR-067/069).
+     * Pattern metadata remains in SQLite; only vector storage moves to RVF.
+     * @default false — will flip to true after benchmarks confirm improvement
+     */
+    useRVFPatternStore: boolean;
+    /**
+     * Enable Agent Memory Branching via RVF COW (ADR-067)
+     * Each spawned agent gets a lightweight COW-derived .rvf branch file.
+     * Agent writes are isolated; successful agents merge back, failed agents
+     * discard at zero cost. Requires useRVFPatternStore to be enabled.
+     * @default false — will flip to true after benchmarks confirm improvement
+     */
+    useAgentMemoryBranching: boolean;
+    /**
+     * Enable Unified HNSW Provider (ADR-071)
+     * Routes all three legacy HNSW implementations (TypeScript, RuvectorFlatIndex,
+     * QEGNNEmbeddingIndex) through a single HnswAdapter backend. Eliminates
+     * inconsistent search results and triples maintenance burden.
+     * @default false — will flip to true after shadow validation confirms <2% divergence
+     */
+    useUnifiedHnsw: boolean;
+    /**
+     * RVF Migration Stage (ADR-072)
+     * Controls the gradual migration from SQLite to RVF primary persistence.
+     *   Stage 0: SQLite only (legacy, no RVF involvement)
+     *   Stage 1: Hybrid (current — ADR-065, RvfPatternStore for vectors, SQLite for metadata)
+     *   Stage 2: Dual-write, SQLite source of truth (both engines receive writes, reads from SQLite)
+     *   Stage 3: Dual-write, RVF source of truth (both engines receive writes, reads from RVF)
+     *   Stage 4: RVF primary, SQLite escape hatch (writes to RVF only, SQLite for fallback)
+     * @default 1 — current hybrid
+     */
+    rvfMigrationStage: 0 | 1 | 2 | 3 | 4;
     /**
      * Enable HDC Pattern Fingerprinting (R1, ADR-087)
      * Uses 10,000-bit binary hypervectors with XOR binding for O(1) compositional
@@ -301,6 +337,24 @@ export interface RuVectorFeatureFlags {
      * @default false
      */
     useGrangerCausality: boolean;
+    /**
+     * Enable Cognitive Routing (R13, ADR-087)
+     * Predictive coding for agent communication bandwidth reduction. Predicts
+     * next message from sliding window context and sends only the delta.
+     * Oscillatory routing multiplexes concurrent message streams.
+     * Consumer: agent communication layer
+     * @default false
+     */
+    useCognitiveRouting: boolean;
+    /**
+     * Enable Hyperbolic HNSW (R14, ADR-087)
+     * Poincare ball embeddings for hierarchical data. Maps tree-structured data
+     * (module hierarchies, test suite trees) into hyperbolic space where distances
+     * naturally preserve parent-child relationships.
+     * Consumer: code-intelligence hierarchical search
+     * @default false
+     */
+    useHyperbolicHnsw: boolean;
 }
 /**
  * Default feature flags - all enabled by default
@@ -453,6 +507,26 @@ export declare function isCoherenceActionGateEnabled(): boolean;
  * @returns true if useReasoningQEC flag is set
  */
 export declare function isReasoningQECEnabled(): boolean;
+/**
+ * Check if RVF-backed PatternStore is enabled (ADR-066)
+ * @returns true if useRVFPatternStore flag is set
+ */
+export declare function isRVFPatternStoreEnabled(): boolean;
+/**
+ * Check if Agent Memory Branching is enabled (ADR-067)
+ * @returns true if useAgentMemoryBranching flag is set
+ */
+export declare function isAgentMemoryBranchingEnabled(): boolean;
+/**
+ * Check if Unified HNSW Provider is enabled (ADR-071)
+ * @returns true if useUnifiedHnsw flag is set
+ */
+export declare function isUnifiedHnswEnabled(): boolean;
+/**
+ * Get the current RVF migration stage (ADR-072)
+ * @returns 0-4 representing the migration stage
+ */
+export declare function getRvfMigrationStage(): 0 | 1 | 2 | 3 | 4;
 /**
  * Check if HDC Pattern Fingerprinting is enabled (R1, ADR-087)
  * @returns true if useHDCFingerprinting flag is set
@@ -518,6 +592,16 @@ export declare function isEpropOnlineLearningEnabled(): boolean;
  * @returns true if useGrangerCausality flag is set
  */
 export declare function isGrangerCausalityEnabled(): boolean;
+/**
+ * Check if Cognitive Routing is enabled (R13, ADR-087)
+ * @returns true if useCognitiveRouting flag is set
+ */
+export declare function isCognitiveRoutingEnabled(): boolean;
+/**
+ * Check if Hyperbolic HNSW is enabled (R14, ADR-087)
+ * @returns true if useHyperbolicHnsw flag is set
+ */
+export declare function isHyperbolicHnswEnabled(): boolean;
 /**
  * Initialize feature flags from environment variables
  *