genesis-ai-cli 7.4.5

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

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * Genesis 6.1 - Active Inference Tests
+ *
+ * Tests for the autonomous decision-making system.
+ *
+ * Run: node --test dist/active-inference/test-active-inference.js
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const index_js_1 = require("./index.js");
+// ============================================================================
+// Core Engine Tests
+// ============================================================================
+(0, node_test_1.describe)('ActiveInferenceEngine', () => {
+    (0, node_test_1.it)('should initialize with default beliefs', () => {
+        const engine = (0, index_js_1.createActiveInferenceEngine)();
+        const beliefs = engine.getBeliefs();
+        node_assert_1.default.ok(beliefs.viability.length === 5);
+        node_assert_1.default.ok(beliefs.worldState.length === 4);
+        node_assert_1.default.ok(beliefs.coupling.length === 5);
+        node_assert_1.default.ok(beliefs.goalProgress.length === 4);
+        // Beliefs should sum to 1
+        const sumViability = beliefs.viability.reduce((a, b) => a + b, 0);
+        node_assert_1.default.ok(Math.abs(sumViability - 1) < 0.001, 'Viability beliefs should sum to 1');
+    });
+    (0, node_test_1.it)('should update beliefs on observation', () => {
+        const engine = (0, index_js_1.createActiveInferenceEngine)();
+        const obs = {
+            energy: 4, // full
+            phi: 3, // high
+            tool: 2, // success
+            coherence: 2, // consistent
+            task: 2, // active
+        };
+        const beforeBeliefs = engine.getBeliefs();
+        const afterBeliefs = engine.inferStates(obs);
+        // Beliefs should have changed
+        node_assert_1.default.ok(JSON.stringify(beforeBeliefs) !== JSON.stringify(afterBeliefs), 'Beliefs should update after observation');
+        // High energy observation should increase viability belief
+        node_assert_1.default.ok(afterBeliefs.viability[4] > beforeBeliefs.viability[4], 'High energy obs should increase optimal viability belief');
+    });
+    (0, node_test_1.it)('should infer policy with correct dimensions', () => {
+        const engine = (0, index_js_1.createActiveInferenceEngine)();
+        // Update beliefs first
+        engine.inferStates({
+            energy: 2,
+            phi: 2,
+            tool: 1,
+            coherence: 1,
+            task: 1,
+        });
+        const policy = engine.inferPolicies();
+        node_assert_1.default.ok(policy.length === index_js_1.ACTIONS.length, 'Policy should have same length as actions');
+        // Policy should sum to 1
+        const sum = policy.reduce((a, b) => a + b, 0);
+        node_assert_1.default.ok(Math.abs(sum - 1) < 0.001, 'Policy should sum to 1');
+        // All probabilities should be non-negative
+        node_assert_1.default.ok(policy.every(p => p >= 0), 'All policy probabilities should be non-negative');
+    });
+    (0, node_test_1.it)('should sample valid action from policy', () => {
+        const engine = (0, index_js_1.createActiveInferenceEngine)();
+        engine.inferStates({
+            energy: 2,
+            phi: 2,
+            tool: 1,
+            coherence: 1,
+            task: 1,
+        });
+        const policy = engine.inferPolicies();
+        const action = engine.sampleAction(policy);
+        node_assert_1.default.ok(index_js_1.ACTIONS.includes(action), `Action ${action} should be valid`);
+    });
+    (0, node_test_1.it)('should prefer recharge when energy is critical', () => {
+        const engine = (0, index_js_1.createActiveInferenceEngine)();
+        // Low energy observation
+        engine.inferStates({
+            energy: 0, // depleted
+            phi: 1,
+            tool: 1,
+            coherence: 1,
+            task: 1,
+        });
+        const policy = engine.inferPolicies();
+        // Recharge should have high probability
+        const rechargeIdx = index_js_1.ACTIONS.indexOf('recharge');
+        const restIdx = index_js_1.ACTIONS.indexOf('rest.idle');
+        // Either recharge or rest should be preferred
+        const preferSurvival = policy[rechargeIdx] > 0.1 || policy[restIdx] > 0.1;
+        node_assert_1.default.ok(preferSurvival, 'Should prefer survival actions when energy is critical');
+    });
+    (0, node_test_1.it)('should prefer execute.task when close to goal', () => {
+        const engine = (0, index_js_1.createActiveInferenceEngine)();
+        // High energy, on-track observation
+        engine.inferStates({
+            energy: 4, // full
+            phi: 3, // high
+            tool: 2, // success
+            coherence: 2, // consistent
+            task: 2, // active
+        });
+        const policy = engine.inferPolicies();
+        // Execute task should have reasonable probability
+        const executeIdx = index_js_1.ACTIONS.indexOf('execute.task');
+        node_assert_1.default.ok(policy[executeIdx] > 0.05, 'Should consider executing task when conditions are good');
+    });
+    (0, node_test_1.it)('should track statistics correctly', () => {
+        const engine = (0, index_js_1.createActiveInferenceEngine)();
+        // Run several inference cycles
+        for (let i = 0; i < 5; i++) {
+            engine.inferStates({
+                energy: 2,
+                phi: 2,
+                tool: 1,
+                coherence: 1,
+                task: 1,
+            });
+            const policy = engine.inferPolicies();
+            engine.sampleAction(policy);
+        }
+        const stats = engine.getStats();
+        node_assert_1.default.strictEqual(stats.inferenceCount, 5);
+        node_assert_1.default.ok(stats.averageSurprise >= 0, 'Average surprise should be non-negative');
+    });
+});
+// ============================================================================
+// Observation Gatherer Tests
+// ============================================================================
+(0, node_test_1.describe)('ObservationGatherer', () => {
+    (0, node_test_1.it)('should create observations from raw values', () => {
+        const gatherer = (0, index_js_1.createObservationGatherer)();
+        const obs = gatherer.fromRaw({
+            energy: 0.9,
+            phi: 0.8,
+            toolSuccess: true,
+            coherent: true,
+            taskStatus: 'running',
+        });
+        node_assert_1.default.strictEqual(obs.energy, 4, 'High energy should map to 4');
+        node_assert_1.default.strictEqual(obs.phi, 3, 'High phi should map to 3');
+        node_assert_1.default.strictEqual(obs.tool, 2, 'Success should map to 2');
+        node_assert_1.default.strictEqual(obs.coherence, 2, 'Coherent should map to 2');
+        node_assert_1.default.strictEqual(obs.task, 2, 'Running should map to 2');
+    });
+    (0, node_test_1.it)('should gather observations with defaults', async () => {
+        const gatherer = (0, index_js_1.createObservationGatherer)();
+        // Without configuration, should use defaults
+        const obs = await gatherer.gather();
+        node_assert_1.default.ok(obs.energy >= 0 && obs.energy <= 4);
+        node_assert_1.default.ok(obs.phi >= 0 && obs.phi <= 3);
+        node_assert_1.default.ok(obs.tool >= 0 && obs.tool <= 2);
+        node_assert_1.default.ok(obs.coherence >= 0 && obs.coherence <= 2);
+        node_assert_1.default.ok(obs.task >= 0 && obs.task <= 3);
+    });
+    (0, node_test_1.it)('should use configured sources', async () => {
+        const gatherer = (0, index_js_1.createObservationGatherer)();
+        gatherer.configure({
+            kernelState: () => ({ energy: 0.1, state: 'idle', taskStatus: 'pending' }),
+            phiState: () => ({ phi: 0.2, state: 'drowsy' }),
+        });
+        const obs = await gatherer.gather();
+        node_assert_1.default.strictEqual(obs.energy, 1, 'Low energy should map to 1');
+        node_assert_1.default.strictEqual(obs.phi, 1, 'Low phi should map to 1');
+    });
+});
+// ============================================================================
+// Action Executor Tests
+// ============================================================================
+(0, node_test_1.describe)('ActionExecutorManager', () => {
+    (0, node_test_1.it)('should execute actions and track history', async () => {
+        const manager = (0, index_js_1.createActionExecutorManager)();
+        const result = await manager.execute('rest.idle');
+        node_assert_1.default.ok(result.success);
+        node_assert_1.default.strictEqual(result.action, 'rest.idle');
+        const history = manager.getHistory();
+        node_assert_1.default.strictEqual(history.length, 1);
+    });
+    (0, node_test_1.it)('should allow custom action registration', async () => {
+        const manager = (0, index_js_1.createActionExecutorManager)();
+        let executed = false;
+        (0, index_js_1.registerAction)('sense.mcp', async () => {
+            executed = true;
+            return {
+                success: true,
+                action: 'sense.mcp',
+                data: { test: true },
+                duration: 0,
+            };
+        });
+        await manager.execute('sense.mcp');
+        node_assert_1.default.ok(executed, 'Custom action should be executed');
+    });
+    (0, node_test_1.it)('should calculate statistics correctly', async () => {
+        const manager = (0, index_js_1.createActionExecutorManager)();
+        await manager.execute('rest.idle');
+        await manager.execute('rest.idle');
+        await manager.execute('sense.mcp');
+        const stats = manager.getStats();
+        node_assert_1.default.strictEqual(stats.total, 3);
+        node_assert_1.default.strictEqual(stats.successful, 3);
+        node_assert_1.default.strictEqual(stats.successRate, 1);
+    });
+});
+// ============================================================================
+// Autonomous Loop Tests
+// ============================================================================
+(0, node_test_1.describe)('AutonomousLoop', () => {
+    (0, node_test_1.it)('should run specified number of cycles', async () => {
+        const loop = (0, index_js_1.createAutonomousLoop)({
+            cycleInterval: 0, // No delay between cycles
+            verbose: false,
+        });
+        const stats = await loop.run(5);
+        node_assert_1.default.strictEqual(stats.cycles, 5);
+        node_assert_1.default.ok(stats.finalBeliefs.viability.length === 5);
+    });
+    (0, node_test_1.it)('should call onCycle handlers', async () => {
+        const loop = (0, index_js_1.createAutonomousLoop)({
+            cycleInterval: 0,
+            verbose: false,
+        });
+        let cyclesCalled = 0;
+        loop.onCycle(() => {
+            cyclesCalled++;
+        });
+        await loop.run(3);
+        node_assert_1.default.strictEqual(cyclesCalled, 3);
+    });
+    (0, node_test_1.it)('should call onStop handlers', async () => {
+        const loop = (0, index_js_1.createAutonomousLoop)({
+            cycleInterval: 0,
+            verbose: false,
+        });
+        let stopReason = '';
+        loop.onStop((reason) => {
+            stopReason = reason;
+        });
+        await loop.run(2);
+        node_assert_1.default.strictEqual(stopReason, 'cycle_limit');
+    });
+    (0, node_test_1.it)('should stop on manual stop', async () => {
+        const loop = (0, index_js_1.createAutonomousLoop)({
+            cycleInterval: 10,
+            maxCycles: 0, // Unlimited
+            verbose: false,
+        });
+        // Schedule stop after 2 cycles
+        setTimeout(() => loop.stop('test_stop'), 25);
+        const stats = await loop.run();
+        node_assert_1.default.ok(stats.cycles >= 1 && stats.cycles <= 5, 'Should have run a few cycles before stop');
+    });
+    (0, node_test_1.it)('should provide valid most likely state', async () => {
+        const loop = (0, index_js_1.createAutonomousLoop)({
+            cycleInterval: 0,
+            verbose: false,
+        });
+        await loop.run(3);
+        const state = loop.getMostLikelyState();
+        node_assert_1.default.ok(['critical', 'low', 'medium', 'high', 'optimal'].includes(state.viability));
+        node_assert_1.default.ok(['unknown', 'stable', 'changing', 'hostile'].includes(state.worldState));
+        node_assert_1.default.ok(['none', 'weak', 'medium', 'strong', 'synced'].includes(state.coupling));
+        node_assert_1.default.ok(['blocked', 'slow', 'onTrack', 'achieved'].includes(state.goalProgress));
+    });
+});
+// ============================================================================
+// Integration Tests
+// ============================================================================
+(0, node_test_1.describe)('Active Inference Integration', () => {
+    (0, node_test_1.it)('should run complete inference cycle', async () => {
+        const loop = (0, index_js_1.createAutonomousLoop)({
+            cycleInterval: 0,
+            verbose: false,
+        });
+        // Configure custom observation source
+        loop.configureObservations({
+            kernelState: () => ({
+                energy: 0.7,
+                state: 'thinking',
+                taskStatus: 'running',
+            }),
+        });
+        // Run cycles
+        const stats = await loop.run(10);
+        // Verify reasonable behavior
+        node_assert_1.default.ok(stats.cycles === 10);
+        node_assert_1.default.ok(Object.keys(stats.actions).length > 0, 'Should have taken some actions');
+    });
+    (0, node_test_1.it)('should adapt behavior to changing observations', async () => {
+        const engine = (0, index_js_1.createActiveInferenceEngine)();
+        // Start with low energy
+        engine.inferStates({
+            energy: 0,
+            phi: 1,
+            tool: 1,
+            coherence: 1,
+            task: 1,
+        });
+        const lowEnergyPolicy = engine.inferPolicies();
+        const lowEnergyRecharge = lowEnergyPolicy[index_js_1.ACTIONS.indexOf('recharge')];
+        const lowEnergyRest = lowEnergyPolicy[index_js_1.ACTIONS.indexOf('rest.idle')];
+        // Then high energy
+        engine.inferStates({
+            energy: 4,
+            phi: 3,
+            tool: 2,
+            coherence: 2,
+            task: 2,
+        });
+        const highEnergyPolicy = engine.inferPolicies();
+        const highEnergyRecharge = highEnergyPolicy[index_js_1.ACTIONS.indexOf('recharge')];
+        const highEnergyRest = highEnergyPolicy[index_js_1.ACTIONS.indexOf('rest.idle')];
+        // Low energy should prefer recharge/rest more than high energy
+        node_assert_1.default.ok((lowEnergyRecharge + lowEnergyRest) > (highEnergyRecharge + highEnergyRest), 'Low energy should prefer survival actions more');
+    });
+});
+console.log('Active Inference Tests - Ready to run');

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

@@ -0,0 +1,6 @@
+/**
+ * Test Value Integration (Genesis 6.2)
+ *
+ * Verifies that Value-Guided JEPA integrates correctly with Active Inference.
+ */
+export {};

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

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Test Value Integration (Genesis 6.2)
+ *
+ * Verifies that Value-Guided JEPA integrates correctly with Active Inference.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const value_integration_js_1 = require("./value-integration.js");
+// ============================================================================
+// Test Utilities
+// ============================================================================
+function createTestObservation(overrides = {}) {
+    return {
+        energy: 2, // 0=critical, 1=low, 2=normal, 3=high, 4=optimal
+        phi: 1, // 0=none, 1=low, 2=medium, 3=high
+        tool: 1, // 0=none, 1=success, 2=failure
+        coherence: 1, // 0=none, 1=low, 2=high
+        task: 1, // 0=none, 1=active, 2=blocked, 3=completed
+        ...overrides,
+    };
+}
+// ============================================================================
+// Tests
+// ============================================================================
+(0, node_test_1.describe)('ValueAugmentedEngine', () => {
+    let engine;
+    (0, node_test_1.beforeEach)(() => {
+        engine = (0, value_integration_js_1.createValueAugmentedEngine)();
+    });
+    (0, node_test_1.describe)('creation', () => {
+        (0, node_test_1.it)('should create with default config', () => {
+            node_assert_1.default.ok(engine);
+            node_assert_1.default.strictEqual(typeof engine.step, 'function');
+        });
+        (0, node_test_1.it)('should create with custom config', () => {
+            const custom = (0, value_integration_js_1.createValueAugmentedEngine)({
+                valueWeight: 0.8,
+                useWorldModelPredictions: false,
+            });
+            node_assert_1.default.ok(custom);
+        });
+    });
+    (0, node_test_1.describe)('step', () => {
+        (0, node_test_1.it)('should perform inference step with value augmentation', async () => {
+            const obs = createTestObservation();
+            const result = await engine.step(obs);
+            node_assert_1.default.ok(result.action);
+            node_assert_1.default.ok(result.beliefs);
+            node_assert_1.default.ok(typeof result.value.value === 'number');
+            node_assert_1.default.ok(result.policy);
+            node_assert_1.default.ok(Array.isArray(result.policy));
+        });
+        (0, node_test_1.it)('should return valid action', async () => {
+            const obs = createTestObservation();
+            const result = await engine.step(obs);
+            // Action should be a valid ActionType string
+            node_assert_1.default.strictEqual(typeof result.action, 'string');
+        });
+        (0, node_test_1.it)('should update beliefs over time', async () => {
+            const obs1 = createTestObservation({ energy: 3 });
+            const result1 = await engine.step(obs1);
+            const obs2 = createTestObservation({ energy: 1 });
+            const result2 = await engine.step(obs2);
+            // Both should have beliefs
+            node_assert_1.default.ok(result1.beliefs);
+            node_assert_1.default.ok(result2.beliefs);
+        });
+    });
+    (0, node_test_1.describe)('value estimation', () => {
+        (0, node_test_1.it)('should return value estimate with components', async () => {
+            const obs = createTestObservation();
+            const result = await engine.step(obs);
+            node_assert_1.default.ok(typeof result.value.value === 'number');
+            node_assert_1.default.ok(typeof result.value.components === 'object');
+            node_assert_1.default.ok('survival' in result.value.components);
+            node_assert_1.default.ok('integrity' in result.value.components);
+            node_assert_1.default.ok('progress' in result.value.components);
+        });
+        (0, node_test_1.it)('should estimate higher value for better states', async () => {
+            // Run multiple steps to let beliefs converge
+            const goodObs = createTestObservation({ energy: 4, task: 3, phi: 3, coherence: 2 });
+            await engine.step(goodObs);
+            await engine.step(goodObs);
+            const goodResult = await engine.step(goodObs);
+            // Reset and try bad state
+            const engine2 = (0, value_integration_js_1.createValueAugmentedEngine)();
+            const badObs = createTestObservation({ energy: 0, task: 0, phi: 0, coherence: 0 });
+            await engine2.step(badObs);
+            await engine2.step(badObs);
+            const badResult = await engine2.step(badObs);
+            // Good state should have higher value (with tolerance for noise)
+            // The value difference should be meaningful
+            const diff = goodResult.value.value - badResult.value.value;
+            node_assert_1.default.ok(diff > -0.05, `Expected good value (${goodResult.value.value.toFixed(3)}) to be close to or greater than bad value (${badResult.value.value.toFixed(3)}), diff=${diff.toFixed(3)}`);
+        });
+    });
+    (0, node_test_1.describe)('policy computation', () => {
+        (0, node_test_1.it)('should compute value-augmented policy', async () => {
+            const obs = createTestObservation();
+            const result = await engine.step(obs);
+            // Policy should be an array of probabilities
+            node_assert_1.default.ok(Array.isArray(result.policy));
+            node_assert_1.default.ok(result.policy.length > 0);
+            // All probabilities should be non-negative
+            for (const p of result.policy) {
+                node_assert_1.default.ok(p >= 0, `Probability ${p} should be >= 0`);
+            }
+        });
+        (0, node_test_1.it)('should have policy sum to approximately 1', async () => {
+            const obs = createTestObservation();
+            const result = await engine.step(obs);
+            const sum = result.policy.reduce((a, b) => a + b, 0);
+            node_assert_1.default.ok(Math.abs(sum - 1) < 0.01, `Policy sum ${sum} should be ~1`);
+        });
+    });
+    (0, node_test_1.describe)('learning', () => {
+        (0, node_test_1.it)('should update from outcome', async () => {
+            const obs = createTestObservation();
+            await engine.step(obs);
+            // Get latent state after step
+            const latentState = engine.getLatentState();
+            node_assert_1.default.ok(latentState, 'Should have latent state after step');
+            // Update with positive outcome
+            const obs2 = createTestObservation({ energy: 3 });
+            engine.updateFromOutcome(latentState, 'execute.task', {
+                success: true,
+                newObservation: obs2,
+            });
+            // Should not throw and continue working
+            const result = await engine.step(obs);
+            node_assert_1.default.ok(result.action);
+        });
+    });
+    (0, node_test_1.describe)('statistics', () => {
+        (0, node_test_1.it)('should track statistics', async () => {
+            const obs = createTestObservation();
+            await engine.step(obs);
+            await engine.step(obs);
+            const stats = engine.getStats();
+            node_assert_1.default.strictEqual(stats.cycleCount, 2);
+            node_assert_1.default.ok(typeof stats.totalValue === 'number');
+        });
+    });
+});
+(0, node_test_1.describe)('createFullyIntegratedEngine', () => {
+    (0, node_test_1.it)('should create fully integrated engine with JEPA', async () => {
+        const engine = await (0, value_integration_js_1.createFullyIntegratedEngine)();
+        node_assert_1.default.ok(engine);
+        node_assert_1.default.strictEqual(typeof engine.step, 'function');
+        // Should have initialized JEPA
+        const stats = engine.getStats();
+        node_assert_1.default.strictEqual(stats.cycleCount, 0);
+    });
+});
+(0, node_test_1.describe)('DEFAULT_VALUE_INTEGRATION_CONFIG', () => {
+    (0, node_test_1.it)('should have valid default values', () => {
+        node_assert_1.default.strictEqual(typeof value_integration_js_1.DEFAULT_VALUE_INTEGRATION_CONFIG.valueWeight, 'number');
+        node_assert_1.default.ok(value_integration_js_1.DEFAULT_VALUE_INTEGRATION_CONFIG.valueWeight >= 0);
+        node_assert_1.default.ok(value_integration_js_1.DEFAULT_VALUE_INTEGRATION_CONFIG.valueWeight <= 1);
+        node_assert_1.default.strictEqual(typeof value_integration_js_1.DEFAULT_VALUE_INTEGRATION_CONFIG.predictionHorizon, 'number');
+        node_assert_1.default.ok(value_integration_js_1.DEFAULT_VALUE_INTEGRATION_CONFIG.predictionHorizon >= 1);
+    });
+});

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

@@ -0,0 +1,150 @@
+/**
+ * Genesis 6.1 - Active Inference Types
+ *
+ * Based on pymdp and Free Energy Principle (Friston)
+ *
+ * Core concepts:
+ * - Hidden states: What the system believes about the world
+ * - Observations: What the system perceives
+ * - Actions: What the system can do
+ * - Preferences: What the system wants (C matrix)
+ */
+/**
+ * Hidden state factors - factorized to avoid combinatorial explosion
+ *
+ * Instead of 400 states (5×4×5×4), we have 4 factors with small dimensions.
+ * This reduces B matrix from 400×400×8 = 1.28M to ~900 parameters.
+ */
+export type ViabilityLevel = 0 | 1 | 2 | 3 | 4;
+export type WorldState = 0 | 1 | 2 | 3;
+export type CouplingState = 0 | 1 | 2 | 3 | 4;
+export type GoalProgress = 0 | 1 | 2 | 3;
+export interface HiddenState {
+    viability: ViabilityLevel;
+    worldState: WorldState;
+    coupling: CouplingState;
+    goalProgress: GoalProgress;
+}
+export declare const HIDDEN_STATE_DIMS: {
+    readonly viability: 5;
+    readonly worldState: 4;
+    readonly coupling: 5;
+    readonly goalProgress: 4;
+};
+export declare const HIDDEN_STATE_LABELS: {
+    viability: readonly ["critical", "low", "medium", "high", "optimal"];
+    worldState: readonly ["unknown", "stable", "changing", "hostile"];
+    coupling: readonly ["none", "weak", "medium", "strong", "synced"];
+    goalProgress: readonly ["blocked", "slow", "onTrack", "achieved"];
+};
+/**
+ * Observation modalities - what the system perceives
+ */
+export type EnergyObs = 0 | 1 | 2 | 3 | 4;
+export type PhiObs = 0 | 1 | 2 | 3;
+export type ToolObs = 0 | 1 | 2;
+export type CoherenceObs = 0 | 1 | 2;
+export type TaskObs = 0 | 1 | 2 | 3;
+export interface Observation {
+    energy: EnergyObs;
+    phi: PhiObs;
+    tool: ToolObs;
+    coherence: CoherenceObs;
+    task: TaskObs;
+}
+export declare const OBSERVATION_DIMS: {
+    readonly energy: 5;
+    readonly phi: 4;
+    readonly tool: 3;
+    readonly coherence: 3;
+    readonly task: 4;
+};
+export declare const OBSERVATION_LABELS: {
+    energy: readonly ["depleted", "low", "medium", "high", "full"];
+    phi: readonly ["dormant", "low", "medium", "high"];
+    tool: readonly ["failed", "partial", "success"];
+    coherence: readonly ["broken", "degraded", "consistent"];
+    task: readonly ["none", "pending", "active", "completed"];
+};
+export type ActionType = 'sense.mcp' | 'recall.memory' | 'plan.goals' | 'verify.ethics' | 'execute.task' | 'dream.cycle' | 'rest.idle' | 'recharge';
+export declare const ACTIONS: ActionType[];
+export declare const ACTION_COUNT: number;
+/**
+ * Beliefs are probability distributions over hidden states
+ * Factorized: one distribution per factor
+ */
+export interface Beliefs {
+    viability: number[];
+    worldState: number[];
+    coupling: number[];
+    goalProgress: number[];
+}
+/**
+ * Policy is a probability distribution over actions
+ */
+export type Policy = number[];
+/**
+ * A matrix: P(observation | hidden_state)
+ * Maps hidden states to expected observations
+ *
+ * Factorized: A[modality][obs_level][state_level]
+ */
+export interface AMatrix {
+    energy: number[][];
+    phi: number[][];
+    tool: number[][];
+    coherence: number[][];
+    task: number[][];
+}
+/**
+ * B matrix: P(next_state | current_state, action)
+ * Transition probabilities
+ *
+ * Factorized: B[factor][next_state][current_state][action]
+ */
+export interface BMatrix {
+    viability: number[][][];
+    worldState: number[][][];
+    coupling: number[][][];
+    goalProgress: number[][][];
+}
+/**
+ * C matrix: log P(preferred_observation)
+ * Encodes preferences (what the system wants to observe)
+ *
+ * Negative values = aversive
+ * Positive values = attractive
+ */
+export interface CMatrix {
+    energy: number[];
+    phi: number[];
+    tool: number[];
+    coherence: number[];
+    task: number[];
+}
+/**
+ * D matrix: P(initial_state)
+ * Prior beliefs about initial state
+ */
+export interface DMatrix {
+    viability: number[];
+    worldState: number[];
+    coupling: number[];
+    goalProgress: number[];
+}
+export interface ActiveInferenceConfig {
+    inferenceIterations: number;
+    policyHorizon: number;
+    actionTemperature: number;
+    priorWeight: number;
+    learningRateA: number;
+    learningRateB: number;
+}
+export declare const DEFAULT_CONFIG: ActiveInferenceConfig;
+export type AIEventType = 'beliefs_updated' | 'policy_inferred' | 'action_selected' | 'action_executed' | 'observation_received' | 'surprise_high' | 'goal_achieved' | 'energy_critical';
+export interface AIEvent {
+    type: AIEventType;
+    timestamp: Date;
+    data: Record<string, any>;
+}
+export type AIEventHandler = (event: AIEvent) => void;