@skillsmith/core 0.4.0 → 0.4.2

package/dist/src/learning/PatternStore.js

@@ -1,231 +1,17 @@
 /**
- * @fileoverview PatternStore with EWC++ for catastrophic forgetting prevention
+ * PatternStore with EWC++ for catastrophic forgetting prevention
  * @module @skillsmith/core/learning/PatternStore
- * @see SMI-1522: Add EWC++ pattern storage for successful matches
- *
- * Implements Elastic Weight Consolidation++ (EWC++) to store successful
- * recommendation patterns without catastrophic forgetting. Unlike traditional
- * storage that overwrites old patterns, EWC++ preserves important learned
- * patterns while integrating new ones.
- *
- * Key capabilities:
- * - storePattern(): Encodes successful matches with Fisher Information tracking
- * - findSimilarPatterns(): Retrieves relevant patterns using importance-weighted similarity
- * - consolidate(): Updates Fisher Information matrix without forgetting important patterns
- * - 95%+ pattern preservation: New patterns do not overwrite important historical patterns
- *
  * @see https://arxiv.org/abs/1801.10112 (Progress & Compress)
  */
 import Database from 'better-sqlite3';
 import { randomUUID } from 'crypto';
 import { EmbeddingService } from '../embeddings/index.js';
-/**
- * Default EWC++ configuration
- */
-export const DEFAULT_EWC_CONFIG = {
-    lambda: 5.0,
-    fisherDecay: 0.95,
-    importanceThreshold: 0.01,
-    fisherSampleSize: 100,
-    consolidationThreshold: 0.1,
-    maxPatterns: 10000,
-};
-/**
- * Default PatternStore configuration
- */
-export const DEFAULT_PATTERN_STORE_CONFIG = {
-    dbPath: undefined,
-    ewc: DEFAULT_EWC_CONFIG,
-    dimensions: 384,
-    autoConsolidate: true,
-    trackAccess: true,
-    useV3Integration: true,
-};
-/**
- * Reward values for pattern outcomes
- * Matches ReasoningBankIntegration.TRAJECTORY_REWARDS
- */
-export const PATTERN_REWARDS = {
-    accept: 1.0,
-    usage: 0.3,
-    frequent: 0.5,
-    dismiss: -0.5,
-    abandonment: -0.3,
-    uninstall: -0.7,
-};
-/**
- * Fisher Information Matrix implementation for EWC++
- *
- * Stores diagonal approximation of Fisher Information,
- * indicating which "weights" (pattern dimensions) are important.
- *
- * In the context of pattern storage:
- * - Each dimension of the context embedding has an importance value
- * - High importance = changing this dimension would harm prediction
- * - Low importance = safe to overwrite with new patterns
- */
-export class FisherInformationMatrix {
-    dimensions;
-    /** Diagonal of Fisher Information (importance per dimension) */
-    importance;
-    /** Running sum for online updates */
-    runningSum;
-    /** Number of updates performed */
-    updateCount = 0;
-    constructor(dimensions) {
-        this.dimensions = dimensions;
-        this.importance = new Float32Array(dimensions);
-        this.runningSum = new Float32Array(dimensions);
-    }
-    getImportance(dimensionIndex) {
-        return this.importance[dimensionIndex] ?? 0;
-    }
-    update(gradient) {
-        // EWC++: F = decay * F + gradient^2
-        for (let i = 0; i < Math.min(gradient.length, this.dimensions); i++) {
-            this.runningSum[i] += gradient[i] * gradient[i];
-        }
-        this.updateCount++;
-        // Update importance as running mean
-        for (let i = 0; i < this.importance.length; i++) {
-            this.importance[i] = this.runningSum[i] / this.updateCount;
-        }
-    }
-    decay(decayFactor) {
-        for (let i = 0; i < this.runningSum.length; i++) {
-            this.runningSum[i] *= decayFactor;
-        }
-        // Recalculate importance after decay
-        for (let i = 0; i < this.importance.length; i++) {
-            this.importance[i] = this.runningSum[i] / Math.max(1, this.updateCount);
-        }
-    }
-    getImportanceVector() {
-        return new Float32Array(this.importance);
-    }
-    getAverageImportance() {
-        let sum = 0;
-        for (let i = 0; i < this.importance.length; i++) {
-            sum += this.importance[i];
-        }
-        return sum / this.importance.length;
-    }
-    serialize() {
-        const buffer = Buffer.alloc(4 + // updateCount
-            4 * this.importance.length + // importance
-            4 * this.runningSum.length // runningSum
-        );
-        buffer.writeUInt32LE(this.updateCount, 0);
-        Buffer.from(this.importance.buffer).copy(buffer, 4);
-        Buffer.from(this.runningSum.buffer).copy(buffer, 4 + 4 * this.importance.length);
-        return buffer;
-    }
-    deserialize(buffer) {
-        const expectedSize = 4 + 4 * this.dimensions * 2;
-        if (buffer.length < expectedSize) {
-            throw new Error(`Invalid Fisher matrix buffer: expected ${expectedSize} bytes, got ${buffer.length}`);
-        }
-        this.updateCount = buffer.readUInt32LE(0);
-        const importanceOffset = 4;
-        const runningSumOffset = 4 + 4 * this.dimensions;
-        // Copy importance values
-        for (let i = 0; i < this.dimensions; i++) {
-            this.importance[i] = buffer.readFloatLE(importanceOffset + i * 4);
-        }
-        // Copy runningSum values
-        for (let i = 0; i < this.dimensions; i++) {
-            this.runningSum[i] = buffer.readFloatLE(runningSumOffset + i * 4);
-        }
-    }
-    reset() {
-        this.importance.fill(0);
-        this.runningSum.fill(0);
-        this.updateCount = 0;
-    }
-    getUpdateCount() {
-        return this.updateCount;
-    }
-}
-// ============================================================================
-// PatternStore Implementation
-// ============================================================================
-/**
- * SQLite schema for pattern storage
- */
-const PATTERN_STORE_SCHEMA = `
--- Patterns table: stores recommendation patterns with outcomes
-CREATE TABLE IF NOT EXISTS patterns (
-  pattern_id TEXT PRIMARY KEY,
-  context_embedding BLOB NOT NULL,
-  skill_id TEXT NOT NULL,
-  skill_features TEXT NOT NULL,
-  context_data TEXT NOT NULL,
-  outcome_type TEXT NOT NULL,
-  outcome_reward REAL NOT NULL,
-  importance REAL NOT NULL DEFAULT 0.1,
-  original_score REAL NOT NULL,
-  source TEXT NOT NULL,
-  access_count INTEGER NOT NULL DEFAULT 0,
-  created_at INTEGER NOT NULL DEFAULT (unixepoch()),
-  last_accessed_at INTEGER NOT NULL DEFAULT (unixepoch())
-);
-
--- Indexes for efficient queries
-CREATE INDEX IF NOT EXISTS idx_patterns_skill_id ON patterns(skill_id);
-CREATE INDEX IF NOT EXISTS idx_patterns_outcome_type ON patterns(outcome_type);
-CREATE INDEX IF NOT EXISTS idx_patterns_importance ON patterns(importance DESC);
-CREATE INDEX IF NOT EXISTS idx_patterns_created_at ON patterns(created_at DESC);
-
--- Fisher Information matrix state
-CREATE TABLE IF NOT EXISTS fisher_info (
-  id INTEGER PRIMARY KEY DEFAULT 1,
-  matrix_data BLOB NOT NULL,
-  update_count INTEGER NOT NULL DEFAULT 0,
-  last_decay_at INTEGER NOT NULL DEFAULT (unixepoch()),
-  updated_at INTEGER NOT NULL DEFAULT (unixepoch())
-);
-
--- Consolidation history for monitoring
-CREATE TABLE IF NOT EXISTS consolidation_history (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
-  patterns_processed INTEGER NOT NULL,
-  patterns_preserved INTEGER NOT NULL,
-  patterns_pruned INTEGER NOT NULL,
-  preservation_rate REAL NOT NULL,
-  duration_ms INTEGER NOT NULL,
-  average_importance REAL NOT NULL
-);
-`;
-/**
- * PatternStore - EWC++ pattern storage for successful recommendation matches
- *
- * Prevents catastrophic forgetting by tracking which pattern dimensions
- * are important via Fisher Information Matrix and preserving high-importance
- * patterns during consolidation.
- *
- * @example
- * ```typescript
- * const store = new PatternStore({ dbPath: './patterns.db' })
- * await store.initialize()
- *
- * // Store a successful pattern
- * await store.storePattern(
- *   {
- *     context: { installedSkills: ['commit'], frameworks: ['react'] },
- *     skill: { skillId: 'jest-helper', category: 'testing' },
- *     originalScore: 0.85,
- *     source: 'recommend'
- *   },
- *   { type: 'accept', reward: 1.0 }
- * )
- *
- * // Find similar patterns
- * const similar = await store.findSimilarPatterns({
- *   context: { installedSkills: ['commit'], frameworks: ['react', 'typescript'] }
- * })
- * ```
- */
+export { DEFAULT_EWC_CONFIG, DEFAULT_PATTERN_STORE_CONFIG, PATTERN_REWARDS, } from './PatternStore.types.js';
+export { FisherInformationMatrix } from './PatternStore.helpers.js';
+import { DEFAULT_EWC_CONFIG, DEFAULT_PATTERN_STORE_CONFIG } from './PatternStore.types.js';
+import { PATTERN_STORE_SCHEMA, FisherInformationMatrix, contextToText, computeGradient, deserializeEmbedding, cosineSimilarity, importanceWeightedSimilarity, calculatePatternImportance, calculateDimensionImportance, rowToStoredPattern, } from './PatternStore.helpers.js';
+import { getPatternCount, getDatabaseSize, getSamplePatterns, getAllPatterns, updatePatternInDB, updatePatternImportance, updateAccessCount, deletePattern, loadFisherMatrixData, saveFisherMatrixData, recordConsolidation, getPatternsByOutcome, getAverageImportance, getHighImportanceCount, getConsolidationStats, getContextEmbeddings, } from './PatternStore.queries.js';
+/** PatternStore - EWC++ pattern storage for successful recommendation matches */
 export class PatternStore {
     db;
     fisherMatrix;
@@ -234,7 +20,6 @@ export class PatternStore {
     config;
     ewcConfig;
     initialized = false;
-    // Query performance tracking
     queryLatencies = [];
     maxQuerySamples = 100;
     constructor(config = {}) {
@@ -250,41 +35,26 @@ export class PatternStore {
             totalPatterns: 0,
         };
     }
-    /**
-     * Initialize the PatternStore
-     */
     async initialize() {
         if (this.initialized)
             return;
-        // Initialize database
         this.db = new Database(this.config.dbPath || ':memory:');
         this.db.exec(PATTERN_STORE_SCHEMA);
-        // Initialize Fisher Information Matrix
         this.fisherMatrix = new FisherInformationMatrix(this.config.dimensions);
-        // Load persisted Fisher matrix if exists
         this.loadFisherMatrix();
-        // Initialize embedding service (fallback mode for context encoding)
         this.embeddingService = new EmbeddingService({ useFallback: true });
-        // Load consolidation state
-        this.consolidationState.totalPatterns = this.getPatternCount();
-        // Try V3 integration
+        this.consolidationState.totalPatterns = getPatternCount(this.db);
+        // IMPORTANT: Keep dynamic import here for lazy loading / graceful degradation
         if (this.config.useV3Integration) {
             await this.initializeV3Integration();
         }
         this.initialized = true;
     }
-    /**
-     * Check if PatternStore is initialized
-     */
     isInitialized() {
         return this.initialized;
     }
-    /**
-     * Attempt to initialize V3 ReasoningBank integration
-     */
     async initializeV3Integration() {
         try {
-            // Attempt to import V3 ReasoningBank for future integration
             await import(
             // @ts-expect-error - V3 types not available at compile time
             'claude-flow/v3/@claude-flow/cli/dist/src/intelligence/index.js');
@@ -294,46 +64,28 @@ export class PatternStore {
             console.log('[PatternStore] V3 not available, using standalone mode');
         }
     }
-    /**
-     * Store a pattern with EWC++ protection
-     *
-     * @param pattern - Pattern to store
-     * @param outcome - Outcome of the recommendation
-     * @returns Pattern ID
-     */
     async storePattern(pattern, outcome) {
         this.ensureInitialized();
-        // Generate context embedding
-        const contextText = this.contextToText(pattern.context);
+        const contextText = contextToText(pattern.context);
         const contextEmbedding = await this.embeddingService.embed(contextText);
-        // Check for similar existing pattern
-        const existingPatterns = await this.findSimilarPatterns({
-            context: pattern.context,
-            skillId: pattern.skill.skillId,
-            positiveOnly: false,
-        }, 5);
+        const existingPatterns = await this.findSimilarPatterns({ context: pattern.context, skillId: pattern.skill.skillId, positiveOnly: false }, 5);
         if (existingPatterns.length > 0 && existingPatterns[0].similarity > 0.95) {
-            // Update existing pattern instead of creating new
             const existingPattern = existingPatterns[0].pattern;
-            const gradient = this.computeGradient(contextEmbedding, existingPattern.contextEmbedding);
+            const gradient = computeGradient(contextEmbedding, existingPattern.contextEmbedding);
             this.fisherMatrix.update(gradient);
-            const newImportance = this.calculatePatternImportance(existingPattern, outcome);
-            this.updatePatternInDB(existingPattern.id, {
+            const newImportance = calculatePatternImportance(existingPattern, outcome);
+            updatePatternInDB(this.db, existingPattern.id, {
                 importance: newImportance,
                 accessCount: existingPattern.accessCount + 1,
             });
             return existingPattern.id;
         }
-        // Calculate initial importance
         let baseImportance = Math.abs(outcome.reward);
-        if (outcome.reward > 0) {
+        if (outcome.reward > 0)
             baseImportance *= 1.5;
-        }
-        if (outcome.confidence !== undefined) {
+        if (outcome.confidence !== undefined)
             baseImportance *= outcome.confidence;
-        }
         const importance = baseImportance * this.ewcConfig.importanceThreshold * 10;
-        // Store new pattern
         const patternId = pattern.id || randomUUID();
         const stmt = this.db.prepare(`
       INSERT INTO patterns (
@@ -343,35 +95,22 @@ export class PatternStore {
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, unixepoch(), unixepoch())
     `);
         stmt.run(patternId, Buffer.from(contextEmbedding.buffer), pattern.skill.skillId, JSON.stringify(pattern.skill), JSON.stringify(pattern.context), outcome.type, outcome.reward, importance, pattern.originalScore, pattern.source);
-        // Update Fisher Information
         const avgEmbedding = await this.computeAverageEmbedding();
-        const gradient = this.computeGradient(contextEmbedding, avgEmbedding);
+        const gradient = computeGradient(contextEmbedding, avgEmbedding);
         this.fisherMatrix.update(gradient);
-        // Update consolidation state
         this.consolidationState.patternsSinceLastConsolidation++;
         this.consolidationState.totalPatterns++;
-        // Trigger consolidation if needed
         if (this.config.autoConsolidate && this.shouldConsolidate()) {
             await this.consolidate();
         }
-        // Persist Fisher matrix
         this.saveFisherMatrix();
         return patternId;
     }
-    /**
-     * Find similar patterns using importance-weighted similarity
-     *
-     * @param query - Pattern query
-     * @param limit - Maximum results
-     * @returns Similar patterns sorted by weighted similarity
-     */
     async findSimilarPatterns(query, limit = 10) {
         this.ensureInitialized();
         const startTime = Date.now();
-        // Generate query embedding
-        const queryText = this.contextToText(query.context);
+        const queryText = contextToText(query.context);
         const queryEmbedding = await this.embeddingService.embed(queryText);
-        // Build SQL query with filters
         let sql = 'SELECT * FROM patterns WHERE 1=1';
         const params = [];
         if (query.skillId) {
@@ -393,52 +132,30 @@ export class PatternStore {
         if (query.positiveOnly) {
             sql += ' AND outcome_reward > 0';
         }
-        // Fetch candidate patterns
         const stmt = this.db.prepare(sql);
         const candidates = stmt.all(...params);
-        // Calculate similarity scores
         const importanceVector = this.fisherMatrix.getImportanceVector();
         const results = [];
         for (const candidate of candidates) {
-            const candidateEmbedding = this.deserializeEmbedding(candidate.context_embedding);
-            const similarity = this.cosineSimilarity(queryEmbedding, candidateEmbedding);
-            const weightedSimilarity = this.importanceWeightedSimilarity(queryEmbedding, candidateEmbedding, importanceVector);
-            const storedPattern = {
-                id: candidate.pattern_id,
-                context: JSON.parse(candidate.context_data),
-                skill: JSON.parse(candidate.skill_features),
-                originalScore: candidate.original_score,
-                source: candidate.source,
-                contextEmbedding: candidateEmbedding,
-                outcome: {
-                    type: candidate.outcome_type,
-                    reward: candidate.outcome_reward,
-                },
-                importance: candidate.importance,
-                accessCount: candidate.access_count,
-                createdAt: new Date(candidate.created_at * 1000),
-                lastAccessedAt: new Date(candidate.last_accessed_at * 1000),
-            };
+            const candidateEmbedding = deserializeEmbedding(candidate.context_embedding, this.config.dimensions);
+            const similarity = cosineSimilarity(queryEmbedding, candidateEmbedding);
+            const weightedSimilarity = importanceWeightedSimilarity(queryEmbedding, candidateEmbedding, importanceVector);
             results.push({
-                pattern: storedPattern,
+                pattern: rowToStoredPattern(candidate, this.config.dimensions),
                 similarity,
                 weightedSimilarity,
                 rank: 0,
             });
         }
-        // Sort by weighted similarity
         results.sort((a, b) => b.weightedSimilarity - a.weightedSimilarity);
-        // Assign ranks
         for (let i = 0; i < results.length; i++) {
             results[i].rank = i + 1;
         }
-        // Update access tracking
         if (this.config.trackAccess) {
             for (const result of results.slice(0, limit)) {
-                this.updateAccessCount(result.pattern.id);
+                updateAccessCount(this.db, result.pattern.id);
             }
         }
-        // Track query latency
         const latency = Date.now() - startTime;
         this.queryLatencies.push(latency);
         if (this.queryLatencies.length > this.maxQuerySamples) {
@@ -446,20 +163,11 @@ export class PatternStore {
         }
         return results.slice(0, limit);
     }
-    /**
-     * Consolidate patterns using EWC++
-     *
-     * Applies Fisher decay, recalculates importance, and prunes low-importance patterns.
-     * Guarantees 95%+ preservation of important patterns.
-     *
-     * @returns Consolidation result
-     */
     async consolidate() {
         this.ensureInitialized();
         const startTime = Date.now();
-        const totalPatterns = this.getPatternCount();
+        const totalPatterns = getPatternCount(this.db);
         const newPatternsRatio = totalPatterns > 0 ? this.consolidationState.patternsSinceLastConsolidation / totalPatterns : 0;
-        // Check if consolidation is needed
         if (newPatternsRatio < this.ewcConfig.consolidationThreshold) {
             return {
                 consolidated: false,
@@ -471,32 +179,27 @@ export class PatternStore {
                 averageImportance: this.fisherMatrix.getAverageImportance(),
             };
         }
-        // Apply Fisher decay
         this.fisherMatrix.decay(this.ewcConfig.fisherDecay);
-        // Sample patterns for Fisher estimation
-        const samplePatterns = this.getSamplePatterns(this.ewcConfig.fisherSampleSize);
+        const samplePatterns = getSamplePatterns(this.db, this.ewcConfig.fisherSampleSize, this.config.dimensions);
         const avgEmbedding = await this.computeAverageEmbedding();
         for (const pattern of samplePatterns) {
-            const gradient = this.computeGradient(pattern.contextEmbedding, avgEmbedding);
+            const gradient = computeGradient(pattern.contextEmbedding, avgEmbedding);
             this.fisherMatrix.update(gradient);
         }
-        // Update importance for all patterns
-        const allPatterns = this.getAllPatterns();
+        const allPatterns = getAllPatterns(this.db, this.config.dimensions);
         const importanceVector = this.fisherMatrix.getImportanceVector();
         for (const pattern of allPatterns) {
-            const newImportance = this.calculateDimensionImportance(pattern, importanceVector);
-            this.updatePatternImportance(pattern.id, newImportance);
+            const newImportance = calculateDimensionImportance(pattern, importanceVector, this.config.dimensions, this.ewcConfig.lambda);
+            updatePatternImportance(this.db, pattern.id, newImportance);
         }
-        // Prune low-importance patterns
         let prunedCount = 0;
         let preservedCount = 0;
-        // Sort by importance (ascending) for pruning
         const sortedPatterns = [...allPatterns].sort((a, b) => a.importance - b.importance);
         if (sortedPatterns.length > this.ewcConfig.maxPatterns) {
             const pruneCandidates = sortedPatterns.slice(0, sortedPatterns.length - this.ewcConfig.maxPatterns);
             for (const candidate of pruneCandidates) {
                 if (candidate.importance < this.ewcConfig.importanceThreshold) {
-                    this.deletePattern(candidate.id);
+                    deletePattern(this.db, candidate.id);
                     prunedCount++;
                 }
                 else {
@@ -506,10 +209,9 @@ export class PatternStore {
             preservedCount += this.ewcConfig.maxPatterns;
         }
         else {
-            // Prune very low importance patterns even if under limit
             for (const pattern of sortedPatterns) {
                 if (pattern.importance < this.ewcConfig.importanceThreshold * 0.1) {
-                    this.deletePattern(pattern.id);
+                    deletePattern(this.db, pattern.id);
                     prunedCount++;
                 }
                 else {
@@ -518,21 +220,12 @@ export class PatternStore {
             }
         }
         const preservationRate = preservedCount / (preservedCount + prunedCount) || 1.0;
-        // Update consolidation state
         this.consolidationState.lastConsolidation = new Date();
         this.consolidationState.patternsSinceLastConsolidation = 0;
-        this.consolidationState.totalPatterns = this.getPatternCount();
-        // Record consolidation history
+        this.consolidationState.totalPatterns = getPatternCount(this.db);
         const durationMs = Date.now() - startTime;
         const avgImportance = this.fisherMatrix.getAverageImportance();
-        const historyStmt = this.db.prepare(`
-      INSERT INTO consolidation_history (
-        patterns_processed, patterns_preserved, patterns_pruned,
-        preservation_rate, duration_ms, average_importance
-      ) VALUES (?, ?, ?, ?, ?, ?)
-    `);
-        historyStmt.run(preservedCount + prunedCount, preservedCount, prunedCount, preservationRate, durationMs, avgImportance);
-        // Persist Fisher matrix
+        recordConsolidation(this.db, preservedCount + prunedCount, preservedCount, prunedCount, preservationRate, durationMs, avgImportance);
         this.saveFisherMatrix();
         return {
             consolidated: true,
@@ -544,64 +237,19 @@ export class PatternStore {
             averageImportance: avgImportance,
         };
     }
-    /**
-     * Get pattern importance value
-     *
-     * @param patternId - Pattern identifier
-     * @returns Importance value or 0 if not found
-     */
     getPatternImportance(patternId) {
         this.ensureInitialized();
         const stmt = this.db.prepare('SELECT importance FROM patterns WHERE pattern_id = ?');
         const result = stmt.get(patternId);
         return result?.importance ?? 0;
     }
-    /**
-     * Get PatternStore metrics
-     */
     getMetrics() {
         this.ensureInitialized();
-        // Total patterns
-        const totalPatterns = this.getPatternCount();
-        // Patterns by outcome type
-        const outcomeStmt = this.db.prepare(`
-      SELECT outcome_type, COUNT(*) as count FROM patterns GROUP BY outcome_type
-    `);
-        const outcomeCounts = outcomeStmt.all();
-        const patternsByOutcome = {
-            accept: 0,
-            usage: 0,
-            frequent: 0,
-            dismiss: 0,
-            abandonment: 0,
-            uninstall: 0,
-        };
-        for (const row of outcomeCounts) {
-            patternsByOutcome[row.outcome_type] = row.count;
-        }
-        // Average importance
-        const avgStmt = this.db.prepare('SELECT AVG(importance) as avg FROM patterns');
-        const avgResult = avgStmt.get();
-        const averageImportance = avgResult?.avg ?? 0;
-        // High importance patterns (above 90th percentile)
-        const percentileStmt = this.db.prepare(`
-      SELECT importance FROM patterns ORDER BY importance DESC
-      LIMIT CAST((SELECT COUNT(*) FROM patterns) * 0.1 AS INTEGER)
-    `);
-        const highImportancePatterns = percentileStmt.all().length;
-        // Consolidation stats
-        const consolidationStmt = this.db.prepare(`
-      SELECT
-        COUNT(*) as total,
-        MAX(timestamp) as last_timestamp,
-        AVG(preservation_rate) as avg_rate,
-        SUM(patterns_pruned) as total_pruned
-      FROM consolidation_history
-    `);
-        const consolidationResult = consolidationStmt.get();
-        // Storage size
-        const fisherMatrixSize = 4 + this.config.dimensions * 4 * 2; // updateCount + importance + runningSum
-        // Query performance
+        const totalPatterns = getPatternCount(this.db);
+        const patternsByOutcome = getPatternsByOutcome(this.db);
+        const averageImportance = getAverageImportance(this.db);
+        const highImportancePatterns = getHighImportanceCount(this.db);
+        const consolidationStats = getConsolidationStats(this.db);
         const avgLatency = this.queryLatencies.length > 0
             ? this.queryLatencies.reduce((a, b) => a + b, 0) / this.queryLatencies.length
             : 0;
@@ -611,16 +259,16 @@ export class PatternStore {
             averageImportance,
             highImportancePatterns,
             consolidation: {
-                totalConsolidations: consolidationResult.total,
-                lastConsolidation: consolidationResult.last_timestamp
-                    ? new Date(consolidationResult.last_timestamp * 1000)
+                totalConsolidations: consolidationStats.total,
+                lastConsolidation: consolidationStats.lastTimestamp
+                    ? new Date(consolidationStats.lastTimestamp * 1000)
                     : null,
-                averagePreservationRate: consolidationResult.avg_rate ?? 1.0,
-                patternsPruned: consolidationResult.total_pruned ?? 0,
+                averagePreservationRate: consolidationStats.avgRate ?? 1.0,
+                patternsPruned: consolidationStats.totalPruned ?? 0,
             },
             storage: {
-                sizeBytes: this.getDatabaseSize(),
-                fisherMatrixSizeBytes: fisherMatrixSize,
+                sizeBytes: getDatabaseSize(this.db),
+                fisherMatrixSizeBytes: 4 + this.config.dimensions * 4 * 2,
             },
             queryPerformance: {
                 averageLatencyMs: avgLatency,
@@ -628,57 +276,25 @@ export class PatternStore {
             },
         };
     }
-    /**
-     * Close the PatternStore and release resources
-     */
     close() {
         if (this.db) {
             this.db.close();
         }
     }
-    // ============================================================================
-    // Private Helper Methods
-    // ============================================================================
+    // Private helpers
     ensureInitialized() {
         if (!this.initialized) {
             throw new Error('PatternStore not initialized. Call initialize() first.');
         }
     }
-    contextToText(context) {
-        const parts = [];
-        if (context.installedSkills && context.installedSkills.length > 0) {
-            parts.push(`installed: ${context.installedSkills.join(', ')}`);
-        }
-        if (context.frameworks && context.frameworks.length > 0) {
-            parts.push(`frameworks: ${context.frameworks.join(', ')}`);
-        }
-        if (context.keywords && context.keywords.length > 0) {
-            parts.push(`keywords: ${context.keywords.join(', ')}`);
-        }
-        if (context.timeOfDay) {
-            parts.push(`time: ${context.timeOfDay}`);
-        }
-        if (context.dayType) {
-            parts.push(`day: ${context.dayType}`);
-        }
-        return parts.join(' | ') || 'empty context';
-    }
-    computeGradient(a, b) {
-        const gradient = new Float32Array(a.length);
-        for (let i = 0; i < a.length; i++) {
-            gradient[i] = a[i] - (b[i] ?? 0);
-        }
-        return gradient;
-    }
     async computeAverageEmbedding() {
-        const stmt = this.db.prepare('SELECT context_embedding FROM patterns LIMIT 100');
-        const rows = stmt.all();
+        const rows = getContextEmbeddings(this.db, 100);
         if (rows.length === 0) {
             return new Float32Array(this.config.dimensions);
         }
         const sum = new Float32Array(this.config.dimensions);
         for (const row of rows) {
-            const embedding = this.deserializeEmbedding(row.context_embedding);
+            const embedding = deserializeEmbedding(row.context_embedding, this.config.dimensions);
             for (let i = 0; i < embedding.length; i++) {
                 sum[i] += embedding[i];
             }
@@ -688,73 +304,7 @@ export class PatternStore {
         }
         return sum;
     }
-    deserializeEmbedding(buffer) {
-        const floatArray = new Float32Array(this.config.dimensions);
-        for (let i = 0; i < this.config.dimensions; i++) {
-            floatArray[i] = buffer.readFloatLE(i * 4);
-        }
-        return floatArray;
-    }
-    cosineSimilarity(a, b) {
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dotProduct += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        if (normA === 0 || normB === 0)
-            return 0;
-        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-    }
-    importanceWeightedSimilarity(a, b, importance) {
-        let weightedDotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            const weight = 1 + (importance[i] ?? 0);
-            weightedDotProduct += weight * a[i] * b[i];
-            normA += weight * a[i] * a[i];
-            normB += weight * b[i] * b[i];
-        }
-        if (normA === 0 || normB === 0)
-            return 0;
-        return weightedDotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-    }
-    calculatePatternImportance(pattern, outcome) {
-        let baseImportance = Math.abs(outcome.reward);
-        if (outcome.reward > 0) {
-            baseImportance *= 1.5;
-        }
-        // Recency factor
-        const ageInDays = (Date.now() - pattern.createdAt.getTime()) / (24 * 60 * 60 * 1000);
-        const recencyFactor = Math.exp(-ageInDays / 30);
-        // Access frequency factor
-        const accessFactor = 1 + Math.log(1 + pattern.accessCount);
-        return baseImportance * recencyFactor * accessFactor * pattern.importance;
-    }
-    calculateDimensionImportance(pattern, importanceVector) {
-        let baseImportance = Math.abs(pattern.outcome.reward);
-        if (pattern.outcome.reward > 0) {
-            baseImportance *= 1.5;
-        }
-        const ageInDays = (Date.now() - pattern.createdAt.getTime()) / (24 * 60 * 60 * 1000);
-        const recencyFactor = Math.exp(-ageInDays / 30);
-        const accessFactor = 1 + Math.log(1 + pattern.accessCount);
-        // Fisher dimension importance (EWC++ core)
-        // Lambda scales how much we weight Fisher importance in preservation
-        let dimensionImportance = 0;
-        for (let i = 0; i < this.config.dimensions; i++) {
-            dimensionImportance += (importanceVector[i] ?? 0) * Math.abs(pattern.contextEmbedding[i] ?? 0);
-        }
-        dimensionImportance /= this.config.dimensions;
-        // Apply lambda regularization: higher lambda = stronger importance preservation
-        const lambdaScaled = 1 + (this.ewcConfig.lambda * dimensionImportance) / 10;
-        return baseImportance * recencyFactor * accessFactor * lambdaScaled;
-    }
     shouldConsolidate() {
-        // Minimum 1 hour between consolidations
         if (this.consolidationState.lastConsolidation) {
             const hoursSinceLast = (Date.now() - this.consolidationState.lastConsolidation.getTime()) / (60 * 60 * 1000);
             if (hoursSinceLast < 1)
@@ -765,103 +315,17 @@ export class PatternStore {
         const newPatternsRatio = this.consolidationState.patternsSinceLastConsolidation / this.consolidationState.totalPatterns;
         if (newPatternsRatio >= this.ewcConfig.consolidationThreshold)
             return true;
-        // Force consolidation if approaching max patterns
         if (this.consolidationState.totalPatterns > this.ewcConfig.maxPatterns * 0.9)
             return true;
         return false;
     }
-    getPatternCount() {
-        const stmt = this.db.prepare('SELECT COUNT(*) as count FROM patterns');
-        const result = stmt.get();
-        return result.count;
-    }
-    getSamplePatterns(limit) {
-        const stmt = this.db.prepare(`
-      SELECT * FROM patterns ORDER BY RANDOM() LIMIT ?
-    `);
-        const rows = stmt.all(limit);
-        return rows.map((row) => ({
-            id: row.pattern_id,
-            context: JSON.parse(row.context_data),
-            skill: JSON.parse(row.skill_features),
-            originalScore: row.original_score,
-            source: row.source,
-            contextEmbedding: this.deserializeEmbedding(row.context_embedding),
-            outcome: {
-                type: row.outcome_type,
-                reward: row.outcome_reward,
-            },
-            importance: row.importance,
-            accessCount: row.access_count,
-            createdAt: new Date(row.created_at * 1000),
-            lastAccessedAt: new Date(row.last_accessed_at * 1000),
-        }));
-    }
-    getAllPatterns() {
-        const stmt = this.db.prepare('SELECT * FROM patterns');
-        const rows = stmt.all();
-        return rows.map((row) => ({
-            id: row.pattern_id,
-            context: JSON.parse(row.context_data),
-            skill: JSON.parse(row.skill_features),
-            originalScore: row.original_score,
-            source: row.source,
-            contextEmbedding: this.deserializeEmbedding(row.context_embedding),
-            outcome: {
-                type: row.outcome_type,
-                reward: row.outcome_reward,
-            },
-            importance: row.importance,
-            accessCount: row.access_count,
-            createdAt: new Date(row.created_at * 1000),
-            lastAccessedAt: new Date(row.last_accessed_at * 1000),
-        }));
-    }
-    updatePatternInDB(patternId, updates) {
-        const sets = [];
-        const params = [];
-        if (updates.importance !== undefined) {
-            sets.push('importance = ?');
-            params.push(updates.importance);
-        }
-        if (updates.accessCount !== undefined) {
-            sets.push('access_count = ?');
-            params.push(updates.accessCount);
-        }
-        sets.push('last_accessed_at = unixepoch()');
-        params.push(patternId);
-        const stmt = this.db.prepare(`UPDATE patterns SET ${sets.join(', ')} WHERE pattern_id = ?`);
-        stmt.run(...params);
-    }
-    updatePatternImportance(patternId, importance) {
-        const stmt = this.db.prepare('UPDATE patterns SET importance = ? WHERE pattern_id = ?');
-        stmt.run(importance, patternId);
-    }
-    updateAccessCount(patternId) {
-        const stmt = this.db.prepare(`
-      UPDATE patterns SET access_count = access_count + 1, last_accessed_at = unixepoch()
-      WHERE pattern_id = ?
-    `);
-        stmt.run(patternId);
-    }
-    deletePattern(patternId) {
-        const stmt = this.db.prepare('DELETE FROM patterns WHERE pattern_id = ?');
-        stmt.run(patternId);
-    }
-    getDatabaseSize() {
-        const stmt = this.db.prepare('SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()');
-        const result = stmt.get();
-        return result?.size ?? 0;
-    }
     loadFisherMatrix() {
-        const stmt = this.db.prepare('SELECT matrix_data FROM fisher_info WHERE id = 1');
-        const result = stmt.get();
-        if (result?.matrix_data) {
+        const matrixData = loadFisherMatrixData(this.db);
+        if (matrixData) {
             try {
-                this.fisherMatrix.deserialize(result.matrix_data);
+                this.fisherMatrix.deserialize(matrixData);
             }
             catch {
-                // Corrupted matrix data - reset to fresh state
                 console.warn('[PatternStore] Fisher matrix data corrupted, resetting');
                 this.fisherMatrix.reset();
             }
@@ -869,21 +333,11 @@ export class PatternStore {
     }
     saveFisherMatrix() {
         const matrixData = this.fisherMatrix.serialize();
-        const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO fisher_info (id, matrix_data, update_count, last_decay_at, updated_at)
-      VALUES (1, ?, ?, unixepoch(), unixepoch())
-    `);
-        stmt.run(matrixData, this.fisherMatrix.getUpdateCount());
+        saveFisherMatrixData(this.db, matrixData, this.fisherMatrix.getUpdateCount());
     }
 }
-// ============================================================================
-// Factory Function
-// ============================================================================
 /**
  * Create and initialize a PatternStore instance
- *
- * @param config - Configuration options
- * @returns Initialized PatternStore
  */
 export async function createPatternStore(config = {}) {
     const store = new PatternStore(config);