kynjal-cli 3.1.3 → 4.0.0

package/dist/src/memory/sona-optimizer.js

@@ -13,23 +13,79 @@
  *
  * @module v3/cli/memory/sona-optimizer
  */
+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 'fs';
 import { dirname, join } from 'path';
 // ============================================================================
 // Constants
 // ============================================================================
-const DEFAULT_PERSISTENCE_PATH = '.swarm/sona-patterns.json';
-const PATTERN_VERSION = '1.0.0';
-const MIN_CONFIDENCE = 0.1;
-const MAX_CONFIDENCE = 0.99;
-const CONFIDENCE_INCREMENT = 0.1;
-const CONFIDENCE_DECREMENT = 0.15;
-const DECAY_RATE = 0.01; // Per day
-const MAX_PATTERNS = 1000;
+var DEFAULT_PERSISTENCE_PATH = '.swarm/sona-patterns.json';
+var PATTERN_VERSION = '1.0.0';
+var MIN_CONFIDENCE = 0.1;
+var MAX_CONFIDENCE = 0.99;
+var CONFIDENCE_INCREMENT = 0.1;
+var CONFIDENCE_DECREMENT = 0.15;
+var DECAY_RATE = 0.01; // Per day
+var MAX_PATTERNS = 1000;
 /**
  * Common agent types for routing
  */
-const AGENT_TYPES = [
+var AGENT_TYPES = [
     'coder',
     'tester',
     'reviewer',
@@ -44,7 +100,7 @@ const AGENT_TYPES = [
 /**
  * Task keywords for pattern extraction
  */
-const KEYWORD_CATEGORIES = {
+var KEYWORD_CATEGORIES = {
     coder: [
         'implement', 'code', 'write', 'create', 'build', 'develop', 'add',
         'feature', 'function', 'class', 'module', 'api', 'endpoint',
@@ -69,7 +125,7 @@ const KEYWORD_CATEGORIES = {
         'optimize', 'performance', 'speed', 'memory', 'improve', 'enhance',
         'faster', 'efficient', 'reduce', 'benchmark',
     ],
-    debugger: [
+    "debugger": [
         'debug', 'fix', 'bug', 'error', 'issue', 'problem', 'crash',
         'exception', 'trace', 'diagnose', 'resolve',
     ],
@@ -84,7 +140,7 @@ const KEYWORD_CATEGORIES = {
     'performance-engineer': [
         'profiling', 'bottleneck', 'latency', 'throughput', 'cache',
         'scale', 'load', 'stress', 'concurrent', 'parallel',
-    ],
+    ]
 };
 // ============================================================================
 // SONAOptimizer Class
@@ -95,69 +151,81 @@ const KEYWORD_CATEGORIES = {
  * Learns from past task outcomes to improve future routing decisions.
  * Integrates with Q-learning router for hybrid routing strategy.
  */
-export class SONAOptimizer {
-    patterns = new Map();
-    trajectoriesProcessed = 0;
-    successfulRoutings = 0;
-    failedRoutings = 0;
-    lastUpdate = null;
-    persistencePath;
-    qLearningRouter = null;
-    qLearningEnabled = false;
-    constructor(options) {
-        this.persistencePath = options?.persistencePath || DEFAULT_PERSISTENCE_PATH;
+var SONAOptimizer = /** @class */ (function () {
+    function SONAOptimizer(options) {
+        this.patterns = new Map();
+        this.trajectoriesProcessed = 0;
+        this.successfulRoutings = 0;
+        this.failedRoutings = 0;
+        this.lastUpdate = null;
+        this.qLearningRouter = null;
+        this.qLearningEnabled = false;
+        this.persistencePath = (options === null || options === void 0 ? void 0 : options.persistencePath) || DEFAULT_PERSISTENCE_PATH;
     }
     /**
      * Initialize the optimizer and load persisted state
      */
-    async initialize() {
-        // Load persisted patterns
-        const loaded = this.loadFromDisk();
-        // Try to load Q-learning router lazily
-        try {
-            const { QLearningRouter } = await import('../ruvector/q-learning-router.js');
-            this.qLearningRouter = new QLearningRouter();
-            await this.qLearningRouter.initialize();
-            this.qLearningEnabled = true;
-        }
-        catch {
-            // Q-learning not available, continue without it
-            this.qLearningEnabled = false;
-        }
-        return {
-            success: true,
-            patternsLoaded: loaded ? this.patterns.size : 0,
-        };
-    }
+    SONAOptimizer.prototype.initialize = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var loaded, QLearningRouter, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        loaded = this.loadFromDisk();
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, import('../ruvector/q-learning-router.js')];
+                    case 2:
+                        QLearningRouter = (_b.sent()).QLearningRouter;
+                        this.qLearningRouter = new QLearningRouter();
+                        return [4 /*yield*/, this.qLearningRouter.initialize()];
+                    case 3:
+                        _b.sent();
+                        this.qLearningEnabled = true;
+                        return [3 /*break*/, 5];
+                    case 4:
+                        _a = _b.sent();
+                        // Q-learning not available, continue without it
+                        this.qLearningEnabled = false;
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/, {
+                            success: true,
+                            patternsLoaded: loaded ? this.patterns.size : 0
+                        }];
+                }
+            });
+        });
+    };
     /**
      * Process a trajectory outcome and learn from it
      * Called by hooksTrajectoryEnd
      */
-    processTrajectoryOutcome(outcome) {
-        const { task, agent, success } = outcome;
+    SONAOptimizer.prototype.processTrajectoryOutcome = function (outcome) {
+        var task = outcome.task, agent = outcome.agent, success = outcome.success;
         // Extract keywords from task
-        const keywords = this.extractKeywords(task);
+        var keywords = this.extractKeywords(task);
         if (keywords.length === 0) {
             return {
                 learned: false,
                 patternKey: '',
                 confidence: 0,
-                keywordsExtracted: [],
+                keywordsExtracted: []
             };
         }
         // Create pattern key from sorted keywords
-        const patternKey = this.createPatternKey(keywords, agent);
+        var patternKey = this.createPatternKey(keywords, agent);
         // Get or create pattern
-        let pattern = this.patterns.get(patternKey);
+        var pattern = this.patterns.get(patternKey);
         if (!pattern) {
             pattern = {
-                keywords,
-                agent,
-                confidence: 0.5, // Start at neutral
+                keywords: keywords,
+                agent: agent,
+                confidence: 0.5,
                 successCount: 0,
                 failureCount: 0,
                 lastUsed: Date.now(),
-                createdAt: Date.now(),
+                createdAt: Date.now()
             };
         }
         // Update pattern based on outcome
@@ -180,25 +248,25 @@ export class SONAOptimizer {
         this.prunePatterns();
         // Update Q-learning router if available
         if (this.qLearningRouter) {
-            const reward = success ? 1.0 : -0.5;
+            var reward = success ? 1.0 : -0.5;
             this.qLearningRouter.update(task, agent, reward);
         }
         // Persist to disk (debounced)
         this.saveToDisk();
         return {
             learned: true,
-            patternKey,
+            patternKey: patternKey,
             confidence: pattern.confidence,
-            keywordsExtracted: keywords,
+            keywordsExtracted: keywords
         };
-    }
+    };
     /**
      * Get routing suggestion based on learned patterns
      */
-    getRoutingSuggestion(task) {
-        const keywords = this.extractKeywords(task);
+    SONAOptimizer.prototype.getRoutingSuggestion = function (task) {
+        var keywords = this.extractKeywords(task);
         // Try SONA pattern matching first
-        const sonaResult = this.findBestPatternMatch(keywords);
+        var sonaResult = this.findBestPatternMatch(keywords);
         if (sonaResult && sonaResult.confidence >= 0.6) {
             return {
                 agent: sonaResult.agent,
@@ -206,29 +274,29 @@ export class SONAOptimizer {
                 usedQLearning: false,
                 source: 'sona-pattern',
                 alternatives: this.getAlternatives(keywords, sonaResult.agent),
-                matchedKeywords: sonaResult.matchedKeywords,
+                matchedKeywords: sonaResult.matchedKeywords
             };
         }
         // Try Q-learning router if available
         if (this.qLearningRouter && this.qLearningEnabled) {
             try {
-                const decision = this.qLearningRouter.route(task, false);
+                var decision = this.qLearningRouter.route(task, false);
                 if (decision.confidence >= 0.5) {
                     return {
                         agent: decision.route,
                         confidence: decision.confidence,
                         usedQLearning: true,
                         source: 'q-learning',
-                        alternatives: decision.alternatives,
+                        alternatives: decision.alternatives
                     };
                 }
             }
-            catch {
+            catch (_a) {
                 // Q-learning failed, continue to fallback
             }
         }
         // Fallback to keyword-based heuristic
-        const keywordMatch = this.matchKeywordsToAgent(keywords);
+        var keywordMatch = this.matchKeywordsToAgent(keywords);
         if (keywordMatch) {
             return {
                 agent: keywordMatch.agent,
@@ -236,7 +304,7 @@ export class SONAOptimizer {
                 usedQLearning: false,
                 source: 'keyword-match',
                 alternatives: this.getAlternatives(keywords, keywordMatch.agent),
-                matchedKeywords: keywordMatch.matchedKeywords,
+                matchedKeywords: keywordMatch.matchedKeywords
             };
         }
         // Default fallback
@@ -248,15 +316,16 @@ export class SONAOptimizer {
             alternatives: [
                 { agent: 'researcher', score: 0.2 },
                 { agent: 'architect', score: 0.15 },
-            ],
+            ]
         };
-    }
+    };
     /**
      * Get optimizer statistics
      */
-    getStats() {
-        let totalConfidence = 0;
-        for (const pattern of this.patterns.values()) {
+    SONAOptimizer.prototype.getStats = function () {
+        var totalConfidence = 0;
+        for (var _i = 0, _a = this.patterns.values(); _i < _a.length; _i++) {
+            var pattern = _a[_i];
             totalConfidence += pattern.confidence;
         }
         return {
@@ -266,24 +335,25 @@ export class SONAOptimizer {
             trajectoriesProcessed: this.trajectoriesProcessed,
             avgConfidence: this.patterns.size > 0 ? totalConfidence / this.patterns.size : 0,
             qLearningEnabled: this.qLearningEnabled,
-            lastUpdate: this.lastUpdate,
+            lastUpdate: this.lastUpdate
         };
-    }
+    };
     /**
      * Apply temporal decay to pattern confidence
      * Reduces confidence of unused patterns
      */
-    applyTemporalDecay() {
-        const now = Date.now();
-        let decayed = 0;
-        for (const [key, pattern] of this.patterns) {
-            const daysSinceUse = (now - pattern.lastUsed) / (1000 * 60 * 60 * 24);
+    SONAOptimizer.prototype.applyTemporalDecay = function () {
+        var now = Date.now();
+        var decayed = 0;
+        for (var _i = 0, _a = this.patterns; _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], pattern = _b[1];
+            var daysSinceUse = (now - pattern.lastUsed) / (1000 * 60 * 60 * 24);
             if (daysSinceUse > 1) {
-                const decay = Math.exp(-DECAY_RATE * daysSinceUse);
-                const newConfidence = pattern.confidence * decay;
+                var decay = Math.exp(-DECAY_RATE * daysSinceUse);
+                var newConfidence = pattern.confidence * decay;
                 if (newConfidence < MIN_CONFIDENCE) {
                     // Remove patterns with very low confidence
-                    this.patterns.delete(key);
+                    this.patterns["delete"](key);
                 }
                 else {
                     pattern.confidence = newConfidence;
@@ -295,11 +365,11 @@ export class SONAOptimizer {
             this.saveToDisk();
         }
         return decayed;
-    }
+    };
     /**
      * Reset all learned patterns
      */
-    reset() {
+    SONAOptimizer.prototype.reset = function () {
         this.patterns.clear();
         this.trajectoriesProcessed = 0;
         this.successfulRoutings = 0;
@@ -309,23 +379,25 @@ export class SONAOptimizer {
             this.qLearningRouter.reset();
         }
         this.saveToDisk();
-    }
+    };
     /**
      * Export patterns for analysis
      */
-    exportPatterns() {
-        const result = {};
-        for (const [key, pattern] of this.patterns) {
-            result[key] = { ...pattern };
+    SONAOptimizer.prototype.exportPatterns = function () {
+        var result = {};
+        for (var _i = 0, _a = this.patterns; _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], pattern = _b[1];
+            result[key] = __assign({}, pattern);
         }
         return result;
-    }
+    };
     /**
      * Import patterns (for migration or testing)
      */
-    importPatterns(patterns) {
-        let imported = 0;
-        for (const [key, pattern] of Object.entries(patterns)) {
+    SONAOptimizer.prototype.importPatterns = function (patterns) {
+        var imported = 0;
+        for (var _i = 0, _a = Object.entries(patterns); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], pattern = _b[1];
             if (this.validatePattern(pattern)) {
                 this.patterns.set(key, pattern);
                 imported++;
@@ -333,99 +405,108 @@ export class SONAOptimizer {
         }
         this.saveToDisk();
         return imported;
-    }
+    };
     // ============================================================================
     // Private Methods
     // ============================================================================
     /**
      * Extract meaningful keywords from task description
      */
-    extractKeywords(task) {
+    SONAOptimizer.prototype.extractKeywords = function (task) {
         if (!task || typeof task !== 'string') {
             return [];
         }
-        const lower = task.toLowerCase();
-        const words = lower.split(/[\s\-_.,;:!?'"()\[\]{}]+/).filter(w => w.length > 2);
+        var lower = task.toLowerCase();
+        var words = lower.split(/[\s\-_.,;:!?'"()\[\]{}]+/).filter(function (w) { return w.length > 2; });
         // Extract keywords that match our categories
-        const keywords = new Set();
-        for (const categoryKeywords of Object.values(KEYWORD_CATEGORIES)) {
-            for (const keyword of categoryKeywords) {
+        var keywords = new Set();
+        for (var _i = 0, _a = Object.values(KEYWORD_CATEGORIES); _i < _a.length; _i++) {
+            var categoryKeywords = _a[_i];
+            for (var _b = 0, categoryKeywords_1 = categoryKeywords; _b < categoryKeywords_1.length; _b++) {
+                var keyword = categoryKeywords_1[_b];
                 if (lower.includes(keyword)) {
                     keywords.add(keyword);
                 }
             }
         }
         // Add any significant words not in categories
-        for (const word of words) {
+        for (var _c = 0, words_1 = words; _c < words_1.length; _c++) {
+            var word = words_1[_c];
             if (word.length >= 4 && !this.isStopWord(word)) {
                 keywords.add(word);
             }
         }
         return Array.from(keywords).slice(0, 10); // Limit to 10 keywords
-    }
+    };
     /**
      * Check if word is a stop word
      */
-    isStopWord(word) {
-        const stopWords = new Set([
+    SONAOptimizer.prototype.isStopWord = function (word) {
+        var stopWords = new Set([
             'the', 'and', 'for', 'that', 'this', 'with', 'from', 'have', 'been',
             'will', 'would', 'could', 'should', 'into', 'then', 'than', 'when',
             'where', 'which', 'there', 'their', 'what', 'about', 'more', 'some',
             'also', 'just', 'only', 'other', 'very', 'after', 'most', 'such',
         ]);
         return stopWords.has(word);
-    }
+    };
     /**
      * Create a unique pattern key from keywords and agent
      */
-    createPatternKey(keywords, agent) {
-        const sortedKeywords = [...keywords].sort();
-        return `${agent}:${sortedKeywords.join('+')}`;
-    }
+    SONAOptimizer.prototype.createPatternKey = function (keywords, agent) {
+        var sortedKeywords = __spreadArray([], keywords, true).sort();
+        return agent + ":" + sortedKeywords.join('+');
+    };
     /**
      * Find the best matching pattern for given keywords
      */
-    findBestPatternMatch(keywords) {
+    SONAOptimizer.prototype.findBestPatternMatch = function (keywords) {
         if (keywords.length === 0 || this.patterns.size === 0) {
             return null;
         }
-        let bestMatch = null;
-        let bestScore = 0;
-        for (const pattern of this.patterns.values()) {
-            const matchedKeywords = pattern.keywords.filter(k => keywords.includes(k));
-            const matchRatio = matchedKeywords.length / Math.max(pattern.keywords.length, keywords.length);
+        var bestMatch = null;
+        var bestScore = 0;
+        for (var _i = 0, _a = this.patterns.values(); _i < _a.length; _i++) {
+            var pattern = _a[_i];
+            var matchedKeywords = pattern.keywords.filter(function (k) { return keywords.includes(k); });
+            var matchRatio = matchedKeywords.length / Math.max(pattern.keywords.length, keywords.length);
             // Combine match ratio with confidence
-            const score = matchRatio * pattern.confidence;
+            var score = matchRatio * pattern.confidence;
             if (score > bestScore && matchedKeywords.length >= 1) {
                 bestScore = score;
                 bestMatch = {
                     agent: pattern.agent,
                     confidence: pattern.confidence * matchRatio,
-                    matchedKeywords,
+                    matchedKeywords: matchedKeywords
                 };
             }
         }
         return bestMatch;
-    }
+    };
     /**
      * Match keywords to agent using category heuristics
      */
-    matchKeywordsToAgent(keywords) {
-        const scores = {};
-        for (const [agent, categoryKeywords] of Object.entries(KEYWORD_CATEGORIES)) {
-            const matched = keywords.filter(k => categoryKeywords.includes(k));
+    SONAOptimizer.prototype.matchKeywordsToAgent = function (keywords) {
+        var scores = {};
+        var _loop_1 = function (agent, categoryKeywords) {
+            var matched = keywords.filter(function (k) { return categoryKeywords.includes(k); });
             if (matched.length > 0) {
                 scores[agent] = {
                     score: matched.length / categoryKeywords.length,
-                    matched,
+                    matched: matched
                 };
             }
+        };
+        for (var _i = 0, _a = Object.entries(KEYWORD_CATEGORIES); _i < _a.length; _i++) {
+            var _b = _a[_i], agent = _b[0], categoryKeywords = _b[1];
+            _loop_1(agent, categoryKeywords);
         }
         // Find best scoring agent
-        let bestAgent = '';
-        let bestScore = 0;
-        let bestMatched = [];
-        for (const [agent, data] of Object.entries(scores)) {
+        var bestAgent = '';
+        var bestScore = 0;
+        var bestMatched = [];
+        for (var _c = 0, _d = Object.entries(scores); _c < _d.length; _c++) {
+            var _e = _d[_c], agent = _e[0], data = _e[1];
             if (data.score > bestScore) {
                 bestScore = data.score;
                 bestAgent = agent;
@@ -436,76 +517,82 @@ export class SONAOptimizer {
             return {
                 agent: bestAgent,
                 confidence: Math.min(0.7, 0.3 + bestScore),
-                matchedKeywords: bestMatched,
+                matchedKeywords: bestMatched
             };
         }
         return null;
-    }
+    };
     /**
      * Get alternative agent suggestions
      */
-    getAlternatives(keywords, excludeAgent) {
-        const alternatives = [];
-        for (const [agent, categoryKeywords] of Object.entries(KEYWORD_CATEGORIES)) {
+    SONAOptimizer.prototype.getAlternatives = function (keywords, excludeAgent) {
+        var alternatives = [];
+        var _loop_2 = function (agent, categoryKeywords) {
             if (agent === excludeAgent)
-                continue;
-            const matched = keywords.filter(k => categoryKeywords.includes(k));
+                return "continue";
+            var matched = keywords.filter(function (k) { return categoryKeywords.includes(k); });
             if (matched.length > 0) {
                 alternatives.push({
-                    agent,
-                    score: matched.length / Math.max(keywords.length, 1) * 0.5,
+                    agent: agent,
+                    score: matched.length / Math.max(keywords.length, 1) * 0.5
                 });
             }
+        };
+        for (var _i = 0, _a = Object.entries(KEYWORD_CATEGORIES); _i < _a.length; _i++) {
+            var _b = _a[_i], agent = _b[0], categoryKeywords = _b[1];
+            _loop_2(agent, categoryKeywords);
         }
         return alternatives
-            .sort((a, b) => b.score - a.score)
+            .sort(function (a, b) { return b.score - a.score; })
             .slice(0, 3);
-    }
+    };
     /**
      * Prune old/low-confidence patterns if over limit
      */
-    prunePatterns() {
+    SONAOptimizer.prototype.prunePatterns = function () {
         if (this.patterns.size <= MAX_PATTERNS) {
             return;
         }
         // Sort patterns by score (confidence * recency)
-        const entries = Array.from(this.patterns.entries()).map(([key, pattern]) => {
-            const ageInDays = (Date.now() - pattern.lastUsed) / (1000 * 60 * 60 * 24);
-            const recency = Math.exp(-0.1 * ageInDays);
-            const score = pattern.confidence * recency;
-            return { key, pattern, score };
+        var entries = Array.from(this.patterns.entries()).map(function (_a) {
+            var key = _a[0], pattern = _a[1];
+            var ageInDays = (Date.now() - pattern.lastUsed) / (1000 * 60 * 60 * 24);
+            var recency = Math.exp(-0.1 * ageInDays);
+            var score = pattern.confidence * recency;
+            return { key: key, pattern: pattern, score: score };
         });
-        entries.sort((a, b) => a.score - b.score);
+        entries.sort(function (a, b) { return a.score - b.score; });
         // Remove lowest-scoring patterns
-        const toRemove = entries.slice(0, entries.length - Math.floor(MAX_PATTERNS * 0.8));
-        for (const { key } of toRemove) {
-            this.patterns.delete(key);
+        var toRemove = entries.slice(0, entries.length - Math.floor(MAX_PATTERNS * 0.8));
+        for (var _i = 0, toRemove_1 = toRemove; _i < toRemove_1.length; _i++) {
+            var key = toRemove_1[_i].key;
+            this.patterns["delete"](key);
         }
-    }
+    };
     /**
      * Validate pattern structure
      */
-    validatePattern(pattern) {
+    SONAOptimizer.prototype.validatePattern = function (pattern) {
         if (!pattern || typeof pattern !== 'object')
             return false;
-        const p = pattern;
+        var p = pattern;
         return (Array.isArray(p.keywords) &&
             typeof p.agent === 'string' &&
             typeof p.confidence === 'number' &&
             typeof p.successCount === 'number' &&
             typeof p.failureCount === 'number');
-    }
+    };
     /**
      * Load patterns from disk
      */
-    loadFromDisk() {
+    SONAOptimizer.prototype.loadFromDisk = function () {
         try {
-            const fullPath = join(process.cwd(), this.persistencePath);
+            var fullPath = join(process.cwd(), this.persistencePath);
             if (!existsSync(fullPath)) {
                 return false;
             }
-            const data = readFileSync(fullPath, 'utf-8');
-            const state = JSON.parse(data);
+            var data = readFileSync(fullPath, 'utf-8');
+            var state = JSON.parse(data);
             // Validate version
             if (!state.version || !state.version.startsWith('1.')) {
                 console.error('[SONA] Incompatible state version, starting fresh');
@@ -513,7 +600,8 @@ export class SONAOptimizer {
             }
             // Load patterns
             this.patterns.clear();
-            for (const [key, pattern] of Object.entries(state.patterns)) {
+            for (var _i = 0, _a = Object.entries(state.patterns); _i < _a.length; _i++) {
+                var _b = _a[_i], key = _b[0], pattern = _b[1];
                 if (this.validatePattern(pattern)) {
                     this.patterns.set(key, pattern);
                 }
@@ -528,68 +616,83 @@ export class SONAOptimizer {
             return true;
         }
         catch (err) {
-            console.error(`[SONA] Failed to load state: ${err}`);
+            console.error("[SONA] Failed to load state: " + err);
             return false;
         }
-    }
+    };
     /**
      * Save patterns to disk
      */
-    saveToDisk() {
+    SONAOptimizer.prototype.saveToDisk = function () {
         try {
-            const fullPath = join(process.cwd(), this.persistencePath);
-            const dir = dirname(fullPath);
+            var fullPath = join(process.cwd(), this.persistencePath);
+            var dir = dirname(fullPath);
             // Ensure directory exists
             if (!existsSync(dir)) {
                 mkdirSync(dir, { recursive: true });
             }
-            const state = {
+            var state = {
                 version: PATTERN_VERSION,
                 patterns: this.exportPatterns(),
                 stats: {
                     trajectoriesProcessed: this.trajectoriesProcessed,
                     successfulRoutings: this.successfulRoutings,
                     failedRoutings: this.failedRoutings,
-                    lastUpdate: this.lastUpdate,
+                    lastUpdate: this.lastUpdate
                 },
                 metadata: {
                     createdAt: new Date().toISOString(),
-                    savedAt: new Date().toISOString(),
-                },
+                    savedAt: new Date().toISOString()
+                }
             };
             writeFileSync(fullPath, JSON.stringify(state, null, 2));
             return true;
         }
         catch (err) {
-            console.error(`[SONA] Failed to save state: ${err}`);
+            console.error("[SONA] Failed to save state: " + err);
             return false;
         }
-    }
-}
+    };
+    return SONAOptimizer;
+}());
+export { SONAOptimizer };
 // ============================================================================
 // Singleton Instance
 // ============================================================================
-let sonaOptimizerInstance = null;
-let initializationPromise = null;
+var sonaOptimizerInstance = null;
+var initializationPromise = null;
 /**
  * Get the singleton SONAOptimizer instance
  * Uses lazy initialization to avoid circular imports
  */
-export async function getSONAOptimizer() {
-    if (sonaOptimizerInstance) {
-        return sonaOptimizerInstance;
-    }
-    // Prevent multiple concurrent initializations
-    if (initializationPromise) {
-        return initializationPromise;
-    }
-    initializationPromise = (async () => {
-        const optimizer = new SONAOptimizer();
-        await optimizer.initialize();
-        sonaOptimizerInstance = optimizer;
-        return optimizer;
-    })();
-    return initializationPromise;
+export function getSONAOptimizer() {
+    return __awaiter(this, void 0, Promise, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            if (sonaOptimizerInstance) {
+                return [2 /*return*/, sonaOptimizerInstance];
+            }
+            // Prevent multiple concurrent initializations
+            if (initializationPromise) {
+                return [2 /*return*/, initializationPromise];
+            }
+            initializationPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                var optimizer;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            optimizer = new SONAOptimizer();
+                            return [4 /*yield*/, optimizer.initialize()];
+                        case 1:
+                            _a.sent();
+                            sonaOptimizerInstance = optimizer;
+                            return [2 /*return*/, optimizer];
+                    }
+                });
+            }); })();
+            return [2 /*return*/, initializationPromise];
+        });
+    });
 }
 /**
  * Reset the singleton instance (for testing)
@@ -604,30 +707,57 @@ export function resetSONAOptimizer() {
 /**
  * Process a trajectory outcome (convenience function)
  */
-export async function processTrajectory(outcome) {
-    const optimizer = await getSONAOptimizer();
-    return optimizer.processTrajectoryOutcome(outcome);
+export function processTrajectory(outcome) {
+    return __awaiter(this, void 0, Promise, function () {
+        var optimizer;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getSONAOptimizer()];
+                case 1:
+                    optimizer = _a.sent();
+                    return [2 /*return*/, optimizer.processTrajectoryOutcome(outcome)];
+            }
+        });
+    });
 }
 /**
  * Get routing suggestion (convenience function)
  */
-export async function getSuggestion(task) {
-    const optimizer = await getSONAOptimizer();
-    return optimizer.getRoutingSuggestion(task);
+export function getSuggestion(task) {
+    return __awaiter(this, void 0, Promise, function () {
+        var optimizer;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getSONAOptimizer()];
+                case 1:
+                    optimizer = _a.sent();
+                    return [2 /*return*/, optimizer.getRoutingSuggestion(task)];
+            }
+        });
+    });
 }
 /**
  * Get SONA statistics (convenience function)
  */
-export async function getSONAStats() {
-    const optimizer = await getSONAOptimizer();
-    return optimizer.getStats();
+export function getSONAStats() {
+    return __awaiter(this, void 0, Promise, function () {
+        var optimizer;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getSONAOptimizer()];
+                case 1:
+                    optimizer = _a.sent();
+                    return [2 /*return*/, optimizer.getStats()];
+            }
+        });
+    });
 }
 export default {
-    SONAOptimizer,
-    getSONAOptimizer,
-    resetSONAOptimizer,
-    processTrajectory,
-    getSuggestion,
-    getSONAStats,
+    SONAOptimizer: SONAOptimizer,
+    getSONAOptimizer: getSONAOptimizer,
+    resetSONAOptimizer: resetSONAOptimizer,
+    processTrajectory: processTrajectory,
+    getSuggestion: getSuggestion,
+    getSONAStats: getSONAStats
 };
 //# sourceMappingURL=sona-optimizer.js.map