genesis-ai-cli 7.4.5

package/dist/src/brain/trace.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Genesis Phase 10 - Brain Trace System
+ *
+ * Visual real-time output of Brain internal processing.
+ * Shows thinking progress during reasoning.
+ *
+ * Usage:
+ *   const trace = new BrainTrace(brain);
+ *   trace.enable();
+ *   await brain.process("query");
+ *   trace.disable();
+ */
+import { Brain } from './index.js';
+export interface BrainTraceOptions {
+    /** Show timing for each step */
+    showTiming?: boolean;
+    /** Show detailed data */
+    showDetails?: boolean;
+    /** Indent level for nested output */
+    indent?: number;
+    /** Prefix for all output */
+    prefix?: string;
+}
+export declare class BrainTrace {
+    private brain;
+    private options;
+    private unsubscribe;
+    private enabled;
+    private cycleStartTime;
+    private currentModule;
+    private moduleStartTime;
+    constructor(brain: Brain, options?: BrainTraceOptions);
+    /**
+     * Enable trace output
+     */
+    enable(): void;
+    /**
+     * Disable trace output
+     */
+    disable(): void;
+    /**
+     * Check if trace is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Toggle trace on/off
+     */
+    toggle(): boolean;
+    /**
+     * Handle brain event
+     */
+    private handleEvent;
+    /**
+     * Safely get a value from event.data
+     */
+    private getData;
+    private onCycleStart;
+    private onModuleEnter;
+    private onModuleExit;
+    private onMemoryRecall;
+    private onMemoryAnticipate;
+    private onLLMRequest;
+    private onLLMResponse;
+    private onGroundingCheck;
+    private onToolExecute;
+    private onToolComplete;
+    private onHealingStart;
+    private onHealingComplete;
+    private onPhiUpdate;
+    private onBroadcast;
+    private onCycleComplete;
+    /**
+     * Format prefix
+     */
+    private prefix;
+    /**
+     * Format detail line (indented)
+     */
+    private detail;
+    /**
+     * Truncate string
+     */
+    private truncate;
+    /**
+     * Render mini phi bar
+     */
+    private renderPhiMini;
+}
+export declare function createBrainTrace(brain: Brain, options?: BrainTraceOptions): BrainTrace;
+export declare function getBrainTrace(brain?: Brain): BrainTrace | null;
+export declare function resetBrainTrace(): void;

package/dist/src/brain/trace.js

@@ -0,0 +1,327 @@
+"use strict";
+/**
+ * Genesis Phase 10 - Brain Trace System
+ *
+ * Visual real-time output of Brain internal processing.
+ * Shows thinking progress during reasoning.
+ *
+ * Usage:
+ *   const trace = new BrainTrace(brain);
+ *   trace.enable();
+ *   await brain.process("query");
+ *   trace.disable();
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrainTrace = void 0;
+exports.createBrainTrace = createBrainTrace;
+exports.getBrainTrace = getBrainTrace;
+exports.resetBrainTrace = resetBrainTrace;
+// ============================================================================
+// Colors
+// ============================================================================
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    italic: '\x1b[3m',
+    cyan: '\x1b[36m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    magenta: '\x1b[35m',
+    blue: '\x1b[34m',
+    gray: '\x1b[90m',
+    white: '\x1b[37m',
+    bgBlue: '\x1b[44m',
+    bgGray: '\x1b[100m',
+};
+function c(text, ...styles) {
+    const codes = styles.map(s => colors[s]).join('');
+    return `${codes}${text}${colors.reset}`;
+}
+const MODULE_ICONS = {
+    memory: '🧠',
+    llm: '💭',
+    grounding: '🔍',
+    tools: '🔧',
+    healing: '🩹',
+    consciousness: '✨',
+    kernel: '⚙️',
+    done: '✓',
+};
+const MODULE_COLORS = {
+    memory: 'blue',
+    llm: 'cyan',
+    grounding: 'yellow',
+    tools: 'magenta',
+    healing: 'red',
+    consciousness: 'green',
+    kernel: 'gray',
+    done: 'green',
+};
+class BrainTrace {
+    brain;
+    options;
+    unsubscribe = null;
+    enabled = false;
+    cycleStartTime = 0;
+    currentModule = '';
+    moduleStartTime = 0;
+    constructor(brain, options = {}) {
+        this.brain = brain;
+        this.options = {
+            showTiming: options.showTiming ?? true,
+            showDetails: options.showDetails ?? true,
+            indent: options.indent ?? 2,
+            prefix: options.prefix ?? 'BRAIN',
+        };
+    }
+    /**
+     * Enable trace output
+     */
+    enable() {
+        if (this.enabled)
+            return;
+        this.enabled = true;
+        this.unsubscribe = this.brain.on(this.handleEvent.bind(this));
+    }
+    /**
+     * Disable trace output
+     */
+    disable() {
+        if (!this.enabled)
+            return;
+        this.enabled = false;
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+    }
+    /**
+     * Check if trace is enabled
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Toggle trace on/off
+     */
+    toggle() {
+        if (this.enabled) {
+            this.disable();
+        }
+        else {
+            this.enable();
+        }
+        return this.enabled;
+    }
+    /**
+     * Handle brain event
+     */
+    handleEvent(event) {
+        switch (event.type) {
+            case 'cycle_start':
+                this.onCycleStart(event);
+                break;
+            case 'module_enter':
+                this.onModuleEnter(event);
+                break;
+            case 'module_exit':
+                this.onModuleExit(event);
+                break;
+            case 'memory_recall':
+                this.onMemoryRecall(event);
+                break;
+            case 'memory_anticipate':
+                this.onMemoryAnticipate(event);
+                break;
+            case 'llm_request':
+                this.onLLMRequest(event);
+                break;
+            case 'llm_response':
+                this.onLLMResponse(event);
+                break;
+            case 'grounding_check':
+                this.onGroundingCheck(event);
+                break;
+            case 'tool_execute':
+                this.onToolExecute(event);
+                break;
+            case 'tool_complete':
+                this.onToolComplete(event);
+                break;
+            case 'healing_start':
+                this.onHealingStart(event);
+                break;
+            case 'healing_complete':
+                this.onHealingComplete(event);
+                break;
+            case 'phi_update':
+                this.onPhiUpdate(event);
+                break;
+            case 'broadcast':
+                this.onBroadcast(event);
+                break;
+            case 'cycle_complete':
+                this.onCycleComplete(event);
+                break;
+        }
+    }
+    // ==========================================================================
+    // Event Handlers
+    // ==========================================================================
+    /**
+     * Safely get a value from event.data
+     */
+    getData(event, key, defaultValue) {
+        const data = event.data;
+        if (data && key in data) {
+            return data[key];
+        }
+        return defaultValue;
+    }
+    onCycleStart(event) {
+        this.cycleStartTime = Date.now();
+        const query = this.getData(event, 'query', '');
+        const truncatedQuery = query.length > 50 ? query.substring(0, 50) + '...' : query;
+        console.log();
+        console.log(this.prefix() + c(' Processing: ', 'bold') + c(`"${truncatedQuery}"`, 'white'));
+        console.log(this.prefix() + c(' ─'.repeat(30), 'dim'));
+    }
+    onModuleEnter(event) {
+        const module = event.module || this.getData(event, 'module', 'unknown');
+        this.currentModule = module;
+        this.moduleStartTime = Date.now();
+        const icon = MODULE_ICONS[module] || '•';
+        const color = MODULE_COLORS[module] || 'white';
+        const moduleName = module.charAt(0).toUpperCase() + module.slice(1);
+        console.log(this.prefix() + c(' → ', 'dim') + icon + ' ' + c(moduleName, color, 'bold'));
+    }
+    onModuleExit(_event) {
+        // Module exit is handled implicitly by next module enter or cycle complete
+    }
+    onMemoryRecall(event) {
+        const query = this.getData(event, 'query', '');
+        console.log(this.detail(`recall("${this.truncate(query, 30)}")`));
+    }
+    onMemoryAnticipate(event) {
+        const items = this.getData(event, 'items', 0);
+        if (items > 0) {
+            console.log(this.detail(`↳ anticipated ${items} item(s)`, 'green'));
+        }
+    }
+    onLLMRequest(_event) {
+        console.log(this.detail('generating response...'));
+    }
+    onLLMResponse(event) {
+        const length = this.getData(event, 'length', 0);
+        const time = this.options.showTiming ? ` (${Date.now() - this.moduleStartTime}ms)` : '';
+        console.log(this.detail(`↳ ${length} chars${time}`, 'green'));
+    }
+    onGroundingCheck(_event) {
+        console.log(this.detail('verifying claims...'));
+    }
+    onToolExecute(event) {
+        const count = this.getData(event, 'count', 0);
+        console.log(this.detail(`executing ${count} tool(s)...`));
+    }
+    onToolComplete(event) {
+        const results = this.getData(event, 'results', 0);
+        const time = this.options.showTiming ? ` (${Date.now() - this.moduleStartTime}ms)` : '';
+        console.log(this.detail(`↳ ${results} result(s)${time}`, 'green'));
+    }
+    onHealingStart(event) {
+        const error = this.getData(event, 'error', 'unknown');
+        console.log(this.detail(`error: ${this.truncate(String(error), 40)}`, 'red'));
+    }
+    onHealingComplete(event) {
+        const success = this.getData(event, 'success', false);
+        if (success) {
+            console.log(this.detail('↳ healed successfully', 'green'));
+        }
+        else {
+            console.log(this.detail('↳ healing failed', 'red'));
+        }
+    }
+    onPhiUpdate(event) {
+        const phi = this.getData(event, 'phi', 0);
+        const bar = this.renderPhiMini(phi);
+        const status = phi > 0.3 ? c('ignited', 'green') : c('local', 'dim');
+        console.log(this.detail(`φ=${phi.toFixed(2)} ${bar} ${status}`));
+    }
+    onBroadcast(event) {
+        const source = this.getData(event, 'source', 'unknown');
+        console.log(this.detail(`↳ broadcast from ${source}`, 'cyan'));
+    }
+    onCycleComplete(event) {
+        const transitions = this.getData(event, 'transitions', 0);
+        const totalTime = Date.now() - this.cycleStartTime;
+        const state = this.getData(event, 'state', null);
+        // Final phi status
+        const phi = state?.phi ?? 0;
+        const phiStatus = phi > 0.3 ? c('✨ ignited', 'green') : c('◌ local', 'dim');
+        console.log(this.prefix() + c(' ─'.repeat(30), 'dim'));
+        console.log(this.prefix() + c(' ✓ ', 'green', 'bold') +
+            c(`Done`, 'green') +
+            c(` (${totalTime}ms, ${transitions} transitions, ${phiStatus})`, 'dim'));
+        console.log();
+    }
+    // ==========================================================================
+    // Helpers
+    // ==========================================================================
+    /**
+     * Format prefix
+     */
+    prefix() {
+        return c(`[${this.options.prefix}]`, 'cyan', 'bold');
+    }
+    /**
+     * Format detail line (indented)
+     */
+    detail(text, color = 'dim') {
+        const indent = ' '.repeat(this.options.indent + 4);
+        return this.prefix() + indent + c(text, color);
+    }
+    /**
+     * Truncate string
+     */
+    truncate(str, max) {
+        if (str.length <= max)
+            return str;
+        return str.substring(0, max) + '...';
+    }
+    /**
+     * Render mini phi bar
+     */
+    renderPhiMini(phi) {
+        const width = 10;
+        const filled = Math.round(phi * width);
+        const empty = width - filled;
+        if (phi >= 0.7)
+            return c('█'.repeat(filled), 'green') + c('░'.repeat(empty), 'dim');
+        if (phi >= 0.3)
+            return c('█'.repeat(filled), 'yellow') + c('░'.repeat(empty), 'dim');
+        return c('█'.repeat(filled), 'gray') + c('░'.repeat(empty), 'dim');
+    }
+}
+exports.BrainTrace = BrainTrace;
+// ============================================================================
+// Factory
+// ============================================================================
+function createBrainTrace(brain, options) {
+    return new BrainTrace(brain, options);
+}
+// Singleton instance management
+let traceInstance = null;
+function getBrainTrace(brain) {
+    if (!traceInstance && brain) {
+        traceInstance = createBrainTrace(brain);
+    }
+    return traceInstance;
+}
+function resetBrainTrace() {
+    if (traceInstance) {
+        traceInstance.disable();
+        traceInstance = null;
+    }
+}

package/dist/src/brain/types.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Genesis Phase 10 - Brain Module Types
+ *
+ * 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
+ *
+ * The Brain orchestrates:
+ * 1. Cognitive Workspace (active memory)
+ * 2. Supervisor (command routing)
+ * 3. Global Workspace (broadcasting)
+ * 4. Healing Loop (error recovery)
+ */
+/**
+ * Modules that can be routed to
+ */
+export type BrainModule = 'memory' | 'llm' | 'grounding' | 'tools' | 'healing' | 'consciousness' | 'kernel' | 'done';
+/**
+ * Command for routing between modules
+ * Inspired by LangGraph's Command primitive
+ */
+export interface Command {
+    goto: BrainModule;
+    update: Partial<BrainState>;
+    reason?: string;
+}
+/**
+ * State maintained during brain processing cycle
+ */
+export interface BrainState {
+    query: string;
+    context: BrainContext;
+    response: string;
+    toolCalls: ToolCall[];
+    toolResults: ToolResult[];
+    phi: number;
+    ignited: boolean;
+    verified: boolean;
+    groundingFeedback?: string;
+    error?: Error;
+    healingAttempts: number;
+    startTime: number;
+    moduleHistory: BrainModule[];
+}
+/**
+ * Context retrieved from cognitive workspace
+ */
+export interface BrainContext {
+    immediate: ContextItem[];
+    task: ContextItem[];
+    episodic: ContextItem[];
+    semantic: ContextItem[];
+    formatted: string;
+    tokenEstimate: number;
+    reuseRate: number;
+}
+export interface ContextItem {
+    id: string;
+    type: 'immediate' | 'task' | 'episodic' | 'semantic';
+    content: string;
+    relevance: number;
+    activation: number;
+    source: string;
+}
+export interface ToolCall {
+    name: string;
+    parameters: Record<string, unknown>;
+    raw: string;
+}
+export interface ToolResult {
+    name: string;
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    duration: number;
+}
+export interface GroundingCheck {
+    valid: boolean;
+    confidence: number;
+    feedback: string;
+    domain: 'factual' | 'mathematical' | 'ethical' | 'existential' | 'aesthetic' | 'novel';
+    needsHuman: boolean;
+    humanQuestion?: string;
+}
+export interface HealingResult {
+    canRetry: boolean;
+    retryFrom: BrainModule;
+    context: string;
+    userMessage: string;
+    fixApplied?: string;
+}
+export interface GlobalBroadcast {
+    content: unknown;
+    source: BrainModule;
+    salience: number;
+    timestamp: Date;
+}
+export interface BrainConfig {
+    memory: {
+        enabled: boolean;
+        anticipationEnabled: boolean;
+        maxContextTokens: number;
+    };
+    llm: {
+        enabled: boolean;
+        maxRetries: number;
+    };
+    grounding: {
+        enabled: boolean;
+        verifyAllResponses: boolean;
+        confidenceThreshold: number;
+    };
+    tools: {
+        enabled: boolean;
+        maxExecutions: number;
+    };
+    healing: {
+        enabled: boolean;
+        maxAttempts: number;
+        autoHeal: boolean;
+    };
+    consciousness: {
+        enabled: boolean;
+        phiThreshold: number;
+        broadcastEnabled: boolean;
+    };
+    maxCycleTime: number;
+    maxModuleTransitions: number;
+}
+export declare const DEFAULT_BRAIN_CONFIG: BrainConfig;
+export interface BrainMetrics {
+    totalCycles: number;
+    successfulCycles: number;
+    failedCycles: number;
+    avgCycleTime: number;
+    memoryRecalls: number;
+    memoryReuseRate: number;
+    anticipationHits: number;
+    anticipationMisses: number;
+    groundingChecks: number;
+    groundingPasses: number;
+    groundingFailures: number;
+    humanConsultations: number;
+    toolExecutions: number;
+    toolSuccesses: number;
+    toolFailures: number;
+    healingAttempts: number;
+    healingSuccesses: number;
+    healingFailures: number;
+    avgPhi: number;
+    phiViolations: number;
+    broadcasts: number;
+    moduleTransitions: Record<string, number>;
+}
+export type BrainEventType = 'cycle_start' | 'cycle_complete' | 'cycle_error' | 'module_enter' | 'module_exit' | 'memory_recall' | 'memory_anticipate' | 'llm_request' | 'llm_response' | 'grounding_check' | 'tool_execute' | 'tool_complete' | 'healing_start' | 'healing_complete' | 'broadcast' | 'phi_update';
+export interface BrainEvent {
+    type: BrainEventType;
+    timestamp: Date;
+    data: unknown;
+    module?: BrainModule;
+}
+export type BrainEventHandler = (event: BrainEvent) => void;

package/dist/src/brain/types.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Genesis Phase 10 - Brain Module Types
+ *
+ * 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
+ *
+ * The Brain orchestrates:
+ * 1. Cognitive Workspace (active memory)
+ * 2. Supervisor (command routing)
+ * 3. Global Workspace (broadcasting)
+ * 4. Healing Loop (error recovery)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BRAIN_CONFIG = void 0;
+exports.DEFAULT_BRAIN_CONFIG = {
+    memory: {
+        enabled: true,
+        anticipationEnabled: true,
+        maxContextTokens: 8192,
+    },
+    llm: {
+        enabled: true,
+        maxRetries: 2,
+    },
+    grounding: {
+        enabled: true,
+        verifyAllResponses: false, // v7.2: Only verify when explicitly requested (was too aggressive)
+        confidenceThreshold: 0.3, // v7.2: Lowered from 0.5 to reduce false positives
+    },
+    tools: {
+        enabled: true,
+        maxExecutions: 5,
+    },
+    healing: {
+        enabled: true,
+        maxAttempts: 3,
+        autoHeal: true,
+    },
+    consciousness: {
+        enabled: true,
+        phiThreshold: 0.1,
+        broadcastEnabled: true,
+    },
+    maxCycleTime: 300000, // 5 minutes (MCP cold starts can be slow)
+    maxModuleTransitions: 20,
+};