genesis-ai-cli 7.16.0 → 7.18.1

package/dist/src/active-inference/core.d.ts

@@ -24,6 +24,8 @@ export declare class ActiveInferenceEngine {
     private D;
     private beliefs;
     private eventHandlers;
+    private actionCounts;
+    private totalActions;
     private stats;
     private learningHistory;
     private readonly MAX_HISTORY;

package/dist/src/active-inference/core.js

@@ -260,6 +260,9 @@ class ActiveInferenceEngine {
     beliefs;
     // Event handlers
     eventHandlers = [];
+    // Self-improved: Track action counts for UCB exploration
+    actionCounts = new Array(types_js_1.ACTION_COUNT).fill(1);
+    totalActions = types_js_1.ACTION_COUNT;
     // Statistics
     stats = {
         inferenceCount: 0,
@@ -348,9 +351,16 @@ class ActiveInferenceEngine {
         for (let a = 0; a < types_js_1.ACTION_COUNT; a++) {
             efe[a] = this.computeEFE(a);
         }
-        // Convert to policy via softmax (lower EFE = higher probability)
-        const negEfe = efe.map(e => -e);
-        const policy = softmax(negEfe, this.config.actionTemperature);
+        // Convert to policy via softmax with exploration bonus (UCB-style)
+        // Self-improved: adds exploration term to prevent getting stuck
+        const explorationBonus = efe.map((_, a) => {
+            const count = this.actionCounts?.[a] ?? 1;
+            const total = this.totalActions ?? types_js_1.ACTION_COUNT;
+            return Math.sqrt(Math.log(total + 1) / count); // UCB term
+        });
+        const beta = 0.5; // Exploration weight
+        const augmentedEfe = efe.map((e, i) => -e + beta * explorationBonus[i]);
+        const policy = softmax(augmentedEfe, this.config.actionTemperature);
         this.emit({
             type: 'policy_inferred',
             timestamp: new Date(),
@@ -377,6 +387,9 @@ class ActiveInferenceEngine {
         // Track statistics
         const count = this.stats.actionsTaken.get(action) || 0;
         this.stats.actionsTaken.set(action, count + 1);
+        // Self-improved: Update action counts for UCB exploration
+        this.actionCounts[selectedIdx]++;
+        this.totalActions++;
         this.emit({
             type: 'action_selected',
             timestamp: new Date(),

package/dist/src/active-inference/types.js

@@ -70,7 +70,7 @@ exports.ACTIONS = [
 ];
 exports.ACTION_COUNT = exports.ACTIONS.length;
 exports.DEFAULT_CONFIG = {
-    inferenceIterations: 16,
+    inferenceIterations: 26, // Auto-improved: Φ was 0.43 // Self-improved: +50% iterations for accuracy
     policyHorizon: 3,
     actionTemperature: 1.0,
     priorWeight: 0.1,

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

@@ -61,6 +61,7 @@ export declare class Brain {
     constructor(config?: Partial<BrainConfig>);
     /**
      * v7.13: Initialize new module integrations
+     * v7.18: Connect real PhiMonitor and dispatcher for full integration
      */
     private initializeV713Modules;
     /**
@@ -100,6 +101,12 @@ export declare class Brain {
      * Memory module: recall context and anticipate needs
      */
     private stepMemory;
+    /**
+     * v7.18: Determine optimal model tier based on task complexity
+     * - fast: Simple queries, short responses, tool formatting
+     * - balanced: Complex reasoning, creative tasks
+     */
+    private determineModelTier;
     /**
      * LLM module: generate response
      */

package/dist/src/brain/index.js

@@ -144,11 +144,30 @@ class Brain {
     }
     /**
      * v7.13: Initialize new module integrations
+     * v7.18: Connect real PhiMonitor and dispatcher for full integration
      */
     initializeV713Modules() {
         try {
             // Active Inference - Free Energy minimization
             this.activeInference = (0, index_js_5.getAutonomousLoop)();
+            // v7.18: Configure observation gatherer with real system state
+            const observationGatherer = (0, index_js_5.getObservationGatherer)();
+            observationGatherer.configure({
+                phiState: () => {
+                    const level = this.phiMonitor.getCurrentLevel();
+                    // Map phi to PhiState: dormant < 0.2, drowsy < 0.4, aware < 0.7, alert >= 0.7
+                    const state = level.phi >= 0.7 ? 'alert'
+                        : level.phi >= 0.4 ? 'aware'
+                            : level.phi >= 0.2 ? 'drowsy'
+                                : 'dormant';
+                    return { phi: level.phi, state };
+                },
+                kernelState: () => ({
+                    energy: 1.0, // Brain doesn't track energy, default to full
+                    state: this.running ? 'thinking' : 'idle',
+                    taskStatus: 'pending',
+                }),
+            });
         }
         catch {
             // Module may not be configured
@@ -156,6 +175,8 @@ class Brain {
         try {
             // Subagent Executor - specialized task delegation
             this.subagentExecutor = (0, executor_js_1.getSubagentExecutor)();
+            // v7.18: Connect dispatcher for multi-turn tool execution
+            this.subagentExecutor.setDispatcher(this.dispatcher);
         }
         catch {
             // Module may not be configured
@@ -278,6 +299,8 @@ class Brain {
         this.emit({ type: 'cycle_start', timestamp: new Date(), data: { query: input } });
         // Supervisor loop
         let transitions = 0;
+        let consecutiveErrors = 0; // v7.18: Track consecutive failures for early exit
+        const MAX_CONSECUTIVE_ERRORS = 3;
         while (command.goto !== 'done' && transitions < this.config.maxModuleTransitions) {
             // Update state
             state = { ...state, ...command.update };
@@ -287,6 +310,14 @@ class Brain {
                 command = { goto: 'done', update: { response: 'Processing timeout. Please try again.' } };
                 break;
             }
+            // v7.18: Early exit on repeated failures
+            if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                command = {
+                    goto: 'done',
+                    update: { response: `Unable to complete after ${consecutiveErrors} consecutive errors. Please try again.` },
+                };
+                break;
+            }
             try {
                 this.emit({ type: 'module_enter', timestamp: new Date(), data: { module: command.goto }, module: command.goto });
                 // Execute module
@@ -296,9 +327,11 @@ class Brain {
                 if (this.config.consciousness.broadcastEnabled) {
                     this.broadcast(state, command.goto);
                 }
+                consecutiveErrors = 0; // Reset on success
                 transitions++;
             }
             catch (error) {
+                consecutiveErrors++; // v7.18: Track consecutive errors
                 // Healing loop
                 if (this.config.healing.enabled && this.config.healing.autoHeal) {
                     command = await this.heal(error, state);
@@ -419,6 +452,30 @@ class Brain {
             reason: 'context_retrieved',
         };
     }
+    /**
+     * v7.18: Determine optimal model tier based on task complexity
+     * - fast: Simple queries, short responses, tool formatting
+     * - balanced: Complex reasoning, creative tasks
+     */
+    determineModelTier(query, hasToolResults) {
+        const wordCount = query.split(/\s+/).length;
+        const lowerQuery = query.toLowerCase();
+        // Use fast tier for:
+        // - Short queries (< 50 words)
+        // - Tool result formatting
+        // - Simple questions
+        const isSimple = wordCount < 50 &&
+            !lowerQuery.includes('explain') &&
+            !lowerQuery.includes('analyze') &&
+            !lowerQuery.includes('design') &&
+            !lowerQuery.includes('implement') &&
+            !lowerQuery.includes('create') &&
+            !lowerQuery.includes('refactor');
+        if (isSimple || hasToolResults) {
+            return 'fast';
+        }
+        return 'balanced';
+    }
     /**
      * LLM module: generate response
      */
@@ -429,8 +486,11 @@ class Brain {
         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);
+        // v7.18: Cost optimization - use tiered models
+        const hasToolResults = state.toolResults && state.toolResults.length > 0;
+        const tier = this.determineModelTier(state.query, hasToolResults);
+        // Call LLM with appropriate model tier
+        const response = await this.llm.chatWithTier(prompt, tier, 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);
@@ -705,8 +765,9 @@ class Brain {
             // Get stats for monitoring
             const stats = this.activeInference.getStats();
             // Route based on action type from active inference
-            // ActionType includes: 'recall.memory', 'execute.task', 'execute.code', 'sense.mcp', etc.
-            if (actionType === 'recall.memory' || actionType === 'dream.cycle') {
+            // v7.18: Comprehensive routing for all action types
+            // Memory-related actions
+            if (actionType === 'recall.memory' || actionType === 'dream.cycle' || actionType === 'code.history') {
                 // Trigger memory anticipation based on active inference predictions
                 try {
                     const anticipated = await this.workspace.anticipate({
@@ -732,11 +793,33 @@ class Brain {
                     reason: 'active_inference_recall',
                 };
             }
-            if (actionType === 'execute.task' || actionType === 'execute.code' || actionType === 'execute.shell') {
+            // Tool execution actions (MCP, web, deployment, etc.)
+            const toolActions = [
+                'execute.task', 'execute.code', 'execute.shell', 'execute.cycle', 'adapt.code',
+                'sense.mcp', 'web.search', 'web.scrape', 'web.browse',
+                'deploy.service', 'content.generate', 'api.call', 'github.deploy',
+            ];
+            if (toolActions.includes(actionType)) {
                 return {
                     goto: 'tools',
                     update: { phi },
-                    reason: 'active_inference_tool',
+                    reason: `active_inference_tool:${actionType}`,
+                };
+            }
+            // Self-modification actions - route to darwin-godel
+            if (actionType === 'self.modify' || actionType === 'self.analyze' || actionType === 'code.snapshot' || actionType === 'code.diff') {
+                return {
+                    goto: 'self-modify',
+                    update: { phi },
+                    reason: 'active_inference_self_modify',
+                };
+            }
+            // Rest actions - skip to response (energy conservation)
+            if (actionType === 'rest.idle' || actionType === 'recharge') {
+                return {
+                    goto: 'llm',
+                    update: { phi },
+                    reason: 'active_inference_rest',
                 };
             }
             // Default: proceed to thinking with beliefs context

package/dist/src/brain/types.js

@@ -46,6 +46,6 @@ exports.DEFAULT_BRAIN_CONFIG = {
         phiThreshold: 0.1,
         broadcastEnabled: true,
     },
-    maxCycleTime: 600000, // 10 minutes (Ollama + complex thinking needs time)
-    maxModuleTransitions: 20,
+    maxCycleTime: 120000, // v7.18: Reduced from 10min to 2min for faster responses
+    maxModuleTransitions: 10, // v7.18: Reduced from 20 to 10 for faster convergence
 };

package/dist/src/cli/chat.d.ts

@@ -59,6 +59,7 @@ export declare class ChatSession {
     private inputHistory;
     private memory;
     private selfProduction;
+    private darwinGodel;
     private inferenceLoop;
     private lastCuriosity;
     private lastSurprise;
@@ -190,7 +191,9 @@ export declare class ChatSession {
      */
     private renderHealthBar;
     /**
-     * Run self-improvement (v7.0 Darwin-Gödel)
+     * Run self-improvement (v7.17 Darwin-Gödel - REAL)
+     *
+     * This actually modifies Genesis code based on runtime metrics.
      */
     private runSelfImprovement;
     /**

package/dist/src/cli/chat.js

@@ -70,6 +70,8 @@ const index_js_4 = require("../brain/index.js");
 const index_js_5 = require("../memory/index.js");
 const index_js_6 = require("../healing/index.js");
 const self_production_js_1 = require("../self-production.js");
+// v7.17: Real Darwin-Gödel self-modification
+const darwin_godel_js_1 = require("../self-modification/darwin-godel.js");
 // v7.1: Active Inference integration
 const index_js_7 = require("../active-inference/index.js");
 // v7.4: Subagent System
@@ -102,6 +104,7 @@ class ChatSession {
     inputHistory;
     memory; // v7.0: Memory system with consolidation
     selfProduction; // v7.0: Darwin-Gödel self-improvement
+    darwinGodel; // v7.17: Real self-modification engine
     // v7.1: Active Inference integration
     inferenceLoop = null;
     lastCuriosity = 0; // Track curiosity level
@@ -135,6 +138,7 @@ class ChatSession {
         this.brainTrace = (0, index_js_4.createBrainTrace)(this.brain); // Phase 10: Initialize trace
         this.memory = (0, index_js_5.getMemorySystem)(); // v7.0: Initialize memory with consolidation
         this.selfProduction = (0, self_production_js_1.createSelfProductionEngine)('7.1.0'); // v7.1: Darwin-Gödel
+        this.darwinGodel = (0, darwin_godel_js_1.getDarwinGodelEngine)({ gitEnabled: true, skipTests: true }); // v7.17: Real modification engine
         this.subagentExecutor = (0, index_js_8.getSubagentExecutor)(); // v7.4: Subagent system
         this.subagentExecutor.setDispatcher(this.dispatcher); // v7.4: Wire dispatcher
         this.verbose = options.verbose ?? false;
@@ -1088,7 +1092,9 @@ INSTRUCTION: You MUST report this error to the user. Do NOT fabricate or guess w
         console.log('  /history       Show conversation history');
         console.log('  /status, /s    Show LLM status');
         console.log('  /verbose, /v   Toggle verbose mode');
-        console.log('  /system        Show system prompt');
+        console.log('  /system        Show/set custom system prompt');
+        console.log('  /system <text> Set custom system prompt injection');
+        console.log('  /system clear  Clear custom system prompt');
         console.log();
         console.log((0, ui_js_1.c)('Tools:', 'bold'));
         console.log('  /tools         Toggle MCP tool execution');
@@ -1672,56 +1678,123 @@ INSTRUCTION: You MUST report this error to the user. Do NOT fabricate or guess w
         return (0, ui_js_1.c)(bar, 'red');
     }
     /**
-     * Run self-improvement (v7.0 Darwin-Gödel)
+     * Run self-improvement (v7.17 Darwin-Gödel - REAL)
+     *
+     * This actually modifies Genesis code based on runtime metrics.
      */
     async runSelfImprovement() {
-        console.log((0, ui_js_1.c)('Darwin-Gödel Self-Improvement (v7.0):', 'bold'));
+        console.log((0, ui_js_1.c)('Darwin-Gödel Self-Improvement (v7.17 - REAL):', 'bold'));
         console.log();
-        // First, run analysis
+        // Analyze brain metrics to determine what to improve
         const brainMetrics = this.brain.getMetrics();
-        const errorRate = brainMetrics.totalCycles > 0
-            ? brainMetrics.failedCycles / brainMetrics.totalCycles
-            : 0;
-        const improvements = this.selfProduction.analyzeForImprovements({
-            avgPipelineDuration: brainMetrics.avgCycleTime,
-            errorRate,
-            systemsCreated: this.messageCount,
-            cacheHitRate: brainMetrics.memoryReuseRate,
-            hasAdvancedTemplates: false,
-        });
-        if (improvements.length === 0) {
-            console.log((0, ui_js_1.success)('✓ No improvements needed. System is already optimal.'));
-            return;
+        const memoryReuse = brainMetrics.memoryReuseRate;
+        const avgCycleTime = brainMetrics.avgCycleTime;
+        const phi = brainMetrics.avgPhi;
+        console.log((0, ui_js_1.info)('Current metrics:'));
+        console.log(`  Memory reuse: ${(memoryReuse * 100).toFixed(1)}%`);
+        console.log(`  Avg cycle time: ${avgCycleTime.toFixed(0)}ms`);
+        console.log(`  Φ (consciousness): ${phi.toFixed(3)}`);
+        console.log();
+        // Build modification plans based on metrics
+        const plans = [];
+        // Read current config values to build correct search strings
+        const fs = await import('fs');
+        const path = await import('path');
+        const srcDir = path.join(process.cwd(), 'src');
+        // If memory reuse is low, increase anticipation depth
+        if (memoryReuse < 0.5) {
+            try {
+                const workspaceFile = path.join(srcDir, 'memory/cognitive-workspace.ts');
+                const content = fs.readFileSync(workspaceFile, 'utf-8');
+                const match = content.match(/anticipationDepth:\s*(\d+)/);
+                if (match) {
+                    const current = parseInt(match[1]);
+                    const newValue = Math.min(current + 2, 15);
+                    plans.push({
+                        id: `improve-anticipation-${Date.now()}`,
+                        name: 'Increase memory anticipation for better reuse',
+                        description: `Memory reuse is ${(memoryReuse * 100).toFixed(1)}%, increasing anticipation depth`,
+                        modifications: [{
+                                id: 'anticipation-boost',
+                                description: `Increase anticipationDepth from ${current} to ${newValue}`,
+                                targetFile: 'memory/cognitive-workspace.ts',
+                                type: 'replace',
+                                search: `anticipationDepth: ${current},`,
+                                content: `anticipationDepth: ${newValue}, // Self-improved: reuse was ${(memoryReuse * 100).toFixed(0)}%`,
+                                reason: 'Low memory reuse indicates insufficient pre-loading',
+                                expectedImprovement: '+20% memory reuse',
+                            }],
+                        createdAt: new Date(),
+                    });
+                }
+            }
+            catch { /* File read error, skip this improvement */ }
+        }
+        // If Φ is low, increase inference iterations
+        if (phi < 0.4) {
+            try {
+                const typesFile = path.join(srcDir, 'active-inference/types.ts');
+                const content = fs.readFileSync(typesFile, 'utf-8');
+                const match = content.match(/inferenceIterations:\s*(\d+)/);
+                if (match) {
+                    const current = parseInt(match[1]);
+                    const newValue = Math.min(current + 4, 48);
+                    plans.push({
+                        id: `improve-inference-${Date.now()}`,
+                        name: 'Increase inference depth for better consciousness',
+                        description: `Φ is ${phi.toFixed(3)}, increasing inference iterations`,
+                        modifications: [{
+                                id: 'inference-boost',
+                                description: `Increase inferenceIterations from ${current} to ${newValue}`,
+                                targetFile: 'active-inference/types.ts',
+                                type: 'replace',
+                                search: `inferenceIterations: ${current},`,
+                                content: `inferenceIterations: ${newValue}, // Self-improved: Φ was ${phi.toFixed(2)}`,
+                                reason: 'Low Φ indicates insufficient belief convergence',
+                                expectedImprovement: '+15% consciousness level',
+                            }],
+                        createdAt: new Date(),
+                    });
+                }
+            }
+            catch { /* File read error, skip this improvement */ }
         }
-        console.log((0, ui_js_1.info)(`Found ${improvements.length} potential improvements.`));
-        // Filter to high priority
-        const highPriority = improvements.filter(i => i.priority === 'critical' || i.priority === 'high');
-        if (highPriority.length === 0) {
-            console.log((0, ui_js_1.muted)('No critical or high priority improvements. Skipping.'));
+        if (plans.length === 0) {
+            console.log((0, ui_js_1.success)('✓ System metrics are healthy. No improvements needed.'));
+            console.log((0, ui_js_1.muted)(`  Memory reuse: ${(memoryReuse * 100).toFixed(1)}% (threshold: 50%)`));
+            console.log((0, ui_js_1.muted)(`  Φ: ${phi.toFixed(3)} (threshold: 0.4)`));
             return;
         }
-        console.log((0, ui_js_1.warning)('Self-improvement would modify the system. This is currently simulated.'));
-        console.log((0, ui_js_1.muted)('In a real scenario, the following steps would occur:'));
-        console.log((0, ui_js_1.muted)('  1. Git commit created as safety checkpoint'));
-        console.log((0, ui_js_1.muted)('  2. Code modifications generated by LLM'));
-        console.log((0, ui_js_1.muted)('  3. Tests run to validate changes'));
-        console.log((0, ui_js_1.muted)('  4. On failure: git revert to checkpoint'));
-        console.log((0, ui_js_1.muted)('  5. On success: new version tagged'));
-        console.log();
-        // Simulate the production
-        const spec = {
-            currentVersion: this.selfProduction.getVersion(),
-            targetVersion: '7.0.1',
-            improvements: highPriority,
-            preserveInvariants: this.selfProduction.getInvariants(),
-        };
-        console.log((0, ui_js_1.info)('Simulating production...'));
-        const result = await this.selfProduction.produce(spec);
-        if (result.success) {
-            console.log((0, ui_js_1.success)(`✓ Self-improvement successful! New version: ${result.newVersion}`));
+        console.log((0, ui_js_1.warning)(`Found ${plans.length} potential improvement(s):`));
+        for (const plan of plans) {
+            console.log(`  • ${plan.name}`);
+        }
+        console.log();
+        // Apply each plan via Darwin-Gödel
+        let applied = 0;
+        for (const plan of plans) {
+            console.log((0, ui_js_1.info)(`Applying: ${plan.name}...`));
+            try {
+                const result = await this.darwinGodel.apply(plan);
+                if (result.success) {
+                    console.log((0, ui_js_1.success)(`  ✓ Applied! Commit: ${result.commitHash?.slice(0, 8)}`));
+                    applied++;
+                }
+                else {
+                    console.log((0, ui_js_1.warning)(`  ✗ Failed: ${result.verificaton.errors[0] || 'Unknown error'}`));
+                }
+            }
+            catch (err) {
+                console.log((0, ui_js_1.error)(`  ✗ Error: ${err instanceof Error ? err.message : err}`));
+            }
+        }
+        console.log();
+        if (applied > 0) {
+            console.log((0, ui_js_1.success)(`✓ Self-improvement complete! Applied ${applied}/${plans.length} modifications.`));
+            console.log((0, ui_js_1.muted)('  Changes committed to git. Use `git log` to see history.'));
         }
         else {
-            console.log((0, ui_js_1.warning)('Self-improvement simulation completed (no actual changes made).'));
+            console.log((0, ui_js_1.warning)('No modifications were applied.'));
         }
         console.log();
     }

package/dist/src/llm/index.d.ts

@@ -11,6 +11,8 @@
  */
 export * from './router.js';
 export type LLMProvider = 'ollama' | 'openai' | 'anthropic';
+export type ModelTier = 'fast' | 'balanced' | 'powerful';
+export declare const MODEL_TIERS: Record<LLMProvider, Record<ModelTier, string>>;
 export declare const OLLAMA_CONFIG: {
     baseUrl: string;
     defaultModel: string;
@@ -86,6 +88,7 @@ export declare const GENESIS_SYSTEM_PROMPT = "# Genesis System\n\nYou are Genesi
 export declare class LLMBridge {
     private config;
     private conversationHistory;
+    private useCache;
     constructor(config?: Partial<LLMConfig>);
     private detectProvider;
     private detectApiKey;
@@ -94,8 +97,11 @@ export declare class LLMBridge {
      * Check if Ollama is running
      */
     isOllamaAvailable(): Promise<boolean>;
+    private fallbackAttempts;
+    private static readonly MAX_FALLBACK_ATTEMPTS;
     /**
      * Send a message and get a response
+     * Fallback chain: Anthropic -> OpenAI -> Ollama (max 3 attempts)
      */
     chat(userMessage: string, systemPrompt?: string): Promise<LLMResponse>;
     /**
@@ -127,6 +133,13 @@ export declare class LLMBridge {
      * Check if API key is configured (or Ollama available)
      */
     isConfigured(): boolean;
+    /**
+     * v7.18: Chat with specific model tier for cost optimization
+     * - fast: GPT-4o-mini/Haiku - 17x cheaper, good for simple tasks
+     * - balanced: GPT-4o/Sonnet - default quality
+     * - powerful: Best available model
+     */
+    chatWithTier(userMessage: string, tier?: ModelTier, systemPrompt?: string): Promise<LLMResponse>;
     /**
      * Get provider status
      */
@@ -136,6 +149,22 @@ export declare class LLMBridge {
         model: string;
         isLocal: boolean;
     };
+    /**
+     * v7.18: Get cache statistics for cost monitoring
+     */
+    getCacheStats(): {
+        size: number;
+        hits: number;
+        estimatedSavings: number;
+    };
+    /**
+     * v7.18: Enable/disable response caching
+     */
+    setCache(enabled: boolean): void;
+    /**
+     * v7.18: Clear the response cache
+     */
+    clearCache(): void;
     /**
      * List available Ollama models
      */