genesis-ai-cli 7.4.5

package/dist/src/active-inference/demo-autonomous-loop.js

@@ -0,0 +1,338 @@
+"use strict";
+/**
+ * Demo: Autonomous Loop with Value Integration
+ *
+ * Runs the autonomous inference loop with value-augmented policy selection.
+ *
+ * Run: node dist/src/active-inference/demo-autonomous-loop.js
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const value_integration_js_1 = require("./value-integration.js");
+const index_js_1 = require("./index.js");
+const types_js_1 = require("./types.js");
+// ============================================================================
+// Simulated Environment
+// ============================================================================
+class SimulatedEnvironment {
+    energy = 0.5;
+    phi = 0.5;
+    taskProgress = 0;
+    cycle = 0;
+    state = 'idle';
+    getKernelState() {
+        return {
+            energy: this.energy,
+            state: this.state,
+            taskStatus: this.taskProgress >= 1 ? 'completed' :
+                this.taskProgress > 0 ? 'running' : 'pending',
+        };
+    }
+    getPhiState() {
+        return {
+            phi: this.phi,
+            state: this.phi > 0.6 ? 'aware' : this.phi > 0.3 ? 'drowsy' : 'dormant',
+        };
+    }
+    applyAction(action) {
+        this.cycle++;
+        // Natural decay
+        this.energy = Math.max(0, this.energy - 0.05);
+        this.phi = Math.max(0, this.phi - 0.02);
+        // Action effects
+        switch (action) {
+            case 'recharge':
+                this.energy = Math.min(1, this.energy + 0.3);
+                this.state = 'idle';
+                break;
+            case 'sense.mcp':
+                this.phi = Math.min(1, this.phi + 0.15);
+                this.state = 'sensing';
+                break;
+            case 'recall.memory':
+                this.phi = Math.min(1, this.phi + 0.1);
+                break;
+            case 'plan.goals':
+                this.state = 'thinking';
+                if (this.energy > 0.3) {
+                    this.taskProgress = Math.min(1, this.taskProgress + 0.15);
+                }
+                break;
+            case 'execute.task':
+                this.state = 'acting';
+                if (this.energy > 0.4 && this.phi > 0.3) {
+                    this.taskProgress = Math.min(1, this.taskProgress + 0.25);
+                    this.energy = Math.max(0, this.energy - 0.1);
+                }
+                break;
+            case 'dream.cycle':
+                this.phi = Math.min(1, this.phi + 0.2);
+                break;
+            case 'rest.idle':
+                this.energy = Math.min(1, this.energy + 0.1);
+                this.state = 'idle';
+                break;
+            case 'verify.ethics':
+                // Minor effect
+                break;
+        }
+    }
+    isGoalAchieved() {
+        return this.taskProgress >= 1;
+    }
+    isCritical() {
+        return this.energy <= 0.05;
+    }
+    getEnergyLevel() {
+        return Math.round(this.energy * 4);
+    }
+    getTaskLevel() {
+        return this.taskProgress >= 1 ? 3 :
+            this.taskProgress > 0.5 ? 2 :
+                this.taskProgress > 0 ? 1 : 0;
+    }
+    reset() {
+        this.energy = 0.5;
+        this.phi = 0.5;
+        this.taskProgress = 0;
+        this.cycle = 0;
+        this.state = 'idle';
+    }
+}
+// ============================================================================
+// Visualization
+// ============================================================================
+function formatAction(action) {
+    const icons = {
+        'sense.mcp': '👁️ ',
+        'recall.memory': '🧠',
+        'plan.goals': '📋',
+        'verify.ethics': '⚖️ ',
+        'execute.task': '⚡',
+        'dream.cycle': '💭',
+        'rest.idle': '😴',
+        'recharge': '🔋',
+    };
+    return `${icons[action] || '❓'} ${action}`;
+}
+function energyBar(level) {
+    const bars = ['▁', '▂', '▄', '▆', '█'];
+    return bars[Math.min(4, Math.max(0, level))];
+}
+function taskProgress(level) {
+    const stages = ['○○○', '●○○', '●●○', '●●●'];
+    return stages[Math.min(3, Math.max(0, level))];
+}
+// ============================================================================
+// Demo 1: Basic Autonomous Loop
+// ============================================================================
+async function demoBasicLoop() {
+    console.log('╔═══════════════════════════════════════════════════════════════╗');
+    console.log('║        Demo 1: Basic Autonomous Loop (20 cycles)              ║');
+    console.log('╚═══════════════════════════════════════════════════════════════╝\n');
+    const env = new SimulatedEnvironment();
+    const loop = (0, index_js_1.createAutonomousLoop)({
+        cycleInterval: 0,
+        maxCycles: 20,
+        stopOnGoalAchieved: true,
+        stopOnEnergyCritical: true,
+        verbose: false,
+    });
+    // Configure observation source using proper interface
+    loop.configureObservations({
+        kernelState: () => env.getKernelState(),
+        phiState: () => env.getPhiState(),
+    });
+    console.log('Cycle │ Energy │ Task  │ Action');
+    console.log('──────┼────────┼───────┼────────────────');
+    loop.onCycle((cycle, action) => {
+        env.applyAction(action);
+        const e = env.getEnergyLevel();
+        const t = env.getTaskLevel();
+        console.log(`  ${cycle.toString().padStart(2)} │ ${energyBar(e)} E:${e} │ ` +
+            `${taskProgress(t)} │ ${formatAction(action)}`);
+    });
+    const stats = await loop.run();
+    console.log('──────┴────────┴───────┴────────────────\n');
+    console.log(`Stopped after ${stats.cycles} cycles`);
+    console.log(`Goal: ${env.isGoalAchieved() ? '✓ Achieved' : '✗ Not achieved'}`);
+    console.log(`Actions: ${Object.entries(stats.actions).filter(([, c]) => c > 0).map(([a, c]) => `${a.split('.')[0]}:${c}`).join(', ')}`);
+}
+// ============================================================================
+// Demo 2: Value-Integrated Autonomous Loop
+// ============================================================================
+async function demoValueIntegratedLoop() {
+    console.log('\n\n╔═══════════════════════════════════════════════════════════════╗');
+    console.log('║      Demo 2: Value-Integrated Autonomous Loop (30 cycles)     ║');
+    console.log('╚═══════════════════════════════════════════════════════════════╝\n');
+    const env = new SimulatedEnvironment();
+    const { loop, valueEngine } = (0, value_integration_js_1.createValueIntegratedLoop)({
+        cycleInterval: 0,
+        maxCycles: 30,
+        stopOnGoalAchieved: true,
+        stopOnEnergyCritical: true,
+        verbose: false,
+        valueIntegration: {
+            valueWeight: 0.6,
+            useWorldModelPredictions: false,
+        },
+    });
+    loop.configureObservations({
+        kernelState: () => env.getKernelState(),
+        phiState: () => env.getPhiState(),
+    });
+    console.log('Cycle │ Energy │ Task  │ Value │ Action');
+    console.log('──────┼────────┼───────┼───────┼────────────────');
+    loop.onCycle((cycle, action) => {
+        env.applyAction(action);
+        const e = env.getEnergyLevel();
+        const t = env.getTaskLevel();
+        const veStats = valueEngine.getStats();
+        console.log(`  ${cycle.toString().padStart(2)} │ ${energyBar(e)} E:${e} │ ` +
+            `${taskProgress(t)} │ ${veStats.averageValue.toFixed(2)} │ ${formatAction(action)}`);
+    });
+    const stats = await loop.run();
+    console.log('──────┴────────┴───────┴───────┴────────────────\n');
+    const veStats = valueEngine.getStats();
+    console.log('Value Engine Statistics:');
+    console.log(`  Cycles: ${veStats.cycleCount}`);
+    console.log(`  Avg Value: ${veStats.averageValue.toFixed(3)}`);
+    console.log(`  Goal: ${env.isGoalAchieved() ? '✓ Achieved' : '✗ Not achieved'}`);
+}
+// ============================================================================
+// Demo 3: Recovery Scenario
+// ============================================================================
+async function demoRecoveryScenario() {
+    console.log('\n\n╔═══════════════════════════════════════════════════════════════╗');
+    console.log('║         Demo 3: Recovery from Critical State (40 cycles)      ║');
+    console.log('╚═══════════════════════════════════════════════════════════════╝\n');
+    const env = new SimulatedEnvironment();
+    // Drain energy to critical
+    for (let i = 0; i < 10; i++) {
+        env.applyAction('execute.task');
+    }
+    console.log(`Starting state: Energy=${env.getKernelState().energy.toFixed(2)} (critical)\n`);
+    const { loop, valueEngine } = (0, value_integration_js_1.createValueIntegratedLoop)({
+        cycleInterval: 0,
+        maxCycles: 40,
+        stopOnGoalAchieved: true,
+        stopOnEnergyCritical: false, // Don't stop - let it recover
+        valueIntegration: {
+            valueWeight: 0.7,
+        },
+    });
+    loop.configureObservations({
+        kernelState: () => env.getKernelState(),
+        phiState: () => env.getPhiState(),
+    });
+    let phase = 'critical';
+    const phases = [];
+    console.log('Cycle │ Phase     │ Energy │ Task  │ Action');
+    console.log('──────┼───────────┼────────┼───────┼────────────────');
+    loop.onCycle((cycle, action) => {
+        env.applyAction(action);
+        const e = env.getEnergyLevel();
+        const t = env.getTaskLevel();
+        // Detect phase
+        const newPhase = e <= 1 ? 'critical' :
+            e <= 2 ? 'recovering' :
+                t >= 3 ? 'complete' :
+                    'executing';
+        if (newPhase !== phase) {
+            phases.push(`Cycle ${cycle}: ${phase} → ${newPhase}`);
+            phase = newPhase;
+        }
+        const phaseIcon = {
+            'critical': '🔴',
+            'recovering': '🟡',
+            'executing': '🟢',
+            'complete': '🔵',
+        }[phase] || '⚪';
+        console.log(`  ${cycle.toString().padStart(2)} │ ${phaseIcon} ${phase.padEnd(9)} │ ` +
+            `${energyBar(e)} E:${e} │ ${taskProgress(t)} │ ${formatAction(action)}`);
+    });
+    await loop.run();
+    console.log('──────┴───────────┴────────┴───────┴────────────────\n');
+    console.log('Phase Transitions:');
+    phases.forEach(p => console.log(`  ${p}`));
+    console.log(`\nFinal: Goal ${env.isGoalAchieved() ? '✓ Achieved' : '✗ Not achieved'}`);
+}
+// ============================================================================
+// Demo 4: Comparison - With vs Without Value
+// ============================================================================
+async function demoComparison() {
+    console.log('\n\n╔═══════════════════════════════════════════════════════════════╗');
+    console.log('║      Demo 4: Comparison - Basic vs Value-Integrated           ║');
+    console.log('╚═══════════════════════════════════════════════════════════════╝\n');
+    const runExperiment = async (useValue) => {
+        const env = new SimulatedEnvironment();
+        let loop;
+        if (useValue) {
+            const result = (0, value_integration_js_1.createValueIntegratedLoop)({
+                cycleInterval: 0,
+                maxCycles: 35,
+                stopOnGoalAchieved: true,
+                stopOnEnergyCritical: true,
+            });
+            loop = result.loop;
+        }
+        else {
+            loop = (0, index_js_1.createAutonomousLoop)({
+                cycleInterval: 0,
+                maxCycles: 35,
+                stopOnGoalAchieved: true,
+                stopOnEnergyCritical: true,
+            });
+        }
+        loop.configureObservations({
+            kernelState: () => env.getKernelState(),
+            phiState: () => env.getPhiState(),
+        });
+        loop.onCycle((_, action) => env.applyAction(action));
+        const stats = await loop.run();
+        return {
+            cycles: stats.cycles,
+            goalAchieved: env.isGoalAchieved(),
+            actions: stats.actions,
+        };
+    };
+    const trials = 5;
+    console.log(`Running ${trials} trials each...\n`);
+    const basicResults = [];
+    const valueResults = [];
+    for (let i = 0; i < trials; i++) {
+        basicResults.push(await runExperiment(false));
+        valueResults.push(await runExperiment(true));
+    }
+    const analyze = (results) => ({
+        avgCycles: results.reduce((s, r) => s + r.cycles, 0) / trials,
+        goalRate: results.filter(r => r.goalAchieved).length / trials * 100,
+    });
+    const basic = analyze(basicResults);
+    const value = analyze(valueResults);
+    console.log('                    │ Basic Loop │ Value-Integrated');
+    console.log('────────────────────┼────────────┼──────────────────');
+    console.log(`  Avg Cycles        │ ${basic.avgCycles.toFixed(1).padStart(10)} │ ${value.avgCycles.toFixed(1).padStart(16)}`);
+    console.log(`  Goal Achieved %   │ ${basic.goalRate.toFixed(0).padStart(9)}% │ ${value.goalRate.toFixed(0).padStart(15)}%`);
+    console.log('\nAction distribution (last trial):');
+    const lastBasic = basicResults[basicResults.length - 1].actions;
+    const lastValue = valueResults[valueResults.length - 1].actions;
+    for (const action of types_js_1.ACTIONS) {
+        const b = lastBasic[action] || 0;
+        const v = lastValue[action] || 0;
+        if (b > 0 || v > 0) {
+            console.log(`  ${action.padEnd(14)} │ ${b.toString().padStart(10)} │ ${v.toString().padStart(16)}`);
+        }
+    }
+}
+// ============================================================================
+// Main
+// ============================================================================
+async function main() {
+    console.log('\n🔄 Genesis 6.2 - Autonomous Loop with Value Integration\n');
+    await demoBasicLoop();
+    await demoValueIntegratedLoop();
+    await demoRecoveryScenario();
+    await demoComparison();
+    console.log('\n✓ All demos complete!\n');
+}
+main().catch(console.error);

package/dist/src/active-inference/demo-value-integration.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Demo: Value-Augmented Active Inference
+ *
+ * Shows the ValueAugmentedEngine combining POMDP beliefs with value function.
+ *
+ * Run: node dist/src/active-inference/demo-value-integration.js
+ */
+export {};

package/dist/src/active-inference/demo-value-integration.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Demo: Value-Augmented Active Inference
+ *
+ * Shows the ValueAugmentedEngine combining POMDP beliefs with value function.
+ *
+ * Run: node dist/src/active-inference/demo-value-integration.js
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const value_integration_js_1 = require("./value-integration.js");
+const types_js_1 = require("./types.js");
+const scenarios = [
+    {
+        name: 'Critical Energy',
+        description: 'Energy depleted, needs immediate recharge',
+        observation: { energy: 0, phi: 1, tool: 1, coherence: 1, task: 1 },
+    },
+    {
+        name: 'Optimal State',
+        description: 'High energy, stable, at attractor (Wu Wei)',
+        observation: { energy: 4, phi: 3, tool: 1, coherence: 2, task: 3 },
+    },
+    {
+        name: 'Task Blocked',
+        description: 'Normal energy but task is blocked',
+        observation: { energy: 2, phi: 2, tool: 2, coherence: 1, task: 2 },
+    },
+    {
+        name: 'Low Coherence',
+        description: 'Need to sense/explore to understand world',
+        observation: { energy: 3, phi: 0, tool: 0, coherence: 0, task: 0 },
+    },
+    {
+        name: 'Ready to Execute',
+        description: 'High energy, good coherence, task active',
+        observation: { energy: 3, phi: 2, tool: 1, coherence: 2, task: 1 },
+    },
+];
+// ============================================================================
+// Visualization
+// ============================================================================
+function bar(value, max = 1, width = 20) {
+    const filled = Math.round((value / max) * width);
+    return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
+function formatPolicy(policy) {
+    const lines = [];
+    for (let i = 0; i < policy.length; i++) {
+        const action = types_js_1.ACTIONS[i];
+        const prob = policy[i];
+        lines.push(`  ${action.padEnd(14)} ${bar(prob)} ${(prob * 100).toFixed(1)}%`);
+    }
+    return lines.join('\n');
+}
+function formatBeliefs(beliefs) {
+    const lines = [];
+    // Viability
+    const viabilityLabels = ['critical', 'low', 'medium', 'high', 'optimal'];
+    const maxVia = beliefs.viability.indexOf(Math.max(...beliefs.viability));
+    lines.push(`  Viability:    ${viabilityLabels[maxVia]} (${(beliefs.viability[maxVia] * 100).toFixed(0)}%)`);
+    // World State
+    const worldLabels = ['unknown', 'stable', 'changing', 'chaotic'];
+    const maxWorld = beliefs.worldState.indexOf(Math.max(...beliefs.worldState));
+    lines.push(`  World State:  ${worldLabels[maxWorld]} (${(beliefs.worldState[maxWorld] * 100).toFixed(0)}%)`);
+    // Coupling
+    const couplingLabels = ['none', 'weak', 'moderate', 'strong', 'synced'];
+    const maxCoup = beliefs.coupling.indexOf(Math.max(...beliefs.coupling));
+    lines.push(`  Coupling:     ${couplingLabels[maxCoup]} (${(beliefs.coupling[maxCoup] * 100).toFixed(0)}%)`);
+    // Goal Progress
+    const goalLabels = ['blocked', 'slow', 'onTrack', 'achieved'];
+    const maxGoal = beliefs.goalProgress.indexOf(Math.max(...beliefs.goalProgress));
+    lines.push(`  Goal:         ${goalLabels[maxGoal]} (${(beliefs.goalProgress[maxGoal] * 100).toFixed(0)}%)`);
+    return lines.join('\n');
+}
+function formatValue(value) {
+    const lines = [];
+    lines.push(`  Total Value:  ${value.value.toFixed(3)}`);
+    lines.push(`  Components:`);
+    for (const [key, val] of Object.entries(value.components)) {
+        lines.push(`    ${key.padEnd(12)} ${val.toFixed(3)}`);
+    }
+    return lines.join('\n');
+}
+// ============================================================================
+// Demo Runner
+// ============================================================================
+async function runDemo() {
+    console.log('╔═══════════════════════════════════════════════════════════════╗');
+    console.log('║     Genesis 6.2 - Value-Augmented Active Inference Demo       ║');
+    console.log('╚═══════════════════════════════════════════════════════════════╝\n');
+    console.log('Creating ValueAugmentedEngine...');
+    const engine = (0, value_integration_js_1.createValueAugmentedEngine)({ verbose: false });
+    console.log('Policy formula: π(a|s) ∝ exp(-EFE(a) + λ·V(s\'))\n');
+    console.log('─'.repeat(65));
+    for (const scenario of scenarios) {
+        console.log(`\n📍 Scenario: ${scenario.name}`);
+        console.log(`   ${scenario.description}\n`);
+        // Show observation
+        console.log('Observation:');
+        console.log(`  energy=${scenario.observation.energy} phi=${scenario.observation.phi} ` +
+            `tool=${scenario.observation.tool} coherence=${scenario.observation.coherence} ` +
+            `task=${scenario.observation.task}\n`);
+        // Run inference
+        const result = await engine.step(scenario.observation);
+        // Show beliefs
+        console.log('Beliefs (after inference):');
+        console.log(formatBeliefs(result.beliefs));
+        console.log();
+        // Show value
+        console.log('Value Estimate:');
+        console.log(formatValue(result.value));
+        console.log();
+        // Show policy
+        console.log('Value-Augmented Policy:');
+        console.log(formatPolicy(result.policy));
+        console.log();
+        // Show selected action
+        console.log(`➤ Selected Action: ${result.action}`);
+        console.log('─'.repeat(65));
+    }
+    // Multi-step demonstration
+    console.log('\n\n╔═══════════════════════════════════════════════════════════════╗');
+    console.log('║              Multi-Step Inference Demonstration                ║');
+    console.log('╚═══════════════════════════════════════════════════════════════╝\n');
+    const engine2 = (0, value_integration_js_1.createValueAugmentedEngine)();
+    // Simulate energy recovery scenario
+    const recoverySequence = [
+        { energy: 0, phi: 1, tool: 1, coherence: 1, task: 1 }, // Critical
+        { energy: 1, phi: 1, tool: 1, coherence: 1, task: 1 }, // Low (after recharge)
+        { energy: 2, phi: 2, tool: 1, coherence: 1, task: 1 }, // Normal
+        { energy: 3, phi: 2, tool: 1, coherence: 2, task: 1 }, // High
+        { energy: 4, phi: 3, tool: 1, coherence: 2, task: 3 }, // Optimal + Task done
+    ];
+    console.log('Simulating energy recovery scenario...\n');
+    console.log('Step │ Energy │ Action         │ Value   │ Top Policy');
+    console.log('─────┼────────┼────────────────┼─────────┼──────────────────');
+    for (let i = 0; i < recoverySequence.length; i++) {
+        const obs = recoverySequence[i];
+        const result = await engine2.step(obs);
+        // Find top 2 actions
+        const sorted = result.policy
+            .map((p, idx) => ({ action: types_js_1.ACTIONS[idx], prob: p }))
+            .sort((a, b) => b.prob - a.prob)
+            .slice(0, 2);
+        const topPolicy = sorted.map(s => `${s.action.split('.')[0]}:${(s.prob * 100).toFixed(0)}%`).join(' ');
+        console.log(`  ${(i + 1).toString().padStart(2)}  │   ${obs.energy}    │ ${result.action.padEnd(14)} │ ${result.value.value.toFixed(3).padStart(7)} │ ${topPolicy}`);
+    }
+    // Show final stats
+    const stats = engine2.getStats();
+    console.log('\n─'.repeat(65));
+    console.log('\nFinal Statistics:');
+    console.log(`  Cycles:        ${stats.cycleCount}`);
+    console.log(`  Avg Value:     ${stats.averageValue.toFixed(3)}`);
+    console.log(`  Value Updates: ${stats.valueUpdates}`);
+    // Demo with JEPA
+    console.log('\n\n╔═══════════════════════════════════════════════════════════════╗');
+    console.log('║              Full Integration with JEPA                        ║');
+    console.log('╚═══════════════════════════════════════════════════════════════╝\n');
+    console.log('Creating engine with JEPA world model...');
+    const fullEngine = await (0, value_integration_js_1.createFullyIntegratedEngine)({
+        useWorldModelPredictions: true,
+        predictionHorizon: 3,
+    });
+    const jepaObs = { energy: 2, phi: 2, tool: 1, coherence: 1, task: 1 };
+    console.log(`\nObservation: energy=${jepaObs.energy} phi=${jepaObs.phi} task=${jepaObs.task}`);
+    const jepaResult = await fullEngine.step(jepaObs);
+    console.log('\nWith JEPA trajectory predictions:');
+    console.log(`  Selected Action: ${jepaResult.action}`);
+    console.log(`  State Value:     ${jepaResult.value.value.toFixed(3)}`);
+    console.log(`  Trajectory Predictions: ${fullEngine.getStats().trajectoryPredictions}`);
+    console.log('\n✓ Demo complete!');
+}
+// Run
+runDemo().catch(console.error);

package/dist/src/active-inference/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Genesis 6.2 - Active Inference Module
+ *
+ * Autonomous decision-making via Free Energy Principle.
+ *
+ * This module enables Genesis to operate autonomously,
+ * making decisions through Active Inference math.
+ *
+ * Usage:
+ * ```typescript
+ * import { createAutonomousLoop, AutonomousLoop } from './active-inference/index.js';
+ *
+ * const loop = createAutonomousLoop();
+ *
+ * // Run N inference cycles
+ * await loop.run(100);
+ *
+ * // Get current beliefs
+ * const beliefs = loop.getBeliefs();
+ *
+ * // Get statistics
+ * const stats = loop.getStats();
+ * ```
+ */
+export * from './types.js';
+export { ActiveInferenceEngine, createActiveInferenceEngine } from './core.js';
+export { ObservationGatherer, createObservationGatherer, getObservationGatherer } from './observations.js';
+export { ActionExecutorManager, createActionExecutorManager, getActionExecutorManager, executeAction, registerAction, type ActionResult, type ActionContext, } from './actions.js';
+export { AutonomousLoop, createAutonomousLoop, getAutonomousLoop, resetAutonomousLoop, type AutonomousLoopConfig, type LoopStats, DEFAULT_LOOP_CONFIG, } from './autonomous-loop.js';
+export { integrateActiveInference, createIntegratedSystem, createKernelObservationBridge, registerKernelActions, registerDaemonTask, createMCPObservationBridge, createMCPInferenceLoop, type IntegrationConfig, type IntegratedSystem, type MCPObservationConfig, } from './integration.js';
+export { ValueAugmentedEngine, createValueAugmentedEngine, createFullyIntegratedEngine, createValueIntegratedLoop, type ValueIntegrationConfig, type ValueIntegrationEvent, type ValueIntegratedLoopConfig, DEFAULT_VALUE_INTEGRATION_CONFIG, } from './value-integration.js';
+export { integrateMemory, getMemoryMetrics, getWorkspaceState, type MemoryIntegrationConfig, DEFAULT_MEMORY_INTEGRATION_CONFIG, } from './memory-integration.js';

package/dist/src/active-inference/index.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Genesis 6.2 - Active Inference Module
+ *
+ * Autonomous decision-making via Free Energy Principle.
+ *
+ * This module enables Genesis to operate autonomously,
+ * making decisions through Active Inference math.
+ *
+ * Usage:
+ * ```typescript
+ * import { createAutonomousLoop, AutonomousLoop } from './active-inference/index.js';
+ *
+ * const loop = createAutonomousLoop();
+ *
+ * // Run N inference cycles
+ * await loop.run(100);
+ *
+ * // Get current beliefs
+ * const beliefs = loop.getBeliefs();
+ *
+ * // Get statistics
+ * const stats = loop.getStats();
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MEMORY_INTEGRATION_CONFIG = exports.getWorkspaceState = exports.getMemoryMetrics = exports.integrateMemory = exports.DEFAULT_VALUE_INTEGRATION_CONFIG = exports.createValueIntegratedLoop = exports.createFullyIntegratedEngine = exports.createValueAugmentedEngine = exports.ValueAugmentedEngine = exports.createMCPInferenceLoop = exports.createMCPObservationBridge = exports.registerDaemonTask = exports.registerKernelActions = exports.createKernelObservationBridge = exports.createIntegratedSystem = exports.integrateActiveInference = exports.DEFAULT_LOOP_CONFIG = exports.resetAutonomousLoop = exports.getAutonomousLoop = exports.createAutonomousLoop = exports.AutonomousLoop = exports.registerAction = exports.executeAction = exports.getActionExecutorManager = exports.createActionExecutorManager = exports.ActionExecutorManager = exports.getObservationGatherer = exports.createObservationGatherer = exports.ObservationGatherer = exports.createActiveInferenceEngine = exports.ActiveInferenceEngine = void 0;
+// Export types
+__exportStar(require("./types.js"), exports);
+// Export core components
+var core_js_1 = require("./core.js");
+Object.defineProperty(exports, "ActiveInferenceEngine", { enumerable: true, get: function () { return core_js_1.ActiveInferenceEngine; } });
+Object.defineProperty(exports, "createActiveInferenceEngine", { enumerable: true, get: function () { return core_js_1.createActiveInferenceEngine; } });
+var observations_js_1 = require("./observations.js");
+Object.defineProperty(exports, "ObservationGatherer", { enumerable: true, get: function () { return observations_js_1.ObservationGatherer; } });
+Object.defineProperty(exports, "createObservationGatherer", { enumerable: true, get: function () { return observations_js_1.createObservationGatherer; } });
+Object.defineProperty(exports, "getObservationGatherer", { enumerable: true, get: function () { return observations_js_1.getObservationGatherer; } });
+var actions_js_1 = require("./actions.js");
+Object.defineProperty(exports, "ActionExecutorManager", { enumerable: true, get: function () { return actions_js_1.ActionExecutorManager; } });
+Object.defineProperty(exports, "createActionExecutorManager", { enumerable: true, get: function () { return actions_js_1.createActionExecutorManager; } });
+Object.defineProperty(exports, "getActionExecutorManager", { enumerable: true, get: function () { return actions_js_1.getActionExecutorManager; } });
+Object.defineProperty(exports, "executeAction", { enumerable: true, get: function () { return actions_js_1.executeAction; } });
+Object.defineProperty(exports, "registerAction", { enumerable: true, get: function () { return actions_js_1.registerAction; } });
+// Export Autonomous Loop (extracted to avoid circular deps)
+var autonomous_loop_js_1 = require("./autonomous-loop.js");
+Object.defineProperty(exports, "AutonomousLoop", { enumerable: true, get: function () { return autonomous_loop_js_1.AutonomousLoop; } });
+Object.defineProperty(exports, "createAutonomousLoop", { enumerable: true, get: function () { return autonomous_loop_js_1.createAutonomousLoop; } });
+Object.defineProperty(exports, "getAutonomousLoop", { enumerable: true, get: function () { return autonomous_loop_js_1.getAutonomousLoop; } });
+Object.defineProperty(exports, "resetAutonomousLoop", { enumerable: true, get: function () { return autonomous_loop_js_1.resetAutonomousLoop; } });
+Object.defineProperty(exports, "DEFAULT_LOOP_CONFIG", { enumerable: true, get: function () { return autonomous_loop_js_1.DEFAULT_LOOP_CONFIG; } });
+// Export integration with Kernel/Daemon
+var integration_js_1 = require("./integration.js");
+Object.defineProperty(exports, "integrateActiveInference", { enumerable: true, get: function () { return integration_js_1.integrateActiveInference; } });
+Object.defineProperty(exports, "createIntegratedSystem", { enumerable: true, get: function () { return integration_js_1.createIntegratedSystem; } });
+Object.defineProperty(exports, "createKernelObservationBridge", { enumerable: true, get: function () { return integration_js_1.createKernelObservationBridge; } });
+Object.defineProperty(exports, "registerKernelActions", { enumerable: true, get: function () { return integration_js_1.registerKernelActions; } });
+Object.defineProperty(exports, "registerDaemonTask", { enumerable: true, get: function () { return integration_js_1.registerDaemonTask; } });
+// MCP integration (Genesis 6.3+)
+Object.defineProperty(exports, "createMCPObservationBridge", { enumerable: true, get: function () { return integration_js_1.createMCPObservationBridge; } });
+Object.defineProperty(exports, "createMCPInferenceLoop", { enumerable: true, get: function () { return integration_js_1.createMCPInferenceLoop; } });
+// Export Value-Guided JEPA integration (Genesis 6.2)
+// Note: createValueIntegratedLoop moved to value-integration.ts to avoid cycle
+var value_integration_js_1 = require("./value-integration.js");
+Object.defineProperty(exports, "ValueAugmentedEngine", { enumerable: true, get: function () { return value_integration_js_1.ValueAugmentedEngine; } });
+Object.defineProperty(exports, "createValueAugmentedEngine", { enumerable: true, get: function () { return value_integration_js_1.createValueAugmentedEngine; } });
+Object.defineProperty(exports, "createFullyIntegratedEngine", { enumerable: true, get: function () { return value_integration_js_1.createFullyIntegratedEngine; } });
+Object.defineProperty(exports, "createValueIntegratedLoop", { enumerable: true, get: function () { return value_integration_js_1.createValueIntegratedLoop; } });
+Object.defineProperty(exports, "DEFAULT_VALUE_INTEGRATION_CONFIG", { enumerable: true, get: function () { return value_integration_js_1.DEFAULT_VALUE_INTEGRATION_CONFIG; } });
+// Export Memory 2.0 integration (Genesis 6.3)
+var memory_integration_js_1 = require("./memory-integration.js");
+Object.defineProperty(exports, "integrateMemory", { enumerable: true, get: function () { return memory_integration_js_1.integrateMemory; } });
+Object.defineProperty(exports, "getMemoryMetrics", { enumerable: true, get: function () { return memory_integration_js_1.getMemoryMetrics; } });
+Object.defineProperty(exports, "getWorkspaceState", { enumerable: true, get: function () { return memory_integration_js_1.getWorkspaceState; } });
+Object.defineProperty(exports, "DEFAULT_MEMORY_INTEGRATION_CONFIG", { enumerable: true, get: function () { return memory_integration_js_1.DEFAULT_MEMORY_INTEGRATION_CONFIG; } });