kynjal-cli 4.0.0 → 4.0.1

package/dist/src/memory/intelligence.js

@@ -10,62 +10,6 @@
  *
  * @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';
@@ -78,9 +22,9 @@ import { join } from 'node:path';
  * falling back to home directory
  */
 function getDataDir() {
-    var cwd = process.cwd();
-    var localDir = join(cwd, '.claude-flow', 'neural');
-    var homeDir = join(homedir(), '.claude-flow', 'neural');
+    const cwd = process.cwd();
+    const localDir = join(cwd, '.claude-flow', 'neural');
+    const homeDir = join(homedir(), '.claude-flow', 'neural');
     // Prefer local directory if .claude-flow exists
     if (existsSync(join(cwd, '.claude-flow'))) {
         return localDir;
@@ -91,7 +35,7 @@ function getDataDir() {
  * Ensure the data directory exists
  */
 function ensureDataDir() {
-    var dir = getDataDir();
+    const dir = getDataDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
@@ -112,7 +56,7 @@ function getStatsPath() {
 // ============================================================================
 // Default Configuration
 // ============================================================================
-var DEFAULT_SONA_CONFIG = {
+const DEFAULT_SONA_CONFIG = {
     instantLoopEnabled: true,
     backgroundLoopEnabled: false,
     loraLearningRate: 0.001,
@@ -131,13 +75,15 @@ var DEFAULT_SONA_CONFIG = {
  * Uses circular buffer for O(1) signal recording
  * Achieves <0.05ms per operation
  */
-var LocalSonaCoordinator = /** @class */ (function () {
-    function LocalSonaCoordinator(config) {
-        this.signalHead = 0;
-        this.signalCount = 0;
-        this.trajectories = [];
-        this.adaptationTimes = [];
-        this.currentTrajectorySteps = [];
+class LocalSonaCoordinator {
+    config;
+    signals;
+    signalHead = 0;
+    signalCount = 0;
+    trajectories = [];
+    adaptationTimes = [];
+    currentTrajectorySteps = [];
+    constructor(config) {
         this.config = config;
         // Pre-allocate circular buffer
         this.signals = new Array(config.maxSignals);
@@ -146,62 +92,61 @@ var LocalSonaCoordinator = /** @class */ (function () {
      * Record a signal - O(1) operation
      * Target: <0.05ms
      */
-    LocalSonaCoordinator.prototype.recordSignal = function (signal) {
-        var start = performance.now();
+    recordSignal(signal) {
+        const 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++;
         }
-        var elapsed = performance.now() - start;
+        const elapsed = performance.now() - start;
         this.adaptationTimes.push(elapsed);
         if (this.adaptationTimes.length > 100) {
             this.adaptationTimes.shift();
         }
-    };
+    }
     /**
      * Record complete trajectory
      */
-    LocalSonaCoordinator.prototype.recordTrajectory = function (trajectory) {
+    recordTrajectory(trajectory) {
         this.trajectories.push(trajectory);
         if (this.trajectories.length > this.config.maxTrajectorySize) {
             this.trajectories.shift();
         }
-    };
+    }
     /**
      * Get recent signals
      */
-    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;
+    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;
             if (this.signals[idx]) {
                 result.push(this.signals[idx]);
             }
         }
         return result;
-    };
+    }
     /**
      * Get average adaptation time
      */
-    LocalSonaCoordinator.prototype.getAvgAdaptationTime = function () {
+    getAvgAdaptationTime() {
         if (this.adaptationTimes.length === 0)
             return 0;
-        return this.adaptationTimes.reduce(function (a, b) { return a + b; }, 0) / this.adaptationTimes.length;
-    };
+        return this.adaptationTimes.reduce((a, b) => a + b, 0) / this.adaptationTimes.length;
+    }
     /**
      * Add a step to the current in-progress trajectory
      */
-    LocalSonaCoordinator.prototype.addTrajectoryStep = function (step) {
+    addTrajectoryStep(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
@@ -209,52 +154,48 @@ var LocalSonaCoordinator = /** @class */ (function () {
      * 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 }];
+    async endTrajectory(verdict, bank) {
+        const rewardMap = {
+            success: 1.0,
+            partial: 0.5,
+            failure: -0.5
+        };
+        const reward = rewardMap[verdict] ?? 0;
+        // Record the completed trajectory
+        const completedTrajectory = {
+            steps: [...this.currentTrajectorySteps],
+            verdict,
+            timestamp: Date.now()
+        };
+        this.recordTrajectory(completedTrajectory);
+        // Update pattern confidences based on reward
+        let patternsUpdated = 0;
+        const allPatterns = bank.getAll();
+        for (const step of this.currentTrajectorySteps) {
+            if (!step.embedding || step.embedding.length === 0)
+                continue;
+            // Find patterns similar to this trajectory step
+            const similar = bank.findSimilar(step.embedding, {
+                k: 3,
+                threshold: 0.3
             });
-        });
-    };
+            for (const match of similar) {
+                const pattern = bank.get(match.id);
+                if (!pattern)
+                    continue;
+                // Adjust confidence: positive reward boosts, negative reduces
+                const delta = reward * 0.1; // small step per update
+                const 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 { reward, patternsUpdated };
+    }
     /**
      * Distill learning from recent successful trajectories.
      * Applies LoRA-style confidence updates and integrates EWC++ consolidation.
@@ -263,140 +204,121 @@ var LocalSonaCoordinator = /** @class */ (function () {
      * 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
-                                    });
-                                }
-                            }
+    async distillLearning(bank) {
+        let patternsDistilled = 0;
+        let totalEwcPenalty = 0;
+        // Get recent successful trajectories
+        const recentSuccessful = this.trajectories.filter(t => t.verdict === 'success' || t.verdict === 'partial').slice(-10); // last 10 successful
+        if (recentSuccessful.length === 0) {
+            return { patternsDistilled: 0, ewcPenalty: 0 };
+        }
+        // Try to get EWC consolidator
+        let ewcConsolidator = null;
+        try {
+            const ewcModule = await import('./ewc-consolidation.js');
+            ewcConsolidator = await ewcModule.getEWCConsolidator({
+                lambda: this.config.ewcLambda
+            });
+        }
+        catch {
+            // EWC not available, proceed without consolidation protection
+        }
+        const rewardMap = {
+            success: 1.0,
+            partial: 0.5
+        };
+        // Collect confidence changes for EWC Fisher update
+        const confidenceChanges = [];
+        for (const trajectory of recentSuccessful) {
+            const reward = rewardMap[trajectory.verdict] ?? 0;
+            for (const step of trajectory.steps) {
+                if (!step.embedding || step.embedding.length === 0)
+                    continue;
+                const similar = bank.findSimilar(step.embedding, {
+                    k: 3,
+                    threshold: 0.4
+                });
+                for (const match of similar) {
+                    const pattern = bank.get(match.id);
+                    if (!pattern)
+                        continue;
+                    // Only distill from high-confidence matches
+                    if (match.confidence < 0.5)
+                        continue;
+                    const oldConfidence = pattern.confidence;
+                    // Check EWC penalty before applying update
+                    if (ewcConsolidator) {
+                        const oldWeights = [oldConfidence];
+                        const proposedConfidence = Math.min(1.0, oldConfidence + this.config.loraLearningRate * reward);
+                        const newWeights = [proposedConfidence];
+                        const penalty = ewcConsolidator.getPenalty(oldWeights, newWeights);
+                        totalEwcPenalty += penalty;
+                        // If penalty is too high, reduce the update magnitude
+                        if (penalty > this.config.ewcLambda) {
+                            const dampedDelta = (this.config.loraLearningRate * reward) / (1 + penalty);
+                            pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + dampedDelta));
                         }
-                        // 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);
-                            }
+                        else {
+                            pattern.confidence = proposedConfidence;
                         }
-                        // Persist updated patterns
-                        bank.flushToDisk();
-                        return [2 /*return*/, { patternsDistilled: patternsDistilled, ewcPenalty: totalEwcPenalty }];
+                    }
+                    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) {
+            for (const change of confidenceChanges) {
+                // Use confidence delta as gradient proxy
+                const gradient = change.embedding.map(e => e * Math.abs(change.newConf - change.oldConf));
+                ewcConsolidator.recordGradient(change.id, gradient, true);
+            }
+        }
+        // Persist updated patterns
+        bank.flushToDisk();
+        return { patternsDistilled, ewcPenalty: totalEwcPenalty };
+    }
     /**
      * Get current trajectory steps (for inspection)
      */
-    LocalSonaCoordinator.prototype.getCurrentTrajectorySteps = function () {
-        return __spreadArray([], this.currentTrajectorySteps, true);
-    };
+    getCurrentTrajectorySteps() {
+        return [...this.currentTrajectorySteps];
+    }
     /**
      * Get statistics
      */
-    LocalSonaCoordinator.prototype.stats = function () {
+    stats() {
         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
  */
-var LocalReasoningBank = /** @class */ (function () {
-    function LocalReasoningBank(options) {
-        this.patterns = new Map();
-        this.patternList = [];
-        this.dirty = false;
-        this.saveTimeout = null;
+class LocalReasoningBank {
+    patterns = new Map();
+    patternList = [];
+    maxSize;
+    persistenceEnabled;
+    dirty = false;
+    saveTimeout = null;
+    constructor(options) {
         this.maxSize = options.maxSize;
         this.persistenceEnabled = options.persistence !== false;
         // Load persisted patterns
@@ -407,29 +329,27 @@ var LocalReasoningBank = /** @class */ (function () {
     /**
      * Load patterns from disk
      */
-    LocalReasoningBank.prototype.loadFromDisk = function () {
+    loadFromDisk() {
         try {
-            var path = getPatternsPath();
+            const path = getPatternsPath();
             if (existsSync(path)) {
-                var data = JSON.parse(readFileSync(path, 'utf-8'));
+                const data = JSON.parse(readFileSync(path, 'utf-8'));
                 if (Array.isArray(data)) {
-                    for (var _i = 0, data_1 = data; _i < data_1.length; _i++) {
-                        var pattern = data_1[_i];
+                    for (const pattern of data) {
                         this.patterns.set(pattern.id, pattern);
                         this.patternList.push(pattern);
                     }
                 }
             }
         }
-        catch (_a) {
+        catch {
             // Ignore load errors, start fresh
         }
-    };
+    }
     /**
      * Save patterns to disk (debounced)
      */
-    LocalReasoningBank.prototype.saveToDisk = function () {
-        var _this = this;
+    saveToDisk() {
         if (!this.persistenceEnabled)
             return;
         this.dirty = true;
@@ -437,19 +357,19 @@ var LocalReasoningBank = /** @class */ (function () {
         if (this.saveTimeout) {
             clearTimeout(this.saveTimeout);
         }
-        this.saveTimeout = setTimeout(function () {
-            _this.flushToDisk();
+        this.saveTimeout = setTimeout(() => {
+            this.flushToDisk();
         }, 100);
-    };
+    }
     /**
      * Immediately flush patterns to disk
      */
-    LocalReasoningBank.prototype.flushToDisk = function () {
+    flushToDisk() {
         if (!this.persistenceEnabled || !this.dirty)
             return;
         try {
             ensureDataDir();
-            var path = getPatternsPath();
+            const path = getPatternsPath();
             writeFileSync(path, JSON.stringify(this.patternList, null, 2), 'utf-8');
             this.dirty = false;
         }
@@ -457,21 +377,25 @@ var LocalReasoningBank = /** @class */ (function () {
             // Log but don't throw - persistence failures shouldn't break training
             console.error('Failed to persist patterns:', error);
         }
-    };
+    }
     /**
      * Store a pattern - O(1)
      */
-    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 });
+    store(pattern) {
+        const now = Date.now();
+        const stored = {
+            ...pattern,
+            usageCount: pattern.usageCount ?? 0,
+            createdAt: pattern.createdAt ?? now,
+            lastUsedAt: pattern.lastUsedAt ?? now
+        };
         // Update or insert
         if (this.patterns.has(pattern.id)) {
-            var existing = this.patterns.get(pattern.id);
+            const existing = this.patterns.get(pattern.id);
             stored.usageCount = existing.usageCount + 1;
             stored.createdAt = existing.createdAt;
             // Update in list
-            var idx = this.patternList.findIndex(function (p) { return p.id === pattern.id; });
+            const idx = this.patternList.findIndex(p => p.id === pattern.id);
             if (idx >= 0) {
                 this.patternList[idx] = stored;
             }
@@ -479,9 +403,9 @@ var LocalReasoningBank = /** @class */ (function () {
         else {
             // Evict oldest if at capacity
             if (this.patterns.size >= this.maxSize) {
-                var oldest = this.patternList.shift();
+                const oldest = this.patternList.shift();
                 if (oldest) {
-                    this.patterns["delete"](oldest.id);
+                    this.patterns.delete(oldest.id);
                 }
             }
             this.patternList.push(stored);
@@ -489,110 +413,108 @@ var LocalReasoningBank = /** @class */ (function () {
         this.patterns.set(pattern.id, stored);
         // Trigger persistence (debounced)
         this.saveToDisk();
-    };
+    }
     /**
      * Find similar patterns by embedding
      */
-    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;
+    findSimilar(queryEmbedding, options) {
+        const { k = 5, threshold = 0.5, type } = options;
         // Filter by type if specified
-        var candidates = type
-            ? this.patternList.filter(function (p) { return p.type === type; })
+        let candidates = type
+            ? this.patternList.filter(p => p.type === type)
             : this.patternList;
         // Compute similarities
-        var scored = candidates.map(function (pattern) { return ({
-            pattern: pattern,
-            score: _this.cosineSim(queryEmbedding, pattern.embedding)
-        }); });
+        const scored = candidates.map(pattern => ({
+            pattern,
+            score: this.cosineSim(queryEmbedding, pattern.embedding)
+        }));
         // Filter by threshold and sort
         return scored
-            .filter(function (s) { return s.score >= threshold; })
-            .sort(function (a, b) { return b.score - a.score; })
+            .filter(s => s.score >= threshold)
+            .sort((a, b) => b.score - a.score)
             .slice(0, k)
-            .map(function (s) {
+            .map(s => {
             // Update usage
             s.pattern.usageCount++;
             s.pattern.lastUsedAt = Date.now();
-            return __assign(__assign({}, s.pattern), { confidence: s.score });
+            return { ...s.pattern, confidence: s.score };
         });
-    };
+    }
     /**
      * Optimized cosine similarity
      */
-    LocalReasoningBank.prototype.cosineSim = function (a, b) {
+    cosineSim(a, b) {
         if (!a || !b || a.length === 0 || b.length === 0)
             return 0;
-        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];
+        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];
             dot += ai * bi;
             normA += ai * ai;
             normB += bi * bi;
         }
-        var mag = Math.sqrt(normA * normB);
+        const mag = Math.sqrt(normA * normB);
         return mag === 0 ? 0 : dot / mag;
-    };
+    }
     /**
      * Get statistics
      */
-    LocalReasoningBank.prototype.stats = function () {
+    stats() {
         return {
             size: this.patterns.size,
             patternCount: this.patternList.length
         };
-    };
+    }
     /**
      * Get pattern by ID
      */
-    LocalReasoningBank.prototype.get = function (id) {
+    get(id) {
         return this.patterns.get(id);
-    };
+    }
     /**
      * Get all patterns
      */
-    LocalReasoningBank.prototype.getAll = function () {
-        return __spreadArray([], this.patternList, true);
-    };
+    getAll() {
+        return [...this.patternList];
+    }
     /**
      * Get patterns by type
      */
-    LocalReasoningBank.prototype.getByType = function (type) {
-        return this.patternList.filter(function (p) { return p.type === type; });
-    };
+    getByType(type) {
+        return this.patternList.filter(p => p.type === type);
+    }
     /**
      * Delete a pattern by ID
      */
-    LocalReasoningBank.prototype["delete"] = function (id) {
-        var pattern = this.patterns.get(id);
+    delete(id) {
+        const pattern = this.patterns.get(id);
         if (!pattern)
             return false;
-        this.patterns["delete"](id);
-        var idx = this.patternList.findIndex(function (p) { return p.id === id; });
+        this.patterns.delete(id);
+        const idx = this.patternList.findIndex(p => p.id === id);
         if (idx >= 0) {
             this.patternList.splice(idx, 1);
         }
         this.saveToDisk();
         return true;
-    };
+    }
     /**
      * Clear all patterns
      */
-    LocalReasoningBank.prototype.clear = function () {
+    clear() {
         this.patterns.clear();
         this.patternList = [];
         this.saveToDisk();
-    };
-    return LocalReasoningBank;
-}());
+    }
+}
 // ============================================================================
 // Module State
 // ============================================================================
-var sonaCoordinator = null;
-var reasoningBank = null;
-var intelligenceInitialized = false;
-var globalStats = {
+let sonaCoordinator = null;
+let reasoningBank = null;
+let intelligenceInitialized = false;
+let globalStats = {
     trajectoriesRecorded: 0,
     lastAdaptation: null
 };
@@ -603,18 +525,17 @@ var globalStats = {
  * Load persisted stats from disk
  */
 function loadPersistedStats() {
-    var _a, _b;
     try {
-        var path = getStatsPath();
+        const path = getStatsPath();
         if (existsSync(path)) {
-            var data = JSON.parse(readFileSync(path, 'utf-8'));
+            const data = JSON.parse(readFileSync(path, 'utf-8'));
             if (data && typeof data === 'object') {
-                globalStats.trajectoriesRecorded = (_a = data.trajectoriesRecorded) !== null && _a !== void 0 ? _a : 0;
-                globalStats.lastAdaptation = (_b = data.lastAdaptation) !== null && _b !== void 0 ? _b : null;
+                globalStats.trajectoriesRecorded = data.trajectoriesRecorded ?? 0;
+                globalStats.lastAdaptation = data.lastAdaptation ?? null;
             }
         }
     }
-    catch (_c) {
+    catch {
         // Ignore load errors, start fresh
     }
 }
@@ -624,10 +545,10 @@ function loadPersistedStats() {
 function savePersistedStats() {
     try {
         ensureDataDir();
-        var path = getStatsPath();
+        const path = getStatsPath();
         writeFileSync(path, JSON.stringify(globalStats, null, 2), 'utf-8');
     }
-    catch (_a) {
+    catch {
         // Ignore save errors
     }
 }
@@ -638,277 +559,210 @@ function savePersistedStats() {
  * Initialize the intelligence system (SONA + ReasoningBank)
  * Uses optimized local implementations
  */
-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*/];
+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
         });
-    });
+        // 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 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*/];
+export async function recordStep(step) {
+    if (!sonaCoordinator) {
+        const init = await initializeIntelligence();
+        if (!init.success)
+            return false;
+    }
+    try {
+        // Generate embedding if not provided
+        // ADR-053: Try AgentDB v3 bridge embedder first
+        let embedding = step.embedding;
+        if (!embedding) {
+            try {
+                const bridge = await import('./memory-bridge.js');
+                const bridgeResult = await bridge.bridgeGenerateEmbedding(step.content);
+                if (bridgeResult) {
+                    embedding = bridgeResult.embedding;
+                }
+            }
+            catch {
+                // Bridge not available
+            }
+            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()
         });
-    });
+        // Add to current trajectory for RL tracking
+        const stepWithEmbedding = { ...step, 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,
+                content: step.content,
+                confidence: 1.0,
+                metadata: step.metadata
+            });
+        }
+        // When a 'result' step arrives, end the trajectory and run RL loop
+        if (step.type === 'result' && reasoningBank) {
+            // Determine verdict from metadata or default to 'partial'
+            const verdict = step.metadata?.verdict || 'partial';
+            await sonaCoordinator.endTrajectory(verdict, reasoningBank);
+            // Distill learning from recent successful trajectories
+            await sonaCoordinator.distillLearning(reasoningBank);
+            globalStats.lastAdaptation = Date.now();
+        }
+        globalStats.trajectoriesRecorded++;
+        savePersistedStats();
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * Record a complete trajectory with verdict
  */
-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*/];
-            }
+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()
         });
-    });
+        // Apply RL: update pattern confidences based on verdict
+        if (reasoningBank) {
+            // Load steps into the coordinator for endTrajectory processing
+            for (const step of steps) {
+                sonaCoordinator.addTrajectoryStep(step);
+            }
+            await sonaCoordinator.endTrajectory(verdict, reasoningBank);
+            await sonaCoordinator.distillLearning(reasoningBank);
+        }
+        globalStats.trajectoriesRecorded++;
+        globalStats.lastAdaptation = Date.now();
+        savePersistedStats();
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
-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*/];
+export async function findSimilarPatterns(query, options) {
+    if (!reasoningBank) {
+        const init = await initializeIntelligence();
+        if (!init.success)
+            return [];
+    }
+    try {
+        // ADR-053: Try AgentDB v3 bridge embedder first
+        let queryEmbedding = null;
+        try {
+            const bridge = await import('./memory-bridge.js');
+            const bridgeResult = await bridge.bridgeGenerateEmbedding(query);
+            if (bridgeResult) {
+                queryEmbedding = bridgeResult.embedding;
             }
+        }
+        catch {
+            // Bridge not available
+        }
+        if (!queryEmbedding) {
+            const { generateEmbedding } = await import('./memory-initializer.js');
+            const queryResult = await generateEmbedding(query);
+            queryEmbedding = queryResult.embedding;
+        }
+        // Hash-fallback embeddings (128-dim) produce lower cosine similarities
+        // than ONNX/transformer embeddings, so use a lower default threshold
+        const isHashFallback = queryEmbedding.length === 128;
+        const defaultThreshold = isHashFallback ? 0.1 : 0.5;
+        const results = reasoningBank.findSimilar(queryEmbedding, {
+            k: options?.k ?? 5,
+            threshold: options?.threshold ?? defaultThreshold,
+            type: options?.type
         });
-    });
+        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() {
-    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();
+    const sonaStats = sonaCoordinator?.stats();
+    const bankStats = reasoningBank?.stats();
     return {
         sonaEnabled: !!sonaCoordinator,
-        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,
+        reasoningBankSize: bankStats?.size ?? 0,
+        patternsLearned: bankStats?.patternCount ?? 0,
         trajectoriesRecorded: globalStats.trajectoriesRecorded,
         lastAdaptation: globalStats.lastAdaptation,
-        avgAdaptationTime: (_c = sonaStats === null || sonaStats === void 0 ? void 0 : sonaStats.avgAdaptationMs) !== null && _c !== void 0 ? _c : 0
+        avgAdaptationTime: sonaStats?.avgAdaptationMs ?? 0
     };
 }
 /**
@@ -930,34 +784,21 @@ export function getReasoningBank() {
  * @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*/];
-            }
-        });
-    });
+export async function endTrajectoryWithVerdict(verdict) {
+    if (!sonaCoordinator || !reasoningBank) {
+        const init = await initializeIntelligence();
+        if (!init.success)
+            return null;
+    }
+    try {
+        const result = await sonaCoordinator.endTrajectory(verdict, reasoningBank);
+        globalStats.lastAdaptation = Date.now();
+        savePersistedStats();
+        return result;
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Distill learning from recent successful trajectories.
@@ -965,34 +806,21 @@ export function endTrajectoryWithVerdict(verdict) {
  *
  * @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*/];
-            }
-        });
-    });
+export async function distillLearning() {
+    if (!sonaCoordinator || !reasoningBank) {
+        const init = await initializeIntelligence();
+        if (!init.success)
+            return null;
+    }
+    try {
+        const result = await sonaCoordinator.distillLearning(reasoningBank);
+        globalStats.lastAdaptation = Date.now();
+        savePersistedStats();
+        return result;
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Clear intelligence state
@@ -1009,32 +837,31 @@ export function clearIntelligence() {
 /**
  * Benchmark SONA adaptation time
  */
-export function benchmarkAdaptation(iterations) {
-    if (iterations === void 0) { iterations = 1000; }
+export function benchmarkAdaptation(iterations = 1000) {
     if (!sonaCoordinator) {
         initializeIntelligence();
     }
-    var times = [];
-    var testEmbedding = Array.from({ length: 384 }, function () { return Math.random(); });
-    for (var i = 0; i < iterations; i++) {
-        var start = performance.now();
+    const times = [];
+    const testEmbedding = Array.from({ length: 384 }, () => Math.random());
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
         sonaCoordinator.recordSignal({
             type: 'test',
-            content: "benchmark_" + i,
+            content: `benchmark_${i}`,
             embedding: testEmbedding,
             timestamp: Date.now()
         });
         times.push(performance.now() - start);
     }
-    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);
+    const totalMs = times.reduce((a, b) => a + b, 0);
+    const avgMs = totalMs / iterations;
+    const minMs = Math.min(...times);
+    const maxMs = Math.max(...times);
     return {
-        totalMs: totalMs,
-        avgMs: avgMs,
-        minMs: minMs,
-        maxMs: maxMs,
+        totalMs,
+        avgMs,
+        minMs,
+        maxMs,
         targetMet: avgMs < 0.05
     };
 }
@@ -1045,62 +872,42 @@ export function benchmarkAdaptation(iterations) {
  * Get all patterns from ReasoningBank
  * Returns persisted patterns even after process restart
  */
-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
-                    }); })];
-            }
-        });
-    });
+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
+    }));
 }
 /**
  * Get patterns by type from ReasoningBank
  */
-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
-                    }); })];
-            }
-        });
-    });
+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
+    }));
 }
 /**
  * Flush patterns to disk immediately
@@ -1116,112 +923,80 @@ export function flushPatterns() {
  * Compact patterns by removing duplicates/similar patterns
  * @param threshold Similarity threshold (0-1), patterns above this are considered duplicates
  */
-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
-                        }];
+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);
+            }
+        }
+    }
+    // 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 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)];
-            }
-        });
-    });
+export async function deletePattern(id) {
+    if (!reasoningBank) {
+        const init = await initializeIntelligence();
+        if (!init.success)
+            return false;
+    }
+    return reasoningBank.delete(id);
 }
 /**
  * Clear all patterns (both in memory and on disk)
  */
-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*/];
-            }
-        });
-    });
+export async function clearAllPatterns() {
+    if (!reasoningBank) {
+        const init = await initializeIntelligence();
+        if (!init.success)
+            return;
+    }
+    reasoningBank.clear();
 }
 /**
  * Get the neural data directory path
@@ -1233,14 +1008,14 @@ export function getNeuralDataDir() {
  * Get persistence status
  */
 export function getPersistenceStatus() {
-    var dataDir = getDataDir();
-    var patternsFile = getPatternsPath();
-    var statsFile = getStatsPath();
+    const dataDir = getDataDir();
+    const patternsFile = getPatternsPath();
+    const statsFile = getStatsPath();
     return {
         enabled: true,
-        dataDir: dataDir,
-        patternsFile: patternsFile,
-        statsFile: statsFile,
+        dataDir,
+        patternsFile,
+        statsFile,
         patternsExist: existsSync(patternsFile),
         statsExist: existsSync(statsFile)
     };