genesis-ai-cli 7.16.0 → 7.17.0

package/dist/src/self-modification/index.d.ts

@@ -10,4 +10,5 @@
  * - Invariant System: Ensures core properties survive modification
  */
 export { DarwinGodelEngine, getDarwinGodelEngine, resetDarwinGodelEngine, Modification, ModificationPlan, VerificationResult, ApplyResult, DarwinGodelConfig, } from './darwin-godel.js';
+export { SelfImprovementEngine, getSelfImprovementEngine, resetSelfImprovementEngine, createSelfImprovementEngine, SystemMetrics, ImprovementOpportunity, ImprovementResult, SelfImprovementConfig, DEFAULT_IMPROVEMENT_CONFIG, } from './self-improvement.js';
 export { invariantRegistry, InvariantRegistry, InvariantContext, InvariantResult, InvariantDefinition, InvariantChecker, } from '../kernel/invariants.js';

package/dist/src/self-modification/index.js

@@ -11,11 +11,18 @@
  * - Invariant System: Ensures core properties survive modification
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvariantRegistry = exports.invariantRegistry = exports.resetDarwinGodelEngine = exports.getDarwinGodelEngine = exports.DarwinGodelEngine = void 0;
+exports.InvariantRegistry = exports.invariantRegistry = exports.DEFAULT_IMPROVEMENT_CONFIG = exports.createSelfImprovementEngine = exports.resetSelfImprovementEngine = exports.getSelfImprovementEngine = exports.SelfImprovementEngine = exports.resetDarwinGodelEngine = exports.getDarwinGodelEngine = exports.DarwinGodelEngine = void 0;
 var darwin_godel_js_1 = require("./darwin-godel.js");
 Object.defineProperty(exports, "DarwinGodelEngine", { enumerable: true, get: function () { return darwin_godel_js_1.DarwinGodelEngine; } });
 Object.defineProperty(exports, "getDarwinGodelEngine", { enumerable: true, get: function () { return darwin_godel_js_1.getDarwinGodelEngine; } });
 Object.defineProperty(exports, "resetDarwinGodelEngine", { enumerable: true, get: function () { return darwin_godel_js_1.resetDarwinGodelEngine; } });
+// v7.17: Self-Improvement Cycle
+var self_improvement_js_1 = require("./self-improvement.js");
+Object.defineProperty(exports, "SelfImprovementEngine", { enumerable: true, get: function () { return self_improvement_js_1.SelfImprovementEngine; } });
+Object.defineProperty(exports, "getSelfImprovementEngine", { enumerable: true, get: function () { return self_improvement_js_1.getSelfImprovementEngine; } });
+Object.defineProperty(exports, "resetSelfImprovementEngine", { enumerable: true, get: function () { return self_improvement_js_1.resetSelfImprovementEngine; } });
+Object.defineProperty(exports, "createSelfImprovementEngine", { enumerable: true, get: function () { return self_improvement_js_1.createSelfImprovementEngine; } });
+Object.defineProperty(exports, "DEFAULT_IMPROVEMENT_CONFIG", { enumerable: true, get: function () { return self_improvement_js_1.DEFAULT_IMPROVEMENT_CONFIG; } });
 // Re-export invariant types for convenience
 var invariants_js_1 = require("../kernel/invariants.js");
 Object.defineProperty(exports, "invariantRegistry", { enumerable: true, get: function () { return invariants_js_1.invariantRegistry; } });

package/dist/src/self-modification/self-improvement.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Genesis 7.17 - Self-Improvement Cycle
+ *
+ * Autonomous self-improvement via observation, reflection, and modification.
+ * Uses Darwin-Gödel Engine for safe code modifications.
+ *
+ * Cycle:
+ * 1. OBSERVE - Collect metrics from all systems
+ * 2. REFLECT - Identify bottlenecks and improvement opportunities
+ * 3. PROPOSE - Generate modification plans
+ * 4. APPLY - Use Darwin-Gödel to safely apply changes
+ * 5. VERIFY - Check if improvement was achieved
+ */
+import { EventEmitter } from 'events';
+import { ModificationPlan } from './darwin-godel.js';
+import { PhiMonitor } from '../consciousness/phi-monitor.js';
+import { CognitiveWorkspace } from '../memory/cognitive-workspace.js';
+export interface SystemMetrics {
+    phi: number;
+    consciousnessState: string;
+    phiTrend: 'rising' | 'stable' | 'falling';
+    memoryReuse: number;
+    cacheHitRate: number;
+    memorySize: number;
+    avgResponseTime: number;
+    taskSuccessRate: number;
+    errorRate: number;
+    avgSurprise: number;
+    expectedFreeEnergy: number;
+    uptime: number;
+    cyclesCompleted: number;
+    timestamp: Date;
+}
+export interface ImprovementOpportunity {
+    id: string;
+    category: 'performance' | 'consciousness' | 'memory' | 'reliability' | 'capability';
+    metric: keyof SystemMetrics;
+    currentValue: number;
+    targetValue: number;
+    priority: number;
+    description: string;
+    suggestedFix?: ModificationPlan;
+}
+export interface ImprovementResult {
+    opportunityId: string;
+    applied: boolean;
+    success: boolean;
+    beforeMetrics: SystemMetrics;
+    afterMetrics?: SystemMetrics;
+    commitHash?: string;
+    rollbackHash?: string;
+    error?: string;
+    duration: number;
+}
+export interface SelfImprovementConfig {
+    /** Enable automatic improvements */
+    autoImprove: boolean;
+    /** Minimum φ required to self-improve */
+    minPhiForImprovement: number;
+    /** Maximum improvements per cycle */
+    maxImprovementsPerCycle: number;
+    /** Cooldown between improvement attempts (ms) */
+    improvementCooldownMs: number;
+    /** Metric thresholds that trigger improvement */
+    thresholds: {
+        minPhi: number;
+        minMemoryReuse: number;
+        maxErrorRate: number;
+        maxSurprise: number;
+        minTaskSuccessRate: number;
+    };
+    /** Metric targets for improvement */
+    targets: {
+        phi: number;
+        memoryReuse: number;
+        errorRate: number;
+        surprise: number;
+        taskSuccessRate: number;
+    };
+}
+export declare const DEFAULT_IMPROVEMENT_CONFIG: SelfImprovementConfig;
+export type SelfImprovementEventType = 'cycle:started' | 'cycle:completed' | 'metrics:collected' | 'opportunity:found' | 'improvement:started' | 'improvement:success' | 'improvement:failed' | 'improvement:skipped';
+export declare class SelfImprovementEngine extends EventEmitter {
+    private config;
+    private darwinGodel;
+    private phiMonitor?;
+    private cognitiveWorkspace?;
+    private running;
+    private lastImprovement;
+    private improvementHistory;
+    private currentMetrics;
+    private metricsCollectors;
+    constructor(config?: Partial<SelfImprovementConfig>);
+    /**
+     * Set the φ monitor for consciousness metrics
+     */
+    setPhiMonitor(monitor: PhiMonitor): void;
+    /**
+     * Set the cognitive workspace for memory metrics
+     */
+    setCognitiveWorkspace(workspace: CognitiveWorkspace): void;
+    /**
+     * Register a custom metrics collector
+     */
+    registerMetricsCollector(name: string, collector: () => Partial<SystemMetrics>): void;
+    /**
+     * Run a single improvement cycle
+     */
+    runCycle(): Promise<{
+        metrics: SystemMetrics;
+        opportunities: ImprovementOpportunity[];
+        results: ImprovementResult[];
+    }>;
+    /**
+     * Collect metrics from all systems
+     */
+    collectMetrics(): SystemMetrics;
+    /**
+     * Find improvement opportunities based on current metrics
+     */
+    findOpportunities(metrics: SystemMetrics): ImprovementOpportunity[];
+    /**
+     * Check if we can attempt an improvement
+     */
+    private canAttemptImprovement;
+    /**
+     * Apply a single improvement
+     */
+    private applyImprovement;
+    /**
+     * Verify that an improvement actually improved the metric
+     */
+    private verifyImprovement;
+    /**
+     * Get improvement statistics
+     */
+    stats(): {
+        totalAttempts: number;
+        successfulImprovements: number;
+        failedImprovements: number;
+        successRate: number;
+        lastImprovement: Date | null;
+        currentMetrics: SystemMetrics | null;
+    };
+    /**
+     * Get improvement history
+     */
+    getHistory(): ImprovementResult[];
+    /**
+     * Get current configuration
+     */
+    getConfig(): SelfImprovementConfig;
+    /**
+     * Update configuration
+     */
+    updateConfig(partial: Partial<SelfImprovementConfig>): void;
+    /**
+     * Enable/disable auto-improvement
+     */
+    setAutoImprove(enabled: boolean): void;
+}
+export declare function getSelfImprovementEngine(config?: Partial<SelfImprovementConfig>): SelfImprovementEngine;
+export declare function resetSelfImprovementEngine(): void;
+export declare function createSelfImprovementEngine(config?: Partial<SelfImprovementConfig>): SelfImprovementEngine;

package/dist/src/self-modification/self-improvement.js

@@ -0,0 +1,550 @@
+"use strict";
+/**
+ * Genesis 7.17 - Self-Improvement Cycle
+ *
+ * Autonomous self-improvement via observation, reflection, and modification.
+ * Uses Darwin-Gödel Engine for safe code modifications.
+ *
+ * Cycle:
+ * 1. OBSERVE - Collect metrics from all systems
+ * 2. REFLECT - Identify bottlenecks and improvement opportunities
+ * 3. PROPOSE - Generate modification plans
+ * 4. APPLY - Use Darwin-Gödel to safely apply changes
+ * 5. VERIFY - Check if improvement was achieved
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelfImprovementEngine = exports.DEFAULT_IMPROVEMENT_CONFIG = void 0;
+exports.getSelfImprovementEngine = getSelfImprovementEngine;
+exports.resetSelfImprovementEngine = resetSelfImprovementEngine;
+exports.createSelfImprovementEngine = createSelfImprovementEngine;
+const events_1 = require("events");
+const darwin_godel_js_1 = require("./darwin-godel.js");
+const invariants_js_1 = require("../kernel/invariants.js");
+exports.DEFAULT_IMPROVEMENT_CONFIG = {
+    autoImprove: false, // Disabled by default for safety
+    minPhiForImprovement: 0.3,
+    maxImprovementsPerCycle: 3,
+    improvementCooldownMs: 60000, // 1 minute
+    thresholds: {
+        minPhi: 0.2,
+        minMemoryReuse: 0.4,
+        maxErrorRate: 0.1,
+        maxSurprise: 5.0,
+        minTaskSuccessRate: 0.8,
+    },
+    targets: {
+        phi: 0.5,
+        memoryReuse: 0.6, // 54-60% from research
+        errorRate: 0.01,
+        surprise: 2.0,
+        taskSuccessRate: 0.95,
+    },
+};
+// ============================================================================
+// Improvement Templates
+// ============================================================================
+/**
+ * Pre-defined improvement patterns that can be applied
+ */
+const IMPROVEMENT_TEMPLATES = {
+    /**
+     * Improve φ by adjusting calculation parameters
+     */
+    'improve-phi': (metrics) => {
+        if (metrics.phi >= 0.3)
+            return null;
+        return {
+            id: `improve-phi-${Date.now()}`,
+            name: 'Improve φ calculation efficiency',
+            description: 'Switch to faster approximation while maintaining accuracy',
+            modifications: [{
+                    id: 'phi-approx',
+                    description: 'Use faster φ approximation',
+                    targetFile: 'consciousness/phi-calculator.ts',
+                    type: 'replace',
+                    search: "approximationLevel: 'exact'",
+                    content: "approximationLevel: 'fast'",
+                    reason: 'Current φ is below threshold, faster calculation enables more frequent updates',
+                    expectedImprovement: 'φ update frequency +50%',
+                }],
+            createdAt: new Date(),
+        };
+    },
+    /**
+     * Improve memory reuse by adjusting workspace parameters
+     */
+    'improve-memory-reuse': (metrics) => {
+        if (metrics.memoryReuse >= 0.5)
+            return null;
+        return {
+            id: `improve-memory-${Date.now()}`,
+            name: 'Optimize memory workspace for better reuse',
+            description: 'Adjust cognitive workspace capacity to improve reuse rate',
+            modifications: [{
+                    id: 'memory-capacity',
+                    description: 'Increase immediate memory capacity',
+                    targetFile: 'memory/cognitive-workspace.ts',
+                    type: 'replace',
+                    search: 'immediateCapacity: 8192',
+                    content: 'immediateCapacity: 16384',
+                    reason: `Memory reuse at ${(metrics.memoryReuse * 100).toFixed(1)}%, target is 54-60%`,
+                    expectedImprovement: 'Memory reuse +15%',
+                }],
+            createdAt: new Date(),
+        };
+    },
+    /**
+     * Reduce error rate by adding retry logic
+     */
+    'reduce-error-rate': (metrics) => {
+        if (metrics.errorRate <= 0.05)
+            return null;
+        return {
+            id: `reduce-errors-${Date.now()}`,
+            name: 'Add retry logic for resilience',
+            description: 'Implement exponential backoff for failed operations',
+            modifications: [{
+                    id: 'add-retry',
+                    description: 'Add retry wrapper to MCP calls',
+                    targetFile: 'mcp/resilient.ts',
+                    type: 'replace',
+                    search: 'maxRetries: 3',
+                    content: 'maxRetries: 5',
+                    reason: `Error rate at ${(metrics.errorRate * 100).toFixed(1)}%, increasing retries`,
+                    expectedImprovement: 'Error rate -40%',
+                }],
+            createdAt: new Date(),
+        };
+    },
+    /**
+     * Reduce surprise by improving prediction
+     */
+    'reduce-surprise': (metrics) => {
+        if (metrics.avgSurprise <= 3.0)
+            return null;
+        return {
+            id: `reduce-surprise-${Date.now()}`,
+            name: 'Improve world model predictions',
+            description: 'Increase prediction horizon for better anticipation',
+            modifications: [{
+                    id: 'prediction-horizon',
+                    description: 'Increase prediction steps',
+                    targetFile: 'world-model/predictor.ts',
+                    type: 'replace',
+                    search: 'predictionSteps: 5',
+                    content: 'predictionSteps: 10',
+                    reason: `Average surprise at ${metrics.avgSurprise.toFixed(2)}, improving predictions`,
+                    expectedImprovement: 'Surprise -25%',
+                }],
+            createdAt: new Date(),
+        };
+    },
+};
+class SelfImprovementEngine extends events_1.EventEmitter {
+    config;
+    darwinGodel;
+    phiMonitor;
+    cognitiveWorkspace;
+    // State
+    running = false;
+    lastImprovement = new Date(0);
+    improvementHistory = [];
+    currentMetrics = null;
+    // Metrics collectors (injected)
+    metricsCollectors = new Map();
+    constructor(config = {}) {
+        super();
+        this.config = { ...exports.DEFAULT_IMPROVEMENT_CONFIG, ...config };
+        this.darwinGodel = (0, darwin_godel_js_1.getDarwinGodelEngine)();
+    }
+    // ============================================================================
+    // Lifecycle
+    // ============================================================================
+    /**
+     * Set the φ monitor for consciousness metrics
+     */
+    setPhiMonitor(monitor) {
+        this.phiMonitor = monitor;
+    }
+    /**
+     * Set the cognitive workspace for memory metrics
+     */
+    setCognitiveWorkspace(workspace) {
+        this.cognitiveWorkspace = workspace;
+    }
+    /**
+     * Register a custom metrics collector
+     */
+    registerMetricsCollector(name, collector) {
+        this.metricsCollectors.set(name, collector);
+    }
+    // ============================================================================
+    // Main Cycle
+    // ============================================================================
+    /**
+     * Run a single improvement cycle
+     */
+    async runCycle() {
+        const startTime = Date.now();
+        this.emit('cycle:started', { timestamp: new Date() });
+        // 1. OBSERVE - Collect metrics
+        const metrics = this.collectMetrics();
+        this.currentMetrics = metrics;
+        this.emit('metrics:collected', { metrics });
+        // 2. REFLECT - Find improvement opportunities
+        const opportunities = this.findOpportunities(metrics);
+        for (const opp of opportunities) {
+            this.emit('opportunity:found', { opportunity: opp });
+        }
+        // 3. CHECK - Can we improve?
+        const canImprove = this.canAttemptImprovement(metrics);
+        const results = [];
+        if (!canImprove) {
+            this.emit('improvement:skipped', { reason: 'conditions not met', metrics });
+        }
+        else if (!this.config.autoImprove) {
+            this.emit('improvement:skipped', { reason: 'auto-improve disabled' });
+        }
+        else {
+            // 4. APPLY - Try improvements
+            const sorted = opportunities.sort((a, b) => b.priority - a.priority);
+            const toApply = sorted.slice(0, this.config.maxImprovementsPerCycle);
+            for (const opportunity of toApply) {
+                if (opportunity.suggestedFix) {
+                    const result = await this.applyImprovement(opportunity, metrics);
+                    results.push(result);
+                }
+            }
+        }
+        this.emit('cycle:completed', {
+            duration: Date.now() - startTime,
+            metrics,
+            opportunitiesFound: opportunities.length,
+            improvementsApplied: results.filter(r => r.success).length,
+        });
+        return { metrics, opportunities, results };
+    }
+    // ============================================================================
+    // Observe - Metrics Collection
+    // ============================================================================
+    /**
+     * Collect metrics from all systems
+     */
+    collectMetrics() {
+        const now = new Date();
+        // Base metrics
+        const metrics = {
+            phi: 0.3,
+            consciousnessState: 'normal',
+            phiTrend: 'stable',
+            memoryReuse: 0.5,
+            cacheHitRate: 0.7,
+            memorySize: 0,
+            avgResponseTime: 100,
+            taskSuccessRate: 0.9,
+            errorRate: 0.05,
+            avgSurprise: 3.0,
+            expectedFreeEnergy: 10.0,
+            uptime: process.uptime() * 1000,
+            cyclesCompleted: 0,
+            timestamp: now,
+        };
+        // Get φ from monitor
+        if (this.phiMonitor) {
+            const level = this.phiMonitor.getCurrentLevel();
+            metrics.phi = level.rawPhi;
+            metrics.consciousnessState = this.phiMonitor.getState();
+            metrics.phiTrend = this.phiMonitor.getTrend();
+        }
+        // Get memory metrics from workspace
+        if (this.cognitiveWorkspace) {
+            const wsMetrics = this.cognitiveWorkspace.getMetrics();
+            const wsStats = this.cognitiveWorkspace.getStats();
+            metrics.memoryReuse = wsMetrics.reuseRate;
+            metrics.memorySize = wsStats.estimatedTokens;
+        }
+        // Collect from registered collectors
+        for (const collector of this.metricsCollectors.values()) {
+            try {
+                const partial = collector();
+                Object.assign(metrics, partial);
+            }
+            catch (e) {
+                // Ignore collector errors
+            }
+        }
+        return metrics;
+    }
+    // ============================================================================
+    // Reflect - Find Opportunities
+    // ============================================================================
+    /**
+     * Find improvement opportunities based on current metrics
+     */
+    findOpportunities(metrics) {
+        const opportunities = [];
+        const { thresholds, targets } = this.config;
+        // Check φ
+        if (metrics.phi < thresholds.minPhi) {
+            const plan = IMPROVEMENT_TEMPLATES['improve-phi'](metrics);
+            if (plan) {
+                opportunities.push({
+                    id: 'opp-phi',
+                    category: 'consciousness',
+                    metric: 'phi',
+                    currentValue: metrics.phi,
+                    targetValue: targets.phi,
+                    priority: 0.9, // High priority - consciousness is core
+                    description: `φ is ${metrics.phi.toFixed(3)}, below threshold ${thresholds.minPhi}`,
+                    suggestedFix: plan,
+                });
+            }
+        }
+        // Check memory reuse
+        if (metrics.memoryReuse < thresholds.minMemoryReuse) {
+            const plan = IMPROVEMENT_TEMPLATES['improve-memory-reuse'](metrics);
+            if (plan) {
+                opportunities.push({
+                    id: 'opp-memory',
+                    category: 'memory',
+                    metric: 'memoryReuse',
+                    currentValue: metrics.memoryReuse,
+                    targetValue: targets.memoryReuse,
+                    priority: 0.7,
+                    description: `Memory reuse at ${(metrics.memoryReuse * 100).toFixed(1)}%, target is ${(targets.memoryReuse * 100).toFixed(0)}%`,
+                    suggestedFix: plan,
+                });
+            }
+        }
+        // Check error rate
+        if (metrics.errorRate > thresholds.maxErrorRate) {
+            const plan = IMPROVEMENT_TEMPLATES['reduce-error-rate'](metrics);
+            if (plan) {
+                opportunities.push({
+                    id: 'opp-errors',
+                    category: 'reliability',
+                    metric: 'errorRate',
+                    currentValue: metrics.errorRate,
+                    targetValue: targets.errorRate,
+                    priority: 0.8,
+                    description: `Error rate at ${(metrics.errorRate * 100).toFixed(1)}%, above threshold ${(thresholds.maxErrorRate * 100).toFixed(0)}%`,
+                    suggestedFix: plan,
+                });
+            }
+        }
+        // Check surprise
+        if (metrics.avgSurprise > thresholds.maxSurprise) {
+            const plan = IMPROVEMENT_TEMPLATES['reduce-surprise'](metrics);
+            if (plan) {
+                opportunities.push({
+                    id: 'opp-surprise',
+                    category: 'performance',
+                    metric: 'avgSurprise',
+                    currentValue: metrics.avgSurprise,
+                    targetValue: targets.surprise,
+                    priority: 0.6,
+                    description: `Average surprise at ${metrics.avgSurprise.toFixed(2)}, above threshold ${thresholds.maxSurprise}`,
+                    suggestedFix: plan,
+                });
+            }
+        }
+        // Check task success rate
+        if (metrics.taskSuccessRate < thresholds.minTaskSuccessRate) {
+            opportunities.push({
+                id: 'opp-success',
+                category: 'performance',
+                metric: 'taskSuccessRate',
+                currentValue: metrics.taskSuccessRate,
+                targetValue: targets.taskSuccessRate,
+                priority: 0.75,
+                description: `Task success at ${(metrics.taskSuccessRate * 100).toFixed(1)}%, below threshold ${(thresholds.minTaskSuccessRate * 100).toFixed(0)}%`,
+                // No automatic fix - needs analysis
+            });
+        }
+        return opportunities;
+    }
+    // ============================================================================
+    // Apply - Implement Improvements
+    // ============================================================================
+    /**
+     * Check if we can attempt an improvement
+     */
+    canAttemptImprovement(metrics) {
+        // Check φ threshold
+        if (metrics.phi < this.config.minPhiForImprovement) {
+            return false;
+        }
+        // Check cooldown
+        const timeSinceLastImprovement = Date.now() - this.lastImprovement.getTime();
+        if (timeSinceLastImprovement < this.config.improvementCooldownMs) {
+            return false;
+        }
+        // Check invariants
+        const invariantContext = {
+            energy: 1.0, // Assume full energy for self-improvement
+            dormancyThreshold: 0.1,
+            isDormant: false,
+            responsiveAgentCount: 1,
+            totalAgentCount: 1,
+        };
+        const invariantResults = invariants_js_1.invariantRegistry.checkAll(invariantContext);
+        const allPassed = invariantResults.every(r => r.passed);
+        return allPassed;
+    }
+    /**
+     * Apply a single improvement
+     */
+    async applyImprovement(opportunity, beforeMetrics) {
+        const startTime = Date.now();
+        if (!opportunity.suggestedFix) {
+            return {
+                opportunityId: opportunity.id,
+                applied: false,
+                success: false,
+                beforeMetrics,
+                error: 'No suggested fix available',
+                duration: Date.now() - startTime,
+            };
+        }
+        this.emit('improvement:started', { opportunity });
+        try {
+            // Use Darwin-Gödel to apply
+            const result = await this.darwinGodel.apply(opportunity.suggestedFix);
+            if (!result.success) {
+                this.emit('improvement:failed', {
+                    opportunity,
+                    errors: result.verificaton.errors,
+                });
+                return {
+                    opportunityId: opportunity.id,
+                    applied: false,
+                    success: false,
+                    beforeMetrics,
+                    error: result.verificaton.errors.join('; '),
+                    rollbackHash: result.rollbackHash,
+                    duration: Date.now() - startTime,
+                };
+            }
+            // Collect after metrics
+            const afterMetrics = this.collectMetrics();
+            // Verify improvement
+            const improved = this.verifyImprovement(opportunity, beforeMetrics, afterMetrics);
+            this.lastImprovement = new Date();
+            const improvementResult = {
+                opportunityId: opportunity.id,
+                applied: true,
+                success: improved,
+                beforeMetrics,
+                afterMetrics,
+                commitHash: result.commitHash,
+                rollbackHash: result.rollbackHash,
+                duration: Date.now() - startTime,
+            };
+            this.improvementHistory.push(improvementResult);
+            if (improved) {
+                this.emit('improvement:success', { opportunity, result: improvementResult });
+            }
+            else {
+                // Rollback if no improvement
+                if (result.rollbackHash) {
+                    this.darwinGodel.rollback(result.rollbackHash);
+                }
+                this.emit('improvement:failed', {
+                    opportunity,
+                    reason: 'no measurable improvement',
+                    result: improvementResult,
+                });
+            }
+            return improvementResult;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.emit('improvement:failed', {
+                opportunity,
+                error: errorMsg,
+            });
+            return {
+                opportunityId: opportunity.id,
+                applied: false,
+                success: false,
+                beforeMetrics,
+                error: errorMsg,
+                duration: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * Verify that an improvement actually improved the metric
+     */
+    verifyImprovement(opportunity, before, after) {
+        const metric = opportunity.metric;
+        const beforeValue = before[metric];
+        const afterValue = after[metric];
+        const target = opportunity.targetValue;
+        // For metrics where lower is better
+        if (['errorRate', 'avgSurprise', 'expectedFreeEnergy'].includes(metric)) {
+            return afterValue < beforeValue;
+        }
+        // For metrics where higher is better
+        return afterValue > beforeValue;
+    }
+    // ============================================================================
+    // Stats
+    // ============================================================================
+    /**
+     * Get improvement statistics
+     */
+    stats() {
+        const total = this.improvementHistory.length;
+        const successful = this.improvementHistory.filter(r => r.success).length;
+        return {
+            totalAttempts: total,
+            successfulImprovements: successful,
+            failedImprovements: total - successful,
+            successRate: total > 0 ? successful / total : 0,
+            lastImprovement: this.lastImprovement.getTime() > 0 ? this.lastImprovement : null,
+            currentMetrics: this.currentMetrics,
+        };
+    }
+    /**
+     * Get improvement history
+     */
+    getHistory() {
+        return [...this.improvementHistory];
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(partial) {
+        this.config = { ...this.config, ...partial };
+    }
+    /**
+     * Enable/disable auto-improvement
+     */
+    setAutoImprove(enabled) {
+        this.config.autoImprove = enabled;
+    }
+}
+exports.SelfImprovementEngine = SelfImprovementEngine;
+// ============================================================================
+// Factory
+// ============================================================================
+let improvementInstance = null;
+function getSelfImprovementEngine(config) {
+    if (!improvementInstance) {
+        improvementInstance = new SelfImprovementEngine(config);
+    }
+    return improvementInstance;
+}
+function resetSelfImprovementEngine() {
+    improvementInstance = null;
+}
+function createSelfImprovementEngine(config) {
+    return new SelfImprovementEngine(config);
+}

package/dist/src/unified-system.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Genesis 7.17 - Unified Autonomous System
+ *
+ * Connects all Genesis modules into a single coherent system:
+ *
+ * ┌─────────────────────────────────────────────────────────────────────────┐
+ * │                          UNIFIED SYSTEM                                 │
+ * ├─────────────────────────────────────────────────────────────────────────┤
+ * │                                                                         │
+ * │  PERCEPTION (MCP)  →  COGNITION  →  ACTION (MCP)                       │
+ * │        ↓                  ↓              ↑                              │
+ * │  ┌─────────────────────────────────────────────────────────────────┐   │
+ * │  │              CONSCIOUSNESS (φ Monitor + Global Workspace)       │   │
+ * │  └─────────────────────────────────────────────────────────────────┘   │
+ * │        ↓                  ↓              ↑                              │
+ * │  ┌─────────────────────────────────────────────────────────────────┐   │
+ * │  │              MEMORY (Episodic + Semantic + Working)             │   │
+ * │  └─────────────────────────────────────────────────────────────────┘   │
+ * │        ↓                  ↓              ↑                              │
+ * │  ┌─────────────────────────────────────────────────────────────────┐   │
+ * │  │              SELF-IMPROVEMENT (Darwin-Gödel)                    │   │
+ * │  └─────────────────────────────────────────────────────────────────┘   │
+ * │                                                                         │
+ * └─────────────────────────────────────────────────────────────────────────┘
+ *
+ * This is Genesis's core loop - a conscious, self-improving autonomous agent.
+ */
+import { EventEmitter } from 'events';
+import { ConsciousnessSystem, ConsciousnessSnapshot, ConsciousnessConfig } from './consciousness/index.js';
+import { ActionResult } from './consciousness/conscious-agent.js';
+import { PerceptionStream, Perception } from './consciousness/perception-stream.js';
+import { CognitiveWorkspace } from './memory/cognitive-workspace.js';
+import { SelfImprovementEngine, SystemMetrics, ImprovementOpportunity, ImprovementResult } from './self-modification/index.js';
+export interface UnifiedSystemConfig {
+    /** System name */
+    name: string;
+    /** Enable consciousness monitoring */
+    consciousnessEnabled: boolean;
+    /** Enable self-improvement */
+    selfImprovementEnabled: boolean;
+    /** Enable MCP perception */
+    perceptionEnabled: boolean;
+    /** Enable active inference loop */
+    activeInferenceEnabled: boolean;
+    /** Initial goals */
+    goals: string[];
+    /** Maximum cycles for autonomous mode */
+    maxCycles: number;
+    /** Cycle interval in ms */
+    cycleIntervalMs: number;
+    /** Minimum φ to continue operation */
+    minPhi: number;
+    /** Consciousness config */
+    consciousness?: Partial<ConsciousnessConfig>;
+}
+export declare const DEFAULT_UNIFIED_CONFIG: UnifiedSystemConfig;
+export interface UnifiedSystemState {
+    status: 'idle' | 'running' | 'paused' | 'stopped' | 'error';
+    cyclesCompleted: number;
+    currentPhi: number;
+    consciousnessLevel: string;
+    memoryReuseRate: number;
+    lastAction: ActionResult | null;
+    lastPerception: Perception | null;
+    improvementsApplied: number;
+    uptime: number;
+    errors: string[];
+}
+export type UnifiedEventType = 'system:started' | 'system:stopped' | 'system:paused' | 'system:resumed' | 'system:error' | 'cycle:started' | 'cycle:completed' | 'perception:received' | 'action:executed' | 'improvement:applied' | 'consciousness:changed' | 'invariant:violated';
+export declare class UnifiedSystem extends EventEmitter {
+    private config;
+    private consciousness;
+    private consciousAgent?;
+    private perceptionStream?;
+    private cognitiveWorkspace;
+    private mcpManager;
+    private selfImprovement;
+    private state;
+    private running;
+    private paused;
+    private startTime;
+    private cycleTimer?;
+    constructor(config?: Partial<UnifiedSystemConfig>);
+    /**
+     * Start the unified system
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the unified system
+     */
+    stop(): Promise<void>;
+    /**
+     * Pause the system
+     */
+    pause(): void;
+    /**
+     * Resume the system
+     */
+    resume(): void;
+    /**
+     * Run a single unified cycle
+     */
+    private runCycle;
+    private setupEventHandlers;
+    /**
+     * Get current system state
+     */
+    getState(): UnifiedSystemState;
+    /**
+     * Get consciousness snapshot
+     */
+    getConsciousnessSnapshot(): ConsciousnessSnapshot | null;
+    /**
+     * Get improvement opportunities
+     */
+    getImprovementOpportunities(): Promise<ImprovementOpportunity[]>;
+    /**
+     * Get system metrics
+     */
+    getMetrics(): SystemMetrics;
+    /**
+     * Get comprehensive stats
+     */
+    stats(): {
+        system: UnifiedSystemState;
+        consciousness: ReturnType<ConsciousnessSystem['stats']>;
+        memory: ReturnType<CognitiveWorkspace['getMetrics']>;
+        improvement: ReturnType<SelfImprovementEngine['stats']>;
+        perceptions: ReturnType<PerceptionStream['stats']> | null;
+    };
+    /**
+     * Manually trigger self-improvement cycle
+     */
+    triggerSelfImprovement(): Promise<{
+        metrics: SystemMetrics;
+        opportunities: ImprovementOpportunity[];
+        results: ImprovementResult[];
+    }>;
+    /**
+     * Set goals for the system
+     */
+    setGoals(goals: string[]): void;
+    /**
+     * Enable/disable self-improvement
+     */
+    setSelfImprovementEnabled(enabled: boolean): void;
+    /**
+     * Get configuration
+     */
+    getConfig(): UnifiedSystemConfig;
+}
+export declare function getUnifiedSystem(config?: Partial<UnifiedSystemConfig>): UnifiedSystem;
+export declare function resetUnifiedSystem(): void;
+export declare function createUnifiedSystem(config?: Partial<UnifiedSystemConfig>): UnifiedSystem;

package/dist/src/unified-system.js

@@ -0,0 +1,355 @@
+"use strict";
+/**
+ * Genesis 7.17 - Unified Autonomous System
+ *
+ * Connects all Genesis modules into a single coherent system:
+ *
+ * ┌─────────────────────────────────────────────────────────────────────────┐
+ * │                          UNIFIED SYSTEM                                 │
+ * ├─────────────────────────────────────────────────────────────────────────┤
+ * │                                                                         │
+ * │  PERCEPTION (MCP)  →  COGNITION  →  ACTION (MCP)                       │
+ * │        ↓                  ↓              ↑                              │
+ * │  ┌─────────────────────────────────────────────────────────────────┐   │
+ * │  │              CONSCIOUSNESS (φ Monitor + Global Workspace)       │   │
+ * │  └─────────────────────────────────────────────────────────────────┘   │
+ * │        ↓                  ↓              ↑                              │
+ * │  ┌─────────────────────────────────────────────────────────────────┐   │
+ * │  │              MEMORY (Episodic + Semantic + Working)             │   │
+ * │  └─────────────────────────────────────────────────────────────────┘   │
+ * │        ↓                  ↓              ↑                              │
+ * │  ┌─────────────────────────────────────────────────────────────────┐   │
+ * │  │              SELF-IMPROVEMENT (Darwin-Gödel)                    │   │
+ * │  └─────────────────────────────────────────────────────────────────┘   │
+ * │                                                                         │
+ * └─────────────────────────────────────────────────────────────────────────┘
+ *
+ * This is Genesis's core loop - a conscious, self-improving autonomous agent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiedSystem = exports.DEFAULT_UNIFIED_CONFIG = void 0;
+exports.getUnifiedSystem = getUnifiedSystem;
+exports.resetUnifiedSystem = resetUnifiedSystem;
+exports.createUnifiedSystem = createUnifiedSystem;
+const events_1 = require("events");
+// Consciousness
+const index_js_1 = require("./consciousness/index.js");
+const conscious_agent_js_1 = require("./consciousness/conscious-agent.js");
+const perception_stream_js_1 = require("./consciousness/perception-stream.js");
+// Memory
+const cognitive_workspace_js_1 = require("./memory/cognitive-workspace.js");
+// MCP
+const client_manager_js_1 = require("./mcp/client-manager.js");
+// Self-Improvement
+const index_js_2 = require("./self-modification/index.js");
+exports.DEFAULT_UNIFIED_CONFIG = {
+    name: 'Genesis',
+    consciousnessEnabled: true,
+    selfImprovementEnabled: false, // Disabled by default for safety
+    perceptionEnabled: true,
+    activeInferenceEnabled: true,
+    goals: ['understand', 'assist', 'improve'],
+    maxCycles: 1000,
+    cycleIntervalMs: 100,
+    minPhi: 0.2,
+};
+// ============================================================================
+// Unified System
+// ============================================================================
+class UnifiedSystem extends events_1.EventEmitter {
+    config;
+    // Core components
+    consciousness;
+    consciousAgent;
+    perceptionStream;
+    cognitiveWorkspace;
+    mcpManager;
+    selfImprovement;
+    // State
+    state;
+    running = false;
+    paused = false;
+    startTime = 0;
+    cycleTimer;
+    constructor(config = {}) {
+        super();
+        this.config = { ...exports.DEFAULT_UNIFIED_CONFIG, ...config };
+        // Initialize state
+        this.state = {
+            status: 'idle',
+            cyclesCompleted: 0,
+            currentPhi: 0.3,
+            consciousnessLevel: 'normal',
+            memoryReuseRate: 0.5,
+            lastAction: null,
+            lastPerception: null,
+            improvementsApplied: 0,
+            uptime: 0,
+            errors: [],
+        };
+        // Initialize components
+        this.consciousness = (0, index_js_1.createConsciousnessSystem)(this.config.consciousness);
+        this.cognitiveWorkspace = (0, cognitive_workspace_js_1.getCognitiveWorkspace)();
+        this.mcpManager = (0, client_manager_js_1.getMCPManager)();
+        this.selfImprovement = (0, index_js_2.getSelfImprovementEngine)();
+        // Wire up self-improvement to consciousness
+        this.selfImprovement.setPhiMonitor(this.consciousness.monitor);
+        this.selfImprovement.setCognitiveWorkspace(this.cognitiveWorkspace);
+        // Wire up event handlers
+        this.setupEventHandlers();
+    }
+    // ============================================================================
+    // Lifecycle
+    // ============================================================================
+    /**
+     * Start the unified system
+     */
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.paused = false;
+        this.startTime = Date.now();
+        this.state.status = 'running';
+        // Start consciousness monitoring
+        if (this.config.consciousnessEnabled) {
+            this.consciousness.start();
+        }
+        // Initialize perception if enabled
+        if (this.config.perceptionEnabled) {
+            this.perceptionStream = (0, perception_stream_js_1.createPerceptionStream)(this.mcpManager);
+            this.perceptionStream.connectWorkspace(this.consciousness.workspace);
+            this.perceptionStream.start();
+        }
+        // Initialize conscious agent if active inference enabled
+        if (this.config.activeInferenceEnabled) {
+            this.consciousAgent = (0, conscious_agent_js_1.createConsciousAgent)(this.mcpManager, {
+                minPhiForAction: this.config.minPhi,
+                maxActionsPerCycle: 5,
+            });
+        }
+        // Start the main cycle
+        this.cycleTimer = setInterval(() => {
+            if (!this.paused) {
+                this.runCycle().catch(err => {
+                    this.state.errors.push(err.message);
+                    this.emit('system:error', { error: err });
+                });
+            }
+        }, this.config.cycleIntervalMs);
+        this.emit('system:started', { config: this.config });
+    }
+    /**
+     * Stop the unified system
+     */
+    async stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        this.state.status = 'stopped';
+        // Stop cycle timer
+        if (this.cycleTimer) {
+            clearInterval(this.cycleTimer);
+            this.cycleTimer = undefined;
+        }
+        // Stop components
+        this.consciousness.stop();
+        if (this.perceptionStream) {
+            this.perceptionStream.stop();
+        }
+        this.emit('system:stopped', { state: this.getState() });
+    }
+    /**
+     * Pause the system
+     */
+    pause() {
+        this.paused = true;
+        this.state.status = 'paused';
+        this.emit('system:paused');
+    }
+    /**
+     * Resume the system
+     */
+    resume() {
+        this.paused = false;
+        this.state.status = 'running';
+        this.emit('system:resumed');
+    }
+    // ============================================================================
+    // Main Cycle
+    // ============================================================================
+    /**
+     * Run a single unified cycle
+     */
+    async runCycle() {
+        const cycleStart = Date.now();
+        this.emit('cycle:started', { cycle: this.state.cyclesCompleted + 1 });
+        try {
+            // 1. Update consciousness snapshot
+            const snapshot = this.consciousness.takeSnapshot();
+            this.state.currentPhi = snapshot.level.rawPhi;
+            this.state.consciousnessLevel = snapshot.state;
+            // Check φ threshold
+            if (this.state.currentPhi < this.config.minPhi) {
+                this.emit('consciousness:changed', {
+                    warning: `φ dropped below threshold: ${this.state.currentPhi.toFixed(3)} < ${this.config.minPhi}`,
+                });
+            }
+            // 2. Process perceptions (if agent available)
+            if (this.consciousAgent) {
+                await this.consciousAgent.runCycle();
+                this.emit('action:executed', { cycle: this.state.cyclesCompleted });
+            }
+            // 3. Update memory metrics
+            const wsMetrics = this.cognitiveWorkspace.getMetrics();
+            this.state.memoryReuseRate = wsMetrics.reuseRate;
+            // 4. Self-improvement (if enabled)
+            if (this.config.selfImprovementEnabled) {
+                const improvementResult = await this.selfImprovement.runCycle();
+                for (const result of improvementResult.results) {
+                    if (result.success) {
+                        this.state.improvementsApplied++;
+                        this.emit('improvement:applied', { result });
+                    }
+                }
+            }
+            // 5. Check invariants
+            const invariant = this.consciousness.checkInvariant();
+            if (!invariant.satisfied) {
+                this.emit('invariant:violated', { invariant });
+            }
+            // Update state
+            this.state.cyclesCompleted++;
+            this.state.uptime = Date.now() - this.startTime;
+            this.emit('cycle:completed', {
+                cycle: this.state.cyclesCompleted,
+                duration: Date.now() - cycleStart,
+                phi: this.state.currentPhi,
+            });
+            // Check max cycles
+            if (this.state.cyclesCompleted >= this.config.maxCycles) {
+                await this.stop();
+            }
+        }
+        catch (error) {
+            this.state.errors.push(error instanceof Error ? error.message : String(error));
+            this.state.status = 'error';
+            throw error;
+        }
+    }
+    // ============================================================================
+    // Event Handlers
+    // ============================================================================
+    setupEventHandlers() {
+        // Forward consciousness events
+        this.consciousness.on((event) => {
+            if (event.type === 'attention_shifted') {
+                this.emit('consciousness:changed', event);
+            }
+        });
+        // Forward perception events (if available)
+        if (this.perceptionStream) {
+            this.perceptionStream.on('perception:received', ({ perception }) => {
+                this.state.lastPerception = perception;
+                this.emit('perception:received', { perception });
+            });
+        }
+        // Forward self-improvement events
+        this.selfImprovement.on('improvement:success', ({ opportunity, result }) => {
+            this.emit('improvement:applied', { opportunity, result });
+        });
+    }
+    // ============================================================================
+    // State & Stats
+    // ============================================================================
+    /**
+     * Get current system state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Get consciousness snapshot
+     */
+    getConsciousnessSnapshot() {
+        return this.consciousness.getSnapshot();
+    }
+    /**
+     * Get improvement opportunities
+     */
+    async getImprovementOpportunities() {
+        const metrics = this.selfImprovement.collectMetrics();
+        return this.selfImprovement.findOpportunities(metrics);
+    }
+    /**
+     * Get system metrics
+     */
+    getMetrics() {
+        return this.selfImprovement.collectMetrics();
+    }
+    /**
+     * Get comprehensive stats
+     */
+    stats() {
+        return {
+            system: this.getState(),
+            consciousness: this.consciousness.stats(),
+            memory: this.cognitiveWorkspace.getMetrics(),
+            improvement: this.selfImprovement.stats(),
+            perceptions: this.perceptionStream?.stats() || null,
+        };
+    }
+    // ============================================================================
+    // Manual Controls
+    // ============================================================================
+    /**
+     * Manually trigger self-improvement cycle
+     */
+    async triggerSelfImprovement() {
+        return this.selfImprovement.runCycle();
+    }
+    /**
+     * Set goals for the system
+     */
+    setGoals(goals) {
+        this.config.goals = goals;
+        // Update perception stream goal
+        if (this.perceptionStream) {
+            this.perceptionStream.setGoal(goals.join(', '));
+        }
+    }
+    /**
+     * Enable/disable self-improvement
+     */
+    setSelfImprovementEnabled(enabled) {
+        this.config.selfImprovementEnabled = enabled;
+        this.selfImprovement.setAutoImprove(enabled);
+    }
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+exports.UnifiedSystem = UnifiedSystem;
+// ============================================================================
+// Factory
+// ============================================================================
+let unifiedInstance = null;
+function getUnifiedSystem(config) {
+    if (!unifiedInstance) {
+        unifiedInstance = new UnifiedSystem(config);
+    }
+    return unifiedInstance;
+}
+function resetUnifiedSystem() {
+    if (unifiedInstance) {
+        unifiedInstance.stop();
+    }
+    unifiedInstance = null;
+    (0, cognitive_workspace_js_1.resetCognitiveWorkspace)();
+}
+function createUnifiedSystem(config) {
+    return new UnifiedSystem(config);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-ai-cli",
-  "version": "7.16.0",
+  "version": "7.17.0",
   "description": "Autonomous AI System Creator - Brain ON by default, Active Inference integrated, Curiosity-driven, Φ monitoring in every response",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",