genesis-ai-cli 8.1.0 → 8.3.0

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

@@ -61,6 +61,9 @@ const child_process_1 = require("child_process");
 const util_1 = require("util");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+// v8.3: Self-modification imports
+const darwin_godel_js_1 = require("../self-modification/darwin-godel.js");
+const self_improvement_js_1 = require("../self-modification/self-improvement.js");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 // ============================================================================
 // Lazy Singleton Instances
@@ -1410,6 +1413,215 @@ registerAction('code.diff', async (context) => {
     }
 });
 // ============================================================================
+// SELF-MODIFICATION EXECUTOR (v8.3)
+// ============================================================================
+/**
+ * self.modify: Radical self-modification via Darwin-Gödel Engine
+ *
+ * This is the core action that allows Genesis to modify its own code.
+ * Requires:
+ * - φ ≥ 0.3 (consciousness threshold)
+ * - Valid modification plan
+ * - All invariants must pass after modification
+ *
+ * Flow:
+ * 1. Check consciousness level
+ * 2. Generate or use provided modification plan
+ * 3. Validate plan (syntax, safety)
+ * 4. Apply in sandbox
+ * 5. Verify (build, test, invariants)
+ * 6. Atomic apply on success
+ * 7. Store outcome in memory
+ */
+registerAction('self.modify', async (context) => {
+    const start = Date.now();
+    try {
+        // 1. Check consciousness level
+        const phiMonitor = getPhiMonitor();
+        const level = phiMonitor.getCurrentLevel();
+        const phi = level.phi;
+        if (phi < 0.3) {
+            return {
+                success: false,
+                action: 'self.modify',
+                error: `Insufficient consciousness level: φ=${phi.toFixed(3)} (need ≥0.3)`,
+                data: { phi, threshold: 0.3 },
+                duration: Date.now() - start,
+            };
+        }
+        // 2. Get or create modification plan
+        let plan;
+        if (context.parameters?.plan) {
+            // Use provided plan
+            plan = context.parameters.plan;
+        }
+        else if (context.parameters?.targetMetric) {
+            // Use SelfImprovementEngine to find opportunity
+            const engine = (0, self_improvement_js_1.getSelfImprovementEngine)();
+            const cycleResult = await engine.runCycle();
+            // Find opportunity matching target metric
+            const targetMetric = context.parameters.targetMetric;
+            const opportunity = cycleResult.opportunities.find((o) => o.metric === targetMetric);
+            if (!opportunity || !opportunity.suggestedFix) {
+                return {
+                    success: false,
+                    action: 'self.modify',
+                    error: `No improvement opportunity found for metric: ${targetMetric}`,
+                    data: {
+                        metrics: cycleResult.metrics,
+                        availableOpportunities: cycleResult.opportunities.map((o) => o.metric),
+                    },
+                    duration: Date.now() - start,
+                };
+            }
+            plan = opportunity.suggestedFix;
+        }
+        else {
+            // Auto-detect: run full improvement cycle
+            const engine = (0, self_improvement_js_1.getSelfImprovementEngine)();
+            const result = await engine.runCycle();
+            if (result.results.length === 0) {
+                return {
+                    success: true,
+                    action: 'self.modify',
+                    data: {
+                        message: 'No improvements needed - all metrics within targets',
+                        metrics: result.metrics,
+                        opportunities: result.opportunities.length,
+                    },
+                    duration: Date.now() - start,
+                };
+            }
+            // Return first improvement result
+            const improvement = result.results[0];
+            return {
+                success: improvement.success,
+                action: 'self.modify',
+                data: {
+                    opportunityId: improvement.opportunityId,
+                    applied: improvement.applied,
+                    beforeMetrics: improvement.beforeMetrics,
+                    afterMetrics: improvement.afterMetrics,
+                    commitHash: improvement.commitHash,
+                },
+                duration: Date.now() - start,
+            };
+        }
+        // 3. Apply via Darwin-Gödel Engine
+        const darwinGodel = (0, darwin_godel_js_1.getDarwinGodelEngine)();
+        const applyResult = await darwinGodel.apply(plan);
+        // 4. Log outcome (memory storage removed - use event system instead)
+        console.log(`[self.modify] ${applyResult.success ? 'SUCCESS' : 'FAILED'}: ${plan.name}`);
+        return {
+            success: applyResult.success,
+            action: 'self.modify',
+            data: {
+                planId: plan.id,
+                planName: plan.name,
+                modificationsCount: plan.modifications.length,
+                verification: {
+                    buildSuccess: applyResult.verificaton.buildSuccess,
+                    testsSuccess: applyResult.verificaton.testsSuccess,
+                    invariantsPass: applyResult.verificaton.invariantsPass,
+                },
+                commitHash: applyResult.commitHash,
+                rollbackHash: applyResult.rollbackHash,
+                canRollback: !!applyResult.rollbackHash,
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'self.modify',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+/**
+ * improve.self: High-level self-improvement action
+ *
+ * Observes metrics, identifies bottlenecks, and triggers self.modify.
+ * This is the "autonomous improvement" entry point.
+ */
+registerAction('improve.self', async (context) => {
+    const start = Date.now();
+    try {
+        const engine = (0, self_improvement_js_1.getSelfImprovementEngine)();
+        // 1. Run improvement cycle (observe + reflect + optionally apply)
+        const cycleResult = await engine.runCycle();
+        const { metrics, opportunities, results } = cycleResult;
+        if (opportunities.length === 0) {
+            return {
+                success: true,
+                action: 'improve.self',
+                data: {
+                    message: 'System is operating within optimal parameters',
+                    metrics: {
+                        phi: metrics.phi,
+                        memoryReuse: metrics.memoryReuse,
+                        errorRate: metrics.errorRate,
+                        taskSuccessRate: metrics.taskSuccessRate,
+                    },
+                },
+                duration: Date.now() - start,
+            };
+        }
+        // 2. Sort by priority and pick top
+        const sorted = [...opportunities].sort((a, b) => b.priority - a.priority);
+        const topOpportunity = sorted[0];
+        // 3. If autoApply and we have results, report them
+        if (context.parameters?.autoApply && results.length > 0) {
+            return {
+                success: true,
+                action: 'improve.self',
+                data: {
+                    applied: results.length > 0,
+                    improvements: results.map((i) => ({
+                        id: i.opportunityId,
+                        success: i.success,
+                    })),
+                    metrics: metrics,
+                },
+                duration: Date.now() - start,
+            };
+        }
+        // 4. Otherwise, just report opportunities
+        return {
+            success: true,
+            action: 'improve.self',
+            data: {
+                opportunities: sorted.map((o) => ({
+                    id: o.id,
+                    category: o.category,
+                    metric: o.metric,
+                    current: o.currentValue,
+                    target: o.targetValue,
+                    priority: o.priority,
+                    description: o.description,
+                })),
+                topRecommendation: {
+                    metric: topOpportunity.metric,
+                    description: topOpportunity.description,
+                    priority: topOpportunity.priority,
+                },
+                hint: 'Use self.modify with targetMetric parameter to apply improvement',
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'improve.self',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+// ============================================================================
 // Action Executor Manager
 // ============================================================================
 class ActionExecutorManager {

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

@@ -54,6 +54,9 @@ export declare class Brain {
     private worldModel;
     private darwinGodel;
     private persistence;
+    private toolCache;
+    private readonly TOOL_CACHE_TTL;
+    private readonly TOOL_CACHE_MAX_SIZE;
     private running;
     private currentState;
     private systemPrompt;
@@ -118,8 +121,17 @@ export declare class Brain {
     private stepGrounding;
     /**
      * Tools module: execute tool calls
+     * v8.2: Added caching for repeated tool calls
      */
     private stepTools;
+    /**
+     * v8.2: Clean expired entries from tool cache
+     */
+    private cleanToolCache;
+    /**
+     * v8.2: Generate cache key from tool call
+     */
+    private getToolCacheKey;
     /**
      * Healing module: recover from errors
      */

package/dist/src/brain/index.js

@@ -99,6 +99,10 @@ class Brain {
     darwinGodel = null;
     // v8.1: State Persistence
     persistence;
+    // v8.2: Tool Results Cache (approved self-modification)
+    toolCache = new Map();
+    TOOL_CACHE_TTL = 60000; // 1 minute TTL
+    TOOL_CACHE_MAX_SIZE = 100;
     // State
     running = false;
     currentState = null;
@@ -563,6 +567,7 @@ class Brain {
     }
     /**
      * Tools module: execute tool calls
+     * v8.2: Added caching for repeated tool calls
      */
     async stepTools(state) {
         if (state.toolCalls.length === 0) {
@@ -574,21 +579,44 @@ class Brain {
         // Parse tool calls for dispatcher
         const dispatcherCalls = this.dispatcher.parseToolCalls(state.response);
         const results = [];
+        // v8.2: Check cache and clean expired entries
+        this.cleanToolCache();
         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) {
+            const uncachedCalls = [];
+            // v8.2: Check cache for each call
+            for (const call of dispatcherCalls) {
+                const cacheKey = this.getToolCacheKey(call);
+                const cached = this.toolCache.get(cacheKey);
+                if (cached && (Date.now() - cached.timestamp) < this.TOOL_CACHE_TTL) {
+                    // Cache hit
+                    results.push({ ...cached.result, cached: true });
                     this.metrics.toolSuccesses++;
                 }
                 else {
-                    this.metrics.toolFailures++;
+                    uncachedCalls.push(call);
+                }
+            }
+            // Execute uncached calls
+            if (uncachedCalls.length > 0) {
+                const dispatchResult = await this.dispatcher.dispatch(uncachedCalls);
+                for (const r of dispatchResult.results) {
+                    const result = {
+                        name: r.name,
+                        success: r.success,
+                        data: r.data,
+                        error: r.error,
+                        duration: r.duration,
+                    };
+                    results.push(result);
+                    // v8.2: Cache successful results
+                    if (r.success) {
+                        const cacheKey = this.getToolCacheKey({ name: r.name, arguments: {} });
+                        this.toolCache.set(cacheKey, { result, timestamp: Date.now() });
+                        this.metrics.toolSuccesses++;
+                    }
+                    else {
+                        this.metrics.toolFailures++;
+                    }
                 }
             }
         }
@@ -610,6 +638,34 @@ class Brain {
             reason: 'tool_results',
         };
     }
+    /**
+     * v8.2: Clean expired entries from tool cache
+     */
+    cleanToolCache() {
+        const now = Date.now();
+        // Remove expired entries
+        for (const [key, entry] of this.toolCache.entries()) {
+            if (now - entry.timestamp > this.TOOL_CACHE_TTL) {
+                this.toolCache.delete(key);
+            }
+        }
+        // Enforce max size (LRU-style: remove oldest entries)
+        if (this.toolCache.size > this.TOOL_CACHE_MAX_SIZE) {
+            const entries = Array.from(this.toolCache.entries())
+                .sort((a, b) => a[1].timestamp - b[1].timestamp);
+            const toRemove = entries.slice(0, this.toolCache.size - this.TOOL_CACHE_MAX_SIZE);
+            for (const [key] of toRemove) {
+                this.toolCache.delete(key);
+            }
+        }
+    }
+    /**
+     * v8.2: Generate cache key from tool call
+     */
+    getToolCacheKey(call) {
+        const argsStr = call.arguments ? JSON.stringify(call.arguments) : '';
+        return `${call.name}:${argsStr}`;
+    }
     /**
      * Healing module: recover from errors
      */

package/dist/test/brain.test.js

@@ -123,18 +123,24 @@ const node_assert_1 = __importDefault(require("node:assert"));
         });
     });
     (0, node_test_1.describe)('Brain Metrics', () => {
-        (0, node_test_1.test)('initial metrics are zeroed', async () => {
+        (0, node_test_1.test)('metrics have correct structure and types', async () => {
             const { createBrain } = await import('../src/brain/index.js');
             const brain = createBrain();
             const metrics = brain.getMetrics();
-            node_assert_1.default.strictEqual(metrics.totalCycles, 0);
-            node_assert_1.default.strictEqual(metrics.successfulCycles, 0);
-            node_assert_1.default.strictEqual(metrics.failedCycles, 0);
-            node_assert_1.default.strictEqual(metrics.memoryRecalls, 0);
-            node_assert_1.default.strictEqual(metrics.groundingChecks, 0);
-            node_assert_1.default.strictEqual(metrics.toolExecutions, 0);
-            node_assert_1.default.strictEqual(metrics.healingAttempts, 0);
-            node_assert_1.default.strictEqual(metrics.broadcasts, 0);
+            // Note: Due to v8.1 state persistence, metrics may carry over from previous runs
+            // We verify the metrics structure and types rather than exact values
+            node_assert_1.default.ok(typeof metrics.totalCycles === 'number', 'totalCycles should be a number');
+            node_assert_1.default.ok(typeof metrics.successfulCycles === 'number', 'successfulCycles should be a number');
+            node_assert_1.default.ok(typeof metrics.failedCycles === 'number', 'failedCycles should be a number');
+            node_assert_1.default.ok(typeof metrics.memoryRecalls === 'number', 'memoryRecalls should be a number');
+            node_assert_1.default.ok(typeof metrics.groundingChecks === 'number', 'groundingChecks should be a number');
+            node_assert_1.default.ok(typeof metrics.toolExecutions === 'number', 'toolExecutions should be a number');
+            node_assert_1.default.ok(typeof metrics.healingAttempts === 'number', 'healingAttempts should be a number');
+            node_assert_1.default.ok(typeof metrics.broadcasts === 'number', 'broadcasts should be a number');
+            // Verify metrics are non-negative
+            node_assert_1.default.ok(metrics.totalCycles >= 0, 'totalCycles should be >= 0');
+            node_assert_1.default.ok(metrics.successfulCycles >= 0, 'successfulCycles should be >= 0');
+            node_assert_1.default.ok(metrics.failedCycles >= 0, 'failedCycles should be >= 0');
         });
         (0, node_test_1.test)('metrics track avgPhi', async () => {
             const { createBrain } = await import('../src/brain/index.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-ai-cli",
-  "version": "8.1.0",
+  "version": "8.3.0",
   "description": "Fully Autonomous AI System - Self-funding, Self-deploying, Production Memory, A2A Protocol & Governance",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",