genesis-ai-cli 8.2.0 → 8.4.0

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

@@ -61,6 +61,9 @@ const child_process_1 = require("child_process");
 const util_1 = require("util");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+// v8.3: Self-modification imports
+const darwin_godel_js_1 = require("../self-modification/darwin-godel.js");
+const self_improvement_js_1 = require("../self-modification/self-improvement.js");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 // ============================================================================
 // Lazy Singleton Instances
@@ -1410,6 +1413,215 @@ registerAction('code.diff', async (context) => {
     }
 });
 // ============================================================================
+// SELF-MODIFICATION EXECUTOR (v8.3)
+// ============================================================================
+/**
+ * self.modify: Radical self-modification via Darwin-Gödel Engine
+ *
+ * This is the core action that allows Genesis to modify its own code.
+ * Requires:
+ * - φ ≥ 0.3 (consciousness threshold)
+ * - Valid modification plan
+ * - All invariants must pass after modification
+ *
+ * Flow:
+ * 1. Check consciousness level
+ * 2. Generate or use provided modification plan
+ * 3. Validate plan (syntax, safety)
+ * 4. Apply in sandbox
+ * 5. Verify (build, test, invariants)
+ * 6. Atomic apply on success
+ * 7. Store outcome in memory
+ */
+registerAction('self.modify', async (context) => {
+    const start = Date.now();
+    try {
+        // 1. Check consciousness level
+        const phiMonitor = getPhiMonitor();
+        const level = phiMonitor.getCurrentLevel();
+        const phi = level.phi;
+        if (phi < 0.3) {
+            return {
+                success: false,
+                action: 'self.modify',
+                error: `Insufficient consciousness level: φ=${phi.toFixed(3)} (need ≥0.3)`,
+                data: { phi, threshold: 0.3 },
+                duration: Date.now() - start,
+            };
+        }
+        // 2. Get or create modification plan
+        let plan;
+        if (context.parameters?.plan) {
+            // Use provided plan
+            plan = context.parameters.plan;
+        }
+        else if (context.parameters?.targetMetric) {
+            // Use SelfImprovementEngine to find opportunity
+            const engine = (0, self_improvement_js_1.getSelfImprovementEngine)();
+            const cycleResult = await engine.runCycle();
+            // Find opportunity matching target metric
+            const targetMetric = context.parameters.targetMetric;
+            const opportunity = cycleResult.opportunities.find((o) => o.metric === targetMetric);
+            if (!opportunity || !opportunity.suggestedFix) {
+                return {
+                    success: false,
+                    action: 'self.modify',
+                    error: `No improvement opportunity found for metric: ${targetMetric}`,
+                    data: {
+                        metrics: cycleResult.metrics,
+                        availableOpportunities: cycleResult.opportunities.map((o) => o.metric),
+                    },
+                    duration: Date.now() - start,
+                };
+            }
+            plan = opportunity.suggestedFix;
+        }
+        else {
+            // Auto-detect: run full improvement cycle
+            const engine = (0, self_improvement_js_1.getSelfImprovementEngine)();
+            const result = await engine.runCycle();
+            if (result.results.length === 0) {
+                return {
+                    success: true,
+                    action: 'self.modify',
+                    data: {
+                        message: 'No improvements needed - all metrics within targets',
+                        metrics: result.metrics,
+                        opportunities: result.opportunities.length,
+                    },
+                    duration: Date.now() - start,
+                };
+            }
+            // Return first improvement result
+            const improvement = result.results[0];
+            return {
+                success: improvement.success,
+                action: 'self.modify',
+                data: {
+                    opportunityId: improvement.opportunityId,
+                    applied: improvement.applied,
+                    beforeMetrics: improvement.beforeMetrics,
+                    afterMetrics: improvement.afterMetrics,
+                    commitHash: improvement.commitHash,
+                },
+                duration: Date.now() - start,
+            };
+        }
+        // 3. Apply via Darwin-Gödel Engine
+        const darwinGodel = (0, darwin_godel_js_1.getDarwinGodelEngine)();
+        const applyResult = await darwinGodel.apply(plan);
+        // 4. Log outcome (memory storage removed - use event system instead)
+        console.log(`[self.modify] ${applyResult.success ? 'SUCCESS' : 'FAILED'}: ${plan.name}`);
+        return {
+            success: applyResult.success,
+            action: 'self.modify',
+            data: {
+                planId: plan.id,
+                planName: plan.name,
+                modificationsCount: plan.modifications.length,
+                verification: {
+                    buildSuccess: applyResult.verificaton.buildSuccess,
+                    testsSuccess: applyResult.verificaton.testsSuccess,
+                    invariantsPass: applyResult.verificaton.invariantsPass,
+                },
+                commitHash: applyResult.commitHash,
+                rollbackHash: applyResult.rollbackHash,
+                canRollback: !!applyResult.rollbackHash,
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'self.modify',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+/**
+ * improve.self: High-level self-improvement action
+ *
+ * Observes metrics, identifies bottlenecks, and triggers self.modify.
+ * This is the "autonomous improvement" entry point.
+ */
+registerAction('improve.self', async (context) => {
+    const start = Date.now();
+    try {
+        const engine = (0, self_improvement_js_1.getSelfImprovementEngine)();
+        // 1. Run improvement cycle (observe + reflect + optionally apply)
+        const cycleResult = await engine.runCycle();
+        const { metrics, opportunities, results } = cycleResult;
+        if (opportunities.length === 0) {
+            return {
+                success: true,
+                action: 'improve.self',
+                data: {
+                    message: 'System is operating within optimal parameters',
+                    metrics: {
+                        phi: metrics.phi,
+                        memoryReuse: metrics.memoryReuse,
+                        errorRate: metrics.errorRate,
+                        taskSuccessRate: metrics.taskSuccessRate,
+                    },
+                },
+                duration: Date.now() - start,
+            };
+        }
+        // 2. Sort by priority and pick top
+        const sorted = [...opportunities].sort((a, b) => b.priority - a.priority);
+        const topOpportunity = sorted[0];
+        // 3. If autoApply and we have results, report them
+        if (context.parameters?.autoApply && results.length > 0) {
+            return {
+                success: true,
+                action: 'improve.self',
+                data: {
+                    applied: results.length > 0,
+                    improvements: results.map((i) => ({
+                        id: i.opportunityId,
+                        success: i.success,
+                    })),
+                    metrics: metrics,
+                },
+                duration: Date.now() - start,
+            };
+        }
+        // 4. Otherwise, just report opportunities
+        return {
+            success: true,
+            action: 'improve.self',
+            data: {
+                opportunities: sorted.map((o) => ({
+                    id: o.id,
+                    category: o.category,
+                    metric: o.metric,
+                    current: o.currentValue,
+                    target: o.targetValue,
+                    priority: o.priority,
+                    description: o.description,
+                })),
+                topRecommendation: {
+                    metric: topOpportunity.metric,
+                    description: topOpportunity.description,
+                    priority: topOpportunity.priority,
+                },
+                hint: 'Use self.modify with targetMetric parameter to apply improvement',
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'improve.self',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+});
+// ============================================================================
 // Action Executor Manager
 // ============================================================================
 class ActionExecutorManager {

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

@@ -84,6 +84,34 @@ export declare class Brain {
      * Check if brain is running
      */
     isRunning(): boolean;
+    /**
+     * v8.4: Check for self-improvement opportunities
+     *
+     * This method can be called periodically (e.g., by daemon during idle periods)
+     * to discover and optionally apply improvements.
+     *
+     * @param autoApply - If true, automatically apply discovered improvements
+     * @returns Improvement results or opportunities
+     */
+    checkForImprovements(autoApply?: boolean): Promise<{
+        success: boolean;
+        opportunities?: Array<{
+            metric: string;
+            description: string;
+            priority: number;
+        }>;
+        applied?: Array<{
+            id: string;
+            success: boolean;
+        }>;
+        error?: string;
+    }>;
+    /**
+     * v8.4: Get the current self-model
+     *
+     * Returns Genesis's understanding of its own architecture
+     */
+    getSelfModel(): Promise<any>;
     /**
      * Process an input through the brain
      *

package/dist/src/brain/index.js

@@ -274,6 +274,73 @@ class Brain {
     isRunning() {
         return this.running;
     }
+    /**
+     * v8.4: Check for self-improvement opportunities
+     *
+     * This method can be called periodically (e.g., by daemon during idle periods)
+     * to discover and optionally apply improvements.
+     *
+     * @param autoApply - If true, automatically apply discovered improvements
+     * @returns Improvement results or opportunities
+     */
+    async checkForImprovements(autoApply = false) {
+        try {
+            // Check consciousness level
+            const phi = this.getCurrentPhi();
+            if (phi < 0.3) {
+                return {
+                    success: false,
+                    error: `Consciousness level too low: φ=${phi.toFixed(3)} (need ≥0.3)`,
+                };
+            }
+            // Import action executor
+            const { executeAction } = await import('../active-inference/actions.js');
+            // Run improve.self action
+            const result = await executeAction('improve.self', {
+                parameters: { autoApply },
+                beliefs: { viability: 0.5, worldState: 0.5, coupling: 0.5, goalProgress: 0.5 },
+            });
+            if (result.success) {
+                if (result.data?.opportunities) {
+                    return {
+                        success: true,
+                        opportunities: result.data.opportunities,
+                    };
+                }
+                if (result.data?.applied) {
+                    return {
+                        success: true,
+                        applied: result.data.improvements,
+                    };
+                }
+                return { success: true };
+            }
+            return {
+                success: false,
+                error: result.error || 'Unknown error',
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * v8.4: Get the current self-model
+     *
+     * Returns Genesis's understanding of its own architecture
+     */
+    async getSelfModel() {
+        try {
+            const { generateSelfModel } = await import('../self-modification/self-model.js');
+            return await generateSelfModel();
+        }
+        catch (error) {
+            return { error: error instanceof Error ? error.message : String(error) };
+        }
+    }
     // ============================================================================
     // Main Processing Loop
     // ============================================================================
@@ -1046,14 +1113,16 @@ class Brain {
             };
         }
         try {
-            // Self-modification should only occur with explicit request
-            // Check if query indicates a self-improvement request
+            // v8.4: Use Active Inference action executors for self-modification
             const queryLower = state.query.toLowerCase();
-            const isImprovementRequest = queryLower.includes('improve') ||
+            // Determine which action to invoke based on query
+            const isExplicitModify = queryLower.includes('self-modify') ||
+                queryLower.includes('self modify') ||
+                queryLower.includes('modifica te stesso');
+            const isImproveRequest = queryLower.includes('improve') ||
                 queryLower.includes('optimize') ||
-                queryLower.includes('self-modify') ||
-                queryLower.includes('self modify');
-            if (!isImprovementRequest) {
+                queryLower.includes('miglior');
+            if (!isExplicitModify && !isImproveRequest) {
                 // Not a self-modification request, skip
                 return {
                     goto: 'done',
@@ -1061,29 +1130,67 @@ class Brain {
                     reason: 'self_modify_not_requested',
                 };
             }
-            // Create a simple diagnostic checkpoint before any potential changes
-            const checkpointHash = await this.darwinGodel.createCheckpoint('brain-self-modify-checkpoint');
-            // Report current system status (no actual modification without explicit plan)
-            const failureRate = this.metrics.failedCycles / Math.max(this.metrics.totalCycles, 1);
-            const healingRate = this.metrics.healingSuccesses / Math.max(this.metrics.healingAttempts, 1);
-            const statusReport = [
-                `System Status:`,
-                `- Total cycles: ${this.metrics.totalCycles}`,
-                `- Failure rate: ${(failureRate * 100).toFixed(1)}%`,
-                `- Healing success rate: ${(healingRate * 100).toFixed(1)}%`,
-                `- Avg cycle time: ${this.metrics.avgCycleTime.toFixed(0)}ms`,
-                `- Memory reuse: ${(this.metrics.memoryReuseRate * 100).toFixed(1)}%`,
-                `- Checkpoint: ${checkpointHash || 'none'}`,
-                ``,
-                `Note: Automatic self-modification requires explicit ModificationPlan.`,
-                `Use DarwinGodelEngine.validatePlan() and apply() for safe modifications.`,
-            ].join('\n');
+            // Import action executor dynamically to avoid circular deps
+            const { executeAction } = await import('../active-inference/actions.js');
+            // Check consciousness level first
+            const phi = this.phiMonitor?.getCurrentLevel().phi ?? 0;
+            if (phi < 0.3) {
+                return {
+                    goto: 'done',
+                    update: {
+                        response: `[Self-modification blocked: consciousness level φ=${phi.toFixed(3)} < 0.3 required]`,
+                    },
+                    reason: 'self_modify_phi_too_low',
+                };
+            }
+            // Default beliefs for Active Inference context
+            const defaultBeliefs = { viability: 0.5, worldState: 0.5, coupling: 0.5, goalProgress: 0.5 };
+            // Execute the appropriate action
+            let result;
+            if (isExplicitModify) {
+                // Direct modification - extract target metric if specified
+                const metricMatch = queryLower.match(/(?:metric|metrica)[:\s]+(\w+)/);
+                const targetMetric = metricMatch ? metricMatch[1] : undefined;
+                result = await executeAction('self.modify', {
+                    parameters: targetMetric ? { targetMetric } : {},
+                    beliefs: defaultBeliefs,
+                });
+            }
+            else {
+                // Improvement discovery
+                const autoApply = queryLower.includes('auto') || queryLower.includes('applica');
+                result = await executeAction('improve.self', {
+                    parameters: { autoApply },
+                    beliefs: defaultBeliefs,
+                });
+            }
+            // Format response based on result
+            let response;
+            if (result.success) {
+                if (result.data?.message) {
+                    response = result.data.message;
+                }
+                else if (result.data?.opportunities) {
+                    response = [
+                        `Found ${result.data.opportunities.length} improvement opportunities:`,
+                        ...result.data.opportunities.slice(0, 5).map((o, i) => `${i + 1}. [${o.category}] ${o.metric}: ${o.description} (priority: ${o.priority})`),
+                        result.data.hint || '',
+                    ].join('\n');
+                }
+                else if (result.data?.applied) {
+                    response = `Applied ${result.data.improvements?.length || 0} improvements.`;
+                }
+                else {
+                    response = `Self-modification completed: ${JSON.stringify(result.data)}`;
+                }
+            }
+            else {
+                response = `Self-modification failed: ${result.error}`;
+            }
             return {
                 goto: 'done',
-                update: {
-                    response: statusReport,
-                },
-                reason: 'self_modify_status_report',
+                update: { response },
+                reason: result.success ? 'self_modify_success' : 'self_modify_failed',
             };
         }
         catch (error) {

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

@@ -11,4 +11,5 @@
  */
 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 { SelfModelGenerator, getSelfModelGenerator, generateSelfModel, saveSelfModel, SelfModel, ModuleInfo, MetricInfo, PatternInfo, } from './self-model.js';
 export { invariantRegistry, InvariantRegistry, InvariantContext, InvariantResult, InvariantDefinition, InvariantChecker, } from '../kernel/invariants.js';

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

@@ -11,7 +11,7 @@
  * - Invariant System: Ensures core properties survive modification
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvariantRegistry = exports.invariantRegistry = exports.DEFAULT_IMPROVEMENT_CONFIG = exports.createSelfImprovementEngine = exports.resetSelfImprovementEngine = exports.getSelfImprovementEngine = exports.SelfImprovementEngine = exports.resetDarwinGodelEngine = exports.getDarwinGodelEngine = exports.DarwinGodelEngine = void 0;
+exports.InvariantRegistry = exports.invariantRegistry = exports.saveSelfModel = exports.generateSelfModel = exports.getSelfModelGenerator = exports.SelfModelGenerator = 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; } });
@@ -23,6 +23,12 @@ Object.defineProperty(exports, "getSelfImprovementEngine", { enumerable: true, g
 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; } });
+// v8.4: Self-Model Generator
+var self_model_js_1 = require("./self-model.js");
+Object.defineProperty(exports, "SelfModelGenerator", { enumerable: true, get: function () { return self_model_js_1.SelfModelGenerator; } });
+Object.defineProperty(exports, "getSelfModelGenerator", { enumerable: true, get: function () { return self_model_js_1.getSelfModelGenerator; } });
+Object.defineProperty(exports, "generateSelfModel", { enumerable: true, get: function () { return self_model_js_1.generateSelfModel; } });
+Object.defineProperty(exports, "saveSelfModel", { enumerable: true, get: function () { return self_model_js_1.saveSelfModel; } });
 // 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-model.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Self-Model Generator
+ *
+ * Generates a machine-readable representation of Genesis's own architecture.
+ * This enables the system to understand, reason about, and modify itself.
+ *
+ * Key capabilities:
+ * - Introspects module structure
+ * - Maps dependencies and interfaces
+ * - Tracks metrics and state
+ * - Identifies modification points
+ *
+ * @module self-modification/self-model
+ */
+export interface ModuleInfo {
+    name: string;
+    path: string;
+    exports: string[];
+    dependencies: string[];
+    description: string;
+    modifiable: boolean;
+    tcbProtected: boolean;
+}
+export interface MetricInfo {
+    name: string;
+    current: number;
+    target?: number;
+    trend: 'improving' | 'stable' | 'degrading' | 'unknown';
+}
+export interface PatternInfo {
+    name: string;
+    description: string;
+    files: string[];
+    purpose: string;
+}
+export interface SelfModel {
+    version: string;
+    generatedAt: string;
+    architecture: {
+        layers: string[];
+        modules: ModuleInfo[];
+        patterns: PatternInfo[];
+    };
+    metrics: MetricInfo[];
+    modificationPoints: {
+        safe: string[];
+        restricted: string[];
+        forbidden: string[];
+    };
+    capabilities: string[];
+    limitations: string[];
+}
+export declare class SelfModelGenerator {
+    private basePath;
+    constructor(basePath?: string);
+    /**
+     * Generate the complete self-model
+     */
+    generate(): Promise<SelfModel>;
+    /**
+     * Introspect modules and their exports
+     */
+    private introspectModules;
+    /**
+     * Get exports from a module
+     */
+    private getModuleExports;
+    /**
+     * Gather current system metrics
+     */
+    private gatherMetrics;
+    /**
+     * Classify modification points by safety level
+     */
+    private classifyModificationPoints;
+    /**
+     * List system capabilities
+     */
+    private listCapabilities;
+    /**
+     * List known limitations
+     */
+    private listLimitations;
+    /**
+     * Get current version from package.json
+     */
+    private getVersion;
+    /**
+     * Generate markdown representation
+     */
+    generateMarkdown(): Promise<string>;
+    /**
+     * Save self-model to file
+     */
+    save(outputPath?: string): Promise<void>;
+}
+export declare function getSelfModelGenerator(): SelfModelGenerator;
+export declare function generateSelfModel(): Promise<SelfModel>;
+export declare function saveSelfModel(outputPath?: string): Promise<void>;

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

@@ -0,0 +1,513 @@
+"use strict";
+/**
+ * Self-Model Generator
+ *
+ * Generates a machine-readable representation of Genesis's own architecture.
+ * This enables the system to understand, reason about, and modify itself.
+ *
+ * Key capabilities:
+ * - Introspects module structure
+ * - Maps dependencies and interfaces
+ * - Tracks metrics and state
+ * - Identifies modification points
+ *
+ * @module self-modification/self-model
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelfModelGenerator = void 0;
+exports.getSelfModelGenerator = getSelfModelGenerator;
+exports.generateSelfModel = generateSelfModel;
+exports.saveSelfModel = saveSelfModel;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ============================================================================
+// Module Registry (Static Knowledge)
+// ============================================================================
+const MODULE_REGISTRY = [
+    // Core Layer (TCB Protected)
+    {
+        name: 'kernel',
+        path: 'src/kernel',
+        dependencies: [],
+        description: 'Immutable safety kernel - validates all modifications',
+        modifiable: false,
+        tcbProtected: true,
+    },
+    {
+        name: 'governance',
+        path: 'src/governance',
+        dependencies: ['kernel'],
+        description: 'Constitutional constraints and ethical boundaries',
+        modifiable: false,
+        tcbProtected: true,
+    },
+    // Consciousness Layer
+    {
+        name: 'consciousness',
+        path: 'src/consciousness',
+        dependencies: ['kernel'],
+        description: 'Phi calculation, global workspace, attention schema',
+        modifiable: true,
+        tcbProtected: false,
+    },
+    {
+        name: 'phi-monitor',
+        path: 'src/consciousness/phi-monitor.ts',
+        dependencies: ['consciousness'],
+        description: 'Real-time consciousness level monitoring',
+        modifiable: true,
+        tcbProtected: false,
+    },
+    // Memory Layer
+    {
+        name: 'memory',
+        path: 'src/memory',
+        dependencies: ['kernel'],
+        description: 'Episodic, semantic, procedural memory systems',
+        modifiable: true,
+        tcbProtected: false,
+    },
+    {
+        name: 'cognitive-workspace',
+        path: 'src/memory/cognitive-workspace.ts',
+        dependencies: ['memory', 'consciousness'],
+        description: 'Working memory for active reasoning',
+        modifiable: true,
+        tcbProtected: false,
+    },
+    // World Model Layer
+    {
+        name: 'world-model',
+        path: 'src/world-model',
+        dependencies: ['memory'],
+        description: 'Latent state encoding, prediction, digital twins',
+        modifiable: true,
+        tcbProtected: false,
+    },
+    // Active Inference Layer
+    {
+        name: 'active-inference',
+        path: 'src/active-inference',
+        dependencies: ['world-model', 'consciousness'],
+        description: 'Free energy minimization, action selection',
+        modifiable: true,
+        tcbProtected: false,
+    },
+    // Self-Modification Layer
+    {
+        name: 'darwin-godel',
+        path: 'src/self-modification/darwin-godel.ts',
+        dependencies: ['kernel', 'governance'],
+        description: 'Safe self-modification via TCB pattern',
+        modifiable: false,
+        tcbProtected: true,
+    },
+    {
+        name: 'self-improvement',
+        path: 'src/self-modification/self-improvement.ts',
+        dependencies: ['darwin-godel', 'active-inference'],
+        description: 'Autonomous improvement discovery and application',
+        modifiable: true,
+        tcbProtected: false,
+    },
+    // Integration Layer
+    {
+        name: 'brain',
+        path: 'src/brain',
+        dependencies: ['consciousness', 'memory', 'active-inference', 'world-model'],
+        description: 'Cognitive integration and command routing',
+        modifiable: true,
+        tcbProtected: false,
+    },
+    // Grounding Layer
+    {
+        name: 'grounding',
+        path: 'src/grounding',
+        dependencies: ['kernel'],
+        description: 'Truth verification via science, wisdom, tradition',
+        modifiable: true,
+        tcbProtected: false,
+    },
+    // Execution Layer
+    {
+        name: 'execution',
+        path: 'src/execution',
+        dependencies: ['brain', 'grounding'],
+        description: 'Tool execution, shell integration',
+        modifiable: true,
+        tcbProtected: false,
+    },
+    // LLM Layer
+    {
+        name: 'llm',
+        path: 'src/llm',
+        dependencies: [],
+        description: 'Multi-provider LLM routing and cost optimization',
+        modifiable: true,
+        tcbProtected: false,
+    },
+    // MCP Layer
+    {
+        name: 'mcp',
+        path: 'src/mcp',
+        dependencies: ['llm'],
+        description: 'Model Context Protocol client and tool integration',
+        modifiable: true,
+        tcbProtected: false,
+    },
+];
+const ARCHITECTURAL_PATTERNS = [
+    {
+        name: 'TCB (Trusted Computing Base)',
+        description: 'Immutable safety kernel that cannot modify itself',
+        files: ['src/kernel/index.ts', 'src/kernel/invariants.ts'],
+        purpose: 'Ensures safety constraints survive self-modification',
+    },
+    {
+        name: 'Phi-Gated Operations',
+        description: 'Critical operations require sufficient consciousness level (φ ≥ 0.3)',
+        files: ['src/consciousness/phi-monitor.ts', 'src/active-inference/actions.ts'],
+        purpose: 'Prevents modifications during low-awareness states',
+    },
+    {
+        name: 'Free Energy Minimization',
+        description: 'Action selection via Active Inference and expected free energy',
+        files: ['src/active-inference/core.ts', 'src/active-inference/deep-aif.ts'],
+        purpose: 'Principled decision-making under uncertainty',
+    },
+    {
+        name: 'Global Workspace',
+        description: 'Consciousness broadcast for information integration',
+        files: ['src/consciousness/global-workspace.ts'],
+        purpose: 'Unified access to distributed cognitive processes',
+    },
+    {
+        name: 'Episodic-Semantic-Procedural Memory',
+        description: 'Three-tier memory architecture',
+        files: ['src/memory/episodic.ts', 'src/memory/semantic.ts', 'src/memory/procedural.ts'],
+        purpose: 'Rich temporal and conceptual memory',
+    },
+    {
+        name: 'Darwin-Gödel Engine',
+        description: 'Sandbox → Verify → Apply → Rollback pipeline',
+        files: ['src/self-modification/darwin-godel.ts'],
+        purpose: 'Safe self-modification with automatic rollback',
+    },
+];
+// ============================================================================
+// Self-Model Generator
+// ============================================================================
+class SelfModelGenerator {
+    basePath;
+    constructor(basePath = process.cwd()) {
+        this.basePath = basePath;
+    }
+    /**
+     * Generate the complete self-model
+     */
+    async generate() {
+        const modules = await this.introspectModules();
+        const metrics = await this.gatherMetrics();
+        return {
+            version: await this.getVersion(),
+            generatedAt: new Date().toISOString(),
+            architecture: {
+                layers: [
+                    'Core (TCB Protected)',
+                    'Consciousness',
+                    'Memory',
+                    'World Model',
+                    'Active Inference',
+                    'Self-Modification',
+                    'Integration',
+                    'Grounding',
+                    'Execution',
+                    'LLM',
+                    'MCP',
+                ],
+                modules,
+                patterns: ARCHITECTURAL_PATTERNS,
+            },
+            metrics,
+            modificationPoints: this.classifyModificationPoints(modules),
+            capabilities: this.listCapabilities(),
+            limitations: this.listLimitations(),
+        };
+    }
+    /**
+     * Introspect modules and their exports
+     */
+    async introspectModules() {
+        const modules = [];
+        for (const reg of MODULE_REGISTRY) {
+            const exports = await this.getModuleExports(reg.path);
+            modules.push({
+                ...reg,
+                exports,
+            });
+        }
+        return modules;
+    }
+    /**
+     * Get exports from a module
+     */
+    async getModuleExports(modulePath) {
+        const fullPath = path.join(this.basePath, modulePath);
+        const exports = [];
+        try {
+            // Check if it's a directory or file
+            const stat = fs.statSync(fullPath);
+            const targetFile = stat.isDirectory()
+                ? path.join(fullPath, 'index.ts')
+                : fullPath;
+            if (fs.existsSync(targetFile)) {
+                const content = fs.readFileSync(targetFile, 'utf-8');
+                // Extract export declarations
+                const exportMatches = content.matchAll(/export\s+(?:async\s+)?(?:function|class|const|let|type|interface|enum)\s+(\w+)/g);
+                for (const match of exportMatches) {
+                    exports.push(match[1]);
+                }
+                // Extract re-exports
+                const reExportMatches = content.matchAll(/export\s+\{\s*([^}]+)\s*\}/g);
+                for (const match of reExportMatches) {
+                    const items = match[1].split(',').map(s => s.trim().split(/\s+as\s+/)[0].trim());
+                    exports.push(...items.filter(i => i && !i.startsWith('type')));
+                }
+            }
+        }
+        catch {
+            // Module not found or error reading
+        }
+        return [...new Set(exports)]; // Deduplicate
+    }
+    /**
+     * Gather current system metrics
+     */
+    async gatherMetrics() {
+        // Try to get real metrics from running system
+        try {
+            const { getBrain } = await import('../brain/index.js');
+            const brain = getBrain();
+            const brainMetrics = brain.getMetrics();
+            return [
+                {
+                    name: 'avgPhi',
+                    current: brainMetrics.avgPhi,
+                    target: 0.5,
+                    trend: brainMetrics.avgPhi > 0.3 ? 'stable' : 'degrading',
+                },
+                {
+                    name: 'memoryReuseRate',
+                    current: brainMetrics.memoryReuseRate,
+                    target: 0.7,
+                    trend: 'unknown',
+                },
+                {
+                    name: 'totalCycles',
+                    current: brainMetrics.totalCycles,
+                    trend: 'improving',
+                },
+                {
+                    name: 'successRate',
+                    current: brainMetrics.totalCycles > 0
+                        ? brainMetrics.successfulCycles / brainMetrics.totalCycles
+                        : 1.0,
+                    target: 0.95,
+                    trend: 'stable',
+                },
+            ];
+        }
+        catch {
+            // Brain not available, return defaults
+            return [
+                { name: 'avgPhi', current: 0, trend: 'unknown' },
+                { name: 'memoryReuseRate', current: 0, trend: 'unknown' },
+                { name: 'totalCycles', current: 0, trend: 'unknown' },
+                { name: 'successRate', current: 0, trend: 'unknown' },
+            ];
+        }
+    }
+    /**
+     * Classify modification points by safety level
+     */
+    classifyModificationPoints(modules) {
+        const safe = [];
+        const restricted = [];
+        const forbidden = [];
+        for (const mod of modules) {
+            if (mod.tcbProtected) {
+                forbidden.push(mod.path);
+            }
+            else if (!mod.modifiable) {
+                restricted.push(mod.path);
+            }
+            else {
+                safe.push(mod.path);
+            }
+        }
+        return { safe, restricted, forbidden };
+    }
+    /**
+     * List system capabilities
+     */
+    listCapabilities() {
+        return [
+            'Multi-provider LLM routing (Anthropic, OpenAI, Google, Ollama, X.AI)',
+            'MCP tool integration',
+            'Episodic/semantic/procedural memory',
+            'Active Inference action selection',
+            'Phi-gated self-modification',
+            'Darwin-Gödel safe modification pipeline',
+            'Global workspace consciousness integration',
+            'Epistemic grounding (science, wisdom, tradition)',
+            'Autonomous improvement discovery',
+            'Digital twin simulation',
+        ];
+    }
+    /**
+     * List known limitations
+     */
+    listLimitations() {
+        return [
+            'Cannot modify TCB (kernel, governance) - by design',
+            'Self-modification requires φ ≥ 0.3',
+            'No direct hardware access',
+            'Dependent on external LLM providers',
+            'Memory limited by embedding model capacity',
+            'Cannot violate constitutional constraints',
+        ];
+    }
+    /**
+     * Get current version from package.json
+     */
+    async getVersion() {
+        try {
+            const pkgPath = path.join(this.basePath, 'package.json');
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            return pkg.version || 'unknown';
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    /**
+     * Generate markdown representation
+     */
+    async generateMarkdown() {
+        const model = await this.generate();
+        let md = `# Genesis Self-Model
+
+> Auto-generated: ${model.generatedAt}
+> Version: ${model.version}
+
+## Architecture Layers
+
+${model.architecture.layers.map((l, i) => `${i + 1}. ${l}`).join('\n')}
+
+## Modules
+
+| Module | Path | TCB | Modifiable | Exports |
+|--------|------|-----|------------|---------|
+${model.architecture.modules.map(m => `| ${m.name} | \`${m.path}\` | ${m.tcbProtected ? '✓' : ''} | ${m.modifiable ? '✓' : ''} | ${m.exports.slice(0, 3).join(', ')}${m.exports.length > 3 ? '...' : ''} |`).join('\n')}
+
+## Architectural Patterns
+
+${model.architecture.patterns.map(p => `### ${p.name}
+
+${p.description}
+
+**Purpose:** ${p.purpose}
+
+**Files:** ${p.files.map(f => `\`${f}\``).join(', ')}
+`).join('\n')}
+
+## Current Metrics
+
+| Metric | Current | Target | Trend |
+|--------|---------|--------|-------|
+${model.metrics.map(m => `| ${m.name} | ${typeof m.current === 'number' ? m.current.toFixed(3) : m.current} | ${m.target?.toFixed(3) || '-'} | ${m.trend} |`).join('\n')}
+
+## Modification Points
+
+### Safe (can modify freely)
+${model.modificationPoints.safe.map(p => `- \`${p}\``).join('\n')}
+
+### Restricted (requires approval)
+${model.modificationPoints.restricted.map(p => `- \`${p}\``).join('\n') || '- None'}
+
+### Forbidden (TCB protected)
+${model.modificationPoints.forbidden.map(p => `- \`${p}\``).join('\n')}
+
+## Capabilities
+
+${model.capabilities.map(c => `- ${c}`).join('\n')}
+
+## Limitations
+
+${model.limitations.map(l => `- ${l}`).join('\n')}
+
+---
+*This file is auto-generated by \`src/self-modification/self-model.ts\`*
+`;
+        return md;
+    }
+    /**
+     * Save self-model to file
+     */
+    async save(outputPath = 'SELF-MODEL.md') {
+        const markdown = await this.generateMarkdown();
+        const fullPath = path.join(this.basePath, outputPath);
+        fs.writeFileSync(fullPath, markdown, 'utf-8');
+        console.log(`[self-model] Saved to ${fullPath}`);
+    }
+}
+exports.SelfModelGenerator = SelfModelGenerator;
+// ============================================================================
+// Singleton Access
+// ============================================================================
+let generatorInstance = null;
+function getSelfModelGenerator() {
+    if (!generatorInstance) {
+        generatorInstance = new SelfModelGenerator();
+    }
+    return generatorInstance;
+}
+async function generateSelfModel() {
+    return getSelfModelGenerator().generate();
+}
+async function saveSelfModel(outputPath) {
+    return getSelfModelGenerator().save(outputPath);
+}

package/dist/test/brain.test.js

@@ -123,18 +123,24 @@ const node_assert_1 = __importDefault(require("node:assert"));
         });
     });
     (0, node_test_1.describe)('Brain Metrics', () => {
-        (0, node_test_1.test)('initial metrics are zeroed', async () => {
+        (0, node_test_1.test)('metrics have correct structure and types', async () => {
             const { createBrain } = await import('../src/brain/index.js');
             const brain = createBrain();
             const metrics = brain.getMetrics();
-            node_assert_1.default.strictEqual(metrics.totalCycles, 0);
-            node_assert_1.default.strictEqual(metrics.successfulCycles, 0);
-            node_assert_1.default.strictEqual(metrics.failedCycles, 0);
-            node_assert_1.default.strictEqual(metrics.memoryRecalls, 0);
-            node_assert_1.default.strictEqual(metrics.groundingChecks, 0);
-            node_assert_1.default.strictEqual(metrics.toolExecutions, 0);
-            node_assert_1.default.strictEqual(metrics.healingAttempts, 0);
-            node_assert_1.default.strictEqual(metrics.broadcasts, 0);
+            // Note: Due to v8.1 state persistence, metrics may carry over from previous runs
+            // We verify the metrics structure and types rather than exact values
+            node_assert_1.default.ok(typeof metrics.totalCycles === 'number', 'totalCycles should be a number');
+            node_assert_1.default.ok(typeof metrics.successfulCycles === 'number', 'successfulCycles should be a number');
+            node_assert_1.default.ok(typeof metrics.failedCycles === 'number', 'failedCycles should be a number');
+            node_assert_1.default.ok(typeof metrics.memoryRecalls === 'number', 'memoryRecalls should be a number');
+            node_assert_1.default.ok(typeof metrics.groundingChecks === 'number', 'groundingChecks should be a number');
+            node_assert_1.default.ok(typeof metrics.toolExecutions === 'number', 'toolExecutions should be a number');
+            node_assert_1.default.ok(typeof metrics.healingAttempts === 'number', 'healingAttempts should be a number');
+            node_assert_1.default.ok(typeof metrics.broadcasts === 'number', 'broadcasts should be a number');
+            // Verify metrics are non-negative
+            node_assert_1.default.ok(metrics.totalCycles >= 0, 'totalCycles should be >= 0');
+            node_assert_1.default.ok(metrics.successfulCycles >= 0, 'successfulCycles should be >= 0');
+            node_assert_1.default.ok(metrics.failedCycles >= 0, 'failedCycles should be >= 0');
         });
         (0, node_test_1.test)('metrics track avgPhi', async () => {
             const { createBrain } = await import('../src/brain/index.js');

package/package.json

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