genesis-ai-cli 13.0.0 → 13.1.0

package/dist/.genesis/code-index/code-index.json

@@ -0,0 +1,12 @@
+{
+  "version": "8.5.0",
+  "indexedAt": "2026-01-24T18:24:32.643Z",
+  "rootPath": "/Users/lucarossignoli/genesis/dist/src",
+  "chunks": [],
+  "stats": {
+    "totalFiles": 0,
+    "totalChunks": 0,
+    "totalLines": 0,
+    "byType": {}
+  }
+}

package/dist/.genesis/code-index/embeddings-nomic-embed-text.json

@@ -0,0 +1 @@
+{"version":"9.0.0","model":"nomic-embed-text","dimensions":768,"count":0,"vectors":{}}

package/dist/.genesis/code-index/metadata.json

@@ -0,0 +1 @@
+{"version":"9.0.0","count":0,"items":{}}

package/dist/.genesis/code-index/vectors.json

@@ -0,0 +1 @@
+{"version":"9.0.0","model":"nomic-embed-text","count":0,"vectors":{}}

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

@@ -38,6 +38,7 @@
  * ```
  */
 import { BrainState, BrainConfig, BrainMetrics, BrainEventHandler } from './types.js';
+import { SelfKnowledge } from './self-knowledge.js';
 import { UnifiedMemoryQuery } from '../memory/unified-query.js';
 export declare class Brain {
     private config;
@@ -56,6 +57,7 @@ export declare class Brain {
     private darwinGodel;
     private metacognition;
     private fek;
+    private selfKnowledge;
     private persistence;
     private unifiedQuery;
     private toolCache;
@@ -335,6 +337,10 @@ export declare class Brain {
      * Reset metrics
      */
     resetMetrics(): void;
+    /**
+     * v13.1: Get self-knowledge module for code queries
+     */
+    getSelfKnowledge(): SelfKnowledge;
     /**
      * v10.4.2: Get unified memory query for cross-store searches
      */
@@ -409,3 +415,4 @@ export declare function resetBrain(): void;
 export declare function getBrainInstance(): Brain | null;
 export * from './types.js';
 export * from './trace.js';
+export { SelfKnowledge, getSelfKnowledge, isCodeQuery } from './self-knowledge.js';

package/dist/src/brain/index.js

@@ -53,7 +53,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Brain = void 0;
+exports.isCodeQuery = exports.getSelfKnowledge = exports.SelfKnowledge = exports.Brain = void 0;
 exports.createBrain = createBrain;
 exports.getBrain = getBrain;
 exports.resetBrain = resetBrain;
@@ -83,6 +83,8 @@ const strategy_executor_js_1 = require("../reasoning/strategy-executor.js");
 const free_energy_kernel_js_1 = require("../kernel/free-energy-kernel.js");
 // v8.1: Brain State Persistence
 const persistence_js_1 = require("./persistence.js");
+// v13.1: Self-Knowledge — code-aware context
+const self_knowledge_js_1 = require("./self-knowledge.js");
 // v10.4.2: Unified Memory Query
 const unified_query_js_1 = require("../memory/unified-query.js");
 const index_js_10 = require("../memory/index.js");
@@ -110,6 +112,8 @@ class Brain {
     metacognition = null;
     // v12.0: Free Energy Kernel
     fek = null;
+    // v13.1: Self-Knowledge (code awareness)
+    selfKnowledge;
     // v8.1: State Persistence
     persistence;
     // v10.4.2: Unified Memory Query
@@ -165,6 +169,8 @@ class Brain {
         // v8.1: Initialize state persistence and load persisted metrics
         this.persistence = (0, persistence_js_1.getBrainStatePersistence)();
         this.metrics = { ...this.metrics, ...this.persistence.getMetrics() };
+        // v13.1: Self-Knowledge — code awareness (keyword search, no API)
+        this.selfKnowledge = (0, self_knowledge_js_1.getSelfKnowledge)();
         // v7.13: Initialize full module integration (lazy - on first use)
         this.initializeV713Modules();
     }
@@ -737,6 +743,8 @@ class Brain {
         this.running = true;
         // v7.2: Build system prompt with available tools
         await this.initializeSystemPrompt();
+        // v13.1: Boot self-knowledge (index own source code)
+        this.selfKnowledge.boot().catch(() => { });
         // Start consciousness monitoring
         if (this.config.consciousness.enabled) {
             this.phiMonitor.start();
@@ -1123,6 +1131,14 @@ class Brain {
         }
         // Build context from working memory
         const context = this.buildContext(state);
+        // v13.1: Inject self-knowledge if query is about own code/architecture
+        if (this.selfKnowledge.isReady() && (0, self_knowledge_js_1.isCodeQuery)(state.query)) {
+            const codeContext = this.selfKnowledge.getContext(state.query);
+            if (codeContext) {
+                context.formatted = codeContext + '\n' + context.formatted;
+                context.tokenEstimate += Math.ceil(codeContext.length / 4);
+            }
+        }
         // Track metrics
         this.metrics.memoryRecalls++;
         const wsMetrics = this.workspace.getMetrics();
@@ -2307,6 +2323,12 @@ class Brain {
     resetMetrics() {
         this.metrics = this.createInitialMetrics();
     }
+    /**
+     * v13.1: Get self-knowledge module for code queries
+     */
+    getSelfKnowledge() {
+        return this.selfKnowledge;
+    }
     /**
      * v10.4.2: Get unified memory query for cross-store searches
      */
@@ -2465,3 +2487,7 @@ function getBrainInstance() {
 // ============================================================================
 __exportStar(require("./types.js"), exports);
 __exportStar(require("./trace.js"), exports);
+var self_knowledge_js_2 = require("./self-knowledge.js");
+Object.defineProperty(exports, "SelfKnowledge", { enumerable: true, get: function () { return self_knowledge_js_2.SelfKnowledge; } });
+Object.defineProperty(exports, "getSelfKnowledge", { enumerable: true, get: function () { return self_knowledge_js_2.getSelfKnowledge; } });
+Object.defineProperty(exports, "isCodeQuery", { enumerable: true, get: function () { return self_knowledge_js_2.isCodeQuery; } });

package/dist/src/brain/self-knowledge.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Genesis v13.1 - Self-Knowledge Module
+ *
+ * Gives the Brain awareness of its own source code.
+ * Uses CodeRAG for keyword-based retrieval (no API keys needed).
+ *
+ * Architecture:
+ *   boot() → index src/ → cache to .genesis/code-index.json
+ *   query(text) → keyword search → relevant CodeChunks
+ *   getContext(query) → formatted string for Brain context injection
+ *
+ * The Brain's stepMemory() calls this when the query relates to
+ * Genesis's own architecture, code, or capabilities.
+ */
+import { QueryResult } from '../self-modification/code-rag.js';
+import { SelfModel } from '../self-modification/self-model.js';
+export interface SelfKnowledgeConfig {
+    rootPath: string;
+    maxContextChunks: number;
+    maxContextChars: number;
+    autoIndex: boolean;
+    cacheDir: string;
+}
+export interface CodeContext {
+    chunks: QueryResult[];
+    summary: string;
+    formatted: string;
+    selfModel?: SelfModel;
+}
+/**
+ * Detect if a query is about Genesis's own code/architecture
+ */
+export declare function isCodeQuery(query: string): boolean;
+export declare class SelfKnowledge {
+    private config;
+    private codeRAG;
+    private selfModelGen;
+    private indexed;
+    private selfModel;
+    private bootPromise;
+    constructor(config?: Partial<SelfKnowledgeConfig>);
+    /**
+     * Boot: index the codebase (or load from cache)
+     * Called once when brain starts. Non-blocking if already cached.
+     */
+    boot(): Promise<void>;
+    private _doBoot;
+    /**
+     * Query the codebase for relevant chunks
+     */
+    query(queryText: string, topK?: number): QueryResult[];
+    /**
+     * Get formatted context string for brain injection
+     * Returns empty string if query isn't code-related or index unavailable
+     */
+    getContext(query: string): string;
+    /**
+     * Get full code context with self-model
+     */
+    getFullContext(query: string): Promise<CodeContext>;
+    /**
+     * Get the self-model (architecture overview)
+     */
+    getSelfModel(): Promise<SelfModel>;
+    /**
+     * Get index statistics
+     */
+    getStats(): {
+        totalFiles: number;
+        totalChunks: number;
+        totalLines: number;
+        byType: Record<string, number>;
+    } | null;
+    /**
+     * Check if indexed
+     */
+    isReady(): boolean;
+    /**
+     * Force re-index
+     */
+    reindex(): Promise<void>;
+}
+export declare function getSelfKnowledge(config?: Partial<SelfKnowledgeConfig>): SelfKnowledge;
+export declare function resetSelfKnowledge(): void;

package/dist/src/brain/self-knowledge.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * Genesis v13.1 - Self-Knowledge Module
+ *
+ * Gives the Brain awareness of its own source code.
+ * Uses CodeRAG for keyword-based retrieval (no API keys needed).
+ *
+ * Architecture:
+ *   boot() → index src/ → cache to .genesis/code-index.json
+ *   query(text) → keyword search → relevant CodeChunks
+ *   getContext(query) → formatted string for Brain context injection
+ *
+ * The Brain's stepMemory() calls this when the query relates to
+ * Genesis's own architecture, code, or capabilities.
+ */
+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.SelfKnowledge = void 0;
+exports.isCodeQuery = isCodeQuery;
+exports.getSelfKnowledge = getSelfKnowledge;
+exports.resetSelfKnowledge = resetSelfKnowledge;
+const code_rag_js_1 = require("../self-modification/code-rag.js");
+const self_model_js_1 = require("../self-modification/self-model.js");
+const path = __importStar(require("path"));
+// __dirname at runtime: <project>/dist/src/brain
+// We need: <project>/ (where src/ lives)
+const PROJECT_ROOT = path.resolve(__dirname, '../../../');
+const DEFAULT_CONFIG = {
+    rootPath: PROJECT_ROOT,
+    maxContextChunks: 8,
+    maxContextChars: 3000,
+    autoIndex: true,
+    cacheDir: '.genesis/code-index',
+};
+// ============================================================================
+// Code-awareness heuristics
+// ============================================================================
+const CODE_QUERY_PATTERNS = [
+    // Direct self-reference
+    /\b(tuo|tua|tuoi|tue)\s+(codice|sorgente|architettura|kernel|modulo|classe|funzione)/i,
+    /\b(your|its)\s+(code|source|architecture|kernel|module|class|function)/i,
+    /\b(come|how)\s+(funzion|work|implement)/i,
+    /\b(genesis|brain|kernel|fek|fiber|ness|contraction|leapfrog|fisher)\b/i,
+    // Architecture questions
+    /\b(architettura|architecture|struttura|structure|design)\b/i,
+    /\b(moduli|modules|subsystem|layer|componenti|components)\b/i,
+    // Self-awareness
+    /\b(te\s+stess|yourself|self-knowledge|self-aware|autopoie)/i,
+    /\b(cosa\s+(sei|fai|puoi)|what\s+(are you|can you|do you))\b/i,
+    // Code inspection
+    /\b(src\/|\.ts\b|import|export|class\s+\w|interface\s+\w|function\s+\w)/i,
+    /\b(implementa|implement|codice|code|sorgente|source)\b/i,
+];
+/**
+ * Detect if a query is about Genesis's own code/architecture
+ */
+function isCodeQuery(query) {
+    return CODE_QUERY_PATTERNS.some(p => p.test(query));
+}
+// ============================================================================
+// SelfKnowledge class
+// ============================================================================
+class SelfKnowledge {
+    config;
+    codeRAG;
+    selfModelGen;
+    indexed = false;
+    selfModel = null;
+    bootPromise = null;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        const rootPath = this.config.rootPath;
+        const srcPath = path.join(rootPath, 'src');
+        this.codeRAG = (0, code_rag_js_1.getCodeRAG)({
+            rootPath: srcPath,
+            useEmbeddings: false, // Keyword-only, no API needed
+            cacheEmbeddings: false,
+            cachePath: path.join(rootPath, this.config.cacheDir),
+            includePatterns: ['**/*.ts'],
+            excludePatterns: ['**/node_modules/**', '**/dist/**', '**/*.test.ts', '**/*.d.ts'],
+        });
+        this.selfModelGen = (0, self_model_js_1.getSelfModelGenerator)();
+    }
+    /**
+     * Boot: index the codebase (or load from cache)
+     * Called once when brain starts. Non-blocking if already cached.
+     */
+    async boot() {
+        if (this.indexed)
+            return;
+        if (this.bootPromise)
+            return this.bootPromise;
+        this.bootPromise = this._doBoot();
+        return this.bootPromise;
+    }
+    async _doBoot() {
+        try {
+            // Try loading cached index first
+            const loaded = await this.codeRAG.loadIndex();
+            if (loaded) {
+                this.indexed = true;
+                return;
+            }
+            // Build fresh index (keyword-only, fast)
+            if (this.config.autoIndex) {
+                await this.codeRAG.buildIndex();
+                await this.codeRAG.saveIndex();
+                this.indexed = true;
+            }
+        }
+        catch (error) {
+            // Non-fatal — brain works without self-knowledge
+            console.warn(`[SelfKnowledge] Boot failed: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    /**
+     * Query the codebase for relevant chunks
+     */
+    query(queryText, topK) {
+        if (!this.indexed)
+            return [];
+        return this.codeRAG.query(queryText, topK || this.config.maxContextChunks);
+    }
+    /**
+     * Get formatted context string for brain injection
+     * Returns empty string if query isn't code-related or index unavailable
+     */
+    getContext(query) {
+        if (!this.indexed)
+            return '';
+        if (!isCodeQuery(query))
+            return '';
+        const results = this.query(query);
+        if (results.length === 0)
+            return '';
+        // Format results for context
+        let context = '[self-knowledge] Genesis source code relevant to query:\n';
+        let chars = context.length;
+        for (const result of results) {
+            const chunk = result.chunk;
+            const entry = `  ${chunk.type} ${chunk.name} (${chunk.relativePath}:${chunk.startLine}):\n` +
+                `    ${chunk.content.slice(0, 200).replace(/\n/g, '\n    ')}\n`;
+            if (chars + entry.length > this.config.maxContextChars)
+                break;
+            context += entry;
+            chars += entry.length;
+        }
+        return context;
+    }
+    /**
+     * Get full code context with self-model
+     */
+    async getFullContext(query) {
+        if (!this.indexed) {
+            await this.boot();
+        }
+        const chunks = this.query(query);
+        const summary = this.codeRAG.getSummary();
+        const formatted = this.getContext(query);
+        return { chunks, summary, formatted };
+    }
+    /**
+     * Get the self-model (architecture overview)
+     */
+    async getSelfModel() {
+        if (!this.selfModel) {
+            this.selfModel = await this.selfModelGen.generate();
+        }
+        return this.selfModel;
+    }
+    /**
+     * Get index statistics
+     */
+    getStats() {
+        return this.codeRAG.getStats();
+    }
+    /**
+     * Check if indexed
+     */
+    isReady() {
+        return this.indexed;
+    }
+    /**
+     * Force re-index
+     */
+    async reindex() {
+        this.indexed = false;
+        await this.codeRAG.buildIndex();
+        await this.codeRAG.saveIndex();
+        this.indexed = true;
+    }
+}
+exports.SelfKnowledge = SelfKnowledge;
+// ============================================================================
+// Singleton
+// ============================================================================
+let instance = null;
+function getSelfKnowledge(config) {
+    if (!instance) {
+        instance = new SelfKnowledge(config);
+    }
+    return instance;
+}
+function resetSelfKnowledge() {
+    instance = null;
+}

package/dist/src/cli/chat.js

@@ -954,6 +954,52 @@ INSTRUCTION: You MUST report this error to the user. Do NOT fabricate or guess w
                     console.log((0, ui_js_1.error)(`Consolidation error: ${err instanceof Error ? err.message : err}`));
                 });
                 break;
+            // v13.1: Self-knowledge (code awareness)
+            case 'code':
+            case 'codice': // Italian
+                if (args.length > 0) {
+                    const codeQuery = args.join(' ');
+                    const sk = this.brain.getSelfKnowledge();
+                    if (!sk.isReady()) {
+                        console.log((0, ui_js_1.info)('Indexing source code...'));
+                        await sk.boot();
+                    }
+                    const results = sk.query(codeQuery, 5);
+                    if (results.length === 0) {
+                        console.log((0, ui_js_1.warning)(`No code found for: "${codeQuery}"`));
+                    }
+                    else {
+                        console.log((0, ui_js_1.c)(`Code results for "${codeQuery}":`, 'bold'));
+                        for (const r of results) {
+                            const chunk = r.chunk;
+                            console.log(`  ${(0, ui_js_1.c)(chunk.type, 'cyan')} ${(0, ui_js_1.c)(chunk.name, 'green')} (${(0, ui_js_1.muted)(chunk.relativePath + ':' + chunk.startLine)})`);
+                            const preview = chunk.content.split('\n').slice(0, 3).join('\n    ');
+                            console.log(`    ${(0, ui_js_1.muted)(preview)}`);
+                            console.log();
+                        }
+                    }
+                }
+                else {
+                    const sk = this.brain.getSelfKnowledge();
+                    if (!sk.isReady()) {
+                        console.log((0, ui_js_1.info)('Indexing source code...'));
+                        await sk.boot();
+                    }
+                    const stats = sk.getStats();
+                    if (stats) {
+                        console.log((0, ui_js_1.c)('Self-Knowledge Status:', 'bold'));
+                        console.log(`  Files indexed:  ${stats.totalFiles}`);
+                        console.log(`  Code chunks:    ${stats.totalChunks}`);
+                        console.log(`  Total lines:    ${stats.totalLines}`);
+                        console.log(`  Types:          ${Object.entries(stats.byType).map(([t, n]) => `${t}:${n}`).join(', ')}`);
+                        console.log((0, ui_js_1.muted)('\n  Usage: /code <query> — search own source code'));
+                    }
+                    else {
+                        console.log((0, ui_js_1.warning)('Self-knowledge not indexed yet.'));
+                    }
+                }
+                console.log();
+                break;
             // v7.0: Darwin-Gödel self-improvement commands
             case 'heal':
             case 'guarisci': // Italian
@@ -1554,6 +1600,7 @@ INSTRUCTION: You MUST report this error to the user. Do NOT fabricate or guess w
             console.log();
             console.log(`  ${(0, ui_js_1.style)('/brain', 'yellow')}       Brain integration on/off`);
             console.log(`  ${(0, ui_js_1.style)('/memory', 'yellow')}      Stato memoria`);
+            console.log(`  ${(0, ui_js_1.style)('/code', 'yellow')}        Cerca nel proprio codice sorgente`);
             console.log(`  ${(0, ui_js_1.style)('/phi', 'yellow')}         Livello coscienza (φ)`);
             console.log(`  ${(0, ui_js_1.style)('/improve', 'yellow')}     Auto-miglioramento`);
             console.log(`  ${(0, ui_js_1.style)('/task', 'yellow')}        Esegui subagent`);

package/dist/src/genesis.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Genesis v13.0 — Unified Bootstrap Layer
+ *
+ * Hierarchical boot (L1→L4), inter-module wiring, and unified process/query interface.
+ * Connects all 49 modules into a coherent organism:
+ *
+ *   L1: Persistence, FEK (autonomic substrate)
+ *   L2: Memory, Active Inference, Kernel, Economic Fiber
+ *   L3: Brain, Causal Reasoning, Perception
+ *   L4: Metacognition (MUSE), NESS Monitor, Darwin-Gödel
+ *
+ * Each level boots only after its predecessor is healthy.
+ */
+import { type FEKState, type FEKStatus } from './kernel/free-energy-kernel.js';
+import { type Effect, type CounterfactualResult, type Intervention, type CausalExplanation } from './causal/index.js';
+import { type ConfidenceEstimate, type ThoughtAudit } from './metacognition/index.js';
+import { type EconomicFiber } from './economy/fiber.js';
+import { type NESSState } from './economy/ness.js';
+import { type ModalityInput, type PerceptionOutput } from './perception/multi-modal.js';
+import { type CurriculumState } from './learning/meta-rl.js';
+import { type CodeRuntime } from './execution/index.js';
+export interface GenesisConfig {
+    /** Budget per FEK level (total = sum) */
+    totalBudget: number;
+    /** Enable causal reasoning */
+    causal: boolean;
+    /** Enable metacognition (MUSE) */
+    metacognition: boolean;
+    /** Enable NESS economic monitoring */
+    ness: boolean;
+    /** Enable multi-modal perception */
+    perception: boolean;
+    /** Enable meta-RL learning */
+    metaRL: boolean;
+    /** Enable code execution runtime */
+    execution: boolean;
+    /** Confidence threshold below which Brain defers to metacognition */
+    deferThreshold: number;
+    /** Audit all responses for hallucinations */
+    auditResponses: boolean;
+}
+export interface GenesisStatus {
+    booted: boolean;
+    levels: {
+        L1: boolean;
+        L2: boolean;
+        L3: boolean;
+        L4: boolean;
+    };
+    fek: FEKStatus | null;
+    brain: {
+        running: boolean;
+        phi: number;
+    } | null;
+    causal: {
+        graphSize: number;
+    } | null;
+    metacognition: {
+        confidence: number;
+        calibrationError: number;
+    } | null;
+    perception: boolean;
+    metaRL: {
+        curriculumSize: number;
+    } | null;
+    execution: boolean;
+    ness: NESSState | null;
+    fiber: {
+        netFlow: number;
+        sustainable: boolean;
+    } | null;
+    uptime: number;
+    cycleCount: number;
+}
+export interface ProcessResult {
+    response: string;
+    confidence: ConfidenceEstimate | null;
+    audit: ThoughtAudit | null;
+    cost: number;
+    fekState: FEKState | null;
+}
+export declare class Genesis {
+    private config;
+    private fek;
+    private brain;
+    private economy;
+    private fiber;
+    private causal;
+    private perception;
+    private codeRuntime;
+    private metacognition;
+    private nessMonitor;
+    private lastNESSState;
+    private metaRL;
+    private booted;
+    private bootTime;
+    private levels;
+    private cycleCount;
+    private performanceHistory;
+    constructor(config?: Partial<GenesisConfig>);
+    boot(): Promise<GenesisStatus>;
+    private bootL1;
+    private bootL2;
+    private bootL3;
+    private bootL4;
+    /**
+     * Process an input through the full Genesis stack:
+     * 1. Metacognition pre-check (should we defer?)
+     * 2. Brain processes query
+     * 3. Metacognition audits response
+     * 4. Causal reasoning (if errors detected)
+     * 5. FEK cycle with observations
+     * 6. NESS + Fiber economic tracking
+     */
+    process(input: string): Promise<ProcessResult>;
+    /**
+     * Estimate causal effect: P(outcome | do(treatment = value))
+     */
+    causalEffect(treatment: string, treatmentValue: unknown, outcome: string): Effect | null;
+    /**
+     * Counterfactual: "What would outcome have been if intervention had occurred?"
+     */
+    whatIf(factual: Record<string, unknown>, intervention: Intervention, outcome: string): CounterfactualResult | null;
+    /**
+     * Diagnose a failure using causal reasoning
+     */
+    diagnoseFailure(failure: Error, observedState: Record<string, unknown>): CausalExplanation | null;
+    /**
+     * Evaluate reasoning quality
+     */
+    evaluateReasoning(reasoning: string, context?: string[]): number | null;
+    /**
+     * Provide outcome feedback for calibration
+     */
+    feedback(success: boolean): void;
+    /**
+     * Get Expected Calibration Error (ECE)
+     */
+    getCalibrationError(): number;
+    /**
+     * Process multi-modal inputs (visual, audio, proprioceptive)
+     */
+    perceive(inputs: ModalityInput[], timestamp?: number): PerceptionOutput | null;
+    /**
+     * Get current curriculum state
+     */
+    getCurriculum(): CurriculumState | null;
+    /**
+     * Report task outcome to meta-RL for curriculum learning
+     */
+    reportTaskOutcome(taskId: string, success: boolean, stepsUsed: number): void;
+    /**
+     * Get the code execution runtime
+     */
+    getCodeRuntime(): CodeRuntime | null;
+    /**
+     * Record revenue from an external source
+     */
+    recordRevenue(moduleId: string, amount: number, source: string): void;
+    /**
+     * Get economic health
+     */
+    getEconomicHealth(): {
+        fiber: ReturnType<EconomicFiber['getGlobalSection']> | null;
+        ness: NESSState | null;
+    };
+    getStatus(): GenesisStatus;
+    /**
+     * Graceful shutdown: L4→L1
+     */
+    shutdown(): Promise<void>;
+    private inferDomain;
+}
+export declare function createGenesis(config?: Partial<GenesisConfig>): Genesis;
+export declare function getGenesis(config?: Partial<GenesisConfig>): Genesis;
+export declare function resetGenesis(): void;
+export default Genesis;

package/dist/src/genesis.js

@@ -0,0 +1,452 @@
+"use strict";
+/**
+ * Genesis v13.0 — Unified Bootstrap Layer
+ *
+ * Hierarchical boot (L1→L4), inter-module wiring, and unified process/query interface.
+ * Connects all 49 modules into a coherent organism:
+ *
+ *   L1: Persistence, FEK (autonomic substrate)
+ *   L2: Memory, Active Inference, Kernel, Economic Fiber
+ *   L3: Brain, Causal Reasoning, Perception
+ *   L4: Metacognition (MUSE), NESS Monitor, Darwin-Gödel
+ *
+ * Each level boots only after its predecessor is healthy.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Genesis = void 0;
+exports.createGenesis = createGenesis;
+exports.getGenesis = getGenesis;
+exports.resetGenesis = resetGenesis;
+const free_energy_kernel_js_1 = require("./kernel/free-energy-kernel.js");
+const index_js_1 = require("./brain/index.js");
+const index_js_2 = require("./causal/index.js");
+const index_js_3 = require("./metacognition/index.js");
+const index_js_4 = require("./economy/index.js");
+const fiber_js_1 = require("./economy/fiber.js");
+const ness_js_1 = require("./economy/ness.js");
+const multi_modal_js_1 = require("./perception/multi-modal.js");
+const meta_rl_js_1 = require("./learning/meta-rl.js");
+const index_js_5 = require("./execution/index.js");
+// ============================================================================
+// Genesis Core
+// ============================================================================
+class Genesis {
+    config;
+    // L1: Substrate
+    fek = null;
+    // L2: Reactive
+    brain = null;
+    economy = null;
+    fiber = null;
+    // L3: Cognitive
+    causal = null;
+    perception = null;
+    codeRuntime = null;
+    // L4: Executive
+    metacognition = null;
+    nessMonitor = null;
+    lastNESSState = null;
+    metaRL = null;
+    // State
+    booted = false;
+    bootTime = 0;
+    levels = { L1: false, L2: false, L3: false, L4: false };
+    cycleCount = 0;
+    performanceHistory = [];
+    constructor(config) {
+        this.config = {
+            totalBudget: 100,
+            causal: true,
+            metacognition: true,
+            ness: true,
+            perception: true,
+            metaRL: true,
+            execution: true,
+            deferThreshold: 0.3,
+            auditResponses: true,
+            ...config,
+        };
+    }
+    // ==========================================================================
+    // Boot Sequence
+    // ==========================================================================
+    async boot() {
+        this.bootTime = Date.now();
+        // L1: Autonomic substrate
+        await this.bootL1();
+        // L2: Reactive layer
+        await this.bootL2();
+        // L3: Cognitive layer
+        await this.bootL3();
+        // L4: Executive layer
+        await this.bootL4();
+        this.booted = true;
+        return this.getStatus();
+    }
+    async bootL1() {
+        // Free Energy Kernel — the core autonomic loop
+        this.fek = (0, free_energy_kernel_js_1.getFreeEnergyKernel)();
+        this.fek.start();
+        this.levels.L1 = true;
+    }
+    async bootL2() {
+        if (!this.levels.L1)
+            throw new Error('L1 must boot before L2');
+        // Brain — the main cognitive processor
+        this.brain = (0, index_js_1.getBrain)();
+        // Economic systems
+        this.economy = (0, index_js_4.getEconomicSystem)({
+            dailyLimit: this.config.totalBudget,
+            monthlyLimit: this.config.totalBudget * 30,
+            perTransactionLimit: this.config.totalBudget * 0.5,
+            requireApprovalAbove: this.config.totalBudget * 0.5,
+        });
+        await this.economy.initialize();
+        this.fiber = (0, fiber_js_1.getEconomicFiber)(this.config.totalBudget);
+        this.fiber.registerModule('genesis');
+        this.fiber.registerModule('brain');
+        this.fiber.registerModule('causal');
+        this.fiber.registerModule('metacognition');
+        this.fiber.registerModule('perception');
+        this.fiber.registerModule('metarl');
+        this.fiber.registerModule('execution');
+        this.levels.L2 = true;
+    }
+    async bootL3() {
+        if (!this.levels.L2)
+            throw new Error('L2 must boot before L3');
+        if (this.config.causal) {
+            // Causal reasoning with standard agent model
+            this.causal = (0, index_js_2.createAgentCausalModel)();
+            // Wire FEK prediction errors to causal diagnosis
+            if (this.fek) {
+                this.fek.onPredictionError((error) => {
+                    if (this.causal) {
+                        this.causal.diagnoseFailure(new Error(error.content), { source: error.source, target: error.target, magnitude: error.magnitude });
+                    }
+                });
+            }
+        }
+        if (this.config.perception) {
+            this.perception = (0, multi_modal_js_1.createMultiModalPerception)();
+        }
+        if (this.config.execution) {
+            this.codeRuntime = (0, index_js_5.getCodeRuntime)();
+        }
+        this.levels.L3 = true;
+    }
+    async bootL4() {
+        if (!this.levels.L3)
+            throw new Error('L3 must boot before L4');
+        if (this.config.metacognition) {
+            this.metacognition = (0, index_js_3.createMetacognitionSystem)();
+        }
+        if (this.config.ness) {
+            this.nessMonitor = (0, ness_js_1.getNESSMonitor)();
+        }
+        if (this.config.metaRL) {
+            this.metaRL = (0, meta_rl_js_1.createMetaRLLearner)({
+                innerLearningRate: 0.01,
+                outerLearningRate: 0.001,
+                adaptationWindow: 50,
+            });
+        }
+        this.levels.L4 = true;
+    }
+    // ==========================================================================
+    // Main Processing Pipeline
+    // ==========================================================================
+    /**
+     * Process an input through the full Genesis stack:
+     * 1. Metacognition pre-check (should we defer?)
+     * 2. Brain processes query
+     * 3. Metacognition audits response
+     * 4. Causal reasoning (if errors detected)
+     * 5. FEK cycle with observations
+     * 6. NESS + Fiber economic tracking
+     */
+    async process(input) {
+        if (!this.booted)
+            await this.boot();
+        this.cycleCount++;
+        const startTime = Date.now();
+        let confidence = null;
+        let audit = null;
+        // Step 1: Metacognitive pre-check
+        if (this.metacognition) {
+            const domain = this.inferDomain(input);
+            if (this.metacognition.shouldDefer(domain)) {
+                // Low competence — still process but flag it
+                confidence = this.metacognition.getConfidence(0.3, domain);
+            }
+        }
+        // Step 2: Brain processes
+        let response = '';
+        if (this.brain) {
+            response = await this.brain.process(input);
+        }
+        // Step 3: Metacognitive audit
+        if (this.metacognition && this.config.auditResponses && response) {
+            audit = this.metacognition.auditThought(response);
+            // Get calibrated confidence
+            const domain = this.inferDomain(input);
+            const rawConfidence = audit.coherence * 0.5 + audit.groundedness * 0.5;
+            confidence = this.metacognition.getConfidence(rawConfidence, domain);
+        }
+        // Step 4: FEK cycle
+        let fekState = null;
+        if (this.fek) {
+            fekState = this.fek.cycle({
+                energy: 1.0,
+                agentResponsive: true,
+                merkleValid: true,
+                systemLoad: this.cycleCount / 100,
+                phi: confidence?.value,
+            });
+        }
+        // Step 5: Economic tracking
+        const elapsed = Date.now() - startTime;
+        const cost = elapsed * 0.001; // Rough cost proxy: $0.001 per ms
+        if (this.fiber) {
+            this.fiber.recordCost('brain', cost, 'process');
+        }
+        if (this.nessMonitor && this.fiber) {
+            const section = this.fiber.getGlobalSection();
+            this.lastNESSState = this.nessMonitor.observe({
+                revenue: section.totalRevenue,
+                costs: section.totalCosts,
+                customers: 1,
+                quality: confidence?.value ?? 0.8,
+                balance: section.netFlow,
+            });
+        }
+        // Track for calibration
+        if (confidence) {
+            this.performanceHistory.push({
+                predicted: confidence.value,
+                actual: true, // Updated externally via feedback()
+            });
+        }
+        return { response, confidence, audit, cost, fekState };
+    }
+    // ==========================================================================
+    // Causal Reasoning Interface
+    // ==========================================================================
+    /**
+     * Estimate causal effect: P(outcome | do(treatment = value))
+     */
+    causalEffect(treatment, treatmentValue, outcome) {
+        if (!this.causal)
+            return null;
+        return this.causal.estimateEffect(treatment, treatmentValue, outcome);
+    }
+    /**
+     * Counterfactual: "What would outcome have been if intervention had occurred?"
+     */
+    whatIf(factual, intervention, outcome) {
+        if (!this.causal)
+            return null;
+        return this.causal.whatIf(factual, intervention, outcome);
+    }
+    /**
+     * Diagnose a failure using causal reasoning
+     */
+    diagnoseFailure(failure, observedState) {
+        if (!this.causal)
+            return null;
+        return this.causal.diagnoseFailure(failure, observedState);
+    }
+    // ==========================================================================
+    // Metacognitive Interface
+    // ==========================================================================
+    /**
+     * Evaluate reasoning quality
+     */
+    evaluateReasoning(reasoning, context) {
+        if (!this.metacognition)
+            return null;
+        return this.metacognition.evaluateReasoning(reasoning, context);
+    }
+    /**
+     * Provide outcome feedback for calibration
+     */
+    feedback(success) {
+        if (this.performanceHistory.length > 0) {
+            this.performanceHistory[this.performanceHistory.length - 1].actual = success;
+        }
+        if (this.metacognition) {
+            const domain = 'general';
+            const predicted = this.performanceHistory.length > 0
+                ? this.performanceHistory[this.performanceHistory.length - 1].predicted
+                : 0.5;
+            this.metacognition.updateFromOutcome(domain, success, predicted);
+        }
+    }
+    /**
+     * Get Expected Calibration Error (ECE)
+     */
+    getCalibrationError() {
+        if (this.performanceHistory.length < 10)
+            return 0;
+        // Bin predictions into 10 buckets, compute |avg_predicted - avg_actual| per bin
+        const bins = Array.from({ length: 10 }, () => ({ predicted: 0, actual: 0, count: 0 }));
+        for (const entry of this.performanceHistory) {
+            const binIdx = Math.min(9, Math.floor(entry.predicted * 10));
+            bins[binIdx].predicted += entry.predicted;
+            bins[binIdx].actual += entry.actual ? 1 : 0;
+            bins[binIdx].count++;
+        }
+        let ece = 0;
+        const total = this.performanceHistory.length;
+        for (const bin of bins) {
+            if (bin.count === 0)
+                continue;
+            const avgPredicted = bin.predicted / bin.count;
+            const avgActual = bin.actual / bin.count;
+            ece += (bin.count / total) * Math.abs(avgPredicted - avgActual);
+        }
+        return ece;
+    }
+    // ==========================================================================
+    // Perception Interface
+    // ==========================================================================
+    /**
+     * Process multi-modal inputs (visual, audio, proprioceptive)
+     */
+    perceive(inputs, timestamp) {
+        if (!this.perception)
+            return null;
+        const output = this.perception.perceive(inputs, timestamp);
+        if (this.fiber) {
+            this.fiber.recordCost('perception', 0.01 * inputs.length, 'perceive');
+        }
+        return output;
+    }
+    // ==========================================================================
+    // Meta-RL Interface
+    // ==========================================================================
+    /**
+     * Get current curriculum state
+     */
+    getCurriculum() {
+        if (!this.metaRL)
+            return null;
+        return this.metaRL.getCurriculum();
+    }
+    /**
+     * Report task outcome to meta-RL for curriculum learning
+     */
+    reportTaskOutcome(taskId, success, stepsUsed) {
+        if (this.metaRL) {
+            this.metaRL.updateCurriculum(taskId, success, stepsUsed);
+        }
+    }
+    // ==========================================================================
+    // Code Execution Interface
+    // ==========================================================================
+    /**
+     * Get the code execution runtime
+     */
+    getCodeRuntime() {
+        return this.codeRuntime;
+    }
+    // ==========================================================================
+    // Economic Interface
+    // ==========================================================================
+    /**
+     * Record revenue from an external source
+     */
+    recordRevenue(moduleId, amount, source) {
+        if (this.fiber) {
+            this.fiber.recordRevenue(moduleId, amount, source);
+        }
+        if (this.fek) {
+            this.fek.recordRevenue(moduleId, amount, source);
+        }
+    }
+    /**
+     * Get economic health
+     */
+    getEconomicHealth() {
+        return {
+            fiber: this.fiber?.getGlobalSection() ?? null,
+            ness: this.lastNESSState,
+        };
+    }
+    // ==========================================================================
+    // Status & Introspection
+    // ==========================================================================
+    getStatus() {
+        const fekStatus = this.fek?.getStatus() ?? null;
+        const brainStatus = this.brain?.getStatus();
+        const metacogState = this.metacognition?.getState();
+        const fiberSection = this.fiber?.getGlobalSection();
+        const nessState = this.lastNESSState;
+        const causalGraph = this.causal?.getGraph();
+        const curriculum = this.metaRL?.getCurriculum();
+        return {
+            booted: this.booted,
+            levels: { ...this.levels },
+            fek: fekStatus,
+            brain: brainStatus ? { running: brainStatus.running, phi: brainStatus.phi } : null,
+            causal: causalGraph ? { graphSize: causalGraph.variables?.size ?? 0 } : null,
+            metacognition: metacogState ? {
+                confidence: metacogState.currentConfidence.value,
+                calibrationError: metacogState.currentConfidence.calibrationError,
+            } : null,
+            perception: this.perception !== null,
+            metaRL: curriculum ? { curriculumSize: curriculum.taskHistory.length } : null,
+            execution: this.codeRuntime !== null,
+            ness: nessState,
+            fiber: fiberSection ? { netFlow: fiberSection.netFlow, sustainable: fiberSection.sustainable } : null,
+            uptime: this.bootTime > 0 ? Date.now() - this.bootTime : 0,
+            cycleCount: this.cycleCount,
+        };
+    }
+    /**
+     * Graceful shutdown: L4→L1
+     */
+    async shutdown() {
+        if (this.fek) {
+            this.fek.stop();
+        }
+        this.booted = false;
+        this.levels = { L1: false, L2: false, L3: false, L4: false };
+    }
+    // ==========================================================================
+    // Helpers
+    // ==========================================================================
+    inferDomain(input) {
+        const lower = input.toLowerCase();
+        if (lower.includes('code') || lower.includes('function') || lower.includes('bug'))
+            return 'coding';
+        if (lower.includes('math') || lower.includes('calcul') || lower.includes('equat'))
+            return 'math';
+        if (lower.includes('deploy') || lower.includes('server') || lower.includes('infra'))
+            return 'infrastructure';
+        if (lower.includes('money') || lower.includes('pay') || lower.includes('budget'))
+            return 'economics';
+        return 'general';
+    }
+}
+exports.Genesis = Genesis;
+// ============================================================================
+// Factory & Singleton
+// ============================================================================
+let genesisInstance = null;
+function createGenesis(config) {
+    return new Genesis(config);
+}
+function getGenesis(config) {
+    if (!genesisInstance) {
+        genesisInstance = new Genesis(config);
+    }
+    return genesisInstance;
+}
+function resetGenesis() {
+    if (genesisInstance) {
+        genesisInstance.shutdown();
+    }
+    genesisInstance = null;
+}
+exports.default = Genesis;

package/dist/src/index.js

@@ -81,6 +81,7 @@ const index_js_5 = require("./brain/index.js");
 const index_js_6 = require("./autonomous/index.js");
 const code_quality_analyzer_js_1 = require("./self-modification/code-quality-analyzer.js");
 const index_js_7 = require("./integration/index.js");
+const genesis_js_1 = require("./genesis.js");
 // ============================================================================
 // CLI Colors
 // ============================================================================
@@ -159,6 +160,26 @@ async function cmdStatus() {
     console.log(`  Checks performed: ${state.governanceChecks}`);
     console.log(c('\n[A2A]', 'green'));
     console.log(`  Delegations: ${state.a2aDelegations}`);
+    // v13.0: Genesis unified system status
+    console.log(c('\n=== GENESIS CORE ===\n', 'bold'));
+    const genesis = (0, genesis_js_1.getGenesis)();
+    const gStatus = genesis.getStatus();
+    const lvl = (b) => b ? c('●', 'green') : c('○', 'red');
+    console.log(c('[LEVELS]', 'cyan'));
+    console.log(`  ${lvl(gStatus.levels.L1)} L1 Autonomic   ${lvl(gStatus.levels.L2)} L2 Reactive   ${lvl(gStatus.levels.L3)} L3 Cognitive   ${lvl(gStatus.levels.L4)} L4 Executive`);
+    console.log(c('\n[MODULES]', 'magenta'));
+    console.log(`  FEK: ${gStatus.fek ? `running, ${gStatus.fek.cycleCount} cycles, FE=${gStatus.fek.totalFE.toFixed(3)}` : 'offline'}`);
+    console.log(`  Brain: ${gStatus.brain ? `phi=${gStatus.brain.phi.toFixed(3)}` : 'offline'}`);
+    console.log(`  Causal: ${gStatus.causal ? `${gStatus.causal.graphSize} variables` : 'disabled'}`);
+    console.log(`  Metacognition: ${gStatus.metacognition ? `conf=${gStatus.metacognition.confidence.toFixed(2)}, ECE=${gStatus.metacognition.calibrationError.toFixed(3)}` : 'disabled'}`);
+    console.log(`  Perception: ${gStatus.perception ? 'active' : 'disabled'}`);
+    console.log(`  Meta-RL: ${gStatus.metaRL ? `${gStatus.metaRL.curriculumSize} tasks learned` : 'disabled'}`);
+    console.log(`  Execution: ${gStatus.execution ? 'active' : 'disabled'}`);
+    if (gStatus.fiber) {
+        console.log(c('\n[ECONOMICS]', 'yellow'));
+        console.log(`  Net flow: $${gStatus.fiber.netFlow.toFixed(4)}/cycle`);
+        console.log(`  Sustainable: ${gStatus.fiber.sustainable ? c('yes', 'green') : c('no', 'red')}`);
+    }
     console.log();
 }
 async function cmdCreate(name, options) {

package/package.json

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