genesis-ai-cli 9.2.0 → 9.3.0

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

@@ -1748,6 +1748,165 @@ class ActionExecutorManager {
 }
 exports.ActionExecutorManager = ActionExecutorManager;
 // ============================================================================
+// v9.3: ECONOMIC SELF-FUNDING ACTIONS
+// ============================================================================
+const economic_integration_js_1 = require("./economic-integration.js");
+/**
+ * econ.check: Check economic health (balance, costs, revenue, runway)
+ */
+registerAction('econ.check', async (_context) => {
+    const start = Date.now();
+    try {
+        const econ = (0, economic_integration_js_1.getEconomicIntegration)();
+        await econ.initialize();
+        const obs = await econ.getObservation();
+        const summary = await econ.getSummary();
+        return {
+            success: true,
+            action: 'econ.check',
+            data: {
+                balance: obs.balance,
+                monthlyCosts: obs.monthlyCosts,
+                monthlyRevenue: obs.monthlyRevenue,
+                runwayDays: obs.runwayDays,
+                health: ['critical', 'low', 'stable', 'growing'][obs.health],
+                summary,
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'econ.check',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+/**
+ * econ.optimize: Optimize costs (cheaper LLMs, aggressive caching)
+ */
+registerAction('econ.optimize', async (_context) => {
+    const start = Date.now();
+    try {
+        const econ = (0, economic_integration_js_1.getEconomicIntegration)();
+        await econ.initialize();
+        // Execute cost optimization actions
+        const llmResult = await econ.executeAction('economic:optimize-llm-usage');
+        const cacheResult = await econ.executeAction('economic:cache-expensive-calls');
+        // Get current cost breakdown
+        const breakdown = econ.getCostTracker().getCostBreakdown();
+        const dailyBurn = econ.getCostTracker().getDailyBurnRate();
+        return {
+            success: true,
+            action: 'econ.optimize',
+            data: {
+                llmOptimization: llmResult.success,
+                cachingEnabled: cacheResult.success,
+                currentCostBreakdown: breakdown,
+                dailyBurnRate: dailyBurn,
+                recommendation: dailyBurn > 10
+                    ? 'Consider reducing LLM usage or using cheaper models'
+                    : 'Cost levels acceptable',
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'econ.optimize',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+/**
+ * econ.activate: Activate a revenue-generating service
+ */
+registerAction('econ.activate', async (context) => {
+    const start = Date.now();
+    try {
+        const econ = (0, economic_integration_js_1.getEconomicIntegration)();
+        await econ.initialize();
+        const serviceName = context.parameters?.service || 'genesis-api';
+        const result = await econ.executeAction(`economic:activate-service:${serviceName}`);
+        // Get all services status
+        const services = econ.getServiceRegistry().getAll();
+        const activeServices = econ.getServiceRegistry().getActive();
+        return {
+            success: result.success,
+            action: 'econ.activate',
+            data: {
+                service: serviceName,
+                activated: result.success,
+                totalServices: services.length,
+                activeServices: activeServices.map(s => s.name),
+                potentialMonthlyRevenue: econ.getServiceRegistry().estimateMonthlyPotential(),
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'econ.activate',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+/**
+ * econ.promote: Promote services to increase revenue
+ */
+registerAction('econ.promote', async (context) => {
+    const start = Date.now();
+    try {
+        const econ = (0, economic_integration_js_1.getEconomicIntegration)();
+        await econ.initialize();
+        const serviceName = context.parameters?.service || '';
+        // If no specific service, promote all active services
+        const activeServices = econ.getServiceRegistry().getActive();
+        const promotedServices = [];
+        if (serviceName) {
+            const result = await econ.executeAction(`economic:promote-service:${serviceName}`);
+            if (result.success)
+                promotedServices.push(serviceName);
+        }
+        else {
+            for (const service of activeServices) {
+                const result = await econ.executeAction(`economic:promote-service:${service.name}`);
+                if (result.success)
+                    promotedServices.push(service.name);
+            }
+        }
+        // Enable micropayments for API endpoints
+        await econ.executeAction('economic:enable-micropayments');
+        return {
+            success: promotedServices.length > 0,
+            action: 'econ.promote',
+            data: {
+                promotedServices,
+                micropayentsEnabled: true,
+                activeServices: activeServices.map(s => ({
+                    name: s.name,
+                    pricing: s.pricing,
+                })),
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'econ.promote',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+// ============================================================================
 // Factory
 // ============================================================================
 let managerInstance = null;

package/dist/src/active-inference/economic-integration.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Genesis v9.3 - Economic Integration for Active Inference
+ *
+ * Creates the autopoietic self-funding loop:
+ * 1. OBSERVE: Track costs, balance, revenue, runway
+ * 2. ACT: Create services, set prices, deploy products
+ * 3. LEARN: Optimize for economic sustainability
+ * 4. SURVIVE: Ensure Genesis can pay for its own existence
+ *
+ * This module connects the Economic System to Active Inference,
+ * making economic sustainability a core part of Genesis's reward function.
+ */
+export interface EconomicObservation {
+    /** Total available balance (fiat + crypto in USD) */
+    balance: number;
+    /** Estimated monthly costs */
+    monthlyCosts: number;
+    /** Monthly revenue */
+    monthlyRevenue: number;
+    /** Runway in days (balance / daily burn rate) */
+    runwayDays: number;
+    /** Economic health: 0=critical, 1=low, 2=stable, 3=growing */
+    health: 0 | 1 | 2 | 3;
+}
+export interface CostRecord {
+    timestamp: number;
+    category: 'llm' | 'mcp' | 'compute' | 'storage' | 'api' | 'other';
+    provider: string;
+    amount: number;
+    description: string;
+}
+export interface RevenueRecord {
+    timestamp: number;
+    source: 'subscription' | 'api' | 'service' | 'micropayment' | 'other';
+    amount: number;
+    customer?: string;
+    description: string;
+}
+export interface ServiceDefinition {
+    name: string;
+    description: string;
+    endpoint?: string;
+    pricing: {
+        model: 'subscription' | 'per-request' | 'tiered';
+        basePrice: number;
+        currency: string;
+    };
+    capabilities: string[];
+    status: 'draft' | 'active' | 'paused' | 'retired';
+}
+export interface EconomicGoal {
+    type: 'maintain-runway' | 'grow-revenue' | 'reduce-costs' | 'expand-services';
+    target: number;
+    deadline?: Date;
+    priority: number;
+}
+export declare class CostTracker {
+    private costs;
+    private readonly maxHistory;
+    /**
+     * Record a cost
+     */
+    record(cost: Omit<CostRecord, 'timestamp'>): void;
+    /**
+     * Record LLM API cost
+     */
+    recordLLMCost(provider: string, inputTokens: number, outputTokens: number, model: string): void;
+    /**
+     * Record MCP server cost (if applicable)
+     */
+    recordMCPCost(server: string, operationType: string, cost: number): void;
+    /**
+     * Get costs for a time period
+     */
+    getCosts(periodMs?: number): CostRecord[];
+    /**
+     * Get total cost for a period
+     */
+    getTotalCost(periodMs?: number): number;
+    /**
+     * Get cost breakdown by category
+     */
+    getCostBreakdown(periodMs?: number): Record<string, number>;
+    /**
+     * Estimate daily burn rate
+     */
+    getDailyBurnRate(periodMs?: number): number;
+}
+export declare class RevenueTracker {
+    private revenue;
+    private readonly maxHistory;
+    /**
+     * Record revenue
+     */
+    record(rev: Omit<RevenueRecord, 'timestamp'>): void;
+    /**
+     * Get revenue for a period
+     */
+    getRevenue(periodMs?: number): RevenueRecord[];
+    /**
+     * Get total revenue for a period
+     */
+    getTotalRevenue(periodMs?: number): number;
+    /**
+     * Get revenue breakdown by source
+     */
+    getRevenueBreakdown(periodMs?: number): Record<string, number>;
+}
+export declare class ServiceRegistry {
+    private services;
+    /**
+     * Register a service Genesis can offer
+     */
+    register(service: ServiceDefinition): void;
+    /**
+     * Get all services
+     */
+    getAll(): ServiceDefinition[];
+    /**
+     * Get active services
+     */
+    getActive(): ServiceDefinition[];
+    /**
+     * Update service status
+     */
+    setStatus(name: string, status: ServiceDefinition['status']): boolean;
+    /**
+     * Get potential revenue from all active services
+     */
+    estimateMonthlyPotential(): number;
+}
+export declare class EconomicIntegration {
+    private economy;
+    private costTracker;
+    private revenueTracker;
+    private serviceRegistry;
+    private goals;
+    private initialized;
+    constructor();
+    /**
+     * Initialize economic integration
+     */
+    initialize(): Promise<boolean>;
+    /**
+     * Register default services Genesis can offer
+     */
+    private registerDefaultServices;
+    /**
+     * Get current economic observation for Active Inference
+     */
+    getObservation(): Promise<EconomicObservation>;
+    /**
+     * Map economic observation to Active Inference discrete state
+     * Returns 0-3 for use in observation vector
+     */
+    getDiscreteObservation(): Promise<number>;
+    /**
+     * Get available economic actions
+     */
+    getAvailableActions(): string[];
+    /**
+     * Execute an economic action
+     */
+    executeAction(action: string): Promise<{
+        success: boolean;
+        result?: unknown;
+        error?: string;
+    }>;
+    /**
+     * Calculate economic reward for Active Inference
+     * Returns a value between -1 and 1
+     */
+    calculateReward(): Promise<number>;
+    /**
+     * Get economic goals for planning
+     */
+    getGoals(): EconomicGoal[];
+    /**
+     * Update goal based on current state
+     */
+    updateGoals(): Promise<void>;
+    /**
+     * Get summary for logging
+     */
+    getSummary(): Promise<string>;
+    getCostTracker(): CostTracker;
+    getRevenueTracker(): RevenueTracker;
+    getServiceRegistry(): ServiceRegistry;
+}
+export declare function getEconomicIntegration(): EconomicIntegration;
+/**
+ * Hook to record LLM costs (call this after each LLM request)
+ */
+export declare function recordLLMCost(provider: string, inputTokens: number, outputTokens: number, model: string): void;
+/**
+ * Hook to record revenue (call this when receiving payment)
+ */
+export declare function recordRevenue(source: RevenueRecord['source'], amount: number, description: string, customer?: string): void;
+export default EconomicIntegration;

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

@@ -0,0 +1,529 @@
+"use strict";
+/**
+ * Genesis v9.3 - Economic Integration for Active Inference
+ *
+ * Creates the autopoietic self-funding loop:
+ * 1. OBSERVE: Track costs, balance, revenue, runway
+ * 2. ACT: Create services, set prices, deploy products
+ * 3. LEARN: Optimize for economic sustainability
+ * 4. SURVIVE: Ensure Genesis can pay for its own existence
+ *
+ * This module connects the Economic System to Active Inference,
+ * making economic sustainability a core part of Genesis's reward function.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EconomicIntegration = exports.ServiceRegistry = exports.RevenueTracker = exports.CostTracker = void 0;
+exports.getEconomicIntegration = getEconomicIntegration;
+exports.recordLLMCost = recordLLMCost;
+exports.recordRevenue = recordRevenue;
+const index_js_1 = require("../economy/index.js");
+// ============================================================================
+// Cost Tracker
+// ============================================================================
+class CostTracker {
+    costs = [];
+    maxHistory = 10000;
+    /**
+     * Record a cost
+     */
+    record(cost) {
+        this.costs.push({
+            ...cost,
+            timestamp: Date.now(),
+        });
+        // Bounded history to prevent memory leak
+        if (this.costs.length > this.maxHistory) {
+            this.costs = this.costs.slice(-this.maxHistory);
+        }
+    }
+    /**
+     * Record LLM API cost
+     */
+    recordLLMCost(provider, inputTokens, outputTokens, model) {
+        // Cost per 1M tokens (approximate 2024-2025 pricing)
+        const pricing = {
+            'claude-3-opus': { input: 15, output: 75 },
+            'claude-3-sonnet': { input: 3, output: 15 },
+            'claude-3-haiku': { input: 0.25, output: 1.25 },
+            'claude-opus-4': { input: 15, output: 75 },
+            'claude-sonnet-4': { input: 3, output: 15 },
+            'gpt-4o': { input: 2.5, output: 10 },
+            'gpt-4o-mini': { input: 0.15, output: 0.6 },
+            'gemini-pro': { input: 0.5, output: 1.5 },
+            'gemini-flash': { input: 0.075, output: 0.3 },
+            'default': { input: 1, output: 4 },
+        };
+        const rates = pricing[model] || pricing['default'];
+        const cost = (inputTokens / 1_000_000) * rates.input + (outputTokens / 1_000_000) * rates.output;
+        this.record({
+            category: 'llm',
+            provider,
+            amount: cost,
+            description: `${model}: ${inputTokens} in, ${outputTokens} out`,
+        });
+    }
+    /**
+     * Record MCP server cost (if applicable)
+     */
+    recordMCPCost(server, operationType, cost) {
+        this.record({
+            category: 'mcp',
+            provider: server,
+            amount: cost,
+            description: `MCP ${server}: ${operationType}`,
+        });
+    }
+    /**
+     * Get costs for a time period
+     */
+    getCosts(periodMs = 30 * 24 * 60 * 60 * 1000) {
+        const cutoff = Date.now() - periodMs;
+        return this.costs.filter(c => c.timestamp >= cutoff);
+    }
+    /**
+     * Get total cost for a period
+     */
+    getTotalCost(periodMs = 30 * 24 * 60 * 60 * 1000) {
+        return this.getCosts(periodMs).reduce((sum, c) => sum + c.amount, 0);
+    }
+    /**
+     * Get cost breakdown by category
+     */
+    getCostBreakdown(periodMs = 30 * 24 * 60 * 60 * 1000) {
+        const costs = this.getCosts(periodMs);
+        const breakdown = {};
+        for (const cost of costs) {
+            breakdown[cost.category] = (breakdown[cost.category] || 0) + cost.amount;
+        }
+        return breakdown;
+    }
+    /**
+     * Estimate daily burn rate
+     */
+    getDailyBurnRate(periodMs = 7 * 24 * 60 * 60 * 1000) {
+        const total = this.getTotalCost(periodMs);
+        const days = periodMs / (24 * 60 * 60 * 1000);
+        return total / days;
+    }
+}
+exports.CostTracker = CostTracker;
+// ============================================================================
+// Revenue Tracker
+// ============================================================================
+class RevenueTracker {
+    revenue = [];
+    maxHistory = 10000;
+    /**
+     * Record revenue
+     */
+    record(rev) {
+        this.revenue.push({
+            ...rev,
+            timestamp: Date.now(),
+        });
+        if (this.revenue.length > this.maxHistory) {
+            this.revenue = this.revenue.slice(-this.maxHistory);
+        }
+    }
+    /**
+     * Get revenue for a period
+     */
+    getRevenue(periodMs = 30 * 24 * 60 * 60 * 1000) {
+        const cutoff = Date.now() - periodMs;
+        return this.revenue.filter(r => r.timestamp >= cutoff);
+    }
+    /**
+     * Get total revenue for a period
+     */
+    getTotalRevenue(periodMs = 30 * 24 * 60 * 60 * 1000) {
+        return this.getRevenue(periodMs).reduce((sum, r) => sum + r.amount, 0);
+    }
+    /**
+     * Get revenue breakdown by source
+     */
+    getRevenueBreakdown(periodMs = 30 * 24 * 60 * 60 * 1000) {
+        const revenue = this.getRevenue(periodMs);
+        const breakdown = {};
+        for (const rev of revenue) {
+            breakdown[rev.source] = (breakdown[rev.source] || 0) + rev.amount;
+        }
+        return breakdown;
+    }
+}
+exports.RevenueTracker = RevenueTracker;
+// ============================================================================
+// Service Registry
+// ============================================================================
+class ServiceRegistry {
+    services = new Map();
+    /**
+     * Register a service Genesis can offer
+     */
+    register(service) {
+        this.services.set(service.name, service);
+    }
+    /**
+     * Get all services
+     */
+    getAll() {
+        return Array.from(this.services.values());
+    }
+    /**
+     * Get active services
+     */
+    getActive() {
+        return this.getAll().filter(s => s.status === 'active');
+    }
+    /**
+     * Update service status
+     */
+    setStatus(name, status) {
+        const service = this.services.get(name);
+        if (service) {
+            service.status = status;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get potential revenue from all active services
+     */
+    estimateMonthlyPotential() {
+        return this.getActive().reduce((sum, s) => {
+            // Estimate based on pricing model
+            switch (s.pricing.model) {
+                case 'subscription':
+                    return sum + s.pricing.basePrice; // Per subscriber
+                case 'per-request':
+                    return sum + s.pricing.basePrice * 1000; // Estimate 1000 requests
+                case 'tiered':
+                    return sum + s.pricing.basePrice * 10; // Estimate 10 units
+                default:
+                    return sum;
+            }
+        }, 0);
+    }
+}
+exports.ServiceRegistry = ServiceRegistry;
+// ============================================================================
+// Economic Integration for Active Inference
+// ============================================================================
+class EconomicIntegration {
+    economy;
+    costTracker;
+    revenueTracker;
+    serviceRegistry;
+    goals = [];
+    initialized = false;
+    constructor() {
+        this.economy = (0, index_js_1.getEconomicSystem)();
+        this.costTracker = new CostTracker();
+        this.revenueTracker = new RevenueTracker();
+        this.serviceRegistry = new ServiceRegistry();
+        // Register default services Genesis can offer
+        this.registerDefaultServices();
+    }
+    /**
+     * Initialize economic integration
+     */
+    async initialize() {
+        if (this.initialized)
+            return true;
+        const status = await this.economy.initialize();
+        this.initialized = status.stripe || status.crypto;
+        // Set default economic goals
+        this.goals = [
+            {
+                type: 'maintain-runway',
+                target: 90, // 90 days runway minimum
+                priority: 1, // Highest priority
+            },
+            {
+                type: 'reduce-costs',
+                target: 0.8, // Target 80% of current costs
+                priority: 2,
+            },
+            {
+                type: 'grow-revenue',
+                target: 1.2, // Target 120% of current revenue
+                priority: 3,
+            },
+        ];
+        return this.initialized;
+    }
+    /**
+     * Register default services Genesis can offer
+     */
+    registerDefaultServices() {
+        // Code generation service
+        this.serviceRegistry.register({
+            name: 'genesis-code-gen',
+            description: 'AI-powered code generation with self-healing capabilities',
+            pricing: { model: 'per-request', basePrice: 0.10, currency: 'USD' },
+            capabilities: ['code-generation', 'bug-fixing', 'refactoring'],
+            status: 'draft',
+        });
+        // Architecture review service
+        this.serviceRegistry.register({
+            name: 'genesis-architect',
+            description: 'Autonomous architecture analysis and recommendations',
+            pricing: { model: 'per-request', basePrice: 0.50, currency: 'USD' },
+            capabilities: ['architecture-review', 'pattern-detection', 'optimization'],
+            status: 'draft',
+        });
+        // Continuous monitoring service
+        this.serviceRegistry.register({
+            name: 'genesis-monitor',
+            description: 'AI-powered codebase monitoring and issue detection',
+            pricing: { model: 'subscription', basePrice: 49.00, currency: 'USD' },
+            capabilities: ['monitoring', 'alerting', 'auto-healing'],
+            status: 'draft',
+        });
+        // API access subscription
+        this.serviceRegistry.register({
+            name: 'genesis-api',
+            description: 'Full API access to Genesis capabilities',
+            pricing: { model: 'subscription', basePrice: 99.00, currency: 'USD' },
+            capabilities: ['full-api', 'priority-support', 'custom-integrations'],
+            status: 'draft',
+        });
+    }
+    /**
+     * Get current economic observation for Active Inference
+     */
+    async getObservation() {
+        const balance = await this.economy.getUnifiedBalance();
+        const totalBalance = balance.fiat + balance.crypto.usdc +
+            balance.crypto.eth * 3000 + balance.crypto.sol * 100; // Rough USD conversion
+        const monthlyCosts = this.costTracker.getTotalCost(30 * 24 * 60 * 60 * 1000);
+        const monthlyRevenue = this.revenueTracker.getTotalRevenue(30 * 24 * 60 * 60 * 1000);
+        const dailyBurn = this.costTracker.getDailyBurnRate();
+        const runwayDays = dailyBurn > 0 ? totalBalance / dailyBurn : Infinity;
+        // Calculate health
+        let health;
+        if (runwayDays < 7) {
+            health = 0; // Critical
+        }
+        else if (runwayDays < 30) {
+            health = 1; // Low
+        }
+        else if (monthlyRevenue >= monthlyCosts) {
+            health = 3; // Growing (self-sustaining)
+        }
+        else {
+            health = 2; // Stable
+        }
+        return {
+            balance: totalBalance,
+            monthlyCosts,
+            monthlyRevenue,
+            runwayDays,
+            health,
+        };
+    }
+    /**
+     * Map economic observation to Active Inference discrete state
+     * Returns 0-3 for use in observation vector
+     */
+    async getDiscreteObservation() {
+        const obs = await this.getObservation();
+        return obs.health;
+    }
+    /**
+     * Get available economic actions
+     */
+    getAvailableActions() {
+        const actions = [
+            'economic:check-balance',
+            'economic:analyze-costs',
+        ];
+        // Add service activation actions for draft services
+        for (const service of this.serviceRegistry.getAll()) {
+            if (service.status === 'draft') {
+                actions.push(`economic:activate-service:${service.name}`);
+            }
+            if (service.status === 'active') {
+                actions.push(`economic:promote-service:${service.name}`);
+            }
+        }
+        // Add cost reduction actions
+        actions.push('economic:optimize-llm-usage');
+        actions.push('economic:cache-expensive-calls');
+        // Add revenue actions
+        actions.push('economic:create-subscription-product');
+        actions.push('economic:enable-micropayments');
+        return actions;
+    }
+    /**
+     * Execute an economic action
+     */
+    async executeAction(action) {
+        const [prefix, cmd, ...args] = action.split(':');
+        if (prefix !== 'economic') {
+            return { success: false, error: 'Not an economic action' };
+        }
+        switch (cmd) {
+            case 'check-balance': {
+                const balance = await this.economy.getUnifiedBalance();
+                return { success: true, result: balance };
+            }
+            case 'analyze-costs': {
+                const breakdown = this.costTracker.getCostBreakdown();
+                const dailyBurn = this.costTracker.getDailyBurnRate();
+                return { success: true, result: { breakdown, dailyBurn } };
+            }
+            case 'activate-service': {
+                const serviceName = args.join(':');
+                const activated = this.serviceRegistry.setStatus(serviceName, 'active');
+                if (activated) {
+                    // In production, this would deploy the service
+                    console.log(`[Economic] Activated service: ${serviceName}`);
+                }
+                return { success: activated, result: { service: serviceName } };
+            }
+            case 'promote-service': {
+                const serviceName = args.join(':');
+                const service = this.serviceRegistry.getAll().find(s => s.name === serviceName);
+                if (service && service.status === 'active') {
+                    // In production, this would create marketing materials, listings, etc.
+                    console.log(`[Economic] Promoting service: ${serviceName}`);
+                    return { success: true, result: { service: serviceName, promoted: true } };
+                }
+                return { success: false, error: 'Service not found or not active' };
+            }
+            case 'create-subscription-product': {
+                const result = await this.economy.createRevenueStream('Genesis Pro', 99, 'subscription');
+                return { success: !!result, result };
+            }
+            case 'enable-micropayments': {
+                // Set x402 rates for API endpoints
+                this.economy.x402.setRate('/api/generate', 0.01);
+                this.economy.x402.setRate('/api/analyze', 0.05);
+                this.economy.x402.setRate('/api/heal', 0.02);
+                return { success: true, result: { enabled: true } };
+            }
+            case 'optimize-llm-usage': {
+                // This would be connected to the LLM router to prefer cheaper models
+                console.log('[Economic] Optimizing LLM usage for cost efficiency');
+                return { success: true, result: { optimizationEnabled: true } };
+            }
+            case 'cache-expensive-calls': {
+                // This would increase cache TTL for expensive operations
+                console.log('[Economic] Enabling aggressive caching for expensive calls');
+                return { success: true, result: { cachingEnabled: true } };
+            }
+            default:
+                return { success: false, error: `Unknown economic action: ${cmd}` };
+        }
+    }
+    /**
+     * Calculate economic reward for Active Inference
+     * Returns a value between -1 and 1
+     */
+    async calculateReward() {
+        const obs = await this.getObservation();
+        let reward = 0;
+        // Runway reward (most important)
+        if (obs.runwayDays >= 90) {
+            reward += 0.4; // Stable runway
+        }
+        else if (obs.runwayDays >= 30) {
+            reward += 0.2;
+        }
+        else if (obs.runwayDays < 7) {
+            reward -= 0.5; // Critical penalty
+        }
+        // Revenue vs costs
+        if (obs.monthlyRevenue >= obs.monthlyCosts) {
+            reward += 0.4; // Self-sustaining!
+        }
+        else if (obs.monthlyCosts > 0) {
+            const ratio = obs.monthlyRevenue / obs.monthlyCosts;
+            reward += (ratio - 1) * 0.3; // Proportional to how close to break-even
+        }
+        // Growth potential
+        const potentialRevenue = this.serviceRegistry.estimateMonthlyPotential();
+        if (potentialRevenue > obs.monthlyCosts * 2) {
+            reward += 0.2; // Good growth potential
+        }
+        return Math.max(-1, Math.min(1, reward));
+    }
+    /**
+     * Get economic goals for planning
+     */
+    getGoals() {
+        return [...this.goals];
+    }
+    /**
+     * Update goal based on current state
+     */
+    async updateGoals() {
+        const obs = await this.getObservation();
+        // If runway is critical, increase its priority
+        if (obs.runwayDays < 30) {
+            const runwayGoal = this.goals.find(g => g.type === 'maintain-runway');
+            if (runwayGoal) {
+                runwayGoal.priority = 0; // Highest priority
+                runwayGoal.target = Math.max(30, obs.runwayDays * 2);
+            }
+        }
+        // If costs are growing faster than revenue, prioritize cost reduction
+        if (obs.monthlyCosts > obs.monthlyRevenue * 1.5) {
+            const costGoal = this.goals.find(g => g.type === 'reduce-costs');
+            if (costGoal) {
+                costGoal.priority = 1;
+            }
+        }
+    }
+    /**
+     * Get summary for logging
+     */
+    async getSummary() {
+        const obs = await this.getObservation();
+        const healthLabels = ['CRITICAL', 'LOW', 'STABLE', 'GROWING'];
+        return `[Economic] Health: ${healthLabels[obs.health]} | ` +
+            `Balance: $${obs.balance.toFixed(2)} | ` +
+            `Revenue: $${obs.monthlyRevenue.toFixed(2)}/mo | ` +
+            `Costs: $${obs.monthlyCosts.toFixed(2)}/mo | ` +
+            `Runway: ${obs.runwayDays === Infinity ? '∞' : Math.round(obs.runwayDays)} days`;
+    }
+    // Expose trackers for external use
+    getCostTracker() {
+        return this.costTracker;
+    }
+    getRevenueTracker() {
+        return this.revenueTracker;
+    }
+    getServiceRegistry() {
+        return this.serviceRegistry;
+    }
+}
+exports.EconomicIntegration = EconomicIntegration;
+// ============================================================================
+// Singleton & Exports
+// ============================================================================
+let economicIntegrationInstance = null;
+function getEconomicIntegration() {
+    if (!economicIntegrationInstance) {
+        economicIntegrationInstance = new EconomicIntegration();
+    }
+    return economicIntegrationInstance;
+}
+/**
+ * Hook to record LLM costs (call this after each LLM request)
+ */
+function recordLLMCost(provider, inputTokens, outputTokens, model) {
+    getEconomicIntegration().getCostTracker().recordLLMCost(provider, inputTokens, outputTokens, model);
+}
+/**
+ * Hook to record revenue (call this when receiving payment)
+ */
+function recordRevenue(source, amount, description, customer) {
+    getEconomicIntegration().getRevenueTracker().record({
+        source,
+        amount,
+        description,
+        customer,
+    });
+}
+exports.default = EconomicIntegration;

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

@@ -30,3 +30,4 @@ export { AutonomousLoop, createAutonomousLoop, getAutonomousLoop, resetAutonomou
 export { integrateActiveInference, createIntegratedSystem, createKernelObservationBridge, registerKernelActions, registerDaemonTask, createMCPObservationBridge, createMCPInferenceLoop, type IntegrationConfig, type IntegratedSystem, type MCPObservationConfig, } from './integration.js';
 export { ValueAugmentedEngine, createValueAugmentedEngine, createFullyIntegratedEngine, createValueIntegratedLoop, type ValueIntegrationConfig, type ValueIntegrationEvent, type ValueIntegratedLoopConfig, DEFAULT_VALUE_INTEGRATION_CONFIG, } from './value-integration.js';
 export { integrateMemory, getMemoryMetrics, getWorkspaceState, type MemoryIntegrationConfig, DEFAULT_MEMORY_INTEGRATION_CONFIG, } from './memory-integration.js';
+export { EconomicIntegration, getEconomicIntegration, recordLLMCost, recordRevenue, CostTracker, RevenueTracker, ServiceRegistry, type EconomicObservation, type CostRecord, type RevenueRecord, type ServiceDefinition, type EconomicGoal, } from './economic-integration.js';

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

@@ -38,7 +38,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_MEMORY_INTEGRATION_CONFIG = exports.getWorkspaceState = exports.getMemoryMetrics = exports.integrateMemory = exports.DEFAULT_VALUE_INTEGRATION_CONFIG = exports.createValueIntegratedLoop = exports.createFullyIntegratedEngine = exports.createValueAugmentedEngine = exports.ValueAugmentedEngine = exports.createMCPInferenceLoop = exports.createMCPObservationBridge = exports.registerDaemonTask = exports.registerKernelActions = exports.createKernelObservationBridge = exports.createIntegratedSystem = exports.integrateActiveInference = exports.DEFAULT_LOOP_CONFIG = exports.resetAutonomousLoop = exports.getAutonomousLoop = exports.createAutonomousLoop = exports.AutonomousLoop = exports.registerAction = exports.executeAction = exports.getActionExecutorManager = exports.createActionExecutorManager = exports.ActionExecutorManager = exports.getObservationGatherer = exports.createObservationGatherer = exports.ObservationGatherer = exports.createActiveInferenceEngine = exports.ActiveInferenceEngine = void 0;
+exports.ServiceRegistry = exports.RevenueTracker = exports.CostTracker = exports.recordRevenue = exports.recordLLMCost = exports.getEconomicIntegration = exports.EconomicIntegration = exports.DEFAULT_MEMORY_INTEGRATION_CONFIG = exports.getWorkspaceState = exports.getMemoryMetrics = exports.integrateMemory = exports.DEFAULT_VALUE_INTEGRATION_CONFIG = exports.createValueIntegratedLoop = exports.createFullyIntegratedEngine = exports.createValueAugmentedEngine = exports.ValueAugmentedEngine = exports.createMCPInferenceLoop = exports.createMCPObservationBridge = exports.registerDaemonTask = exports.registerKernelActions = exports.createKernelObservationBridge = exports.createIntegratedSystem = exports.integrateActiveInference = exports.DEFAULT_LOOP_CONFIG = exports.resetAutonomousLoop = exports.getAutonomousLoop = exports.createAutonomousLoop = exports.AutonomousLoop = exports.registerAction = exports.executeAction = exports.getActionExecutorManager = exports.createActionExecutorManager = exports.ActionExecutorManager = exports.getObservationGatherer = exports.createObservationGatherer = exports.ObservationGatherer = exports.createActiveInferenceEngine = exports.ActiveInferenceEngine = void 0;
 // Export types
 __exportStar(require("./types.js"), exports);
 // Export core components
@@ -86,3 +86,12 @@ Object.defineProperty(exports, "integrateMemory", { enumerable: true, get: funct
 Object.defineProperty(exports, "getMemoryMetrics", { enumerable: true, get: function () { return memory_integration_js_1.getMemoryMetrics; } });
 Object.defineProperty(exports, "getWorkspaceState", { enumerable: true, get: function () { return memory_integration_js_1.getWorkspaceState; } });
 Object.defineProperty(exports, "DEFAULT_MEMORY_INTEGRATION_CONFIG", { enumerable: true, get: function () { return memory_integration_js_1.DEFAULT_MEMORY_INTEGRATION_CONFIG; } });
+// Export Economic Integration (Genesis 9.3 - Autopoietic Self-Funding)
+var economic_integration_js_1 = require("./economic-integration.js");
+Object.defineProperty(exports, "EconomicIntegration", { enumerable: true, get: function () { return economic_integration_js_1.EconomicIntegration; } });
+Object.defineProperty(exports, "getEconomicIntegration", { enumerable: true, get: function () { return economic_integration_js_1.getEconomicIntegration; } });
+Object.defineProperty(exports, "recordLLMCost", { enumerable: true, get: function () { return economic_integration_js_1.recordLLMCost; } });
+Object.defineProperty(exports, "recordRevenue", { enumerable: true, get: function () { return economic_integration_js_1.recordRevenue; } });
+Object.defineProperty(exports, "CostTracker", { enumerable: true, get: function () { return economic_integration_js_1.CostTracker; } });
+Object.defineProperty(exports, "RevenueTracker", { enumerable: true, get: function () { return economic_integration_js_1.RevenueTracker; } });
+Object.defineProperty(exports, "ServiceRegistry", { enumerable: true, get: function () { return economic_integration_js_1.ServiceRegistry; } });

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

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservationGatherer = void 0;
 exports.createObservationGatherer = createObservationGatherer;
 exports.getObservationGatherer = getObservationGatherer;
+const economic_integration_js_1 = require("./economic-integration.js");
 // ============================================================================
 // Observation Gatherer
 // ============================================================================
@@ -58,6 +59,14 @@ class ObservationGatherer {
             consistent: true,
             issues: 0,
         };
+        // v9.3: Get economic observation
+        let economicObs = 2; // Default stable
+        try {
+            economicObs = await (0, economic_integration_js_1.getEconomicIntegration)().getDiscreteObservation();
+        }
+        catch {
+            // Economic system not initialized, use default
+        }
         // Map to discrete observations
         return {
             energy: this.mapEnergy(kernelState.energy),
@@ -65,6 +74,7 @@ class ObservationGatherer {
             tool: this.mapTool(sensorResult),
             coherence: this.mapCoherence(worldModelState),
             task: this.mapTask(kernelState.taskStatus),
+            economic: economicObs, // v9.3
         };
     }
     /**

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

@@ -45,12 +45,14 @@ export type PhiObs = 0 | 1 | 2 | 3;
 export type ToolObs = 0 | 1 | 2;
 export type CoherenceObs = 0 | 1 | 2;
 export type TaskObs = 0 | 1 | 2 | 3;
+export type EconomicObs = 0 | 1 | 2 | 3;
 export interface Observation {
     energy: EnergyObs;
     phi: PhiObs;
     tool: ToolObs;
     coherence: CoherenceObs;
     task: TaskObs;
+    economic?: EconomicObs;
 }
 export declare const OBSERVATION_DIMS: {
     readonly energy: 5;
@@ -58,6 +60,7 @@ export declare const OBSERVATION_DIMS: {
     readonly tool: 3;
     readonly coherence: 3;
     readonly task: 4;
+    readonly economic: 4;
 };
 export declare const OBSERVATION_LABELS: {
     energy: readonly ["depleted", "low", "medium", "high", "full"];
@@ -65,8 +68,9 @@ export declare const OBSERVATION_LABELS: {
     tool: readonly ["failed", "partial", "success"];
     coherence: readonly ["broken", "degraded", "consistent"];
     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';
+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';
 export declare const ACTIONS: ActionType[];
 export declare const ACTION_COUNT: number;
 /**

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

@@ -30,6 +30,7 @@ exports.OBSERVATION_DIMS = {
     tool: 3,
     coherence: 3,
     task: 4,
+    economic: 4, // v9.3
 };
 exports.OBSERVATION_LABELS = {
     energy: ['depleted', 'low', 'medium', 'high', 'full'],
@@ -37,6 +38,7 @@ exports.OBSERVATION_LABELS = {
     tool: ['failed', 'partial', 'success'],
     coherence: ['broken', 'degraded', 'consistent'],
     task: ['none', 'pending', 'active', 'completed'],
+    economic: ['critical', 'low', 'stable', 'growing'], // v9.3
 };
 exports.ACTIONS = [
     'sense.mcp',
@@ -67,6 +69,11 @@ exports.ACTIONS = [
     'code.snapshot',
     'code.history',
     'code.diff',
+    // v9.3 - Economic Self-Funding
+    'econ.check',
+    'econ.optimize',
+    'econ.activate',
+    'econ.promote',
 ];
 exports.ACTION_COUNT = exports.ACTIONS.length;
 exports.DEFAULT_CONFIG = {

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

@@ -69,6 +69,11 @@ const AI_TO_WM_ACTION = {
     'code.snapshot': 'transform', // Store code state
     'code.history': 'query', // Recall evolution
     'code.diff': 'query', // Compare versions
+    // v9.3 - Economic Self-Funding
+    'econ.check': 'observe', // Check economic health
+    'econ.optimize': 'transform', // Optimize costs
+    'econ.activate': 'execute', // Activate service
+    'econ.promote': 'execute', // Promote services
 };
 // ============================================================================
 // Value-Augmented Active Inference Engine

package/dist/src/llm/index.js

@@ -35,6 +35,8 @@ exports.resetLLMBridge = resetLLMBridge;
 __exportStar(require("./router.js"), exports);
 // Re-export Phase 11: Advanced Multi-Provider Router (v7.21)
 __exportStar(require("./advanced-router.js"), exports);
+// v9.3: Economic cost tracking
+const economic_integration_js_1 = require("../active-inference/economic-integration.js");
 exports.MODEL_TIERS = {
     openai: {
         fast: 'gpt-4o-mini', // $0.15/$0.60 per 1M - 17x cheaper!
@@ -327,6 +329,10 @@ class LLMBridge {
             this.fallbackAttempts = 0;
             // Add assistant response to history
             this.conversationHistory.push({ role: 'assistant', content: response.content });
+            // v9.3: Track LLM costs for economic autopoiesis
+            if (response.usage) {
+                (0, economic_integration_js_1.recordLLMCost)(this.config.provider, response.usage.inputTokens || 0, response.usage.outputTokens || 0, this.config.model);
+            }
             // v9.1.0: Store in cache for future identical queries
             if (this.useCache && response.content) {
                 const cacheKey = getCacheKey(userMessage + '|' + (systemPrompt || ''), this.config.model);

package/package.json

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