kynjal-cli 4.0.0 → 4.0.1

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

@@ -20,59 +20,12 @@
  *
  * @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
 // ============================================================================
-var DEFAULT_EWC_CONFIG = {
+const DEFAULT_EWC_CONFIG = {
     lambda: 0.4,
     maxPatterns: 1000,
     fisherDecayRate: 0.01,
@@ -89,45 +42,34 @@ var DEFAULT_EWC_CONFIG = {
  * Implements Elastic Weight Consolidation with online updates
  * for preventing catastrophic forgetting in continual learning
  */
-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);
+export class EWCConsolidator {
+    config;
+    patterns = new Map();
+    gradientHistory = [];
+    globalFisher = [];
+    consolidationHistory = [];
+    initialized = false;
+    constructor(config) {
+        this.config = { ...DEFAULT_EWC_CONFIG, ...config };
         this.globalFisher = new Array(this.config.dimensions).fill(0);
     }
     /**
      * Initialize the consolidator by loading persisted state
      */
-    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*/];
-                }
-            });
-        });
-    };
+    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;
+        }
+    }
     /**
      * Compute Fisher Information Matrix from gradient history
      * Uses diagonal approximation for efficiency: F_i = E[g_i^2]
@@ -135,11 +77,10 @@ var EWCConsolidator = /** @class */ (function () {
      * @param patterns - Array of patterns with their gradients/embeddings
      * @returns Fisher information diagonal
      */
-    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];
+    computeFisherMatrix(patterns) {
+        const fisher = new Array(this.config.dimensions).fill(0);
+        let sampleCount = 0;
+        for (const pattern of patterns) {
             if (!pattern.embedding || pattern.embedding.length === 0)
                 continue;
             // Only use successful patterns for Fisher computation
@@ -149,27 +90,27 @@ var EWCConsolidator = /** @class */ (function () {
             sampleCount++;
             // Fisher diagonal is expectation of squared gradients
             // For embeddings, we use the embedding values as proxy for gradients
-            var len = Math.min(pattern.embedding.length, this.config.dimensions);
-            for (var i = 0; i < len; i++) {
+            const len = Math.min(pattern.embedding.length, this.config.dimensions);
+            for (let 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 (var i = 0; i < this.config.dimensions; i++) {
+            for (let i = 0; i < this.config.dimensions; i++) {
                 fisher[i] /= sampleCount;
             }
         }
         // Update global Fisher with exponential moving average (EWC++)
         if (this.config.onlineMode) {
-            var decay = this.config.fisherDecayRate;
-            for (var i = 0; i < this.config.dimensions; i++) {
+            const decay = this.config.fisherDecayRate;
+            for (let 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
@@ -178,9 +119,9 @@ var EWCConsolidator = /** @class */ (function () {
      * @param oldPatterns - Existing patterns to preserve
      * @returns Consolidated patterns with modified weights
      */
-    EWCConsolidator.prototype.consolidate = function (newPatterns, oldPatterns) {
-        var startTime = performance.now();
-        var result = {
+    consolidate(newPatterns, oldPatterns) {
+        const startTime = performance.now();
+        const result = {
             success: false,
             patternsConsolidated: 0,
             totalPenalty: 0,
@@ -190,33 +131,32 @@ var EWCConsolidator = /** @class */ (function () {
         };
         try {
             // Use stored patterns if no old patterns provided
-            var existingPatterns = oldPatterns || Array.from(this.patterns.values());
+            const existingPatterns = oldPatterns || Array.from(this.patterns.values());
             // Compute Fisher from successful existing patterns
-            var fisherInput = existingPatterns
-                .filter(function (p) { return p.successCount > p.failureCount; })
-                .map(function (p) { return ({
+            const fisherInput = existingPatterns
+                .filter(p => p.successCount > p.failureCount)
+                .map(p => ({
                 id: p.id,
                 embedding: p.weights,
                 success: true
-            }); });
-            var fisher = this.computeFisherMatrix(fisherInput);
+            }));
+            const fisher = this.computeFisherMatrix(fisherInput);
             // Process each new pattern
-            for (var _i = 0, newPatterns_1 = newPatterns; _i < newPatterns_1.length; _i++) {
-                var newPattern = newPatterns_1[_i];
+            for (const newPattern of newPatterns) {
                 if (!newPattern.embedding || newPattern.embedding.length === 0)
                     continue;
-                var existingPattern = this.patterns.get(newPattern.id);
+                const existingPattern = this.patterns.get(newPattern.id);
                 if (existingPattern) {
                     // Calculate EWC penalty for updating existing pattern
-                    var penalty = this.getPenalty(existingPattern.weights, newPattern.embedding, fisher);
+                    const penalty = this.getPenalty(existingPattern.weights, newPattern.embedding, fisher);
                     // Determine if update is allowed based on penalty
-                    var importanceScore = this.calculateImportance(existingPattern);
+                    const 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
-                        var blendFactor = 1 - importanceScore;
-                        var blendedWeights = this.blendWeights(existingPattern.weights, newPattern.embedding, blendFactor, fisher);
+                        const blendFactor = 1 - importanceScore;
+                        const blendedWeights = this.blendWeights(existingPattern.weights, newPattern.embedding, blendFactor, fisher);
                         existingPattern.weights = blendedWeights;
                         existingPattern.lastUpdated = Date.now();
                         result.modifiedPatterns.push(newPattern.id);
@@ -233,7 +173,7 @@ var EWCConsolidator = /** @class */ (function () {
                 }
                 else {
                     // New pattern: add directly
-                    var weights = {
+                    const weights = {
                         id: newPattern.id,
                         weights: newPattern.embedding.slice(0, this.config.dimensions),
                         fisherDiagonal: fisher,
@@ -270,7 +210,7 @@ var EWCConsolidator = /** @class */ (function () {
             result.duration = performance.now() - startTime;
             return result;
         }
-    };
+    }
     /**
      * Calculate EWC regularization penalty
      *
@@ -281,48 +221,47 @@ var EWCConsolidator = /** @class */ (function () {
      * @param fisher - Fisher information diagonal (optional, uses global if not provided)
      * @returns Regularization penalty value
      */
-    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];
+    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];
             penalty += fisherDiag[i] * diff * diff;
         }
         return (this.config.lambda / 2) * penalty;
-    };
+    }
     /**
      * Get consolidation statistics
      */
-    EWCConsolidator.prototype.getConsolidationStats = function () {
-        var totalFisher = 0;
-        var maxFisher = 0;
-        var highImportance = 0;
-        for (var i = 0; i < this.globalFisher.length; i++) {
+    getConsolidationStats() {
+        let totalFisher = 0;
+        let maxFisher = 0;
+        let highImportance = 0;
+        for (let i = 0; i < this.globalFisher.length; i++) {
             totalFisher += this.globalFisher[i];
             if (this.globalFisher[i] > maxFisher) {
                 maxFisher = this.globalFisher[i];
             }
         }
-        for (var _i = 0, _a = this.patterns.values(); _i < _a.length; _i++) {
-            var pattern = _a[_i];
+        for (const pattern of this.patterns.values()) {
             if (this.calculateImportance(pattern) > this.config.importanceThreshold) {
                 highImportance++;
             }
         }
-        var totalPenalty = this.consolidationHistory.reduce(function (sum, h) { return sum + h.penalty; }, 0);
-        var avgPenalty = this.consolidationHistory.length > 0
+        const totalPenalty = this.consolidationHistory.reduce((sum, h) => sum + h.penalty, 0);
+        const avgPenalty = this.consolidationHistory.length > 0
             ? totalPenalty / this.consolidationHistory.length
             : 0;
         // Estimate storage size
-        var storageSizeBytes = 0;
+        let storageSizeBytes = 0;
         try {
             if (fs.existsSync(this.config.storagePath)) {
-                var stats = fs.statSync(this.config.storagePath);
+                const stats = fs.statSync(this.config.storagePath);
                 storageSizeBytes = stats.size;
             }
         }
-        catch (_b) {
+        catch {
             // Ignore stat errors
         }
         return {
@@ -334,27 +273,27 @@ var EWCConsolidator = /** @class */ (function () {
             lastConsolidation: this.consolidationHistory.length > 0
                 ? this.consolidationHistory[this.consolidationHistory.length - 1].timestamp
                 : null,
-            avgPenalty: avgPenalty,
-            storageSizeBytes: storageSizeBytes
+            avgPenalty,
+            storageSizeBytes
         };
-    };
+    }
     /**
      * Record a gradient sample for Fisher computation
      */
-    EWCConsolidator.prototype.recordGradient = function (patternId, gradients, success) {
+    recordGradient(patternId, gradients, success) {
         this.gradientHistory.push({
-            patternId: patternId,
-            gradients: gradients,
+            patternId,
+            gradients,
             timestamp: Date.now(),
-            success: success
+            success
         });
         // Keep only recent gradients
-        var maxGradients = this.config.maxPatterns * 2;
+        const maxGradients = this.config.maxPatterns * 2;
         if (this.gradientHistory.length > maxGradients) {
             this.gradientHistory = this.gradientHistory.slice(-maxGradients);
         }
         // Update pattern success/failure counts
-        var pattern = this.patterns.get(patternId);
+        const pattern = this.patterns.get(patternId);
         if (pattern) {
             if (success) {
                 pattern.successCount++;
@@ -366,43 +305,43 @@ var EWCConsolidator = /** @class */ (function () {
         }
         // Online Fisher update from this gradient
         if (this.config.onlineMode && success) {
-            var decay = this.config.fisherDecayRate;
-            var len = Math.min(gradients.length, this.config.dimensions);
-            for (var i = 0; i < len; i++) {
+            const decay = this.config.fisherDecayRate;
+            const len = Math.min(gradients.length, this.config.dimensions);
+            for (let i = 0; i < len; i++) {
                 this.globalFisher[i] = (1 - decay) * this.globalFisher[i] + decay * gradients[i] * gradients[i];
             }
         }
-    };
+    }
     /**
      * Get pattern weights by ID
      */
-    EWCConsolidator.prototype.getPatternWeights = function (id) {
+    getPatternWeights(id) {
         return this.patterns.get(id);
-    };
+    }
     /**
      * Get all stored patterns
      */
-    EWCConsolidator.prototype.getAllPatterns = function () {
+    getAllPatterns() {
         return Array.from(this.patterns.values());
-    };
+    }
     /**
      * Update EWC lambda (regularization strength)
      */
-    EWCConsolidator.prototype.setLambda = function (lambda) {
+    setLambda(lambda) {
         this.config.lambda = lambda;
-    };
+    }
     /**
      * Get current lambda value
      */
-    EWCConsolidator.prototype.getLambda = function () {
+    getLambda() {
         return this.config.lambda;
-    };
+    }
     /**
      * Reset Fisher matrix (use with caution - allows forgetting)
      */
-    EWCConsolidator.prototype.resetFisher = function () {
+    resetFisher() {
         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
@@ -412,38 +351,37 @@ var EWCConsolidator = /** @class */ (function () {
      *
      * @param confidenceChanges - Array of {id, embedding, oldConf, newConf}
      */
-    EWCConsolidator.prototype.updateFisherFromConfidences = function (confidenceChanges) {
+    updateFisherFromConfidences(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];
+        const alpha = this.config.fisherDecayRate;
+        const currentFisher = new Array(this.config.dimensions).fill(0);
+        let sampleCount = 0;
+        for (const change of confidenceChanges) {
             if (!change.embedding || change.embedding.length === 0)
                 continue;
-            var confDelta = Math.abs(change.newConf - change.oldConf);
+            const confDelta = Math.abs(change.newConf - change.oldConf);
             if (confDelta === 0)
                 continue;
             sampleCount++;
-            var len = Math.min(change.embedding.length, this.config.dimensions);
+            const 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;
+            for (let i = 0; i < len; i++) {
+                const grad = change.embedding[i] * confDelta;
                 currentFisher[i] += grad * grad;
             }
         }
         if (sampleCount > 0) {
-            for (var i = 0; i < this.config.dimensions; i++) {
+            for (let 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++) {
+        for (let 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.
@@ -452,21 +390,21 @@ var EWCConsolidator = /** @class */ (function () {
      * @param newConfidence - Proposed new confidence value
      * @returns Penalty value (higher = more forgetting risk)
      */
-    EWCConsolidator.prototype.computeConfidencePenalty = function (oldConfidence, newConfidence) {
+    computeConfidencePenalty(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++) {
+        let avgFisher = 0;
+        for (let 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;
+        const diff = newConfidence - oldConfidence;
         return (this.config.lambda / 2) * avgFisher * diff * diff;
-    };
+    }
     /**
      * Clear all patterns and history (full reset)
      */
-    EWCConsolidator.prototype.clear = function () {
+    clear() {
         this.patterns.clear();
         this.gradientHistory = [];
         this.globalFisher = new Array(this.config.dimensions).fill(0);
@@ -477,79 +415,75 @@ var EWCConsolidator = /** @class */ (function () {
                 fs.unlinkSync(this.config.storagePath);
             }
         }
-        catch (_a) {
+        catch {
             // Ignore deletion errors
         }
-    };
+    }
     // ============================================================================
     // Private Methods
     // ============================================================================
     /**
      * Calculate importance score for a pattern based on usage
      */
-    EWCConsolidator.prototype.calculateImportance = function (pattern) {
-        var total = pattern.successCount + pattern.failureCount;
+    calculateImportance(pattern) {
+        const total = pattern.successCount + pattern.failureCount;
         if (total === 0)
             return 0.5;
         // Success rate with Laplace smoothing
-        var successRate = (pattern.successCount + 1) / (total + 2);
+        const successRate = (pattern.successCount + 1) / (total + 2);
         // Recency factor: recent patterns are more important
-        var hoursSinceUpdate = (Date.now() - pattern.lastUpdated) / (1000 * 60 * 60);
-        var recencyFactor = Math.exp(-hoursSinceUpdate / 168); // 1 week half-life
+        const hoursSinceUpdate = (Date.now() - pattern.lastUpdated) / (1000 * 60 * 60);
+        const 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
      */
-    EWCConsolidator.prototype.blendWeights = function (oldWeights, newWeights, blendFactor, fisher) {
-        var len = Math.min(oldWeights.length, newWeights.length, this.config.dimensions);
-        var result = new Array(len);
+    blendWeights(oldWeights, newWeights, blendFactor, fisher) {
+        const len = Math.min(oldWeights.length, newWeights.length, this.config.dimensions);
+        const result = new Array(len);
         // Normalize Fisher for per-weight blend factors
-        var maxF = 0;
-        for (var i = 0; i < len; i++) {
+        let maxF = 0;
+        for (let i = 0; i < len; i++) {
             if (fisher[i] > maxF)
                 maxF = fisher[i];
         }
-        var normFactor = maxF > 0 ? 1 / maxF : 1;
-        for (var i = 0; i < len; i++) {
+        const normFactor = maxF > 0 ? 1 / maxF : 1;
+        for (let i = 0; i < len; i++) {
             // Higher Fisher = more weight on old value
-            var fisherWeight = fisher[i] * normFactor;
-            var adjustedBlend = blendFactor * (1 - fisherWeight * 0.5);
+            const fisherWeight = fisher[i] * normFactor;
+            const 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
      */
-    EWCConsolidator.prototype.pruneOldPatterns = function () {
-        var _this = this;
+    pruneOldPatterns() {
         if (this.patterns.size <= this.config.maxPatterns)
             return;
         // Sort by importance (ascending)
-        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; });
+        const sortedPatterns = Array.from(this.patterns.entries())
+            .map(([id, pattern]) => ({ id, importance: this.calculateImportance(pattern) }))
+            .sort((a, b) => a.importance - b.importance);
         // Remove lowest importance patterns
-        var toRemove = this.patterns.size - this.config.maxPatterns;
-        for (var i = 0; i < toRemove; i++) {
-            this.patterns["delete"](sortedPatterns[i].id);
+        const toRemove = this.patterns.size - this.config.maxPatterns;
+        for (let i = 0; i < toRemove; i++) {
+            this.patterns.delete(sortedPatterns[i].id);
         }
-    };
+    }
     /**
      * Save state to disk
      */
-    EWCConsolidator.prototype.saveToDisk = function () {
+    saveToDisk() {
         try {
-            var dir = path.dirname(this.config.storagePath);
+            const dir = path.dirname(this.config.storagePath);
             if (!fs.existsSync(dir)) {
                 fs.mkdirSync(dir, { recursive: true });
             }
-            var state = {
+            const state = {
                 version: '1.0.0',
                 config: {
                     lambda: this.config.lambda,
@@ -563,75 +497,56 @@ var EWCConsolidator = /** @class */ (function () {
             };
             fs.writeFileSync(this.config.storagePath, JSON.stringify(state, null, 2));
         }
-        catch (_a) {
+        catch {
             // Silently fail - persistence is best-effort
         }
-    };
+    }
     /**
      * Load state from disk
      */
-    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 };
+    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;
+        }
+    }
+}
 // ============================================================================
 // Singleton Instance
 // ============================================================================
-var ewcConsolidatorInstance = null;
+let ewcConsolidatorInstance = null;
 /**
  * Get the singleton EWC Consolidator instance
  *
  * @param config - Optional configuration overrides
  * @returns EWC Consolidator instance
  */
-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];
-            }
-        });
-    });
+export async function getEWCConsolidator(config) {
+    if (!ewcConsolidatorInstance) {
+        ewcConsolidatorInstance = new EWCConsolidator(config);
+        await ewcConsolidatorInstance.initialize();
+    }
+    return ewcConsolidatorInstance;
 }
 /**
  * Reset the singleton instance (for testing)
@@ -652,18 +567,9 @@ export function resetEWCConsolidator() {
  * @param newPatterns - New patterns to add
  * @returns Consolidation result
  */
-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)];
-            }
-        });
-    });
+export async function consolidatePatterns(newPatterns) {
+    const consolidator = await getEWCConsolidator();
+    return consolidator.consolidate(newPatterns);
 }
 /**
  * Record pattern usage outcome
@@ -673,42 +579,23 @@ export function consolidatePatterns(newPatterns) {
  * @param embedding - Pattern embedding (used as gradient proxy)
  * @param success - Whether the pattern was successful
  */
-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*/];
-            }
-        });
-    });
+export async function recordPatternOutcome(patternId, embedding, success) {
+    const consolidator = await getEWCConsolidator();
+    consolidator.recordGradient(patternId, embedding, success);
 }
 /**
  * Get EWC statistics
  */
-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 async function getEWCStats() {
+    const consolidator = await getEWCConsolidator();
+    return consolidator.getConsolidationStats();
 }
 export default {
-    EWCConsolidator: EWCConsolidator,
-    getEWCConsolidator: getEWCConsolidator,
-    resetEWCConsolidator: resetEWCConsolidator,
-    consolidatePatterns: consolidatePatterns,
-    recordPatternOutcome: recordPatternOutcome,
-    getEWCStats: getEWCStats
+    EWCConsolidator,
+    getEWCConsolidator,
+    resetEWCConsolidator,
+    consolidatePatterns,
+    recordPatternOutcome,
+    getEWCStats
 };
 //# sourceMappingURL=ewc-consolidation.js.map