genesis-ai-cli 7.4.5

package/dist/src/world-model/test-value-jepa.js

@@ -0,0 +1,430 @@
+"use strict";
+/**
+ * Genesis 6.2 - Value-Guided JEPA Tests
+ *
+ * Tests for the value function and value-guided prediction.
+ *
+ * Run: node --test dist/world-model/test-value-jepa.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 value_jepa_js_1 = require("./value-jepa.js");
+// ============================================================================
+// Test Utilities
+// ============================================================================
+function createTestState(values) {
+    const dim = 64;
+    const vector = Array(dim).fill(0).map((_, i) => {
+        // First 16 dims: energy-related
+        if (i < 16)
+            return values?.energy ?? 0.5;
+        // Next 16 dims: progress-related
+        if (i < 32)
+            return values?.progress ?? 0.5;
+        // Rest: random
+        return Math.random() * 0.5;
+    });
+    return {
+        vector,
+        dimensions: dim,
+        sourceModality: 'state',
+        sourceId: `test-${Date.now()}`,
+        timestamp: new Date(),
+        confidence: values?.confidence ?? 0.7,
+        entropy: values?.entropy ?? 0.3,
+    };
+}
+function createTestAction(type = 'execute') {
+    return {
+        id: `act-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        type,
+        parameters: {},
+        agent: 'test',
+        timestamp: new Date(),
+    };
+}
+function createTestPrediction(state, action) {
+    return {
+        state,
+        action: action ?? createTestAction(),
+        probability: 0.8,
+        uncertainty: 0.2,
+        alternativeStates: [],
+        predictionTime: 10,
+    };
+}
+function createTestTrajectory(states, actions) {
+    const predictedStates = states.map((s, i) => createTestPrediction(s, actions?.[i]));
+    return {
+        id: `traj-${Date.now()}`,
+        initialState: states[0],
+        states: predictedStates,
+        actions: actions ?? states.slice(1).map(() => createTestAction()),
+        totalProbability: 1,
+        horizon: states.length,
+        simulationTime: 0,
+    };
+}
+// ============================================================================
+// ValueFunction Tests
+// ============================================================================
+(0, node_test_1.describe)('ValueFunction', () => {
+    (0, node_test_1.beforeEach)(() => {
+        (0, value_jepa_js_1.resetValueFunction)();
+    });
+    (0, node_test_1.describe)('initialization', () => {
+        (0, node_test_1.it)('should create with default config', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const config = vf.getConfig();
+            node_assert_1.default.strictEqual(config.gamma, value_jepa_js_1.DEFAULT_VALUE_CONFIG.gamma);
+            node_assert_1.default.strictEqual(config.riskAversion, value_jepa_js_1.DEFAULT_VALUE_CONFIG.riskAversion);
+            node_assert_1.default.ok(config.weights.survival > 0);
+        });
+        (0, node_test_1.it)('should accept custom config', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)({
+                gamma: 0.9,
+                riskAversion: 0.8,
+            });
+            const config = vf.getConfig();
+            node_assert_1.default.strictEqual(config.gamma, 0.9);
+            node_assert_1.default.strictEqual(config.riskAversion, 0.8);
+        });
+        (0, node_test_1.it)('should provide singleton via getValueFunction', () => {
+            const vf1 = (0, value_jepa_js_1.getValueFunction)();
+            const vf2 = (0, value_jepa_js_1.getValueFunction)();
+            node_assert_1.default.strictEqual(vf1, vf2);
+        });
+    });
+    (0, node_test_1.describe)('estimate', () => {
+        (0, node_test_1.it)('should return value in range [-1, 1]', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const state = createTestState();
+            const estimate = vf.estimate(state);
+            node_assert_1.default.ok(estimate.value >= -1 && estimate.value <= 1, `Value ${estimate.value} out of range`);
+        });
+        (0, node_test_1.it)('should return all components in range [0, 1]', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const state = createTestState();
+            const estimate = vf.estimate(state);
+            for (const [name, value] of Object.entries(estimate.components)) {
+                node_assert_1.default.ok(value >= 0 && value <= 1, `Component ${name} = ${value} out of range`);
+            }
+        });
+        (0, node_test_1.it)('should apply discount factor for future horizons', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)({ gamma: 0.9 });
+            const state = createTestState({ energy: 0.8 });
+            const now = vf.estimate(state, 0);
+            const future = vf.estimate(state, 5);
+            node_assert_1.default.ok(future.discount < now.discount, 'Future should have smaller discount');
+            node_assert_1.default.ok(Math.abs(future.discount - Math.pow(0.9, 5)) < 0.001);
+        });
+        (0, node_test_1.it)('should return valueUncertainty estimate', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const state = createTestState({ confidence: 0.5 });
+            const estimate = vf.estimate(state);
+            node_assert_1.default.ok(estimate.valueUncertainty >= 0 && estimate.valueUncertainty <= 1);
+            node_assert_1.default.ok(estimate.valueConfidence >= 0 && estimate.valueConfidence <= 1);
+        });
+        (0, node_test_1.it)('should give higher survival value to high-energy states', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const lowEnergy = createTestState({ energy: 0.1 });
+            const highEnergy = createTestState({ energy: 0.9 });
+            const lowEstimate = vf.estimate(lowEnergy);
+            const highEstimate = vf.estimate(highEnergy);
+            // Higher energy should give higher survival component
+            node_assert_1.default.ok(highEstimate.components.survival >= lowEstimate.components.survival, `High energy survival ${highEstimate.components.survival} should >= low ${lowEstimate.components.survival}`);
+        });
+    });
+    (0, node_test_1.describe)('Q-value computation', () => {
+        (0, node_test_1.it)('should compute Q-value for state-action pair', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const state = createTestState();
+            const action = createTestAction();
+            const nextState = createTestState({ energy: 0.8 });
+            const predicted = createTestPrediction(nextState, action);
+            const qValue = vf.computeQValue(state, action, predicted);
+            node_assert_1.default.ok('qValue' in qValue);
+            node_assert_1.default.ok('advantage' in qValue);
+            node_assert_1.default.ok('qUncertainty' in qValue);
+            node_assert_1.default.strictEqual(qValue.action, action);
+        });
+        (0, node_test_1.it)('should compute positive advantage for improving actions', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const state = createTestState({ energy: 0.3 });
+            const action = createTestAction('transform');
+            const nextState = createTestState({ energy: 0.8 });
+            const predicted = createTestPrediction(nextState, action);
+            const qValue = vf.computeQValue(state, action, predicted);
+            // Action that increases energy should have reasonable Q-value
+            node_assert_1.default.ok(qValue.qValue > vf.estimate(state).value * 0.9 || qValue.advantage > -0.5, 'Improving action should have reasonable Q-value');
+        });
+    });
+    (0, node_test_1.describe)('action ranking', () => {
+        (0, node_test_1.it)('should rank actions by Q-value', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)({ riskAversion: 0 });
+            // Create actions with different predicted outcomes
+            const actionValues = [
+                {
+                    action: createTestAction('observe'),
+                    qValue: 0.2,
+                    advantage: -0.3,
+                    qUncertainty: 0.1,
+                    predictedState: createTestPrediction(createTestState({ energy: 0.2 })),
+                },
+                {
+                    action: createTestAction('execute'),
+                    qValue: 0.8,
+                    advantage: 0.3,
+                    qUncertainty: 0.1,
+                    predictedState: createTestPrediction(createTestState({ energy: 0.8 })),
+                },
+                {
+                    action: createTestAction('query'),
+                    qValue: 0.5,
+                    advantage: 0,
+                    qUncertainty: 0.1,
+                    predictedState: createTestPrediction(createTestState({ energy: 0.5 })),
+                },
+            ];
+            const ranked = vf.rankActions(actionValues);
+            node_assert_1.default.strictEqual(ranked[0].action.type, 'execute');
+            node_assert_1.default.strictEqual(ranked[1].action.type, 'query');
+            node_assert_1.default.strictEqual(ranked[2].action.type, 'observe');
+        });
+        (0, node_test_1.it)('should prefer lower uncertainty when risk-averse', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)({ riskAversion: 1.0 });
+            const actionValues = [
+                {
+                    action: createTestAction('execute'),
+                    qValue: 0.6,
+                    advantage: 0.1,
+                    qUncertainty: 0.5, // High uncertainty
+                    predictedState: createTestPrediction(createTestState()),
+                },
+                {
+                    action: createTestAction('observe'),
+                    qValue: 0.5,
+                    advantage: 0,
+                    qUncertainty: 0.1, // Low uncertainty
+                    predictedState: createTestPrediction(createTestState()),
+                },
+            ];
+            const ranked = vf.rankActions(actionValues);
+            // Safe (observe) should be preferred despite lower Q-value
+            node_assert_1.default.strictEqual(ranked[0].action.type, 'observe');
+        });
+    });
+    (0, node_test_1.describe)('trajectory evaluation', () => {
+        (0, node_test_1.it)('should evaluate trajectory with cumulative value', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const states = [
+                createTestState({ energy: 0.5 }),
+                createTestState({ energy: 0.6 }),
+                createTestState({ energy: 0.7 }),
+            ];
+            const trajectory = createTestTrajectory(states);
+            const valued = vf.evaluateTrajectory(trajectory);
+            node_assert_1.default.ok('totalValue' in valued);
+            node_assert_1.default.ok('expectedValue' in valued);
+            node_assert_1.default.ok('stepValues' in valued);
+            node_assert_1.default.strictEqual(valued.stepValues.length, 3);
+            node_assert_1.default.ok(valued.minValue <= valued.maxValue);
+        });
+        (0, node_test_1.it)('should select best trajectory from candidates', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const goodStates = [
+                createTestState({ energy: 0.5 }),
+                createTestState({ energy: 0.8 }),
+            ];
+            const goodTrajectory = createTestTrajectory(goodStates);
+            const badStates = [
+                createTestState({ energy: 0.5 }),
+                createTestState({ energy: 0.2 }),
+            ];
+            const badTrajectory = createTestTrajectory(badStates);
+            const best = vf.selectBestTrajectory([badTrajectory, goodTrajectory]);
+            // Best should have higher expected value
+            const goodValued = vf.evaluateTrajectory(goodTrajectory);
+            node_assert_1.default.ok(best.expectedValue >= goodValued.expectedValue - 0.1, 'Selected trajectory should have high expected value');
+        });
+    });
+    (0, node_test_1.describe)('Expected Free Energy', () => {
+        (0, node_test_1.it)('should compute EFE components', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const currentState = createTestState();
+            const policy = [createTestAction()];
+            const predictedStates = [
+                createTestPrediction(createTestState({ energy: 0.7 })),
+            ];
+            const preferences = createTestState({ energy: 1.0 });
+            const efe = vf.computeExpectedFreeEnergy(currentState, policy, predictedStates, preferences);
+            node_assert_1.default.ok('expectedFreeEnergy' in efe);
+            node_assert_1.default.ok('ambiguity' in efe);
+            node_assert_1.default.ok('risk' in efe);
+            node_assert_1.default.ok('pragmaticValue' in efe);
+            node_assert_1.default.ok('epistemicValue' in efe);
+            node_assert_1.default.ok('instrumentalValue' in efe);
+        });
+        (0, node_test_1.it)('should have lower EFE for states closer to preferences', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const currentState = createTestState({ energy: 0.5 });
+            const preferences = createTestState({ energy: 1.0 });
+            // Close to preferences
+            const closeState = createTestPrediction(createTestState({ energy: 0.9 }));
+            // Far from preferences
+            const farState = createTestPrediction(createTestState({ energy: 0.2 }));
+            const closeFE = vf.computeExpectedFreeEnergy(currentState, [createTestAction()], [closeState], preferences);
+            const farFE = vf.computeExpectedFreeEnergy(currentState, [createTestAction()], [farState], preferences);
+            // Close to preferences should have lower risk
+            node_assert_1.default.ok(closeFE.risk <= farFE.risk, `Close risk ${closeFE.risk} should <= far risk ${farFE.risk}`);
+        });
+    });
+    (0, node_test_1.describe)('learning', () => {
+        (0, node_test_1.it)('should update value function from observed returns', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const state = createTestState({ energy: 0.5 });
+            // Update with high observed return
+            vf.update(state, 0.9, 0.1);
+            vf.update(state, 0.9, 0.1);
+            vf.update(state, 0.9, 0.1);
+            const stats = vf.getStats();
+            node_assert_1.default.ok(stats.count === 3);
+        });
+        (0, node_test_1.it)('should track value statistics', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            const state = createTestState();
+            vf.update(state, 0.5, 0.01);
+            vf.update(state, 0.6, 0.01);
+            vf.update(state, 0.7, 0.01);
+            const stats = vf.getStats();
+            node_assert_1.default.strictEqual(stats.count, 3);
+            node_assert_1.default.ok(stats.mean > 0.4 && stats.mean < 0.8);
+            node_assert_1.default.ok(stats.min <= 0.5);
+            node_assert_1.default.ok(stats.max >= 0.7);
+        });
+    });
+    (0, node_test_1.describe)('weight configuration', () => {
+        (0, node_test_1.it)('should allow setting preference weights', () => {
+            const vf = (0, value_jepa_js_1.createValueFunction)();
+            vf.setWeights({ survival: 0.9, novelty: 0.1 });
+            const config = vf.getConfig();
+            // Weights should be normalized
+            const sum = Object.values(config.weights).reduce((a, b) => a + b, 0);
+            node_assert_1.default.ok(Math.abs(sum - 1) < 0.001, 'Weights should sum to 1');
+            // Survival should be highest
+            node_assert_1.default.ok(config.weights.survival > config.weights.novelty);
+        });
+    });
+});
+// ============================================================================
+// Action Sampling Tests
+// ============================================================================
+(0, node_test_1.describe)('Action Sampling', () => {
+    (0, node_test_1.it)('should sample action from distribution', () => {
+        const vf = (0, value_jepa_js_1.createValueFunction)({ temperature: 1.0 });
+        const actionValues = [
+            {
+                action: createTestAction('observe'),
+                qValue: 0.1,
+                advantage: 0,
+                qUncertainty: 0.1,
+                predictedState: createTestPrediction(createTestState()),
+            },
+            {
+                action: createTestAction('execute'),
+                qValue: 0.9,
+                advantage: 0.5,
+                qUncertainty: 0.1,
+                predictedState: createTestPrediction(createTestState()),
+            },
+        ];
+        // Sample many times
+        const counts = { observe: 0, execute: 0 };
+        for (let i = 0; i < 100; i++) {
+            const sampled = vf.sampleAction(actionValues);
+            counts[sampled.action.type]++;
+        }
+        // Higher Q-value should be sampled more often
+        node_assert_1.default.ok(counts['execute'] > counts['observe'], `execute (${counts['execute']}) should be sampled more than observe (${counts['observe']})`);
+    });
+    (0, node_test_1.it)('should respect temperature parameter', () => {
+        // Low temperature = more deterministic
+        const vfLow = (0, value_jepa_js_1.createValueFunction)({ temperature: 0.1 });
+        // High temperature = more exploratory
+        const vfHigh = (0, value_jepa_js_1.createValueFunction)({ temperature: 5.0 });
+        const actionValues = [
+            {
+                action: createTestAction('observe'),
+                qValue: 0.4,
+                advantage: 0,
+                qUncertainty: 0.1,
+                predictedState: createTestPrediction(createTestState()),
+            },
+            {
+                action: createTestAction('execute'),
+                qValue: 0.6,
+                advantage: 0.1,
+                qUncertainty: 0.1,
+                predictedState: createTestPrediction(createTestState()),
+            },
+        ];
+        // Count selections at low temperature
+        let lowTempExecuteCount = 0;
+        for (let i = 0; i < 50; i++) {
+            if (vfLow.sampleAction(actionValues).action.type === 'execute') {
+                lowTempExecuteCount++;
+            }
+        }
+        // Count selections at high temperature
+        let highTempExecuteCount = 0;
+        for (let i = 0; i < 50; i++) {
+            if (vfHigh.sampleAction(actionValues).action.type === 'execute') {
+                highTempExecuteCount++;
+            }
+        }
+        // Low temperature should select 'execute' more consistently
+        node_assert_1.default.ok(lowTempExecuteCount >= highTempExecuteCount * 0.8, `Low temp selections (${lowTempExecuteCount}) should be more deterministic than high temp (${highTempExecuteCount})`);
+    });
+});
+// ============================================================================
+// Integration Tests
+// ============================================================================
+(0, node_test_1.describe)('Value-Guided JEPA Integration', () => {
+    (0, node_test_1.it)('should work end-to-end: estimate -> rank -> select', () => {
+        const vf = (0, value_jepa_js_1.createValueFunction)();
+        const state = createTestState({ energy: 0.5 });
+        // Create candidate actions with predictions
+        const candidates = ['observe', 'query', 'execute'];
+        // Compute Q-values for each action
+        const actionValues = candidates.map((type, i) => {
+            const action = createTestAction(type);
+            const nextEnergy = 0.3 + i * 0.2; // observe=0.3, query=0.5, execute=0.7
+            const nextState = createTestState({ energy: nextEnergy });
+            return vf.computeQValue(state, action, createTestPrediction(nextState, action));
+        });
+        // Rank actions
+        const ranked = vf.rankActions(actionValues);
+        // Select best
+        const best = ranked[0];
+        node_assert_1.default.ok(best.action.type);
+        node_assert_1.default.ok(best.qValue !== undefined);
+    });
+    (0, node_test_1.it)('should compute trajectory value consistently', () => {
+        const vf = (0, value_jepa_js_1.createValueFunction)();
+        // Create increasing value trajectory
+        const states = [0.4, 0.5, 0.6, 0.7, 0.8].map(e => createTestState({ energy: e }));
+        const trajectory = createTestTrajectory(states);
+        const valued = vf.evaluateTrajectory(trajectory);
+        // Values should generally have decreasing discount
+        for (let i = 1; i < valued.stepValues.length; i++) {
+            const prev = valued.stepValues[i - 1];
+            const curr = valued.stepValues[i];
+            node_assert_1.default.ok(curr.discount <= prev.discount, `Discount should decrease over time: ${prev.discount} -> ${curr.discount}`);
+        }
+    });
+});
+console.log('Value-Guided JEPA Tests - Ready to run');