genesis-ai-cli 13.3.1 → 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)
@@ -80,6 +89,8 @@ export interface CycleResult {
     costsIncurred: number;
     nessDeviation: number;
     phaseChanged: boolean;
+    contractionStable: boolean;
+    dampingApplied: number;
     errors: string[];
 }
 export declare class AutonomousController {
@@ -90,6 +101,7 @@ export declare class AutonomousController {
     private totalCosts;
     private startedAt;
     private lastCycle;
+    private lastAdaptiveBeta;
     private errors;
     private running;
     constructor(config?: Partial<AutonomousConfig>);
@@ -131,13 +143,32 @@ export declare class AutonomousController {
      * Get monthly revenue estimate (extrapolated from recent data).
      */
     estimateMonthlyRevenue(): number;
+    /**
+     * Get monthly cost estimate (extrapolated from recent data).
+     */
+    private estimateMonthlyCosts;
+    /**
+     * Get allocation vector for contraction monitoring.
+     */
+    private getAllocationVector;
+    /**
+     * Get ROI vector for contraction monitoring.
+     */
+    private getROIVector;
     private executeActivities;
+    /**
+     * Boltzmann (softmax) action selection with given temperature β.
+     */
+    private boltzmannSelect;
     private executeActivity;
     private maintenance;
     private checkPhaseTransition;
     private unlockPhaseActivities;
-    private buildNESSObservation;
-    private computeQuality;
+    /**
+     * 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;