genesis-ai-cli 7.4.5

package/dist/src/world-model/types.d.ts

@@ -0,0 +1,341 @@
+/**
+ * Genesis 6.0 - World Model Types
+ *
+ * Types for the unified world model implementing:
+ * - JEPA-style latent space encoding
+ * - Predictive modeling and simulation
+ * - Digital twin capabilities
+ * - Dream mode consolidation
+ *
+ * Key concepts:
+ * - Latent space: Compressed representation of world state
+ * - Prediction: Single-step state transition
+ * - Simulation: Multi-step trajectory generation
+ * - Digital Twin: Real-time synchronized model
+ *
+ * References:
+ * - LeCun (2022). A Path Towards Autonomous Machine Intelligence
+ * - JEPA (Joint Embedding Predictive Architecture)
+ * - World Models (Ha & Schmidhuber, 2018)
+ *
+ * Key invariant: INV-008 - World model consistency
+ */
+/**
+ * Modality types that can be encoded
+ */
+export type Modality = 'text' | 'image' | 'code' | 'state' | 'audio' | 'sensor';
+/**
+ * Input for encoding - multimodal
+ */
+export interface MultimodalInput {
+    modality: Modality;
+    data: unknown;
+    metadata?: Record<string, unknown>;
+    timestamp: Date;
+}
+/**
+ * Text input for encoding
+ */
+export interface TextInput extends MultimodalInput {
+    modality: 'text';
+    data: string;
+    language?: string;
+    context?: string;
+}
+/**
+ * Image input for encoding
+ */
+export interface ImageInput extends MultimodalInput {
+    modality: 'image';
+    data: string;
+    width?: number;
+    height?: number;
+    format?: 'png' | 'jpg' | 'webp';
+}
+/**
+ * Code input for encoding
+ */
+export interface CodeInput extends MultimodalInput {
+    modality: 'code';
+    data: string;
+    language: string;
+    filePath?: string;
+}
+/**
+ * State input (agent/system state)
+ */
+export interface StateInput extends MultimodalInput {
+    modality: 'state';
+    data: Record<string, unknown>;
+    componentId?: string;
+}
+/**
+ * Sensor input (from MCP servers)
+ */
+export interface SensorInput extends MultimodalInput {
+    modality: 'sensor';
+    data: unknown;
+    sensorType: string;
+    source: string;
+}
+/**
+ * Latent state - compressed representation
+ */
+export interface LatentState {
+    vector: number[];
+    dimensions: number;
+    sourceModality: Modality;
+    sourceId: string;
+    timestamp: Date;
+    confidence: number;
+    entropy: number;
+    features?: LatentFeature[];
+}
+/**
+ * Named feature in latent space
+ */
+export interface LatentFeature {
+    name: string;
+    indices: number[];
+    activation: number;
+}
+/**
+ * Encoder configuration
+ */
+export interface EncoderConfig {
+    latentDim: number;
+    modalityWeights: Record<Modality, number>;
+    useCompression: boolean;
+    compressionRatio: number;
+    normalizeOutput: boolean;
+}
+export declare const DEFAULT_ENCODER_CONFIG: EncoderConfig;
+/**
+ * Action that can be taken in the world
+ */
+export interface Action {
+    id: string;
+    type: ActionType;
+    parameters: Record<string, unknown>;
+    agent: string;
+    timestamp: Date;
+}
+export type ActionType = 'observe' | 'query' | 'execute' | 'communicate' | 'transform' | 'create' | 'delete' | 'navigate';
+/**
+ * Predicted state after action
+ */
+export interface PredictedState {
+    state: LatentState;
+    action: Action;
+    probability: number;
+    uncertainty: number;
+    alternativeStates: LatentState[];
+    predictionTime: number;
+}
+/**
+ * Trajectory - sequence of states
+ */
+export interface Trajectory {
+    id: string;
+    initialState: LatentState;
+    actions: Action[];
+    states: PredictedState[];
+    totalProbability: number;
+    horizon: number;
+    simulationTime: number;
+}
+/**
+ * World model configuration
+ */
+export interface WorldModelConfig {
+    maxHorizon: number;
+    uncertaintyThreshold: number;
+    branchingFactor: number;
+    updateIntervalMs: number;
+    consistencyCheckIntervalMs: number;
+}
+export declare const DEFAULT_WORLD_MODEL_CONFIG: WorldModelConfig;
+/**
+ * Physics query for common sense reasoning
+ */
+export interface PhysicsQuery {
+    type: PhysicsQueryType;
+    objects: PhysicsObject[];
+    question: string;
+    constraints?: PhysicsConstraint[];
+}
+export type PhysicsQueryType = 'collision' | 'stability' | 'containment' | 'reachability' | 'causation' | 'trajectory';
+export interface PhysicsObject {
+    id: string;
+    type: string;
+    position?: [number, number, number];
+    velocity?: [number, number, number];
+    mass?: number;
+    properties: Record<string, unknown>;
+}
+export interface PhysicsConstraint {
+    type: 'gravity' | 'friction' | 'boundary' | 'connection';
+    parameters: Record<string, unknown>;
+}
+export interface PhysicsAnswer {
+    query: PhysicsQuery;
+    answer: boolean | number | string;
+    confidence: number;
+    reasoning: string[];
+    visualization?: string;
+}
+/**
+ * Digital twin - synchronized model of real system
+ */
+export interface DigitalTwin {
+    id: string;
+    name: string;
+    realSystemId: string;
+    currentState: LatentState;
+    lastSync: Date;
+    syncDrift: number;
+    stateHistory: LatentState[];
+    historyLimit: number;
+    config: DigitalTwinConfig;
+    status: TwinStatus;
+}
+export interface DigitalTwinConfig {
+    syncIntervalMs: number;
+    maxDrift: number;
+    predictAhead: number;
+    trackMetrics: string[];
+}
+export declare const DEFAULT_DIGITAL_TWIN_CONFIG: DigitalTwinConfig;
+export type TwinStatus = 'synced' | 'drifting' | 'disconnected' | 'initializing';
+/**
+ * Dream cycle result
+ */
+export interface DreamResult {
+    startTime: Date;
+    endTime: Date;
+    duration: number;
+    slowWaveReplay: SlowWaveResult;
+    remAbstraction: REMResult;
+    consolidation: ConsolidationResult;
+    memoriesConsolidated: number;
+    patternsExtracted: number;
+    modelImproved: boolean;
+}
+/**
+ * Slow-wave replay phase
+ * Replays recent experiences
+ */
+export interface SlowWaveResult {
+    experiencesReplayed: number;
+    strongestMemories: string[];
+    replayDuration: number;
+}
+/**
+ * REM abstraction phase
+ * Extracts patterns and generalizations
+ */
+export interface REMResult {
+    patternsFound: Pattern[];
+    abstractionLevel: number;
+    creativeCombinations: number;
+}
+/**
+ * Pattern extracted during REM
+ */
+export interface Pattern {
+    id: string;
+    type: 'sequence' | 'structure' | 'causal' | 'analogy';
+    elements: string[];
+    confidence: number;
+    novelty: number;
+}
+/**
+ * Consolidation phase
+ * Integrates learnings into world model
+ */
+export interface ConsolidationResult {
+    modelUpdates: number;
+    pruned: number;
+    strengthened: number;
+    newConnections: number;
+}
+/**
+ * Dream mode configuration
+ */
+export interface DreamConfig {
+    slowWaveDuration: number;
+    remDuration: number;
+    consolidationDuration: number;
+    triggerThreshold: number;
+    minPendingMemories: number;
+}
+export declare const DEFAULT_DREAM_CONFIG: DreamConfig;
+/**
+ * Entity in the world model
+ */
+export interface WorldEntity {
+    id: string;
+    type: EntityType;
+    name: string;
+    state: LatentState;
+    properties: Record<string, unknown>;
+    relations: EntityRelation[];
+    created: Date;
+    lastUpdated: Date;
+    confidence: number;
+}
+export type EntityType = 'agent' | 'object' | 'location' | 'event' | 'concept' | 'process';
+/**
+ * Relation between entities
+ */
+export interface EntityRelation {
+    id: string;
+    type: RelationType;
+    source: string;
+    target: string;
+    strength: number;
+    bidirectional: boolean;
+    properties: Record<string, unknown>;
+}
+export type RelationType = 'contains' | 'part_of' | 'causes' | 'before' | 'similar' | 'opposite' | 'instance_of' | 'interacts' | 'depends_on';
+/**
+ * Consistency check result
+ */
+export interface ConsistencyCheck {
+    id: string;
+    timestamp: Date;
+    passed: boolean;
+    checks: {
+        stateConsistency: boolean;
+        temporalConsistency: boolean;
+        causalConsistency: boolean;
+        entityConsistency: boolean;
+    };
+    issues: ConsistencyIssue[];
+    inconsistencyScore: number;
+}
+export interface ConsistencyIssue {
+    type: 'contradiction' | 'gap' | 'cycle' | 'orphan' | 'drift';
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    description: string;
+    affectedEntities: string[];
+    suggestedFix?: string;
+}
+export type WorldModelEventType = 'state_predicted' | 'simulation_complete' | 'entity_created' | 'entity_updated' | 'entity_deleted' | 'relation_added' | 'relation_removed' | 'consistency_check' | 'consistency_violation' | 'dream_started' | 'dream_complete' | 'twin_synced' | 'twin_drifted';
+export interface WorldModelEvent {
+    type: WorldModelEventType;
+    timestamp: Date;
+    data: unknown;
+}
+export type WorldModelEventHandler = (event: WorldModelEvent) => void;
+export interface WorldModelSystemConfig {
+    encoder: Partial<EncoderConfig>;
+    predictor: Partial<WorldModelConfig>;
+    twin: Partial<DigitalTwinConfig>;
+    dream: Partial<DreamConfig>;
+    maxEntities: number;
+    entityTTL: number;
+    consistencyCheckEnabled: boolean;
+    autoRepairEnabled: boolean;
+}
+export declare const DEFAULT_WORLD_MODEL_SYSTEM_CONFIG: WorldModelSystemConfig;

package/dist/src/world-model/types.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Genesis 6.0 - World Model Types
+ *
+ * Types for the unified world model implementing:
+ * - JEPA-style latent space encoding
+ * - Predictive modeling and simulation
+ * - Digital twin capabilities
+ * - Dream mode consolidation
+ *
+ * Key concepts:
+ * - Latent space: Compressed representation of world state
+ * - Prediction: Single-step state transition
+ * - Simulation: Multi-step trajectory generation
+ * - Digital Twin: Real-time synchronized model
+ *
+ * References:
+ * - LeCun (2022). A Path Towards Autonomous Machine Intelligence
+ * - JEPA (Joint Embedding Predictive Architecture)
+ * - World Models (Ha & Schmidhuber, 2018)
+ *
+ * Key invariant: INV-008 - World model consistency
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_WORLD_MODEL_SYSTEM_CONFIG = exports.DEFAULT_DREAM_CONFIG = exports.DEFAULT_DIGITAL_TWIN_CONFIG = exports.DEFAULT_WORLD_MODEL_CONFIG = exports.DEFAULT_ENCODER_CONFIG = void 0;
+exports.DEFAULT_ENCODER_CONFIG = {
+    latentDim: 512,
+    modalityWeights: {
+        text: 1.0,
+        image: 1.0,
+        code: 1.0,
+        state: 1.0,
+        audio: 0.8,
+        sensor: 0.9,
+    },
+    useCompression: true,
+    compressionRatio: 0.1,
+    normalizeOutput: true,
+};
+exports.DEFAULT_WORLD_MODEL_CONFIG = {
+    maxHorizon: 100,
+    uncertaintyThreshold: 0.8,
+    branchingFactor: 3,
+    updateIntervalMs: 1000,
+    consistencyCheckIntervalMs: 5000,
+};
+exports.DEFAULT_DIGITAL_TWIN_CONFIG = {
+    syncIntervalMs: 1000,
+    maxDrift: 0.1,
+    predictAhead: 10,
+    trackMetrics: ['energy', 'health', 'performance'],
+};
+exports.DEFAULT_DREAM_CONFIG = {
+    slowWaveDuration: 10000, // 10 seconds
+    remDuration: 15000, // 15 seconds
+    consolidationDuration: 5000, // 5 seconds
+    triggerThreshold: 0.3,
+    minPendingMemories: 10,
+};
+exports.DEFAULT_WORLD_MODEL_SYSTEM_CONFIG = {
+    encoder: exports.DEFAULT_ENCODER_CONFIG,
+    predictor: exports.DEFAULT_WORLD_MODEL_CONFIG,
+    twin: exports.DEFAULT_DIGITAL_TWIN_CONFIG,
+    dream: exports.DEFAULT_DREAM_CONFIG,
+    maxEntities: 10000,
+    entityTTL: 3600000, // 1 hour
+    consistencyCheckEnabled: true,
+    autoRepairEnabled: true,
+};

package/dist/src/world-model/value-jepa.d.ts

@@ -0,0 +1,247 @@
+/**
+ * Genesis 6.2 - Value-Guided JEPA (Joint Embedding Predictive Architecture)
+ *
+ * Extends the world model with value functions for decision-making.
+ *
+ * Scientific foundations:
+ * - LeCun (2022): JEPA - predict in latent space, not pixel space
+ * - Friston: Free Energy Principle - minimize expected free energy
+ * - Hafner (2019): Dreamer - value learning in world models
+ * - Schmidhuber: Curiosity-driven learning via prediction error
+ *
+ * The value function evaluates predicted states to guide:
+ * 1. Action selection (which action leads to best outcome?)
+ * 2. Trajectory planning (which path maximizes value?)
+ * 3. Dream consolidation (which memories are most valuable?)
+ *
+ * Integration with Active Inference:
+ * - G(π) = E[log P(o|s)] - KL[Q(s)||P(s)] + Value(s)
+ * - Expected Free Energy includes value term for goal-directedness
+ */
+import type { LatentState, Action, PredictedState, Trajectory } from './types.js';
+/**
+ * Value function output for a latent state
+ */
+export interface ValueEstimate {
+    value: number;
+    components: {
+        survival: number;
+        integrity: number;
+        progress: number;
+        novelty: number;
+        efficiency: number;
+    };
+    valueUncertainty: number;
+    valueConfidence: number;
+    discount: number;
+    horizon: number;
+}
+/**
+ * Value-guided trajectory with cumulative value
+ */
+export interface ValuedTrajectory extends Trajectory {
+    totalValue: number;
+    expectedValue: number;
+    valueVariance: number;
+    stepValues: ValueEstimate[];
+    minValue: number;
+    maxValue: number;
+    riskAdjustedValue: number;
+}
+/**
+ * Action value (Q-value)
+ */
+export interface ActionValue {
+    action: Action;
+    qValue: number;
+    advantage: number;
+    qUncertainty: number;
+    predictedState: PredictedState;
+}
+/**
+ * Value function configuration
+ */
+export interface ValueFunctionConfig {
+    gamma: number;
+    weights: {
+        survival: number;
+        integrity: number;
+        progress: number;
+        novelty: number;
+        efficiency: number;
+    };
+    riskAversion: number;
+    curiosityBonus: number;
+    temperature: number;
+    horizon: number;
+}
+/**
+ * Free Energy components for Active Inference integration
+ */
+export interface FreeEnergyDecomposition {
+    expectedFreeEnergy: number;
+    ambiguity: number;
+    risk: number;
+    pragmaticValue: number;
+    epistemicValue: number;
+    instrumentalValue: number;
+}
+export declare const DEFAULT_VALUE_CONFIG: ValueFunctionConfig;
+export declare class ValueFunction {
+    private config;
+    private survivalBasis;
+    private integrityBasis;
+    private progressBasis;
+    private valueStats;
+    constructor(config?: Partial<ValueFunctionConfig>);
+    /**
+     * Initialize basis functions for value estimation
+     */
+    private initializeBasis;
+    /**
+     * Estimate value of a latent state
+     */
+    estimate(state: LatentState, horizon?: number): ValueEstimate;
+    /**
+     * Compute individual value components
+     */
+    private computeComponents;
+    /**
+     * Estimate uncertainty in value estimate
+     */
+    private estimateUncertainty;
+    /**
+     * Compute novelty of state (how different from seen states)
+     */
+    private computeNovelty;
+    /**
+     * Compute coherence of latent vector
+     */
+    private computeCoherence;
+    /**
+     * Compute Q-value for state-action pair
+     */
+    computeQValue(state: LatentState, action: Action, predictedState: PredictedState): ActionValue;
+    /**
+     * Rank actions by Q-value
+     */
+    rankActions(actionValues: ActionValue[]): ActionValue[];
+    /**
+     * Sample action using softmax over Q-values
+     */
+    sampleAction(actionValues: ActionValue[]): ActionValue;
+    /**
+     * Evaluate a trajectory with cumulative value
+     */
+    evaluateTrajectory(trajectory: Trajectory): ValuedTrajectory;
+    /**
+     * Select best trajectory from candidates
+     */
+    selectBestTrajectory(trajectories: Trajectory[]): ValuedTrajectory;
+    /**
+     * Compute Expected Free Energy for Active Inference
+     *
+     * G(π) = ambiguity + risk - pragmatic_value - epistemic_value + instrumental_value
+     */
+    computeExpectedFreeEnergy(currentState: LatentState, policy: Action[], predictedStates: PredictedState[], preferences: LatentState): FreeEnergyDecomposition;
+    /**
+     * Ambiguity: Expected observation uncertainty
+     */
+    private computeAmbiguity;
+    /**
+     * Risk: Divergence from preferred states
+     */
+    private computeRisk;
+    /**
+     * Pragmatic Value: Alignment with preferences
+     */
+    private computePragmaticValue;
+    /**
+     * Epistemic Value: Information gain from exploration
+     */
+    private computeEpistemicValue;
+    /**
+     * Instrumental Value: V(s) contribution
+     */
+    private computeInstrumentalValue;
+    /**
+     * Distance between two latent states
+     */
+    private stateDistance;
+    /**
+     * Update value function from observed returns
+     */
+    update(state: LatentState, observedReturn: number, learningRate?: number): void;
+    /**
+     * Update running statistics for normalization
+     */
+    private updateStats;
+    private dotProduct;
+    private sigmoid;
+    private clamp;
+    getConfig(): ValueFunctionConfig;
+    getStats(): {
+        mean: number;
+        std: number;
+        min: number;
+        max: number;
+        count: number;
+    };
+    /**
+     * Set preference weights
+     */
+    setWeights(weights: Partial<ValueFunctionConfig['weights']>): void;
+}
+export declare function createValueFunction(config?: Partial<ValueFunctionConfig>): ValueFunction;
+export declare function getValueFunction(config?: Partial<ValueFunctionConfig>): ValueFunction;
+export declare function resetValueFunction(): void;
+import type { WorldModelPredictor } from './predictor.js';
+/**
+ * Value-Guided JEPA Predictor
+ *
+ * Wraps the WorldModelPredictor with value-guided prediction
+ */
+export declare class ValueGuidedJEPA {
+    private predictor;
+    private valueFunction;
+    constructor(predictor: WorldModelPredictor, valueFn?: ValueFunction);
+    /**
+     * Predict next state and compute value
+     */
+    predictWithValue(state: LatentState, action: Action): Promise<PredictedState & {
+        value: ValueEstimate;
+    }>;
+    /**
+     * Generate value-guided trajectory
+     *
+     * Uses rollout with value-based action selection
+     */
+    planWithValue(initialState: LatentState, horizon: number, candidateActions: Action[][], // Actions to consider at each step
+    preferences?: LatentState): Promise<ValuedTrajectory>;
+    /**
+     * Select action via Expected Free Energy minimization
+     *
+     * This is the core Active Inference decision rule
+     */
+    selectActionActiveInference(currentState: LatentState, candidateActions: Action[], preferences: LatentState, horizon?: number): Promise<{
+        action: Action;
+        freeEnergy: FreeEnergyDecomposition;
+    }>;
+    /**
+     * Dream-time consolidation with value-based prioritization
+     *
+     * Memories with higher value prediction error are replayed more
+     */
+    dreamConsolidate(memories: Array<{
+        state: LatentState;
+        action: Action;
+        nextState: LatentState;
+        reward: number;
+    }>, epochs?: number): Promise<{
+        replayCount: number;
+        avgError: number;
+    }>;
+    getValueFunction(): ValueFunction;
+    getPredictor(): WorldModelPredictor;
+}
+export declare function createValueGuidedJEPA(valueFnConfig?: Partial<ValueFunctionConfig>): Promise<ValueGuidedJEPA>;