genesis-ai-cli 7.4.5

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

@@ -0,0 +1,772 @@
+"use strict";
+/**
+ * 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();
+ * ```
+ */
+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.WorldModelSystem = exports.DEFAULT_VALUE_CONFIG = exports.createValueGuidedJEPA = exports.resetValueFunction = exports.getValueFunction = exports.createValueFunction = exports.ValueGuidedJEPA = exports.ValueFunction = exports.createDigitalTwinManager = exports.createDigitalTwin = exports.DigitalTwinManager = exports.DigitalTwinInstance = exports.createAction = exports.createWorldModelPredictor = exports.WorldModelPredictor = exports.createLatentDecoder = exports.LatentDecoder = exports.createLatentEncoder = exports.LatentEncoder = void 0;
+exports.createWorldModelSystem = createWorldModelSystem;
+exports.getWorldModelSystem = getWorldModelSystem;
+exports.resetWorldModelSystem = resetWorldModelSystem;
+// Re-export types
+__exportStar(require("./types.js"), exports);
+// Re-export components
+var encoder_js_1 = require("./encoder.js");
+Object.defineProperty(exports, "LatentEncoder", { enumerable: true, get: function () { return encoder_js_1.LatentEncoder; } });
+Object.defineProperty(exports, "createLatentEncoder", { enumerable: true, get: function () { return encoder_js_1.createLatentEncoder; } });
+var decoder_js_1 = require("./decoder.js");
+Object.defineProperty(exports, "LatentDecoder", { enumerable: true, get: function () { return decoder_js_1.LatentDecoder; } });
+Object.defineProperty(exports, "createLatentDecoder", { enumerable: true, get: function () { return decoder_js_1.createLatentDecoder; } });
+var predictor_js_1 = require("./predictor.js");
+Object.defineProperty(exports, "WorldModelPredictor", { enumerable: true, get: function () { return predictor_js_1.WorldModelPredictor; } });
+Object.defineProperty(exports, "createWorldModelPredictor", { enumerable: true, get: function () { return predictor_js_1.createWorldModelPredictor; } });
+Object.defineProperty(exports, "createAction", { enumerable: true, get: function () { return predictor_js_1.createAction; } });
+var digital_twin_js_1 = require("./digital-twin.js");
+Object.defineProperty(exports, "DigitalTwinInstance", { enumerable: true, get: function () { return digital_twin_js_1.DigitalTwinInstance; } });
+Object.defineProperty(exports, "DigitalTwinManager", { enumerable: true, get: function () { return digital_twin_js_1.DigitalTwinManager; } });
+Object.defineProperty(exports, "createDigitalTwin", { enumerable: true, get: function () { return digital_twin_js_1.createDigitalTwin; } });
+Object.defineProperty(exports, "createDigitalTwinManager", { enumerable: true, get: function () { return digital_twin_js_1.createDigitalTwinManager; } });
+// Value-Guided JEPA (Genesis 6.2)
+var value_jepa_js_1 = require("./value-jepa.js");
+Object.defineProperty(exports, "ValueFunction", { enumerable: true, get: function () { return value_jepa_js_1.ValueFunction; } });
+Object.defineProperty(exports, "ValueGuidedJEPA", { enumerable: true, get: function () { return value_jepa_js_1.ValueGuidedJEPA; } });
+Object.defineProperty(exports, "createValueFunction", { enumerable: true, get: function () { return value_jepa_js_1.createValueFunction; } });
+Object.defineProperty(exports, "getValueFunction", { enumerable: true, get: function () { return value_jepa_js_1.getValueFunction; } });
+Object.defineProperty(exports, "resetValueFunction", { enumerable: true, get: function () { return value_jepa_js_1.resetValueFunction; } });
+Object.defineProperty(exports, "createValueGuidedJEPA", { enumerable: true, get: function () { return value_jepa_js_1.createValueGuidedJEPA; } });
+Object.defineProperty(exports, "DEFAULT_VALUE_CONFIG", { enumerable: true, get: function () { return value_jepa_js_1.DEFAULT_VALUE_CONFIG; } });
+const types_js_1 = require("./types.js");
+const encoder_js_2 = require("./encoder.js");
+const decoder_js_2 = require("./decoder.js");
+const predictor_js_2 = require("./predictor.js");
+const digital_twin_js_2 = require("./digital-twin.js");
+// ============================================================================
+// World Model System
+// ============================================================================
+class WorldModelSystem {
+    config;
+    // Components
+    encoder;
+    decoder;
+    predictor;
+    twinManager;
+    // State
+    running = false;
+    entities = new Map();
+    relations = new Map();
+    eventHandlers = new Set();
+    // Dream state
+    dreamConfig;
+    pendingConsolidation = [];
+    dreamHistory = [];
+    // Consistency check timer
+    consistencyTimer = null;
+    constructor(config = {}) {
+        this.config = this.mergeConfig(config);
+        this.dreamConfig = { ...types_js_1.DEFAULT_DREAM_CONFIG, ...config.dream };
+        // Create components
+        this.encoder = (0, encoder_js_2.createLatentEncoder)(this.config.encoder);
+        this.decoder = (0, decoder_js_2.createLatentDecoder)();
+        this.predictor = (0, predictor_js_2.createWorldModelPredictor)(this.config.predictor);
+        this.twinManager = (0, digital_twin_js_2.createDigitalTwinManager)();
+        // Setup event forwarding
+        this.setupEventForwarding();
+    }
+    // ============================================================================
+    // Lifecycle
+    // ============================================================================
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        // Start consistency checking if enabled
+        if (this.config.consistencyCheckEnabled) {
+            this.consistencyTimer = setInterval(() => this.runConsistencyCheck(), this.config.predictor.consistencyCheckIntervalMs || 5000);
+        }
+    }
+    stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        // Stop consistency checking
+        if (this.consistencyTimer) {
+            clearInterval(this.consistencyTimer);
+            this.consistencyTimer = null;
+        }
+        // Stop all twins
+        for (const twin of this.twinManager.getAllTwins()) {
+            twin.stopSync();
+        }
+    }
+    isRunning() {
+        return this.running;
+    }
+    // ============================================================================
+    // Encoding / Decoding
+    // ============================================================================
+    /**
+     * Encode input to latent space
+     */
+    encode(input) {
+        const state = this.encoder.encode(input);
+        // Add to pending consolidation
+        this.pendingConsolidation.push(state);
+        if (this.pendingConsolidation.length > 1000) {
+            this.pendingConsolidation.shift();
+        }
+        return state;
+    }
+    /**
+     * Fuse multiple states
+     */
+    fuse(states) {
+        return this.encoder.fuse(states);
+    }
+    /**
+     * Decode to text
+     */
+    decodeToText(state) {
+        return this.decoder.decodeToText(state);
+    }
+    /**
+     * Decode to structured state
+     */
+    decodeToState(state) {
+        return this.decoder.decodeToState(state);
+    }
+    /**
+     * Calculate similarity between states
+     */
+    similarity(a, b) {
+        return this.encoder.similarity(a, b);
+    }
+    /**
+     * Interpolate between states
+     */
+    interpolate(a, b, t) {
+        return this.decoder.interpolate(a, b, t);
+    }
+    // ============================================================================
+    // Prediction / Simulation
+    // ============================================================================
+    /**
+     * Predict next state
+     */
+    predict(currentState, action) {
+        const prediction = this.predictor.predict(currentState, action);
+        this.emit({ type: 'state_predicted', timestamp: new Date(), data: prediction });
+        return prediction;
+    }
+    /**
+     * Simulate trajectory
+     */
+    simulate(initialState, actions, horizon) {
+        const trajectory = this.predictor.simulate(initialState, actions, horizon);
+        this.emit({ type: 'simulation_complete', timestamp: new Date(), data: trajectory });
+        return trajectory;
+    }
+    /**
+     * Get uncertainty of prediction
+     */
+    uncertainty(prediction) {
+        return this.predictor.uncertainty(prediction);
+    }
+    /**
+     * Physics/common sense reasoning
+     */
+    reason(query) {
+        return this.predictor.reason(query);
+    }
+    // ============================================================================
+    // Digital Twins
+    // ============================================================================
+    /**
+     * Create a digital twin
+     */
+    createTwin(realSystemId, name) {
+        const twin = this.twinManager.createTwin(realSystemId, name, this.config.twin);
+        // Forward events
+        twin.on((event) => {
+            this.emit({
+                type: event.type === 'synced' ? 'twin_synced' : 'twin_drifted',
+                timestamp: new Date(),
+                data: { twinId: twin.id, eventData: event.data },
+            });
+        });
+        return twin;
+    }
+    /**
+     * Get twin by ID
+     */
+    getTwin(id) {
+        return this.twinManager.getTwin(id);
+    }
+    /**
+     * Get all twins
+     */
+    getAllTwins() {
+        return this.twinManager.getAllTwins();
+    }
+    /**
+     * Remove twin
+     */
+    removeTwin(id) {
+        return this.twinManager.removeTwin(id);
+    }
+    // ============================================================================
+    // Entity Management
+    // ============================================================================
+    /**
+     * Add entity to world model
+     */
+    addEntity(entity) {
+        this.entities.set(entity.id, entity);
+        this.predictor.addEntity(entity);
+        this.emit({ type: 'entity_created', timestamp: new Date(), data: entity });
+    }
+    /**
+     * Get entity
+     */
+    getEntity(id) {
+        return this.entities.get(id);
+    }
+    /**
+     * Update entity
+     */
+    updateEntity(id, updates) {
+        const entity = this.entities.get(id);
+        if (!entity)
+            return false;
+        Object.assign(entity, updates, { lastUpdated: new Date() });
+        this.emit({ type: 'entity_updated', timestamp: new Date(), data: entity });
+        return true;
+    }
+    /**
+     * Remove entity
+     */
+    removeEntity(id) {
+        const removed = this.entities.delete(id);
+        if (removed) {
+            this.predictor.removeEntity(id);
+            this.emit({ type: 'entity_deleted', timestamp: new Date(), data: { id } });
+        }
+        return removed;
+    }
+    /**
+     * Add relation between entities
+     */
+    addRelation(relation) {
+        this.relations.set(relation.id, relation);
+        this.predictor.addRelation(relation);
+        this.emit({ type: 'relation_added', timestamp: new Date(), data: relation });
+    }
+    /**
+     * Remove relation
+     */
+    removeRelation(id) {
+        const removed = this.relations.delete(id);
+        if (removed) {
+            this.emit({ type: 'relation_removed', timestamp: new Date(), data: { id } });
+        }
+        return removed;
+    }
+    // ============================================================================
+    // Consistency (INV-008)
+    // ============================================================================
+    /**
+     * Check world model consistency
+     */
+    checkConsistency() {
+        const issues = [];
+        // Check entity consistency
+        for (const [id, entity] of this.entities) {
+            // Check for orphan relations
+            for (const relation of entity.relations) {
+                if (!this.entities.has(relation.target)) {
+                    issues.push({
+                        type: 'orphan',
+                        severity: 'medium',
+                        description: `Entity ${id} has relation to non-existent entity ${relation.target}`,
+                        affectedEntities: [id, relation.target],
+                    });
+                }
+            }
+            // Check for stale entities
+            const age = Date.now() - entity.lastUpdated.getTime();
+            if (age > this.config.entityTTL) {
+                issues.push({
+                    type: 'drift',
+                    severity: 'low',
+                    description: `Entity ${id} has not been updated in ${Math.round(age / 1000)}s`,
+                    affectedEntities: [id],
+                    suggestedFix: 'Update entity or remove if no longer relevant',
+                });
+            }
+        }
+        // Check twin consistency
+        for (const twin of this.twinManager.getAllTwins()) {
+            const twinCheck = twin.checkConsistency();
+            issues.push(...twinCheck.issues);
+        }
+        // Check for circular relations
+        const circularRelations = this.detectCircularRelations();
+        if (circularRelations.length > 0) {
+            issues.push({
+                type: 'cycle',
+                severity: 'medium',
+                description: `Circular relations detected`,
+                affectedEntities: circularRelations,
+            });
+        }
+        const inconsistencyScore = issues.reduce((sum, issue) => {
+            const severityScores = { low: 0.1, medium: 0.3, high: 0.6, critical: 1.0 };
+            return sum + severityScores[issue.severity];
+        }, 0);
+        const check = {
+            id: `check-${Date.now()}`,
+            timestamp: new Date(),
+            passed: issues.length === 0,
+            checks: {
+                stateConsistency: issues.filter((i) => i.type === 'contradiction').length === 0,
+                temporalConsistency: issues.filter((i) => i.type === 'drift').length === 0,
+                causalConsistency: issues.filter((i) => i.type === 'gap').length === 0,
+                entityConsistency: issues.filter((i) => i.type === 'orphan').length === 0,
+            },
+            issues,
+            inconsistencyScore: Math.min(1, inconsistencyScore),
+        };
+        this.emit({ type: 'consistency_check', timestamp: new Date(), data: check });
+        if (!check.passed) {
+            this.emit({ type: 'consistency_violation', timestamp: new Date(), data: check });
+        }
+        return check;
+    }
+    /**
+     * Run consistency check (called by timer)
+     */
+    runConsistencyCheck() {
+        const check = this.checkConsistency();
+        // Auto-repair if enabled
+        if (!check.passed && this.config.autoRepairEnabled) {
+            this.autoRepair(check.issues);
+        }
+    }
+    /**
+     * Auto-repair consistency issues
+     */
+    autoRepair(issues) {
+        for (const issue of issues) {
+            switch (issue.type) {
+                case 'orphan':
+                    // Remove orphan relations
+                    for (const entityId of issue.affectedEntities) {
+                        const entity = this.entities.get(entityId);
+                        if (entity) {
+                            entity.relations = entity.relations.filter((r) => this.entities.has(r.target));
+                        }
+                    }
+                    break;
+                case 'drift':
+                    // Remove stale entities
+                    for (const entityId of issue.affectedEntities) {
+                        const entity = this.entities.get(entityId);
+                        if (entity && entity.confidence < 0.3) {
+                            this.removeEntity(entityId);
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+    /**
+     * Detect circular relations
+     */
+    detectCircularRelations() {
+        const visited = new Set();
+        const stack = new Set();
+        const circular = [];
+        const dfs = (entityId) => {
+            if (stack.has(entityId)) {
+                circular.push(entityId);
+                return true;
+            }
+            if (visited.has(entityId))
+                return false;
+            visited.add(entityId);
+            stack.add(entityId);
+            const entity = this.entities.get(entityId);
+            if (entity) {
+                for (const relation of entity.relations) {
+                    if (dfs(relation.target)) {
+                        circular.push(entityId);
+                    }
+                }
+            }
+            stack.delete(entityId);
+            return false;
+        };
+        for (const entityId of this.entities.keys()) {
+            dfs(entityId);
+        }
+        return [...new Set(circular)];
+    }
+    // ============================================================================
+    // Dream Mode
+    // ============================================================================
+    /**
+     * Check if should dream
+     */
+    shouldDream(energy) {
+        if (energy !== undefined && energy < this.dreamConfig.triggerThreshold) {
+            return true;
+        }
+        if (this.pendingConsolidation.length >= this.dreamConfig.minPendingMemories) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Run dream cycle
+     */
+    async dream() {
+        const startTime = new Date();
+        this.emit({ type: 'dream_started', timestamp: startTime, data: {} });
+        // Phase 1: Slow-wave replay
+        const slowWaveResult = await this.slowWaveReplay();
+        // Phase 2: REM abstraction
+        const remResult = await this.remAbstraction();
+        // Phase 3: Consolidation
+        const consolidationResult = await this.consolidate();
+        const endTime = new Date();
+        const dreamResult = {
+            startTime,
+            endTime,
+            duration: endTime.getTime() - startTime.getTime(),
+            slowWaveReplay: slowWaveResult,
+            remAbstraction: remResult,
+            consolidation: consolidationResult,
+            memoriesConsolidated: consolidationResult.strengthened,
+            patternsExtracted: remResult.patternsFound.length,
+            modelImproved: consolidationResult.newConnections > 0,
+        };
+        this.dreamHistory.push(dreamResult);
+        if (this.dreamHistory.length > 100) {
+            this.dreamHistory.shift();
+        }
+        // Clear pending consolidation
+        this.pendingConsolidation = [];
+        this.emit({ type: 'dream_complete', timestamp: endTime, data: dreamResult });
+        return dreamResult;
+    }
+    /**
+     * Slow-wave replay phase
+     */
+    async slowWaveReplay() {
+        // Simulate slow-wave sleep - replay recent experiences
+        const experiences = this.pendingConsolidation.slice(-50);
+        // Sort by confidence (strongest memories)
+        experiences.sort((a, b) => b.confidence - a.confidence);
+        const strongestMemories = experiences
+            .slice(0, 10)
+            .map((e) => e.sourceId);
+        // Simulate replay time
+        await this.sleep(Math.min(this.dreamConfig.slowWaveDuration, 1000));
+        return {
+            experiencesReplayed: experiences.length,
+            strongestMemories,
+            replayDuration: this.dreamConfig.slowWaveDuration,
+        };
+    }
+    /**
+     * REM abstraction phase
+     */
+    async remAbstraction() {
+        const patterns = [];
+        // Find sequence patterns
+        const sequences = this.findSequencePatterns();
+        patterns.push(...sequences);
+        // Find structural patterns
+        const structural = this.findStructuralPatterns();
+        patterns.push(...structural);
+        // Creative combinations (random associations)
+        let creativeCombinations = 0;
+        for (let i = 0; i < 5; i++) {
+            if (this.pendingConsolidation.length >= 2) {
+                const idx1 = Math.floor(Math.random() * this.pendingConsolidation.length);
+                const idx2 = Math.floor(Math.random() * this.pendingConsolidation.length);
+                if (idx1 !== idx2) {
+                    const fused = this.encoder.fuse([
+                        this.pendingConsolidation[idx1],
+                        this.pendingConsolidation[idx2],
+                    ]);
+                    creativeCombinations++;
+                }
+            }
+        }
+        // Simulate abstraction time
+        await this.sleep(Math.min(this.dreamConfig.remDuration, 1000));
+        return {
+            patternsFound: patterns,
+            abstractionLevel: patterns.length > 5 ? 0.8 : patterns.length * 0.15,
+            creativeCombinations,
+        };
+    }
+    /**
+     * Find sequence patterns in pending consolidation
+     */
+    findSequencePatterns() {
+        const patterns = [];
+        if (this.pendingConsolidation.length < 3)
+            return patterns;
+        // Look for similar consecutive states
+        for (let i = 0; i < this.pendingConsolidation.length - 2; i++) {
+            const sim1 = this.encoder.similarity(this.pendingConsolidation[i], this.pendingConsolidation[i + 1]);
+            const sim2 = this.encoder.similarity(this.pendingConsolidation[i + 1], this.pendingConsolidation[i + 2]);
+            if (sim1 > 0.7 && sim2 > 0.7) {
+                patterns.push({
+                    id: `seq-${i}`,
+                    type: 'sequence',
+                    elements: [
+                        this.pendingConsolidation[i].sourceId,
+                        this.pendingConsolidation[i + 1].sourceId,
+                        this.pendingConsolidation[i + 2].sourceId,
+                    ],
+                    confidence: (sim1 + sim2) / 2,
+                    novelty: 0.5,
+                });
+            }
+        }
+        return patterns;
+    }
+    /**
+     * Find structural patterns
+     */
+    findStructuralPatterns() {
+        const patterns = [];
+        // Group by modality
+        const modalityGroups = new Map();
+        for (const state of this.pendingConsolidation) {
+            const group = modalityGroups.get(state.sourceModality) || [];
+            group.push(state);
+            modalityGroups.set(state.sourceModality, group);
+        }
+        // Find patterns within modalities
+        for (const [modality, states] of modalityGroups) {
+            if (states.length >= 3) {
+                patterns.push({
+                    id: `struct-${modality}`,
+                    type: 'structure',
+                    elements: states.slice(0, 5).map((s) => s.sourceId),
+                    confidence: 0.6,
+                    novelty: 0.4,
+                });
+            }
+        }
+        return patterns;
+    }
+    /**
+     * Consolidation phase
+     */
+    async consolidate() {
+        let modelUpdates = 0;
+        let pruned = 0;
+        let strengthened = 0;
+        let newConnections = 0;
+        // Strengthen frequently occurring patterns
+        for (const state of this.pendingConsolidation) {
+            if (state.confidence > 0.7) {
+                strengthened++;
+            }
+        }
+        // Prune low-confidence states
+        const beforeCount = this.entities.size;
+        for (const [id, entity] of this.entities) {
+            if (entity.confidence < 0.2) {
+                const age = Date.now() - entity.lastUpdated.getTime();
+                if (age > this.config.entityTTL / 2) {
+                    this.entities.delete(id);
+                    pruned++;
+                }
+            }
+        }
+        // Create new connections based on patterns
+        const similarPairs = this.findSimilarStatePairs();
+        for (const [s1, s2] of similarPairs) {
+            newConnections++;
+        }
+        modelUpdates = strengthened + pruned + newConnections;
+        // Simulate consolidation time
+        await this.sleep(Math.min(this.dreamConfig.consolidationDuration, 500));
+        return {
+            modelUpdates,
+            pruned,
+            strengthened,
+            newConnections,
+        };
+    }
+    /**
+     * Find similar state pairs
+     */
+    findSimilarStatePairs() {
+        const pairs = [];
+        for (let i = 0; i < this.pendingConsolidation.length; i++) {
+            for (let j = i + 1; j < this.pendingConsolidation.length; j++) {
+                const sim = this.encoder.similarity(this.pendingConsolidation[i], this.pendingConsolidation[j]);
+                if (sim > 0.8) {
+                    pairs.push([this.pendingConsolidation[i], this.pendingConsolidation[j]]);
+                }
+            }
+        }
+        return pairs.slice(0, 10); // Limit
+    }
+    /**
+     * Sleep helper
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    // ============================================================================
+    // Events
+    // ============================================================================
+    on(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    emit(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch (err) {
+                console.error('World model event handler error:', err);
+            }
+        }
+    }
+    setupEventForwarding() {
+        // Forward encoder events
+        this.encoder.on((event) => {
+            if (event.type === 'encoded') {
+                this.emit({
+                    type: 'entity_created',
+                    timestamp: new Date(),
+                    data: event.data,
+                });
+            }
+        });
+        // Forward predictor events
+        this.predictor.on((event) => {
+            if (event.type === 'prediction_made') {
+                this.emit({
+                    type: 'state_predicted',
+                    timestamp: new Date(),
+                    data: event.data,
+                });
+            }
+        });
+    }
+    // ============================================================================
+    // Stats
+    // ============================================================================
+    stats() {
+        return {
+            encoder: this.encoder.stats(),
+            decoder: this.decoder.stats(),
+            predictor: this.predictor.stats(),
+            twins: this.twinManager.getOverallHealth(),
+            entities: this.entities.size,
+            relations: this.relations.size,
+            pendingConsolidation: this.pendingConsolidation.length,
+            dreamCount: this.dreamHistory.length,
+        };
+    }
+    // ============================================================================
+    // Helpers
+    // ============================================================================
+    mergeConfig(partial) {
+        return {
+            encoder: { ...types_js_1.DEFAULT_WORLD_MODEL_SYSTEM_CONFIG.encoder, ...partial.encoder },
+            predictor: { ...types_js_1.DEFAULT_WORLD_MODEL_SYSTEM_CONFIG.predictor, ...partial.predictor },
+            twin: { ...types_js_1.DEFAULT_WORLD_MODEL_SYSTEM_CONFIG.twin, ...partial.twin },
+            dream: { ...types_js_1.DEFAULT_WORLD_MODEL_SYSTEM_CONFIG.dream, ...partial.dream },
+            maxEntities: partial.maxEntities ?? types_js_1.DEFAULT_WORLD_MODEL_SYSTEM_CONFIG.maxEntities,
+            entityTTL: partial.entityTTL ?? types_js_1.DEFAULT_WORLD_MODEL_SYSTEM_CONFIG.entityTTL,
+            consistencyCheckEnabled: partial.consistencyCheckEnabled ?? types_js_1.DEFAULT_WORLD_MODEL_SYSTEM_CONFIG.consistencyCheckEnabled,
+            autoRepairEnabled: partial.autoRepairEnabled ?? types_js_1.DEFAULT_WORLD_MODEL_SYSTEM_CONFIG.autoRepairEnabled,
+        };
+    }
+}
+exports.WorldModelSystem = WorldModelSystem;
+// ============================================================================
+// Factory
+// ============================================================================
+function createWorldModelSystem(config) {
+    return new WorldModelSystem(config);
+}
+// ============================================================================
+// Singleton Instance (optional)
+// ============================================================================
+let worldModelInstance = null;
+function getWorldModelSystem(config) {
+    if (!worldModelInstance) {
+        worldModelInstance = createWorldModelSystem(config);
+    }
+    return worldModelInstance;
+}
+function resetWorldModelSystem() {
+    if (worldModelInstance) {
+        worldModelInstance.stop();
+        worldModelInstance = null;
+    }
+}