kynjal-cli 3.1.3 → 4.0.0

package/dist/src/memory/intelligence.js

@@ -10,6 +10,62 @@
  *
  * @module v3/cli/intelligence
  */
+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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
@@ -22,9 +78,9 @@ import { join } from 'node:path';
  * falling back to home directory
  */
 function getDataDir() {
-    const cwd = process.cwd();
-    const localDir = join(cwd, '.claude-flow', 'neural');
-    const homeDir = join(homedir(), '.claude-flow', 'neural');
+    var cwd = process.cwd();
+    var localDir = join(cwd, '.claude-flow', 'neural');
+    var homeDir = join(homedir(), '.claude-flow', 'neural');
     // Prefer local directory if .claude-flow exists
     if (existsSync(join(cwd, '.claude-flow'))) {
         return localDir;
@@ -35,7 +91,7 @@ function getDataDir() {
  * Ensure the data directory exists
  */
 function ensureDataDir() {
-    const dir = getDataDir();
+    var dir = getDataDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
@@ -56,7 +112,7 @@ function getStatsPath() {
 // ============================================================================
 // Default Configuration
 // ============================================================================
-const DEFAULT_SONA_CONFIG = {
+var DEFAULT_SONA_CONFIG = {
     instantLoopEnabled: true,
     backgroundLoopEnabled: false,
     loraLearningRate: 0.001,
@@ -75,14 +131,13 @@ const DEFAULT_SONA_CONFIG = {
  * Uses circular buffer for O(1) signal recording
  * Achieves <0.05ms per operation
  */
-class LocalSonaCoordinator {
-    config;
-    signals;
-    signalHead = 0;
-    signalCount = 0;
-    trajectories = [];
-    adaptationTimes = [];
-    constructor(config) {
+var LocalSonaCoordinator = /** @class */ (function () {
+    function LocalSonaCoordinator(config) {
+        this.signalHead = 0;
+        this.signalCount = 0;
+        this.trajectories = [];
+        this.adaptationTimes = [];
+        this.currentTrajectorySteps = [];
         this.config = config;
         // Pre-allocate circular buffer
         this.signals = new Array(config.maxSignals);
@@ -91,75 +146,257 @@ class LocalSonaCoordinator {
      * Record a signal - O(1) operation
      * Target: <0.05ms
      */
-    recordSignal(signal) {
-        const start = performance.now();
+    LocalSonaCoordinator.prototype.recordSignal = function (signal) {
+        var start = performance.now();
         // Circular buffer insertion - constant time
         this.signals[this.signalHead] = signal;
         this.signalHead = (this.signalHead + 1) % this.config.maxSignals;
         if (this.signalCount < this.config.maxSignals) {
             this.signalCount++;
         }
-        const elapsed = performance.now() - start;
+        var elapsed = performance.now() - start;
         this.adaptationTimes.push(elapsed);
         if (this.adaptationTimes.length > 100) {
             this.adaptationTimes.shift();
         }
-    }
+    };
     /**
      * Record complete trajectory
      */
-    recordTrajectory(trajectory) {
+    LocalSonaCoordinator.prototype.recordTrajectory = function (trajectory) {
         this.trajectories.push(trajectory);
         if (this.trajectories.length > this.config.maxTrajectorySize) {
             this.trajectories.shift();
         }
-    }
+    };
     /**
      * Get recent signals
      */
-    getRecentSignals(count = 10) {
-        const result = [];
-        const actualCount = Math.min(count, this.signalCount);
-        for (let i = 0; i < actualCount; i++) {
-            const idx = (this.signalHead - 1 - i + this.config.maxSignals) % this.config.maxSignals;
+    LocalSonaCoordinator.prototype.getRecentSignals = function (count) {
+        if (count === void 0) { count = 10; }
+        var result = [];
+        var actualCount = Math.min(count, this.signalCount);
+        for (var i = 0; i < actualCount; i++) {
+            var idx = (this.signalHead - 1 - i + this.config.maxSignals) % this.config.maxSignals;
             if (this.signals[idx]) {
                 result.push(this.signals[idx]);
             }
         }
         return result;
-    }
+    };
     /**
      * Get average adaptation time
      */
-    getAvgAdaptationTime() {
+    LocalSonaCoordinator.prototype.getAvgAdaptationTime = function () {
         if (this.adaptationTimes.length === 0)
             return 0;
-        return this.adaptationTimes.reduce((a, b) => a + b, 0) / this.adaptationTimes.length;
-    }
+        return this.adaptationTimes.reduce(function (a, b) { return a + b; }, 0) / this.adaptationTimes.length;
+    };
+    /**
+     * Add a step to the current in-progress trajectory
+     */
+    LocalSonaCoordinator.prototype.addTrajectoryStep = function (step) {
+        this.currentTrajectorySteps.push(step);
+        // Prevent unbounded growth
+        if (this.currentTrajectorySteps.length > this.config.maxTrajectorySize) {
+            this.currentTrajectorySteps.shift();
+        }
+    };
+    /**
+     * End the current trajectory with a verdict and apply RL updates.
+     * Reward mapping: success=1.0, partial=0.5, failure=-0.5
+     *
+     * For successful/partial trajectories, boosts confidence of similar patterns
+     * in the ReasoningBank. For failures, reduces confidence scores.
+     */
+    LocalSonaCoordinator.prototype.endTrajectory = function (verdict, bank) {
+        var _a;
+        return __awaiter(this, void 0, Promise, function () {
+            var rewardMap, reward, completedTrajectory, patternsUpdated, allPatterns, _i, _b, step, similar, _c, similar_1, match, pattern, delta, newConfidence;
+            return __generator(this, function (_d) {
+                rewardMap = {
+                    success: 1.0,
+                    partial: 0.5,
+                    failure: -0.5
+                };
+                reward = (_a = rewardMap[verdict]) !== null && _a !== void 0 ? _a : 0;
+                completedTrajectory = {
+                    steps: __spreadArray([], this.currentTrajectorySteps, true),
+                    verdict: verdict,
+                    timestamp: Date.now()
+                };
+                this.recordTrajectory(completedTrajectory);
+                patternsUpdated = 0;
+                allPatterns = bank.getAll();
+                for (_i = 0, _b = this.currentTrajectorySteps; _i < _b.length; _i++) {
+                    step = _b[_i];
+                    if (!step.embedding || step.embedding.length === 0)
+                        continue;
+                    similar = bank.findSimilar(step.embedding, {
+                        k: 3,
+                        threshold: 0.3
+                    });
+                    for (_c = 0, similar_1 = similar; _c < similar_1.length; _c++) {
+                        match = similar_1[_c];
+                        pattern = bank.get(match.id);
+                        if (!pattern)
+                            continue;
+                        delta = reward * 0.1;
+                        newConfidence = Math.max(0.0, Math.min(1.0, pattern.confidence + delta));
+                        pattern.confidence = newConfidence;
+                        pattern.usageCount++;
+                        pattern.lastUsedAt = Date.now();
+                        patternsUpdated++;
+                    }
+                }
+                // Clear current trajectory
+                this.currentTrajectorySteps = [];
+                return [2 /*return*/, { reward: reward, patternsUpdated: patternsUpdated }];
+            });
+        });
+    };
+    /**
+     * Distill learning from recent successful trajectories.
+     * Applies LoRA-style confidence updates and integrates EWC++ consolidation.
+     *
+     * For each successful trajectory step with high confidence,
+     * increases the pattern's stored confidence by loraLearningRate * reward.
+     * Before applying updates, checks EWC penalty to prevent catastrophic forgetting.
+     */
+    LocalSonaCoordinator.prototype.distillLearning = function (bank) {
+        var _a;
+        return __awaiter(this, void 0, Promise, function () {
+            var patternsDistilled, totalEwcPenalty, recentSuccessful, ewcConsolidator, ewcModule, _b, rewardMap, confidenceChanges, _i, recentSuccessful_1, trajectory, reward, _c, _d, step, similar, _e, similar_2, match, pattern, oldConfidence, oldWeights, proposedConfidence, newWeights, penalty, dampedDelta, _loop_1, _f, confidenceChanges_1, change;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        patternsDistilled = 0;
+                        totalEwcPenalty = 0;
+                        recentSuccessful = this.trajectories.filter(function (t) { return t.verdict === 'success' || t.verdict === 'partial'; }).slice(-10);
+                        if (recentSuccessful.length === 0) {
+                            return [2 /*return*/, { patternsDistilled: 0, ewcPenalty: 0 }];
+                        }
+                        ewcConsolidator = null;
+                        _g.label = 1;
+                    case 1:
+                        _g.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, import('./ewc-consolidation.js')];
+                    case 2:
+                        ewcModule = _g.sent();
+                        return [4 /*yield*/, ewcModule.getEWCConsolidator({
+                                lambda: this.config.ewcLambda
+                            })];
+                    case 3:
+                        ewcConsolidator = _g.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        _b = _g.sent();
+                        return [3 /*break*/, 5];
+                    case 5:
+                        rewardMap = {
+                            success: 1.0,
+                            partial: 0.5
+                        };
+                        confidenceChanges = [];
+                        for (_i = 0, recentSuccessful_1 = recentSuccessful; _i < recentSuccessful_1.length; _i++) {
+                            trajectory = recentSuccessful_1[_i];
+                            reward = (_a = rewardMap[trajectory.verdict]) !== null && _a !== void 0 ? _a : 0;
+                            for (_c = 0, _d = trajectory.steps; _c < _d.length; _c++) {
+                                step = _d[_c];
+                                if (!step.embedding || step.embedding.length === 0)
+                                    continue;
+                                similar = bank.findSimilar(step.embedding, {
+                                    k: 3,
+                                    threshold: 0.4
+                                });
+                                for (_e = 0, similar_2 = similar; _e < similar_2.length; _e++) {
+                                    match = similar_2[_e];
+                                    pattern = bank.get(match.id);
+                                    if (!pattern)
+                                        continue;
+                                    // Only distill from high-confidence matches
+                                    if (match.confidence < 0.5)
+                                        continue;
+                                    oldConfidence = pattern.confidence;
+                                    // Check EWC penalty before applying update
+                                    if (ewcConsolidator) {
+                                        oldWeights = [oldConfidence];
+                                        proposedConfidence = Math.min(1.0, oldConfidence + this.config.loraLearningRate * reward);
+                                        newWeights = [proposedConfidence];
+                                        penalty = ewcConsolidator.getPenalty(oldWeights, newWeights);
+                                        totalEwcPenalty += penalty;
+                                        // If penalty is too high, reduce the update magnitude
+                                        if (penalty > this.config.ewcLambda) {
+                                            dampedDelta = (this.config.loraLearningRate * reward) / (1 + penalty);
+                                            pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + dampedDelta));
+                                        }
+                                        else {
+                                            pattern.confidence = proposedConfidence;
+                                        }
+                                    }
+                                    else {
+                                        // No EWC: apply full LoRA update
+                                        pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + this.config.loraLearningRate * reward));
+                                    }
+                                    pattern.lastUsedAt = Date.now();
+                                    patternsDistilled++;
+                                    confidenceChanges.push({
+                                        id: pattern.id,
+                                        oldConf: oldConfidence,
+                                        newConf: pattern.confidence,
+                                        embedding: pattern.embedding
+                                    });
+                                }
+                            }
+                        }
+                        // Update EWC Fisher matrix with confidence changes
+                        if (ewcConsolidator && confidenceChanges.length > 0) {
+                            _loop_1 = function (change) {
+                                // Use confidence delta as gradient proxy
+                                var gradient = change.embedding.map(function (e) { return e * Math.abs(change.newConf - change.oldConf); });
+                                ewcConsolidator.recordGradient(change.id, gradient, true);
+                            };
+                            for (_f = 0, confidenceChanges_1 = confidenceChanges; _f < confidenceChanges_1.length; _f++) {
+                                change = confidenceChanges_1[_f];
+                                _loop_1(change);
+                            }
+                        }
+                        // Persist updated patterns
+                        bank.flushToDisk();
+                        return [2 /*return*/, { patternsDistilled: patternsDistilled, ewcPenalty: totalEwcPenalty }];
+                }
+            });
+        });
+    };
+    /**
+     * Get current trajectory steps (for inspection)
+     */
+    LocalSonaCoordinator.prototype.getCurrentTrajectorySteps = function () {
+        return __spreadArray([], this.currentTrajectorySteps, true);
+    };
     /**
      * Get statistics
      */
-    stats() {
+    LocalSonaCoordinator.prototype.stats = function () {
         return {
             signalCount: this.signalCount,
             trajectoryCount: this.trajectories.length,
             avgAdaptationMs: this.getAvgAdaptationTime()
         };
-    }
-}
+    };
+    return LocalSonaCoordinator;
+}());
 /**
  * Lightweight ReasoningBank
  * Uses Map for O(1) storage and array for similarity search
  * Supports persistence to disk
  */
-class LocalReasoningBank {
-    patterns = new Map();
-    patternList = [];
-    maxSize;
-    persistenceEnabled;
-    dirty = false;
-    saveTimeout = null;
-    constructor(options) {
+var LocalReasoningBank = /** @class */ (function () {
+    function LocalReasoningBank(options) {
+        this.patterns = new Map();
+        this.patternList = [];
+        this.dirty = false;
+        this.saveTimeout = null;
         this.maxSize = options.maxSize;
         this.persistenceEnabled = options.persistence !== false;
         // Load persisted patterns
@@ -170,27 +407,29 @@ class LocalReasoningBank {
     /**
      * Load patterns from disk
      */
-    loadFromDisk() {
+    LocalReasoningBank.prototype.loadFromDisk = function () {
         try {
-            const path = getPatternsPath();
+            var path = getPatternsPath();
             if (existsSync(path)) {
-                const data = JSON.parse(readFileSync(path, 'utf-8'));
+                var data = JSON.parse(readFileSync(path, 'utf-8'));
                 if (Array.isArray(data)) {
-                    for (const pattern of data) {
+                    for (var _i = 0, data_1 = data; _i < data_1.length; _i++) {
+                        var pattern = data_1[_i];
                         this.patterns.set(pattern.id, pattern);
                         this.patternList.push(pattern);
                     }
                 }
             }
         }
-        catch {
+        catch (_a) {
             // Ignore load errors, start fresh
         }
-    }
+    };
     /**
      * Save patterns to disk (debounced)
      */
-    saveToDisk() {
+    LocalReasoningBank.prototype.saveToDisk = function () {
+        var _this = this;
         if (!this.persistenceEnabled)
             return;
         this.dirty = true;
@@ -198,19 +437,19 @@ class LocalReasoningBank {
         if (this.saveTimeout) {
             clearTimeout(this.saveTimeout);
         }
-        this.saveTimeout = setTimeout(() => {
-            this.flushToDisk();
+        this.saveTimeout = setTimeout(function () {
+            _this.flushToDisk();
         }, 100);
-    }
+    };
     /**
      * Immediately flush patterns to disk
      */
-    flushToDisk() {
+    LocalReasoningBank.prototype.flushToDisk = function () {
         if (!this.persistenceEnabled || !this.dirty)
             return;
         try {
             ensureDataDir();
-            const path = getPatternsPath();
+            var path = getPatternsPath();
             writeFileSync(path, JSON.stringify(this.patternList, null, 2), 'utf-8');
             this.dirty = false;
         }
@@ -218,25 +457,21 @@ class LocalReasoningBank {
             // Log but don't throw - persistence failures shouldn't break training
             console.error('Failed to persist patterns:', error);
         }
-    }
+    };
     /**
      * Store a pattern - O(1)
      */
-    store(pattern) {
-        const now = Date.now();
-        const stored = {
-            ...pattern,
-            usageCount: pattern.usageCount ?? 0,
-            createdAt: pattern.createdAt ?? now,
-            lastUsedAt: pattern.lastUsedAt ?? now
-        };
+    LocalReasoningBank.prototype.store = function (pattern) {
+        var _a, _b, _c;
+        var now = Date.now();
+        var stored = __assign(__assign({}, pattern), { usageCount: (_a = pattern.usageCount) !== null && _a !== void 0 ? _a : 0, createdAt: (_b = pattern.createdAt) !== null && _b !== void 0 ? _b : now, lastUsedAt: (_c = pattern.lastUsedAt) !== null && _c !== void 0 ? _c : now });
         // Update or insert
         if (this.patterns.has(pattern.id)) {
-            const existing = this.patterns.get(pattern.id);
+            var existing = this.patterns.get(pattern.id);
             stored.usageCount = existing.usageCount + 1;
             stored.createdAt = existing.createdAt;
             // Update in list
-            const idx = this.patternList.findIndex(p => p.id === pattern.id);
+            var idx = this.patternList.findIndex(function (p) { return p.id === pattern.id; });
             if (idx >= 0) {
                 this.patternList[idx] = stored;
             }
@@ -244,9 +479,9 @@ class LocalReasoningBank {
         else {
             // Evict oldest if at capacity
             if (this.patterns.size >= this.maxSize) {
-                const oldest = this.patternList.shift();
+                var oldest = this.patternList.shift();
                 if (oldest) {
-                    this.patterns.delete(oldest.id);
+                    this.patterns["delete"](oldest.id);
                 }
             }
             this.patternList.push(stored);
@@ -254,108 +489,110 @@ class LocalReasoningBank {
         this.patterns.set(pattern.id, stored);
         // Trigger persistence (debounced)
         this.saveToDisk();
-    }
+    };
     /**
      * Find similar patterns by embedding
      */
-    findSimilar(queryEmbedding, options) {
-        const { k = 5, threshold = 0.5, type } = options;
+    LocalReasoningBank.prototype.findSimilar = function (queryEmbedding, options) {
+        var _this = this;
+        var _a = options.k, k = _a === void 0 ? 5 : _a, _b = options.threshold, threshold = _b === void 0 ? 0.5 : _b, type = options.type;
         // Filter by type if specified
-        let candidates = type
-            ? this.patternList.filter(p => p.type === type)
+        var candidates = type
+            ? this.patternList.filter(function (p) { return p.type === type; })
             : this.patternList;
         // Compute similarities
-        const scored = candidates.map(pattern => ({
-            pattern,
-            score: this.cosineSim(queryEmbedding, pattern.embedding)
-        }));
+        var scored = candidates.map(function (pattern) { return ({
+            pattern: pattern,
+            score: _this.cosineSim(queryEmbedding, pattern.embedding)
+        }); });
         // Filter by threshold and sort
         return scored
-            .filter(s => s.score >= threshold)
-            .sort((a, b) => b.score - a.score)
+            .filter(function (s) { return s.score >= threshold; })
+            .sort(function (a, b) { return b.score - a.score; })
             .slice(0, k)
-            .map(s => {
+            .map(function (s) {
             // Update usage
             s.pattern.usageCount++;
             s.pattern.lastUsedAt = Date.now();
-            return { ...s.pattern, confidence: s.score };
+            return __assign(__assign({}, s.pattern), { confidence: s.score });
         });
-    }
+    };
     /**
      * Optimized cosine similarity
      */
-    cosineSim(a, b) {
+    LocalReasoningBank.prototype.cosineSim = function (a, b) {
         if (!a || !b || a.length === 0 || b.length === 0)
             return 0;
-        const len = Math.min(a.length, b.length);
-        let dot = 0, normA = 0, normB = 0;
-        for (let i = 0; i < len; i++) {
-            const ai = a[i], bi = b[i];
+        var len = Math.min(a.length, b.length);
+        var dot = 0, normA = 0, normB = 0;
+        for (var i = 0; i < len; i++) {
+            var ai = a[i], bi = b[i];
             dot += ai * bi;
             normA += ai * ai;
             normB += bi * bi;
         }
-        const mag = Math.sqrt(normA * normB);
+        var mag = Math.sqrt(normA * normB);
         return mag === 0 ? 0 : dot / mag;
-    }
+    };
     /**
      * Get statistics
      */
-    stats() {
+    LocalReasoningBank.prototype.stats = function () {
         return {
             size: this.patterns.size,
             patternCount: this.patternList.length
         };
-    }
+    };
     /**
      * Get pattern by ID
      */
-    get(id) {
+    LocalReasoningBank.prototype.get = function (id) {
         return this.patterns.get(id);
-    }
+    };
     /**
      * Get all patterns
      */
-    getAll() {
-        return [...this.patternList];
-    }
+    LocalReasoningBank.prototype.getAll = function () {
+        return __spreadArray([], this.patternList, true);
+    };
     /**
      * Get patterns by type
      */
-    getByType(type) {
-        return this.patternList.filter(p => p.type === type);
-    }
+    LocalReasoningBank.prototype.getByType = function (type) {
+        return this.patternList.filter(function (p) { return p.type === type; });
+    };
     /**
      * Delete a pattern by ID
      */
-    delete(id) {
-        const pattern = this.patterns.get(id);
+    LocalReasoningBank.prototype["delete"] = function (id) {
+        var pattern = this.patterns.get(id);
         if (!pattern)
             return false;
-        this.patterns.delete(id);
-        const idx = this.patternList.findIndex(p => p.id === id);
+        this.patterns["delete"](id);
+        var idx = this.patternList.findIndex(function (p) { return p.id === id; });
         if (idx >= 0) {
             this.patternList.splice(idx, 1);
         }
         this.saveToDisk();
         return true;
-    }
+    };
     /**
      * Clear all patterns
      */
-    clear() {
+    LocalReasoningBank.prototype.clear = function () {
         this.patterns.clear();
         this.patternList = [];
         this.saveToDisk();
-    }
-}
+    };
+    return LocalReasoningBank;
+}());
 // ============================================================================
 // Module State
 // ============================================================================
-let sonaCoordinator = null;
-let reasoningBank = null;
-let intelligenceInitialized = false;
-let globalStats = {
+var sonaCoordinator = null;
+var reasoningBank = null;
+var intelligenceInitialized = false;
+var globalStats = {
     trajectoriesRecorded: 0,
     lastAdaptation: null
 };
@@ -366,17 +603,18 @@ let globalStats = {
  * Load persisted stats from disk
  */
 function loadPersistedStats() {
+    var _a, _b;
     try {
-        const path = getStatsPath();
+        var path = getStatsPath();
         if (existsSync(path)) {
-            const data = JSON.parse(readFileSync(path, 'utf-8'));
+            var data = JSON.parse(readFileSync(path, 'utf-8'));
             if (data && typeof data === 'object') {
-                globalStats.trajectoriesRecorded = data.trajectoriesRecorded ?? 0;
-                globalStats.lastAdaptation = data.lastAdaptation ?? null;
+                globalStats.trajectoriesRecorded = (_a = data.trajectoriesRecorded) !== null && _a !== void 0 ? _a : 0;
+                globalStats.lastAdaptation = (_b = data.lastAdaptation) !== null && _b !== void 0 ? _b : null;
             }
         }
     }
-    catch {
+    catch (_c) {
         // Ignore load errors, start fresh
     }
 }
@@ -386,10 +624,10 @@ function loadPersistedStats() {
 function savePersistedStats() {
     try {
         ensureDataDir();
-        const path = getStatsPath();
+        var path = getStatsPath();
         writeFileSync(path, JSON.stringify(globalStats, null, 2), 'utf-8');
     }
-    catch {
+    catch (_a) {
         // Ignore save errors
     }
 }
@@ -400,157 +638,277 @@ function savePersistedStats() {
  * Initialize the intelligence system (SONA + ReasoningBank)
  * Uses optimized local implementations
  */
-export async function initializeIntelligence(config) {
-    if (intelligenceInitialized) {
-        return {
-            success: true,
-            sonaEnabled: !!sonaCoordinator,
-            reasoningBankEnabled: !!reasoningBank
-        };
-    }
-    try {
-        // Merge config with defaults
-        const finalConfig = {
-            ...DEFAULT_SONA_CONFIG,
-            ...config
-        };
-        // Initialize local SONA (optimized for <0.05ms)
-        sonaCoordinator = new LocalSonaCoordinator(finalConfig);
-        // Initialize local ReasoningBank with persistence enabled
-        reasoningBank = new LocalReasoningBank({
-            maxSize: finalConfig.maxPatterns,
-            persistence: true
+export function initializeIntelligence(config) {
+    return __awaiter(this, void 0, Promise, function () {
+        var finalConfig;
+        return __generator(this, function (_a) {
+            if (intelligenceInitialized) {
+                return [2 /*return*/, {
+                        success: true,
+                        sonaEnabled: !!sonaCoordinator,
+                        reasoningBankEnabled: !!reasoningBank
+                    }];
+            }
+            try {
+                finalConfig = __assign(__assign({}, DEFAULT_SONA_CONFIG), config);
+                // Initialize local SONA (optimized for <0.05ms)
+                sonaCoordinator = new LocalSonaCoordinator(finalConfig);
+                // Initialize local ReasoningBank with persistence enabled
+                reasoningBank = new LocalReasoningBank({
+                    maxSize: finalConfig.maxPatterns,
+                    persistence: true
+                });
+                // Load persisted stats if available
+                loadPersistedStats();
+                intelligenceInitialized = true;
+                return [2 /*return*/, {
+                        success: true,
+                        sonaEnabled: true,
+                        reasoningBankEnabled: true
+                    }];
+            }
+            catch (error) {
+                return [2 /*return*/, {
+                        success: false,
+                        sonaEnabled: false,
+                        reasoningBankEnabled: false,
+                        error: error instanceof Error ? error.message : String(error)
+                    }];
+            }
+            return [2 /*return*/];
         });
-        // Load persisted stats if available
-        loadPersistedStats();
-        intelligenceInitialized = true;
-        return {
-            success: true,
-            sonaEnabled: true,
-            reasoningBankEnabled: true
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            sonaEnabled: false,
-            reasoningBankEnabled: false,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
+    });
 }
 /**
  * Record a trajectory step for learning
  * Performance: <0.05ms without embedding generation
  */
-export async function recordStep(step) {
-    if (!sonaCoordinator) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return false;
-    }
-    try {
-        // Generate embedding if not provided
-        let embedding = step.embedding;
-        if (!embedding) {
-            const { generateEmbedding } = await import('./memory-initializer.js');
-            const result = await generateEmbedding(step.content);
-            embedding = result.embedding;
-        }
-        // Record in SONA - <0.05ms
-        sonaCoordinator.recordSignal({
-            type: step.type,
-            content: step.content,
-            embedding,
-            metadata: step.metadata,
-            timestamp: step.timestamp || Date.now()
+export function recordStep(step) {
+    var _a;
+    return __awaiter(this, void 0, Promise, function () {
+        var init, embedding, bridge, bridgeResult, _b, generateEmbedding, result, stepWithEmbedding, verdict, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    if (!!sonaCoordinator) return [3 /*break*/, 2];
+                    return [4 /*yield*/, initializeIntelligence()];
+                case 1:
+                    init = _d.sent();
+                    if (!init.success)
+                        return [2 /*return*/, false];
+                    _d.label = 2;
+                case 2:
+                    _d.trys.push([2, 14, , 15]);
+                    embedding = step.embedding;
+                    if (!!embedding) return [3 /*break*/, 10];
+                    _d.label = 3;
+                case 3:
+                    _d.trys.push([3, 6, , 7]);
+                    return [4 /*yield*/, import('./memory-bridge.js')];
+                case 4:
+                    bridge = _d.sent();
+                    return [4 /*yield*/, bridge.bridgeGenerateEmbedding(step.content)];
+                case 5:
+                    bridgeResult = _d.sent();
+                    if (bridgeResult) {
+                        embedding = bridgeResult.embedding;
+                    }
+                    return [3 /*break*/, 7];
+                case 6:
+                    _b = _d.sent();
+                    return [3 /*break*/, 7];
+                case 7:
+                    if (!!embedding) return [3 /*break*/, 10];
+                    return [4 /*yield*/, import('./memory-initializer.js')];
+                case 8:
+                    generateEmbedding = (_d.sent()).generateEmbedding;
+                    return [4 /*yield*/, generateEmbedding(step.content)];
+                case 9:
+                    result = _d.sent();
+                    embedding = result.embedding;
+                    _d.label = 10;
+                case 10:
+                    // Record in SONA - <0.05ms
+                    sonaCoordinator.recordSignal({
+                        type: step.type,
+                        content: step.content,
+                        embedding: embedding,
+                        metadata: step.metadata,
+                        timestamp: step.timestamp || Date.now()
+                    });
+                    stepWithEmbedding = __assign(__assign({}, step), { embedding: embedding });
+                    sonaCoordinator.addTrajectoryStep(stepWithEmbedding);
+                    // Store in ReasoningBank for retrieval
+                    if (reasoningBank) {
+                        reasoningBank.store({
+                            id: "step_" + Date.now() + "_" + Math.random().toString(36).substring(7),
+                            type: step.type,
+                            embedding: embedding,
+                            content: step.content,
+                            confidence: 1.0,
+                            metadata: step.metadata
+                        });
+                    }
+                    if (!(step.type === 'result' && reasoningBank)) return [3 /*break*/, 13];
+                    verdict = ((_a = step.metadata) === null || _a === void 0 ? void 0 : _a.verdict) || 'partial';
+                    return [4 /*yield*/, sonaCoordinator.endTrajectory(verdict, reasoningBank)];
+                case 11:
+                    _d.sent();
+                    // Distill learning from recent successful trajectories
+                    return [4 /*yield*/, sonaCoordinator.distillLearning(reasoningBank)];
+                case 12:
+                    // Distill learning from recent successful trajectories
+                    _d.sent();
+                    globalStats.lastAdaptation = Date.now();
+                    _d.label = 13;
+                case 13:
+                    globalStats.trajectoriesRecorded++;
+                    savePersistedStats();
+                    return [2 /*return*/, true];
+                case 14:
+                    _c = _d.sent();
+                    return [2 /*return*/, false];
+                case 15: return [2 /*return*/];
+            }
         });
-        // Store in ReasoningBank for retrieval
-        if (reasoningBank) {
-            reasoningBank.store({
-                id: `step_${Date.now()}_${Math.random().toString(36).substring(7)}`,
-                type: step.type,
-                embedding,
-                content: step.content,
-                confidence: 1.0,
-                metadata: step.metadata
-            });
-        }
-        globalStats.trajectoriesRecorded++;
-        savePersistedStats();
-        return true;
-    }
-    catch {
-        return false;
-    }
+    });
 }
 /**
  * Record a complete trajectory with verdict
  */
-export async function recordTrajectory(steps, verdict) {
-    if (!sonaCoordinator) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return false;
-    }
-    try {
-        sonaCoordinator.recordTrajectory({
-            steps,
-            verdict,
-            timestamp: Date.now()
+export function recordTrajectory(steps, verdict) {
+    return __awaiter(this, void 0, Promise, function () {
+        var init, _i, steps_1, step, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!!sonaCoordinator) return [3 /*break*/, 2];
+                    return [4 /*yield*/, initializeIntelligence()];
+                case 1:
+                    init = _b.sent();
+                    if (!init.success)
+                        return [2 /*return*/, false];
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 6, , 7]);
+                    sonaCoordinator.recordTrajectory({
+                        steps: steps,
+                        verdict: verdict,
+                        timestamp: Date.now()
+                    });
+                    if (!reasoningBank) return [3 /*break*/, 5];
+                    // Load steps into the coordinator for endTrajectory processing
+                    for (_i = 0, steps_1 = steps; _i < steps_1.length; _i++) {
+                        step = steps_1[_i];
+                        sonaCoordinator.addTrajectoryStep(step);
+                    }
+                    return [4 /*yield*/, sonaCoordinator.endTrajectory(verdict, reasoningBank)];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, sonaCoordinator.distillLearning(reasoningBank)];
+                case 4:
+                    _b.sent();
+                    _b.label = 5;
+                case 5:
+                    globalStats.trajectoriesRecorded++;
+                    globalStats.lastAdaptation = Date.now();
+                    savePersistedStats();
+                    return [2 /*return*/, true];
+                case 6:
+                    _a = _b.sent();
+                    return [2 /*return*/, false];
+                case 7: return [2 /*return*/];
+            }
         });
-        globalStats.trajectoriesRecorded++;
-        globalStats.lastAdaptation = Date.now();
-        savePersistedStats();
-        return true;
-    }
-    catch {
-        return false;
-    }
+    });
 }
-export async function findSimilarPatterns(query, options) {
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return [];
-    }
-    try {
-        const { generateEmbedding } = await import('./memory-initializer.js');
-        const queryResult = await generateEmbedding(query);
-        const results = reasoningBank.findSimilar(queryResult.embedding, {
-            k: options?.k ?? 5,
-            threshold: options?.threshold ?? 0.5,
-            type: options?.type
+export function findSimilarPatterns(query, options) {
+    var _a, _b;
+    return __awaiter(this, void 0, Promise, function () {
+        var init, queryEmbedding, bridge, bridgeResult, _c, generateEmbedding, queryResult, isHashFallback, defaultThreshold, results, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    if (!!reasoningBank) return [3 /*break*/, 2];
+                    return [4 /*yield*/, initializeIntelligence()];
+                case 1:
+                    init = _e.sent();
+                    if (!init.success)
+                        return [2 /*return*/, []];
+                    _e.label = 2;
+                case 2:
+                    _e.trys.push([2, 11, , 12]);
+                    queryEmbedding = null;
+                    _e.label = 3;
+                case 3:
+                    _e.trys.push([3, 6, , 7]);
+                    return [4 /*yield*/, import('./memory-bridge.js')];
+                case 4:
+                    bridge = _e.sent();
+                    return [4 /*yield*/, bridge.bridgeGenerateEmbedding(query)];
+                case 5:
+                    bridgeResult = _e.sent();
+                    if (bridgeResult) {
+                        queryEmbedding = bridgeResult.embedding;
+                    }
+                    return [3 /*break*/, 7];
+                case 6:
+                    _c = _e.sent();
+                    return [3 /*break*/, 7];
+                case 7:
+                    if (!!queryEmbedding) return [3 /*break*/, 10];
+                    return [4 /*yield*/, import('./memory-initializer.js')];
+                case 8:
+                    generateEmbedding = (_e.sent()).generateEmbedding;
+                    return [4 /*yield*/, generateEmbedding(query)];
+                case 9:
+                    queryResult = _e.sent();
+                    queryEmbedding = queryResult.embedding;
+                    _e.label = 10;
+                case 10:
+                    isHashFallback = queryEmbedding.length === 128;
+                    defaultThreshold = isHashFallback ? 0.1 : 0.5;
+                    results = reasoningBank.findSimilar(queryEmbedding, {
+                        k: (_a = options === null || options === void 0 ? void 0 : options.k) !== null && _a !== void 0 ? _a : 5,
+                        threshold: (_b = options === null || options === void 0 ? void 0 : options.threshold) !== null && _b !== void 0 ? _b : defaultThreshold,
+                        type: options === null || options === void 0 ? void 0 : options.type
+                    });
+                    return [2 /*return*/, results.map(function (r) {
+                            var _a, _b;
+                            return ({
+                                id: r.id,
+                                type: r.type,
+                                embedding: r.embedding,
+                                content: r.content,
+                                confidence: r.confidence,
+                                usageCount: r.usageCount,
+                                createdAt: r.createdAt,
+                                lastUsedAt: r.lastUsedAt,
+                                similarity: (_b = (_a = r.similarity) !== null && _a !== void 0 ? _a : r.confidence) !== null && _b !== void 0 ? _b : 0.5
+                            });
+                        })];
+                case 11:
+                    _d = _e.sent();
+                    return [2 /*return*/, []];
+                case 12: return [2 /*return*/];
+            }
         });
-        return results.map((r) => ({
-            id: r.id,
-            type: r.type,
-            embedding: r.embedding,
-            content: r.content,
-            confidence: r.confidence,
-            usageCount: r.usageCount,
-            createdAt: r.createdAt,
-            lastUsedAt: r.lastUsedAt,
-            similarity: r.similarity ?? r.confidence ?? 0.5
-        }));
-    }
-    catch {
-        return [];
-    }
+    });
 }
 /**
  * Get intelligence system statistics
  */
 export function getIntelligenceStats() {
-    const sonaStats = sonaCoordinator?.stats();
-    const bankStats = reasoningBank?.stats();
+    var _a, _b, _c;
+    var sonaStats = sonaCoordinator === null || sonaCoordinator === void 0 ? void 0 : sonaCoordinator.stats();
+    var bankStats = reasoningBank === null || reasoningBank === void 0 ? void 0 : reasoningBank.stats();
     return {
         sonaEnabled: !!sonaCoordinator,
-        reasoningBankSize: bankStats?.size ?? 0,
-        patternsLearned: bankStats?.patternCount ?? 0,
+        reasoningBankSize: (_a = bankStats === null || bankStats === void 0 ? void 0 : bankStats.size) !== null && _a !== void 0 ? _a : 0,
+        patternsLearned: (_b = bankStats === null || bankStats === void 0 ? void 0 : bankStats.patternCount) !== null && _b !== void 0 ? _b : 0,
         trajectoriesRecorded: globalStats.trajectoriesRecorded,
         lastAdaptation: globalStats.lastAdaptation,
-        avgAdaptationTime: sonaStats?.avgAdaptationMs ?? 0
+        avgAdaptationTime: (_c = sonaStats === null || sonaStats === void 0 ? void 0 : sonaStats.avgAdaptationMs) !== null && _c !== void 0 ? _c : 0
     };
 }
 /**
@@ -565,6 +923,77 @@ export function getSonaCoordinator() {
 export function getReasoningBank() {
     return reasoningBank;
 }
+/**
+ * End the current trajectory with a verdict and apply RL updates.
+ * This is the public API for the SONA RL loop.
+ *
+ * @param verdict - 'success' (reward=1.0), 'partial' (0.5), or 'failure' (-0.5)
+ * @returns Update statistics or null if not initialized
+ */
+export function endTrajectoryWithVerdict(verdict) {
+    return __awaiter(this, void 0, Promise, function () {
+        var init, result, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!(!sonaCoordinator || !reasoningBank)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, initializeIntelligence()];
+                case 1:
+                    init = _b.sent();
+                    if (!init.success)
+                        return [2 /*return*/, null];
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, sonaCoordinator.endTrajectory(verdict, reasoningBank)];
+                case 3:
+                    result = _b.sent();
+                    globalStats.lastAdaptation = Date.now();
+                    savePersistedStats();
+                    return [2 /*return*/, result];
+                case 4:
+                    _a = _b.sent();
+                    return [2 /*return*/, null];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Distill learning from recent successful trajectories.
+ * Applies LoRA-style confidence updates with EWC++ consolidation protection.
+ *
+ * @returns Distillation statistics or null if not initialized
+ */
+export function distillLearning() {
+    return __awaiter(this, void 0, Promise, function () {
+        var init, result, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!(!sonaCoordinator || !reasoningBank)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, initializeIntelligence()];
+                case 1:
+                    init = _b.sent();
+                    if (!init.success)
+                        return [2 /*return*/, null];
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, sonaCoordinator.distillLearning(reasoningBank)];
+                case 3:
+                    result = _b.sent();
+                    globalStats.lastAdaptation = Date.now();
+                    savePersistedStats();
+                    return [2 /*return*/, result];
+                case 4:
+                    _a = _b.sent();
+                    return [2 /*return*/, null];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
 /**
  * Clear intelligence state
  */
@@ -580,31 +1009,32 @@ export function clearIntelligence() {
 /**
  * Benchmark SONA adaptation time
  */
-export function benchmarkAdaptation(iterations = 1000) {
+export function benchmarkAdaptation(iterations) {
+    if (iterations === void 0) { iterations = 1000; }
     if (!sonaCoordinator) {
         initializeIntelligence();
     }
-    const times = [];
-    const testEmbedding = Array.from({ length: 384 }, () => Math.random());
-    for (let i = 0; i < iterations; i++) {
-        const start = performance.now();
+    var times = [];
+    var testEmbedding = Array.from({ length: 384 }, function () { return Math.random(); });
+    for (var i = 0; i < iterations; i++) {
+        var start = performance.now();
         sonaCoordinator.recordSignal({
             type: 'test',
-            content: `benchmark_${i}`,
+            content: "benchmark_" + i,
             embedding: testEmbedding,
             timestamp: Date.now()
         });
         times.push(performance.now() - start);
     }
-    const totalMs = times.reduce((a, b) => a + b, 0);
-    const avgMs = totalMs / iterations;
-    const minMs = Math.min(...times);
-    const maxMs = Math.max(...times);
+    var totalMs = times.reduce(function (a, b) { return a + b; }, 0);
+    var avgMs = totalMs / iterations;
+    var minMs = Math.min.apply(Math, times);
+    var maxMs = Math.max.apply(Math, times);
     return {
-        totalMs,
-        avgMs,
-        minMs,
-        maxMs,
+        totalMs: totalMs,
+        avgMs: avgMs,
+        minMs: minMs,
+        maxMs: maxMs,
         targetMet: avgMs < 0.05
     };
 }
@@ -615,42 +1045,62 @@ export function benchmarkAdaptation(iterations = 1000) {
  * Get all patterns from ReasoningBank
  * Returns persisted patterns even after process restart
  */
-export async function getAllPatterns() {
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return [];
-    }
-    return reasoningBank.getAll().map(p => ({
-        id: p.id,
-        type: p.type,
-        embedding: p.embedding,
-        content: p.content,
-        confidence: p.confidence,
-        usageCount: p.usageCount,
-        createdAt: p.createdAt,
-        lastUsedAt: p.lastUsedAt
-    }));
+export function getAllPatterns() {
+    return __awaiter(this, void 0, Promise, function () {
+        var init;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!reasoningBank) return [3 /*break*/, 2];
+                    return [4 /*yield*/, initializeIntelligence()];
+                case 1:
+                    init = _a.sent();
+                    if (!init.success)
+                        return [2 /*return*/, []];
+                    _a.label = 2;
+                case 2: return [2 /*return*/, reasoningBank.getAll().map(function (p) { return ({
+                        id: p.id,
+                        type: p.type,
+                        embedding: p.embedding,
+                        content: p.content,
+                        confidence: p.confidence,
+                        usageCount: p.usageCount,
+                        createdAt: p.createdAt,
+                        lastUsedAt: p.lastUsedAt
+                    }); })];
+            }
+        });
+    });
 }
 /**
  * Get patterns by type from ReasoningBank
  */
-export async function getPatternsByType(type) {
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return [];
-    }
-    return reasoningBank.getByType(type).map(p => ({
-        id: p.id,
-        type: p.type,
-        embedding: p.embedding,
-        content: p.content,
-        confidence: p.confidence,
-        usageCount: p.usageCount,
-        createdAt: p.createdAt,
-        lastUsedAt: p.lastUsedAt
-    }));
+export function getPatternsByType(type) {
+    return __awaiter(this, void 0, Promise, function () {
+        var init;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!reasoningBank) return [3 /*break*/, 2];
+                    return [4 /*yield*/, initializeIntelligence()];
+                case 1:
+                    init = _a.sent();
+                    if (!init.success)
+                        return [2 /*return*/, []];
+                    _a.label = 2;
+                case 2: return [2 /*return*/, reasoningBank.getByType(type).map(function (p) { return ({
+                        id: p.id,
+                        type: p.type,
+                        embedding: p.embedding,
+                        content: p.content,
+                        confidence: p.confidence,
+                        usageCount: p.usageCount,
+                        createdAt: p.createdAt,
+                        lastUsedAt: p.lastUsedAt
+                    }); })];
+            }
+        });
+    });
 }
 /**
  * Flush patterns to disk immediately
@@ -666,80 +1116,112 @@ export function flushPatterns() {
  * Compact patterns by removing duplicates/similar patterns
  * @param threshold Similarity threshold (0-1), patterns above this are considered duplicates
  */
-export async function compactPatterns(threshold = 0.95) {
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success) {
-            return { before: 0, after: 0, removed: 0 };
-        }
-    }
-    const patterns = reasoningBank.getAll();
-    const before = patterns.length;
-    // Find duplicates using cosine similarity
-    const toRemove = new Set();
-    for (let i = 0; i < patterns.length; i++) {
-        if (toRemove.has(patterns[i].id))
-            continue;
-        const embA = patterns[i].embedding;
-        if (!embA || embA.length === 0)
-            continue;
-        for (let j = i + 1; j < patterns.length; j++) {
-            if (toRemove.has(patterns[j].id))
-                continue;
-            const embB = patterns[j].embedding;
-            if (!embB || embB.length === 0 || embA.length !== embB.length)
-                continue;
-            // Compute cosine similarity
-            let dotProduct = 0;
-            let normA = 0;
-            let normB = 0;
-            for (let k = 0; k < embA.length; k++) {
-                dotProduct += embA[k] * embB[k];
-                normA += embA[k] * embA[k];
-                normB += embB[k] * embB[k];
-            }
-            const similarity = dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-            if (similarity >= threshold) {
-                // Remove the one with lower usage count
-                const useA = patterns[i].usageCount || 0;
-                const useB = patterns[j].usageCount || 0;
-                toRemove.add(useA >= useB ? patterns[j].id : patterns[i].id);
+export function compactPatterns(threshold) {
+    if (threshold === void 0) { threshold = 0.95; }
+    return __awaiter(this, void 0, Promise, function () {
+        var init, patterns, before, toRemove, i, embA, j, embB, dotProduct, normA, normB, k, similarity, useA, useB, _i, toRemove_1, id;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!reasoningBank) return [3 /*break*/, 2];
+                    return [4 /*yield*/, initializeIntelligence()];
+                case 1:
+                    init = _a.sent();
+                    if (!init.success) {
+                        return [2 /*return*/, { before: 0, after: 0, removed: 0 }];
+                    }
+                    _a.label = 2;
+                case 2:
+                    patterns = reasoningBank.getAll();
+                    before = patterns.length;
+                    toRemove = new Set();
+                    for (i = 0; i < patterns.length; i++) {
+                        if (toRemove.has(patterns[i].id))
+                            continue;
+                        embA = patterns[i].embedding;
+                        if (!embA || embA.length === 0)
+                            continue;
+                        for (j = i + 1; j < patterns.length; j++) {
+                            if (toRemove.has(patterns[j].id))
+                                continue;
+                            embB = patterns[j].embedding;
+                            if (!embB || embB.length === 0 || embA.length !== embB.length)
+                                continue;
+                            dotProduct = 0;
+                            normA = 0;
+                            normB = 0;
+                            for (k = 0; k < embA.length; k++) {
+                                dotProduct += embA[k] * embB[k];
+                                normA += embA[k] * embA[k];
+                                normB += embB[k] * embB[k];
+                            }
+                            similarity = dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+                            if (similarity >= threshold) {
+                                useA = patterns[i].usageCount || 0;
+                                useB = patterns[j].usageCount || 0;
+                                toRemove.add(useA >= useB ? patterns[j].id : patterns[i].id);
+                            }
+                        }
+                    }
+                    // Remove duplicates
+                    for (_i = 0, toRemove_1 = toRemove; _i < toRemove_1.length; _i++) {
+                        id = toRemove_1[_i];
+                        reasoningBank["delete"](id);
+                    }
+                    // Flush to disk
+                    flushPatterns();
+                    return [2 /*return*/, {
+                            before: before,
+                            after: before - toRemove.size,
+                            removed: toRemove.size
+                        }];
             }
-        }
-    }
-    // Remove duplicates
-    for (const id of toRemove) {
-        reasoningBank.delete(id);
-    }
-    // Flush to disk
-    flushPatterns();
-    return {
-        before,
-        after: before - toRemove.size,
-        removed: toRemove.size,
-    };
+        });
+    });
 }
 /**
  * Delete a pattern by ID
  */
-export async function deletePattern(id) {
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return false;
-    }
-    return reasoningBank.delete(id);
+export function deletePattern(id) {
+    return __awaiter(this, void 0, Promise, function () {
+        var init;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!reasoningBank) return [3 /*break*/, 2];
+                    return [4 /*yield*/, initializeIntelligence()];
+                case 1:
+                    init = _a.sent();
+                    if (!init.success)
+                        return [2 /*return*/, false];
+                    _a.label = 2;
+                case 2: return [2 /*return*/, reasoningBank["delete"](id)];
+            }
+        });
+    });
 }
 /**
  * Clear all patterns (both in memory and on disk)
  */
-export async function clearAllPatterns() {
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return;
-    }
-    reasoningBank.clear();
+export function clearAllPatterns() {
+    return __awaiter(this, void 0, Promise, function () {
+        var init;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!reasoningBank) return [3 /*break*/, 2];
+                    return [4 /*yield*/, initializeIntelligence()];
+                case 1:
+                    init = _a.sent();
+                    if (!init.success)
+                        return [2 /*return*/];
+                    _a.label = 2;
+                case 2:
+                    reasoningBank.clear();
+                    return [2 /*return*/];
+            }
+        });
+    });
 }
 /**
  * Get the neural data directory path
@@ -751,14 +1233,14 @@ export function getNeuralDataDir() {
  * Get persistence status
  */
 export function getPersistenceStatus() {
-    const dataDir = getDataDir();
-    const patternsFile = getPatternsPath();
-    const statsFile = getStatsPath();
+    var dataDir = getDataDir();
+    var patternsFile = getPatternsPath();
+    var statsFile = getStatsPath();
     return {
         enabled: true,
-        dataDir,
-        patternsFile,
-        statsFile,
+        dataDir: dataDir,
+        patternsFile: patternsFile,
+        statsFile: statsFile,
         patternsExist: existsSync(patternsFile),
         statsExist: existsSync(statsFile)
     };