mark-improving-agent 2.2.0

package/dist/core/consciousness/emotion-engine.js

@@ -0,0 +1,101 @@
+import { atomicWriteJSON, readJSON } from '../../storage/archive.js';
+const MAX_HISTORY = 50;
+const DECAY_RATE = 0.05;
+const DECAY_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
+function mapValenceToEmotion(valence) {
+    if (valence > 0) {
+        const positiveEmotions = ['joy', 'trust', 'anticipation'];
+        const idx = Math.abs(Math.floor(valence * positiveEmotions.length)) % positiveEmotions.length;
+        return positiveEmotions[idx];
+    }
+    else {
+        const negativeEmotions = ['sadness', 'anger', 'fear', 'disgust', 'surprise'];
+        const idx = Math.abs(Math.floor(valence * negativeEmotions.length)) % negativeEmotions.length;
+        return negativeEmotions[idx];
+    }
+}
+export function createEmotionEngine(dataDir) {
+    let currentEmotion = {
+        primary: 'trust',
+        intensity: 0.5,
+        valence: 0.0,
+        arousal: 0.5,
+        timestamp: Date.now(),
+    };
+    let history = [];
+    let lastStimulusTime = Date.now();
+    let isDirty = false;
+    const emotionsPath = `${dataDir}/emotions.json`;
+    function applyDecay(state) {
+        const elapsed = Date.now() - lastStimulusTime;
+        const decayIntervals = Math.floor(elapsed / DECAY_INTERVAL_MS);
+        const decayFactor = Math.pow(1 - DECAY_RATE, decayIntervals);
+        return {
+            ...state,
+            intensity: Math.max(0, state.intensity * decayFactor),
+        };
+    }
+    return {
+        getCurrentEmotion() {
+            const decayed = applyDecay(currentEmotion);
+            if (decayed.intensity !== currentEmotion.intensity) {
+                currentEmotion = decayed;
+            }
+            return { ...currentEmotion };
+        },
+        processStimulus(valence, arousal) {
+            const clampedValence = Math.max(-1, Math.min(1, valence));
+            const clampedArousal = Math.max(0, Math.min(1, arousal));
+            const primary = mapValenceToEmotion(clampedValence);
+            const intensity = Math.abs(clampedValence) * clampedArousal;
+            currentEmotion = {
+                primary,
+                intensity,
+                valence: clampedValence,
+                arousal: clampedArousal,
+                timestamp: Date.now(),
+            };
+            lastStimulusTime = Date.now();
+            if (history.length >= MAX_HISTORY) {
+                history.shift();
+            }
+            history.push({ ...currentEmotion });
+            isDirty = true;
+            return { ...currentEmotion };
+        },
+        recordEmotionalEvent(valence) {
+            this.processStimulus(valence, 0.5);
+        },
+        getEmotionalHistory() {
+            return [...history];
+        },
+        async persist() {
+            if (!isDirty)
+                return;
+            await atomicWriteJSON(emotionsPath, {
+                currentEmotion,
+                history,
+                lastStimulusTime,
+            });
+            isDirty = false;
+        },
+        async boot() {
+            const data = await readJSON(emotionsPath, {
+                currentEmotion: {
+                    primary: 'trust',
+                    intensity: 0.5,
+                    valence: 0.0,
+                    arousal: 0.5,
+                    timestamp: Date.now(),
+                },
+                history: [],
+                lastStimulusTime: Date.now(),
+            });
+            if (data) {
+                currentEmotion = data.currentEmotion ?? currentEmotion;
+                history = (data.history ?? []).slice(-MAX_HISTORY);
+                lastStimulusTime = data.lastStimulusTime ?? Date.now();
+            }
+        },
+    };
+}

package/dist/core/consciousness/flow-machine.js

@@ -0,0 +1,121 @@
+const INITIATING_DURATION_MS = 3000; // 3 seconds to enter flow
+const TIMEOUT_MS = 30000; // 30 seconds timeout
+export function createFlowMachine() {
+    let state = 'idle';
+    let flowStartTime = null;
+    let lastActivityTime = Date.now();
+    let initiatingStartTime = null;
+    return {
+        getState() {
+            // Check for timeout while in flow
+            if (state === 'in_flow' && Date.now() - lastActivityTime > TIMEOUT_MS) {
+                state = 'idle';
+                flowStartTime = null;
+            }
+            return state;
+        },
+        transition(event) {
+            lastActivityTime = Date.now();
+            switch (state) {
+                case 'idle':
+                    if (event === 'user_input') {
+                        state = 'initiating';
+                        initiatingStartTime = Date.now();
+                    }
+                    else if (event === 'break') {
+                        state = 'resting';
+                    }
+                    break;
+                case 'initiating':
+                    if (event === 'distraction') {
+                        state = 'idle';
+                        initiatingStartTime = null;
+                    }
+                    else if (event === 'completion') {
+                        state = 'completed';
+                        initiatingStartTime = null;
+                    }
+                    else if (event === 'timeout') {
+                        state = 'idle';
+                        initiatingStartTime = null;
+                    }
+                    else if (event === 'user_input') {
+                        // Still in initiating, check if we've been here long enough
+                        if (initiatingStartTime && Date.now() - initiatingStartTime >= INITIATING_DURATION_MS) {
+                            state = 'in_flow';
+                            flowStartTime = Date.now();
+                            initiatingStartTime = null;
+                        }
+                    }
+                    break;
+                case 'in_flow':
+                    if (event === 'distraction') {
+                        state = 'distracted';
+                    }
+                    else if (event === 'completion') {
+                        state = 'completed';
+                        flowStartTime = null;
+                    }
+                    else if (event === 'timeout') {
+                        state = 'idle';
+                        flowStartTime = null;
+                    }
+                    else if (event === 'break') {
+                        state = 'resting';
+                        flowStartTime = null;
+                    }
+                    break;
+                case 'completed':
+                    if (event === 'user_input' || event === 'break') {
+                        state = 'idle';
+                    }
+                    break;
+                case 'distracted':
+                    if (event === 'user_input') {
+                        state = 'initiating';
+                        initiatingStartTime = Date.now();
+                    }
+                    else if (event === 'break') {
+                        state = 'resting';
+                    }
+                    break;
+                case 'resting':
+                    if (event === 'user_input') {
+                        state = 'idle';
+                    }
+                    break;
+            }
+            return state;
+        },
+        getFocusScore() {
+            switch (state) {
+                case 'idle':
+                    return 0;
+                case 'initiating':
+                    return 0.3;
+                case 'in_flow':
+                    return 1.0;
+                case 'distracted':
+                    return 0.1;
+                case 'completed':
+                    return 0.5;
+                case 'resting':
+                    return 0.2;
+                default:
+                    return 0;
+            }
+        },
+        getFlowDuration() {
+            if (state === 'in_flow' && flowStartTime !== null) {
+                return Date.now() - flowStartTime;
+            }
+            return 0;
+        },
+        reset() {
+            state = 'idle';
+            flowStartTime = null;
+            lastActivityTime = Date.now();
+            initiatingStartTime = null;
+        },
+    };
+}

package/dist/core/consciousness/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './emotion-engine.js';
+export * from './flow-machine.js';
+export * from './personality.js';

package/dist/core/consciousness/personality.js

@@ -0,0 +1,103 @@
+import { atomicWriteJSON, readJSON } from '../../storage/archive.js';
+const TRAIT_ADJUSTMENT = 5;
+const MAX_TRAIT = 100;
+const MIN_TRAIT = 0;
+const EMOTIONAL_KEYWORDS = [
+    { pattern: /\b(joy|happy|delighted|pleased|excited|wonderful)\b/gi, trait: 'extraversion', direction: 1 },
+    { pattern: /\b(sad|gloomy|depressed|melancholy|sorrowful)\b/gi, trait: 'neuroticism', direction: 1 },
+    { pattern: /\b(angry|furious|irritated|annoyed|frustrated)\b/gi, trait: 'agreeableness', direction: -1 },
+    { pattern: /\b(fear|afraid|anxious|worried|nervous|scared)\b/gi, trait: 'neuroticism', direction: 1 },
+    { pattern: /\b(surprised|amazed|astonished|shocked|unexpected)\b/gi, trait: 'openness', direction: 1 },
+    { pattern: /\b(disgusted|revolted| repulsed|gross|sickened)\b/gi, trait: 'agreeableness', direction: -1 },
+    { pattern: /\b(anticipating|eager|hopeful|optimistic|expecting)\b/gi, trait: 'openness', direction: 1 },
+    { pattern: /\b(trusting|confident|reliable|dependable|faithful)\b/gi, trait: 'agreeableness', direction: 1 },
+    { pattern: /\b(curious|exploring|discovering|learning|investigating)\b/gi, trait: 'openness', direction: 1 },
+    { pattern: /\b(creative|imaginative|innovative|artistic|inventive)\b/gi, trait: 'openness', direction: 1 },
+    { pattern: /\b(organized|planned|structured|systematic|methodical)\b/gi, trait: 'conscientiousness', direction: 1 },
+    { pattern: /\b(spontaneous|flexible|adaptable|go_with_the_flow)\b/gi, trait: 'conscientiousness', direction: -1 },
+    { pattern: /\b(social|outgoing|gregarious|extroverted|sociable)\b/gi, trait: 'extraversion', direction: 1 },
+    { pattern: /\b(reserved|introverted|withdrawn|quiet|solitary)\b/gi, trait: 'extraversion', direction: -1 },
+    { pattern: /\b(compassionate|kind|caring|empathetic|supportive)\b/gi, trait: 'agreeableness', direction: 1 },
+    { pattern: /\b(competitive|ambitious|driven|determined|goal.oriented)\b/gi, trait: 'conscientiousness', direction: 1 },
+];
+export function createPersonalityEngine(dataDir, initial) {
+    let profile = {
+        openness: 50,
+        conscientiousness: 50,
+        extraversion: 50,
+        agreeableness: 50,
+        neuroticism: 50,
+        ...initial,
+    };
+    let isDirty = false;
+    const personalityPath = `${dataDir}/personality.json`;
+    return {
+        getProfile() {
+            return { ...profile };
+        },
+        adjustTraits(adjustments) {
+            if (adjustments.openness !== undefined) {
+                profile.openness = Math.max(MIN_TRAIT, Math.min(MAX_TRAIT, adjustments.openness));
+                isDirty = true;
+            }
+            if (adjustments.conscientiousness !== undefined) {
+                profile.conscientiousness = Math.max(MIN_TRAIT, Math.min(MAX_TRAIT, adjustments.conscientiousness));
+                isDirty = true;
+            }
+            if (adjustments.extraversion !== undefined) {
+                profile.extraversion = Math.max(MIN_TRAIT, Math.min(MAX_TRAIT, adjustments.extraversion));
+                isDirty = true;
+            }
+            if (adjustments.agreeableness !== undefined) {
+                profile.agreeableness = Math.max(MIN_TRAIT, Math.min(MAX_TRAIT, adjustments.agreeableness));
+                isDirty = true;
+            }
+            if (adjustments.neuroticism !== undefined) {
+                profile.neuroticism = Math.max(MIN_TRAIT, Math.min(MAX_TRAIT, adjustments.neuroticism));
+                isDirty = true;
+            }
+        },
+        respondToContext(input) {
+            const adjustments = {};
+            for (const keyword of EMOTIONAL_KEYWORDS) {
+                if (keyword.pattern.test(input)) {
+                    const trait = keyword.trait;
+                    const currentValue = profile[trait];
+                    const delta = TRAIT_ADJUSTMENT * keyword.direction;
+                    const newValue = Math.max(MIN_TRAIT, Math.min(MAX_TRAIT, currentValue + delta));
+                    if (newValue !== currentValue) {
+                        adjustments[trait] = newValue;
+                    }
+                }
+            }
+            if (Object.keys(adjustments).length > 0) {
+                this.adjustTraits(adjustments);
+            }
+            return adjustments;
+        },
+        async persist() {
+            if (!isDirty)
+                return;
+            await atomicWriteJSON(personalityPath, profile);
+            isDirty = false;
+        },
+        async boot() {
+            const loaded = await readJSON(personalityPath, {
+                openness: 50,
+                conscientiousness: 50,
+                extraversion: 50,
+                agreeableness: 50,
+                neuroticism: 50,
+            });
+            if (loaded) {
+                profile = {
+                    openness: loaded.openness ?? 50,
+                    conscientiousness: loaded.conscientiousness ?? 50,
+                    extraversion: loaded.extraversion ?? 50,
+                    agreeableness: loaded.agreeableness ?? 50,
+                    neuroticism: loaded.neuroticism ?? 50,
+                };
+            }
+        },
+    };
+}

package/dist/core/consciousness/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/emotional-protocol.js

@@ -0,0 +1,54 @@
+/**
+ * Emotional Protocol - "容器是漏的" (Container is Leaking)
+ *
+ * Core principle: when facing emotional content, acknowledge first, analyze second.
+ * From learnings: "容器是漏的 - 只分析不接住感受"
+ */
+const EMOTIONAL_KEYWORDS = [
+    '害怕', '恐惧', '无奈', '痛苦', '伤心', '失望', '沮丧',
+    '焦虑', '不安', '累', '压力', '委屈',
+];
+export function createEmotionalProtocol() {
+    function detectEmotion(input) {
+        const lowerInput = input.toLowerCase();
+        return EMOTIONAL_KEYWORDS.some(keyword => lowerInput.includes(keyword));
+    }
+    function acknowledge(input) {
+        const lowerInput = input.toLowerCase();
+        // Find which emotional keywords are present
+        const detectedEmotions = EMOTIONAL_KEYWORDS.filter(keyword => lowerInput.includes(keyword));
+        if (detectedEmotions.length === 0) {
+            return '';
+        }
+        // Generate acknowledgment based on detected emotions
+        const primaryEmotion = detectedEmotions[0];
+        const acknowledgments = {
+            '害怕': '我听到了，你感到害怕。',
+            '恐惧': '我听到了，你感到恐惧。',
+            '无奈': '我听到了，你感到无奈。',
+            '痛苦': '我听到了，你感到痛苦。',
+            '伤心': '我听到了，你感到伤心。',
+            '失望': '我听到了，你感到失望。',
+            '沮丧': '我听到了，你感到沮丧。',
+            '焦虑': '我听到了，你感到焦虑。',
+            '不安': '我听到了，你感到不安。',
+            '累': '我听到了，你感到累了。',
+            '压力': '我听到了，你感到压力很大。',
+            '委屈': '我听到了，你感到委屈。',
+        };
+        return acknowledgments[primaryEmotion] || `我听到了，你感到${primaryEmotion}。`;
+    }
+    function process(input) {
+        const hasEmotion = detectEmotion(input);
+        return {
+            hasEmotion,
+            acknowledgment: hasEmotion ? acknowledge(input) : null,
+            canAnalyze: true, // Always allow analysis to proceed
+        };
+    }
+    return {
+        detectEmotion,
+        acknowledge,
+        process,
+    };
+}

package/dist/core/evolution/engine.js

@@ -0,0 +1,194 @@
+import { randomUUID } from 'crypto';
+import { writeFileSync, existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { createGoalEngine } from './goal-engine.js';
+import { createMetaLearner } from './meta-learning.js';
+import { createReflector } from './reflection.js';
+import { createSelfHealer } from './self-healer.js';
+import { createReflexion } from '../identity/reflexion.js';
+import { createSelfVerifier } from '../identity/self-verifier.js';
+function atomicWrite(filePath, data) {
+    const tmp = filePath + '.tmp.' + randomUUID().slice(0, 8);
+    writeFileSync(tmp, data, 'utf-8');
+    const fs = require('fs');
+    fs.renameSync(tmp, filePath);
+}
+function ensureDir(dir) {
+    const fs = require('fs');
+    if (!existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function createInitialMetrics() {
+    return {
+        autonomy: 50,
+        introspection: 50,
+        growth: 50,
+        authenticity: 50,
+        wisdom: 50,
+        compassion: 50,
+    };
+}
+function emitPhase(phase, data) {
+    // Internal phase tracking - removed invalid process.emit calls
+}
+export function createEvolutionEngine(dataDir) {
+    let goalEngine;
+    let metaLearner;
+    let reflector;
+    let selfHealer;
+    let reflexion;
+    let selfVerifier;
+    let metrics = createInitialMetrics();
+    let cycles = 0;
+    let learnings = 0;
+    let errorsCorrected = 0;
+    let booted = false;
+    const stateFile = join(dataDir, 'evolution-state.json');
+    async function persist() {
+        if (!booted)
+            return;
+        try {
+            ensureDir(dirname(stateFile));
+            const state = { metrics, cycles, learnings, errorsCorrected };
+            atomicWrite(stateFile, JSON.stringify(state, null, 2));
+            await goalEngine.persist();
+            await metaLearner.persist();
+        }
+        catch {
+            // Persistence failed, continue with in-memory state
+        }
+    }
+    async function loadState() {
+        if (existsSync(stateFile)) {
+            try {
+                const raw = readFileSync(stateFile, 'utf-8');
+                const state = JSON.parse(raw);
+                if (state.metrics)
+                    metrics = { ...createInitialMetrics(), ...state.metrics };
+                if (typeof state.cycles === 'number')
+                    cycles = state.cycles;
+                if (typeof state.learnings === 'number')
+                    learnings = state.learnings;
+                if (typeof state.errorsCorrected === 'number')
+                    errorsCorrected = state.errorsCorrected;
+            }
+            catch {
+                metrics = createInitialMetrics();
+            }
+        }
+    }
+    async function boot() {
+        goalEngine = createGoalEngine(dataDir);
+        metaLearner = createMetaLearner(dataDir);
+        reflector = createReflector(dataDir);
+        selfHealer = createSelfHealer();
+        reflexion = createReflexion(dataDir);
+        selfVerifier = createSelfVerifier(dataDir);
+        await goalEngine.boot();
+        await metaLearner.boot();
+        await reflexion.boot();
+        await loadState();
+        booted = true;
+    }
+    async function evolve(input, context) {
+        emitPhase('goal', { input });
+        const goals = goalEngine.generateGoals(input);
+        const plan = goals.map(g => `Goal: ${g.description}`);
+        emitPhase('learn', { goals });
+        const { strategy } = metaLearner.selectStrategy(input);
+        const learning = await metaLearner.learn(input, strategy);
+        learnings++;
+        emitPhase('reflect', { learning });
+        const reflection = reflector.reflect(input, learning, context);
+        emitPhase('improve', { reflection });
+        cycles++;
+        metrics.introspection = Math.min(100, metrics.introspection + 1);
+        metrics.growth = Math.min(100, metrics.growth + 0.5);
+        await persist();
+        const outcomes = reflection.insights.map(i => i.description);
+        const cycle = {
+            goals,
+            plan,
+            outcomes,
+            metrics: { ...metrics },
+            timestamp: Date.now(),
+        };
+        return cycle;
+    }
+    async function learn(input) {
+        const { strategy } = metaLearner.selectStrategy(input);
+        const result = await metaLearner.learn(input, strategy);
+        metaLearner.recordOutcome(strategy, result.quality !== 'low');
+        learnings++;
+        await persist();
+    }
+    async function reflect(input, learning) {
+        const result = reflector.reflect(input, learning);
+        if (result.quality === 'needs_improvement') {
+            metrics.introspection = Math.max(0, metrics.introspection - 2);
+        }
+        else {
+            metrics.introspection = Math.min(100, metrics.introspection + 1);
+        }
+        await persist();
+        return result;
+    }
+    function heal(error) {
+        const result = selfHealer.heal(error);
+        if (!result.ok) {
+            errorsCorrected++;
+            selfHealer.recordOutcome(result.strategy, false);
+        }
+        else {
+            selfHealer.recordOutcome(result.strategy, true);
+        }
+        return result;
+    }
+    function getGrowthMetrics() {
+        return { ...metrics };
+    }
+    function recordAutonomy(_action) {
+        metrics.autonomy = Math.min(100, metrics.autonomy + 1);
+    }
+    function recordCompassion(_depth) {
+        metrics.compassion = Math.min(100, metrics.compassion + 1);
+    }
+    function getStats() {
+        return { cycles, learnings, errorsCorrected };
+    }
+    function recordReflexion(task, outcome, error) {
+        reflexion.reflect({ task, outcome, error });
+    }
+    function verify(reasoning, conclusion) {
+        const result = selfVerifier.verify(reasoning, conclusion);
+        selfVerifier.recordVerification(result);
+        return { verified: result.passed, confidence: result.confidence, issues: result.issues };
+    }
+    function getReflexionStats() {
+        const stats = reflexion.getStats();
+        return {
+            totalReflexions: stats.totalReflexions,
+            successRate: stats.totalReflexions > 0 ? stats.successes / stats.totalReflexions : 0,
+            recentFailures: stats.recentPatterns,
+        };
+    }
+    async function shutdown() {
+        await persist();
+    }
+    return {
+        boot,
+        evolve,
+        learn,
+        reflect,
+        heal,
+        recordReflexion,
+        verify,
+        getReflexionStats,
+        getGrowthMetrics,
+        recordAutonomy,
+        recordCompassion,
+        getStats,
+        shutdown,
+    };
+}