agentic-qe 3.8.11 → 3.8.13

package/dist/learning/pattern-store.js

@@ -10,6 +10,34 @@ import { ok, err } from '../shared/types/index.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 { DeltaTracker } from '../integrations/ruvector/delta-tracker.js';
+import { createHopfieldMemory } from '../integrations/ruvector/hopfield-memory.js';
+// ============================================================================
+// R1: HDC Fingerprint Singleton (lazy-initialized)
+// ============================================================================
+/** Module-level HDC fingerprinter, created on first use */
+let hdcFingerprinter = null;
+function getHdcFingerprinter() {
+    if (!hdcFingerprinter) {
+        hdcFingerprinter = createHdcFingerprinter({ dimensions: 10000 });
+    }
+    return hdcFingerprinter;
+}
+// ============================================================================
+// R5: Hopfield Memory Singleton (lazy-initialized, dimension-aware)
+// ============================================================================
+/** Module-level Hopfield memory for exact pattern recall */
+let hopfieldMemory = null;
+let hopfieldDimension = 0;
+function getHopfieldMemory(dimension) {
+    if (!hopfieldMemory || hopfieldDimension !== dimension) {
+        hopfieldMemory = createHopfieldMemory({ dimension, maxPatterns: 10000 });
+        hopfieldDimension = dimension;
+    }
+    return hopfieldMemory;
+}
 /**
  * Default pattern store configuration
  */
@@ -67,6 +95,10 @@ export class PatternStore {
     hnswIndex = null;
     hnswAvailable = false;
     hnswInitPromise = null;
+    // R1: HDC fingerprint cache (pattern ID -> fingerprint vector)
+    hdcCache = new Map();
+    // R3: Delta event sourcing tracker (lazy-initialized with SQLite)
+    deltaTracker = null;
     // Statistics
     stats = {
         searchOperations: 0,
@@ -86,6 +118,18 @@ export class PatternStore {
      */
     setSqliteStore(store) {
         this.sqliteStore = store;
+        // R3: Initialize DeltaTracker using the same SQLite DB instance
+        if (isDeltaEventSourcingEnabled() && !this.deltaTracker) {
+            try {
+                const db = store.getDb();
+                this.deltaTracker = new DeltaTracker(db);
+                this.deltaTracker.initialize();
+                console.log('[PatternStore] Delta event sourcing initialized');
+            }
+            catch (e) {
+                console.warn('[PatternStore] Delta tracker init failed:', e instanceof Error ? e.message : e);
+            }
+        }
         // Load patterns from SQLite if we're already initialized
         // (setSqliteStore is called after initialize() in QEReasoningBank)
         // Store promise so concurrent store/search calls can await it
@@ -278,6 +322,7 @@ export class PatternStore {
         this.domainIndex.get(pattern.qeDomain)?.delete(pattern.id);
         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
     }
     /**
      * Store a new pattern
@@ -340,6 +385,55 @@ export class PatternStore {
                 }
             }
         }
+        // R1: Compute and cache HDC fingerprint for fast pre-filtering
+        if (isHDCFingerprintingEnabled()) {
+            try {
+                const hdc = getHdcFingerprinter();
+                const fp = hdc.fingerprint({
+                    id: pattern.id,
+                    domain: pattern.qeDomain,
+                    type: pattern.patternType,
+                    content: pattern.description,
+                });
+                this.hdcCache.set(pattern.id, fp.vector);
+            }
+            catch (error) {
+                console.debug(`[PatternStore] HDC fingerprint failed for ${pattern.id}:`, toErrorMessage(error));
+            }
+        }
+        // R5: Store embedding in Hopfield memory for exact recall
+        if (isHopfieldMemoryEnabled() && pattern.embedding) {
+            try {
+                const hopfield = getHopfieldMemory(pattern.embedding.length);
+                hopfield.store(new Float32Array(pattern.embedding), {
+                    id: pattern.id,
+                    name: pattern.name,
+                    domain: pattern.qeDomain,
+                });
+            }
+            catch (error) {
+                console.debug(`[PatternStore] Hopfield store failed for ${pattern.id}:`, toErrorMessage(error));
+            }
+        }
+        // R3: Create genesis delta event for new patterns
+        if (isDeltaEventSourcingEnabled() && this.deltaTracker) {
+            try {
+                const snapshot = {
+                    id: pattern.id,
+                    name: pattern.name,
+                    confidence: pattern.confidence,
+                    qualityScore: pattern.qualityScore,
+                    usageCount: pattern.usageCount,
+                    successRate: pattern.successRate,
+                    tier: pattern.tier,
+                };
+                this.deltaTracker.createGenesis(pattern.id, snapshot);
+            }
+            catch (error) {
+                // Genesis may already exist if pattern was re-stored; log at debug level
+                console.debug(`[PatternStore] Delta genesis for ${pattern.id}:`, toErrorMessage(error));
+            }
+        }
         return ok(pattern.id);
     }
     /**
@@ -429,6 +523,34 @@ export class PatternStore {
         const limit = options.limit || 10;
         const results = [];
         try {
+            // R5: Exact recall via Hopfield — check for high-confidence exact match
+            if (Array.isArray(query) && isHopfieldMemoryEnabled()) {
+                try {
+                    const hopfield = getHopfieldMemory(query.length);
+                    if (hopfield.getPatternCount() > 0) {
+                        const recallResult = hopfield.recall(new Float32Array(query));
+                        if (recallResult && recallResult.similarity > 0.98) {
+                            const patternId = recallResult.metadata.id;
+                            const pattern = await this.get(patternId);
+                            if (pattern && this.matchesFilters(pattern, options)) {
+                                const reuseInfo = this.calculateReuseInfo(pattern, recallResult.similarity);
+                                results.push({
+                                    pattern,
+                                    score: recallResult.similarity,
+                                    matchType: 'vector',
+                                    similarity: recallResult.similarity,
+                                    canReuse: reuseInfo.canReuse,
+                                    estimatedTokenSavings: reuseInfo.estimatedTokenSavings,
+                                    reuseConfidence: reuseInfo.reuseConfidence,
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    console.debug('[PatternStore] Hopfield recall failed:', toErrorMessage(error));
+                }
+            }
             // Vector search if query is embedding and HNSW available (lazy-load)
             if (Array.isArray(query) && options.useVectorSearch !== false) {
                 const hnsw = await this.ensureHNSW();
@@ -552,7 +674,37 @@ export class PatternStore {
         else {
             candidates = new Set(this.patternCache.keys());
         }
-        for (const id of candidates) {
+        // R1: HDC fast-path pre-filter — sort candidates by Hamming similarity
+        // so we process the most likely matches first (reduces wasted iterations)
+        let orderedCandidates = [...candidates];
+        if (isHDCFingerprintingEnabled() && queryLower && this.hdcCache.size > 0) {
+            try {
+                const hdc = getHdcFingerprinter();
+                const queryFp = hdc.fingerprint({
+                    id: 'query',
+                    domain: options.domain ?? 'unknown',
+                    type: options.patternType ?? 'unknown',
+                    content: query,
+                });
+                // Score each candidate by Hamming similarity and sort descending
+                const scored = orderedCandidates
+                    .filter(id => this.hdcCache.has(id))
+                    .map(id => ({
+                    id,
+                    similarity: hdc.similarity(queryFp.vector, this.hdcCache.get(id)),
+                }));
+                scored.sort((a, b) => b.similarity - a.similarity);
+                // Reorder by HDC similarity but never eliminate — text match is authoritative
+                const hdcOrdered = scored.map(s => s.id);
+                // Add back candidates without fingerprints at the end
+                const unfingerprinted = orderedCandidates.filter(id => !this.hdcCache.has(id));
+                orderedCandidates = [...hdcOrdered, ...unfingerprinted];
+            }
+            catch {
+                // HDC pre-filter is best-effort; fall through to normal search
+            }
+        }
+        for (const id of orderedCandidates) {
             if (results.length >= limit)
                 break;
             const pattern = this.patternCache.get(id);
@@ -717,6 +869,33 @@ export class PatternStore {
                 console.warn(`[PatternStore] SQLite recordUsage failed for ${id}:`, toErrorMessage(error));
             }
         }
+        // R3: Record delta event for the pattern update
+        if (isDeltaEventSourcingEnabled() && this.deltaTracker) {
+            try {
+                const before = {
+                    id: pattern.id,
+                    name: pattern.name,
+                    confidence: pattern.confidence,
+                    qualityScore: pattern.qualityScore,
+                    usageCount: pattern.usageCount,
+                    successRate: pattern.successRate,
+                    tier: pattern.tier,
+                };
+                const after = {
+                    id: updated.id,
+                    name: updated.name,
+                    confidence: updated.confidence,
+                    qualityScore: updated.qualityScore,
+                    usageCount: updated.usageCount,
+                    successRate: updated.successRate,
+                    tier: updated.tier,
+                };
+                this.deltaTracker.recordDelta(id, before, after, { success });
+            }
+            catch (error) {
+                console.debug(`[PatternStore] Delta recordDelta for ${id}:`, toErrorMessage(error));
+            }
+        }
         // Check for promotion (ADR-052: shouldPromotePattern returns PromotionCheck object)
         const promotionCheck = shouldPromotePattern(updated);
         const shouldPromote = promotionCheck.meetsUsageCriteria &&
@@ -948,6 +1127,13 @@ export class PatternStore {
         this.domainIndex.clear();
         this.typeIndex.clear();
         this.tierIndex.clear();
+        this.hdcCache.clear(); // R1: cleanup
+        this.deltaTracker = null; // R3: cleanup
+        if (hopfieldMemory) {
+            hopfieldMemory.clear();
+            hopfieldMemory = null;
+            hopfieldDimension = 0;
+        } // R5: cleanup
         this.initialized = false;
     }
 }

package/dist/learning/sqlite-persistence.d.ts

@@ -53,6 +53,8 @@ export declare class SQLitePatternStore {
     private initialized;
     private unifiedMemory;
     constructor(config?: Partial<SQLitePersistenceConfig>);
+    /** Expose the underlying database for cross-module schema extensions (R8 citations, R3 deltas) */
+    getDatabase(): DatabaseType | null;
     /**
      * Initialize the database
      */

package/dist/learning/sqlite-persistence.js

@@ -64,6 +64,10 @@ export class SQLitePatternStore {
     constructor(config = {}) {
         this.config = { ...DEFAULT_SQLITE_CONFIG, ...config };
     }
+    /** Expose the underlying database for cross-module schema extensions (R8 citations, R3 deltas) */
+    getDatabase() {
+        return this.db;
+    }
     /**
      * Initialize the database
      */