mark-improving-agent 2.2.7 → 2.2.8

package/VERSION

@@ -1 +1 @@
-2.2.7
+2.2.8

package/dist/core/cognition/cognitive-budget.js

@@ -0,0 +1,225 @@
+/**
+ * Cognitive Budget Manager
+ *
+ * Intelligently manages token usage and context window to prevent overflow.
+ * Tracks token consumption, predicts when context will exceed limits,
+ * and proactively compresses or archives low-priority content.
+ *
+ * @module cognition/cognitive-budget
+ * @fileoverview Cognitive budget management for context window optimization
+ */
+import { atomicWriteJSON, readJSON } from '../../storage/archive.js';
+import { createLogger } from '../../utils/logger.js';
+const logger = createLogger('[CognitiveBudget]');
+const DEFAULT_CONFIG = {
+    maxTokens: 100000,
+    warningThreshold: 0.7,
+    criticalThreshold: 0.9,
+    autoCompress: true,
+    compressionRatio: 0.5,
+};
+const STATE_FILE = 'cognitive-budget.json';
+/**
+ * Estimate tokens from text (rough approximation)
+ * 1 token ≈ 4 characters for English, 2 for Chinese
+ */
+function estimateTokens(text) {
+    if (!text)
+        return 0;
+    let count = 0;
+    for (const char of text) {
+        if (char.charCodeAt(0) > 127) {
+            count += 2; // Chinese/Unicode
+        }
+        else {
+            count += 1;
+        }
+    }
+    return Math.ceil(count / 4);
+}
+/**
+ * Categorize content by priority
+ */
+function getContentPriority(category) {
+    const priorityMap = {
+        'system': 1.0, // Highest - system prompts
+        'identity': 0.95, // Identity core
+        'memory': 0.8, // Long-term memory
+        'goals': 0.75, // Active goals
+        'context': 0.6, // Recent context
+        'reflection': 0.5, // Reflection data
+        'history': 0.3, // Chat history
+        'archive': 0.1, // Archived content - lowest
+    };
+    return priorityMap[category] ?? 0.5;
+}
+export function createCognitiveBudgetManager(dataDir, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const usage = new Map();
+    const alerts = [];
+    let totalTokens = 0;
+    let sessionStart = Date.now();
+    const statePath = `${dataDir}/cognition/${STATE_FILE}`;
+    function track(category, tokens) {
+        if (tokens <= 0)
+            return;
+        const current = usage.get(category) || 0;
+        usage.set(category, current + tokens);
+        totalTokens += tokens;
+        logger.debug(`Tracked ${tokens} tokens for '${category}'`, {
+            categoryTotal: usage.get(category),
+            overallTotal: totalTokens,
+        });
+    }
+    function getUsage() {
+        const byCategory = {};
+        let sum = 0;
+        for (const [cat, tokens] of usage) {
+            byCategory[cat] = tokens;
+            sum += tokens;
+        }
+        return {
+            current: sum,
+            max: cfg.maxTokens,
+            ratio: sum / cfg.maxTokens,
+            byCategory,
+        };
+    }
+    function getLoadLevel() {
+        const ratio = getUsage().ratio;
+        if (ratio >= cfg.criticalThreshold)
+            return 'critical';
+        if (ratio >= cfg.warningThreshold)
+            return 'warning';
+        if (ratio >= 0.5)
+            return 'moderate';
+        return 'healthy';
+    }
+    function checkThresholds() {
+        const level = getLoadLevel();
+        if (level === 'healthy')
+            return null;
+        const usage = getUsage();
+        const recommendations = [];
+        switch (level) {
+            case 'moderate':
+                recommendations.push('Consider summarizing old context soon');
+                break;
+            case 'warning':
+                recommendations.push('Archive low-priority content');
+                recommendations.push('Enable compression if not already');
+                break;
+            case 'critical':
+                recommendations.push('Immediately archive or compress content');
+                recommendations.push('Consider fragmenting long context');
+                recommendations.push('Prune oldest history entries');
+                break;
+        }
+        const messages = {
+            healthy: 'Context budget healthy',
+            moderate: 'Context usage increasing',
+            warning: 'Context approaching limit - action recommended',
+            critical: 'Context critical - immediate action required',
+        };
+        return {
+            level,
+            message: messages[level],
+            timestamp: Date.now(),
+            recommendations,
+        };
+    }
+    function getCompressionRecommendations(limit = 5) {
+        const recommendations = [];
+        const usage = getUsage();
+        if (usage.current < cfg.maxTokens * 0.5) {
+            return recommendations;
+        }
+        // Analyze each category for compression potential
+        for (const [category, tokens] of Object.entries(usage.byCategory)) {
+            const priority = getContentPriority(category);
+            const capacity = cfg.maxTokens * (1 - priority);
+            if (tokens > capacity * 0.3) {
+                const excess = tokens - capacity * 0.3;
+                const priorityScore = 1 - priority;
+                recommendations.push({
+                    priority: priorityScore,
+                    reason: `Category '${category}' has ${tokens} tokens at priority ${priority.toFixed(2)}`,
+                    estimatedSavings: Math.floor(excess * 0.5),
+                    target: category,
+                    strategy: priority < 0.3 ? 'prune' : priority < 0.6 ? 'archive' : 'summarize',
+                });
+            }
+        }
+        // Sort by priority (highest first)
+        recommendations.sort((a, b) => b.priority - a.priority);
+        return recommendations.slice(0, limit);
+    }
+    async function compress(recommendation) {
+        logger.info(`Compressing category: ${recommendation.target}`, recommendation);
+        const current = usage.get(recommendation.target) || 0;
+        const savings = Math.floor(current * (1 - cfg.compressionRatio));
+        // Apply compression
+        usage.set(recommendation.target, current - savings);
+        totalTokens -= savings;
+        // Record alert
+        alerts.push({
+            level: getLoadLevel(),
+            message: `Compressed ${recommendation.target}: freed ~${savings} tokens`,
+            timestamp: Date.now(),
+            recommendations: [recommendation.strategy],
+        });
+        // Keep only last 50 alerts
+        if (alerts.length > 50) {
+            alerts.shift();
+        }
+        await persist();
+        return true;
+    }
+    function reset() {
+        usage.clear();
+        totalTokens = 0;
+        sessionStart = Date.now();
+        alerts.length = 0;
+    }
+    async function persist() {
+        const state = {
+            usage: Object.fromEntries(usage),
+            totalTokens,
+            sessionStart,
+            config: cfg,
+            alerts: alerts.slice(-20),
+        };
+        await atomicWriteJSON(statePath, state);
+    }
+    async function boot() {
+        const loaded = await readJSON(statePath, {});
+        if (loaded) {
+            if (loaded.usage) {
+                for (const [k, v] of Object.entries(loaded.usage)) {
+                    usage.set(k, v);
+                }
+            }
+            if (typeof loaded.totalTokens === 'number') {
+                totalTokens = loaded.totalTokens;
+            }
+            if (loaded.alerts) {
+                alerts.push(...loaded.alerts.slice(-20));
+            }
+        }
+        logger.info('CognitiveBudgetManager initialized', {
+            maxTokens: cfg.maxTokens,
+            currentTokens: getUsage().current,
+        });
+    }
+    return {
+        track,
+        getUsage,
+        getLoadLevel,
+        checkThresholds,
+        getCompressionRecommendations,
+        compress,
+        reset,
+        persist,
+        boot,
+    };
+}

package/dist/core/cognition/index.js

@@ -11,3 +11,4 @@ export * from './self-evolution.js';
 export * from './cognitive-architecture.js';
 export * from './meta-agent.js';
 export * from './active-inference.js';
+export { createCognitiveBudgetManager } from './cognitive-budget.js';

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '2.2.7';
+export const VERSION = '2.2.8';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mark-improving-agent",
-  "version": "2.2.7",
+  "version": "2.2.8",
   "description": "Self-evolving AI agent with permanent memory, identity continuity, and self-evolution — for AI agents that need to remember, learn, and evolve across sessions",
   "type": "module",
   "main": "./dist/index.js",