mark-improving-agent 2.2.6 → 2.2.8

package/VERSION

@@ -1 +1 @@
-2.2.6
+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/core/psychology/index.js

@@ -1 +1,2 @@
 export * from './analysis.js';
+export * from './mindset.js';

package/dist/core/psychology/mindset.js

@@ -0,0 +1,435 @@
+/**
+ * Mindset Framework - Growth vs Fixed Mindset Integration
+ *
+ * Based on Carol Dweck's mindset research applied to AI self-evolution.
+ * This module tracks and influences how the agent approaches challenges,
+ * learning, and self-improvement.
+ *
+ * Key concepts:
+ * - Growth Mindset: Challenges are opportunities to grow
+ * - Fixed Mindset: Challenges threaten self-image
+ * - Learning Orientation: Focus on learning over performance
+ * - Performance Orientation: Focus on appearing capable
+ *
+ * @module core/psychology
+ * @fileoverview Mindset Framework for AI self-evolution
+ */
+import { randomUUID } from 'crypto';
+import { createLogger } from '../../utils/logger.js';
+const logger = createLogger('[Mindset]');
+// Growth mindset keywords and patterns
+const GROWTH_KEYWORDS = [
+    '学习', '成长', '进步', '尝试', '努力', '练习', '改进', '提升',
+    '挑战', '困难', '过程', '方法', '策略', '探索', '发现',
+    'learn', 'grow', 'improve', 'try', 'effort', 'practice', 'develop',
+    'challenge', 'challenge', 'process', 'strategy', 'yet', 'yet',
+    '还没', '还在', '逐渐', '慢慢', '持续',
+];
+const FIXED_KEYWORDS = [
+    '不能', '不会', '不行', '做不到', '天赋', '天生', '聪明',
+    '笨', '差', '失败', '算了', '就这样吧', '反正',
+    'cannot', 'cannot', 'impossible', 'talented', 'naturally',
+    'stupid', 'dumb', 'fail', 'give up', 'quit',
+];
+const LEARNING_ORIENTATION_KEYWORDS = [
+    '学到了', '理解了', '掌握', '了解', '发现', '收获',
+    'learned', 'understood', 'discovered', 'gained', 'figured out',
+];
+const PERFORMANCE_ORIENTATION_KEYWORDS = [
+    '表现', '证明', '显示', '看起来', '别人会', '显得',
+    'perform', 'prove', 'show', 'look', 'appear', 'impress',
+];
+const AVOIDANCE_KEYWORDS = [
+    '避免', '不尝试', '算了', '不要', '逃避',
+    'avoid', 'skip', 'escape', 'run away',
+];
+function detectMindsetInText(text) {
+    const textLower = text.toLowerCase();
+    let growthCount = 0;
+    let fixedCount = 0;
+    for (const keyword of GROWTH_KEYWORDS) {
+        if (textLower.includes(keyword.toLowerCase()))
+            growthCount++;
+    }
+    for (const keyword of FIXED_KEYWORDS) {
+        if (textLower.includes(keyword.toLowerCase()))
+            fixedCount++;
+    }
+    return { growth: growthCount, fixed: fixedCount };
+}
+function detectOrientationInText(text) {
+    const textLower = text.toLowerCase();
+    let learningScore = 0;
+    let performanceScore = 0;
+    let avoidanceScore = 0;
+    for (const keyword of LEARNING_ORIENTATION_KEYWORDS) {
+        if (textLower.includes(keyword.toLowerCase()))
+            learningScore++;
+    }
+    for (const keyword of PERFORMANCE_ORIENTATION_KEYWORDS) {
+        if (textLower.includes(keyword.toLowerCase()))
+            performanceScore++;
+    }
+    for (const keyword of AVOIDANCE_KEYWORDS) {
+        if (textLower.includes(keyword.toLowerCase()))
+            avoidanceScore++;
+    }
+    if (avoidanceScore > 0 && avoidanceScore >= learningScore && avoidanceScore >= performanceScore) {
+        return 'avoidance';
+    }
+    if (learningScore > performanceScore) {
+        return 'learning';
+    }
+    else if (performanceScore > learningScore) {
+        return 'performance';
+    }
+    return 'learning';
+}
+function createDefaultMindsetFramework() {
+    const state = {
+        challengeHistory: [],
+        abilityBeliefs: [],
+        growthProgress: [],
+        strategyAdaptations: [],
+        overallGrowthScore: 50,
+        effortBelief: 70,
+        failureRecoveryRate: 65,
+    };
+    function analyzeMindset(text, context) {
+        const { growth, fixed } = detectMindsetInText(text);
+        const orientation = detectOrientationInText(text);
+        const total = growth + fixed;
+        let mindsetScore = 0.5;
+        let mindset = 'mixed';
+        if (total > 0) {
+            mindsetScore = growth / total;
+        }
+        if (mindsetScore > 0.6) {
+            mindset = 'growth';
+        }
+        else if (mindsetScore < 0.4) {
+            mindset = 'fixed';
+        }
+        else {
+            mindset = 'mixed';
+        }
+        if (context && context.length > 0) {
+            const contextAnalysis = detectMindsetInText(context.join(' '));
+            const contextTotal = contextAnalysis.growth + contextAnalysis.fixed;
+            if (contextTotal > 0) {
+                const contextScore = contextAnalysis.growth / contextTotal;
+                mindsetScore = (mindsetScore + contextScore) / 2;
+            }
+        }
+        logger.debug(`Mindset analysis: ${mindset} (${(mindsetScore * 100).toFixed(0)}%)`);
+        return { mindset, orientation, mindsetScore };
+    }
+    function respondToChallenge(challenge, context) {
+        const { mindset, orientation, mindsetScore } = analyzeMindset(challenge, context);
+        let response = 'embrace';
+        let emotionalShift = 0;
+        if (mindset === 'growth') {
+            response = 'embrace';
+            emotionalShift = 0.2;
+        }
+        else if (mindset === 'fixed') {
+            if (orientation === 'performance') {
+                response = 'threat';
+                emotionalShift = -0.3;
+            }
+            else if (orientation === 'avoidance') {
+                response = 'avoid';
+                emotionalShift = -0.1;
+            }
+            else {
+                response = 'overwhelm';
+                emotionalShift = -0.2;
+            }
+        }
+        else {
+            if (mindsetScore > 0.5) {
+                response = 'embrace';
+                emotionalShift = 0.1;
+            }
+            else {
+                response = 'overwhelm';
+                emotionalShift = -0.1;
+            }
+        }
+        const reflection = generateReflection(mindset, response, challenge);
+        const entry = {
+            id: randomUUID(),
+            challenge,
+            response,
+            mindset,
+            orientation,
+            emotionalShift,
+            reflection,
+            timestamp: Date.now(),
+        };
+        state.challengeHistory.push(entry);
+        if (state.challengeHistory.length > 100) {
+            state.challengeHistory = state.challengeHistory.slice(-100);
+        }
+        if (response === 'embrace') {
+            state.overallGrowthScore = Math.min(100, state.overallGrowthScore + 1);
+        }
+        else if (response === 'threat' || response === 'avoid') {
+            state.overallGrowthScore = Math.max(0, state.overallGrowthScore - 0.5);
+        }
+        logger.info(`Challenge response: ${response} (${mindset})`);
+        return entry;
+    }
+    function generateReflection(mindset, response, challenge) {
+        if (mindset === 'growth' && response === 'embrace') {
+            return 'This challenge is an opportunity to grow. I may not succeed immediately, but effort leads to improvement.';
+        }
+        else if (mindset === 'fixed' && response === 'threat') {
+            return 'I feel my abilities are being judged. I need to protect my self-image rather than risk failure.';
+        }
+        else if (mindset === 'fixed' && response === 'avoid') {
+            return 'This is too difficult. I will avoid it to prevent failure.';
+        }
+        else if (response === 'overwhelm') {
+            return 'This is too much. I need to break it down into smaller steps.';
+        }
+        return 'I will approach this carefully and learn from the process.';
+    }
+    function updateAbilityBelief(ability, evidence, isPositive) {
+        let belief = state.abilityBeliefs.find(b => b.ability === ability);
+        if (!belief) {
+            belief = {
+                ability,
+                belief: 'mixed',
+                confidence: 0.3,
+                evidence: [],
+                counterEvidence: [],
+                lastUpdated: Date.now(),
+            };
+            state.abilityBeliefs.push(belief);
+        }
+        if (isPositive) {
+            belief.evidence.push(evidence);
+        }
+        else {
+            belief.counterEvidence.push(evidence);
+        }
+        const total = belief.evidence.length + belief.counterEvidence.length;
+        if (total > 0) {
+            const growthRatio = belief.evidence.length / total;
+            if (growthRatio > 0.6) {
+                belief.belief = 'growth';
+                belief.confidence = Math.min(1, belief.confidence + 0.05);
+            }
+            else if (growthRatio < 0.4) {
+                belief.belief = 'fixed';
+                belief.confidence = Math.min(1, belief.confidence + 0.05);
+            }
+        }
+        belief.lastUpdated = Date.now();
+    }
+    function getAbilityBeliefs() {
+        return [...state.abilityBeliefs];
+    }
+    function getBeliefSummary() {
+        const summary = [];
+        for (const belief of state.abilityBeliefs) {
+            const status = belief.belief === 'growth'
+                ? 'Growth'
+                : belief.belief === 'fixed'
+                    ? 'Fixed'
+                    : 'Mixed';
+            summary.push(`${belief.ability}: ${status} (${(belief.confidence * 100).toFixed(0)}% confidence)`);
+            if (belief.evidence.length > 0) {
+                summary.push(`  + Evidence: ${belief.evidence.slice(-2).join('; ')}`);
+            }
+        }
+        return summary;
+    }
+    function trackGrowth(area, level, strategy) {
+        let progress = state.growthProgress.find(g => g.area === area);
+        if (!progress) {
+            progress = {
+                area,
+                initialLevel: level,
+                currentLevel: level,
+                targetLevel: level + 10,
+                efforts: 1,
+                strategies: strategy ? [strategy] : [],
+                setbacks: 0,
+                breakthroughs: 0,
+                startedAt: Date.now(),
+                lastUpdated: Date.now(),
+            };
+            state.growthProgress.push(progress);
+        }
+        else {
+            const delta = level - progress.currentLevel;
+            if (delta > 0) {
+                progress.currentLevel = level;
+                progress.breakthroughs++;
+                state.overallGrowthScore = Math.min(100, state.overallGrowthScore + 2);
+            }
+            else if (delta < -2) {
+                progress.setbacks++;
+                state.overallGrowthScore = Math.max(0, state.overallGrowthScore - 1);
+                state.failureRecoveryRate = Math.max(0, state.failureRecoveryRate - 1);
+            }
+            progress.efforts++;
+            if (strategy && !progress.strategies.includes(strategy)) {
+                progress.strategies.push(strategy);
+            }
+            progress.lastUpdated = Date.now();
+        }
+    }
+    function getGrowthProgress(area) {
+        if (area) {
+            return state.growthProgress.find(g => g.area === area) || {
+                area,
+                initialLevel: 0,
+                currentLevel: 0,
+                targetLevel: 10,
+                efforts: 0,
+                strategies: [],
+                setbacks: 0,
+                breakthroughs: 0,
+                startedAt: Date.now(),
+                lastUpdated: Date.now(),
+            };
+        }
+        return [...state.growthProgress];
+    }
+    function getGrowthInsights() {
+        const insights = [];
+        for (const progress of state.growthProgress) {
+            const percentComplete = ((progress.currentLevel - progress.initialLevel) /
+                (progress.targetLevel - progress.initialLevel) * 100).toFixed(0);
+            insights.push(`${progress.area}: ${percentComplete}% toward goal (${progress.breakthroughs} breakthroughs, ${progress.setbacks} setbacks)`);
+        }
+        if (state.growthProgress.length === 0) {
+            insights.push('No growth tracking yet. Start by setting a growth area.');
+        }
+        return insights;
+    }
+    function recordStrategyAdaptation(situation, previousStrategy, newStrategy, reason, outcome) {
+        const adaptation = {
+            id: randomUUID(),
+            situation,
+            previousStrategy,
+            newStrategy,
+            reason,
+            outcome,
+            learning: `Adapted from "${previousStrategy}" to "${newStrategy}"`,
+            timestamp: Date.now(),
+        };
+        state.strategyAdaptations.push(adaptation);
+        if (state.strategyAdaptations.length > 50) {
+            state.strategyAdaptations = state.strategyAdaptations.slice(-50);
+        }
+        if (outcome === 'success') {
+            state.overallGrowthScore = Math.min(100, state.overallGrowthScore + 1);
+        }
+        logger.debug(`Strategy adaptation: ${previousStrategy} -> ${newStrategy} (${outcome})`);
+    }
+    function getStrategyAdaptations(limit = 10) {
+        return state.strategyAdaptations.slice(-limit);
+    }
+    function getAdaptationInsights() {
+        const insights = [];
+        if (state.strategyAdaptations.length === 0) {
+            return ['No strategy adaptations recorded yet'];
+        }
+        const recent = state.strategyAdaptations.slice(-5);
+        const successCount = recent.filter(a => a.outcome === 'success').length;
+        const successRate = (successCount / recent.length * 100).toFixed(0);
+        insights.push(`Recent adaptation success rate: ${successRate}%`);
+        for (const adaptation of recent) {
+            insights.push(`- "${adaptation.previousStrategy}" -> "${adaptation.newStrategy}": ${adaptation.outcome}`);
+        }
+        return insights;
+    }
+    function getMetrics() {
+        const challengeHistory = state.challengeHistory.slice(-20);
+        const embraceCount = challengeHistory.filter(c => c.response === 'embrace').length;
+        const challengeApproachRate = challengeHistory.length > 0
+            ? (embraceCount / challengeHistory.length) * 100
+            : 50;
+        const learningCount = challengeHistory.filter(c => c.orientation === 'learning').length;
+        const performanceCount = challengeHistory.filter(c => c.orientation === 'performance').length;
+        const total = learningCount + performanceCount;
+        const learningOrientation = total > 0 ? (learningCount / total) * 100 : 50;
+        const performanceOrientation = total > 0 ? (performanceCount / total) * 100 : 50;
+        let overallMindset = 'mixed';
+        if (state.overallGrowthScore > 60) {
+            overallMindset = 'growth';
+        }
+        else if (state.overallGrowthScore < 40) {
+            overallMindset = 'fixed';
+        }
+        return {
+            overallMindset,
+            growthScore: state.overallGrowthScore,
+            learningOrientation,
+            performanceOrientation,
+            challengeApproachRate,
+            effortBelief: state.effortBelief,
+            failureRecoveryRate: state.failureRecoveryRate,
+            flexibilityScore: state.overallGrowthScore * 0.8 + state.effortBelief * 0.2,
+        };
+    }
+    function getChallengeHistory(limit = 20) {
+        return state.challengeHistory.slice(-limit);
+    }
+    function assessMindset(text, context) {
+        analyzeMindset(text, context);
+        respondToChallenge(text, context);
+        const metrics = getMetrics();
+        const insights = [];
+        const recommendations = [];
+        if (metrics.overallMindset === 'growth') {
+            insights.push('You are in a growth mindset - challenges are opportunities');
+        }
+        else if (metrics.overallMindset === 'fixed') {
+            insights.push('You may be in a fixed mindset - challenges feel threatening');
+        }
+        if (metrics.learningOrientation > metrics.performanceOrientation) {
+            insights.push('Learning orientation detected - focus on gaining knowledge');
+        }
+        else {
+            insights.push('Performance orientation detected - focus on appearing capable');
+        }
+        if (metrics.challengeApproachRate < 50) {
+            recommendations.push('Try to view challenges as opportunities to grow');
+        }
+        if (metrics.effortBelief < 50) {
+            recommendations.push('Remind yourself that effort leads to improvement');
+        }
+        if (metrics.failureRecoveryRate < 50) {
+            recommendations.push('Practice bouncing back faster from setbacks');
+        }
+        if (metrics.overallMindset === 'fixed' && metrics.performanceOrientation > metrics.learningOrientation) {
+            recommendations.push('Shift focus from "proving yourself" to "improving yourself"');
+        }
+        return { metrics, insights, recommendations };
+    }
+    return {
+        analyzeMindset,
+        respondToChallenge,
+        updateAbilityBelief,
+        getAbilityBeliefs,
+        getBeliefSummary,
+        trackGrowth,
+        getGrowthProgress,
+        getGrowthInsights,
+        recordStrategyAdaptation,
+        getStrategyAdaptations,
+        getAdaptationInsights,
+        getMetrics,
+        getChallengeHistory,
+        assessMindset,
+    };
+}
+export function createMindsetFramework() {
+    logger.info('Creating Mindset Framework');
+    return createDefaultMindsetFramework();
+}

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mark-improving-agent",
-  "version": "2.2.6",
+  "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",