genesis-ai-cli 7.4.5

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

@@ -0,0 +1,221 @@
+/**
+ * Genesis 6.0 - World Model Module
+ *
+ * Unified world model for prediction, simulation, and dreaming.
+ *
+ * This module provides:
+ * - Latent space encoding (JEPA-style)
+ * - Predictive modeling and multi-step simulation
+ * - Digital twin capabilities
+ * - Physics/common sense reasoning
+ * - Dream mode for memory consolidation
+ *
+ * The world model enables the system to:
+ * - Predict consequences of actions
+ * - Run what-if scenarios safely
+ * - Maintain synchronized models of external systems
+ * - Reason about physical causality
+ *
+ * Key invariant: INV-008 - World model consistency
+ *
+ * Usage:
+ * ```typescript
+ * import { createWorldModelSystem } from './world-model/index.js';
+ *
+ * const worldModel = createWorldModelSystem();
+ *
+ * // Encode observation
+ * const state = worldModel.encode({ modality: 'text', data: 'User logged in' });
+ *
+ * // Predict next state
+ * const prediction = worldModel.predict(state, action);
+ *
+ * // Simulate trajectory
+ * const trajectory = worldModel.simulate(state, actions, 100);
+ *
+ * // Create digital twin
+ * const twin = worldModel.createTwin('server-1', 'Production Server');
+ *
+ * // Run dream cycle
+ * const dreamResult = await worldModel.dream();
+ * ```
+ */
+export * from './types.js';
+export { LatentEncoder, createLatentEncoder, type EncoderEventHandler } from './encoder.js';
+export { LatentDecoder, createLatentDecoder, type DecoderEventHandler, type TextDecoding, type StateDecoding, type FeatureDecoding } from './decoder.js';
+export { WorldModelPredictor, createWorldModelPredictor, createAction, type PredictorEventHandler } from './predictor.js';
+export { DigitalTwinInstance, DigitalTwinManager, createDigitalTwin, createDigitalTwinManager, type TwinEventHandler, type TwinHealth, type WhatIfResult, type TwinSnapshot, type TwinMetrics } from './digital-twin.js';
+export { ValueFunction, ValueGuidedJEPA, createValueFunction, getValueFunction, resetValueFunction, createValueGuidedJEPA, type ValueEstimate, type ValuedTrajectory, type ActionValue, type ValueFunctionConfig, type FreeEnergyDecomposition, DEFAULT_VALUE_CONFIG, } from './value-jepa.js';
+import { MultimodalInput, LatentState, Action, PredictedState, Trajectory, PhysicsQuery, PhysicsAnswer, WorldEntity, EntityRelation, ConsistencyCheck, DreamResult, WorldModelSystemConfig, WorldModelEventHandler } from './types.js';
+import { LatentEncoder } from './encoder.js';
+import { LatentDecoder, TextDecoding, StateDecoding } from './decoder.js';
+import { WorldModelPredictor } from './predictor.js';
+import { DigitalTwinInstance, DigitalTwinManager } from './digital-twin.js';
+export declare class WorldModelSystem {
+    private config;
+    readonly encoder: LatentEncoder;
+    readonly decoder: LatentDecoder;
+    readonly predictor: WorldModelPredictor;
+    readonly twinManager: DigitalTwinManager;
+    private running;
+    private entities;
+    private relations;
+    private eventHandlers;
+    private dreamConfig;
+    private pendingConsolidation;
+    private dreamHistory;
+    private consistencyTimer;
+    constructor(config?: Partial<WorldModelSystemConfig>);
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    /**
+     * Encode input to latent space
+     */
+    encode(input: MultimodalInput): LatentState;
+    /**
+     * Fuse multiple states
+     */
+    fuse(states: LatentState[]): LatentState;
+    /**
+     * Decode to text
+     */
+    decodeToText(state: LatentState): TextDecoding;
+    /**
+     * Decode to structured state
+     */
+    decodeToState(state: LatentState): StateDecoding;
+    /**
+     * Calculate similarity between states
+     */
+    similarity(a: LatentState, b: LatentState): number;
+    /**
+     * Interpolate between states
+     */
+    interpolate(a: LatentState, b: LatentState, t: number): LatentState;
+    /**
+     * Predict next state
+     */
+    predict(currentState: LatentState, action: Action): PredictedState;
+    /**
+     * Simulate trajectory
+     */
+    simulate(initialState: LatentState, actions: Action[], horizon?: number): Trajectory;
+    /**
+     * Get uncertainty of prediction
+     */
+    uncertainty(prediction: PredictedState): number;
+    /**
+     * Physics/common sense reasoning
+     */
+    reason(query: PhysicsQuery): PhysicsAnswer;
+    /**
+     * Create a digital twin
+     */
+    createTwin(realSystemId: string, name: string): DigitalTwinInstance;
+    /**
+     * Get twin by ID
+     */
+    getTwin(id: string): DigitalTwinInstance | undefined;
+    /**
+     * Get all twins
+     */
+    getAllTwins(): DigitalTwinInstance[];
+    /**
+     * Remove twin
+     */
+    removeTwin(id: string): boolean;
+    /**
+     * Add entity to world model
+     */
+    addEntity(entity: WorldEntity): void;
+    /**
+     * Get entity
+     */
+    getEntity(id: string): WorldEntity | undefined;
+    /**
+     * Update entity
+     */
+    updateEntity(id: string, updates: Partial<WorldEntity>): boolean;
+    /**
+     * Remove entity
+     */
+    removeEntity(id: string): boolean;
+    /**
+     * Add relation between entities
+     */
+    addRelation(relation: EntityRelation): void;
+    /**
+     * Remove relation
+     */
+    removeRelation(id: string): boolean;
+    /**
+     * Check world model consistency
+     */
+    checkConsistency(): ConsistencyCheck;
+    /**
+     * Run consistency check (called by timer)
+     */
+    private runConsistencyCheck;
+    /**
+     * Auto-repair consistency issues
+     */
+    private autoRepair;
+    /**
+     * Detect circular relations
+     */
+    private detectCircularRelations;
+    /**
+     * Check if should dream
+     */
+    shouldDream(energy?: number): boolean;
+    /**
+     * Run dream cycle
+     */
+    dream(): Promise<DreamResult>;
+    /**
+     * Slow-wave replay phase
+     */
+    private slowWaveReplay;
+    /**
+     * REM abstraction phase
+     */
+    private remAbstraction;
+    /**
+     * Find sequence patterns in pending consolidation
+     */
+    private findSequencePatterns;
+    /**
+     * Find structural patterns
+     */
+    private findStructuralPatterns;
+    /**
+     * Consolidation phase
+     */
+    private consolidate;
+    /**
+     * Find similar state pairs
+     */
+    private findSimilarStatePairs;
+    /**
+     * Sleep helper
+     */
+    private sleep;
+    on(handler: WorldModelEventHandler): () => void;
+    private emit;
+    private setupEventForwarding;
+    stats(): {
+        encoder: ReturnType<LatentEncoder['stats']>;
+        decoder: ReturnType<LatentDecoder['stats']>;
+        predictor: ReturnType<WorldModelPredictor['stats']>;
+        twins: ReturnType<DigitalTwinManager['getOverallHealth']>;
+        entities: number;
+        relations: number;
+        pendingConsolidation: number;
+        dreamCount: number;
+    };
+    private mergeConfig;
+}
+export declare function createWorldModelSystem(config?: Partial<WorldModelSystemConfig>): WorldModelSystem;
+export declare function getWorldModelSystem(config?: Partial<WorldModelSystemConfig>): WorldModelSystem;
+export declare function resetWorldModelSystem(): void;