mark-improving-agent 2.2.4 → 2.2.6

package/VERSION

@@ -1 +1 @@
-2.2.4
+2.2.6

package/dist/core/collaboration/index.js

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

package/dist/core/collaboration/peer-review.js

@@ -0,0 +1,265 @@
+/**
+ * Multi-Agent Peer Review System
+ *
+ * Enables cross-model peer review of agent decisions and outputs.
+ * Based on agentic-fleet-hub's peer review architecture.
+ *
+ * Key features:
+ * - Multiple agents review each other's work
+ * - Consensus-based approval
+ * - Dissent tracking for quality improvement
+ * - Reputation-weighted voting
+ *
+ * @module core/collaboration
+ * @fileoverview Cross-model peer review for agent outputs
+ */
+import { randomUUID } from 'crypto';
+import { createLogger } from '../../utils/logger.js';
+const logger = createLogger('PeerReview');
+/**
+ * Default reviewers
+ */
+const DEFAULT_REVIEWERS = [
+    {
+        id: 'reviewer-logic',
+        name: 'Logic Reviewer',
+        model: 'claude-opus',
+        specialties: ['reasoning', 'logic', 'consistency'],
+        reputation: 0.95,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+    {
+        id: 'reviewer-safety',
+        name: 'Safety Reviewer',
+        model: 'claude-opus',
+        specialties: ['safety', 'ethics', 'harm prevention'],
+        reputation: 0.98,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+    {
+        id: 'reviewer-quality',
+        name: 'Quality Reviewer',
+        model: 'claude-sonnet',
+        specialties: ['code quality', 'documentation', 'best practices'],
+        reputation: 0.92,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+    {
+        id: 'reviewer-creativity',
+        name: 'Creativity Reviewer',
+        model: 'claude-haiku',
+        specialties: ['innovation', 'alternatives', 'creative solutions'],
+        reputation: 0.88,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+];
+export function createPeerReviewSystem(options) {
+    const consensusThreshold = options?.consensusThreshold ?? 0.7;
+    const requiredReviewers = options?.requiredReviewers ?? 3;
+    const enableArbitration = options?.enableArbitration ?? true;
+    // State
+    const items = new Map();
+    const reviewers = new Map(DEFAULT_REVIEWERS.map(r => [r.id, r]));
+    const sessions = new Map();
+    const reviewHistory = [];
+    // Stats
+    let totalReviewTime = 0;
+    let consensusCount = 0;
+    let revisionCount = 0;
+    function submitItem(submitterId, content, type, context, options) {
+        const item = {
+            id: randomUUID(),
+            submitterId,
+            content,
+            type,
+            context: context ?? {},
+            status: 'pending',
+            votes: [],
+            createdAt: Date.now(),
+            consensusThreshold: options?.consensusThreshold ?? consensusThreshold,
+            requiredReviewers: options?.requiredReviewers ?? requiredReviewers,
+        };
+        items.set(item.id, item);
+        logger.info(`Review item submitted: ${item.id} by ${submitterId}`);
+        // Auto-assign reviewers
+        assignReviewers(item.id);
+        return item;
+    }
+    function registerReviewer(reviewer) {
+        reviewers.set(reviewer.id, {
+            ...reviewer,
+            reviewsCompleted: 0,
+            approvalRate: 0,
+        });
+        logger.info(`Reviewer registered: ${reviewer.name}`);
+    }
+    function getReviewersForType(contentType) {
+        const relevantReviewers = Array.from(reviewers.values()).filter(r => r.specialties.some(s => contentType === 'code' ? s.includes('code') :
+            contentType === 'decision' ? s.includes('reasoning') || s.includes('logic') :
+                contentType === 'response' ? s.includes('ethics') || s.includes('safety') :
+                    true));
+        // Return up to 4 reviewers
+        return relevantReviewers.slice(0, 4);
+    }
+    function assignReviewers(itemId) {
+        const item = items.get(itemId);
+        if (!item || item.status !== 'pending')
+            return null;
+        const availableReviewers = getReviewersForType(item.type)
+            .filter(r => r.id !== item.submitterId)
+            .slice(0, item.requiredReviewers);
+        if (availableReviewers.length < 2) {
+            // Use default reviewers if no specialty match
+            const defaults = Array.from(reviewers.values())
+                .filter(r => r.id !== item.submitterId)
+                .slice(0, item.requiredReviewers);
+            availableReviewers.push(...defaults);
+        }
+        const session = {
+            itemId,
+            phase: 'review',
+            assignedReviewers: availableReviewers.map(r => r.id),
+            completedReviews: 0,
+            consensusReached: false,
+        };
+        sessions.set(itemId, session);
+        item.status = 'in_review';
+        logger.info(`Assigned ${availableReviewers.length} reviewers to ${itemId}`);
+        return item;
+    }
+    function submitVote(itemId, reviewerId, decision, feedback, confidence) {
+        const item = items.get(itemId);
+        const session = sessions.get(itemId);
+        const reviewer = reviewers.get(reviewerId);
+        if (!item || !session || !reviewer) {
+            logger.warn(`Invalid vote submission: item=${itemId}, reviewer=${reviewerId}`);
+            return null;
+        }
+        // Check if reviewer is assigned
+        if (!session.assignedReviewers.includes(reviewerId)) {
+            logger.warn(`Reviewer ${reviewerId} not assigned to ${itemId}`);
+            return null;
+        }
+        // Check if reviewer already voted
+        if (item.votes.some(v => v.reviewerId === reviewerId)) {
+            logger.warn(`Reviewer ${reviewerId} already voted on ${itemId}`);
+            return null;
+        }
+        const vote = {
+            reviewerId,
+            role: session.completedReviews === 0 ? 'primary' : 'secondary',
+            decision,
+            confidence: Math.max(0, Math.min(1, confidence)),
+            feedback,
+            timestamp: Date.now(),
+        };
+        item.votes.push(vote);
+        session.completedReviews++;
+        reviewHistory.push(vote);
+        // Update reviewer stats
+        reviewer.reviewsCompleted++;
+        logger.info(`Vote submitted: ${reviewerId} -> ${decision} on ${itemId}`);
+        // Check consensus
+        const consensus = checkConsensus(itemId);
+        if (consensus.reached && consensus.decision) {
+            item.status = consensus.decision;
+            item.completedAt = Date.now();
+            session.consensusReached = true;
+            session.decision = consensus.decision === 'approved' ? 'approved' :
+                consensus.decision === 'rejected' ? 'rejected' : 'revision_requested';
+            if (consensus.decision === 'revision_requested') {
+                revisionCount++;
+            }
+            consensusCount++;
+        }
+        return vote;
+    }
+    function checkConsensus(itemId) {
+        const item = items.get(itemId);
+        if (!item)
+            return { reached: false };
+        const requiredApprovals = Math.ceil(item.requiredReviewers * item.consensusThreshold);
+        const votes = item.votes;
+        // Need minimum votes
+        if (votes.length < item.requiredReviewers) {
+            return { reached: false };
+        }
+        // Count decisions
+        const approvals = votes.filter(v => v.decision === 'approve').length;
+        const rejections = votes.filter(v => v.decision === 'reject').length;
+        const revisions = votes.filter(v => v.decision === 'revision').length;
+        // Reputation-weighted voting
+        let weightedApprovals = 0;
+        let totalWeight = 0;
+        for (const vote of votes) {
+            const reviewer = reviewers.get(vote.reviewerId);
+            if (reviewer) {
+                const weight = reviewer.reputation * vote.confidence;
+                totalWeight += weight;
+                if (vote.decision === 'approve') {
+                    weightedApprovals += weight;
+                }
+            }
+        }
+        const weightedApprovalRate = totalWeight > 0 ? weightedApprovals / totalWeight : 0;
+        if (weightedApprovalRate >= item.consensusThreshold) {
+            return { reached: true, decision: 'approved' };
+        }
+        if (rejections > item.requiredReviewers / 2) {
+            // Check for revision option before outright rejection
+            if (enableArbitration && revisions > 0) {
+                return { reached: true, decision: 'revision_requested' };
+            }
+            return { reached: true, decision: 'rejected' };
+        }
+        // No consensus yet
+        return { reached: false };
+    }
+    function getItemStatus(itemId) {
+        return items.get(itemId);
+    }
+    function getPendingReviews(reviewerId) {
+        return Array.from(items.values()).filter(item => {
+            const session = sessions.get(item.id);
+            return (item.status === 'in_review' &&
+                session?.assignedReviewers.includes(reviewerId) &&
+                !item.votes.some(v => v.reviewerId === reviewerId));
+        });
+    }
+    function getStats() {
+        const allItems = Array.from(items.values());
+        const completedItems = allItems.filter(i => i.completedAt);
+        const avgReviewTime = completedItems.length > 0
+            ? totalReviewTime / completedItems.length
+            : 0;
+        return {
+            itemsReviewed: completedItems.length,
+            approvalRate: completedItems.length > 0
+                ? completedItems.filter(i => i.status === 'approved').length / completedItems.length
+                : 0,
+            avgReviewTime,
+            consensusRate: completedItems.length > 0
+                ? consensusCount / completedItems.length
+                : 0,
+            revisionRate: completedItems.length > 0
+                ? revisionCount / completedItems.length
+                : 0,
+            dissentCount: reviewHistory.filter(v => v.decision !== 'approve').length,
+        };
+    }
+    return {
+        submitItem,
+        registerReviewer,
+        getReviewersForType,
+        assignReviewers,
+        submitVote,
+        checkConsensus,
+        getItemStatus,
+        getPendingReviews,
+        getStats,
+    };
+}

package/dist/core/expert-models/index.js

@@ -0,0 +1,596 @@
+/**
+ * Expert Mental Models Integration
+ *
+ * Loads expert mental models into HeartFlow to improve decisions,
+ * reasoning, and judgment without role-playing personas.
+ *
+ * Based on the expert-skills pattern: mental models provide
+ * structured thinking frameworks that enhance AI reasoning.
+ *
+ * Key features:
+ * - Mental model registry with predefined expert thinking patterns
+ * - Model application to any context or decision
+ * - Model blending for multi-perspective analysis
+ * - Learning from model application outcomes
+ * - Model performance tracking
+ *
+ * @module core/expert-models
+ * @fileoverview Expert mental model integration for enhanced reasoning
+ */
+import { randomUUID } from 'crypto';
+import { createLogger } from '../../utils/logger.js';
+const logger = createLogger('[ExpertModels]');
+const DEFAULT_CONFIG = {
+    autoSuggest: true,
+    minConfidence: 0.6,
+    trackPerformance: true,
+    allowBlending: true,
+    defaultBlendWeights: [0.5, 0.3, 0.2],
+};
+// ============================================================
+// Predefined Mental Models
+// ============================================================
+const PREDEFINED_MODELS = [
+    {
+        name: 'First Principles Thinking',
+        description: 'Break down problems to their fundamental components and rebuild from there',
+        source: 'Aristotle / Elon Musk',
+        principles: [
+            'Identify the current assumption',
+            'Break it down to fundamental truths',
+            'Create new solutions from scratch',
+            'Test and iterate',
+        ],
+        applicationSteps: [
+            'State the problem as commonly understood',
+            'Ask "Is this really true?" for each component',
+            'Break down to facts that cannot be reduced further',
+            'Build new reasoning from these foundations',
+            'Test the new solution',
+        ],
+        适用场景: ['Innovation', 'Problem-solving', 'Challenging status quo'],
+        strengths: ['Eliminates assumptions', 'Enables breakthrough thinking', 'Reduces bias'],
+        weaknesses: ['Time-consuming', 'May miss practical constraints', 'Requires deep expertise'],
+        examples: ['SpaceX rocket costs', 'Tesla battery technology', 'Business model innovation'],
+        complexity: 4,
+        category: 'critical-thinking',
+    },
+    {
+        name: 'Inversion',
+        description: 'Think about the problem backwards to identify what to avoid',
+        source: 'Charlie Munger',
+        principles: [
+            'Identify what you want to achieve',
+            'Instead of asking how to succeed, ask how to fail',
+            'Avoid those failure paths',
+            'Focus on the inverse of problems',
+        ],
+        applicationSteps: [
+            'Clearly state the goal',
+            'List ways the goal could fail',
+            'Identify the root causes of potential failure',
+            'Create actions to prevent those failures',
+            'Prioritize avoiding bad outcomes',
+        ],
+        适用场景: ['Risk management', 'Strategic planning', 'Decision validation'],
+        strengths: ['Reveals hidden risks', 'Prevents hubris', 'Highlights what to avoid'],
+        weaknesses: ['Can be overly pessimistic', 'May miss opportunities', 'Focuses on negatives'],
+        examples: ['Avoiding stupid decisions', 'Risk assessment', 'Portfolio management'],
+        complexity: 3,
+        category: 'decision-making',
+    },
+    {
+        name: 'Second Order Thinking',
+        description: 'Consider the consequences of the consequences',
+        source: 'Howard Marks / Ray Dalio',
+        principles: [
+            'First order: immediate result',
+            'Second order: what follows from the first result',
+            'Third order: long-term effects',
+            'Most people stop at first order',
+        ],
+        applicationSteps: [
+            'Identify the obvious first-order consequence',
+            'Ask "And then?" for each subsequent effect',
+            'Map out 2-3 levels of consequences',
+            'Evaluate the full chain of events',
+            'Make decision based on second/third order effects',
+        ],
+        适用场景: ['Impact analysis', 'Long-term planning', 'Policy decisions'],
+        strengths: ['Prevents short-term thinking', 'Reveals hidden consequences', 'Improves foresight'],
+        weaknesses: ['Can lead to analysis paralysis', 'Hard to predict accurately', 'Uncertainty increases'],
+        examples: ['Economic policy', 'Technology adoption', 'Environmental decisions'],
+        complexity: 4,
+        category: 'systems-thinking',
+    },
+    {
+        name: 'Circle of Competence',
+        description: 'Know your boundaries and stay within them',
+        source: 'Warren Buffett',
+        principles: [
+            'Recognize what you truly understand',
+            'Identify areas where you have expertise',
+            'Be honest about ignorance',
+            'Stay within known boundaries',
+            'Expand boundaries deliberately',
+        ],
+        applicationSteps: [
+            'List areas of genuine expertise',
+            'Identify knowledge gaps honestly',
+            'When facing decisions, check if in circle',
+            'If outside, seek expert input or abstain',
+            'Gradually expand circle through learning',
+        ],
+        适用场景: ['Investment decisions', 'Expert consultation', 'Self-awareness'],
+        strengths: ['Prevents overconfidence', 'Encourages humility', 'Focuses resources'],
+        weaknesses: ['Can be limiting', 'Circle boundaries unclear', 'May miss opportunities'],
+        examples: ['Buffett investment strategy', 'Professional specialization', 'Team building'],
+        complexity: 2,
+        category: 'self-awareness',
+    },
+    {
+        name: 'Probabilistic Thinking',
+        description: 'Think in probabilities rather than certainties',
+        source: 'Nassim Taleb / Nate Silver',
+        principles: [
+            'Assign probabilities to outcomes',
+            'Update beliefs with new evidence (Bayesian)',
+            'Consider base rates',
+            'Think in expected value',
+            'Embrace uncertainty',
+        ],
+        applicationSteps: [
+            'List possible outcomes',
+            'Estimate probability of each',
+            'Calculate expected value (P × outcome)',
+            'Update with new information',
+            'Choose highest expected value option',
+        ],
+        适用场景: ['Risk assessment', 'Forecasting', 'Decision under uncertainty'],
+        strengths: ['Accounts for uncertainty', 'Prevents binary thinking', 'Quantifies risk'],
+        weaknesses: ['Requires accurate probability estimates', 'Can be gamed', 'Base rate neglect'],
+        examples: ['Weather forecasting', 'Sports betting', 'Project estimation'],
+        complexity: 4,
+        category: 'analytical',
+    },
+    {
+        name: 'Regret Minimization',
+        description: 'Minimize future regret rather than optimize present comfort',
+        source: 'Jeff Bezos',
+        principles: [
+            'Project yourself to end of life',
+            'Ask what you would regret not doing',
+            'Prioritize bold moves for low regret',
+            'Accept that regret is inevitable',
+            'Take the path with least potential regret',
+        ],
+        applicationSteps: [
+            'Imagine yourself at 80 years old',
+            'Look back at this decision point',
+            'Ask: "Will I regret not trying?"',
+            'Weight long-term regret over short-term comfort',
+            'Take the bolder action if regret is likely',
+        ],
+        适用场景: ['Career decisions', 'Major life choices', 'Entrepreneurship'],
+        strengths: ['Encourages boldness', 'Long-term perspective', 'Overcomes fear'],
+        weaknesses: ['Can justify recklessness', 'Ignores practical constraints', 'Emotional basis'],
+        examples: ['Bezos Amazon decision', 'Career pivots', 'Startup founding'],
+        complexity: 2,
+        category: 'decision-making',
+    },
+    {
+        name: "Occam's Razor",
+        description: 'The simplest explanation is usually correct',
+        source: 'William of Ockham',
+        principles: [
+            'Prefer simplicity over complexity',
+            'When multiple explanations exist, choose simplest',
+            'Entities should not be multiplied unnecessarily',
+            'Test simple explanations first',
+            'Complexity requires justification',
+        ],
+        applicationSteps: [
+            'Gather all possible explanations',
+            'Evaluate complexity of each',
+            'Remove unnecessary assumptions',
+            'Select the simplest that fits facts',
+            'Only add complexity if evidence demands it',
+        ],
+        适用场景: ['Diagnosis', 'Problem diagnosis', 'Theory building'],
+        strengths: ['Parsimonious', 'Practical', 'Avoids overfitting'],
+        weaknesses: ['Truth may be complex', 'Can oversimplify', 'Bias toward familiar'],
+        examples: ['Medical diagnosis', 'Troubleshooting', 'Scientific hypothesis'],
+        complexity: 2,
+        category: 'analytical',
+    },
+    {
+        name: "Hanlon's Razor",
+        description: 'Never attribute to malice that which is adequately explained by incompetence',
+        source: 'Robert Hanlon',
+        principles: [
+            'Assume incompetence before malice',
+            'Look for simple explanations first',
+            'Consider communication failures',
+            'Avoid unnecessary negative interpretations',
+            'Give benefit of the doubt',
+        ],
+        applicationSteps: [
+            'Observe an action that seems harmful',
+            'Ask: is there a simple explanation?',
+            'Consider information gaps or confusion',
+            'Only assume malice if no other explanation fits',
+            'Address the incompetence, not the person',
+        ],
+        适用场景: ['Conflict resolution', 'Team dynamics', 'Communication'],
+        strengths: ['Preserves relationships', 'Avoids unnecessary conflict', 'Practical'],
+        weaknesses: ['May miss actual bad actors', 'Can excuse abuse', 'Naive in some contexts'],
+        examples: ['Office politics', 'Customer complaints', 'Cross-cultural communication'],
+        complexity: 2,
+        category: 'ethical',
+    },
+    {
+        name: 'Map and Territory',
+        description: 'Distinguish between your model of reality and reality itself',
+        source: 'Nassim Taleb',
+        principles: [
+            'Your mental map is not the territory',
+            'Models are simplifications of reality',
+            'Reality is always more complex',
+            'Update maps when territory disagrees',
+            'Be humble about model accuracy',
+        ],
+        applicationSteps: [
+            'Identify your current model/belief',
+            'Acknowledge it is a simplification',
+            'Compare to actual outcomes/evidence',
+            'Note where model diverges from reality',
+            'Update model to better fit territory',
+        ],
+        适用场景: ['Belief revision', 'Forecast evaluation', 'Self-awareness'],
+        strengths: ['Promotes epistemic humility', 'Encourages testing', 'Reduces overconfidence'],
+        weaknesses: ['Can lead to perpetual doubt', 'Hard to know true territory', 'May paralyze'],
+        examples: ['Economic forecasts', 'Expert predictions', 'Personal beliefs'],
+        complexity: 3,
+        category: 'critical-thinking',
+    },
+    {
+        name: 'Thought Experiment',
+        description: 'Use imaginative scenarios to test ideas and assumptions',
+        source: 'Einstein / Philosophy tradition',
+        principles: [
+            'Construct hypothetical scenarios',
+            'Follow logic through to implications',
+            'Isolate key variables',
+            'Use imagination to explore possibilities',
+            'Derive insights from deduction',
+        ],
+        applicationSteps: [
+            'Identify the principle or rule to test',
+            'Construct a hypothetical scenario',
+            'Apply the principle to this scenario',
+            'Follow implications logically',
+            'Extract insights about the principle',
+        ],
+        适用场景: ['Philosophy', 'Physics', 'Ethical reasoning', 'Strategy'],
+        strengths: ['No real-world consequences', 'Tests logic', 'Reveals assumptions'],
+        weaknesses: ['May not transfer to reality', 'Imagination limits', 'Logical errors possible'],
+        examples: ["Einstein's elevator", 'Trolley problem', 'Veil of ignorance'],
+        complexity: 3,
+        category: 'creative',
+    },
+    {
+        name: 'STS (Systems Thinking Synthesis)',
+        description: 'See the whole system, not just parts - feedback loops, emergence, delays',
+        source: 'Peter Senge / Donella Meadows',
+        principles: [
+            'See interconnections, not just components',
+            'Identify feedback loops (reinforcing/balancing)',
+            'Notice delays between action and effect',
+            'Look for emergent properties',
+            'Find leverage points in the system',
+        ],
+        applicationSteps: [
+            'Map the system components',
+            'Identify relationships and connections',
+            'Find feedback loops',
+            'Notice delays and accumulations',
+            'Identify high-leverage intervention points',
+        ],
+        适用场景: ['Organizational change', 'Policy design', 'Complex problem diagnosis'],
+        strengths: ['Holistic view', 'Reveals hidden dynamics', 'Identifies leverage'],
+        weaknesses: ['Complex', 'Hard to model accurately', 'Delays hard to predict'],
+        examples: ['Climate policy', 'Company culture', 'Market dynamics'],
+        complexity: 5,
+        category: 'systems-thinking',
+    },
+];
+/**
+ * Create an Expert Models Engine
+ */
+export function createExpertModelsEngine(config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    // Model registry
+    const models = new Map();
+    // Application history
+    const applicationHistory = new Map();
+    // Model blends
+    const blends = new Map();
+    // Initialize with predefined models
+    for (const modelData of PREDEFINED_MODELS) {
+        const model = {
+            ...modelData,
+            id: randomUUID(),
+            usageCount: 0,
+            successRate: 0,
+            lastUsed: 0,
+        };
+        models.set(model.id, model);
+    }
+    logger.info(`Expert Models initialized with ${models.size} predefined models`);
+    // ========================================
+    // Utility functions
+    // ========================================
+    function scoreModelRelevance(model, context, purpose) {
+        const contextLower = (context + ' ' + (purpose || '')).toLowerCase();
+        // Score based on category keywords
+        const categoryKeywords = {
+            'decision-making': ['decide', 'choice', 'option', 'select', 'pick', 'choose', 'risk', 'opportunity'],
+            'critical-thinking': ['analyze', 'evaluate', 'assess', 'examine', 'critique', 'reason', 'think'],
+            'problem-solving': ['problem', 'issue', 'fix', 'solve', 'resolve', 'troubleshoot', 'debug'],
+            'strategic': ['strategy', 'long-term', 'planning', 'goal', 'future', 'vision', 'competitive'],
+            'systems-thinking': ['system', 'feedback', 'loop', 'emergent', 'interconnected', 'holistic'],
+            'creative': ['creative', 'innovate', 'new', 'idea', 'imagine', 'brainstorm', 'design'],
+            'analytical': ['data', 'analyze', 'measure', 'quantify', 'statistic', 'probability', 'evidence'],
+            'ethical': ['moral', 'ethical', 'right', 'wrong', 'fair', 'justice', 'value'],
+            'self-awareness': ['aware', 'bias', 'blind', 'strength', 'weakness', 'competence', 'knowledge'],
+        };
+        const keywords = categoryKeywords[model.category] || [];
+        let score = 0;
+        for (const keyword of keywords) {
+            if (contextLower.includes(keyword)) {
+                score += 1;
+            }
+        }
+        // Boost for matching 应用场景
+        for (const scenario of model.适用场景) {
+            if (contextLower.includes(scenario.toLowerCase())) {
+                score += 2;
+            }
+        }
+        // Normalize by model complexity (simpler models score slightly higher for general use)
+        const complexityBonus = (6 - model.complexity) * 0.1;
+        return Math.min(1, (score / Math.max(1, keywords.length)) + complexityBonus);
+    }
+    function generateReasoning(model, context, input) {
+        const steps = model.applicationSteps.map((step, i) => `${i + 1}. ${step}`).join('\n');
+        return `Applying "${model.name}" mental model:
+
+**Context**: ${context}
+
+**Input**: ${input}
+
+**Model Source**: ${model.source}
+
+**Principles**:
+${model.principles.map(p => `- ${p}`).join('\n')}
+
+**Application Steps**:
+${steps}
+
+**Model Strengths**: ${model.strengths.join(', ')}
+**Model Limitations**: ${model.weaknesses.join(', ')}
+`;
+    }
+    function extractConclusion(reasoning, model) {
+        // Extract a conclusion based on model type
+        const modelConclusions = {
+            'First Principles Thinking': 'Rebuild from fundamental truths, eliminating assumptions',
+            'Inversion': 'Avoid failure paths to achieve success',
+            'Second Order Thinking': 'Consider second and third order consequences',
+            'Circle of Competence': 'Stay within known boundaries or expand deliberately',
+            'Probabilistic Thinking': 'Calculate expected value and update with evidence',
+            'Regret Minimization': 'Choose the path that minimizes long-term regret',
+            "Occam's Razor": 'Select the simplest explanation that fits',
+            "Hanlon's Razor": 'Assume incompetence before malice',
+            'Map and Territory': 'Update mental models to match reality',
+            'Thought Experiment': 'Use hypothetical scenarios to test principles',
+            'STS (Systems Thinking Synthesis)': 'Find leverage points in the system',
+        };
+        return modelConclusions[model.name] || `Apply ${model.name} principles`;
+    }
+    // ========================================
+    // Engine implementation
+    // ========================================
+    return {
+        // Registry
+        registerModel(modelData) {
+            const model = {
+                ...modelData,
+                id: randomUUID(),
+                usageCount: 0,
+                successRate: 0,
+                lastUsed: Date.now(),
+            };
+            models.set(model.id, model);
+            logger.info(`Registered new model: ${model.name} (${model.id})`);
+            return model;
+        },
+        getModel(id) {
+            return models.get(id);
+        },
+        getModelsByCategory(category) {
+            return Array.from(models.values()).filter(m => m.category === category);
+        },
+        listModels() {
+            return Array.from(models.values());
+        },
+        removeModel(id) {
+            const deleted = models.delete(id);
+            if (deleted) {
+                logger.info(`Removed model: ${id}`);
+            }
+            return deleted;
+        },
+        // Application
+        async applyModel(modelId, context, input) {
+            const model = models.get(modelId);
+            if (!model) {
+                throw new Error(`Model not found: ${modelId}`);
+            }
+            const startTime = Date.now();
+            const reasoning = generateReasoning(model, context, input);
+            const conclusion = extractConclusion(reasoning, model);
+            const application = {
+                id: randomUUID(),
+                modelId,
+                context,
+                input,
+                reasoning,
+                timestamp: startTime,
+                duration: Date.now() - startTime,
+            };
+            applicationHistory.set(application.id, { application, modelId });
+            // Update model usage
+            model.usageCount++;
+            model.lastUsed = Date.now();
+            logger.info(`Applied model "${model.name}" to context "${context}"`);
+            return {
+                modelId,
+                modelName: model.name,
+                reasoning,
+                conclusion,
+                confidence: 0.7 + (model.complexity * 0.05), // Higher complexity = higher confidence
+                principlesApplied: model.principles.slice(0, 2),
+                alternativePerspectives: [],
+                potentialBiases: model.weaknesses.slice(0, 2),
+                quality: 0.75, // Placeholder until outcome recorded
+            };
+        },
+        suggestModels(context, purpose) {
+            const scored = Array.from(models.values())
+                .map(model => ({
+                model,
+                score: scoreModelRelevance(model, context, purpose),
+            }))
+                .filter(s => s.score > 0.1)
+                .sort((a, b) => b.score - a.score);
+            return scored.slice(0, 3).map(s => s.model);
+        },
+        getApplicableModels(scenario) {
+            return this.suggestModels(scenario);
+        },
+        // Blending
+        createBlend(name, modelIds, weights) {
+            if (modelIds.length < 2) {
+                throw new Error('Blend requires at least 2 models');
+            }
+            const blendWeights = weights || cfg.defaultBlendWeights.slice(0, modelIds.length);
+            while (blendWeights.length < modelIds.length) {
+                blendWeights.push(0);
+            }
+            // Normalize weights
+            const total = blendWeights.reduce((a, b) => a + b, 0);
+            const normalized = blendWeights.map(w => w / total);
+            const blend = {
+                id: randomUUID(),
+                name,
+                modelIds,
+                weights: normalized,
+                description: `Blend of ${modelIds.length} mental models`,
+                purpose: 'Multi-perspective analysis',
+            };
+            blends.set(blend.id, blend);
+            logger.info(`Created blend: ${name} (${blend.id})`);
+            return blend;
+        },
+        async applyBlend(blendId, context, input) {
+            const blend = blends.get(blendId);
+            if (!blend) {
+                throw new Error(`Blend not found: ${blendId}`);
+            }
+            const perspectives = [];
+            const conflicts = [];
+            for (let i = 0; i < blend.modelIds.length; i++) {
+                const result = await this.applyModel(blend.modelIds[i], context, input);
+                perspectives.push(result);
+            }
+            // Check agreement between perspectives
+            const conclusions = perspectives.map(p => p.conclusion);
+            const uniqueConclusions = new Set(conclusions);
+            const agreementLevel = 1 - (uniqueConclusions.size - 1) / conclusions.length;
+            if (agreementLevel < 0.5) {
+                conflicts.push(`Only ${Math.round(agreementLevel * 100)}% agreement between models`);
+            }
+            // Synthesize conclusion
+            const synthesizedConclusion = `Multi-model analysis (${perspectives.length} perspectives): ${perspectives.map(p => p.modelName).join(', ')}. Agreement: ${Math.round(agreementLevel * 100)}%.`;
+            return {
+                blendId: blend.id,
+                blendName: blend.name,
+                perspectives,
+                synthesizedConclusion,
+                agreementLevel,
+                conflicts,
+                confidence: agreementLevel * 0.8 + 0.2,
+                quality: 0.75,
+            };
+        },
+        getBlends() {
+            return Array.from(blends.values());
+        },
+        removeBlend(id) {
+            return blends.delete(id);
+        },
+        // Performance tracking
+        recordOutcome(applicationId, outcome, quality) {
+            const record = applicationHistory.get(applicationId);
+            if (!record) {
+                logger.warn(`Application not found: ${applicationId}`);
+                return;
+            }
+            record.application.outcome = outcome;
+            record.application.quality = quality;
+            const model = models.get(record.modelId);
+            if (model && cfg.trackPerformance) {
+                // Update running success rate
+                const totalQuality = model.successRate * model.usageCount + quality;
+                model.successRate = totalQuality / model.usageCount;
+            }
+            logger.info(`Recorded outcome for ${applicationId}: quality=${quality}`);
+        },
+        getModelStats(modelId) {
+            const model = models.get(modelId);
+            if (!model) {
+                return { usageCount: 0, successRate: 0, avgQuality: 0 };
+            }
+            return {
+                usageCount: model.usageCount,
+                successRate: model.successRate,
+                avgQuality: model.successRate, // Same as successRate
+            };
+        },
+        getTopModels(limit = 5) {
+            return Array.from(models.values())
+                .filter(m => m.usageCount > 0)
+                .sort((a, b) => b.successRate - a.successRate)
+                .slice(0, limit);
+        },
+        // Analysis
+        async analyzeDecision(context, input) {
+            const suggestedModels = this.suggestModels(context);
+            const modelsToApply = suggestedModels.slice(0, 3);
+            const results = [];
+            for (const model of modelsToApply) {
+                const result = await this.applyModel(model.id, context, input);
+                results.push(result);
+            }
+            // Generate recommendation
+            const avgConfidence = results.reduce((sum, r) => sum + r.confidence, 0) / results.length;
+            const topResult = results.reduce((best, r) => r.confidence > best.confidence ? r : best, results[0]);
+            return {
+                models: results,
+                recommendation: `Apply "${topResult.modelName}" for highest confidence. Consider blending ${results.length} models for multi-perspective analysis.`,
+                confidence: avgConfidence,
+            };
+        },
+    };
+}

package/dist/core/memory/hybrid-search.js

@@ -0,0 +1,177 @@
+/**
+ * Hybrid Memory Search
+ *
+ * Combines vector similarity search with BM25 keyword matching and knowledge graph traversal
+ * Based on Dakera AI's hybrid search architecture (87.8% LoCoMo accuracy)
+ *
+ * @module core/memory
+ * @fileoverview Hybrid search combining vector + BM25 + knowledge graph for superior recall
+ */
+import { createLogger } from '../../utils/logger.js';
+const logger = createLogger('HybridSearch');
+/**
+ * Default hybrid search configuration
+ */
+export const DEFAULT_HYBRID_CONFIG = {
+    vectorWeight: 0.5,
+    bm25Weight: 0.3,
+    kgWeight: 0.2,
+    bm25: { k1: 1.5, b: 0.75 },
+    minScore: 0.1,
+    maxResults: 20,
+};
+/**
+ * Tokenizer for BM25
+ */
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s]/g, ' ')
+        .split(/\s+/)
+        .filter(token => token.length > 2);
+}
+/**
+ * Create a BM25 index from memory entries
+ */
+export function createBM25Index(entries) {
+    const index = {
+        docLengths: new Map(),
+        termDocFreq: new Map(),
+        avgDocLength: 0,
+        totalDocs: entries.length,
+        invertedIndex: new Map(),
+    };
+    let totalLength = 0;
+    for (const entry of entries) {
+        const tokens = tokenize(entry.content);
+        const docLength = tokens.length;
+        index.docLengths.set(entry.id, docLength);
+        totalLength += docLength;
+        // Count term frequencies
+        const termFreq = new Map();
+        for (const token of tokens) {
+            termFreq.set(token, (termFreq.get(token) ?? 0) + 1);
+            if (!index.invertedIndex.has(token)) {
+                index.invertedIndex.set(token, new Map());
+            }
+            const posting = index.invertedIndex.get(token);
+            posting.set(entry.id, termFreq.get(token));
+        }
+        // Update document frequency
+        for (const token of new Set(tokens)) {
+            index.termDocFreq.set(token, (index.termDocFreq.get(token) ?? 0) + 1);
+        }
+    }
+    index.avgDocLength = totalLength / Math.max(entries.length, 1);
+    return index;
+}
+/**
+ * Calculate BM25 score for a single document
+ */
+export function bm25Score(index, docId, queryTokens, config) {
+    const docLength = index.docLengths.get(docId) ?? 0;
+    let score = 0;
+    for (const token of queryTokens) {
+        const tf = index.invertedIndex.get(token)?.get(docId) ?? 0;
+        if (tf === 0)
+            continue;
+        const df = index.termDocFreq.get(token) ?? 0;
+        if (df === 0)
+            continue;
+        const idf = Math.log((index.totalDocs - df + 0.5) / (df + 0.5) + 1);
+        const tfComponent = (tf * (config.k1 + 1)) / (tf + config.k1 * (1 - config.b + config.b * (docLength / index.avgDocLength)));
+        score += idf * tfComponent;
+    }
+    return score;
+}
+/**
+ * Normalize BM25 scores to 0-1 range
+ */
+export function normalizeBM25Scores(scores) {
+    const maxScore = Math.max(...Array.from(scores.values()), 1);
+    const normalized = new Map();
+    for (const [docId, score] of scores) {
+        normalized.set(docId, score / maxScore);
+    }
+    return normalized;
+}
+/**
+ * Create a hybrid search engine
+ */
+export function createHybridSearchEngine(initialEntries = [], config = {}) {
+    const fullConfig = {
+        ...DEFAULT_HYBRID_CONFIG,
+        ...config,
+        bm25: { ...DEFAULT_HYBRID_CONFIG.bm25, ...config.bm25 },
+    };
+    let bm25Index = createBM25Index(initialEntries);
+    function rebuildIndex(entries) {
+        logger.info(`Rebuilding BM25 index with ${entries.length} documents`);
+        bm25Index = createBM25Index(entries);
+    }
+    function search(query, entries, options) {
+        const searchConfig = {
+            ...fullConfig,
+            ...options?.config,
+        };
+        // Tokenize query for BM25
+        const queryTokens = tokenize(query);
+        // Calculate BM25 scores for all entries
+        const bm25Scores = new Map();
+        for (const entry of entries) {
+            const score = bm25Score(bm25Index, entry.id, queryTokens, searchConfig.bm25);
+            if (score > 0) {
+                bm25Scores.set(entry.id, score);
+            }
+        }
+        const normalizedBM25 = normalizeBM25Scores(bm25Scores);
+        // Calculate KG scores based on connection count
+        const kgScores = new Map();
+        if (options?.kgConnections) {
+            const maxConnections = Math.max(...Array.from(options.kgConnections.values()).map(arr => arr.length), 1);
+            for (const entry of entries) {
+                const connections = options.kgConnections.get(entry.id)?.length ?? 0;
+                kgScores.set(entry.id, connections / maxConnections);
+            }
+        }
+        // Combine scores
+        const combinedResults = new Map();
+        for (const entry of entries) {
+            const vectorScore = options?.vectorScores?.get(entry.id) ?? 0;
+            const bm25Score = normalizedBM25.get(entry.id) ?? 0;
+            const kgScore = kgScores.get(entry.id) ?? 0;
+            // Weighted combination
+            const combinedScore = (vectorScore * searchConfig.vectorWeight) +
+                (bm25Score * searchConfig.bm25Weight) +
+                (kgScore * searchConfig.kgWeight);
+            if (combinedScore >= searchConfig.minScore) {
+                combinedResults.set(entry.id, {
+                    entry,
+                    score: combinedScore,
+                    combinedScore,
+                    vectorScore,
+                    bm25Score,
+                    kgScore,
+                    reason: 'semantic',
+                });
+            }
+        }
+        // Sort by combined score
+        const results = Array.from(combinedResults.values())
+            .sort((a, b) => b.combinedScore - a.combinedScore)
+            .slice(0, searchConfig.maxResults);
+        logger.debug(`Hybrid search for "${query}": ${results.length} results`);
+        return results;
+    }
+    function getStats() {
+        return {
+            indexedDocs: bm25Index.totalDocs,
+            avgDocLength: Math.round(bm25Index.avgDocLength),
+        };
+    }
+    return {
+        search,
+        rebuildIndex,
+        getStats,
+    };
+}

package/dist/core/memory/index.js

@@ -8,3 +8,4 @@ export * from './spaced-repetition.js';
 export * from './hopfield-network.js';
 export * from './adaptive-rag.js';
 export { createContextFragmentationEngine } from './context-fragmentation.js';
+export { createHybridSearchEngine, createBM25Index, bm25Score, normalizeBM25Scores, DEFAULT_HYBRID_CONFIG } from './hybrid-search.js';

package/dist/index.js

@@ -9,3 +9,4 @@ export { createIdentityContinuityVerifier } from './core/identity/identity-conti
 export { createMCPProtocol } from './core/collaboration/mcp-protocol.js';
 export { createTruthTeller, formatTruthStatement } from './core/truth-teller.js';
 export { createActiveInferenceEngine, formatFreeEnergyMetrics, formatBeliefState } from './core/cognition/active-inference.js';
+export { createExpertModelsEngine } from './core/expert-models/index.js';

package/dist/version.js

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

package/package.json

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