genesis-ai-cli 8.0.1 → 8.2.0

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

@@ -53,6 +53,10 @@ export declare class Brain {
     private stateStore;
     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;
@@ -117,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
      */
@@ -193,6 +206,7 @@ export declare class Brain {
     private createInitialMetrics;
     /**
      * Update metrics after a cycle
+     * v8.1: Also persist metrics to disk
      */
     private updateMetrics;
     /**
@@ -213,6 +227,7 @@ export declare class Brain {
     private emit;
     /**
      * Get brain status
+     * v8.1: Includes persisted consciousness stats
      */
     getStatus(): {
         running: boolean;
@@ -221,6 +236,14 @@ export declare class Brain {
         lastState: BrainState | null;
         metrics: BrainMetrics;
         moduleStates: Record<string, boolean>;
+        persisted: {
+            peakPhi: number;
+            avgPhi: number;
+            totalIgnitions: number;
+            totalBroadcasts: number;
+            totalSessions: number;
+            totalUptime: number;
+        };
     };
     /**
      * Get configuration

package/dist/src/brain/index.js

@@ -75,6 +75,8 @@ const index_js_6 = require("../kernel/index.js");
 const index_js_7 = require("../persistence/index.js");
 const index_js_8 = require("../world-model/index.js");
 const index_js_9 = require("../self-modification/index.js");
+// v8.1: Brain State Persistence
+const persistence_js_1 = require("./persistence.js");
 // ============================================================================
 // Brain Class
 // ============================================================================
@@ -95,6 +97,12 @@ class Brain {
     stateStore = null;
     worldModel = null;
     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;
@@ -139,6 +147,9 @@ class Brain {
                 thinkingBudget: 4096,
             });
         }
+        // v8.1: Initialize state persistence and load persisted metrics
+        this.persistence = (0, persistence_js_1.getBrainStatePersistence)();
+        this.metrics = { ...this.metrics, ...this.persistence.getMetrics() };
         // v7.13: Initialize full module integration (lazy - on first use)
         this.initializeV713Modules();
     }
@@ -556,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) {
@@ -567,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++;
+                    }
                 }
             }
         }
@@ -603,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
      */
@@ -1374,6 +1437,7 @@ class Brain {
     }
     /**
      * Update metrics after a cycle
+     * v8.1: Also persist metrics to disk
      */
     updateMetrics(state, transitions) {
         const cycleTime = Date.now() - state.startTime;
@@ -1397,6 +1461,23 @@ class Brain {
             this.metrics.moduleTransitions[module] =
                 (this.metrics.moduleTransitions[module] || 0) + 1;
         }
+        // v8.1: Persist metrics and phi to disk
+        this.persistence.updateMetrics({
+            totalCycles: 1,
+            successfulCycles: state.error ? 0 : 1,
+            failedCycles: state.error ? 1 : 0,
+            avgCycleTime: cycleTime,
+            memoryRecalls: state.context.immediate.length + state.context.episodic.length,
+            toolExecutions: state.toolResults.length,
+            toolSuccesses: state.toolResults.filter(r => r.success).length,
+            toolFailures: state.toolResults.filter(r => !r.success).length,
+            healingAttempts: state.healingAttempts,
+        });
+        this.persistence.recordPhi(state.phi, state.query.slice(0, 50));
+        if (state.ignited) {
+            this.persistence.recordBroadcast();
+        }
+        this.persistence.save();
     }
     /**
      * Get current metrics
@@ -1438,8 +1519,11 @@ class Brain {
     // ============================================================================
     /**
      * Get brain status
+     * v8.1: Includes persisted consciousness stats
      */
     getStatus() {
+        const consciousnessStats = this.persistence.getConsciousnessStats();
+        const persistedState = this.persistence.getState();
         return {
             running: this.running,
             phi: this.getCurrentPhi(),
@@ -1461,6 +1545,15 @@ class Brain {
                 worldModel: this.worldModel !== null,
                 selfModify: this.darwinGodel !== null,
             },
+            // v8.1: Persisted stats across sessions
+            persisted: {
+                peakPhi: consciousnessStats.peakPhi,
+                avgPhi: consciousnessStats.avgPhi,
+                totalIgnitions: consciousnessStats.totalIgnitions,
+                totalBroadcasts: consciousnessStats.totalBroadcasts,
+                totalSessions: persistedState.sessions.total,
+                totalUptime: persistedState.sessions.totalUptime,
+            },
         };
     }
     /**

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

@@ -0,0 +1,105 @@
+/**
+ * Genesis v8.1 - Brain State Persistence
+ *
+ * Persists brain metrics and consciousness state between CLI invocations.
+ * State is saved to ~/.genesis/brain-state.json
+ *
+ * Features:
+ * - Auto-save after each brain cycle
+ * - Load state on startup
+ * - Track cumulative metrics across sessions
+ * - Persist phi history for consciousness continuity
+ */
+import { BrainMetrics } from './types.js';
+export interface PersistedBrainState {
+    version: string;
+    created: string;
+    lastModified: string;
+    metrics: BrainMetrics;
+    consciousness: {
+        currentPhi: number;
+        peakPhi: number;
+        avgPhi: number;
+        phiHistory: PhiSnapshot[];
+        totalIgnitions: number;
+        totalBroadcasts: number;
+        consciousnessViolations: number;
+    };
+    sessions: {
+        total: number;
+        totalUptime: number;
+        lastSessionId: string;
+        lastSessionStart: string;
+        lastSessionEnd: string;
+    };
+    memory: {
+        totalRecalls: number;
+        totalAnticipations: number;
+        cumulativeReuseRate: number;
+    };
+}
+export interface PhiSnapshot {
+    timestamp: string;
+    phi: number;
+    ignited: boolean;
+    trigger?: string;
+}
+export declare class BrainStatePersistence {
+    private dataDir;
+    private statePath;
+    private state;
+    private dirty;
+    private sessionId;
+    private sessionStart;
+    constructor(dataDir?: string);
+    /**
+     * Load brain state from disk
+     */
+    private load;
+    /**
+     * Save brain state to disk
+     */
+    save(): boolean;
+    /**
+     * Update metrics after a brain cycle
+     */
+    updateMetrics(metrics: Partial<BrainMetrics>): void;
+    /**
+     * Record a phi snapshot
+     */
+    recordPhi(phi: number, trigger?: string): void;
+    /**
+     * Record a broadcast event
+     */
+    recordBroadcast(): void;
+    /**
+     * Record a consciousness violation
+     */
+    recordViolation(): void;
+    /**
+     * Get current persisted state
+     */
+    getState(): PersistedBrainState;
+    /**
+     * Get persisted metrics
+     */
+    getMetrics(): BrainMetrics;
+    /**
+     * Get consciousness stats
+     */
+    getConsciousnessStats(): PersistedBrainState['consciousness'];
+    /**
+     * Get current phi (persisted)
+     */
+    getCurrentPhi(): number;
+    /**
+     * Reset all state (fresh start)
+     */
+    reset(): void;
+    private ensureDataDir;
+    private generateSessionId;
+    private createInitialState;
+    private migrate;
+}
+export declare function getBrainStatePersistence(dataDir?: string): BrainStatePersistence;
+export declare function resetBrainStatePersistence(): void;

package/dist/src/brain/persistence.js

@@ -0,0 +1,351 @@
+"use strict";
+/**
+ * Genesis v8.1 - Brain State Persistence
+ *
+ * Persists brain metrics and consciousness state between CLI invocations.
+ * State is saved to ~/.genesis/brain-state.json
+ *
+ * Features:
+ * - Auto-save after each brain cycle
+ * - Load state on startup
+ * - Track cumulative metrics across sessions
+ * - Persist phi history for consciousness continuity
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrainStatePersistence = void 0;
+exports.getBrainStatePersistence = getBrainStatePersistence;
+exports.resetBrainStatePersistence = resetBrainStatePersistence;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_DATA_DIR = path.join(process.env.HOME || '.', '.genesis');
+const BRAIN_STATE_FILE = 'brain-state.json';
+const PHI_HISTORY_MAX = 100; // Keep last 100 phi readings
+const VERSION = '8.1.0';
+// ============================================================================
+// Brain State Persistence Class
+// ============================================================================
+class BrainStatePersistence {
+    dataDir;
+    statePath;
+    state;
+    dirty = false;
+    sessionId;
+    sessionStart;
+    constructor(dataDir) {
+        this.dataDir = dataDir || DEFAULT_DATA_DIR;
+        this.statePath = path.join(this.dataDir, BRAIN_STATE_FILE);
+        this.sessionId = this.generateSessionId();
+        this.sessionStart = new Date();
+        // Ensure data directory exists
+        this.ensureDataDir();
+        // Load or create initial state
+        this.state = this.load();
+        // Update session info
+        this.state.sessions.total++;
+        this.state.sessions.lastSessionId = this.sessionId;
+        this.state.sessions.lastSessionStart = this.sessionStart.toISOString();
+        this.dirty = true;
+    }
+    // ============================================================================
+    // Core Operations
+    // ============================================================================
+    /**
+     * Load brain state from disk
+     */
+    load() {
+        try {
+            if (fs.existsSync(this.statePath)) {
+                const raw = fs.readFileSync(this.statePath, 'utf-8');
+                const state = JSON.parse(raw);
+                // Validate version and migrate if needed
+                if (state.version !== VERSION) {
+                    return this.migrate(state);
+                }
+                return state;
+            }
+        }
+        catch (error) {
+            console.error('[BrainPersistence] Failed to load state:', error);
+        }
+        return this.createInitialState();
+    }
+    /**
+     * Save brain state to disk
+     */
+    save() {
+        if (!this.dirty)
+            return true;
+        try {
+            this.state.lastModified = new Date().toISOString();
+            this.state.sessions.lastSessionEnd = new Date().toISOString();
+            this.state.sessions.totalUptime += Date.now() - this.sessionStart.getTime();
+            const json = JSON.stringify(this.state, null, 2);
+            fs.writeFileSync(this.statePath, json, 'utf-8');
+            this.dirty = false;
+            return true;
+        }
+        catch (error) {
+            console.error('[BrainPersistence] Failed to save state:', error);
+            return false;
+        }
+    }
+    /**
+     * Update metrics after a brain cycle
+     */
+    updateMetrics(metrics) {
+        // Merge metrics (cumulative)
+        const m = this.state.metrics;
+        if (metrics.totalCycles !== undefined)
+            m.totalCycles += metrics.totalCycles;
+        if (metrics.successfulCycles !== undefined)
+            m.successfulCycles += metrics.successfulCycles;
+        if (metrics.failedCycles !== undefined)
+            m.failedCycles += metrics.failedCycles;
+        if (metrics.memoryRecalls !== undefined)
+            m.memoryRecalls += metrics.memoryRecalls;
+        if (metrics.anticipationHits !== undefined)
+            m.anticipationHits += metrics.anticipationHits;
+        if (metrics.anticipationMisses !== undefined)
+            m.anticipationMisses += metrics.anticipationMisses;
+        if (metrics.groundingChecks !== undefined)
+            m.groundingChecks += metrics.groundingChecks;
+        if (metrics.groundingPasses !== undefined)
+            m.groundingPasses += metrics.groundingPasses;
+        if (metrics.groundingFailures !== undefined)
+            m.groundingFailures += metrics.groundingFailures;
+        if (metrics.humanConsultations !== undefined)
+            m.humanConsultations += metrics.humanConsultations;
+        if (metrics.toolExecutions !== undefined)
+            m.toolExecutions += metrics.toolExecutions;
+        if (metrics.toolSuccesses !== undefined)
+            m.toolSuccesses += metrics.toolSuccesses;
+        if (metrics.toolFailures !== undefined)
+            m.toolFailures += metrics.toolFailures;
+        if (metrics.healingAttempts !== undefined)
+            m.healingAttempts += metrics.healingAttempts;
+        if (metrics.healingSuccesses !== undefined)
+            m.healingSuccesses += metrics.healingSuccesses;
+        if (metrics.healingFailures !== undefined)
+            m.healingFailures += metrics.healingFailures;
+        // Update avg cycle time (weighted average)
+        if (metrics.avgCycleTime !== undefined && metrics.totalCycles !== undefined) {
+            const totalTime = m.avgCycleTime * (m.totalCycles - metrics.totalCycles) +
+                metrics.avgCycleTime * metrics.totalCycles;
+            m.avgCycleTime = m.totalCycles > 0 ? totalTime / m.totalCycles : 0;
+        }
+        this.dirty = true;
+    }
+    /**
+     * Record a phi snapshot
+     */
+    recordPhi(phi, trigger) {
+        const snapshot = {
+            timestamp: new Date().toISOString(),
+            phi,
+            ignited: phi >= 0.3,
+            trigger,
+        };
+        // Update consciousness tracking
+        const c = this.state.consciousness;
+        c.currentPhi = phi;
+        if (phi > c.peakPhi)
+            c.peakPhi = phi;
+        // Update running average
+        const historyLen = c.phiHistory.length;
+        c.avgPhi = historyLen > 0
+            ? (c.avgPhi * historyLen + phi) / (historyLen + 1)
+            : phi;
+        // Track ignitions
+        if (snapshot.ignited) {
+            c.totalIgnitions++;
+        }
+        // Add to history (keep last N)
+        c.phiHistory.push(snapshot);
+        if (c.phiHistory.length > PHI_HISTORY_MAX) {
+            c.phiHistory.shift();
+        }
+        this.dirty = true;
+    }
+    /**
+     * Record a broadcast event
+     */
+    recordBroadcast() {
+        this.state.consciousness.totalBroadcasts++;
+        this.dirty = true;
+    }
+    /**
+     * Record a consciousness violation
+     */
+    recordViolation() {
+        this.state.consciousness.consciousnessViolations++;
+        this.dirty = true;
+    }
+    /**
+     * Get current persisted state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Get persisted metrics
+     */
+    getMetrics() {
+        return { ...this.state.metrics };
+    }
+    /**
+     * Get consciousness stats
+     */
+    getConsciousnessStats() {
+        return { ...this.state.consciousness };
+    }
+    /**
+     * Get current phi (persisted)
+     */
+    getCurrentPhi() {
+        return this.state.consciousness.currentPhi;
+    }
+    /**
+     * Reset all state (fresh start)
+     */
+    reset() {
+        this.state = this.createInitialState();
+        this.dirty = true;
+        this.save();
+    }
+    // ============================================================================
+    // Helpers
+    // ============================================================================
+    ensureDataDir() {
+        if (!fs.existsSync(this.dataDir)) {
+            fs.mkdirSync(this.dataDir, { recursive: true });
+        }
+    }
+    generateSessionId() {
+        return `session-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+    }
+    createInitialState() {
+        return {
+            version: VERSION,
+            created: new Date().toISOString(),
+            lastModified: new Date().toISOString(),
+            metrics: {
+                totalCycles: 0,
+                successfulCycles: 0,
+                failedCycles: 0,
+                avgCycleTime: 0,
+                memoryRecalls: 0,
+                memoryReuseRate: 0,
+                anticipationHits: 0,
+                anticipationMisses: 0,
+                groundingChecks: 0,
+                groundingPasses: 0,
+                groundingFailures: 0,
+                humanConsultations: 0,
+                toolExecutions: 0,
+                toolSuccesses: 0,
+                toolFailures: 0,
+                healingAttempts: 0,
+                healingSuccesses: 0,
+                healingFailures: 0,
+                avgPhi: 0,
+                phiViolations: 0,
+                broadcasts: 0,
+                moduleTransitions: {},
+            },
+            consciousness: {
+                currentPhi: 0,
+                peakPhi: 0,
+                avgPhi: 0,
+                phiHistory: [],
+                totalIgnitions: 0,
+                totalBroadcasts: 0,
+                consciousnessViolations: 0,
+            },
+            sessions: {
+                total: 0,
+                totalUptime: 0,
+                lastSessionId: '',
+                lastSessionStart: '',
+                lastSessionEnd: '',
+            },
+            memory: {
+                totalRecalls: 0,
+                totalAnticipations: 0,
+                cumulativeReuseRate: 0,
+            },
+        };
+    }
+    migrate(oldState) {
+        // Migrate from older versions
+        const newState = this.createInitialState();
+        // Preserve what we can
+        if (oldState.metrics) {
+            newState.metrics = { ...newState.metrics, ...oldState.metrics };
+        }
+        if (oldState.consciousness) {
+            newState.consciousness = { ...newState.consciousness, ...oldState.consciousness };
+        }
+        if (oldState.sessions) {
+            newState.sessions = { ...newState.sessions, ...oldState.sessions };
+        }
+        if (oldState.memory) {
+            newState.memory = { ...newState.memory, ...oldState.memory };
+        }
+        newState.version = VERSION;
+        newState.created = oldState.created || newState.created;
+        return newState;
+    }
+}
+exports.BrainStatePersistence = BrainStatePersistence;
+// ============================================================================
+// Singleton Instance
+// ============================================================================
+let persistenceInstance = null;
+function getBrainStatePersistence(dataDir) {
+    if (!persistenceInstance) {
+        persistenceInstance = new BrainStatePersistence(dataDir);
+    }
+    return persistenceInstance;
+}
+function resetBrainStatePersistence() {
+    if (persistenceInstance) {
+        persistenceInstance.save();
+    }
+    persistenceInstance = null;
+}

package/dist/src/index.js

@@ -909,8 +909,8 @@ async function cmdBrain(subcommand, options) {
         return;
     }
     if (subcommand === 'phi') {
-        const metrics = brain.getMetrics();
-        const phi = metrics.avgPhi;
+        const status = brain.getStatus();
+        const phi = status.persisted.avgPhi; // v8.1: Use persisted phi
         console.log(c('\n=== CONSCIOUSNESS LEVEL (φ) ===\n', 'bold'));
         // Visual bar
         const width = 30;
@@ -930,6 +930,14 @@ async function cmdBrain(subcommand, options) {
             console.log(`  Level:        ${c(bar, 'dim')} LOW`);
             console.log(`  Status:       ${c('Local processing - no broadcasting', 'dim')}`);
         }
+        // v8.1: Show persisted consciousness history
+        console.log();
+        console.log(c('History (persisted):', 'cyan'));
+        console.log(`  Peak φ:       ${status.persisted.peakPhi.toFixed(3)}`);
+        console.log(`  Avg φ:        ${status.persisted.avgPhi.toFixed(3)}`);
+        console.log(`  Ignitions:    ${status.persisted.totalIgnitions} (φ > 0.3 events)`);
+        console.log(`  Broadcasts:   ${status.persisted.totalBroadcasts}`);
+        console.log(`  Sessions:     ${status.persisted.totalSessions}`);
         console.log();
         console.log(c('Theory:', 'dim'));
         console.log('  φ (phi) measures integrated information (IIT 4.0)');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-ai-cli",
-  "version": "8.0.1",
+  "version": "8.2.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",