mark-improving-agent 2.2.0

package/dist/core/healing-rl.js

@@ -0,0 +1,266 @@
+/**
+ * HealingMemoryRL: Reinforcement Learning for Error Recovery
+ *
+ * Closed-loop system: record → learn → rankedPatches
+ * Based on RL principles from v0.13.163 references.
+ *
+ * Q-table learning with epsilon-greedy strategy selection.
+ */
+import { atomicWriteJSON, readJSON, ensureDir } from '../storage/archive.js';
+const RL_STATE_FILE = 'healing-rl-state.json';
+const MAX_RECENT_FAILURES = 20;
+function getBackoffMs(strategy) {
+    switch (strategy) {
+        case 'retry': return 1000;
+        case 'fallback': return 5000;
+        case 'skip': return 0;
+        case 'abort': return 0;
+        case 'decompose': return 2000;
+        case 'simplify': return 1000;
+        default: return 1000;
+    }
+}
+function allStrategies() {
+    return ['retry', 'fallback', 'skip', 'abort', 'decompose', 'simplify'];
+}
+function extractPattern(error) {
+    const msg = error.message ?? error.error ?? String(error);
+    const msgStr = typeof msg === 'string' ? msg : JSON.stringify(msg);
+    // Extract key patterns from error message
+    const patterns = [];
+    if (msgStr.toLowerCase().includes('null') || msgStr.toLowerCase().includes('undefined')) {
+        patterns.push('null-reference');
+    }
+    if (msgStr.toLowerCase().includes('timeout')) {
+        patterns.push('async-timeout');
+    }
+    if (msgStr.toLowerCase().includes('network') || msgStr.toLowerCase().includes('fetch')) {
+        patterns.push('network-error');
+    }
+    if (msgStr.toLowerCase().includes('type')) {
+        patterns.push('type-error');
+    }
+    if (msgStr.toLowerCase().includes('syntax') || msgStr.toLowerCase().includes('parse')) {
+        patterns.push('syntax-error');
+    }
+    if (msgStr.toLowerCase().includes('permission') || msgStr.toLowerCase().includes('denied')) {
+        patterns.push('permission-error');
+    }
+    if (msgStr.toLowerCase().includes('not found') || msgStr.toLowerCase().includes('404')) {
+        patterns.push('not-found');
+    }
+    if (msgStr.toLowerCase().includes('validation')) {
+        patterns.push('validation-error');
+    }
+    if (msgStr.toLowerCase().includes('logic') || msgStr.toLowerCase().includes('assertion')) {
+        patterns.push('logic-error');
+    }
+    if (msgStr.toLowerCase().includes('memory') || msgStr.toLowerCase().includes('heap')) {
+        patterns.push('memory-error');
+    }
+    return patterns.length > 0 ? patterns.join('+') : 'generic-error';
+}
+function generateHints(pattern, strategy) {
+    const hints = [];
+    switch (strategy) {
+        case 'retry':
+            hints.push('Retry the operation with exponential backoff');
+            hints.push('Check if state was modified during failure');
+            break;
+        case 'fallback':
+            hints.push('Use alternative approach or cached data');
+            hints.push('Fallback to degraded but functional mode');
+            break;
+        case 'skip':
+            hints.push('Skip non-critical step and continue');
+            hints.push('Mark as optional and proceed');
+            break;
+        case 'abort':
+            hints.push('Stop operation and report error');
+            hints.push('Clean up partial state before aborting');
+            break;
+        case 'decompose':
+            hints.push('Break complex operation into smaller steps');
+            hints.push('Handle each step independently with error recovery');
+            break;
+        case 'simplify':
+            hints.push('Reduce complexity of the operation');
+            hints.push('Use simpler data structures or algorithms');
+            break;
+    }
+    // Add pattern-specific hints
+    if (pattern.includes('null-reference')) {
+        hints.push('Add null/undefined guards before property access');
+        hints.push('Validate object initialization');
+    }
+    if (pattern.includes('timeout')) {
+        hints.push('Increase timeout threshold');
+        hints.push('Implement request batching for large operations');
+    }
+    if (pattern.includes('network')) {
+        hints.push('Check network connectivity and endpoints');
+        hints.push('Implement retry with exponential backoff');
+    }
+    return hints.slice(0, 3);
+}
+export function createHealingMemoryRL(dataDir) {
+    const state = {
+        qTable: new Map(),
+        recentFailures: [],
+        totalRepairs: 0,
+        lastUpdated: Date.now(),
+    };
+    const statePath = `${dataDir}/identity/${RL_STATE_FILE}`;
+    function getQ(pattern, strategy) {
+        const patternMap = state.qTable.get(pattern);
+        if (!patternMap)
+            return 0.5; // Default Q value
+        return patternMap.get(strategy) ?? 0.5;
+    }
+    function setQ(pattern, strategy, value) {
+        if (!state.qTable.has(pattern)) {
+            state.qTable.set(pattern, new Map());
+        }
+        // Clamp Q values to [0, 1]
+        const clamped = Math.max(0, Math.min(1, value));
+        state.qTable.get(pattern).set(strategy, clamped);
+    }
+    function updateQ(pattern, strategy, reward) {
+        const currentQ = getQ(pattern, strategy);
+        const learningRate = 0.1;
+        // Q[pattern][strategy] += alpha * (reward - Q[pattern][strategy])
+        const newQ = currentQ + learningRate * (reward - currentQ);
+        setQ(pattern, strategy, newQ);
+    }
+    function selectStrategy(pattern) {
+        const epsilon = 0.1; // 10% random exploration
+        if (Math.random() < epsilon) {
+            // Random exploration
+            const strategies = allStrategies();
+            const randomIdx = Math.floor(Math.random() * strategies.length);
+            const randomStrategy = strategies[randomIdx];
+            return { strategy: randomStrategy, qValue: getQ(pattern, randomStrategy) };
+        }
+        // Exploitation: pick best strategy
+        let bestStrategy = 'retry';
+        let bestQ = -Infinity;
+        for (const strategy of allStrategies()) {
+            const q = getQ(pattern, strategy);
+            if (q > bestQ) {
+                bestQ = q;
+                bestStrategy = strategy;
+            }
+        }
+        return { strategy: bestStrategy, qValue: bestQ };
+    }
+    return {
+        record(pattern, strategy, outcome) {
+            const reward = outcome === 'success' ? 1.0 : 0.0;
+            updateQ(pattern, strategy, reward);
+            state.recentFailures.push({
+                pattern,
+                strategy,
+                outcome,
+                timestamp: Date.now(),
+            });
+            if (state.recentFailures.length > MAX_RECENT_FAILURES) {
+                state.recentFailures = state.recentFailures.slice(-MAX_RECENT_FAILURES);
+            }
+            state.totalRepairs++;
+            state.lastUpdated = Date.now();
+        },
+        learn(input) {
+            // Analyze input string, extract key patterns, generate ranked hint patches
+            const patterns = [];
+            const input_lower = input.toLowerCase();
+            // Extract pattern keywords
+            const keywords = [
+                'null', 'undefined', 'timeout', 'network', 'fetch',
+                'type', 'syntax', 'parse', 'permission', 'denied',
+                'not found', '404', 'validation', 'logic', 'assertion',
+                'memory', 'heap', 'deadlock', 'race'
+            ];
+            for (const kw of keywords) {
+                if (input_lower.includes(kw)) {
+                    const pattern = kw === 'null' || kw === 'undefined' ? 'null-reference' :
+                        kw === 'not found' ? 'not-found' :
+                            kw === 'permission' || kw === 'denied' ? 'permission-error' :
+                                `${kw}-error`;
+                    patterns.push(pattern);
+                }
+            }
+            if (patterns.length === 0) {
+                patterns.push('generic-error');
+            }
+            // Generate ranked hints based on best strategies for each pattern
+            const hints = [];
+            const seen = new Set();
+            for (const pattern of patterns) {
+                const { strategy, qValue } = selectStrategy(pattern);
+                const strategyHints = generateHints(pattern, strategy);
+                for (const hint of strategyHints) {
+                    if (!seen.has(hint)) {
+                        hints.push(`[${pattern}] Q=${qValue.toFixed(2)}: ${hint}`);
+                        seen.add(hint);
+                    }
+                }
+            }
+            return hints.slice(0, 3);
+        },
+        heal(error) {
+            const pattern = extractPattern(error);
+            const { strategy, qValue } = selectStrategy(pattern);
+            const hints = generateHints(pattern, strategy);
+            const backoffMs = getBackoffMs(strategy);
+            return {
+                ok: false,
+                strategy,
+                hints,
+                backoffMs,
+                attempt: 1,
+                qValue,
+            };
+        },
+        getStats() {
+            const recent = state.recentFailures.slice(-10);
+            const successes = recent.filter(f => f.outcome === 'success').length;
+            const successRate = recent.length > 0 ? successes / recent.length : 0;
+            return {
+                totalRepairs: state.totalRepairs,
+                successRate,
+                recentPatterns: recent.slice(-10).map(f => f.pattern),
+            };
+        },
+        async persist() {
+            // Serialize Q-table as plain object for JSON
+            const qTableObj = {};
+            for (const [pattern, strategyMap] of state.qTable) {
+                qTableObj[pattern] = Object.fromEntries(strategyMap);
+            }
+            await atomicWriteJSON(statePath, {
+                qTable: qTableObj,
+                recentFailures: state.recentFailures,
+                totalRepairs: state.totalRepairs,
+                lastUpdated: state.lastUpdated,
+            });
+        },
+        async boot() {
+            await ensureDir(`${dataDir}/identity`);
+            const loaded = await readJSON(statePath, {});
+            if (loaded?.qTable) {
+                for (const [pattern, strategyMap] of Object.entries(loaded.qTable)) {
+                    state.qTable.set(pattern, new Map(Object.entries(strategyMap)));
+                }
+            }
+            if (loaded?.recentFailures && Array.isArray(loaded.recentFailures)) {
+                state.recentFailures = loaded.recentFailures.slice(-MAX_RECENT_FAILURES);
+            }
+            if (typeof loaded?.totalRepairs === 'number') {
+                state.totalRepairs = loaded.totalRepairs;
+            }
+            if (loaded?.lastUpdated) {
+                state.lastUpdated = loaded.lastUpdated;
+            }
+        },
+    };
+}

package/dist/core/heartbeat.js

@@ -0,0 +1,408 @@
+/**
+ * HeartFlow - Self-evolving AI agent identity framework
+ *
+ * The main HeartFlow class orchestrates all subsystems:
+ * - 3-tier memory (core, learned, ephemeral, archived)
+ * - Self-evolution engine with goal management
+ * - Identity self-model with drift detection
+ * - Consciousness (emotion, flow, personality)
+ * - Skill DAG execution
+ * - Task graph management
+ * - Checkpointing for persistence
+ */
+import { VERSION } from '../version.js';
+import { createLogger } from '../utils/logger.js';
+import { loadConfig } from '../utils/config.js';
+import { ensureDir } from '../storage/archive.js';
+import { createCheckpointManager } from '../storage/checkpoint.js';
+import { events } from '../event/bus.js';
+// Memory subsystem
+import { createMemoryStore } from './memory/store.js';
+import { DEFAULT_EMBEDDER } from './memory/embedder.js';
+import { createArchiveStore } from './memory/archive-store.js';
+import { createDreamEngine } from './memory/dream-consolidation.js';
+import { createSpacedRepetition } from './memory/spaced-repetition.js';
+// Evolution subsystem
+import { createGoalEngine } from './evolution/goal-engine.js';
+import { createMetaLearner } from './evolution/meta-learning.js';
+import { createEvolutionEngine } from './evolution/engine.js';
+// Identity subsystem
+import { createSelfModelManager } from './identity/self-model.js';
+import { createReflexion } from './identity/reflexion.js';
+import { createSelfVerifier } from './identity/self-verifier.js';
+// Healing RL subsystem
+import { createHealingMemoryRL } from './healing-rl.js';
+import { createRollbackManager } from './rollback-manager.js';
+// Lesson Bank subsystem
+import { createLessonBank } from './lesson-bank.js';
+// Emotional Protocol subsystem
+import { createEmotionalProtocol } from './emotional-protocol.js';
+// Truthfulness subsystem
+import { createTruthfulnessChecker } from './truthfulness.js';
+// Consciousness subsystem
+import { createEmotionEngine } from './consciousness/emotion-engine.js';
+import { createFlowMachine } from './consciousness/flow-machine.js';
+import { createPersonalityEngine } from './consciousness/personality.js';
+// Skills subsystem
+import { createSkillRegistry } from '../skills/registry.js';
+import { createSkillDAG } from '../skills/dag.js';
+// Agent subsystem
+import { createTaskGraph } from '../agent/task-graph.js';
+import { createContextManager } from '../agent/context.js';
+function createHeartFlowInstance(deps, config, logger) {
+    const state = {
+        booted: false,
+        shutdown: false,
+        startTime: Date.now(),
+        evolutionCycles: 0,
+    };
+    // -------------------- Memory --------------------
+    function store(content, importance = 0.5, tags = []) {
+        const entry = deps.memoryStore.store(content, importance, tags, 'learned', 'system');
+        events.emit('memory:store', { id: entry.id, content: entry.content, importance: entry.importance, tier: entry.tier });
+        return entry;
+    }
+    function recall(query) {
+        const results = [];
+        // Use search with the query
+        const searchResults = deps.memoryStore.search(query.query, query.limit ?? 20);
+        for (const result of searchResults) {
+            // Apply tier filter
+            if (query.tier && result.entry.tier !== query.tier)
+                continue;
+            if (query.minImportance !== undefined && result.entry.importance < query.minImportance)
+                continue;
+            if (query.tags && query.tags.length > 0 && !query.tags.some(t => result.entry.tags.includes(t)))
+                continue;
+            results.push(result);
+        }
+        return results;
+    }
+    function recallById(id) {
+        return deps.memoryStore.recall(id);
+    }
+    function search(query, limit = 20) {
+        return deps.memoryStore.search(query, limit);
+    }
+    async function dream() {
+        return await deps.dreamEngine.dream([]);
+    }
+    function getDreamStats() {
+        return deps.dreamEngine.getDreamStats();
+    }
+    function getMemoryHealth() {
+        return deps.dreamEngine.getMemoryHealth();
+    }
+    // -------------------- Evolution --------------------
+    async function evolve(input) {
+        const cycle = await deps.evolutionEngine.evolve(input);
+        state.evolutionCycles++;
+        // After learning, call reflexion if outcome was failure
+        // The evolution engine stores outcome in cycle.outcomes
+        if (cycle.outcomes && cycle.outcomes.length > 0) {
+            const lastOutcome = cycle.outcomes[cycle.outcomes.length - 1];
+            if (lastOutcome.toLowerCase().includes('fail') || lastOutcome.toLowerCase().includes('error')) {
+                deps.reflexion.reflect({ task: input, outcome: 'failure', error: lastOutcome });
+            }
+        }
+        events.emit('evolution:cycle', cycle);
+        return cycle;
+    }
+    function getGrowthMetrics() {
+        return deps.selfModel.getSelfModel().growthMetrics;
+    }
+    // -------------------- Identity --------------------
+    function getSelfModel() {
+        return deps.selfModel.getSelfModel();
+    }
+    function detectDrift() {
+        return deps.selfModel.detectDrift();
+    }
+    function getIdentityCore() {
+        return deps.selfModel.getIdentityCore();
+    }
+    function recordInstall() {
+        deps.selfModel.recordInstall();
+    }
+    // -------------------- Reflexion & Self-Verification --------------------
+    function reflect(task, outcome, error) {
+        return deps.reflexion.reflect({ task, outcome, error });
+    }
+    function verify(reasoning, conclusion) {
+        const result = deps.selfVerifier.verify(reasoning, conclusion);
+        deps.selfVerifier.recordVerification(result);
+        return result;
+    }
+    function getReflexionStats() {
+        return deps.reflexion.getStats();
+    }
+    // -------------------- Healing RL --------------------
+    function heal(error) {
+        return deps.healingRL.heal(error);
+    }
+    // -------------------- Consciousness --------------------
+    function getConsciousnessState() {
+        const emotion = deps.emotionEngine.getCurrentEmotion();
+        const flow = deps.flowMachine.getState();
+        return {
+            emotion,
+            flow,
+            focus: deps.flowMachine.getFocusScore(),
+            energy: 0.5, // Placeholder
+            lastActivity: Date.now(),
+        };
+    }
+    function getPersonality() {
+        return deps.selfModel.getSelfModel().personality;
+    }
+    // -------------------- Lesson Bank --------------------
+    function checkLesson(input) {
+        return deps.lessonBank.checkPattern(input);
+    }
+    function recordLesson(lesson) {
+        return deps.lessonBank.addLesson(lesson);
+    }
+    function getLessonsBySkill(skill) {
+        return deps.lessonBank.getBySkill(skill);
+    }
+    function getTopLessons(limit) {
+        return deps.lessonBank.getTopLessons(limit);
+    }
+    // -------------------- Emotional Protocol --------------------
+    function processWithEmotion(input) {
+        return deps.emotionalProtocol.process(input);
+    }
+    // -------------------- Truthfulness --------------------
+    function checkTruthfulness(statement) {
+        return deps.truthfulnessChecker.checkStatement(statement);
+    }
+    function annotateStatement(statement, confidence) {
+        return deps.truthfulnessChecker.annotateConfidence(statement, confidence);
+    }
+    // -------------------- Skills --------------------
+    function registerSkill(skill) {
+        deps.skillRegistry.register(skill);
+        try {
+            deps.skillDAG.addSkill(skill);
+        }
+        catch {
+            deps.skillRegistry.unregister(skill.id);
+            throw new Error(`Failed to add skill ${skill.id} to DAG: cycle detected`);
+        }
+        events.emit('skill:registered', { id: skill.id, name: skill.name });
+    }
+    function listSkills() {
+        return deps.skillRegistry.list();
+    }
+    // -------------------- Checkpointing --------------------
+    async function checkpoint(label) {
+        const id = await deps.checkpointManager.save(label);
+        events.emit('checkpoint:created', { id, label });
+        return id;
+    }
+    async function restore(id) {
+        // Note: Full restore would reload all subsystem state
+        // This is a simplified version
+        const loaded = await deps.checkpointManager.load(id);
+        if (!loaded) {
+            throw new Error(`Checkpoint ${id} not found`);
+        }
+        events.emit('checkpoint:restored', { id });
+    }
+    function getRollbackStats() {
+        return deps.rollbackManager.getStats();
+    }
+    // -------------------- Stats --------------------
+    function getStats() {
+        const uptime = Date.now() - state.startTime;
+        const latestCheckpoint = deps.checkpointManager.getLatest();
+        return {
+            version: VERSION,
+            uptime,
+            memory: {
+                core: 0, // Placeholder - would track actual counts
+                learned: 0,
+                ephemeral: 0,
+                archived: 0,
+            },
+            evolution: {
+                cycles: state.evolutionCycles,
+                metrics: getGrowthMetrics(),
+            },
+            consciousness: getConsciousnessState(),
+            checkpoint: {
+                count: 0,
+                latest: null,
+            },
+        };
+    }
+    // -------------------- Boot / Shutdown --------------------
+    async function boot() {
+        if (state.booted) {
+            logger.warn('mark-improving-agent already booted');
+            return;
+        }
+        logger.info('Booting mark-improving-agent...');
+        // Ensure data directories exist
+        await ensureDir(config.dataDir);
+        await ensureDir(`${config.dataDir}/checkpoints`);
+        await ensureDir(`${config.dataDir}/memory`);
+        await ensureDir(`${config.dataDir}/archive`);
+        // Boot memory store first
+        await deps.memoryStore.boot();
+        logger.debug('Memory store booted');
+        // Boot subsystems in dependency order
+        await deps.selfModel.boot();
+        logger.debug('Self-model booted');
+        await deps.emotionEngine.boot();
+        logger.debug('Emotion engine booted');
+        await deps.personalityEngine.boot();
+        logger.debug('Personality engine booted');
+        // Boot goal engine
+        deps.goalEngine.persist().catch(() => { }); // Ensure goals are loaded
+        logger.debug('Goal engine booted');
+        // Boot meta learner
+        deps.metaLearner.boot().catch(() => { });
+        logger.debug('Meta-learner booted');
+        // Boot evolution engine
+        await deps.evolutionEngine.boot();
+        logger.debug('Evolution engine booted');
+        // Boot new identity subsystems
+        await deps.reflexion.boot();
+        logger.debug('Reflexion booted');
+        await deps.selfVerifier.boot();
+        logger.debug('Self-verifier booted');
+        await deps.healingRL.boot();
+        logger.debug('Healing RL booted');
+        await deps.lessonBank.boot();
+        logger.debug('Lesson bank booted');
+        // truthfulnessChecker boots itself automatically
+        logger.debug('Truthfulness checker ready');
+        // Boot archive store
+        // Note: archiveStore.boot() if it exists
+        state.booted = true;
+        events.emit('system:booted', {});
+        logger.info('mark-improving-agent booted successfully');
+    }
+    async function shutdown() {
+        if (state.shutdown) {
+            return;
+        }
+        logger.info('Shutting down mark-improving-agent...');
+        state.shutdown = true;
+        // Persist all subsystem state
+        await deps.selfModel.persist();
+        await deps.emotionEngine.persist();
+        await deps.personalityEngine.persist();
+        await deps.selfVerifier.persist();
+        await deps.healingRL.persist();
+        await deps.lessonBank.persist();
+        events.emit('system:shutdown', {});
+        logger.info('mark-improving-agent shutdown complete');
+    }
+    return {
+        boot,
+        shutdown,
+        store,
+        recall,
+        recallById,
+        search,
+        evolve,
+        getGrowthMetrics,
+        getSelfModel,
+        detectDrift,
+        getIdentityCore,
+        recordInstall,
+        reflect,
+        verify,
+        getReflexionStats,
+        heal,
+        getConsciousnessState,
+        getPersonality,
+        registerSkill,
+        listSkills,
+        checkpoint,
+        restore,
+        getRollbackStats,
+        getStats,
+        dream,
+        getDreamStats,
+        getMemoryHealth,
+        checkLesson,
+        recordLesson,
+        getLessonsBySkill,
+        getTopLessons,
+        processWithEmotion,
+        checkTruthfulness,
+        annotateStatement,
+    };
+}
+export async function createHeartFlow(options) {
+    const config = loadConfig();
+    // Override with options if provided
+    if (options?.dataDir) {
+        config.dataDir = options.dataDir;
+    }
+    if (options?.logLevel) {
+        config.logLevel = options.logLevel;
+    }
+    const logger = createLogger('mark-improving-agent', config.logLevel);
+    // Validate config
+    if (!config.dataDir) {
+        throw new Error('dataDir is required in mark-improving-agent config');
+    }
+    // Ensure data directory exists
+    await ensureDir(config.dataDir);
+    // Create all subsystem instances
+    const memoryStore = createMemoryStore({ dataDir: `${config.dataDir}/memory`, embedder: DEFAULT_EMBEDDER });
+    const archiveStore = createArchiveStore(`${config.dataDir}/archive`);
+    const dreamEngine = createDreamEngine(config.dataDir);
+    const spacedRepetition = createSpacedRepetition(config.dataDir);
+    const goalEngine = createGoalEngine(config.dataDir);
+    const metaLearner = createMetaLearner(config.dataDir);
+    const evolutionEngine = createEvolutionEngine(config.dataDir);
+    const selfModel = createSelfModelManager(config.dataDir);
+    const emotionEngine = createEmotionEngine(config.dataDir);
+    const flowMachine = createFlowMachine();
+    const personalityEngine = createPersonalityEngine(config.dataDir);
+    const skillRegistry = createSkillRegistry();
+    const skillDAG = createSkillDAG();
+    const taskGraph = createTaskGraph();
+    const contextManager = createContextManager(config.agent.maxContext);
+    const checkpointManager = createCheckpointManager(config.dataDir, config.checkpoint.maxKeep);
+    const rollbackManager = createRollbackManager(config.dataDir);
+    // New identity subsystems
+    const reflexion = createReflexion(config.dataDir);
+    const selfVerifier = createSelfVerifier(config.dataDir);
+    const healingRL = createHealingMemoryRL(config.dataDir);
+    const lessonBank = createLessonBank(config.dataDir);
+    const emotionalProtocol = createEmotionalProtocol();
+    const truthfulnessChecker = createTruthfulnessChecker(config.dataDir);
+    const deps = {
+        memoryStore,
+        archiveStore,
+        dreamEngine,
+        spacedRepetition,
+        goalEngine,
+        metaLearner,
+        evolutionEngine,
+        selfModel,
+        emotionEngine,
+        flowMachine,
+        personalityEngine,
+        skillRegistry,
+        skillDAG,
+        taskGraph,
+        contextManager,
+        checkpointManager,
+        rollbackManager,
+        reflexion,
+        selfVerifier,
+        healingRL,
+        lessonBank,
+        emotionalProtocol,
+        truthfulnessChecker,
+    };
+    return createHeartFlowInstance(deps, config, logger);
+}
+export default createHeartFlow;

package/dist/core/identity/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './self-model.js';
+export { createReflexion } from './reflexion.js';