agentic-qe 3.8.14 → 3.9.1

package/dist/learning/pattern-store.js

@@ -7,13 +7,17 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../shared/types/index.js';
+import { RvfPatternStore } from './rvf-pattern-store.js';
+import { createRvfStore as _createRvfStore, isRvfNativeAvailable } from '../integrations/ruvector/rvf-native-adapter.js';
 import { toErrorMessage, toError } from '../shared/error-utils.js';
 import { calculateQualityScore, shouldPromotePattern, validateQEPattern, mapQEDomainToAQE, PROMOTION_THRESHOLD, } from './qe-patterns.js';
 import { applyFilterSync } from '../integrations/ruvector/filter-adapter.js';
-import { isHDCFingerprintingEnabled, isDeltaEventSourcingEnabled, isHopfieldMemoryEnabled, } from '../integrations/ruvector/feature-flags.js';
-import { createHdcFingerprinter, } from '../integrations/ruvector/hdc-fingerprint.js';
+import { isHDCFingerprintingEnabled, isDeltaEventSourcingEnabled, isHopfieldMemoryEnabled, isHyperbolicHnswEnabled, getRuVectorFeatureFlags, } from '../integrations/ruvector/feature-flags.js';
+import { createHdcFingerprinter, createHDCFingerprinter, } from '../integrations/ruvector/hdc-fingerprint.js';
 import { DeltaTracker } from '../integrations/ruvector/delta-tracker.js';
+import { createVectorDeltaTracker, } from '../integrations/ruvector/vector-delta-tracker.js';
 import { createHopfieldMemory } from '../integrations/ruvector/hopfield-memory.js';
+import { createHyperbolicPatternIndex, } from './hyperbolic-pattern-index.js';
 // ============================================================================
 // R1: HDC Fingerprint Singleton (lazy-initialized)
 // ============================================================================
@@ -26,6 +30,17 @@ function getHdcFingerprinter() {
     return hdcFingerprinter;
 }
 // ============================================================================
+// R1b: Token-based HDC Fingerprinter Singleton (lazy-initialized, flag-gated)
+// ============================================================================
+/** Module-level token-based HDC fingerprinter (null when feature disabled) */
+let hdcTokenFingerprinter = undefined;
+function getHDCTokenFingerprinter() {
+    if (hdcTokenFingerprinter === undefined) {
+        hdcTokenFingerprinter = createHDCFingerprinter(); // null when flag disabled
+    }
+    return hdcTokenFingerprinter;
+}
+// ============================================================================
 // R5: Hopfield Memory Singleton (lazy-initialized, dimension-aware)
 // ============================================================================
 /** Module-level Hopfield memory for exact pattern recall */
@@ -97,8 +112,14 @@ export class PatternStore {
     hnswInitPromise = null;
     // R1: HDC fingerprint cache (pattern ID -> fingerprint vector)
     hdcCache = new Map();
+    // R1b: Token-based HDC fingerprint cache (pattern ID -> token fingerprint vector)
+    hdcTokenCache = new Map();
     // R3: Delta event sourcing tracker (lazy-initialized with SQLite)
     deltaTracker = null;
+    // R3b: Vector delta tracker for embedding version history (lazy-initialized, flag-gated)
+    vectorDeltaTracker = undefined;
+    // R14: Hyperbolic HNSW index for hierarchical pattern search (lazy-initialized, flag-gated)
+    hyperbolicIndex = null;
     // Statistics
     stats = {
         searchOperations: 0,
@@ -201,7 +222,29 @@ export class PatternStore {
      */
     async initializeHNSWInternal() {
         try {
-            // Try to import and use the existing HNSWIndex
+            // ADR-071: Use unified HNSW via bridge when flag is enabled
+            const unifiedFlags = getRuVectorFeatureFlags();
+            if (unifiedFlags.useUnifiedHnsw) {
+                try {
+                    const { HnswLegacyBridge } = await import('../kernel/hnsw-legacy-bridge.js');
+                    const { HnswAdapter } = await import('../kernel/hnsw-adapter.js');
+                    const adapter = new HnswAdapter('patterns', {
+                        dimensions: this.config.embeddingDimension,
+                        M: this.config.hnsw.M,
+                        efConstruction: this.config.hnsw.efConstruction,
+                        efSearch: this.config.hnsw.efSearch,
+                        metric: 'cosine',
+                    });
+                    this.hnswIndex = new HnswLegacyBridge(adapter);
+                    this.hnswAvailable = true;
+                    console.log('[PatternStore] Using unified HNSW via HnswLegacyBridge (ADR-071)');
+                    return;
+                }
+                catch (bridgeError) {
+                    console.warn('[PatternStore] Unified HNSW bridge failed, falling back:', bridgeError);
+                }
+            }
+            // Fallback: direct HNSWIndex (legacy path)
             const { HNSWIndex } = await import('../domains/coverage-analysis/services/hnsw-index.js');
             this.hnswIndex = new HNSWIndex(this.memory, {
                 dimensions: this.config.embeddingDimension,
@@ -267,6 +310,16 @@ export class PatternStore {
             this.hnswAvailable = false;
         }
     }
+    /**
+     * Lazily initialize the VectorDeltaTracker for embedding version history.
+     * Returns null when the useDeltaEventSourcing feature flag is disabled.
+     */
+    getVectorDeltaTracker() {
+        if (this.vectorDeltaTracker === undefined) {
+            this.vectorDeltaTracker = createVectorDeltaTracker(); // null when flag disabled
+        }
+        return this.vectorDeltaTracker;
+    }
     /**
      * Load existing patterns from SQLite into in-memory cache.
      *
@@ -323,6 +376,7 @@ export class PatternStore {
         this.typeIndex.get(pattern.patternType)?.delete(pattern.id);
         this.tierIndex.get(pattern.tier)?.delete(pattern.id);
         this.hdcCache.delete(pattern.id); // R1: cleanup HDC fingerprint
+        this.hdcTokenCache.delete(pattern.id); // R1b: cleanup token-based fingerprint
     }
     /**
      * Store a new pattern
@@ -349,6 +403,8 @@ export class PatternStore {
             // Run cleanup for this domain
             await this.cleanupDomain(pattern.qeDomain);
         }
+        // R3b: Capture pre-existing pattern for VectorDeltaTracker before overwrite
+        const existingPattern = this.patternCache.get(pattern.id) ?? null;
         // Index in memory cache
         this.indexPattern(pattern);
         // Persist to SQLite (pattern + embedding atomically)
@@ -401,6 +457,25 @@ export class PatternStore {
                 console.debug(`[PatternStore] HDC fingerprint failed for ${pattern.id}:`, toErrorMessage(error));
             }
         }
+        // R1b: Compute token-based HDC fingerprint via HDCPatternFingerprinter
+        try {
+            const tokenFp = getHDCTokenFingerprinter();
+            if (tokenFp) {
+                const tokens = [pattern.patternType, pattern.qeDomain];
+                if (pattern.context?.tags) {
+                    tokens.push(...pattern.context.tags);
+                }
+                if (pattern.name) {
+                    tokens.push(pattern.name);
+                }
+                const fpVector = tokenFp.fingerprintPattern(tokens);
+                this.hdcTokenCache.set(pattern.id, fpVector);
+            }
+        }
+        catch (error) {
+            // Token fingerprinting failure must not prevent pattern storage
+            console.debug(`[PatternStore] HDC token fingerprint failed for ${pattern.id}:`, toErrorMessage(error));
+        }
         // R5: Store embedding in Hopfield memory for exact recall
         if (isHopfieldMemoryEnabled() && pattern.embedding) {
             try {
@@ -434,6 +509,37 @@ export class PatternStore {
                 console.debug(`[PatternStore] Delta genesis for ${pattern.id}:`, toErrorMessage(error));
             }
         }
+        // R3b: Track embedding version history via VectorDeltaTracker
+        if (pattern.embedding) {
+            try {
+                const vdt = this.getVectorDeltaTracker();
+                if (vdt) {
+                    if (existingPattern?.embedding) {
+                        // Update: record delta between old and new embeddings
+                        vdt.recordDelta(pattern.id, existingPattern.embedding, pattern.embedding);
+                    }
+                    else if (vdt.getVersion(pattern.id) < 0) {
+                        // New pattern: record genesis for the embedding
+                        vdt.recordGenesis(pattern.id, pattern.embedding);
+                    }
+                }
+            }
+            catch (error) {
+                // Vector delta tracking failure must not prevent pattern storage
+                console.debug(`[PatternStore] VectorDeltaTracker for ${pattern.id}:`, toErrorMessage(error));
+            }
+        }
+        // R14: Auto-index into hyperbolic HNSW when enabled
+        try {
+            if (isHyperbolicHnswEnabled() && pattern.embedding) {
+                this.indexHyperbolic(pattern.id, pattern.embedding, {
+                    domain: pattern.qeDomain,
+                    type: pattern.patternType,
+                    name: pattern.name,
+                });
+            }
+        }
+        catch { /* best-effort — hyperbolic indexing must not block store() */ }
         return ok(pattern.id);
     }
     /**
@@ -494,6 +600,7 @@ export class PatternStore {
             'flaky-fix': 'test-execution',
             'refactor-safe': 'code-intelligence',
             'error-handling': 'test-generation',
+            'meta-optimization': 'learning-optimization',
         };
         return typeToDomain[patternType] || 'test-generation';
     }
@@ -1129,6 +1236,10 @@ export class PatternStore {
         this.tierIndex.clear();
         this.hdcCache.clear(); // R1: cleanup
         this.deltaTracker = null; // R3: cleanup
+        if (this.hyperbolicIndex) {
+            this.hyperbolicIndex.reset();
+            this.hyperbolicIndex = null;
+        } // R14: cleanup
         if (hopfieldMemory) {
             hopfieldMemory.clear();
             hopfieldMemory = null;
@@ -1136,14 +1247,116 @@ export class PatternStore {
         } // R5: cleanup
         this.initialized = false;
     }
+    // ==========================================================================
+    // R14: Hyperbolic Pattern Search (ADR-087)
+    // ==========================================================================
+    /**
+     * Index a pattern's embedding into the hyperbolic HNSW index.
+     *
+     * Call this after storing a pattern when hyperbolic search is enabled.
+     * Safe to call when disabled — it no-ops. Does not modify the pattern
+     * or the main HNSW index; the hyperbolic index is a parallel backend.
+     *
+     * @param patternId - The pattern ID to index
+     * @param embedding - Euclidean embedding (projected to Poincare ball internally)
+     * @param metadata - Optional metadata (e.g., domain, type)
+     */
+    indexHyperbolic(patternId, embedding, metadata) {
+        if (!isHyperbolicHnswEnabled())
+            return;
+        try {
+            if (!this.hyperbolicIndex) {
+                this.hyperbolicIndex = createHyperbolicPatternIndex({
+                    dimensions: this.config.embeddingDimension,
+                    maxElements: this.config.hnsw.maxElements,
+                });
+            }
+            this.hyperbolicIndex.indexPattern(patternId, embedding, metadata);
+        }
+        catch (error) {
+            console.debug(`[PatternStore] Hyperbolic indexing failed for ${patternId}:`, error instanceof Error ? error.message : error);
+        }
+    }
+    /**
+     * Search for similar patterns using the hyperbolic (Poincare ball) HNSW index.
+     *
+     * Hyperbolic geometry naturally preserves hierarchical relationships:
+     * root patterns cluster near the origin, leaf patterns near the boundary.
+     * This makes it well-suited for module hierarchy and test suite tree searches.
+     *
+     * Falls back to an empty result set when:
+     * - The `useHyperbolicHnsw` feature flag is disabled
+     * - The hyperbolic index has not been populated
+     * - An error occurs during search
+     *
+     * @param query - Euclidean query embedding (will be projected to Poincare ball)
+     * @param k - Number of nearest neighbors to return
+     * @returns Array of pattern search results with hyperbolic distances, or empty on failure
+     */
+    async searchHyperbolic(query, k = 10) {
+        if (!isHyperbolicHnswEnabled() || !this.hyperbolicIndex) {
+            return ok([]);
+        }
+        try {
+            const hyperbolicResults = this.hyperbolicIndex.search(query, k);
+            const results = [];
+            for (const hr of hyperbolicResults) {
+                const pattern = await this.get(hr.patternId);
+                if (!pattern)
+                    continue;
+                // Convert hyperbolic distance to a 0-1 similarity score
+                // Using exp(-distance) which maps [0, inf) -> (0, 1]
+                const similarity = Math.exp(-hr.distance);
+                const reuseInfo = this.calculateReuseInfo(pattern, similarity);
+                results.push({
+                    pattern,
+                    score: similarity,
+                    matchType: 'vector',
+                    similarity,
+                    canReuse: reuseInfo.canReuse,
+                    estimatedTokenSavings: reuseInfo.estimatedTokenSavings,
+                    reuseConfidence: reuseInfo.reuseConfidence,
+                });
+            }
+            return ok(results);
+        }
+        catch (error) {
+            console.warn('[PatternStore] Hyperbolic search failed, returning empty results:', error instanceof Error ? error.message : error);
+            return ok([]);
+        }
+    }
 }
 // ============================================================================
 // Factory Functions
 // ============================================================================
 /**
- * Create a new pattern store instance
+ * Create a new pattern store instance.
+ *
+ * When `useRVFPatternStore` feature flag is enabled (ADR-066), returns an
+ * RvfPatternStore backed by @ruvector/rvf-node with persistent HNSW.
+ * Otherwise returns the existing in-memory HNSW PatternStore.
  */
 export function createPatternStore(memory, config) {
+    // ADR-066: RVF-backed PatternStore when feature flag is enabled
+    try {
+        const flags = getRuVectorFeatureFlags();
+        if (flags.useRVFPatternStore && isRvfNativeAvailable()) {
+            // Only use RVF if the data directory exists (created by kernel init)
+            const { existsSync } = require('fs');
+            const rvfPath = '.agentic-qe/patterns.rvf';
+            const rvfDir = require('path').dirname(rvfPath);
+            if (existsSync(rvfDir)) {
+                const mergedConfig = { ...DEFAULT_PATTERN_STORE_CONFIG, ...config };
+                const store = new RvfPatternStore((path, dim) => _createRvfStore(path, dim), { rvfPath, base: mergedConfig });
+                console.log('[PatternStore] Using RVF-backed store (ADR-066)');
+                return store;
+            }
+        }
+    }
+    catch (error) {
+        // Feature flags or RVF modules not available — use default
+        console.warn('[PatternStore] RVF store unavailable, using in-memory HNSW:', error instanceof Error ? error.message : error);
+    }
     return new PatternStore(memory, config);
 }
 //# sourceMappingURL=pattern-store.js.map

package/dist/learning/qe-patterns.d.ts

@@ -31,7 +31,7 @@ export type QEDomain = keyof typeof QE_DOMAINS;
 /**
  * QE pattern types - specific pattern categories
  */
-export type QEPatternType = 'test-template' | 'assertion-pattern' | 'mock-pattern' | 'coverage-strategy' | 'mutation-strategy' | 'api-contract' | 'visual-baseline' | 'a11y-check' | 'perf-benchmark' | 'flaky-fix' | 'refactor-safe' | 'error-handling';
+export type QEPatternType = 'test-template' | 'assertion-pattern' | 'mock-pattern' | 'coverage-strategy' | 'mutation-strategy' | 'api-contract' | 'visual-baseline' | 'a11y-check' | 'perf-benchmark' | 'flaky-fix' | 'refactor-safe' | 'error-handling' | 'meta-optimization';
 /**
  * Test framework identifiers
  */

package/dist/learning/qe-reasoning-bank.js

@@ -116,7 +116,7 @@ export class QEReasoningBank {
         try {
             const store = this.getSqliteStore();
             await store.initialize();
-            this.patternStore.setSqliteStore(store);
+            this.patternStore.setSqliteStore?.(store);
         }
         catch (e) {
             logger.warn('Failed to wire SQLitePatternStore into PatternStore', { error: toErrorMessage(e) });

package/dist/learning/rvf-pattern-migration.d.ts

@@ -0,0 +1,50 @@
+/**
+ * SQLite → RVF Pattern Migration Utility (ADR-066)
+ *
+ * Reads pattern embeddings from the SQLite qe_patterns/qe_pattern_embeddings
+ * tables and ingests them into an RVF file. This is a one-time migration
+ * that creates the .rvf file for the RvfPatternStore.
+ *
+ * Safety:
+ * - Read-only on SQLite (never modifies memory.db)
+ * - Creates a NEW .rvf file (never overwrites existing)
+ * - Batch ingestion (500 vectors at a time) for memory efficiency
+ *
+ * @module learning/rvf-pattern-migration
+ */
+import type { RvfNativeAdapter } from '../integrations/ruvector/rvf-native-adapter.js';
+import type { SQLitePatternStore } from './sqlite-persistence.js';
+export interface MigrationResult {
+    /** Total patterns successfully migrated */
+    totalMigrated: number;
+    /** Patterns skipped (no embedding or dimension mismatch) */
+    totalSkipped: number;
+    /** Errors encountered during ingestion */
+    errors: string[];
+    /** Migration duration in milliseconds */
+    durationMs: number;
+    /** Path to the created .rvf file */
+    rvfPath: string;
+}
+export interface MigrationOptions {
+    /** Batch size for ingestion (default: 500) */
+    batchSize?: number;
+    /** Expected embedding dimension (default: 384) */
+    dimension?: number;
+    /** Log progress every N patterns (default: 1000) */
+    progressInterval?: number;
+}
+/**
+ * Migrate pattern embeddings from SQLite to an RVF file.
+ *
+ * This function is read-only on SQLite. It reads all embeddings from
+ * the qe_pattern_embeddings table and ingests them into the provided
+ * RVF adapter in batches.
+ *
+ * @param sqliteStore - Initialized SQLitePatternStore to read from
+ * @param rvfAdapter - Initialized RvfNativeAdapter to write to
+ * @param options - Migration options (batch size, dimension)
+ * @returns Migration result with counts and timing
+ */
+export declare function migratePatterns(sqliteStore: SQLitePatternStore, rvfAdapter: RvfNativeAdapter, options?: MigrationOptions): MigrationResult;
+//# sourceMappingURL=rvf-pattern-migration.d.ts.map

package/dist/learning/rvf-pattern-migration.js

@@ -0,0 +1,106 @@
+/**
+ * SQLite → RVF Pattern Migration Utility (ADR-066)
+ *
+ * Reads pattern embeddings from the SQLite qe_patterns/qe_pattern_embeddings
+ * tables and ingests them into an RVF file. This is a one-time migration
+ * that creates the .rvf file for the RvfPatternStore.
+ *
+ * Safety:
+ * - Read-only on SQLite (never modifies memory.db)
+ * - Creates a NEW .rvf file (never overwrites existing)
+ * - Batch ingestion (500 vectors at a time) for memory efficiency
+ *
+ * @module learning/rvf-pattern-migration
+ */
+// ============================================================================
+// Migration Function
+// ============================================================================
+/**
+ * Migrate pattern embeddings from SQLite to an RVF file.
+ *
+ * This function is read-only on SQLite. It reads all embeddings from
+ * the qe_pattern_embeddings table and ingests them into the provided
+ * RVF adapter in batches.
+ *
+ * @param sqliteStore - Initialized SQLitePatternStore to read from
+ * @param rvfAdapter - Initialized RvfNativeAdapter to write to
+ * @param options - Migration options (batch size, dimension)
+ * @returns Migration result with counts and timing
+ */
+export function migratePatterns(sqliteStore, rvfAdapter, options = {}) {
+    const startTime = performance.now();
+    const batchSize = options.batchSize ?? 500;
+    const dimension = options.dimension ?? 384;
+    const progressInterval = options.progressInterval ?? 1000;
+    const result = {
+        totalMigrated: 0,
+        totalSkipped: 0,
+        errors: [],
+        durationMs: 0,
+        rvfPath: rvfAdapter.path(),
+    };
+    // Read all embeddings from SQLite
+    let allEmbeddings;
+    try {
+        allEmbeddings = sqliteStore.getAllEmbeddings();
+    }
+    catch (error) {
+        result.errors.push(`Failed to read embeddings from SQLite: ${error}`);
+        result.durationMs = performance.now() - startTime;
+        return result;
+    }
+    console.log(`[RVF Migration] Found ${allEmbeddings.length} embeddings to migrate (dim=${dimension})`);
+    // Process in batches
+    let batch = [];
+    for (let i = 0; i < allEmbeddings.length; i++) {
+        const { patternId, embedding } = allEmbeddings[i];
+        // Skip if dimension doesn't match
+        if (embedding.length !== dimension) {
+            result.totalSkipped++;
+            continue;
+        }
+        batch.push({
+            id: patternId,
+            vector: new Float32Array(embedding),
+        });
+        // Flush batch when full
+        if (batch.length >= batchSize) {
+            const batchResult = flushBatch(rvfAdapter, batch, result);
+            if (!batchResult)
+                break; // Fatal error
+            batch = [];
+        }
+        // Progress logging
+        if ((i + 1) % progressInterval === 0) {
+            console.log(`[RVF Migration] Progress: ${i + 1}/${allEmbeddings.length} ` +
+                `(migrated: ${result.totalMigrated}, skipped: ${result.totalSkipped})`);
+        }
+    }
+    // Flush remaining
+    if (batch.length > 0) {
+        flushBatch(rvfAdapter, batch, result);
+    }
+    result.durationMs = performance.now() - startTime;
+    console.log(`[RVF Migration] Complete: ${result.totalMigrated} migrated, ` +
+        `${result.totalSkipped} skipped, ${result.errors.length} errors ` +
+        `in ${result.durationMs.toFixed(0)}ms`);
+    return result;
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function flushBatch(adapter, batch, result) {
+    try {
+        const ingestResult = adapter.ingest(batch);
+        result.totalMigrated += ingestResult.accepted;
+        if (ingestResult.rejected > 0) {
+            result.errors.push(`Batch rejected ${ingestResult.rejected} of ${batch.length} vectors`);
+        }
+        return true;
+    }
+    catch (error) {
+        result.errors.push(`Batch ingest failed: ${error}`);
+        return false;
+    }
+}
+//# sourceMappingURL=rvf-pattern-migration.js.map

package/dist/learning/rvf-pattern-store.d.ts

@@ -0,0 +1,66 @@
+/**
+ * RVF-Backed Pattern Store (ADR-066)
+ *
+ * Implements IPatternStore using @ruvector/rvf-node for persistent HNSW
+ * vector indexing. Eliminates cold-start index rebuild (SQLite BLOB →
+ * in-memory HNSW) by storing vectors in the RVF native format with
+ * progressive 3-layer indexing.
+ *
+ * Pattern metadata remains in SQLite (via the existing SQLitePatternStore);
+ * only vector storage and search moves to RVF.
+ *
+ * @module learning/rvf-pattern-store
+ */
+import type { Result } from '../shared/types/index.js';
+import type { RvfNativeAdapter } from '../integrations/ruvector/rvf-native-adapter.js';
+import { type QEPattern, type CreateQEPatternOptions } from './qe-patterns.js';
+import type { IPatternStore, PatternStoreConfig, PatternStoreStats, PatternSearchOptions, PatternSearchResult } from './pattern-store.js';
+export interface RvfPatternStoreConfig {
+    /** Path to the .rvf file for vector storage */
+    rvfPath: string;
+    /** Base PatternStore config (for metadata, thresholds) */
+    base: PatternStoreConfig;
+}
+/**
+ * Pattern store backed by @ruvector/rvf-node for persistent HNSW.
+ *
+ * Vectors live in a .rvf file (persistent HNSW, no cold-start rebuild).
+ * Metadata (pattern fields, FTS5) lives in SQLite via sqliteStore delegate.
+ */
+export declare class RvfPatternStore implements IPatternStore {
+    private readonly createAdapter;
+    private readonly config;
+    private readonly rvfPath;
+    private adapter;
+    private sqliteStore;
+    private initialized;
+    private rvfInitError;
+    private searchOps;
+    private totalSearchMs;
+    constructor(createAdapter: (path: string, dim: number) => RvfNativeAdapter, config?: Partial<RvfPatternStoreConfig>);
+    /**
+     * Attach SQLite persistence for metadata (pattern fields, FTS5).
+     * Must be called before initialize() if SQLite metadata is desired.
+     */
+    setSqliteStore(store: import('./sqlite-persistence.js').SQLitePatternStore): void;
+    /** Get the underlying RVF adapter (for COW branching, migration, etc.) */
+    getAdapter(): RvfNativeAdapter | null;
+    initialize(): Promise<void>;
+    dispose(): Promise<void>;
+    store(pattern: QEPattern): Promise<Result<string>>;
+    create(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;
+    get(id: string): Promise<QEPattern | null>;
+    search(query: string | number[], options?: PatternSearchOptions): Promise<Result<PatternSearchResult[]>>;
+    recordUsage(id: string, success: boolean): Promise<Result<void>>;
+    promote(id: string): Promise<Result<void>>;
+    delete(id: string): Promise<Result<void>>;
+    getStats(): Promise<PatternStoreStats>;
+    cleanup(): Promise<{
+        removed: number;
+        promoted: number;
+    }>;
+    private ensureInitialized;
+    private matchesFilters;
+    private calculateReuseInfo;
+}
+//# sourceMappingURL=rvf-pattern-store.d.ts.map