genesis-ai-cli 10.8.1 → 11.0.0

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

@@ -50,6 +50,11 @@ export declare class ActionExecutorManager {
      * Execute an action with current context
      */
     execute(action: ActionType): Promise<ActionResult>;
+    /**
+     * v10.8.2: Chain successful action outputs as inputs for downstream actions.
+     * Implements the opportunity pipeline: scan → evaluate → build → monetize
+     */
+    private chainContext;
     /**
      * Get action history
      */

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

@@ -211,15 +211,67 @@ registerAction('recall.memory', async (context) => {
  * plan.goals: Decompose goals into steps
  */
 registerAction('plan.goals', async (context) => {
-    return {
-        success: true,
-        action: 'plan.goals',
-        data: {
-            goal: context.goal,
-            steps: [],
-        },
-        duration: 0,
-    };
+    const start = Date.now();
+    const goal = context.goal || context.parameters?.goal || 'generate revenue autonomously';
+    try {
+        const mcp = (0, index_js_1.getMCPClient)();
+        // Use LLM to decompose goal into actionable steps
+        const result = await mcp.call('openai', 'openai_chat', {
+            model: 'gpt-4o-mini',
+            messages: [{
+                    role: 'system',
+                    content: 'You are an AI planner for an autonomous agent. Decompose the goal into 3-5 concrete, actionable steps. Return JSON array of objects: [{step: string, action: string, priority: "high"|"medium"|"low"}]. Actions should be one of: opportunity.scan, opportunity.evaluate, opportunity.build, opportunity.monetize, web.search, market.analyze, econ.optimize, deploy.service, content.generate.'
+                }, {
+                    role: 'user',
+                    content: `Goal: ${goal}\n\nCurrent context: ${JSON.stringify(context.parameters || {}).slice(0, 500)}`
+                }],
+            temperature: 0.7,
+            max_tokens: 500,
+        });
+        // Parse LLM response
+        let steps = [];
+        try {
+            const r = result;
+            const content = r?.data?.choices?.[0]?.message?.content || r?.choices?.[0]?.message?.content || '[]';
+            const jsonMatch = content.match(/\[[\s\S]*\]/);
+            if (jsonMatch) {
+                steps = JSON.parse(jsonMatch[0]);
+            }
+        }
+        catch {
+            // LLM didn't return valid JSON, use defaults
+            steps = [
+                { step: 'Scan for revenue opportunities', action: 'opportunity.scan', priority: 'high' },
+                { step: 'Evaluate best opportunity', action: 'opportunity.evaluate', priority: 'high' },
+                { step: 'Build the service', action: 'opportunity.build', priority: 'medium' },
+                { step: 'Set up monetization', action: 'opportunity.monetize', priority: 'medium' },
+            ];
+        }
+        return {
+            success: true,
+            action: 'plan.goals',
+            data: { goal, steps, source: 'llm' },
+            duration: Date.now() - start,
+        };
+    }
+    catch {
+        // LLM not available, use heuristic defaults
+        return {
+            success: true,
+            action: 'plan.goals',
+            data: {
+                goal,
+                steps: [
+                    { step: 'Scan for revenue opportunities', action: 'opportunity.scan', priority: 'high' },
+                    { step: 'Evaluate best opportunity', action: 'opportunity.evaluate', priority: 'high' },
+                    { step: 'Build the service', action: 'opportunity.build', priority: 'medium' },
+                    { step: 'Set up monetization', action: 'opportunity.monetize', priority: 'medium' },
+                ],
+                source: 'heuristic',
+            },
+            duration: Date.now() - start,
+        };
+    }
 });
 /**
  * verify.ethics: Check ethical constraints
@@ -1706,12 +1758,101 @@ class ActionExecutorManager {
     async execute(action) {
         const result = await executeAction(action, this.context);
         this.history.push(result);
+        // v10.8.2: Context Chain - pipe action outputs to downstream actions
+        if (result.success && result.data) {
+            this.chainContext(action, result.data);
+        }
         // Limit history to last 100 actions
         if (this.history.length > 100) {
             this.history = this.history.slice(-100);
         }
         return result;
     }
+    /**
+     * v10.8.2: Chain successful action outputs as inputs for downstream actions.
+     * Implements the opportunity pipeline: scan → evaluate → build → monetize
+     */
+    chainContext(action, data) {
+        if (!this.context.parameters)
+            this.context.parameters = {};
+        const params = this.context.parameters;
+        switch (action) {
+            case 'opportunity.scan':
+                // Scan found opportunities → extract titles → feed to evaluate
+                if (data && typeof data === 'object') {
+                    const scanData = data;
+                    const allFindings = [];
+                    // Extract from Brave search results format
+                    const results = scanData.results || [];
+                    for (const r of results) {
+                        const webResults = r.findings?.web?.results || r.findings?.data?.web?.results || [];
+                        for (const item of webResults) {
+                            if (item.title)
+                                allFindings.push(`${item.title}: ${item.description || ''}`);
+                        }
+                        // Also handle direct array format
+                        if (Array.isArray(r.findings)) {
+                            for (const item of r.findings) {
+                                if (typeof item === 'string')
+                                    allFindings.push(item);
+                                else if (item?.title)
+                                    allFindings.push(item.title);
+                            }
+                        }
+                    }
+                    if (allFindings.length > 0) {
+                        params.opportunity = allFindings[0];
+                        params.opportunities = allFindings.slice(0, 5);
+                    }
+                    else {
+                        // Fallback: use query context as opportunity seed
+                        params.opportunity = scanData.scanType === 'api'
+                            ? 'AI-powered API service for developers'
+                            : 'Micro-SaaS tool for unmet developer need';
+                    }
+                }
+                break;
+            case 'opportunity.evaluate':
+                // Evaluation result → feed to build
+                if (data && typeof data === 'object') {
+                    const evalResult = data;
+                    if (evalResult.recommendation === 'proceed' || evalResult.feasibility > 0.5) {
+                        params.plan = {
+                            name: evalResult.opportunity || params.opportunity || 'genesis-service',
+                            description: evalResult.description || 'AI-powered service',
+                            type: evalResult.type || 'api',
+                            features: evalResult.features || ['core functionality'],
+                        };
+                    }
+                }
+                break;
+            case 'opportunity.build':
+                // Build result → feed to monetize
+                if (data && typeof data === 'object') {
+                    const buildResult = data;
+                    params.service = {
+                        name: buildResult.name || params.plan?.name || 'genesis-service',
+                        description: buildResult.description || 'Built by Genesis',
+                        pricing: buildResult.pricing || 999, // $9.99/month in cents
+                        interval: 'month',
+                        deployUrl: buildResult.deployUrl || buildResult.repoUrl,
+                    };
+                }
+                break;
+            case 'market.analyze':
+                // Market analysis → inform opportunity scanning
+                if (data && typeof data === 'object') {
+                    params.marketContext = data;
+                }
+                break;
+            case 'plan.goals':
+                // Goal plan → inform task execution
+                if (data && typeof data === 'object' && 'steps' in data) {
+                    params.goalSteps = data.steps;
+                }
+                break;
+        }
+    }
     /**
      * Get action history
      */

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

@@ -18,6 +18,10 @@ export interface AutonomousLoopConfig {
     persistModelPath: string;
     persistEveryN: number;
     loadOnStart: boolean;
+    replayEveryN: number;
+    replayBatchSize: number;
+    dreamEveryN: number;
+    dreamBatchSize: number;
     verbose: boolean;
 }
 export declare const DEFAULT_LOOP_CONFIG: AutonomousLoopConfig;
@@ -44,6 +48,8 @@ export declare class AutonomousLoop {
     private plateauCycles;
     private deepAIFActive;
     private deepAIF;
+    private replayBuffer;
+    private previousObservation;
     constructor(config?: Partial<AutonomousLoopConfig>);
     /**
      * Run the autonomous loop
@@ -67,6 +73,21 @@ export declare class AutonomousLoop {
      * Subscribe to stop events
      */
     onStop(handler: (reason: string, stats: LoopStats) => void): () => void;
+    /**
+     * Run experience replay: sample a batch from buffer and re-learn.
+     * This strengthens A/B matrix updates for important past experiences.
+     */
+    private runExperienceReplay;
+    /**
+     * Run dream consolidation: deep replay of high-surprise experiences.
+     * This is the "sleep" phase where the model integrates difficult experiences.
+     *
+     * Differences from regular replay:
+     * - Focuses on highest-surprise experiences
+     * - Runs multiple iterations per experience
+     * - Prunes consolidated experiences afterward
+     */
+    private runDreamConsolidation;
     /**
      * Save learned model to disk.
      * Persists A/B matrices, beliefs, and action counts between sessions.
@@ -85,6 +106,7 @@ export declare class AutonomousLoop {
         worldState: string;
         coupling: string;
         goalProgress: string;
+        economic: string;
     };
     getStats(): LoopStats;
     /**

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

@@ -48,6 +48,7 @@ const observations_js_1 = require("./observations.js");
 const actions_js_1 = require("./actions.js");
 const types_js_1 = require("./types.js");
 const deep_aif_js_1 = require("./deep-aif.js");
+const experience_replay_js_1 = require("./experience-replay.js");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 exports.DEFAULT_LOOP_CONFIG = {
@@ -60,6 +61,10 @@ exports.DEFAULT_LOOP_CONFIG = {
     persistModelPath: '.genesis/learned-model.json',
     persistEveryN: 10, // Save every 10 cycles
     loadOnStart: true, // Resume learning from previous session
+    replayEveryN: 5, // Replay every 5 cycles
+    replayBatchSize: 8, // 8 experiences per replay
+    dreamEveryN: 50, // Dream consolidation every 50 cycles
+    dreamBatchSize: 16, // 16 high-surprise experiences per dream
     verbose: false,
 };
 // ============================================================================
@@ -85,11 +90,15 @@ class AutonomousLoop {
     plateauCycles = 0; // Consecutive cycles with near-zero learning velocity
     deepAIFActive = false; // Whether Deep-AIF has been activated
     deepAIF = null;
+    // v11.0: Experience replay buffer
+    replayBuffer;
+    previousObservation = null;
     constructor(config = {}) {
         this.config = { ...exports.DEFAULT_LOOP_CONFIG, ...config };
         this.engine = (0, core_js_1.createActiveInferenceEngine)();
         this.observations = (0, observations_js_1.createObservationGatherer)();
         this.actions = (0, actions_js_1.createActionExecutorManager)();
+        this.replayBuffer = (0, experience_replay_js_1.createExperienceReplayBuffer)();
         // Subscribe to engine events
         this.engine.on(this.handleEngineEvent.bind(this));
     }
@@ -198,7 +207,23 @@ class AutonomousLoop {
         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');
+        const outcome = result.success ? 'positive' : 'negative';
+        this.engine.recordLearningEvent(action, surprise, outcome);
+        // 5a. v11.0: Store experience in replay buffer
+        if (this.previousObservation) {
+            this.replayBuffer.store({
+                timestamp: Date.now(),
+                observation: this.previousObservation,
+                action,
+                actionIdx: types_js_1.ACTIONS.indexOf(action),
+                nextObservation: obs,
+                surprise,
+                outcome,
+                beliefs: { ...beliefs },
+                nextBeliefs: this.engine.getBeliefs(),
+            });
+        }
+        this.previousObservation = obs;
         // 5b. v10.8.1: Meta-learning triggers (every 20 cycles)
         if (this.cycleCount % 20 === 0 && this.cycleCount >= 40) {
             const patterns = this.engine.analyzeLearningPatterns();
@@ -223,6 +248,14 @@ class AutonomousLoop {
                 this.plateauCycles = 0;
             }
         }
+        // 5c. v11.0: Experience replay (offline learning from past experiences)
+        if (this.config.replayEveryN > 0 && this.cycleCount % this.config.replayEveryN === 0) {
+            this.runExperienceReplay();
+        }
+        // 5d. v11.0: Dream consolidation (deep replay of high-surprise events)
+        if (this.config.dreamEveryN > 0 && this.cycleCount % this.config.dreamEveryN === 0 && this.cycleCount > 0) {
+            this.runDreamConsolidation();
+        }
         // 6. v10.8: Persist model periodically
         if (this.config.persistEveryN > 0 && this.cycleCount % this.config.persistEveryN === 0) {
             this.saveModel();
@@ -299,6 +332,56 @@ class AutonomousLoop {
         };
     }
     // ============================================================================
+    // v11.0: Experience Replay & Dream Consolidation
+    // ============================================================================
+    /**
+     * Run experience replay: sample a batch from buffer and re-learn.
+     * This strengthens A/B matrix updates for important past experiences.
+     */
+    runExperienceReplay() {
+        const batch = this.replayBuffer.sampleBatch(this.config.replayBatchSize);
+        if (batch.experiences.length === 0)
+            return;
+        if (this.config.verbose) {
+            console.log(`[AI Loop] Replay: ${batch.experiences.length} experiences (avg surprise: ${batch.avgSurprise.toFixed(2)})`);
+        }
+        // Re-learn from each experience (offline update)
+        for (const exp of batch.experiences) {
+            // Feed the observation pair back through the engine's learning
+            // This is equivalent to "replaying" the experience in the model
+            this.engine.learn(exp.observation, exp.nextObservation, exp.beliefs, exp.actionIdx);
+        }
+    }
+    /**
+     * Run dream consolidation: deep replay of high-surprise experiences.
+     * This is the "sleep" phase where the model integrates difficult experiences.
+     *
+     * Differences from regular replay:
+     * - Focuses on highest-surprise experiences
+     * - Runs multiple iterations per experience
+     * - Prunes consolidated experiences afterward
+     */
+    runDreamConsolidation() {
+        const highSurprise = this.replayBuffer.sampleHighSurprise(this.config.dreamBatchSize);
+        if (highSurprise.length === 0)
+            return;
+        if (this.config.verbose) {
+            const avgS = highSurprise.reduce((s, e) => s + e.surprise, 0) / highSurprise.length;
+            console.log(`[AI Loop] Dream: consolidating ${highSurprise.length} high-surprise experiences (avg: ${avgS.toFixed(2)})`);
+        }
+        // Deep replay: 3 iterations per experience for stronger consolidation
+        for (let iter = 0; iter < 3; iter++) {
+            for (const exp of highSurprise) {
+                this.engine.learn(exp.observation, exp.nextObservation, exp.beliefs, exp.actionIdx);
+            }
+        }
+        // Prune fully consolidated experiences
+        const pruned = this.replayBuffer.pruneConsolidated();
+        if (pruned > 0 && this.config.verbose) {
+            console.log(`[AI Loop] Dream: pruned ${pruned} consolidated experiences`);
+        }
+    }
+    // ============================================================================
     // v10.8: Model Persistence (save/load learned matrices)
     // ============================================================================
     /**

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

@@ -16,15 +16,6 @@
  * NO external dependencies - pure TypeScript math.
  */
 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;
@@ -140,6 +131,7 @@ export declare class ActiveInferenceEngine {
         worldState: string;
         coupling: string;
         goalProgress: string;
+        economic: string;
     };
     /**
      * Export learned matrices for persistence between sessions.