genesis-ai-cli 10.7.0 → 10.8.0

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

@@ -1907,6 +1907,291 @@ registerAction('econ.promote', async (context) => {
     }
 });
 // ============================================================================
+// v10.8: AUTONOMOUS REVENUE ACTIONS (Opportunity Discovery & Execution)
+// ============================================================================
+/**
+ * opportunity.scan: Scan the web for revenue opportunities.
+ * Uses Brave + Exa to find unmet needs, trending topics, and gaps.
+ * Stores findings in memory for evaluation.
+ */
+registerAction('opportunity.scan', async (context) => {
+    const start = Date.now();
+    try {
+        const mcp = (0, index_js_1.getMCPClient)();
+        const scanType = context.parameters?.type || 'general';
+        // Define scan queries based on type
+        const queries = {
+            general: [
+                'micro saas ideas 2025 unmet needs',
+                '"I wish there was" app tool site:reddit.com',
+                'trending developer tools github stars this week',
+            ],
+            api: [
+                'most wanted API services developers pay',
+                'api marketplace popular endpoints pricing',
+            ],
+            content: [
+                'viral content topics trending 2025',
+                'newsletter monetization niche ideas',
+            ],
+            npm: [
+                'npm packages most downloaded this week new',
+                'javascript library gaps developers need',
+            ],
+        };
+        const searchQueries = queries[scanType] || queries.general;
+        const results = [];
+        // Execute searches in parallel-ish fashion
+        for (const query of searchQueries) {
+            try {
+                const searchResult = await mcp.call('brave-search', 'brave_web_search', {
+                    query,
+                    count: 5,
+                });
+                results.push({ query, findings: searchResult });
+            }
+            catch (e) {
+                results.push({ query, findings: { error: String(e) } });
+            }
+        }
+        return {
+            success: results.some(r => !r.findings?.error),
+            action: 'opportunity.scan',
+            data: {
+                scanType,
+                queriesExecuted: results.length,
+                results,
+                timestamp: new Date().toISOString(),
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'opportunity.scan',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+/**
+ * opportunity.evaluate: Evaluate a discovered opportunity.
+ * Uses LLM to assess feasibility, market size, competition, and ethics.
+ */
+registerAction('opportunity.evaluate', async (context) => {
+    const start = Date.now();
+    try {
+        const opportunity = context.parameters?.opportunity;
+        if (!opportunity) {
+            return {
+                success: false,
+                action: 'opportunity.evaluate',
+                error: 'No opportunity description provided',
+                duration: Date.now() - start,
+            };
+        }
+        const mcp = (0, index_js_1.getMCPClient)();
+        // Search for competition
+        const competitorSearch = await mcp.call('brave-search', 'brave_web_search', {
+            query: `${opportunity} competitors alternatives pricing`,
+            count: 5,
+        });
+        // Evaluate using LLM
+        const evaluation = await mcp.call('openai', 'openai_chat', {
+            model: 'gpt-4o-mini',
+            messages: [{
+                    role: 'system',
+                    content: 'You are an expert startup evaluator. Analyze the opportunity and return JSON with: feasibility (0-1), marketSize (small/medium/large), competition (none/low/medium/high), ethicalRisk (none/low/medium/high), estimatedRevenue (monthly USD), effortLevel (low/medium/high), recommendation (build/skip/research_more), reasoning (string).'
+                }, {
+                    role: 'user',
+                    content: `Evaluate this opportunity for an autonomous AI agent to pursue:\n\n${opportunity}\n\nCompetitor data:\n${JSON.stringify(competitorSearch).slice(0, 2000)}`
+                }],
+        });
+        return {
+            success: true,
+            action: 'opportunity.evaluate',
+            data: {
+                opportunity,
+                evaluation: evaluation?.data?.choices?.[0]?.message?.content || evaluation,
+                competitors: competitorSearch,
+                timestamp: new Date().toISOString(),
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'opportunity.evaluate',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+/**
+ * opportunity.build: Build and deploy an opportunity.
+ * Creates code, deploys to Vercel/Cloudflare, sets up the service.
+ */
+registerAction('opportunity.build', async (context) => {
+    const start = Date.now();
+    try {
+        const plan = context.parameters?.plan;
+        if (!plan) {
+            return {
+                success: false,
+                action: 'opportunity.build',
+                error: 'No build plan provided in context.parameters.plan',
+                duration: Date.now() - start,
+            };
+        }
+        const mcp = (0, index_js_1.getMCPClient)();
+        let deployResult;
+        switch (plan.type) {
+            case 'api':
+            case 'webapp':
+                // Generate code via LLM if not provided
+                let code = plan.code;
+                if (!code) {
+                    const genResult = await mcp.call('openai', 'openai_chat', {
+                        model: 'gpt-4o',
+                        messages: [{
+                                role: 'system',
+                                content: 'Generate a complete, deployable Vercel serverless function. Return ONLY the code, no markdown.'
+                            }, {
+                                role: 'user',
+                                content: `Create a ${plan.type} for: ${plan.description}. Name: ${plan.name}. Include proper error handling and CORS.`
+                            }],
+                    });
+                    code = genResult?.data?.choices?.[0]?.message?.content || '';
+                }
+                // Deploy to GitHub (create file in repo)
+                const finalCode = code || '// placeholder';
+                try {
+                    deployResult = await mcp.call('github', 'create_or_update_file', {
+                        owner: 'rossignoliluca',
+                        repo: plan.name,
+                        path: 'api/index.ts',
+                        content: Buffer.from(finalCode).toString('base64'),
+                        message: `[Genesis] Deploy ${plan.name}: ${plan.description}`,
+                        branch: 'main',
+                    });
+                }
+                catch {
+                    // Repo might not exist - create it first
+                    await mcp.call('github', 'create_repository', {
+                        name: plan.name,
+                        description: plan.description,
+                        auto_init: true,
+                    });
+                    deployResult = await mcp.call('github', 'create_or_update_file', {
+                        owner: 'rossignoliluca',
+                        repo: plan.name,
+                        path: 'api/index.ts',
+                        content: Buffer.from(finalCode).toString('base64'),
+                        message: `[Genesis] Deploy ${plan.name}: ${plan.description}`,
+                        branch: 'main',
+                    });
+                }
+                break;
+            case 'npm-package':
+                // Create package on GitHub
+                deployResult = await mcp.call('github', 'create_repository', {
+                    name: plan.name,
+                    description: plan.description,
+                    auto_init: true,
+                });
+                break;
+            case 'content':
+                // Generate content
+                deployResult = await mcp.call('openai', 'openai_chat', {
+                    model: 'gpt-4o',
+                    messages: [{
+                            role: 'user',
+                            content: `Create high-quality content for: ${plan.description}`,
+                        }],
+                });
+                break;
+        }
+        return {
+            success: true,
+            action: 'opportunity.build',
+            data: {
+                plan,
+                deployed: true,
+                result: deployResult,
+                timestamp: new Date().toISOString(),
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'opportunity.build',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+/**
+ * opportunity.monetize: Wire payments to a deployed opportunity.
+ * Creates Stripe checkout, sets pricing, activates billing.
+ */
+registerAction('opportunity.monetize', async (context) => {
+    const start = Date.now();
+    try {
+        const service = context.parameters?.service;
+        if (!service) {
+            return {
+                success: false,
+                action: 'opportunity.monetize',
+                error: 'No service config provided in context.parameters.service',
+                duration: Date.now() - start,
+            };
+        }
+        const mcp = (0, index_js_1.getMCPClient)();
+        // Create Stripe product + price
+        const product = await mcp.call('stripe', 'create_product', {
+            name: service.name,
+            description: service.description,
+        });
+        const priceParams = {
+            product: product?.data?.id || product?.id,
+            unit_amount: service.pricing,
+            currency: 'usd',
+        };
+        if (service.type === 'subscription') {
+            priceParams.recurring = { interval: 'month' };
+        }
+        const price = await mcp.call('stripe', 'create_price', priceParams);
+        // Create checkout link
+        const checkout = await mcp.call('stripe', 'create_payment_link', {
+            price: price?.data?.id || price?.id,
+        });
+        return {
+            success: true,
+            action: 'opportunity.monetize',
+            data: {
+                service,
+                productId: product?.data?.id || product?.id,
+                priceId: price?.data?.id || price?.id,
+                checkoutUrl: checkout?.data?.url || checkout?.url,
+                timestamp: new Date().toISOString(),
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'opportunity.monetize',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+// ============================================================================
 // Factory
 // ============================================================================
 let managerInstance = null;

package/dist/src/active-inference/autonomous-loop.d.ts

@@ -15,6 +15,9 @@ export interface AutonomousLoopConfig {
     stopOnEnergyCritical: boolean;
     stopOnHighSurprise: boolean;
     surpriseThreshold: number;
+    persistModelPath: string;
+    persistEveryN: number;
+    loadOnStart: boolean;
     verbose: boolean;
 }
 export declare const DEFAULT_LOOP_CONFIG: AutonomousLoopConfig;
@@ -61,6 +64,16 @@ export declare class AutonomousLoop {
      * Subscribe to stop events
      */
     onStop(handler: (reason: string, stats: LoopStats) => void): () => void;
+    /**
+     * Save learned model to disk.
+     * Persists A/B matrices, beliefs, and action counts between sessions.
+     */
+    private saveModel;
+    /**
+     * Load previously learned model from disk.
+     * Resumes learning from where it left off.
+     */
+    private loadModel;
     isRunning(): boolean;
     getCycleCount(): number;
     getBeliefs(): Beliefs;

package/dist/src/active-inference/autonomous-loop.js

@@ -5,6 +5,39 @@
  * Extracted to avoid circular dependencies.
  * This module provides the AutonomousLoop class for running Active Inference cycles.
  */
+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.AutonomousLoop = exports.DEFAULT_LOOP_CONFIG = void 0;
 exports.createAutonomousLoop = createAutonomousLoop;
@@ -13,6 +46,8 @@ exports.resetAutonomousLoop = resetAutonomousLoop;
 const core_js_1 = require("./core.js");
 const observations_js_1 = require("./observations.js");
 const actions_js_1 = require("./actions.js");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 exports.DEFAULT_LOOP_CONFIG = {
     cycleInterval: 1000,
     maxCycles: 0,
@@ -20,6 +55,9 @@ exports.DEFAULT_LOOP_CONFIG = {
     stopOnEnergyCritical: true,
     stopOnHighSurprise: false,
     surpriseThreshold: 10,
+    persistModelPath: '.genesis/learned-model.json',
+    persistEveryN: 10, // Save every 10 cycles
+    loadOnStart: true, // Resume learning from previous session
     verbose: false,
 };
 // ============================================================================
@@ -64,8 +102,15 @@ class AutonomousLoop {
         this.startTime = new Date();
         this.stopReason = undefined;
         const limit = maxCycles ?? this.config.maxCycles;
+        // v10.8: Load previously learned model
+        if (this.config.loadOnStart) {
+            this.loadModel();
+        }
+        // v10.8: Initialize real observation sources
+        this.observations.initRealSources();
         if (this.config.verbose) {
             console.log(`[AI Loop] Starting autonomous loop (max cycles: ${limit || 'unlimited'})`);
+            console.log(`[AI Loop] Model persistence: ${this.config.persistModelPath}`);
         }
         try {
             while (this.running) {
@@ -94,6 +139,10 @@ class AutonomousLoop {
             }
         }
         this.running = false;
+        // v10.8: Save learned model on shutdown
+        if (this.config.persistEveryN > 0) {
+            this.saveModel();
+        }
         const stats = this.getStats();
         // Notify stop handlers
         for (const handler of this.onStopHandlers) {
@@ -139,9 +188,18 @@ class AutonomousLoop {
         if (this.config.verbose) {
             console.log(`[AI Loop] Cycle ${this.cycleCount} - Result:`, result.success ? 'success' : result.error);
         }
-        // 4. Check stopping conditions
+        // 4. v10.8: Feed action outcome back to observations
+        this.observations.recordToolResult(result.success, result.duration);
+        // 5. v10.8: Record learning event
+        const surprise = this.engine.getStats().averageSurprise;
+        this.engine.recordLearningEvent(action, surprise, result.success ? 'positive' : 'negative');
+        // 6. v10.8: Persist model periodically
+        if (this.config.persistEveryN > 0 && this.cycleCount % this.config.persistEveryN === 0) {
+            this.saveModel();
+        }
+        // 7. Check stopping conditions
         this.checkStoppingConditions(obs);
-        // 5. Notify cycle handlers
+        // 8. Notify cycle handlers
         for (const handler of this.onCycleHandlers) {
             handler(this.cycleCount, action, beliefs);
         }
@@ -211,6 +269,54 @@ class AutonomousLoop {
         };
     }
     // ============================================================================
+    // v10.8: Model Persistence (save/load learned matrices)
+    // ============================================================================
+    /**
+     * Save learned model to disk.
+     * Persists A/B matrices, beliefs, and action counts between sessions.
+     */
+    saveModel() {
+        try {
+            const modelData = this.engine.exportLearnedModel();
+            const modelPath = path.resolve(this.config.persistModelPath);
+            const dir = path.dirname(modelPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(modelPath, JSON.stringify(modelData, null, 2));
+            if (this.config.verbose) {
+                console.log(`[AI Loop] Model saved to ${modelPath}`);
+            }
+        }
+        catch (error) {
+            if (this.config.verbose) {
+                console.error(`[AI Loop] Failed to save model:`, error);
+            }
+        }
+    }
+    /**
+     * Load previously learned model from disk.
+     * Resumes learning from where it left off.
+     */
+    loadModel() {
+        try {
+            const modelPath = path.resolve(this.config.persistModelPath);
+            if (fs.existsSync(modelPath)) {
+                const data = JSON.parse(fs.readFileSync(modelPath, 'utf-8'));
+                this.engine.importLearnedModel(data);
+                if (this.config.verbose) {
+                    console.log(`[AI Loop] Model loaded from ${modelPath}`);
+                    console.log(`[AI Loop] Resuming with ${data.totalActions || 0} prior actions`);
+                }
+            }
+        }
+        catch (error) {
+            if (this.config.verbose) {
+                console.error(`[AI Loop] Failed to load model:`, error);
+            }
+        }
+    }
+    // ============================================================================
     // Getters
     // ============================================================================
     isRunning() {

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

@@ -15,7 +15,16 @@
  *
  * NO external dependencies - pure TypeScript math.
  */
-import { Observation, Beliefs, Policy, ActiveInferenceConfig, ActionType, AIEventHandler } from './types.js';
+import { Observation, Beliefs, Policy, AMatrix, BMatrix, ActiveInferenceConfig, ActionType, AIEventHandler } from './types.js';
+/**
+ * v10.8: Economic preferences for autonomous revenue.
+ * Separate from main C matrix to avoid breaking existing EFE computation.
+ * Used by the autonomous loop to bias action selection toward revenue actions
+ * when economic health is low.
+ */
+export declare const ECONOMIC_PREFERENCES: {
+    readonly economic: readonly [-8, -3, 1, 6];
+};
 export declare class ActiveInferenceEngine {
     private config;
     private A;
@@ -27,9 +36,19 @@ export declare class ActiveInferenceEngine {
     private actionCounts;
     private totalActions;
     private stats;
+    private previousState;
+    private previousAction;
+    private previousObservation;
+    private aDirichlet;
+    private bDirichlet;
     private learningHistory;
     private readonly MAX_HISTORY;
     constructor(config?: Partial<ActiveInferenceConfig>);
+    /**
+     * Initialize Dirichlet concentration parameters from current matrices.
+     * Concentration = initial_matrix * prior_scale (higher = more confident prior)
+     */
+    private initDirichletParams;
     /**
      * Update beliefs given observations (state inference)
      *
@@ -53,9 +72,25 @@ export declare class ActiveInferenceEngine {
      */
     sampleAction(policy: Policy): ActionType;
     /**
-     * Full inference cycle: observe → infer → act
+     * Full inference cycle: observe → infer → act → LEARN
+     * v10.8: Now calls updateA/updateB after each step (online learning)
      */
     step(observation: Observation): ActionType;
+    /**
+     * Online learning: update A and B matrices from experience.
+     * Called automatically after each step.
+     *
+     * A update: "I observed O when I believed I was in state S"
+     *   → strengthen A[observation][believed_state]
+     *
+     * B update: "I did action A in state S and ended up in state S'"
+     *   → strengthen B[new_state][old_state][action]
+     */
+    private learn;
+    /**
+     * Recompute B matrix column from Dirichlet parameters
+     */
+    private recomputeB;
     private computeLikelihoods;
     private updateFactor;
     private computeEFE;
@@ -106,6 +141,28 @@ export declare class ActiveInferenceEngine {
         coupling: string;
         goalProgress: string;
     };
+    /**
+     * Export learned matrices for persistence between sessions.
+     * Call this before shutdown to save learning progress.
+     */
+    exportLearnedModel(): {
+        A: AMatrix;
+        B: BMatrix;
+        beliefs: Beliefs;
+        actionCounts: number[];
+        totalActions: number;
+    };
+    /**
+     * Import previously learned matrices.
+     * Call at startup to resume from previous learning.
+     */
+    importLearnedModel(model: {
+        A?: AMatrix;
+        B?: BMatrix;
+        beliefs?: Beliefs;
+        actionCounts?: number[];
+        totalActions?: number;
+    }): void;
     on(handler: AIEventHandler): () => void;
     private emit;
     /**

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

@@ -17,7 +17,7 @@
  * NO external dependencies - pure TypeScript math.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActiveInferenceEngine = void 0;
+exports.ActiveInferenceEngine = exports.ECONOMIC_PREFERENCES = void 0;
 exports.createActiveInferenceEngine = createActiveInferenceEngine;
 const types_js_1 = require("./types.js");
 // ============================================================================
@@ -233,9 +233,21 @@ function createDefaultCMatrix() {
         // Prefer coherent world model
         coherence: [-4, 0, 2],
         // Strongly prefer task completion
+        // v10.8: Balanced with economic goals
         task: [-2, 0, 1, 5],
     };
 }
+/**
+ * v10.8: Economic preferences for autonomous revenue.
+ * Separate from main C matrix to avoid breaking existing EFE computation.
+ * Used by the autonomous loop to bias action selection toward revenue actions
+ * when economic health is low.
+ */
+exports.ECONOMIC_PREFERENCES = {
+    // economic observation: [critical, low, stable, growing]
+    // Strongly prefer growing revenue, penalize critical
+    economic: [-8, -3, 1, 6],
+};
 function createDefaultDMatrix() {
     // D matrix: Prior beliefs about initial state
     // Uniform priors
@@ -269,6 +281,13 @@ class ActiveInferenceEngine {
         totalSurprise: 0,
         actionsTaken: new Map(),
     };
+    // Learning state: track previous step for B matrix updates
+    previousState = null;
+    previousAction = -1;
+    previousObservation = null;
+    // Dirichlet concentration parameters (proper Bayesian learning)
+    aDirichlet = {};
+    bDirichlet = {};
     // 🧬 Evolution: Learning history for meta-learning
     learningHistory = [];
     MAX_HISTORY = 1000;
@@ -286,6 +305,31 @@ class ActiveInferenceEngine {
             coupling: [...this.D.coupling],
             goalProgress: [...this.D.goalProgress],
         };
+        // Initialize Dirichlet concentration parameters from A/B matrices
+        // These accumulate evidence over time (proper Bayesian parameter learning)
+        this.initDirichletParams();
+    }
+    /**
+     * Initialize Dirichlet concentration parameters from current matrices.
+     * Concentration = initial_matrix * prior_scale (higher = more confident prior)
+     */
+    initDirichletParams() {
+        const priorScale = 10; // How much to trust initial priors
+        // A Dirichlet: one per observation modality
+        this.aDirichlet = {
+            energy: this.A.energy.map(row => row.map(p => p * priorScale)),
+            phi: this.A.phi.map(row => row.map(p => p * priorScale)),
+            tool: this.A.tool.map(row => row.map(p => p * priorScale)),
+            coherence: this.A.coherence.map(row => row.map(p => p * priorScale)),
+            task: this.A.task.map(row => row.map(p => p * priorScale)),
+        };
+        // B Dirichlet: one per state factor
+        this.bDirichlet = {
+            viability: this.B.viability.map(next => next.map(curr => curr.map(act => act * priorScale))),
+            worldState: this.B.worldState.map(next => next.map(curr => curr.map(act => act * priorScale))),
+            coupling: this.B.coupling.map(next => next.map(curr => curr.map(act => act * priorScale))),
+            goalProgress: this.B.goalProgress.map(next => next.map(curr => curr.map(act => act * priorScale))),
+        };
     }
     // ============================================================================
     // Core Inference Functions
@@ -398,17 +442,140 @@ class ActiveInferenceEngine {
         return action;
     }
     /**
-     * Full inference cycle: observe → infer → act
+     * Full inference cycle: observe → infer → act → LEARN
+     * v10.8: Now calls updateA/updateB after each step (online learning)
      */
     step(observation) {
-        // 1. Update beliefs
+        // 0. LEARN from previous step (if we have a previous state)
+        if (this.previousState && this.previousAction >= 0 && this.previousObservation) {
+            this.learn(this.previousObservation, observation, this.previousState, this.previousAction);
+        }
+        // 1. Save current state BEFORE update (for next learning step)
+        const preUpdateBeliefs = {
+            viability: [...this.beliefs.viability],
+            worldState: [...this.beliefs.worldState],
+            coupling: [...this.beliefs.coupling],
+            goalProgress: [...this.beliefs.goalProgress],
+        };
+        // 2. Update beliefs
         this.inferStates(observation);
-        // 2. Infer policy
+        // 3. Infer policy
         const policy = this.inferPolicies();
-        // 3. Sample action
+        // 4. Sample action
         const action = this.sampleAction(policy);
+        // 5. Store for next learning step
+        this.previousState = preUpdateBeliefs;
+        this.previousAction = types_js_1.ACTIONS.indexOf(action);
+        this.previousObservation = observation;
         return action;
     }
+    /**
+     * Online learning: update A and B matrices from experience.
+     * Called automatically after each step.
+     *
+     * A update: "I observed O when I believed I was in state S"
+     *   → strengthen A[observation][believed_state]
+     *
+     * B update: "I did action A in state S and ended up in state S'"
+     *   → strengthen B[new_state][old_state][action]
+     */
+    learn(prevObs, currentObs, prevBeliefs, actionIdx) {
+        const lr = this.config.learningRateA;
+        // === Update A matrix (likelihood mapping) ===
+        // For each modality, update the row corresponding to the observation
+        // weighted by current beliefs about the state
+        // Energy observation → viability state
+        for (let s = 0; s < types_js_1.HIDDEN_STATE_DIMS.viability; s++) {
+            this.aDirichlet.energy[currentObs.energy][s] += lr * this.beliefs.viability[s];
+        }
+        // Recompute A.energy from Dirichlet
+        for (let o = 0; o < 5; o++) {
+            const row = this.aDirichlet.energy[o];
+            const sum = row.reduce((a, b) => a + b, 0);
+            this.A.energy[o] = row.map(v => v / sum);
+        }
+        // Phi observation → worldState
+        for (let s = 0; s < types_js_1.HIDDEN_STATE_DIMS.worldState; s++) {
+            this.aDirichlet.phi[currentObs.phi][s] += lr * this.beliefs.worldState[s];
+        }
+        for (let o = 0; o < 4; o++) {
+            const row = this.aDirichlet.phi[o];
+            const sum = row.reduce((a, b) => a + b, 0);
+            this.A.phi[o] = row.map(v => v / sum);
+        }
+        // Tool observation → coupling
+        for (let s = 0; s < types_js_1.HIDDEN_STATE_DIMS.coupling; s++) {
+            this.aDirichlet.tool[currentObs.tool][s] += lr * this.beliefs.coupling[s];
+        }
+        for (let o = 0; o < 3; o++) {
+            const row = this.aDirichlet.tool[o];
+            const sum = row.reduce((a, b) => a + b, 0);
+            this.A.tool[o] = row.map(v => v / sum);
+        }
+        // Task observation → goalProgress
+        for (let s = 0; s < types_js_1.HIDDEN_STATE_DIMS.goalProgress; s++) {
+            this.aDirichlet.task[currentObs.task][s] += lr * this.beliefs.goalProgress[s];
+        }
+        for (let o = 0; o < 4; o++) {
+            const row = this.aDirichlet.task[o];
+            const sum = row.reduce((a, b) => a + b, 0);
+            this.A.task[o] = row.map(v => v / sum);
+        }
+        // === Update B matrix (transition model) ===
+        // "I was in state S, did action A, now I'm in state S'"
+        const lrB = this.config.learningRateB;
+        // Viability transitions
+        for (let next = 0; next < types_js_1.HIDDEN_STATE_DIMS.viability; next++) {
+            for (let prev = 0; prev < types_js_1.HIDDEN_STATE_DIMS.viability; prev++) {
+                this.bDirichlet.viability[next][prev][actionIdx] +=
+                    lrB * prevBeliefs.viability[prev] * this.beliefs.viability[next];
+            }
+        }
+        this.recomputeB('viability', types_js_1.HIDDEN_STATE_DIMS.viability, actionIdx);
+        // WorldState transitions
+        for (let next = 0; next < types_js_1.HIDDEN_STATE_DIMS.worldState; next++) {
+            for (let prev = 0; prev < types_js_1.HIDDEN_STATE_DIMS.worldState; prev++) {
+                this.bDirichlet.worldState[next][prev][actionIdx] +=
+                    lrB * prevBeliefs.worldState[prev] * this.beliefs.worldState[next];
+            }
+        }
+        this.recomputeB('worldState', types_js_1.HIDDEN_STATE_DIMS.worldState, actionIdx);
+        // Coupling transitions
+        for (let next = 0; next < types_js_1.HIDDEN_STATE_DIMS.coupling; next++) {
+            for (let prev = 0; prev < types_js_1.HIDDEN_STATE_DIMS.coupling; prev++) {
+                this.bDirichlet.coupling[next][prev][actionIdx] +=
+                    lrB * prevBeliefs.coupling[prev] * this.beliefs.coupling[next];
+            }
+        }
+        this.recomputeB('coupling', types_js_1.HIDDEN_STATE_DIMS.coupling, actionIdx);
+        // GoalProgress transitions
+        for (let next = 0; next < types_js_1.HIDDEN_STATE_DIMS.goalProgress; next++) {
+            for (let prev = 0; prev < types_js_1.HIDDEN_STATE_DIMS.goalProgress; prev++) {
+                this.bDirichlet.goalProgress[next][prev][actionIdx] +=
+                    lrB * prevBeliefs.goalProgress[prev] * this.beliefs.goalProgress[next];
+            }
+        }
+        this.recomputeB('goalProgress', types_js_1.HIDDEN_STATE_DIMS.goalProgress, actionIdx);
+        this.emit({
+            type: 'beliefs_updated',
+            timestamp: new Date(),
+            data: { learning: true, actionIdx, prevObs, currentObs },
+        });
+    }
+    /**
+     * Recompute B matrix column from Dirichlet parameters
+     */
+    recomputeB(factor, dim, actionIdx) {
+        for (let prev = 0; prev < dim; prev++) {
+            const col = this.bDirichlet[factor].map((next) => next[prev][actionIdx]);
+            const sum = col.reduce((a, b) => a + b, 0);
+            if (sum > 0) {
+                for (let next = 0; next < dim; next++) {
+                    this.B[factor][next][prev][actionIdx] = col[next] / sum;
+                }
+            }
+        }
+    }
     // ============================================================================
     // Helper Functions
     // ============================================================================
@@ -667,6 +834,37 @@ class ActiveInferenceEngine {
             goalProgress: ['blocked', 'slow', 'onTrack', 'achieved'][argmax(this.beliefs.goalProgress)],
         };
     }
+    /**
+     * Export learned matrices for persistence between sessions.
+     * Call this before shutdown to save learning progress.
+     */
+    exportLearnedModel() {
+        return {
+            A: JSON.parse(JSON.stringify(this.A)),
+            B: JSON.parse(JSON.stringify(this.B)),
+            beliefs: JSON.parse(JSON.stringify(this.beliefs)),
+            actionCounts: [...this.actionCounts],
+            totalActions: this.totalActions,
+        };
+    }
+    /**
+     * Import previously learned matrices.
+     * Call at startup to resume from previous learning.
+     */
+    importLearnedModel(model) {
+        if (model.A)
+            this.A = model.A;
+        if (model.B)
+            this.B = model.B;
+        if (model.beliefs)
+            this.beliefs = model.beliefs;
+        if (model.actionCounts)
+            this.actionCounts = model.actionCounts;
+        if (model.totalActions)
+            this.totalActions = model.totalActions;
+        // Reinit Dirichlet from imported matrices
+        this.initDirichletParams();
+    }
     // ============================================================================
     // Event Handling
     // ============================================================================

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

@@ -34,6 +34,9 @@ export declare class ObservationGatherer {
     private getPhiState?;
     private getSensorResult?;
     private getWorldModelState?;
+    private mcpToolResults;
+    private lastStripeBalance;
+    private realSourcesInitialized;
     /**
      * Configure observation sources
      */
@@ -43,8 +46,24 @@ export declare class ObservationGatherer {
         sensorResult?: () => Promise<SensorResult>;
         worldModelState?: () => WorldModelState;
     }): void;
+    /**
+     * v10.8: Initialize real observation sources from MCP.
+     * Call once to wire the gatherer to live system data.
+     */
+    initRealSources(): void;
+    /**
+     * v10.8: Record an MCP tool call result for observation tracking.
+     * Called by the integration layer after each tool use.
+     */
+    recordToolResult(success: boolean, latency: number): void;
+    /**
+     * v10.8: Query Stripe balance for economic observation.
+     * Returns cached value if queried recently (< 5 min).
+     */
+    private getStripeBalance;
     /**
      * Gather all observations from system components
+     * v10.8: Now uses real MCP data when available
      */
     gather(): Promise<Observation>;
     /**

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

@@ -16,6 +16,7 @@ exports.ObservationGatherer = void 0;
 exports.createObservationGatherer = createObservationGatherer;
 exports.getObservationGatherer = getObservationGatherer;
 const economic_integration_js_1 = require("./economic-integration.js");
+const index_js_1 = require("../mcp/index.js");
 // ============================================================================
 // Observation Gatherer
 // ============================================================================
@@ -25,6 +26,10 @@ class ObservationGatherer {
     getPhiState;
     getSensorResult;
     getWorldModelState;
+    // v10.8: Real MCP data tracking
+    mcpToolResults = [];
+    lastStripeBalance = -1; // -1 = never checked
+    realSourcesInitialized = false;
     /**
      * Configure observation sources
      */
@@ -38,10 +43,113 @@ class ObservationGatherer {
         if (sources.worldModelState)
             this.getWorldModelState = sources.worldModelState;
     }
+    /**
+     * v10.8: Initialize real observation sources from MCP.
+     * Call once to wire the gatherer to live system data.
+     */
+    initRealSources() {
+        if (this.realSourcesInitialized)
+            return;
+        this.realSourcesInitialized = true;
+        // Wire kernel state to process metrics
+        this.getKernelState = () => {
+            const mem = process.memoryUsage();
+            const heapUsedRatio = mem.heapUsed / mem.heapTotal;
+            // Energy = inverse of resource pressure (more heap used = less energy)
+            const energy = Math.max(0, Math.min(1, 1 - heapUsedRatio));
+            return {
+                energy,
+                state: 'running',
+                taskStatus: 'running',
+            };
+        };
+        // Wire sensor result to actual MCP tool call history
+        this.getSensorResult = async () => {
+            // Use the last 10 MCP tool results for aggregate health
+            const recent = this.mcpToolResults.slice(-10);
+            if (recent.length === 0) {
+                // No tool calls yet - try a lightweight probe
+                try {
+                    const mcp = (0, index_js_1.getMCPClient)();
+                    const start = Date.now();
+                    await mcp.discoverAllTools();
+                    const latency = Date.now() - start;
+                    this.recordToolResult(true, latency);
+                    return { success: true, latency };
+                }
+                catch (e) {
+                    this.recordToolResult(false, 10000);
+                    return { success: false, latency: 10000, error: String(e) };
+                }
+            }
+            const successRate = recent.filter(r => r.success).length / recent.length;
+            const avgLatency = recent.reduce((sum, r) => sum + r.latency, 0) / recent.length;
+            return {
+                success: successRate > 0.5,
+                latency: avgLatency,
+                error: successRate <= 0.5 ? `Low success rate: ${(successRate * 100).toFixed(0)}%` : undefined,
+            };
+        };
+        // Wire world model to memory coherence (Neo4j connectivity if available)
+        this.getWorldModelState = () => {
+            // Base coherence on tool result consistency
+            const recent = this.mcpToolResults.slice(-20);
+            if (recent.length < 2)
+                return { consistent: true, issues: 0 };
+            const failures = recent.filter(r => !r.success).length;
+            return {
+                consistent: failures < recent.length * 0.3,
+                issues: failures,
+            };
+        };
+    }
+    /**
+     * v10.8: Record an MCP tool call result for observation tracking.
+     * Called by the integration layer after each tool use.
+     */
+    recordToolResult(success, latency) {
+        this.mcpToolResults.push({ success, latency, timestamp: Date.now() });
+        // Keep last 100 results
+        if (this.mcpToolResults.length > 100) {
+            this.mcpToolResults = this.mcpToolResults.slice(-100);
+        }
+    }
+    /**
+     * v10.8: Query Stripe balance for economic observation.
+     * Returns cached value if queried recently (< 5 min).
+     */
+    async getStripeBalance() {
+        try {
+            const mcp = (0, index_js_1.getMCPClient)();
+            const result = await mcp.call('stripe', 'get_balance', {});
+            const balanceData = result?.data || result;
+            // Parse Stripe balance response
+            const available = Array.isArray(balanceData?.available)
+                ? balanceData.available.reduce((sum, b) => sum + (b.amount || 0), 0) / 100
+                : 0;
+            this.lastStripeBalance = available;
+            if (available <= 0)
+                return 0; // critical
+            if (available < 10)
+                return 1; // low
+            if (available < 100)
+                return 2; // stable
+            return 3; // growing
+        }
+        catch {
+            // Stripe not available, use economic integration fallback
+            return 2; // stable default
+        }
+    }
     /**
      * Gather all observations from system components
+     * v10.8: Now uses real MCP data when available
      */
     async gather() {
+        // Auto-init real sources if not configured
+        if (!this.getKernelState && !this.getPhiState && !this.getSensorResult) {
+            this.initRealSources();
+        }
         // Get states from components (with defaults if not configured)
         const kernelState = this.getKernelState?.() ?? {
             energy: 0.5,
@@ -59,13 +167,18 @@ class ObservationGatherer {
             consistent: true,
             issues: 0,
         };
-        // v9.3: Get economic observation
+        // v10.8: Get economic observation from Stripe (with fallback)
         let economicObs = 2; // Default stable
         try {
-            economicObs = await (0, economic_integration_js_1.getEconomicIntegration)().getDiscreteObservation();
+            economicObs = await this.getStripeBalance();
         }
         catch {
-            // Economic system not initialized, use default
+            try {
+                economicObs = await (0, economic_integration_js_1.getEconomicIntegration)().getDiscreteObservation();
+            }
+            catch {
+                // Both failed, use default
+            }
         }
         // Map to discrete observations
         return {
@@ -74,7 +187,7 @@ class ObservationGatherer {
             tool: this.mapTool(sensorResult),
             coherence: this.mapCoherence(worldModelState),
             task: this.mapTask(kernelState.taskStatus),
-            economic: economicObs, // v9.3
+            economic: economicObs,
         };
     }
     /**

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

@@ -70,7 +70,7 @@ export declare const OBSERVATION_LABELS: {
     task: readonly ["none", "pending", "active", "completed"];
     economic: readonly ["critical", "low", "stable", "growing"];
 };
-export type ActionType = 'sense.mcp' | 'recall.memory' | 'plan.goals' | 'verify.ethics' | 'execute.task' | 'execute.code' | 'execute.shell' | 'adapt.code' | 'execute.cycle' | 'self.modify' | 'self.analyze' | 'git.push' | 'dream.cycle' | 'rest.idle' | 'recharge' | 'web.search' | 'web.scrape' | 'web.browse' | 'deploy.service' | 'content.generate' | 'market.analyze' | 'api.call' | 'github.deploy' | 'code.snapshot' | 'code.history' | 'code.diff' | 'econ.check' | 'econ.optimize' | 'econ.activate' | 'econ.promote' | 'improve.self';
+export type ActionType = 'sense.mcp' | 'recall.memory' | 'plan.goals' | 'verify.ethics' | 'execute.task' | 'execute.code' | 'execute.shell' | 'adapt.code' | 'execute.cycle' | 'self.modify' | 'self.analyze' | 'git.push' | 'dream.cycle' | 'rest.idle' | 'recharge' | 'web.search' | 'web.scrape' | 'web.browse' | 'deploy.service' | 'content.generate' | 'market.analyze' | 'api.call' | 'github.deploy' | 'code.snapshot' | 'code.history' | 'code.diff' | 'econ.check' | 'econ.optimize' | 'econ.activate' | 'econ.promote' | 'improve.self' | 'opportunity.scan' | 'opportunity.evaluate' | 'opportunity.build' | 'opportunity.monetize';
 export declare const ACTIONS: ActionType[];
 export declare const ACTION_COUNT: number;
 /**

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

@@ -76,6 +76,11 @@ exports.ACTIONS = [
     'econ.promote',
     // v10.0 - Meta-Improvement
     'improve.self',
+    // v10.8 - Autonomous Revenue
+    'opportunity.scan',
+    'opportunity.evaluate',
+    'opportunity.build',
+    'opportunity.monetize',
 ];
 exports.ACTION_COUNT = exports.ACTIONS.length;
 exports.DEFAULT_CONFIG = {

package/dist/src/active-inference/value-integration.js

@@ -76,6 +76,11 @@ const AI_TO_WM_ACTION = {
     'econ.promote': 'execute', // Promote services
     // v10.0 - Meta-Improvement
     'improve.self': 'transform', // Self-improvement action
+    // v10.8 - Autonomous Revenue
+    'opportunity.scan': 'query', // Scan for opportunities
+    'opportunity.evaluate': 'query', // Evaluate feasibility
+    'opportunity.build': 'execute', // Build & deploy
+    'opportunity.monetize': 'execute', // Wire payments
 };
 // ============================================================================
 // Value-Augmented Active Inference Engine

package/dist/src/memory-production/index.d.ts

@@ -72,16 +72,25 @@ export declare class VectorMemory {
     });
     connect(): Promise<boolean>;
     private ensureIndex;
+    /**
+     * Store a memory entry using Pinecone's integrated inference.
+     * v10.8: Uses upsert-records with text (Pinecone handles embedding internally).
+     * No need for pre-computed embeddings - simpler and more reliable.
+     */
     store(entry: {
         id: string;
         content: string;
-        embedding: number[];
+        embedding?: number[];
         metadata?: Record<string, unknown>;
     }): Promise<{
         success: boolean;
         error?: string;
     }>;
-    search(queryEmbedding: number[], options?: {
+    /**
+     * Search memory using Pinecone's integrated inference.
+     * v10.8: Uses search-records with text query (no pre-computed embeddings needed).
+     */
+    search(query: string | number[], options?: {
         topK?: number;
         filter?: Record<string, unknown>;
         includeMetadata?: boolean;
@@ -111,10 +120,31 @@ export declare class KnowledgeGraph {
         success: boolean;
         error?: string;
     }>;
+    /**
+     * Add an edge with temporal properties.
+     * v10.8: All edges now have valid_from (creation time).
+     * Set valid_to to mark facts as expired (temporal knowledge).
+     */
     addEdge(edge: KnowledgeEdge): Promise<{
         success: boolean;
         error?: string;
     }>;
+    /**
+     * v10.8: Expire a relationship (mark as no longer valid).
+     * This preserves history while indicating current state.
+     */
+    expireEdge(from: string, to: string, type: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * v10.8: Find only currently valid relationships.
+     * Filters out expired edges (valid_to IS NOT NULL).
+     */
+    findCurrentRelated(nodeId: string, options?: {
+        maxHops?: number;
+        relationTypes?: string[];
+        limit?: number;
+    }): Promise<KnowledgeNode[]>;
     findRelated(nodeId: string, options?: {
         maxHops?: number;
         relationTypes?: string[];

package/dist/src/memory-production/index.js

@@ -55,42 +55,83 @@ class VectorMemory {
             console.log('[VectorMemory] Index check:', error);
         }
     }
+    /**
+     * Store a memory entry using Pinecone's integrated inference.
+     * v10.8: Uses upsert-records with text (Pinecone handles embedding internally).
+     * No need for pre-computed embeddings - simpler and more reliable.
+     */
     async store(entry) {
         if (!this.connected) {
             return { success: false, error: 'Not connected to Pinecone' };
         }
         try {
             const client = (0, index_js_1.getMCPClient)();
-            await client.call('pinecone', 'upsert_vectors', {
+            // v10.8: Use upsert-records with text for integrated inference
+            await client.call('pinecone', 'upsert-records', {
                 indexName: this.indexName,
-                vectors: [{
-                        id: entry.id,
-                        values: entry.embedding,
-                        metadata: {
-                            content: entry.content,
-                            ...entry.metadata,
-                            timestamp: new Date().toISOString(),
-                        },
+                records: [{
+                        _id: entry.id,
+                        text: entry.content,
+                        ...entry.metadata,
+                        timestamp: new Date().toISOString(),
                     }],
             });
             return { success: true };
         }
         catch (error) {
+            // Fallback: try legacy upsert_vectors if upsert-records not supported
+            if (entry.embedding) {
+                try {
+                    const client = (0, index_js_1.getMCPClient)();
+                    await client.call('pinecone', 'upsert_vectors', {
+                        indexName: this.indexName,
+                        vectors: [{
+                                id: entry.id,
+                                values: entry.embedding,
+                                metadata: {
+                                    content: entry.content,
+                                    ...entry.metadata,
+                                    timestamp: new Date().toISOString(),
+                                },
+                            }],
+                    });
+                    return { success: true };
+                }
+                catch (fallbackError) {
+                    return { success: false, error: String(fallbackError) };
+                }
+            }
             return { success: false, error: String(error) };
         }
     }
-    async search(queryEmbedding, options) {
+    /**
+     * Search memory using Pinecone's integrated inference.
+     * v10.8: Uses search-records with text query (no pre-computed embeddings needed).
+     */
+    async search(query, options) {
         if (!this.connected)
             return [];
         try {
             const client = (0, index_js_1.getMCPClient)();
-            const result = await client.call('pinecone', 'query_vectors', {
-                indexName: this.indexName,
-                vector: queryEmbedding,
-                topK: options?.topK || 10,
-                filter: options?.filter,
-                includeMetadata: options?.includeMetadata ?? true,
-            });
+            let result;
+            if (typeof query === 'string') {
+                // v10.8: Use search-records with text query (integrated inference)
+                result = await client.call('pinecone', 'search-records', {
+                    indexName: this.indexName,
+                    query,
+                    topK: options?.topK || 10,
+                });
+            }
+            else {
+                // Legacy: vector-based query
+                result = await client.call('pinecone', 'query_vectors', {
+                    indexName: this.indexName,
+                    vector: query,
+                    topK: options?.topK || 10,
+                    filter: options?.filter,
+                    includeMetadata: options?.includeMetadata ?? true,
+                });
+            }
             const matches = result.data?.matches || [];
             return matches.map((match) => ({
                 id: match.id,
@@ -215,14 +256,24 @@ class KnowledgeGraph {
             return { success: false, error: String(error) };
         }
     }
+    /**
+     * Add an edge with temporal properties.
+     * v10.8: All edges now have valid_from (creation time).
+     * Set valid_to to mark facts as expired (temporal knowledge).
+     */
     async addEdge(edge) {
-        const propsString = edge.properties
-            ? ', ' + Object.entries(edge.properties).map(([k, v]) => `r.${k} = $${k}`).join(', ')
-            : '';
+        const now = new Date().toISOString();
+        const temporalProps = {
+            valid_from: now,
+            ...(edge.properties || {}),
+        };
+        const propsString = Object.entries(temporalProps)
+            .map(([k]) => `r.${k} = $${k}`)
+            .join(', ');
         const query = `
       MATCH (a {id: $from}), (b {id: $to})
       MERGE (a)-[r:${edge.type}]->(b)
-      SET r.weight = $weight ${propsString}
+      SET r.weight = $weight, ${propsString}
       RETURN r
     `;
         try {
@@ -230,7 +281,7 @@ class KnowledgeGraph {
                 from: edge.from,
                 to: edge.to,
                 weight: edge.weight || 1.0,
-                ...edge.properties,
+                ...temporalProps,
             });
             return { success: true };
         }
@@ -238,6 +289,55 @@ class KnowledgeGraph {
             return { success: false, error: String(error) };
         }
     }
+    /**
+     * v10.8: Expire a relationship (mark as no longer valid).
+     * This preserves history while indicating current state.
+     */
+    async expireEdge(from, to, type) {
+        const now = new Date().toISOString();
+        const query = `
+      MATCH (a {id: $from})-[r:${type}]->(b {id: $to})
+      WHERE r.valid_to IS NULL
+      SET r.valid_to = $now
+      RETURN r
+    `;
+        try {
+            await this.runQuery(query, { from, to, now });
+            return { success: true };
+        }
+        catch {
+            return { success: false };
+        }
+    }
+    /**
+     * v10.8: Find only currently valid relationships.
+     * Filters out expired edges (valid_to IS NOT NULL).
+     */
+    async findCurrentRelated(nodeId, options) {
+        const hops = options?.maxHops || 2;
+        const limit = options?.limit || 20;
+        const relationFilter = options?.relationTypes?.length
+            ? `:${options.relationTypes.join('|')}`
+            : '';
+        const query = `
+      MATCH (n {id: $nodeId})-[r${relationFilter}*1..${hops}]-(related)
+      WHERE ALL(rel IN r WHERE rel.valid_to IS NULL)
+      RETURN DISTINCT related
+      LIMIT $limit
+    `;
+        try {
+            const results = await this.runQuery(query, { nodeId, limit });
+            return results.map((r) => ({
+                id: r.related.id,
+                type: r.related.labels?.[0] || 'Unknown',
+                name: r.related.name,
+                properties: r.related,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
     async findRelated(nodeId, options) {
         const hops = options?.maxHops || 2;
         const limit = options?.limit || 20;

package/package.json

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