kynjal-cli 3.1.3 → 4.0.0

package/dist/src/memory/ewc-consolidation.js

@@ -20,12 +20,59 @@
  *
  * @module v3/cli/memory/ewc-consolidation
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import * as fs from 'fs';
 import * as path from 'path';
 // ============================================================================
 // Default Configuration
 // ============================================================================
-const DEFAULT_EWC_CONFIG = {
+var DEFAULT_EWC_CONFIG = {
     lambda: 0.4,
     maxPatterns: 1000,
     fisherDecayRate: 0.01,
@@ -42,34 +89,45 @@ const DEFAULT_EWC_CONFIG = {
  * Implements Elastic Weight Consolidation with online updates
  * for preventing catastrophic forgetting in continual learning
  */
-export class EWCConsolidator {
-    config;
-    patterns = new Map();
-    gradientHistory = [];
-    globalFisher = [];
-    consolidationHistory = [];
-    initialized = false;
-    constructor(config) {
-        this.config = { ...DEFAULT_EWC_CONFIG, ...config };
+var EWCConsolidator = /** @class */ (function () {
+    function EWCConsolidator(config) {
+        this.patterns = new Map();
+        this.gradientHistory = [];
+        this.globalFisher = [];
+        this.consolidationHistory = [];
+        this.initialized = false;
+        this.config = __assign(__assign({}, DEFAULT_EWC_CONFIG), config);
         this.globalFisher = new Array(this.config.dimensions).fill(0);
     }
     /**
      * Initialize the consolidator by loading persisted state
      */
-    async initialize() {
-        if (this.initialized)
-            return true;
-        try {
-            await this.loadFromDisk();
-            this.initialized = true;
-            return true;
-        }
-        catch {
-            // Start fresh if no persisted state
-            this.initialized = true;
-            return true;
-        }
-    }
+    EWCConsolidator.prototype.initialize = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.initialized)
+                            return [2 /*return*/, true];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.loadFromDisk()];
+                    case 2:
+                        _b.sent();
+                        this.initialized = true;
+                        return [2 /*return*/, true];
+                    case 3:
+                        _a = _b.sent();
+                        // Start fresh if no persisted state
+                        this.initialized = true;
+                        return [2 /*return*/, true];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Compute Fisher Information Matrix from gradient history
      * Uses diagonal approximation for efficiency: F_i = E[g_i^2]
@@ -77,10 +135,11 @@ export class EWCConsolidator {
      * @param patterns - Array of patterns with their gradients/embeddings
      * @returns Fisher information diagonal
      */
-    computeFisherMatrix(patterns) {
-        const fisher = new Array(this.config.dimensions).fill(0);
-        let sampleCount = 0;
-        for (const pattern of patterns) {
+    EWCConsolidator.prototype.computeFisherMatrix = function (patterns) {
+        var fisher = new Array(this.config.dimensions).fill(0);
+        var sampleCount = 0;
+        for (var _i = 0, patterns_1 = patterns; _i < patterns_1.length; _i++) {
+            var pattern = patterns_1[_i];
             if (!pattern.embedding || pattern.embedding.length === 0)
                 continue;
             // Only use successful patterns for Fisher computation
@@ -90,27 +149,27 @@ export class EWCConsolidator {
             sampleCount++;
             // Fisher diagonal is expectation of squared gradients
             // For embeddings, we use the embedding values as proxy for gradients
-            const len = Math.min(pattern.embedding.length, this.config.dimensions);
-            for (let i = 0; i < len; i++) {
+            var len = Math.min(pattern.embedding.length, this.config.dimensions);
+            for (var i = 0; i < len; i++) {
                 // Accumulate squared values (gradient proxy)
                 fisher[i] += pattern.embedding[i] * pattern.embedding[i];
             }
         }
         // Normalize by sample count
         if (sampleCount > 0) {
-            for (let i = 0; i < this.config.dimensions; i++) {
+            for (var i = 0; i < this.config.dimensions; i++) {
                 fisher[i] /= sampleCount;
             }
         }
         // Update global Fisher with exponential moving average (EWC++)
         if (this.config.onlineMode) {
-            const decay = this.config.fisherDecayRate;
-            for (let i = 0; i < this.config.dimensions; i++) {
+            var decay = this.config.fisherDecayRate;
+            for (var i = 0; i < this.config.dimensions; i++) {
                 this.globalFisher[i] = (1 - decay) * this.globalFisher[i] + decay * fisher[i];
             }
         }
         return fisher;
-    }
+    };
     /**
      * Consolidate new patterns with old patterns without forgetting
      * Applies EWC penalty to preserve important weights
@@ -119,9 +178,9 @@ export class EWCConsolidator {
      * @param oldPatterns - Existing patterns to preserve
      * @returns Consolidated patterns with modified weights
      */
-    consolidate(newPatterns, oldPatterns) {
-        const startTime = performance.now();
-        const result = {
+    EWCConsolidator.prototype.consolidate = function (newPatterns, oldPatterns) {
+        var startTime = performance.now();
+        var result = {
             success: false,
             patternsConsolidated: 0,
             totalPenalty: 0,
@@ -131,32 +190,33 @@ export class EWCConsolidator {
         };
         try {
             // Use stored patterns if no old patterns provided
-            const existingPatterns = oldPatterns || Array.from(this.patterns.values());
+            var existingPatterns = oldPatterns || Array.from(this.patterns.values());
             // Compute Fisher from successful existing patterns
-            const fisherInput = existingPatterns
-                .filter(p => p.successCount > p.failureCount)
-                .map(p => ({
+            var fisherInput = existingPatterns
+                .filter(function (p) { return p.successCount > p.failureCount; })
+                .map(function (p) { return ({
                 id: p.id,
                 embedding: p.weights,
                 success: true
-            }));
-            const fisher = this.computeFisherMatrix(fisherInput);
+            }); });
+            var fisher = this.computeFisherMatrix(fisherInput);
             // Process each new pattern
-            for (const newPattern of newPatterns) {
+            for (var _i = 0, newPatterns_1 = newPatterns; _i < newPatterns_1.length; _i++) {
+                var newPattern = newPatterns_1[_i];
                 if (!newPattern.embedding || newPattern.embedding.length === 0)
                     continue;
-                const existingPattern = this.patterns.get(newPattern.id);
+                var existingPattern = this.patterns.get(newPattern.id);
                 if (existingPattern) {
                     // Calculate EWC penalty for updating existing pattern
-                    const penalty = this.getPenalty(existingPattern.weights, newPattern.embedding, fisher);
+                    var penalty = this.getPenalty(existingPattern.weights, newPattern.embedding, fisher);
                     // Determine if update is allowed based on penalty
-                    const importanceScore = this.calculateImportance(existingPattern);
+                    var importanceScore = this.calculateImportance(existingPattern);
                     if (importanceScore > this.config.importanceThreshold && penalty > this.config.lambda) {
                         // Protect high-importance patterns with high penalty
                         result.protectedPatterns.push(newPattern.id);
                         // Apply constrained update: blend old and new based on importance
-                        const blendFactor = 1 - importanceScore;
-                        const blendedWeights = this.blendWeights(existingPattern.weights, newPattern.embedding, blendFactor, fisher);
+                        var blendFactor = 1 - importanceScore;
+                        var blendedWeights = this.blendWeights(existingPattern.weights, newPattern.embedding, blendFactor, fisher);
                         existingPattern.weights = blendedWeights;
                         existingPattern.lastUpdated = Date.now();
                         result.modifiedPatterns.push(newPattern.id);
@@ -173,7 +233,7 @@ export class EWCConsolidator {
                 }
                 else {
                     // New pattern: add directly
-                    const weights = {
+                    var weights = {
                         id: newPattern.id,
                         weights: newPattern.embedding.slice(0, this.config.dimensions),
                         fisherDiagonal: fisher,
@@ -210,7 +270,7 @@ export class EWCConsolidator {
             result.duration = performance.now() - startTime;
             return result;
         }
-    }
+    };
     /**
      * Calculate EWC regularization penalty
      *
@@ -221,47 +281,48 @@ export class EWCConsolidator {
      * @param fisher - Fisher information diagonal (optional, uses global if not provided)
      * @returns Regularization penalty value
      */
-    getPenalty(oldWeights, newWeights, fisher) {
-        const fisherDiag = fisher || this.globalFisher;
-        const len = Math.min(oldWeights.length, newWeights.length, fisherDiag.length);
-        let penalty = 0;
-        for (let i = 0; i < len; i++) {
-            const diff = newWeights[i] - oldWeights[i];
+    EWCConsolidator.prototype.getPenalty = function (oldWeights, newWeights, fisher) {
+        var fisherDiag = fisher || this.globalFisher;
+        var len = Math.min(oldWeights.length, newWeights.length, fisherDiag.length);
+        var penalty = 0;
+        for (var i = 0; i < len; i++) {
+            var diff = newWeights[i] - oldWeights[i];
             penalty += fisherDiag[i] * diff * diff;
         }
         return (this.config.lambda / 2) * penalty;
-    }
+    };
     /**
      * Get consolidation statistics
      */
-    getConsolidationStats() {
-        let totalFisher = 0;
-        let maxFisher = 0;
-        let highImportance = 0;
-        for (let i = 0; i < this.globalFisher.length; i++) {
+    EWCConsolidator.prototype.getConsolidationStats = function () {
+        var totalFisher = 0;
+        var maxFisher = 0;
+        var highImportance = 0;
+        for (var i = 0; i < this.globalFisher.length; i++) {
             totalFisher += this.globalFisher[i];
             if (this.globalFisher[i] > maxFisher) {
                 maxFisher = this.globalFisher[i];
             }
         }
-        for (const pattern of this.patterns.values()) {
+        for (var _i = 0, _a = this.patterns.values(); _i < _a.length; _i++) {
+            var pattern = _a[_i];
             if (this.calculateImportance(pattern) > this.config.importanceThreshold) {
                 highImportance++;
             }
         }
-        const totalPenalty = this.consolidationHistory.reduce((sum, h) => sum + h.penalty, 0);
-        const avgPenalty = this.consolidationHistory.length > 0
+        var totalPenalty = this.consolidationHistory.reduce(function (sum, h) { return sum + h.penalty; }, 0);
+        var avgPenalty = this.consolidationHistory.length > 0
             ? totalPenalty / this.consolidationHistory.length
             : 0;
         // Estimate storage size
-        let storageSizeBytes = 0;
+        var storageSizeBytes = 0;
         try {
             if (fs.existsSync(this.config.storagePath)) {
-                const stats = fs.statSync(this.config.storagePath);
+                var stats = fs.statSync(this.config.storagePath);
                 storageSizeBytes = stats.size;
             }
         }
-        catch {
+        catch (_b) {
             // Ignore stat errors
         }
         return {
@@ -273,27 +334,27 @@ export class EWCConsolidator {
             lastConsolidation: this.consolidationHistory.length > 0
                 ? this.consolidationHistory[this.consolidationHistory.length - 1].timestamp
                 : null,
-            avgPenalty,
-            storageSizeBytes
+            avgPenalty: avgPenalty,
+            storageSizeBytes: storageSizeBytes
         };
-    }
+    };
     /**
      * Record a gradient sample for Fisher computation
      */
-    recordGradient(patternId, gradients, success) {
+    EWCConsolidator.prototype.recordGradient = function (patternId, gradients, success) {
         this.gradientHistory.push({
-            patternId,
-            gradients,
+            patternId: patternId,
+            gradients: gradients,
             timestamp: Date.now(),
-            success
+            success: success
         });
         // Keep only recent gradients
-        const maxGradients = this.config.maxPatterns * 2;
+        var maxGradients = this.config.maxPatterns * 2;
         if (this.gradientHistory.length > maxGradients) {
             this.gradientHistory = this.gradientHistory.slice(-maxGradients);
         }
         // Update pattern success/failure counts
-        const pattern = this.patterns.get(patternId);
+        var pattern = this.patterns.get(patternId);
         if (pattern) {
             if (success) {
                 pattern.successCount++;
@@ -305,47 +366,107 @@ export class EWCConsolidator {
         }
         // Online Fisher update from this gradient
         if (this.config.onlineMode && success) {
-            const decay = this.config.fisherDecayRate;
-            const len = Math.min(gradients.length, this.config.dimensions);
-            for (let i = 0; i < len; i++) {
+            var decay = this.config.fisherDecayRate;
+            var len = Math.min(gradients.length, this.config.dimensions);
+            for (var i = 0; i < len; i++) {
                 this.globalFisher[i] = (1 - decay) * this.globalFisher[i] + decay * gradients[i] * gradients[i];
             }
         }
-    }
+    };
     /**
      * Get pattern weights by ID
      */
-    getPatternWeights(id) {
+    EWCConsolidator.prototype.getPatternWeights = function (id) {
         return this.patterns.get(id);
-    }
+    };
     /**
      * Get all stored patterns
      */
-    getAllPatterns() {
+    EWCConsolidator.prototype.getAllPatterns = function () {
         return Array.from(this.patterns.values());
-    }
+    };
     /**
      * Update EWC lambda (regularization strength)
      */
-    setLambda(lambda) {
+    EWCConsolidator.prototype.setLambda = function (lambda) {
         this.config.lambda = lambda;
-    }
+    };
     /**
      * Get current lambda value
      */
-    getLambda() {
+    EWCConsolidator.prototype.getLambda = function () {
         return this.config.lambda;
-    }
+    };
     /**
      * Reset Fisher matrix (use with caution - allows forgetting)
      */
-    resetFisher() {
+    EWCConsolidator.prototype.resetFisher = function () {
         this.globalFisher = new Array(this.config.dimensions).fill(0);
-    }
+    };
+    /**
+     * Update Fisher matrix from pattern confidence changes.
+     * Called by SONA after distillLearning to track which patterns
+     * are important and should be protected from forgetting.
+     *
+     * Uses online averaging: F_new = alpha * F_old + (1-alpha) * F_current
+     *
+     * @param confidenceChanges - Array of {id, embedding, oldConf, newConf}
+     */
+    EWCConsolidator.prototype.updateFisherFromConfidences = function (confidenceChanges) {
+        if (confidenceChanges.length === 0)
+            return;
+        var alpha = this.config.fisherDecayRate;
+        var currentFisher = new Array(this.config.dimensions).fill(0);
+        var sampleCount = 0;
+        for (var _i = 0, confidenceChanges_1 = confidenceChanges; _i < confidenceChanges_1.length; _i++) {
+            var change = confidenceChanges_1[_i];
+            if (!change.embedding || change.embedding.length === 0)
+                continue;
+            var confDelta = Math.abs(change.newConf - change.oldConf);
+            if (confDelta === 0)
+                continue;
+            sampleCount++;
+            var len = Math.min(change.embedding.length, this.config.dimensions);
+            // Squared gradient proxy: embedding scaled by confidence change magnitude
+            for (var i = 0; i < len; i++) {
+                var grad = change.embedding[i] * confDelta;
+                currentFisher[i] += grad * grad;
+            }
+        }
+        if (sampleCount > 0) {
+            for (var i = 0; i < this.config.dimensions; i++) {
+                currentFisher[i] /= sampleCount;
+            }
+        }
+        // Online EMA: F_new = alpha * F_old + (1-alpha) * F_current
+        for (var i = 0; i < this.config.dimensions; i++) {
+            this.globalFisher[i] = alpha * this.globalFisher[i] + (1 - alpha) * currentFisher[i];
+        }
+        this.saveToDisk();
+    };
+    /**
+     * Compute consolidation penalty for a proposed confidence update.
+     * Used by SONA to check whether a pattern update would cause forgetting.
+     *
+     * @param oldConfidence - Current confidence value
+     * @param newConfidence - Proposed new confidence value
+     * @returns Penalty value (higher = more forgetting risk)
+     */
+    EWCConsolidator.prototype.computeConfidencePenalty = function (oldConfidence, newConfidence) {
+        // Use the global Fisher to estimate penalty for scalar confidence change
+        // Average Fisher value represents overall importance
+        var avgFisher = 0;
+        for (var i = 0; i < this.globalFisher.length; i++) {
+            avgFisher += this.globalFisher[i];
+        }
+        avgFisher = this.globalFisher.length > 0 ? avgFisher / this.globalFisher.length : 0;
+        var diff = newConfidence - oldConfidence;
+        return (this.config.lambda / 2) * avgFisher * diff * diff;
+    };
     /**
      * Clear all patterns and history (full reset)
      */
-    clear() {
+    EWCConsolidator.prototype.clear = function () {
         this.patterns.clear();
         this.gradientHistory = [];
         this.globalFisher = new Array(this.config.dimensions).fill(0);
@@ -356,75 +477,79 @@ export class EWCConsolidator {
                 fs.unlinkSync(this.config.storagePath);
             }
         }
-        catch {
+        catch (_a) {
             // Ignore deletion errors
         }
-    }
+    };
     // ============================================================================
     // Private Methods
     // ============================================================================
     /**
      * Calculate importance score for a pattern based on usage
      */
-    calculateImportance(pattern) {
-        const total = pattern.successCount + pattern.failureCount;
+    EWCConsolidator.prototype.calculateImportance = function (pattern) {
+        var total = pattern.successCount + pattern.failureCount;
         if (total === 0)
             return 0.5;
         // Success rate with Laplace smoothing
-        const successRate = (pattern.successCount + 1) / (total + 2);
+        var successRate = (pattern.successCount + 1) / (total + 2);
         // Recency factor: recent patterns are more important
-        const hoursSinceUpdate = (Date.now() - pattern.lastUpdated) / (1000 * 60 * 60);
-        const recencyFactor = Math.exp(-hoursSinceUpdate / 168); // 1 week half-life
+        var hoursSinceUpdate = (Date.now() - pattern.lastUpdated) / (1000 * 60 * 60);
+        var recencyFactor = Math.exp(-hoursSinceUpdate / 168); // 1 week half-life
         // Combine factors
         return successRate * 0.7 + recencyFactor * 0.3;
-    }
+    };
     /**
      * Blend old and new weights using Fisher-weighted interpolation
      */
-    blendWeights(oldWeights, newWeights, blendFactor, fisher) {
-        const len = Math.min(oldWeights.length, newWeights.length, this.config.dimensions);
-        const result = new Array(len);
+    EWCConsolidator.prototype.blendWeights = function (oldWeights, newWeights, blendFactor, fisher) {
+        var len = Math.min(oldWeights.length, newWeights.length, this.config.dimensions);
+        var result = new Array(len);
         // Normalize Fisher for per-weight blend factors
-        let maxF = 0;
-        for (let i = 0; i < len; i++) {
+        var maxF = 0;
+        for (var i = 0; i < len; i++) {
             if (fisher[i] > maxF)
                 maxF = fisher[i];
         }
-        const normFactor = maxF > 0 ? 1 / maxF : 1;
-        for (let i = 0; i < len; i++) {
+        var normFactor = maxF > 0 ? 1 / maxF : 1;
+        for (var i = 0; i < len; i++) {
             // Higher Fisher = more weight on old value
-            const fisherWeight = fisher[i] * normFactor;
-            const adjustedBlend = blendFactor * (1 - fisherWeight * 0.5);
+            var fisherWeight = fisher[i] * normFactor;
+            var adjustedBlend = blendFactor * (1 - fisherWeight * 0.5);
             result[i] = oldWeights[i] * (1 - adjustedBlend) + newWeights[i] * adjustedBlend;
         }
         return result;
-    }
+    };
     /**
      * Prune old, low-importance patterns to stay within limit
      */
-    pruneOldPatterns() {
+    EWCConsolidator.prototype.pruneOldPatterns = function () {
+        var _this = this;
         if (this.patterns.size <= this.config.maxPatterns)
             return;
         // Sort by importance (ascending)
-        const sortedPatterns = Array.from(this.patterns.entries())
-            .map(([id, pattern]) => ({ id, importance: this.calculateImportance(pattern) }))
-            .sort((a, b) => a.importance - b.importance);
+        var sortedPatterns = Array.from(this.patterns.entries())
+            .map(function (_a) {
+            var id = _a[0], pattern = _a[1];
+            return ({ id: id, importance: _this.calculateImportance(pattern) });
+        })
+            .sort(function (a, b) { return a.importance - b.importance; });
         // Remove lowest importance patterns
-        const toRemove = this.patterns.size - this.config.maxPatterns;
-        for (let i = 0; i < toRemove; i++) {
-            this.patterns.delete(sortedPatterns[i].id);
+        var toRemove = this.patterns.size - this.config.maxPatterns;
+        for (var i = 0; i < toRemove; i++) {
+            this.patterns["delete"](sortedPatterns[i].id);
         }
-    }
+    };
     /**
      * Save state to disk
      */
-    saveToDisk() {
+    EWCConsolidator.prototype.saveToDisk = function () {
         try {
-            const dir = path.dirname(this.config.storagePath);
+            var dir = path.dirname(this.config.storagePath);
             if (!fs.existsSync(dir)) {
                 fs.mkdirSync(dir, { recursive: true });
             }
-            const state = {
+            var state = {
                 version: '1.0.0',
                 config: {
                     lambda: this.config.lambda,
@@ -438,56 +563,75 @@ export class EWCConsolidator {
             };
             fs.writeFileSync(this.config.storagePath, JSON.stringify(state, null, 2));
         }
-        catch {
+        catch (_a) {
             // Silently fail - persistence is best-effort
         }
-    }
+    };
     /**
      * Load state from disk
      */
-    async loadFromDisk() {
-        if (!fs.existsSync(this.config.storagePath)) {
-            throw new Error('No persisted state found');
-        }
-        const content = fs.readFileSync(this.config.storagePath, 'utf-8');
-        const state = JSON.parse(content);
-        // Validate version
-        if (state.version !== '1.0.0') {
-            throw new Error(`Unsupported state version: ${state.version}`);
-        }
-        // Restore state
-        this.globalFisher = state.globalFisher || new Array(this.config.dimensions).fill(0);
-        // Restore patterns
-        this.patterns.clear();
-        if (state.patterns) {
-            for (const [id, pattern] of state.patterns) {
-                this.patterns.set(id, pattern);
-            }
-        }
-        // Restore history
-        this.consolidationHistory = state.consolidationHistory || [];
-        // Update config from persisted values
-        if (state.config) {
-            this.config.lambda = state.config.lambda ?? this.config.lambda;
-        }
-    }
-}
+    EWCConsolidator.prototype.loadFromDisk = function () {
+        var _a;
+        return __awaiter(this, void 0, Promise, function () {
+            var content, state, _i, _b, _c, id, pattern;
+            return __generator(this, function (_d) {
+                if (!fs.existsSync(this.config.storagePath)) {
+                    throw new Error('No persisted state found');
+                }
+                content = fs.readFileSync(this.config.storagePath, 'utf-8');
+                state = JSON.parse(content);
+                // Validate version
+                if (state.version !== '1.0.0') {
+                    throw new Error("Unsupported state version: " + state.version);
+                }
+                // Restore state
+                this.globalFisher = state.globalFisher || new Array(this.config.dimensions).fill(0);
+                // Restore patterns
+                this.patterns.clear();
+                if (state.patterns) {
+                    for (_i = 0, _b = state.patterns; _i < _b.length; _i++) {
+                        _c = _b[_i], id = _c[0], pattern = _c[1];
+                        this.patterns.set(id, pattern);
+                    }
+                }
+                // Restore history
+                this.consolidationHistory = state.consolidationHistory || [];
+                // Update config from persisted values
+                if (state.config) {
+                    this.config.lambda = (_a = state.config.lambda) !== null && _a !== void 0 ? _a : this.config.lambda;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return EWCConsolidator;
+}());
+export { EWCConsolidator };
 // ============================================================================
 // Singleton Instance
 // ============================================================================
-let ewcConsolidatorInstance = null;
+var ewcConsolidatorInstance = null;
 /**
  * Get the singleton EWC Consolidator instance
  *
  * @param config - Optional configuration overrides
  * @returns EWC Consolidator instance
  */
-export async function getEWCConsolidator(config) {
-    if (!ewcConsolidatorInstance) {
-        ewcConsolidatorInstance = new EWCConsolidator(config);
-        await ewcConsolidatorInstance.initialize();
-    }
-    return ewcConsolidatorInstance;
+export function getEWCConsolidator(config) {
+    return __awaiter(this, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!ewcConsolidatorInstance) return [3 /*break*/, 2];
+                    ewcConsolidatorInstance = new EWCConsolidator(config);
+                    return [4 /*yield*/, ewcConsolidatorInstance.initialize()];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/, ewcConsolidatorInstance];
+            }
+        });
+    });
 }
 /**
  * Reset the singleton instance (for testing)
@@ -508,9 +652,18 @@ export function resetEWCConsolidator() {
  * @param newPatterns - New patterns to add
  * @returns Consolidation result
  */
-export async function consolidatePatterns(newPatterns) {
-    const consolidator = await getEWCConsolidator();
-    return consolidator.consolidate(newPatterns);
+export function consolidatePatterns(newPatterns) {
+    return __awaiter(this, void 0, Promise, function () {
+        var consolidator;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getEWCConsolidator()];
+                case 1:
+                    consolidator = _a.sent();
+                    return [2 /*return*/, consolidator.consolidate(newPatterns)];
+            }
+        });
+    });
 }
 /**
  * Record pattern usage outcome
@@ -520,23 +673,42 @@ export async function consolidatePatterns(newPatterns) {
  * @param embedding - Pattern embedding (used as gradient proxy)
  * @param success - Whether the pattern was successful
  */
-export async function recordPatternOutcome(patternId, embedding, success) {
-    const consolidator = await getEWCConsolidator();
-    consolidator.recordGradient(patternId, embedding, success);
+export function recordPatternOutcome(patternId, embedding, success) {
+    return __awaiter(this, void 0, Promise, function () {
+        var consolidator;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getEWCConsolidator()];
+                case 1:
+                    consolidator = _a.sent();
+                    consolidator.recordGradient(patternId, embedding, success);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }
 /**
  * Get EWC statistics
  */
-export async function getEWCStats() {
-    const consolidator = await getEWCConsolidator();
-    return consolidator.getConsolidationStats();
+export function getEWCStats() {
+    return __awaiter(this, void 0, Promise, function () {
+        var consolidator;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getEWCConsolidator()];
+                case 1:
+                    consolidator = _a.sent();
+                    return [2 /*return*/, consolidator.getConsolidationStats()];
+            }
+        });
+    });
 }
 export default {
-    EWCConsolidator,
-    getEWCConsolidator,
-    resetEWCConsolidator,
-    consolidatePatterns,
-    recordPatternOutcome,
-    getEWCStats
+    EWCConsolidator: EWCConsolidator,
+    getEWCConsolidator: getEWCConsolidator,
+    resetEWCConsolidator: resetEWCConsolidator,
+    consolidatePatterns: consolidatePatterns,
+    recordPatternOutcome: recordPatternOutcome,
+    getEWCStats: getEWCStats
 };
 //# sourceMappingURL=ewc-consolidation.js.map