mark-improving-agent 2.2.7 → 2.2.9

package/VERSION

@@ -1 +1 @@
-2.2.7
+2.2.9

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/collaboration/index.js

@@ -3,3 +3,4 @@ export * from './agentic-loop.js';
 export * from './multi-agent-system.js';
 export { createMCPProtocol } from './mcp-protocol.js';
 export { createPeerReviewSystem } from './peer-review.js';
+export { createTrustScorer, TrustScorer } from './trust-scorer.js';

package/dist/core/collaboration/trust-scorer.js

@@ -0,0 +1,374 @@
+/**
+ * Multi-Agent Trust Scoring System
+ *
+ * Provides trust and quality scoring for AI agents based on their
+ * task performance, peer reviews, and capability assessments.
+ * Includes EU AI Act compliance metrics.
+ *
+ * @module collaboration/trust-scorer
+ * @fileoverview Trust scoring system for multi-agent collaboration
+ */
+import { createLogger } from '../../utils/logger.js';
+import { createPeerReviewSystem } from './peer-review.js';
+const logger = createLogger('[TrustScorer]');
+/**
+ * Trust score level based on numeric score
+ */
+export var TrustLevel;
+(function (TrustLevel) {
+    TrustLevel["UNTRUSTED"] = "untrusted";
+    TrustLevel["LOW"] = "low";
+    TrustLevel["MEDIUM"] = "medium";
+    TrustLevel["HIGH"] = "high";
+    TrustLevel["TRUSTED"] = "trusted";
+})(TrustLevel || (TrustLevel = {}));
+/**
+ * EU AI Act risk categories
+ */
+export var AIActRiskCategory;
+(function (AIActRiskCategory) {
+    AIActRiskCategory["UNacceptable_Risk"] = "unacceptable-risk";
+    AIActRiskCategory["HIGH_RISK"] = "high-risk";
+    AIActRiskCategory["LIMITED_RISK"] = "limited-risk";
+    AIActRiskCategory["MINIMAL_RISK"] = "minimal-risk";
+})(AIActRiskCategory || (AIActRiskCategory = {}));
+/**
+ * Trust Scorer class
+ */
+export class TrustScorer {
+    config;
+    agentProfiles = new Map();
+    scoringEvents = [];
+    peerReviewSystem;
+    constructor(config = {}) {
+        this.config = {
+            minTasksForTrustScore: config.minTasksForTrustScore ?? 5,
+            taskSuccessWeight: config.taskSuccessWeight ?? 0.4,
+            peerReviewWeight: config.peerReviewWeight ?? 0.35,
+            capabilityWeight: config.capabilityWeight ?? 0.25,
+            decayRatePerDay: config.decayRatePerDay ?? 0.01,
+            trustLevelThresholds: config.trustLevelThresholds ?? {
+                untrusted: 0,
+                low: 20,
+                medium: 40,
+                high: 70,
+                trusted: 85
+            }
+        };
+        this.peerReviewSystem = createPeerReviewSystem({
+            consensusThreshold: 0.6,
+            requiredReviewers: 3,
+            enableArbitration: false
+        });
+        logger.info('TrustScorer initialized', this.config);
+    }
+    /**
+     * Register a new agent in the trust system
+     */
+    registerAgent(agentId, agentName) {
+        const profile = {
+            agentId,
+            agentName,
+            trustScore: 50, // Start with neutral score
+            trustLevel: TrustLevel.MEDIUM,
+            successfulTasks: 0,
+            failedTasks: 0,
+            successRate: 0,
+            avgPeerScore: 0.5,
+            reviewCount: 0,
+            capabilities: new Map(),
+            aiActCategory: AIActRiskCategory.MINIMAL_RISK,
+            registeredAt: Date.now(),
+            lastActivityAt: Date.now(),
+            isActive: true
+        };
+        this.agentProfiles.set(agentId, profile);
+        logger.info(`Agent registered: ${agentId} (${agentName})`);
+        return profile;
+    }
+    /**
+     * Record a task outcome for an agent
+     */
+    recordTaskOutcome(agentId, taskId, success, metadata) {
+        const profile = this.getOrCreateProfile(agentId);
+        if (success) {
+            profile.successfulTasks++;
+        }
+        else {
+            profile.failedTasks++;
+        }
+        profile.lastActivityAt = Date.now();
+        profile.successRate = profile.successfulTasks / (profile.successfulTasks + profile.failedTasks);
+        const event = {
+            eventId: `evt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            agentId,
+            eventType: success ? 'task_success' : 'task_failure',
+            timestamp: Date.now(),
+            referenceId: taskId,
+            scoreDelta: success ? 1 : -1,
+            metadata
+        };
+        this.scoringEvents.push(event);
+        this.recalculateTrustScore(agentId);
+        logger.info(`Task outcome recorded: ${agentId} - ${taskId} - ${success ? 'SUCCESS' : 'FAILURE'}`);
+    }
+    /**
+     * Record a peer review for an agent
+     */
+    recordPeerReview(agentId, reviewId, score, // 0-1
+    reviewerId) {
+        const profile = this.getOrCreateProfile(agentId);
+        const totalScore = profile.avgPeerScore * profile.reviewCount + score;
+        profile.reviewCount++;
+        profile.avgPeerScore = totalScore / profile.reviewCount;
+        profile.lastActivityAt = Date.now();
+        const event = {
+            eventId: `evt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            agentId,
+            eventType: 'peer_review',
+            timestamp: Date.now(),
+            referenceId: reviewId,
+            scoreDelta: score - 0.5,
+            metadata: { reviewerId }
+        };
+        this.scoringEvents.push(event);
+        this.recalculateTrustScore(agentId);
+        logger.info(`Peer review recorded: ${agentId} - Review: ${reviewerId} - Score: ${score.toFixed(2)}`);
+    }
+    /**
+     * Update capability quality score for an agent
+     */
+    updateCapabilityScore(agentId, capability, qualityScore, assessmentCount = 1) {
+        const profile = this.getOrCreateProfile(agentId);
+        const existing = profile.capabilities.get(capability);
+        const newScore = existing
+            ? {
+                capability,
+                qualityScore: (existing.qualityScore * existing.assessmentCount + qualityScore) / (existing.assessmentCount + assessmentCount),
+                assessmentCount: existing.assessmentCount + assessmentCount,
+                lastUpdated: Date.now(),
+                trend: qualityScore > existing.qualityScore ? 'positive' : qualityScore < existing.qualityScore ? 'negative' : 'stable'
+            }
+            : {
+                capability,
+                qualityScore,
+                assessmentCount,
+                lastUpdated: Date.now(),
+                trend: 'stable'
+            };
+        profile.capabilities.set(capability, newScore);
+        profile.lastActivityAt = Date.now();
+        const event = {
+            eventId: `evt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            agentId,
+            eventType: 'capability_assessment',
+            timestamp: Date.now(),
+            metadata: { capability, qualityScore }
+        };
+        this.scoringEvents.push(event);
+        this.recalculateTrustScore(agentId);
+        logger.info(`Capability updated: ${agentId} - ${capability}: ${qualityScore}`);
+    }
+    /**
+     * Set EU AI Act risk category for an agent
+     */
+    setAIActCategory(agentId, category) {
+        const profile = this.getOrCreateProfile(agentId);
+        profile.aiActCategory = category;
+        logger.info(`AI Act category set: ${agentId} - ${category}`);
+    }
+    /**
+     * Get trust scoring result for an agent
+     */
+    getTrustScore(agentId) {
+        const profile = this.agentProfiles.get(agentId);
+        if (!profile) {
+            return null;
+        }
+        const recentEvents = this.scoringEvents
+            .filter(e => e.agentId === agentId)
+            .slice(-10);
+        const breakdown = this.calculateScoreBreakdown(profile);
+        return {
+            profile: { ...profile, capabilities: new Map(profile.capabilities) },
+            recentEvents,
+            breakdown
+        };
+    }
+    /**
+     * Get trust level from numeric score
+     */
+    getTrustLevel(score) {
+        const { trustLevelThresholds } = this.config;
+        if (score >= trustLevelThresholds.trusted)
+            return TrustLevel.TRUSTED;
+        if (score >= trustLevelThresholds.high)
+            return TrustLevel.HIGH;
+        if (score >= trustLevelThresholds.medium)
+            return TrustLevel.MEDIUM;
+        if (score >= trustLevelThresholds.low)
+            return TrustLevel.LOW;
+        return TrustLevel.UNTRUSTED;
+    }
+    /**
+     * Get or create agent profile
+     */
+    getOrCreateProfile(agentId) {
+        let profile = this.agentProfiles.get(agentId);
+        if (!profile) {
+            profile = this.registerAgent(agentId, agentId);
+        }
+        return profile;
+    }
+    /**
+     * Recalculate trust score for an agent
+     */
+    recalculateTrustScore(agentId) {
+        const profile = this.agentProfiles.get(agentId);
+        if (!profile)
+            return;
+        const breakdown = this.calculateScoreBreakdown(profile);
+        profile.trustScore = Math.max(0, Math.min(100, Math.round(breakdown.finalScore)));
+        profile.trustLevel = this.getTrustLevel(profile.trustScore);
+    }
+    /**
+     * Calculate score breakdown for an agent
+     */
+    calculateScoreBreakdown(profile) {
+        const totalTasks = profile.successfulTasks + profile.failedTasks;
+        // Task success score (requires minimum tasks)
+        let taskScore = 50;
+        if (totalTasks >= this.config.minTasksForTrustScore) {
+            taskScore = profile.successRate * 100;
+        }
+        // Peer review score (already 0-1, scale to 0-100)
+        const peerReviewScore = profile.avgPeerScore * 100;
+        // Capability score
+        let capabilityScore = 50;
+        if (profile.capabilities.size > 0) {
+            const totalCapabilityScore = Array.from(profile.capabilities.values())
+                .reduce((sum, cap) => sum + cap.qualityScore, 0);
+            capabilityScore = totalCapabilityScore / profile.capabilities.size;
+        }
+        // Calculate weighted final score
+        const weightedScore = (taskScore * this.config.taskSuccessWeight +
+            peerReviewScore * this.config.peerReviewWeight +
+            capabilityScore * this.config.capabilityWeight);
+        // Apply decay for inactivity
+        const daysInactive = (Date.now() - profile.lastActivityAt) / (1000 * 60 * 60 * 24);
+        const decayPenalty = Math.min(30, daysInactive * this.config.decayRatePerDay * 100);
+        const finalScore = Math.max(0, weightedScore - decayPenalty);
+        return {
+            taskScore: Math.round(taskScore * 100) / 100,
+            peerReviewScore: Math.round(peerReviewScore * 100) / 100,
+            capabilityScore: Math.round(capabilityScore * 100) / 100,
+            decayPenalty: Math.round(decayPenalty * 100) / 100,
+            finalScore: Math.round(finalScore * 100) / 100
+        };
+    }
+    /**
+     * Get all registered agents sorted by trust score
+     */
+    getAllAgents() {
+        return Array.from(this.agentProfiles.values())
+            .sort((a, b) => b.trustScore - a.trustScore);
+    }
+    /**
+     * Get agents by trust level
+     */
+    getAgentsByLevel(level) {
+        return Array.from(this.agentProfiles.values())
+            .filter(p => p.trustLevel === level);
+    }
+    /**
+     * Get high-risk agents (EU AI Act)
+     */
+    getHighRiskAgents() {
+        return Array.from(this.agentProfiles.values())
+            .filter(p => p.aiActCategory === AIActRiskCategory.HIGH_RISK ||
+            p.aiActCategory === AIActRiskCategory.UNacceptable_Risk);
+    }
+    /**
+     * Check if agent meets trust threshold for a task
+     */
+    meetsTrustThreshold(agentId, minTrustLevel) {
+        const profile = this.agentProfiles.get(agentId);
+        if (!profile)
+            return false;
+        const levels = [
+            TrustLevel.UNTRUSTED,
+            TrustLevel.LOW,
+            TrustLevel.MEDIUM,
+            TrustLevel.HIGH,
+            TrustLevel.TRUSTED
+        ];
+        return levels.indexOf(profile.trustLevel) >= levels.indexOf(minTrustLevel);
+    }
+    /**
+     * Get scoring events for an agent
+     */
+    getEvents(agentId, limit = 50) {
+        return this.scoringEvents
+            .filter(e => e.agentId === agentId)
+            .slice(-limit);
+    }
+    /**
+     * Get system statistics
+     */
+    getSystemStats() {
+        const profiles = Array.from(this.agentProfiles.values());
+        const avgTrustScore = profiles.length > 0
+            ? profiles.reduce((sum, p) => sum + p.trustScore, 0) / profiles.length
+            : 0;
+        const agentsByLevel = {
+            [TrustLevel.UNTRUSTED]: 0,
+            [TrustLevel.LOW]: 0,
+            [TrustLevel.MEDIUM]: 0,
+            [TrustLevel.HIGH]: 0,
+            [TrustLevel.TRUSTED]: 0
+        };
+        profiles.forEach(p => agentsByLevel[p.trustLevel]++);
+        return {
+            totalAgents: profiles.length,
+            avgTrustScore: Math.round(avgTrustScore * 100) / 100,
+            agentsByLevel,
+            highRiskCount: this.getHighRiskAgents().length,
+            totalEvents: this.scoringEvents.length
+        };
+    }
+    /**
+     * Export profile data for compliance
+     */
+    exportForCompliance(agentId) {
+        const profile = this.agentProfiles.get(agentId);
+        if (!profile)
+            return null;
+        return {
+            agentId: profile.agentId,
+            agentName: profile.agentName,
+            trustScore: profile.trustScore,
+            trustLevel: profile.trustLevel,
+            aiActCategory: profile.aiActCategory,
+            capabilities: Array.from(profile.capabilities.entries()).map(([cap, score]) => ({
+                capability: cap,
+                qualityScore: score.qualityScore,
+                assessmentCount: score.assessmentCount,
+                trend: score.trend
+            })),
+            registeredAt: new Date(profile.registeredAt).toISOString(),
+            lastActivityAt: new Date(profile.lastActivityAt).toISOString(),
+            complianceCheck: {
+                hasRequiredAssessments: profile.reviewCount >= 3,
+                meetsMinimumTrust: profile.trustScore >= 40,
+                highRiskClassification: profile.aiActCategory === AIActRiskCategory.HIGH_RISK
+            }
+        };
+    }
+}
+/**
+ * Create a trust scoring system instance
+ */
+export function createTrustScorer(config) {
+    logger.info('Creating TrustScorer instance');
+    return new TrustScorer(config);
+}

package/dist/version.js

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

package/package.json

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