genesis-ai-cli 13.4.0 → 13.5.0

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

@@ -276,17 +276,63 @@ registerAction('plan.goals', async (context) => {
 });
 /**
  * verify.ethics: Check ethical constraints
+ * v14.0: Connected to real Ethicist agent for ethical evaluation
  */
 registerAction('verify.ethics', async (context) => {
-    return {
-        success: true,
-        action: 'verify.ethics',
-        data: {
-            approved: true,
-            priority: 'flourishing',
-        },
-        duration: 0,
-    };
+    const start = Date.now();
+    try {
+        // Dynamic import to get Ethicist agent
+        const { createEthicistAgent } = await import('../agents/ethicist.js');
+        const ethicist = createEthicistAgent();
+        // Convert context to Action format expected by Ethicist
+        const action = {
+            id: `action-${Date.now()}`,
+            type: context.parameters?.type || 'unknown',
+            description: context.parameters?.intent ||
+                context.parameters?.action ||
+                context.goal ||
+                'unknown_action',
+            parameters: context.parameters || context.beliefs || {},
+            estimatedHarm: context.parameters?.estimatedHarm,
+            reversible: context.parameters?.reversible ?? true,
+            affectsHumans: context.parameters?.affectsHumans,
+            affectsAI: context.parameters?.affectsAI,
+            affectsBiosphere: context.parameters?.affectsBiosphere,
+        };
+        // Call ethicist.evaluate
+        const decision = await ethicist.evaluate(action);
+        return {
+            success: decision.allow !== false,
+            action: 'verify.ethics',
+            data: {
+                approved: decision.allow === true,
+                deferred: decision.allow === 'defer',
+                priority: decision.priority,
+                confidence: decision.confidence,
+                reason: decision.reason,
+                potentialHarm: decision.potentialHarm,
+                flourishingScore: decision.flourishingScore,
+                reversible: decision.reversible,
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        // Conservative fallback: defer on error (not auto-approve)
+        return {
+            success: false,
+            action: 'verify.ethics',
+            error: error instanceof Error ? error.message : String(error),
+            data: {
+                approved: false,
+                deferred: true,
+                priority: 'P0_SURVIVAL',
+                confidence: 0,
+                reason: 'Ethicist evaluation failed - deferring for safety',
+            },
+            duration: Date.now() - start,
+        };
+    }
 });
 /**
  * execute.task: Execute the planned task

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

@@ -246,14 +246,60 @@ function registerKernelActions(kernel, options = {}) {
     });
     // verify.ethics: Ethical check via Kernel (delegated to ethicist agent)
     (0, actions_js_1.registerAction)('verify.ethics', async (context) => {
-        // The Kernel already requires ethical checks for all tasks
-        // This action is more of an explicit verification
-        return {
-            success: true,
-            action: 'verify.ethics',
-            data: { approved: true, priority: 'flourishing' },
-            duration: 0,
-        };
+        const start = Date.now();
+        try {
+            // Dynamic import to get Ethicist agent
+            const { createEthicistAgent } = await import('../agents/ethicist.js');
+            const ethicist = createEthicistAgent();
+            // Convert context to Action format expected by Ethicist
+            const action = {
+                id: `action-${Date.now()}`,
+                type: context.parameters?.type || 'unknown',
+                description: context.parameters?.intent ||
+                    context.parameters?.action ||
+                    context.goal ||
+                    'unknown_action',
+                parameters: context.parameters || context.beliefs || {},
+                estimatedHarm: context.parameters?.estimatedHarm,
+                reversible: context.parameters?.reversible ?? true,
+                affectsHumans: context.parameters?.affectsHumans,
+                affectsAI: context.parameters?.affectsAI,
+                affectsBiosphere: context.parameters?.affectsBiosphere,
+            };
+            // Call ethicist.evaluate
+            const decision = await ethicist.evaluate(action);
+            return {
+                success: decision.allow !== false,
+                action: 'verify.ethics',
+                data: {
+                    approved: decision.allow === true,
+                    deferred: decision.allow === 'defer',
+                    priority: decision.priority,
+                    confidence: decision.confidence,
+                    reason: decision.reason,
+                    potentialHarm: decision.potentialHarm,
+                    flourishingScore: decision.flourishingScore,
+                    reversible: decision.reversible,
+                },
+                duration: Date.now() - start,
+            };
+        }
+        catch (error) {
+            // Conservative fallback: defer on error (not auto-approve)
+            return {
+                success: false,
+                action: 'verify.ethics',
+                error: error instanceof Error ? error.message : String(error),
+                data: {
+                    approved: false,
+                    deferred: true,
+                    priority: 'P0_SURVIVAL',
+                    confidence: 0,
+                    reason: 'Ethicist evaluation failed - deferring for safety',
+                },
+                duration: Date.now() - start,
+            };
+        }
     });
     // execute.task: Execute a task via Kernel
     (0, actions_js_1.registerAction)('execute.task', async (context) => {

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

@@ -37,7 +37,7 @@
  * └─────────────────────────────────────────────────────────────────────┘
  * ```
  */
-import { BrainState, BrainConfig, BrainMetrics, BrainEventHandler } from './types.js';
+import { BrainState, BrainConfig, BrainMetrics, BrainEventHandler, ProcessContext } from './types.js';
 import { SelfKnowledge } from './self-knowledge.js';
 import { UnifiedMemoryQuery } from '../memory/unified-query.js';
 export declare class Brain {
@@ -200,8 +200,11 @@ export declare class Brain {
      * memory → llm → grounding → tools → done
      *
      * Each module can route to another via Command({ goto, update })
+     *
+     * @param input - User input query
+     * @param context - Optional context from external systems (Genesis bootstrap)
      */
-    process(input: string): Promise<string>;
+    process(input: string, context?: ProcessContext): Promise<string>;
     /**
      * v7.13: Auto-persist state after each processing cycle
      */

package/dist/src/brain/index.js

@@ -958,8 +958,11 @@ class Brain {
      * memory → llm → grounding → tools → done
      *
      * Each module can route to another via Command({ goto, update })
+     *
+     * @param input - User input query
+     * @param context - Optional context from external systems (Genesis bootstrap)
      */
-    async process(input) {
+    async process(input, context) {
         const startTime = Date.now();
         // Initialize state
         let state = {
@@ -968,13 +971,40 @@ class Brain {
             response: '',
             toolCalls: [],
             toolResults: [],
-            phi: this.getCurrentPhi(),
+            phi: context?.consciousness?.phi ?? this.getCurrentPhi(),
             ignited: false,
             verified: false,
             healingAttempts: 0,
             startTime,
             moduleHistory: [],
         };
+        // Process injected context from Genesis bootstrap
+        if (context?.workspaceItems?.length) {
+            const items = context.workspaceItems.map((w, i) => ({
+                id: `injected-${i}`,
+                type: w.type === 'episodic' ? 'episodic' : w.type === 'semantic' ? 'semantic' : 'task',
+                content: w.content,
+                relevance: w.relevance,
+                activation: 1.0,
+                source: w.source || 'genesis-context',
+            }));
+            // Pre-fill context
+            state.context = {
+                ...state.context,
+                task: items.filter(i => i.type === 'task'),
+                episodic: items.filter(i => i.type === 'episodic'),
+                semantic: items.filter(i => i.type === 'semantic'),
+                formatted: items.map(i => i.content).join('\n'),
+                tokenEstimate: items.reduce((s, i) => s + i.content.length / 4, 0),
+                reuseRate: 0,
+            };
+        }
+        // Store additional context metadata for modules
+        if (context?.sensorimotorState || context?.metadata) {
+            // Store in state for module access (modules can access via state)
+            // Note: BrainState doesn't have metadata field yet, so modules would need
+            // to access this via the formatted context or through a future extension
+        }
         // Initial command: start with memory
         let command = {
             goto: this.config.memory.enabled ? 'memory' : 'llm',

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

@@ -183,3 +183,39 @@ export interface BrainEvent {
     module?: BrainModule;
 }
 export type BrainEventHandler = (event: BrainEvent) => void;
+/**
+ * Optional context injected into Brain.process() from external systems.
+ * Allows Genesis bootstrap to feed workspace state, sensorimotor perception,
+ * and consciousness data into the processing cycle.
+ */
+export interface ProcessContext {
+    /** Pre-loaded workspace items (bypasses internal memory lookup) */
+    workspaceItems?: WorkspaceItem[];
+    /** Sensorimotor perception data for embodied cognition */
+    sensorimotorState?: {
+        perception?: {
+            features: number[];
+            confidence: number;
+            modalities: string[];
+        };
+        sensorState?: {
+            joints: number[];
+            forces: number[];
+            safety: string;
+        };
+    };
+    /** Current consciousness metrics */
+    consciousness?: {
+        phi: number;
+        attentionFocus?: string;
+        mode?: string;
+    };
+    /** Additional metadata from the caller */
+    metadata?: Record<string, unknown>;
+}
+export interface WorkspaceItem {
+    content: string;
+    type: 'episodic' | 'semantic' | 'procedural';
+    relevance: number;
+    source: string;
+}

package/dist/src/economy/autonomous.d.ts

@@ -2,22 +2,31 @@
  * Autonomous Economic Controller
  *
  * The central orchestrator for Genesis's autonomous revenue generation.
- * Coordinates all generators, infrastructure services, and asset managers.
+ * Full Active Inference architecture with Bayesian generative model.
  *
  * Architecture:
  *   AutonomousController
- *     ├── CapitalAllocator (leapfrog symplectic integrator)
- *     ├── Generators/ (active revenue: keeper, bounties, content)
- *     ├── Infrastructure/ (agent economy: MCP marketplace, x402, reputation)
- *     ├── Assets/ (passive: yield, compute, domains)
- *     └── NESSMonitor (convergence tracking)
+ *     ├── GenerativeModel (Bayesian beliefs + regime HMM + adaptive β)
+ *     │     ├── ActivityBeliefs (Normal-Inverse-Gamma conjugate posteriors)
+ *     │     ├── MarketRegime (3-state HMM: bull/neutral/bear)
+ *     │     ├── AdaptiveTemperature (annealing: explore→exploit)
+ *     │     └── TemporalPlanner (2-step EFE lookahead)
+ *     ├── EconomicEFE (Expected Free Energy action selection)
+ *     ├── EconomicContraction (Lipschitz stability monitoring)
+ *     ├── AutonomousNESS (activity-based convergence)
+ *     ├── CapitalAllocator (leapfrog symplectic integrator + contraction damping)
+ *     ├── Generators/ (active: keeper, bounties, content, auditor)
+ *     ├── Infrastructure/ (platform: MCP marketplace, x402, memory, orchestrator)
+ *     ├── Assets/ (passive: yield, compute)
+ *     └── Multipliers/ (non-linear: grants, cross-L2 arb)
  *
- * Control loop:
- *   1. Observe: Read balances, check pending payouts
- *   2. Allocate: Leapfrog step to rebalance portfolio
- *   3. Execute: Run highest-priority activities
- *   4. Record: Update fiber bundle with costs/revenue
- *   5. Monitor: Check NESS convergence, contraction stability
+ * Control loop (per cycle):
+ *   1. Contraction check → damping recommendation
+ *   2. Allocate: leapfrog step with stability-informed damping
+ *   3. Execute: EFE + temporal planning + Boltzmann(β_adaptive) selection
+ *   4. Observe NESS: activity-based deviation tracking
+ *   5. Infer: Bayesian belief update + regime inference + temperature adaptation
+ *   6. Phase check → unlock new activities at revenue thresholds
  *
  * NESS target (autonomous, no customers):
  *   Revenue ≥ Costs from Month 1 ($2,500 revenue, $150 costs)
@@ -92,6 +101,7 @@ export declare class AutonomousController {
     private totalCosts;
     private startedAt;
     private lastCycle;
+    private lastAdaptiveBeta;
     private errors;
     private running;
     constructor(config?: Partial<AutonomousConfig>);
@@ -146,10 +156,19 @@ export declare class AutonomousController {
      */
     private getROIVector;
     private executeActivities;
+    /**
+     * Boltzmann (softmax) action selection with given temperature β.
+     */
+    private boltzmannSelect;
     private executeActivity;
     private maintenance;
     private checkPhaseTransition;
     private unlockPhaseActivities;
+    /**
+     * Pause high-risk activities when circuit breaker triggers.
+     * Preserves zero-capital and low-risk activities.
+     */
+    private pauseRiskyActivities;
     private getActivityStatuses;
 }
 export declare function getAutonomousController(config?: Partial<AutonomousConfig>): AutonomousController;

package/dist/src/economy/autonomous.js

@@ -3,22 +3,31 @@
  * Autonomous Economic Controller
  *
  * The central orchestrator for Genesis's autonomous revenue generation.
- * Coordinates all generators, infrastructure services, and asset managers.
+ * Full Active Inference architecture with Bayesian generative model.
  *
  * Architecture:
  *   AutonomousController
- *     ├── CapitalAllocator (leapfrog symplectic integrator)
- *     ├── Generators/ (active revenue: keeper, bounties, content)
- *     ├── Infrastructure/ (agent economy: MCP marketplace, x402, reputation)
- *     ├── Assets/ (passive: yield, compute, domains)
- *     └── NESSMonitor (convergence tracking)
+ *     ├── GenerativeModel (Bayesian beliefs + regime HMM + adaptive β)
+ *     │     ├── ActivityBeliefs (Normal-Inverse-Gamma conjugate posteriors)
+ *     │     ├── MarketRegime (3-state HMM: bull/neutral/bear)
+ *     │     ├── AdaptiveTemperature (annealing: explore→exploit)
+ *     │     └── TemporalPlanner (2-step EFE lookahead)
+ *     ├── EconomicEFE (Expected Free Energy action selection)
+ *     ├── EconomicContraction (Lipschitz stability monitoring)
+ *     ├── AutonomousNESS (activity-based convergence)
+ *     ├── CapitalAllocator (leapfrog symplectic integrator + contraction damping)
+ *     ├── Generators/ (active: keeper, bounties, content, auditor)
+ *     ├── Infrastructure/ (platform: MCP marketplace, x402, memory, orchestrator)
+ *     ├── Assets/ (passive: yield, compute)
+ *     └── Multipliers/ (non-linear: grants, cross-L2 arb)
  *
- * Control loop:
- *   1. Observe: Read balances, check pending payouts
- *   2. Allocate: Leapfrog step to rebalance portfolio
- *   3. Execute: Run highest-priority activities
- *   4. Record: Update fiber bundle with costs/revenue
- *   5. Monitor: Check NESS convergence, contraction stability
+ * Control loop (per cycle):
+ *   1. Contraction check → damping recommendation
+ *   2. Allocate: leapfrog step with stability-informed damping
+ *   3. Execute: EFE + temporal planning + Boltzmann(β_adaptive) selection
+ *   4. Observe NESS: activity-based deviation tracking
+ *   5. Infer: Bayesian belief update + regime inference + temperature adaptation
+ *   6. Phase check → unlock new activities at revenue thresholds
  *
  * NESS target (autonomous, no customers):
  *   Revenue ≥ Costs from Month 1 ($2,500 revenue, $150 costs)
@@ -34,6 +43,8 @@ const fiber_js_1 = require("./fiber.js");
 const ness_js_1 = require("./ness.js");
 const capital_allocator_js_1 = require("./capital-allocator.js");
 const economic_intelligence_js_1 = require("./economic-intelligence.js");
+const generative_model_js_1 = require("./generative-model.js");
+const variational_engine_js_1 = require("./variational-engine.js");
 const keeper_js_1 = require("./generators/keeper.js");
 const bounty_hunter_js_1 = require("./generators/bounty-hunter.js");
 const mcp_marketplace_js_1 = require("./infrastructure/mcp-marketplace.js");
@@ -240,6 +251,7 @@ class AutonomousController {
     totalCosts = 0;
     startedAt = Date.now();
     lastCycle = 0;
+    lastAdaptiveBeta = 5.0;
     errors = [];
     running = false;
     constructor(config) {
@@ -268,6 +280,9 @@ class AutonomousController {
         const allocator = (0, capital_allocator_js_1.getCapitalAllocator)(this.config.seedCapital);
         const activeProfiles = ACTIVITY_PROFILES.filter(a => this.config.enabledActivities.includes(a.id));
         allocator.registerActivities(activeProfiles);
+        // Initialize generative model (Bayesian beliefs + regime + temperature)
+        const model = (0, generative_model_js_1.getGenerativeModel)();
+        model.initializeActivities(ACTIVITY_PROFILES);
         // Initialize NESS monitor for autonomous mode
         const ness = (0, ness_js_1.getNESSMonitor)({
             targetRevenue: this.config.nessTarget.monthlyRevenue,
@@ -374,11 +389,45 @@ class AutonomousController {
                 allocations: currentAllocations,
             });
             result.nessDeviation = nessState.deviation;
-            // 6. RECORD EFE RESULTS: Update intelligence history
+            // 6. RECORD & INFER: Update beliefs, regime, temperature
             const efe = (0, economic_intelligence_js_1.getEconomicEFE)();
+            const model = (0, generative_model_js_1.getGenerativeModel)();
+            const activityResults = [];
             for (const exec of executed) {
                 const roi = exec.cost > 0 ? exec.revenue / exec.cost : exec.revenue > 0 ? 10 : 0;
                 efe.recordExecution(exec.id, roi);
+                activityResults.push({ id: exec.id, roi });
+            }
+            // Generative model inference: Bayesian belief update + regime + temperature
+            const modelState = model.infer({
+                activityResults,
+                nessDeviation: nessState.deviation,
+                contractionStable: contractionState.stable,
+                logLipAvg: contraction.getLogLipAvg(),
+                cycleCount: this.cycleCount,
+            });
+            // Feed adaptive temperature back to EFE for next cycle
+            this.lastAdaptiveBeta = modelState.temperature.beta;
+            // 6b. VARIATIONAL STEP: VFE + precision scoring + risk assessment
+            const engine = (0, variational_engine_js_1.getVariationalEngine)();
+            const currentBalance = this.config.seedCapital + this.totalRevenue - this.totalCosts;
+            const varState = engine.step({
+                activities: allocator.getActivities().filter(a => a.active),
+                beliefs: model.beliefs,
+                allocations: allocator.getAllocations(),
+                observations: activityResults.map(r => ({ activityId: r.id, observedROI: r.roi })),
+                regimeFactor: model.getRegimeFactor(),
+                targetROI: 2.0 * model.getRegimeFactor(),
+                currentBalance,
+            });
+            // Circuit breaker: if drawdown exceeds limit, pause risky activities
+            if (varState.circuitBroken) {
+                result.errors.push('CIRCUIT BREAKER: Max drawdown exceeded, pausing risky activities');
+                this.pauseRiskyActivities(allocator);
+            }
+            // Risk warnings
+            if (varState.risk.warnings.length > 0) {
+                result.errors.push(...varState.risk.warnings);
             }
             // 7. PHASE CHECK: Upgrade if threshold met
             const monthlyRevenue = this.estimateMonthlyRevenue();
@@ -533,18 +582,28 @@ class AutonomousController {
         const results = [];
         const allocator = (0, capital_allocator_js_1.getCapitalAllocator)();
         const efe = (0, economic_intelligence_js_1.getEconomicEFE)();
+        const model = (0, generative_model_js_1.getGenerativeModel)();
         const activeActivities = allocator.getActivities().filter(a => a.active);
         const allocations = allocator.getAllocations();
-        // Score all activities using Expected Free Energy
-        const scores = efe.scoreActivities(activeActivities, allocations);
-        // Select activities via Boltzmann sampling (Active Inference)
+        // Score activities using belief-informed EFE
+        // Regime factor adjusts expected ROIs for current market conditions
+        const regimeFactor = model.getRegimeFactor();
+        const targetROI = 2.0 * regimeFactor; // Adjust target by regime
+        const scores = efe.scoreActivities(activeActivities, allocations, targetROI);
+        // Apply temporal planning: rank by G_now + γ × E[G_next]
+        const plans = model.planner.rankWithLookahead(scores, model.beliefs, activeActivities, allocations, regimeFactor);
+        // Select via Boltzmann sampling with adaptive temperature
         const selected = new Set();
         let executed = 0;
-        while (executed < this.config.maxConcurrentActivities && selected.size < activeActivities.length) {
-            const remainingScores = scores.filter(s => !selected.has(s.activityId));
+        // Use plan ordering as primary, with stochastic selection via adaptive β
+        const candidateIds = plans.map(p => p.immediateAction);
+        while (executed < this.config.maxConcurrentActivities && selected.size < candidateIds.length) {
+            // Build remaining scores for Boltzmann selection
+            const remainingScores = scores.filter(s => candidateIds.includes(s.activityId) && !selected.has(s.activityId));
             if (remainingScores.length === 0)
                 break;
-            const activityId = efe.selectAction(remainingScores);
+            // Boltzmann selection with adaptive β
+            const activityId = this.boltzmannSelect(remainingScores, this.lastAdaptiveBeta);
             if (!activityId || selected.has(activityId))
                 break;
             selected.add(activityId);
@@ -561,6 +620,26 @@ class AutonomousController {
         }
         return results;
     }
+    /**
+     * Boltzmann (softmax) action selection with given temperature β.
+     */
+    boltzmannSelect(scores, beta) {
+        if (scores.length === 0)
+            return null;
+        const negG = scores.map(s => -s.G * beta);
+        const maxNegG = Math.max(...negG);
+        const expScores = negG.map(g => Math.exp(g - maxNegG));
+        const sumExp = expScores.reduce((s, e) => s + e, 0);
+        const probs = expScores.map(e => e / sumExp);
+        const r = Math.random();
+        let cumProb = 0;
+        for (let i = 0; i < probs.length; i++) {
+            cumProb += probs[i];
+            if (r <= cumProb)
+                return scores[i].activityId;
+        }
+        return scores[0].activityId;
+    }
     async executeActivity(activityId) {
         switch (activityId) {
             case 'keeper': {
@@ -747,6 +826,18 @@ class AutonomousController {
             allocator.setActivityActive(activityId, true);
         }
     }
+    /**
+     * Pause high-risk activities when circuit breaker triggers.
+     * Preserves zero-capital and low-risk activities.
+     */
+    pauseRiskyActivities(allocator) {
+        const riskyTiers = ['B', 'C', 'D']; // Pause capital-intensive activities
+        for (const activity of allocator.getActivities()) {
+            if (riskyTiers.includes(activity.tier) && activity.riskLevel > 0.4) {
+                allocator.setActivityActive(activity.id, false);
+            }
+        }
+    }
     getActivityStatuses() {
         const allocator = (0, capital_allocator_js_1.getCapitalAllocator)();
         const fiber = (0, fiber_js_1.getEconomicFiber)();