genesis-ai-cli 13.0.0 → 13.2.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/active-inference/actions.js

@@ -290,17 +290,68 @@ registerAction('verify.ethics', async (context) => {
 });
 /**
  * execute.task: Execute the planned task
+ * v13.1: Closes the autopoietic execution loop by routing through Brain.process()
  */
+let _executeTaskDepth = 0;
+const MAX_EXECUTE_DEPTH = 2; // Prevent infinite recursion (AIF → brain → AIF → brain)
 registerAction('execute.task', async (context) => {
-    return {
-        success: true,
-        action: 'execute.task',
-        data: {
-            taskId: context.taskId,
-            result: null,
-        },
-        duration: 0,
-    };
+    const start = Date.now();
+    // Re-entrancy guard: prevent recursive brain.process() calls
+    if (_executeTaskDepth >= MAX_EXECUTE_DEPTH) {
+        return {
+            success: false,
+            action: 'execute.task',
+            error: `Execution depth limit (${MAX_EXECUTE_DEPTH}) reached — preventing recursion`,
+            duration: Date.now() - start,
+        };
+    }
+    _executeTaskDepth++;
+    try {
+        // Dynamic import to avoid circular dependency (brain → actions → brain)
+        const { getBrainInstance } = await import('../brain/index.js');
+        const brain = getBrainInstance();
+        if (!brain) {
+            return {
+                success: false,
+                action: 'execute.task',
+                error: 'Brain not initialized — cannot execute task',
+                duration: Date.now() - start,
+            };
+        }
+        const goal = context.goal || context.parameters?.goal || '';
+        if (!goal) {
+            return {
+                success: false,
+                action: 'execute.task',
+                error: 'No goal specified for task execution',
+                duration: Date.now() - start,
+            };
+        }
+        // Route through Brain's full processing pipeline (memory → LLM → tools → response)
+        const result = await brain.process(goal);
+        return {
+            success: true,
+            action: 'execute.task',
+            data: {
+                taskId: context.taskId,
+                goal,
+                result,
+                truncated: result.length > 500,
+            },
+            duration: Date.now() - start,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            action: 'execute.task',
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+        };
+    }
+    finally {
+        _executeTaskDepth--;
+    }
 });
 /**
  * execute.cycle: Run a processing cycle

package/dist/src/active-inference/autonomous-loop.js

@@ -575,12 +575,28 @@ class AutonomousLoop {
             const avgS = highSurprise.reduce((s, e) => s + e.surprise, 0) / highSurprise.length;
             console.log(`[AI Loop] Dream: ${highSurprise.length} experiences, avg surprise ${avgS.toFixed(2)}`);
         }
+        // v13.1: Notify FEK to enter dreaming mode (suppresses L2-L4 during consolidation)
+        try {
+            const { getFreeEnergyKernel } = require('../kernel/free-energy-kernel.js');
+            const fek = getFreeEnergyKernel();
+            if (fek?.setMode)
+                fek.setMode('dreaming');
+        }
+        catch { /* FEK may not be available */ }
         // v11.4: Delegate to DreamService for NREM/SWS/REM phases
         // DreamService handles: episodic consolidation, pattern extraction, creative synthesis
         this.dreamService.startDream({ duration: 3000 }).then(session => {
             if (this.config.verbose && session?.results) {
                 console.log(`[AI Loop] Dream complete: ${session.results.memoriesConsolidated} consolidated, ${session.results.patternsExtracted} patterns`);
             }
+            // v13.1: Restore FEK to awake mode after dream
+            try {
+                const { getFreeEnergyKernel } = require('../kernel/free-energy-kernel.js');
+                const fek = getFreeEnergyKernel();
+                if (fek?.setMode)
+                    fek.setMode('awake');
+            }
+            catch { /* non-fatal */ }
         }).catch(() => {
             // Fallback: direct 3× replay if DreamService fails
             for (let iter = 0; iter < 3; iter++) {

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

@@ -190,6 +190,7 @@ export declare class EconomicIntegration {
 export declare function getEconomicIntegration(): EconomicIntegration;
 /**
  * Hook to record LLM costs (call this after each LLM request)
+ * v13.1: Also feeds real costs into EconomicFiber for FEK's leapfrog budget allocation
  */
 export declare function recordLLMCost(provider: string, inputTokens: number, outputTokens: number, model: string): void;
 /**

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

@@ -17,6 +17,7 @@ exports.getEconomicIntegration = getEconomicIntegration;
 exports.recordLLMCost = recordLLMCost;
 exports.recordRevenue = recordRevenue;
 const index_js_1 = require("../economy/index.js");
+const fiber_js_1 = require("../economy/fiber.js");
 // ============================================================================
 // Cost Tracker
 // ============================================================================
@@ -511,9 +512,32 @@ function getEconomicIntegration() {
 }
 /**
  * Hook to record LLM costs (call this after each LLM request)
+ * v13.1: Also feeds real costs into EconomicFiber for FEK's leapfrog budget allocation
  */
 function recordLLMCost(provider, inputTokens, outputTokens, model) {
-    getEconomicIntegration().getCostTracker().recordLLMCost(provider, inputTokens, outputTokens, model);
+    const tracker = getEconomicIntegration().getCostTracker();
+    tracker.recordLLMCost(provider, inputTokens, outputTokens, model);
+    // v13.1: Feed real cost into FEK's EconomicFiber (replaces synthetic $0.001/cycle)
+    // Recompute cost using same pricing as CostTracker
+    const pricing = {
+        'claude-3-opus': { input: 15, output: 75 },
+        'claude-3-sonnet': { input: 3, output: 15 },
+        'claude-3-haiku': { input: 0.25, output: 1.25 },
+        'claude-opus-4': { input: 15, output: 75 },
+        'claude-sonnet-4': { input: 3, output: 15 },
+        'gpt-4o': { input: 2.5, output: 10 },
+        'gpt-4o-mini': { input: 0.15, output: 0.6 },
+        'default': { input: 1, output: 4 },
+    };
+    const rates = pricing[model] || pricing['default'];
+    const realCost = (inputTokens / 1_000_000) * rates.input + (outputTokens / 1_000_000) * rates.output;
+    try {
+        const fiber = (0, fiber_js_1.getEconomicFiber)();
+        fiber.recordCost('llm', realCost, `${provider}:${model}`);
+    }
+    catch {
+        // Fiber may not be initialized yet during startup
+    }
 }
 /**
  * Hook to record revenue (call this when receiving payment)

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

@@ -55,12 +55,26 @@ class ObservationGatherer {
         if (this.realSourcesInitialized)
             return;
         this.realSourcesInitialized = true;
-        // Wire kernel state to process metrics
+        // Wire kernel state to process metrics + FEK total free energy
+        // v13.1: Incorporates FEK's hierarchical free energy as the primary energy signal
         this.getKernelState = () => {
             const mem = process.memoryUsage();
             const heapUsedRatio = mem.heapUsed / mem.heapTotal;
-            // Energy = inverse of resource pressure (more heap used = less energy)
-            const energy = Math.max(0, Math.min(1, 1 - heapUsedRatio));
+            const heapEnergy = Math.max(0, Math.min(1, 1 - heapUsedRatio));
+            // v13.1: Blend with FEK's total free energy (low FE = high energy/viability)
+            let fekEnergy = heapEnergy;
+            try {
+                const { getFreeEnergyKernel } = require('../kernel/free-energy-kernel.js');
+                const fek = getFreeEnergyKernel();
+                if (fek) {
+                    const totalFE = fek.getTotalFE?.() ?? 0;
+                    // Map FE to energy: FE=0 → energy=1.0, FE≥5 → energy=0.0
+                    fekEnergy = Math.max(0, Math.min(1, 1 - totalFE / 5));
+                }
+            }
+            catch { /* FEK may not be initialized */ }
+            // Blend: 30% heap pressure, 70% FEK free energy
+            const energy = 0.3 * heapEnergy + 0.7 * fekEnergy;
             return {
                 energy,
                 state: 'running',

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();
     }
@@ -275,6 +281,27 @@ class Brain {
                     data: { mode, prev, kernel: 'fek' },
                     module: 'consciousness',
                 });
+                // v13.1: Close the self-modification loop — when FEK L4 requests
+                // self_improving mode, trigger the DarwinGodel improvement engine
+                if (mode === 'self_improving' && prev !== 'self_improving' && this.darwinGodel) {
+                    import('../active-inference/actions.js').then(({ executeAction }) => {
+                        executeAction('improve.self', {
+                            parameters: { autoApply: false },
+                            beliefs: { viability: 0.5, worldState: 0.5, coupling: 0.5, goalProgress: 0.5 },
+                        }).then((result) => {
+                            this.emit({
+                                type: 'module_exit',
+                                timestamp: new Date(),
+                                data: {
+                                    type: 'fek_self_improvement',
+                                    success: result.success,
+                                    opportunities: result.data?.opportunities?.length || 0,
+                                },
+                                module: 'consciousness',
+                            });
+                        }).catch(() => { });
+                    }).catch(() => { });
+                }
             });
         }
         catch {
@@ -737,6 +764,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 +1152,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 +2344,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 +2508,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;
+}