mark-improving-agent 2.2.5 → 2.2.6

package/VERSION

@@ -1 +1 @@
-2.2.5
+2.2.6

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/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.5';
+export const VERSION = '2.2.6';

package/package.json

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