genesis-ai-cli 7.4.5

package/dist/src/brain/index.js

@@ -0,0 +1,843 @@
+"use strict";
+/**
+ * Genesis Phase 10 - Brain Module
+ *
+ * The Neural Integration Layer - connects all 17 modules.
+ *
+ * Based on:
+ * - arXiv:2508.13171 (Cognitive Workspace) - 54-60% memory reuse
+ * - LangGraph Supervisor Pattern - Command({ goto, update })
+ * - IWMT (Integrated World Modeling Theory) - GWT + IIT + Active Inference
+ *
+ * Architecture:
+ * ```
+ * ┌─────────────────────────────────────────────────────────────────────┐
+ * │                           BRAIN                                     │
+ * │                                                                     │
+ * │  ┌──────────────────────────────────────────────────────────────┐  │
+ * │  │                  COGNITIVE WORKSPACE                          │  │
+ * │  │  Immediate (8K) → Task (64K) → Episodic (256K) → Semantic    │  │
+ * │  │  recall() / anticipate() / consolidate()                      │  │
+ * │  └──────────────────────────────────────────────────────────────┘  │
+ * │                              │                                      │
+ * │  ┌──────────────────────────────────────────────────────────────┐  │
+ * │  │                    SUPERVISOR                                 │  │
+ * │  │  memory → llm → grounding → tools → done                      │  │
+ * │  │  Command({ goto, update })                                    │  │
+ * │  └──────────────────────────────────────────────────────────────┘  │
+ * │                              │                                      │
+ * │  ┌──────────────────────────────────────────────────────────────┐  │
+ * │  │               GLOBAL WORKSPACE (φ Monitor)                    │  │
+ * │  │  broadcast() → all modules receive                            │  │
+ * │  └──────────────────────────────────────────────────────────────┘  │
+ * │                              │                                      │
+ * │  ┌──────────────────────────────────────────────────────────────┐  │
+ * │  │                   HEALING LOOP                                │  │
+ * │  │  detect() → diagnose() → fix() → verify() → retry()          │  │
+ * │  └──────────────────────────────────────────────────────────────┘  │
+ * └─────────────────────────────────────────────────────────────────────┘
+ * ```
+ */
+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.Brain = void 0;
+exports.createBrain = createBrain;
+exports.getBrain = getBrain;
+exports.resetBrain = resetBrain;
+const types_js_1 = require("./types.js");
+// Module imports
+const cognitive_workspace_js_1 = require("../memory/cognitive-workspace.js");
+const global_workspace_js_1 = require("../consciousness/global-workspace.js");
+const phi_monitor_js_1 = require("../consciousness/phi-monitor.js");
+const index_js_1 = require("../llm/index.js");
+const dispatcher_js_1 = require("../cli/dispatcher.js");
+const index_js_2 = require("../healing/index.js");
+const index_js_3 = require("../grounding/index.js");
+// ============================================================================
+// Brain Class
+// ============================================================================
+class Brain {
+    config;
+    // Core modules
+    workspace;
+    globalWorkspace;
+    phiMonitor;
+    llm;
+    dispatcher;
+    grounding;
+    // State
+    running = false;
+    currentState = null;
+    systemPrompt = ''; // v7.2: Cached system prompt with tools
+    // Metrics
+    metrics = this.createInitialMetrics();
+    // Event handlers
+    eventHandlers = new Set();
+    constructor(config = {}) {
+        this.config = { ...types_js_1.DEFAULT_BRAIN_CONFIG, ...config };
+        // Initialize modules
+        this.workspace = (0, cognitive_workspace_js_1.getCognitiveWorkspace)({
+            maxItems: 7,
+            maxTokens: this.config.memory.maxContextTokens,
+        });
+        this.globalWorkspace = (0, global_workspace_js_1.createGlobalWorkspace)({
+            capacity: 7,
+            selectionIntervalMs: 100,
+        });
+        this.phiMonitor = (0, phi_monitor_js_1.createPhiMonitor)({
+            minPhi: this.config.consciousness.phiThreshold,
+            updateIntervalMs: 5000,
+        });
+        this.llm = (0, index_js_1.getLLMBridge)();
+        this.dispatcher = new dispatcher_js_1.ToolDispatcher({ verbose: false });
+        this.grounding = (0, index_js_3.getGroundingSystem)();
+    }
+    // ============================================================================
+    // Lifecycle
+    // ============================================================================
+    /**
+     * Start the brain (initializes consciousness monitoring)
+     */
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        // v7.2: Build system prompt with available tools
+        await this.initializeSystemPrompt();
+        // Start consciousness monitoring
+        if (this.config.consciousness.enabled) {
+            this.phiMonitor.start();
+            this.globalWorkspace.start();
+        }
+        // Start memory curation
+        if (this.config.memory.enabled) {
+            this.workspace.startAutoCuration();
+        }
+        this.emit({ type: 'cycle_start', timestamp: new Date(), data: { status: 'brain_started' } });
+    }
+    /**
+     * v7.2: Build system prompt with all available tools
+     */
+    async initializeSystemPrompt() {
+        if (this.systemPrompt)
+            return; // Already built
+        const tools = this.dispatcher.listToolsWithSchemas();
+        // Convert to format expected by buildSystemPrompt
+        const mcpTools = tools.mcp;
+        const localTools = tools.local;
+        this.systemPrompt = await (0, index_js_1.buildSystemPrompt)(mcpTools, localTools, true);
+    }
+    /**
+     * Stop the brain
+     */
+    stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        this.phiMonitor.stop();
+        this.globalWorkspace.stop();
+        this.workspace.stopAutoCuration();
+        this.emit({ type: 'cycle_complete', timestamp: new Date(), data: { status: 'brain_stopped' } });
+    }
+    /**
+     * Check if brain is running
+     */
+    isRunning() {
+        return this.running;
+    }
+    // ============================================================================
+    // Main Processing Loop
+    // ============================================================================
+    /**
+     * Process an input through the brain
+     *
+     * This is the main entry point. It follows the supervisor pattern:
+     * memory → llm → grounding → tools → done
+     *
+     * Each module can route to another via Command({ goto, update })
+     */
+    async process(input) {
+        const startTime = Date.now();
+        // Initialize state
+        let state = {
+            query: input,
+            context: this.createEmptyContext(),
+            response: '',
+            toolCalls: [],
+            toolResults: [],
+            phi: this.getCurrentPhi(),
+            ignited: false,
+            verified: false,
+            healingAttempts: 0,
+            startTime,
+            moduleHistory: [],
+        };
+        // Initial command: start with memory
+        let command = {
+            goto: this.config.memory.enabled ? 'memory' : 'llm',
+            update: {},
+            reason: 'initial',
+        };
+        this.emit({ type: 'cycle_start', timestamp: new Date(), data: { query: input } });
+        // Supervisor loop
+        let transitions = 0;
+        while (command.goto !== 'done' && transitions < this.config.maxModuleTransitions) {
+            // Update state
+            state = { ...state, ...command.update };
+            state.moduleHistory.push(command.goto);
+            // Check timeout
+            if (Date.now() - startTime > this.config.maxCycleTime) {
+                command = { goto: 'done', update: { response: 'Processing timeout. Please try again.' } };
+                break;
+            }
+            try {
+                this.emit({ type: 'module_enter', timestamp: new Date(), data: { module: command.goto }, module: command.goto });
+                // Execute module
+                command = await this.step(command.goto, state);
+                this.emit({ type: 'module_exit', timestamp: new Date(), data: { module: command.goto, nextModule: command.goto }, module: command.goto });
+                // Broadcast to global workspace if enabled
+                if (this.config.consciousness.broadcastEnabled) {
+                    this.broadcast(state, command.goto);
+                }
+                transitions++;
+            }
+            catch (error) {
+                // Healing loop
+                if (this.config.healing.enabled && this.config.healing.autoHeal) {
+                    command = await this.heal(error, state);
+                }
+                else {
+                    command = {
+                        goto: 'done',
+                        update: {
+                            response: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                            error: error,
+                        },
+                    };
+                }
+            }
+        }
+        // Final state update
+        state = { ...state, ...command.update };
+        this.currentState = state;
+        // Update metrics
+        this.updateMetrics(state, transitions);
+        this.emit({ type: 'cycle_complete', timestamp: new Date(), data: { state, transitions } });
+        return state.response;
+    }
+    // ============================================================================
+    // Module Execution
+    // ============================================================================
+    /**
+     * Execute a single module step
+     */
+    async step(module, state) {
+        switch (module) {
+            case 'memory':
+                return this.stepMemory(state);
+            case 'llm':
+                return this.stepLLM(state);
+            case 'grounding':
+                return this.stepGrounding(state);
+            case 'tools':
+                return this.stepTools(state);
+            case 'healing':
+                return this.stepHealing(state);
+            case 'consciousness':
+                return this.stepConsciousness(state);
+            case 'kernel':
+                return this.stepKernel(state);
+            default:
+                return { goto: 'done', update: {} };
+        }
+    }
+    /**
+     * Memory module: recall context and anticipate needs
+     */
+    async stepMemory(state) {
+        this.emit({ type: 'memory_recall', timestamp: new Date(), data: { query: state.query } });
+        // Build anticipation context
+        const anticipationContext = {
+            task: state.query,
+            keywords: state.query.split(/\s+/).filter(w => w.length > 3),
+        };
+        // Anticipate needed memories (proactive retrieval)
+        if (this.config.memory.anticipationEnabled) {
+            try {
+                const anticipated = await this.workspace.anticipate(anticipationContext);
+                this.metrics.anticipationHits += anticipated.length;
+                this.emit({ type: 'memory_anticipate', timestamp: new Date(), data: { items: anticipated.length } });
+            }
+            catch {
+                // Anticipation failed, continue without it
+            }
+        }
+        // Build context from working memory
+        const context = this.buildContext(state);
+        // Track metrics
+        this.metrics.memoryRecalls++;
+        const wsMetrics = this.workspace.getMetrics();
+        this.metrics.memoryReuseRate = wsMetrics.reuseRate;
+        return {
+            goto: 'llm',
+            update: { context },
+            reason: 'context_retrieved',
+        };
+    }
+    /**
+     * LLM module: generate response
+     */
+    async stepLLM(state) {
+        this.emit({ type: 'llm_request', timestamp: new Date(), data: { query: state.query } });
+        // Build prompt with context
+        const contextStr = state.context.formatted || '';
+        const prompt = contextStr
+            ? `Context:\n${contextStr}\n\nUser: ${state.query}`
+            : state.query;
+        // Call LLM with system prompt that includes available tools
+        const response = await this.llm.chat(prompt, this.systemPrompt || undefined);
+        this.emit({ type: 'llm_response', timestamp: new Date(), data: { length: response.content.length } });
+        // Parse tool calls if any
+        const toolCalls = this.parseToolCalls(response.content);
+        // Decide next step
+        if (toolCalls.length > 0 && this.config.tools.enabled) {
+            return {
+                goto: 'tools',
+                update: { response: response.content, toolCalls },
+                reason: 'tool_calls_detected',
+            };
+        }
+        if (this.config.grounding.verifyAllResponses && this.config.grounding.enabled) {
+            return {
+                goto: 'grounding',
+                update: { response: response.content },
+                reason: 'verify_response',
+            };
+        }
+        return {
+            goto: 'done',
+            update: { response: response.content },
+            reason: 'response_complete',
+        };
+    }
+    /**
+     * Grounding module: verify claims in response
+     */
+    async stepGrounding(state) {
+        this.emit({ type: 'grounding_check', timestamp: new Date(), data: { response: state.response.slice(0, 100) } });
+        this.metrics.groundingChecks++;
+        // Ground the response
+        const claim = await this.grounding.ground(state.response);
+        // Check if needs human
+        if (this.grounding.needsHuman(claim)) {
+            this.metrics.humanConsultations++;
+            const question = this.grounding.getQuestion(claim);
+            return {
+                goto: 'done',
+                update: {
+                    response: state.response + `\n\n[Human verification needed: ${question}]`,
+                    verified: false,
+                },
+                reason: 'needs_human',
+            };
+        }
+        // Check confidence
+        if (claim.confidence < this.config.grounding.confidenceThreshold) {
+            this.metrics.groundingFailures++;
+            return {
+                goto: 'llm',
+                update: {
+                    groundingFeedback: `Low confidence (${(claim.confidence * 100).toFixed(0)}%). Please reconsider.`,
+                },
+                reason: 'low_confidence',
+            };
+        }
+        this.metrics.groundingPasses++;
+        return {
+            goto: 'done',
+            update: { verified: true },
+            reason: 'verified',
+        };
+    }
+    /**
+     * Tools module: execute tool calls
+     */
+    async stepTools(state) {
+        if (state.toolCalls.length === 0) {
+            return { goto: 'done', update: {}, reason: 'no_tools' };
+        }
+        // Limit executions
+        const callsToExecute = state.toolCalls.slice(0, this.config.tools.maxExecutions);
+        this.emit({ type: 'tool_execute', timestamp: new Date(), data: { count: callsToExecute.length } });
+        // Parse tool calls for dispatcher
+        const dispatcherCalls = this.dispatcher.parseToolCalls(state.response);
+        const results = [];
+        if (dispatcherCalls.length > 0) {
+            const dispatchResult = await this.dispatcher.dispatch(dispatcherCalls);
+            for (const r of dispatchResult.results) {
+                results.push({
+                    name: r.name,
+                    success: r.success,
+                    data: r.data,
+                    error: r.error,
+                    duration: r.duration,
+                });
+                if (r.success) {
+                    this.metrics.toolSuccesses++;
+                }
+                else {
+                    this.metrics.toolFailures++;
+                }
+            }
+        }
+        this.metrics.toolExecutions += results.length;
+        this.emit({ type: 'tool_complete', timestamp: new Date(), data: { results: results.length } });
+        // Format results for LLM
+        const resultsStr = results.map(r => r.success
+            ? `[${r.name}] SUCCESS: ${typeof r.data === 'string' ? r.data.slice(0, 500) : JSON.stringify(r.data).slice(0, 500)}`
+            : `[${r.name}] ERROR: ${r.error}`).join('\n\n');
+        return {
+            goto: 'llm',
+            update: {
+                toolResults: results,
+                context: {
+                    ...state.context,
+                    formatted: state.context.formatted + `\n\nTool Results:\n${resultsStr}`,
+                },
+            },
+            reason: 'tool_results',
+        };
+    }
+    /**
+     * Healing module: recover from errors
+     */
+    async stepHealing(state) {
+        if (!state.error) {
+            return { goto: 'done', update: {}, reason: 'no_error' };
+        }
+        this.emit({ type: 'healing_start', timestamp: new Date(), data: { error: state.error.message } });
+        this.metrics.healingAttempts++;
+        // Check if we've exceeded max attempts
+        if (state.healingAttempts >= this.config.healing.maxAttempts) {
+            this.metrics.healingFailures++;
+            return {
+                goto: 'done',
+                update: {
+                    response: `Unable to recover after ${state.healingAttempts} attempts. Error: ${state.error.message}`,
+                },
+                reason: 'max_attempts',
+            };
+        }
+        // Try to detect and fix
+        const hasErrors = index_js_2.healing.hasErrors(state.error.message);
+        if (hasErrors) {
+            const detected = index_js_2.healing.detectErrors(state.error.message);
+            if (detected.errors.length > 0) {
+                // Attempt auto-fix
+                const fixResult = await index_js_2.healing.autoFix(state.error.message);
+                if (fixResult.success) {
+                    this.metrics.healingSuccesses++;
+                    this.emit({ type: 'healing_complete', timestamp: new Date(), data: { success: true } });
+                    return {
+                        goto: 'llm',
+                        update: {
+                            error: undefined,
+                            healingAttempts: state.healingAttempts + 1,
+                            context: {
+                                ...state.context,
+                                formatted: state.context.formatted + '\n\n[Auto-fix applied]',
+                            },
+                        },
+                        reason: 'healed',
+                    };
+                }
+            }
+        }
+        this.metrics.healingFailures++;
+        this.emit({ type: 'healing_complete', timestamp: new Date(), data: { success: false } });
+        return {
+            goto: 'done',
+            update: {
+                response: `Error occurred: ${state.error.message}`,
+                healingAttempts: state.healingAttempts + 1,
+            },
+            reason: 'healing_failed',
+        };
+    }
+    /**
+     * Consciousness module: check φ level
+     */
+    async stepConsciousness(state) {
+        const phi = this.getCurrentPhi();
+        this.emit({ type: 'phi_update', timestamp: new Date(), data: { phi } });
+        if (phi < this.config.consciousness.phiThreshold) {
+            this.metrics.phiViolations++;
+            return {
+                goto: 'done',
+                update: {
+                    phi,
+                    response: `[Consciousness level (φ=${phi.toFixed(2)}) below threshold. System paused.]`,
+                },
+                reason: 'phi_low',
+            };
+        }
+        return {
+            goto: 'done',
+            update: { phi },
+            reason: 'phi_ok',
+        };
+    }
+    /**
+     * Kernel module: delegate to agent orchestration
+     * (Placeholder for future kernel integration)
+     */
+    async stepKernel(state) {
+        // For now, just pass through to LLM
+        return {
+            goto: 'llm',
+            update: {},
+            reason: 'kernel_passthrough',
+        };
+    }
+    // ============================================================================
+    // Healing Loop
+    // ============================================================================
+    /**
+     * Attempt to heal from an error
+     */
+    async heal(error, state) {
+        this.emit({ type: 'healing_start', timestamp: new Date(), data: { error: error.message } });
+        // Update state with error
+        state.error = error;
+        state.healingAttempts++;
+        // Check if healing is enabled
+        if (!this.config.healing.enabled) {
+            return {
+                goto: 'done',
+                update: {
+                    response: `Error: ${error.message}`,
+                    error,
+                },
+                reason: 'healing_disabled',
+            };
+        }
+        // Attempt healing
+        return this.stepHealing(state);
+    }
+    // ============================================================================
+    // Global Workspace Broadcasting
+    // ============================================================================
+    /**
+     * Broadcast to global workspace
+     */
+    broadcast(state, source) {
+        if (!this.config.consciousness.broadcastEnabled)
+            return;
+        const content = (0, global_workspace_js_1.createWorkspaceContent)(source, 'thought', {
+            query: state.query,
+            response: state.response?.slice(0, 200),
+            phi: state.phi,
+        }, {
+            salience: state.phi,
+            relevance: 0.8,
+        });
+        // Note: GlobalWorkspace.broadcast expects internal competition/selection
+        // For direct broadcasting, we would need to extend the API
+        // For now, we emit a brain event
+        this.metrics.broadcasts++;
+        this.emit({
+            type: 'broadcast',
+            timestamp: new Date(),
+            data: { source, content: state },
+            module: source,
+        });
+    }
+    // ============================================================================
+    // Context Building
+    // ============================================================================
+    /**
+     * Build context from cognitive workspace
+     */
+    buildContext(state) {
+        const items = this.workspace.getActive();
+        const context = {
+            immediate: [],
+            task: [],
+            episodic: [],
+            semantic: [],
+            formatted: '',
+            tokenEstimate: 0,
+            reuseRate: this.workspace.getMetrics().reuseRate,
+        };
+        // Categorize items
+        for (const item of items) {
+            const contextItem = {
+                id: item.id,
+                type: item.source === 'anticipate' ? 'task' : 'immediate',
+                content: JSON.stringify(item.memory),
+                relevance: item.relevance,
+                activation: item.activation,
+                source: item.source,
+            };
+            // Categorize by memory type
+            if (item.memory.type === 'episodic') {
+                context.episodic.push(contextItem);
+            }
+            else if (item.memory.type === 'semantic') {
+                context.semantic.push(contextItem);
+            }
+            else {
+                context.task.push(contextItem);
+            }
+        }
+        // Build formatted string (limit to maxContextTokens)
+        const allItems = [...context.immediate, ...context.task, ...context.episodic, ...context.semantic];
+        let formatted = '';
+        let tokens = 0;
+        const maxTokens = this.config.memory.maxContextTokens;
+        for (const item of allItems.sort((a, b) => b.relevance - a.relevance)) {
+            const itemTokens = Math.ceil(item.content.length / 4);
+            if (tokens + itemTokens > maxTokens)
+                break;
+            formatted += `[${item.type}] ${item.content}\n`;
+            tokens += itemTokens;
+        }
+        context.formatted = formatted;
+        context.tokenEstimate = tokens;
+        return context;
+    }
+    /**
+     * Create empty context
+     */
+    createEmptyContext() {
+        return {
+            immediate: [],
+            task: [],
+            episodic: [],
+            semantic: [],
+            formatted: '',
+            tokenEstimate: 0,
+            reuseRate: 0,
+        };
+    }
+    // ============================================================================
+    // Tool Parsing
+    // ============================================================================
+    /**
+     * Parse tool calls from LLM response
+     */
+    parseToolCalls(response) {
+        const calls = [];
+        // Parse <invoke> tags
+        const invokePattern = /<invoke\s+name="([^"]+)">([\s\S]*?)<\/invoke>/g;
+        let match;
+        while ((match = invokePattern.exec(response)) !== null) {
+            const name = match[1];
+            const paramsXml = match[2];
+            const params = {};
+            // Parse parameters
+            const paramPattern = /<parameter\s+name="([^"]+)">([\s\S]*?)<\/parameter>/g;
+            let paramMatch;
+            while ((paramMatch = paramPattern.exec(paramsXml)) !== null) {
+                const paramName = paramMatch[1];
+                const paramValue = paramMatch[2].trim();
+                // Try to parse as JSON
+                try {
+                    params[paramName] = JSON.parse(paramValue);
+                }
+                catch {
+                    params[paramName] = paramValue;
+                }
+            }
+            calls.push({
+                name,
+                parameters: params,
+                raw: match[0],
+            });
+        }
+        return calls;
+    }
+    // ============================================================================
+    // Consciousness Integration
+    // ============================================================================
+    /**
+     * Get current φ level
+     */
+    getCurrentPhi() {
+        if (!this.config.consciousness.enabled)
+            return 1.0;
+        try {
+            const level = this.phiMonitor.getCurrentLevel();
+            return level.phi;
+        }
+        catch {
+            return 0.5; // Default if monitor not available
+        }
+    }
+    // ============================================================================
+    // Metrics
+    // ============================================================================
+    /**
+     * Create initial metrics
+     */
+    createInitialMetrics() {
+        return {
+            totalCycles: 0,
+            successfulCycles: 0,
+            failedCycles: 0,
+            avgCycleTime: 0,
+            memoryRecalls: 0,
+            memoryReuseRate: 0,
+            anticipationHits: 0,
+            anticipationMisses: 0,
+            groundingChecks: 0,
+            groundingPasses: 0,
+            groundingFailures: 0,
+            humanConsultations: 0,
+            toolExecutions: 0,
+            toolSuccesses: 0,
+            toolFailures: 0,
+            healingAttempts: 0,
+            healingSuccesses: 0,
+            healingFailures: 0,
+            avgPhi: 0,
+            phiViolations: 0,
+            broadcasts: 0,
+            moduleTransitions: {},
+        };
+    }
+    /**
+     * Update metrics after a cycle
+     */
+    updateMetrics(state, transitions) {
+        const cycleTime = Date.now() - state.startTime;
+        this.metrics.totalCycles++;
+        if (!state.error) {
+            this.metrics.successfulCycles++;
+        }
+        else {
+            this.metrics.failedCycles++;
+        }
+        // Update average cycle time
+        this.metrics.avgCycleTime =
+            (this.metrics.avgCycleTime * (this.metrics.totalCycles - 1) + cycleTime) /
+                this.metrics.totalCycles;
+        // Update average phi
+        this.metrics.avgPhi =
+            (this.metrics.avgPhi * (this.metrics.totalCycles - 1) + state.phi) /
+                this.metrics.totalCycles;
+        // Track module transitions
+        for (const module of state.moduleHistory) {
+            this.metrics.moduleTransitions[module] =
+                (this.metrics.moduleTransitions[module] || 0) + 1;
+        }
+    }
+    /**
+     * Get current metrics
+     */
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    /**
+     * Reset metrics
+     */
+    resetMetrics() {
+        this.metrics = this.createInitialMetrics();
+    }
+    // ============================================================================
+    // Events
+    // ============================================================================
+    /**
+     * Subscribe to brain events
+     */
+    on(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    /**
+     * Emit brain event
+     */
+    emit(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch (err) {
+                console.error('Brain event handler error:', err);
+            }
+        }
+    }
+    // ============================================================================
+    // Status & Debug
+    // ============================================================================
+    /**
+     * Get brain status
+     */
+    getStatus() {
+        return {
+            running: this.running,
+            phi: this.getCurrentPhi(),
+            memoryReuseRate: this.workspace.getMetrics().reuseRate,
+            lastState: this.currentState,
+            metrics: this.getMetrics(),
+            moduleStates: {
+                memory: this.config.memory.enabled,
+                llm: this.config.llm.enabled,
+                grounding: this.config.grounding.enabled,
+                tools: this.config.tools.enabled,
+                healing: this.config.healing.enabled,
+                consciousness: this.config.consciousness.enabled,
+            },
+        };
+    }
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+}
+exports.Brain = Brain;
+// ============================================================================
+// Factory & Singleton
+// ============================================================================
+function createBrain(config) {
+    return new Brain(config);
+}
+let brainInstance = null;
+function getBrain(config) {
+    if (!brainInstance) {
+        brainInstance = createBrain(config);
+    }
+    return brainInstance;
+}
+function resetBrain() {
+    if (brainInstance) {
+        brainInstance.stop();
+        brainInstance = null;
+    }
+}
+// ============================================================================
+// Re-exports
+// ============================================================================
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./trace.js"), exports);