genesis-ai-cli 7.17.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
      */

package/dist/src/llm/index.js

@@ -25,13 +25,30 @@ 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.LLMBridge = exports.GENESIS_SYSTEM_PROMPT = exports.GENESIS_IDENTITY_PROMPT = exports.OLLAMA_CONFIG = void 0;
+exports.LLMBridge = exports.GENESIS_SYSTEM_PROMPT = exports.GENESIS_IDENTITY_PROMPT = exports.OLLAMA_CONFIG = exports.MODEL_TIERS = void 0;
 exports.buildSystemPrompt = buildSystemPrompt;
 exports.createLLMBridge = createLLMBridge;
 exports.getLLMBridge = getLLMBridge;
 exports.resetLLMBridge = resetLLMBridge;
 // Re-export Phase 8: Hybrid Router
 __exportStar(require("./router.js"), exports);
+exports.MODEL_TIERS = {
+    openai: {
+        fast: 'gpt-4o-mini', // $0.15/$0.60 per 1M - 17x cheaper!
+        balanced: 'gpt-4o', // $2.5/$10 per 1M
+        powerful: 'gpt-4o', // Same as balanced for OpenAI
+    },
+    anthropic: {
+        fast: 'claude-3-5-haiku-20241022', // Cheaper, faster
+        balanced: 'claude-sonnet-4-20250514',
+        powerful: 'claude-sonnet-4-20250514',
+    },
+    ollama: {
+        fast: 'qwen2.5-coder', // Fast local
+        balanced: 'qwen2.5-coder',
+        powerful: 'mistral-small', // Higher quality local
+    },
+};
 // Ollama config
 exports.OLLAMA_CONFIG = {
     baseUrl: process.env.OLLAMA_HOST || 'http://localhost:11434',
@@ -151,12 +168,35 @@ async function buildSystemPrompt(mcpTools, localTools, includeSchemas = true) {
 }
 // Legacy export for backwards compatibility
 exports.GENESIS_SYSTEM_PROMPT = exports.GENESIS_IDENTITY_PROMPT;
-// ============================================================================
-// LLM Bridge Class
-// ============================================================================
+const responseCache = new Map();
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_CACHE_SIZE = 100;
+function getCacheKey(prompt, model) {
+    // Simple hash for cache key
+    const hash = prompt.slice(0, 100) + '|' + model;
+    return hash;
+}
+function cleanCache() {
+    const now = Date.now();
+    for (const [key, entry] of responseCache) {
+        if (now - entry.timestamp > CACHE_TTL_MS) {
+            responseCache.delete(key);
+        }
+    }
+    // Limit size
+    if (responseCache.size > MAX_CACHE_SIZE) {
+        const oldest = [...responseCache.entries()]
+            .sort((a, b) => a[1].timestamp - b[1].timestamp)
+            .slice(0, responseCache.size - MAX_CACHE_SIZE);
+        for (const [key] of oldest) {
+            responseCache.delete(key);
+        }
+    }
+}
 class LLMBridge {
     config;
     conversationHistory = [];
+    useCache = true; // v7.18: Enable caching by default
     constructor(config = {}) {
         // Detect provider first, then use it for model selection
         const provider = config.provider || this.detectProvider();
@@ -222,8 +262,12 @@ class LLMBridge {
             return false;
         }
     }
+    // v7.18: Track fallback attempts to prevent infinite loops
+    fallbackAttempts = 0;
+    static MAX_FALLBACK_ATTEMPTS = 3;
     /**
      * Send a message and get a response
+     * Fallback chain: Anthropic -> OpenAI -> Ollama (max 3 attempts)
      */
     async chat(userMessage, systemPrompt) {
         const system = systemPrompt || exports.GENESIS_SYSTEM_PROMPT;
@@ -241,20 +285,47 @@ class LLMBridge {
             else {
                 response = await this.callOpenAI(system);
             }
+            // Reset fallback counter on success
+            this.fallbackAttempts = 0;
             // Add assistant response to history
             this.conversationHistory.push({ role: 'assistant', content: response.content });
             return response;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            // Fallback: if Ollama fails, try cloud
-            if (this.config.provider === 'ollama' && process.env.OPENAI_API_KEY) {
-                console.log('[LLM] Ollama unavailable, falling back to OpenAI...');
+            const isQuotaError = errorMessage.includes('credit balance') ||
+                errorMessage.includes('quota') ||
+                errorMessage.includes('rate limit') ||
+                errorMessage.includes('insufficient_quota');
+            // v7.18: Check fallback limit to prevent infinite loops
+            if (this.fallbackAttempts >= LLMBridge.MAX_FALLBACK_ATTEMPTS) {
+                this.fallbackAttempts = 0; // Reset for next call
+                this.conversationHistory.pop();
+                throw new Error(`LLM call failed after ${LLMBridge.MAX_FALLBACK_ATTEMPTS} fallback attempts: ${errorMessage}`);
+            }
+            this.fallbackAttempts++;
+            // v7.18: Enhanced fallback chain with attempt tracking
+            // Anthropic fails -> try OpenAI
+            if (this.config.provider === 'anthropic' && process.env.OPENAI_API_KEY) {
+                console.log(`[LLM] Anthropic failed (${isQuotaError ? 'quota' : 'error'}), falling back to OpenAI... (attempt ${this.fallbackAttempts}/${LLMBridge.MAX_FALLBACK_ATTEMPTS})`);
                 this.config.provider = 'openai';
                 this.config.apiKey = process.env.OPENAI_API_KEY;
                 this.config.model = 'gpt-4o';
+                this.conversationHistory.pop();
                 return this.chat(userMessage, systemPrompt);
             }
+            // OpenAI fails -> try Ollama (if available)
+            if (this.config.provider === 'openai') {
+                console.log(`[LLM] OpenAI failed (${isQuotaError ? 'quota' : 'error'}), falling back to Ollama... (attempt ${this.fallbackAttempts}/${LLMBridge.MAX_FALLBACK_ATTEMPTS})`);
+                this.config.provider = 'ollama';
+                this.config.apiKey = 'not-needed';
+                this.config.model = exports.OLLAMA_CONFIG.defaultModel;
+                this.conversationHistory.pop();
+                return this.chat(userMessage, systemPrompt);
+            }
+            // Ollama fails -> fail fast (don't loop back to OpenAI)
+            this.fallbackAttempts = 0;
+            this.conversationHistory.pop();
             throw new Error(`LLM call failed: ${errorMessage}`);
         }
     }
@@ -279,6 +350,7 @@ class LLMBridge {
                 temperature: this.config.temperature,
                 max_tokens: this.config.maxTokens,
             }),
+            signal: AbortSignal.timeout(60000), // v7.18: 60s timeout for faster failure
         });
         if (!response.ok) {
             const error = await response.text();
@@ -317,6 +389,7 @@ class LLMBridge {
                     content: m.content,
                 })),
             }),
+            signal: AbortSignal.timeout(60000), // v7.18: 60s timeout for faster failure
         });
         if (!response.ok) {
             const error = await response.text();
@@ -358,6 +431,7 @@ class LLMBridge {
                     num_predict: this.config.maxTokens,
                 },
             }),
+            signal: AbortSignal.timeout(90000), // v7.18: 90s timeout (local can be slower)
         });
         if (!response.ok) {
             const error = await response.text();
@@ -401,6 +475,26 @@ class LLMBridge {
             return true; // Local, no key needed
         return !!this.config.apiKey;
     }
+    /**
+     * 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
+     */
+    async chatWithTier(userMessage, tier = 'balanced', systemPrompt) {
+        const originalModel = this.config.model;
+        const tierModel = exports.MODEL_TIERS[this.config.provider][tier];
+        // Temporarily switch to tier model
+        this.config.model = tierModel;
+        try {
+            const response = await this.chat(userMessage, systemPrompt);
+            return response;
+        }
+        finally {
+            // Restore original model
+            this.config.model = originalModel;
+        }
+    }
     /**
      * Get provider status
      */
@@ -412,6 +506,35 @@ class LLMBridge {
             isLocal: this.config.provider === 'ollama',
         };
     }
+    /**
+     * v7.18: Get cache statistics for cost monitoring
+     */
+    getCacheStats() {
+        cleanCache();
+        let totalTokensSaved = 0;
+        for (const entry of responseCache.values()) {
+            totalTokensSaved += entry.tokens;
+        }
+        // Estimate savings: avg $0.01 per 1K tokens for GPT-4o
+        const estimatedSavings = (totalTokensSaved / 1000) * 0.01;
+        return {
+            size: responseCache.size,
+            hits: totalTokensSaved,
+            estimatedSavings,
+        };
+    }
+    /**
+     * v7.18: Enable/disable response caching
+     */
+    setCache(enabled) {
+        this.useCache = enabled;
+    }
+    /**
+     * v7.18: Clear the response cache
+     */
+    clearCache() {
+        responseCache.clear();
+    }
     /**
      * List available Ollama models
      */

package/dist/src/llm/router.js

@@ -271,9 +271,10 @@ function detectCloudProvider() {
  * Estimate cost for cloud provider
  */
 function estimateCost(inputTokens, outputTokens, provider) {
-    // Prices per 1M tokens (as of 2024)
+    // Prices per 1M tokens (as of 2025)
+    // GPT-4o-mini: { input: 0.15, output: 0.60 } - 17x cheaper for simple tasks!
     const prices = {
-        openai: { input: 2.5, output: 10 }, // GPT-4o
+        openai: { input: 2.5, output: 10 }, // GPT-4o (default)
         anthropic: { input: 3, output: 15 }, // Claude Sonnet
         ollama: { input: 0, output: 0 }, // Free!
     };

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

@@ -16,6 +16,10 @@
  * - Cache: Intelligent per-server caching with TTL
  * - DAG Executor: Parallel execution with dependency awareness
  * - Transformers: Composable result transformations
+ *
+ * New in 7.18: Web Search Fallback Chain
+ * - brave-search → exa → gemini → firecrawl
+ * - Automatic tool name mapping between providers
  */
 export * from './resilient.js';
 export * from './tool-chain.js';

package/dist/src/mcp/index.js

@@ -17,6 +17,10 @@
  * - Cache: Intelligent per-server caching with TTL
  * - DAG Executor: Parallel execution with dependency awareness
  * - Transformers: Composable result transformations
+ *
+ * New in 7.18: Web Search Fallback Chain
+ * - brave-search → exa → gemini → firecrawl
+ * - Automatic tool name mapping between providers
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -205,6 +209,82 @@ const MCP_SERVER_REGISTRY = {
     },
 };
 exports.MCP_SERVER_REGISTRY = MCP_SERVER_REGISTRY;
+// ============================================================================
+// v7.18 - Web Search Fallback Chain
+// ============================================================================
+/**
+ * Fallback chain for web search providers.
+ * When one fails (rate limit, API key missing, error), try the next.
+ */
+const WEB_SEARCH_FALLBACK_CHAIN = ['brave-search', 'exa', 'gemini', 'firecrawl'];
+/**
+ * Tool name mapping between web search providers.
+ * Maps the original tool name to equivalent tool on fallback server.
+ */
+const WEB_SEARCH_TOOL_MAP = {
+    'brave_web_search': {
+        'brave-search': 'brave_web_search',
+        'exa': 'web_search_exa',
+        'gemini': 'web_search',
+        'firecrawl': 'firecrawl_search',
+    },
+    'brave_news_search': {
+        'brave-search': 'brave_news_search',
+        'exa': 'web_search_exa', // Exa doesn't have news-specific, use general
+        'gemini': 'web_search',
+        'firecrawl': 'firecrawl_search',
+    },
+};
+/**
+ * Check if a server requires an API key and if it's configured.
+ */
+function isServerConfigured(server) {
+    const requiredEnvVars = {
+        'brave-search': ['BRAVE_API_KEY'],
+        'exa': ['EXA_API_KEY'],
+        'gemini': ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+        'firecrawl': ['FIRECRAWL_API_KEY'],
+    };
+    const vars = requiredEnvVars[server];
+    if (!vars)
+        return true; // No API key required
+    return vars.some(v => !!process.env[v]);
+}
+/**
+ * Check if an error indicates rate limiting or quota exhaustion.
+ */
+function isRateLimitError(error) {
+    const rateLimitPatterns = [
+        'rate limit', 'rate_limit', 'ratelimit',
+        '429', 'too many requests',
+        'quota', 'exceeded', 'exhausted',
+        'credit balance',
+    ];
+    const lowerError = error.toLowerCase();
+    return rateLimitPatterns.some(p => lowerError.includes(p));
+}
+/**
+ * Get next fallback server in the chain.
+ */
+function getNextFallbackServer(currentServer, tool) {
+    // Only handle web search tools
+    if (!WEB_SEARCH_TOOL_MAP[tool])
+        return null;
+    const currentIndex = WEB_SEARCH_FALLBACK_CHAIN.indexOf(currentServer);
+    if (currentIndex === -1)
+        return null;
+    // Find next configured server in chain
+    for (let i = currentIndex + 1; i < WEB_SEARCH_FALLBACK_CHAIN.length; i++) {
+        const nextServer = WEB_SEARCH_FALLBACK_CHAIN[i];
+        if (isServerConfigured(nextServer)) {
+            const mappedTool = WEB_SEARCH_TOOL_MAP[tool][nextServer];
+            if (mappedTool) {
+                return { server: nextServer, tool: mappedTool };
+            }
+        }
+    }
+    return null;
+}
 class MCPConnectionManager {
     connections = new Map();
     connecting = new Map();
@@ -292,16 +372,23 @@ class MCPConnectionManager {
     }
     /**
      * Call a tool on an MCP server
+     * v7.18: Added timeout wrapper for faster failure
      */
     async callTool(server, tool, args) {
         const connection = await this.getConnection(server);
         if (this.logCalls) {
             console.log(`[MCP] ${server}.${tool}(${JSON.stringify(args).slice(0, 100)}...)`);
         }
-        const result = await connection.client.callTool({
-            name: tool,
-            arguments: args,
-        });
+        // v7.18: Wrap call in timeout for faster failure (15s default, 30s for heavy ops)
+        const isHeavyOp = ['firecrawl_crawl', 'parse_paper_content', 'web_search'].includes(tool);
+        const callTimeout = isHeavyOp ? 30000 : 15000;
+        const result = await Promise.race([
+            connection.client.callTool({
+                name: tool,
+                arguments: args,
+            }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`MCP call to ${server}.${tool} timed out after ${callTimeout}ms`)), callTimeout)),
+        ]);
         // Parse result content
         const content = result.content;
         if (content && content.length > 0) {
@@ -419,7 +506,7 @@ class RealMCPClient {
         this.mode = this.config.mode;
         this.manager = new MCPConnectionManager(this.config.timeout, this.config.logCalls);
     }
-    async call(server, tool, params, options = {}) {
+    async call(server, tool, params, options = {}, _isRetry = false) {
         const startTime = Date.now();
         if (this.config.onCall) {
             this.config.onCall(server, tool, params);
@@ -441,9 +528,20 @@ class RealMCPClient {
             return result;
         }
         catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // v7.18: Try fallback for web search tools
+            if (!_isRetry) {
+                const fallback = getNextFallbackServer(server, tool);
+                if (fallback) {
+                    console.log(`[MCP] ${server}.${tool} failed (${isRateLimitError(errorMessage) ? 'rate limit' : 'error'}), trying ${fallback.server}.${fallback.tool}...`);
+                    // Adapt params for the new tool if needed
+                    const adaptedParams = this.adaptParamsForFallback(tool, fallback.tool, params);
+                    return this.call(fallback.server, fallback.tool, adaptedParams, options, true);
+                }
+            }
             const result = {
                 success: false,
-                error: error instanceof Error ? error.message : String(error),
+                error: errorMessage,
                 server,
                 tool,
                 mode: 'real',
@@ -456,6 +554,33 @@ class RealMCPClient {
             return result;
         }
     }
+    /**
+     * Adapt parameters when falling back to a different web search provider.
+     */
+    adaptParamsForFallback(originalTool, newTool, params) {
+        // Exa uses slightly different param names
+        if (newTool === 'web_search_exa') {
+            return {
+                query: params.query || params.q,
+                numResults: params.count || params.numResults || 10,
+            };
+        }
+        // Gemini web search
+        if (newTool === 'web_search') {
+            return {
+                q: params.query || params.q,
+                verbosity: 'concise',
+            };
+        }
+        // Firecrawl search
+        if (newTool === 'firecrawl_search') {
+            return {
+                query: params.query || params.q,
+                limit: params.count || 10,
+            };
+        }
+        return params;
+    }
     async listTools(server) {
         return this.manager.listTools(server);
     }

package/dist/src/mcp/resilient.js

@@ -22,7 +22,7 @@ const indexer_js_1 = require("../memory/indexer.js");
 // ============================================================================
 const DEFAULT_CONFIG = {
     defaultTimeout: 30000,
-    defaultMaxRetries: 2,
+    defaultMaxRetries: 3, // Improved by self-improvement cycle
     circuitBreakerThreshold: 5,
     circuitBreakerResetTime: 60000,
     logCalls: false,

package/dist/src/memory/cognitive-workspace.js

@@ -34,10 +34,10 @@ exports.resetCognitiveWorkspace = resetCognitiveWorkspace;
 exports.DEFAULT_WORKSPACE_CONFIG = {
     maxItems: 7,
     maxTokens: 8192,
-    decayRate: 0.01,
+    decayRate: 0.005, // Self-improved: slower decay for persistence
     boostOnAccess: 0.3,
     minActivation: 0.1,
-    anticipationDepth: 5,
+    anticipationDepth: 7, // Self-improved: better context pre-loading
     associationStrength: 0.3,
     curationInterval: 5000,
     autoCurate: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-ai-cli",
-  "version": "7.17.0",
+  "version": "7.18.1",
   "description": "Autonomous AI System Creator - Brain ON by default, Active Inference integrated, Curiosity-driven, Φ monitoring in every response",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",