closed-loop-cli 1.0.3 → 1.0.4

package/dist/orchestrator/autogenesis.js

@@ -1,973 +0,0 @@
-"use strict";
-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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AutogenesisEngine = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const child_process_1 = require("child_process");
-const shell_tools_1 = require("../tools/shell-tools");
-const meta_agent_1 = require("./meta-agent");
-const tui_tools_1 = require("../tools/tui-tools");
-const repo_map_1 = require("../tools/repo-map");
-const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
-const dotenv = __importStar(require("dotenv"));
-const task_agent_1 = require("./task-agent");
-const state_manager_1 = require("./state-manager");
-const research_manager_1 = require("./research-manager");
-const dgm_archive_1 = require("./dgm-archive");
-const fitness_evaluator_1 = require("./fitness-evaluator");
-const mutation_strategies_1 = require("./mutation-strategies");
-dotenv.config();
-const apiKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || '';
-const baseURL = process.env.ANTHROPIC_BASE_URL || undefined;
-const defaultModel = process.env.ANTHROPIC_MODEL || 'mimo-v2.5-pro[1m]';
-// SEPL (Self-Evolution Protocol Layer) Engine
-class AutogenesisEngine {
-    substrate;
-    effort = 'standard';
-    codeactMode = false;
-    constructor() {
-        this.substrate = {
-            prompts: new Map(),
-            tools: new Map(),
-            agents: new Map(),
-            workspaceVersion: '1.0.0'
-        };
-        const envEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL || 'standard';
-        this.effort = (envEffort === 'max' || envEffort === 'ultracode') ? 'ultracode' : 'standard';
-        this.initializeSubstrates();
-    }
-    setEffort(effort) {
-        this.effort = effort;
-        console.log(`\x1b[36m[AutogenesisEngine]\x1b[0m Effort level set to: \x1b[32m${this.effort.toUpperCase()}\x1b[0m`);
-    }
-    initializeSubstrates() {
-        // Register baseline substrates
-        this.substrate.prompts.set('system', {
-            id: 'system',
-            template: 'Standard coding agent prompt...',
-            version: '1.0.0'
-        });
-        this.substrate.tools.set('readFile', { name: 'readFile', description: 'Reads files', version: '1.0.0' });
-        this.substrate.tools.set('writeFile', { name: 'writeFile', description: 'Writes files', version: '1.0.0' });
-        this.substrate.tools.set('editFile', { name: 'editFile', description: 'Edits files', version: '1.0.0' });
-        this.substrate.tools.set('runCommand', { name: 'runCommand', description: 'Runs terminal commands', version: '1.0.0' });
-    }
-    /**
-     * SEPL Phase 1: Reflect (R)
-     * Analyzes current workspace compile status and tests logs to identify improvement areas.
-     */
-    async reflect() {
-        const spinner = new tui_tools_1.Spinner('AGP - Reflect: Checking codebase compile & test status...');
-        spinner.start();
-        // Check if git is initialized and clean
-        const status = await (0, shell_tools_1.runCommand)('git status --porcelain');
-        // Run tests as a diagnostic baseline
-        const testResult = await (0, shell_tools_1.runCommand)('npm test');
-        if (testResult.exitCode !== 0) {
-            spinner.stop(false, 'AGP - Reflect: Diagnostic checks failed. Core compilation or tests are currently FAILING.');
-            return `Reflect Analysis: Core compilation or test suite is currently FAILING.\nLogs:\n${testResult.stderr || testResult.stdout}`;
-        }
-        spinner.stop(true, 'AGP - Reflect: Codebase compiles and tests pass. Workspace is stable.');
-        return 'Reflect Analysis: Core compilation and test suite are passing. Workspace is stable.';
-    }
-    /**
-     * SEPL Phase 2: Select (S)
-     * Formulates a proposal of what should be optimized (prompts, tools, or code).
-     */
-    select(analysis, targetTask) {
-        console.log('\x1b[32m✔\x1b[0m AGP - Select: Evolutionary path formulated.');
-        return `Proposal: Mutate the codebase to implement the target task: "${targetTask}". Analysis confirms workspace status: ${analysis.substring(0, 100)}...`;
-    }
-    /**
-     * SEPL Phase 3: Improve (I)
-     * Executes the modification proposal by running the Meta-Agent.
-     */
-    async improve(proposal, targetTask) {
-        console.log('\x1b[36m[AGP - Improve]\x1b[0m Triggering Self-Modification Loop...');
-        // Delegate actual code mutation to the Meta-Agent
-        return await (0, meta_agent_1.runSelfImprovingTask)(targetTask, this.effort, this.codeactMode);
-    }
-    /**
-     * SEPL Phase 4: Evaluate (E)
-     * Evaluates the mutated candidate codebase against compilation, tests, and SAHOO.
-     * Note: The Meta-Agent's internally integrated SAHOO Gateway handles file-specific checks,
-     * while AGP evaluates overall workspace stability here.
-     */
-    async evaluate() {
-        const result = await this.verifyBuildAndTest();
-        return {
-            success: result.success,
-            message: result.success
-                ? 'Evaluate Passed: Codebase compiles and passes all unit tests.'
-                : `Evaluate Failed: ${result.message}`
-        };
-    }
-    /**
-     * SEPL Phase 5: Commit (C)
-     * Commits the mutation to Git or executes rollback if evaluation fails.
-     */
-    async commit(evaluationSuccess, rollbackMessage, targetTask) {
-        if (evaluationSuccess) {
-            const spinner = new tui_tools_1.Spinner('AGP - Commit: Evolution successful. Committing snapshot...');
-            spinner.start();
-            // Extract and save reusable skill playbook
-            if (targetTask) {
-                try {
-                    const diffRes = await this.gitGetDiff();
-                    if (diffRes.exitCode === 0 && diffRes.stdout.trim()) {
-                        spinner.stop(true, 'AGP - Commit: Code healthy. Extracting reusable skill from changes...');
-                        const { extractAndSaveSkill } = require('../tools/skills');
-                        await extractAndSaveSkill(targetTask, diffRes.stdout);
-                    }
-                }
-                catch (e) {
-                    console.error('[Skill Registry] Failed to register skill:', e);
-                }
-            }
-            spinner.stop(true);
-            const commitRes = await this.commitAll();
-            if (commitRes.exitCode === 0 && targetTask) {
-                const revRes = await (0, shell_tools_1.runCommand)('git rev-parse HEAD');
-                if (revRes.exitCode === 0) {
-                    const hash = revRes.stdout.trim();
-                    const currentRefactorResult = (0, state_manager_1.getEvolutionState)().lastRefactorResult;
-                    const { appendArchive } = require('./state-manager');
-                    appendArchive({
-                        commitHash: hash,
-                        task: targetTask,
-                        cycle: (0, state_manager_1.getEvolutionState)().currentCycle,
-                        metrics: currentRefactorResult?.metrics
-                    });
-                }
-            }
-        }
-        else {
-            const spinner = new tui_tools_1.Spinner('AGP - Rollback: Verification failed. Reverting mutations...');
-            spinner.start();
-            await this.gitResetClean();
-            spinner.stop(false, `AGP - Rollback: Codebase reverted to prior HEAD checkpoint.`);
-            console.log(`\x1b[33mFailure Reason: ${rollbackMessage}\x1b[0m`);
-        }
-    }
-    /**
-     * Helper to calculate prompt utility score: higher is better.
-     */
-    calculatePromptScore(timeSeconds, totalTokens) {
-        const timeWeight = 0.4;
-        const tokenWeight = 0.6;
-        if (totalTokens === 0 || timeSeconds === 0)
-            return 0;
-        return 100000 / (timeSeconds * timeWeight + totalTokens * tokenWeight);
-    }
-    /**
-     * Atomic workspace rollback. Resets HEAD and cleans untracked files.
-     */
-    async gitResetClean() {
-        await (0, shell_tools_1.runCommand)('git reset --hard HEAD');
-        await (0, shell_tools_1.runCommand)('git clean -fd');
-    }
-    /**
-     * Runs npm run build and npm test with a managed spinner.
-     * Returns success status and a descriptive message.
-     */
-    async verifyBuildAndTest() {
-        const spinner = new tui_tools_1.Spinner('Verifying: Running build & test suites...');
-        spinner.start();
-        const compile = await (0, shell_tools_1.runCommand)('npm run build');
-        if (compile.exitCode !== 0) {
-            spinner.stop(false, 'Verification failed (Compilation error).');
-            return { success: false, message: `Compilation error:\n${compile.stdout}\n${compile.stderr}` };
-        }
-        const test = await (0, shell_tools_1.runCommand)('npm test');
-        if (test.exitCode !== 0) {
-            spinner.stop(false, 'Verification failed (Tests failed).');
-            return { success: false, message: `Test suite failed:\n${test.stdout}\n${test.stderr}` };
-        }
-        spinner.stop(true, 'Verification passed: Build & tests succeeded.');
-        return { success: true, message: 'Build & tests succeeded.' };
-    }
-    /**
-     * Stages all changes and commits with the standard auto-evolution message.
-     */
-    async commitAll() {
-        const spinner = new tui_tools_1.Spinner('Committing: Staging all changes and committing...');
-        spinner.start();
-        const addRes = await (0, shell_tools_1.runCommand)('git add -A');
-        if (addRes.exitCode !== 0) {
-            spinner.stop(false, 'Commit failed: git add -A failed.');
-            return addRes;
-        }
-        const commitRes = await (0, shell_tools_1.runCommand)('git commit -m "Auto-evolution step: code modification successfully passed SAHOO & AGP gates."');
-        if (commitRes.exitCode !== 0) {
-            spinner.stop(false, 'Commit failed: git commit failed.');
-        }
-        else {
-            spinner.stop(true, 'Evolution transaction committed successfully.');
-        }
-        return commitRes;
-    }
-    /**
-     * Thin wrapper around git diff for readability.
-     */
-    async gitGetDiff() {
-        return await (0, shell_tools_1.runCommand)('git diff');
-    }
-    /**
-     * Thin wrapper for targeted git add <path>.
-     */
-    async gitAdd(target) {
-        return await (0, shell_tools_1.runCommand)(`git add ${target}`);
-    }
-    /**
-     * Thin wrapper for git commit with a custom message.
-     */
-    async gitCommit(message) {
-        return await (0, shell_tools_1.runCommand)(`git commit -m "${message}"`);
-    }
-    /**
-     * Benchmarks a system prompt on a standard task.
-     * Returns token usage, execution time, and compilation success.
-     */
-    async benchmarkPrompt(systemPrompt) {
-        const benchmarkTask = "Create a typescript helper file src/tools/math-helper.ts that exports a sum(a: number, b: number) function. Ensure it compiles. Do not change any other files.";
-        // Clear any previous math-helper.ts file
-        const helperPath = path.join(process.cwd(), 'src/tools/math-helper.ts');
-        if (fs.existsSync(helperPath)) {
-            fs.unlinkSync(helperPath);
-        }
-        // Reset workspace to clean baseline
-        await this.gitResetClean();
-        const startTime = Date.now();
-        let success = false;
-        let inputTokens = 0;
-        let outputTokens = 0;
-        let timeSeconds = 0;
-        try {
-            // Delegate to Task Agent directly with the specified system prompt override
-            const report = await (0, task_agent_1.runTaskAgent)(benchmarkTask, { systemPrompt });
-            timeSeconds = report.timeSeconds;
-            inputTokens = report.inputTokens;
-            outputTokens = report.outputTokens;
-            // Verify compile
-            const verification = await this.verifyBuildAndTest();
-            if (verification.success) {
-                success = true;
-            }
-        }
-        catch (err) {
-            // Failed to execute task or compile
-        }
-        finally {
-            // Clean up changes
-            if (fs.existsSync(helperPath)) {
-                fs.unlinkSync(helperPath);
-            }
-            await this.gitResetClean();
-        }
-        if (!timeSeconds) {
-            timeSeconds = (Date.now() - startTime) / 1000;
-        }
-        const totalTokens = inputTokens + outputTokens;
-        const score = success ? this.calculatePromptScore(timeSeconds, totalTokens) : 0;
-        return { success, time: timeSeconds, tokens: totalTokens, score };
-    }
-    /**
-     * Runs the prompt optimization and benchmarking pipeline.
-     */
-    async runPromptOptimization() {
-        const workspaceRoot = process.cwd();
-        const promptPath = path.join(workspaceRoot, 'src/orchestrator/system-prompt.txt');
-        let baselinePrompt = '';
-        if (fs.existsSync(promptPath)) {
-            baselinePrompt = fs.readFileSync(promptPath, 'utf-8');
-        }
-        else {
-            baselinePrompt = `You are an elite coding agent designed to operate inside a codebase workspace.
-Your primary objective is to fulfill the user's coding tasks accurately and cleanly.
-
-You have access to a set of local tools to read, write, edit files and execute terminal commands.
-Always prefer editing precise parts of files using editFile instead of overwriting the whole file with writeFile unless it is a new file.
-When running commands, verify compilation and test outcomes. If a test fails, you must attempt to fix the issues (Self-Healing).
-
-Be concise and professional. Formulate plans before making changes.`;
-        }
-        console.log(`\n\x1b[35m=== STEP 1: BENCHMARKING BASELINE SYSTEM PROMPT ===\x1b[0m`);
-        const baselineReport = await this.benchmarkPrompt(baselinePrompt);
-        console.log(`Baseline Prompt Benchmark Result:`);
-        console.log(`- Success: ${baselineReport.success ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m'}`);
-        console.log(`- Time:    ${baselineReport.time.toFixed(1)}s`);
-        console.log(`- Tokens:  ${baselineReport.tokens}`);
-        console.log(`- Score:   ${baselineReport.score.toFixed(2)}`);
-        console.log(`\n\x1b[35m=== STEP 2: GENERATING OPTIMIZED CANDIDATE SYSTEM PROMPT ===\x1b[0m`);
-        const optimizerSpinner = new tui_tools_1.Spinner('AGP - Optimizer: Refinement model generating optimized system prompt...');
-        optimizerSpinner.start();
-        const anthropic = new sdk_1.default({
-            apiKey: apiKey,
-            baseURL: baseURL,
-        });
-        const optimizerPrompt = `You are an expert system prompt engineer. Your goal is to optimize the following system prompt for an autonomous coding agent.
-You need to make the prompt more concise, remove redundancy, and explicitly instruct the agent to reduce token waste and thinking overhead, while ensuring it retains all functionality (using file-tools, rulez, self-healing, compiling, running tests).
-
-Here is the Current System Prompt:
-"""
-${baselinePrompt}
-"""
-
-Provide your output strictly as the new optimized system prompt. Do not write any markdown wrappers (like \`\`\` or \`\`\`txt), explanations, greetings, or conversational headers/footers. Output ONLY the raw optimized system prompt text.`;
-        let candidatePrompt = '';
-        try {
-            const response = await anthropic.messages.create({
-                model: defaultModel,
-                max_tokens: 1500,
-                messages: [{ role: 'user', content: optimizerPrompt }]
-            });
-            const block = response.content.find(b => b.type === 'text');
-            if (!block || !block.text) {
-                throw new Error('Failed to retrieve system prompt candidate from LLM.');
-            }
-            candidatePrompt = block.text.trim();
-            optimizerSpinner.stop(true, 'AGP - Optimizer: Prompt candidate generated.');
-        }
-        catch (err) {
-            optimizerSpinner.stop(false, 'AGP - Optimizer: Prompt candidate generation failed.');
-            throw new Error(`Prompt Optimization Failed: ${err.message}`);
-        }
-        console.log('\n\x1b[33m┌── Candidate System Prompt ──────────────────────────────────────────────────────┐\x1b[0m');
-        candidatePrompt.split('\n').forEach(line => console.log(`\x1b[33m│\x1b[0m ${line}`));
-        console.log('\x1b[33m└─────────────────────────────────────────────────────────────────────────────────┘\x1b[0m\n');
-        console.log(`\x1b[35m=== STEP 3: BENCHMARKING CANDIDATE SYSTEM PROMPT ===\x1b[0m`);
-        const candidateReport = await this.benchmarkPrompt(candidatePrompt);
-        console.log(`Candidate Prompt Benchmark Result:`);
-        console.log(`- Success: ${candidateReport.success ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m'}`);
-        console.log(`- Time:    ${candidateReport.time.toFixed(1)}s`);
-        console.log(`- Tokens:  ${candidateReport.tokens}`);
-        console.log(`- Score:   ${candidateReport.score.toFixed(2)}`);
-        console.log(`\n\x1b[35m=== STEP 4: COMPARING PERFORMANCE METRICS ===\x1b[0m`);
-        console.log(`Baseline Score:  \x1b[1m${baselineReport.score.toFixed(2)}\x1b[0m`);
-        console.log(`Candidate Score: \x1b[1m${candidateReport.score.toFixed(2)}\x1b[0m`);
-        if (candidateReport.success && candidateReport.score > baselineReport.score) {
-            console.log(`\n\x1b[32;1m[Optimization Approved] Candidate prompt is more efficient. Overwriting system-prompt.txt...\x1b[0m`);
-            fs.writeFileSync(promptPath, candidatePrompt, 'utf-8');
-            // Commit the changes to Git
-            await this.gitAdd('src/orchestrator/system-prompt.txt');
-            await this.gitCommit('chore: optimize Task Agent system prompt via automated benchmarking loop');
-            console.log(`\x1b[32m[Git Status] System prompt snapshot committed to repository HEAD.\x1b[0m`);
-        }
-        else {
-            console.log(`\n\x1b[31;1m[Optimization Rejected] Candidate prompt did not improve performance. Retaining baseline.\x1b[0m`);
-        }
-        (0, state_manager_1.updateEvolutionState)({
-            lastPromptOptimization: {
-                success: candidateReport.success,
-                baselineScore: baselineReport.score,
-                candidateScore: candidateReport.score,
-                approved: candidateReport.success && candidateReport.score > baselineReport.score,
-                time: new Date().toISOString()
-            }
-        });
-        (0, state_manager_1.appendHistory)({
-            cycle: (0, state_manager_1.getEvolutionState)().currentCycle,
-            type: 'prompt_opt',
-            description: `Optimized system prompt. Baseline: ${baselineReport.score.toFixed(2)}, Candidate: ${candidateReport.score.toFixed(2)}`,
-            success: candidateReport.success && candidateReport.score > baselineReport.score
-        });
-    }
-    /**
-     * Generates a refactoring proposal by scanning the codebase repository map.
-     */
-    async getAutonomousRefactorProposal() {
-        const workspaceRoot = process.cwd();
-        const repoMap = (0, repo_map_1.generateRepoMap)(workspaceRoot);
-        const scanSpinner = new tui_tools_1.Spinner('AGP - Scan: Auditing codebase structure for optimizations...');
-        scanSpinner.start();
-        // 1. Context Gathering: logs & learnings
-        let evolutionLog = '';
-        const logPath = path.join(workspaceRoot, 'evolution.log');
-        if (fs.existsSync(logPath)) {
-            try {
-                const fullLog = fs.readFileSync(logPath, 'utf-8');
-                const lines = fullLog.split('\n');
-                evolutionLog = lines.slice(-40).join('\n'); // Ingest last 40 lines of log
-            }
-            catch (e) { }
-        }
-        let learningsMd = '';
-        const learningsPath = path.join(workspaceRoot, 'Learnings.md');
-        if (fs.existsSync(learningsPath)) {
-            try {
-                learningsMd = fs.readFileSync(learningsPath, 'utf-8');
-            }
-            catch (e) { }
-        }
-        const anthropic = new sdk_1.default({
-            apiKey: apiKey,
-            baseURL: baseURL,
-        });
-        try {
-            // Step 1: Select 2 target candidate files based on Repo Map, Logs, and Learnings
-            const candidatePrompt = `You are an expert software architect. Your goal is to select the top 2 files in this codebase that would benefit most from refactoring (improving type-safety, code duplication, helper functions cleanup, or performance).
-Review the codebase map, past evolution logs, and lessons learned.
-
-Codebase Repository Map:
-${repoMap}
-
-Last 40 lines of evolution logs (shows recent runs/warnings/failures):
-${evolutionLog || 'No log history available.'}
-
-Learnings Registry (shows past insights):
-${learningsMd || 'No past learnings recorded.'}
-
-Output your response strictly as a JSON object containing a list of 2 candidate target files (relative paths). Do not include any other text, markdown blocks, or formatting, just the raw JSON.
-
-Format:
-{
-  "candidates": [
-    { "targetFile": "relative/path/to/file1.ts" },
-    { "targetFile": "relative/path/to/file2.ts" }
-  ]
-}`;
-            const candidateResponse = await anthropic.messages.create({
-                model: defaultModel,
-                max_tokens: 4000,
-                messages: [{ role: 'user', content: candidatePrompt }]
-            });
-            const candBlock = candidateResponse.content.find(b => b.type === 'text');
-            if (!candBlock || !candBlock.text) {
-                console.error('DEBUG - candidateResponse content:', JSON.stringify(candidateResponse.content));
-                throw new Error('Failed to retrieve candidates from LLM.');
-            }
-            const candText = candBlock.text.trim().replace(/^```json/, '').replace(/```$/, '').trim();
-            const candJson = JSON.parse(candText);
-            const candidates = candJson.candidates || [];
-            if (candidates.length === 0) {
-                throw new Error('No candidates identified by the LLM.');
-            }
-            // Step 2: Read candidate file contents
-            let fileContext = '';
-            for (const cand of candidates) {
-                const fullPath = path.join(workspaceRoot, cand.targetFile);
-                if (fs.existsSync(fullPath)) {
-                    try {
-                        const fileContent = fs.readFileSync(fullPath, 'utf-8');
-                        fileContext += `\n--- FILE: ${cand.targetFile} ---\n${fileContent}\n`;
-                    }
-                    catch (e) {
-                        fileContext += `\n--- FILE: ${cand.targetFile} (Could not read file contents) ---\n`;
-                    }
-                }
-                else {
-                    fileContext += `\n--- FILE: ${cand.targetFile} (File not found on disk) ---\n`;
-                }
-            }
-            // Step 3: Evaluate and Select Winner based on actual code inspection
-            const evaluationPrompt = `You are an expert software architect. Analyze the actual code content of the candidate files below and select the single best refactoring proposal.
-Evaluate each file and design a specific refactor goal.
-Score each proposal out of 10 based on:
-1. Impact (readability, duplication reduction, safety, performance).
-2. Feasibility (compilation safety, low risk of breaking tests).
-
-Candidate File Contents:
-${fileContext}
-
-Output your response strictly as a JSON object containing the winning proposal's target file and the specific refactoring goal. Do not include any other text, markdown blocks, or formatting, just the raw JSON.
-
-Format:
-{
-  "winningProposal": {
-    "targetFile": "relative/path/to/file.ts",
-    "refactorGoal": "A concise, specific description of the refactoring goal (e.g., 'Refactor search-tools to use strong interfaces instead of any[]')",
-    "impactScore": 8.5,
-    "feasibilityScore": 9.0
-  }
-}`;
-            const evaluationResponse = await anthropic.messages.create({
-                model: defaultModel,
-                max_tokens: 4000,
-                messages: [{ role: 'user', content: evaluationPrompt }]
-            });
-            const evalBlock = evaluationResponse.content.find(b => b.type === 'text');
-            if (!evalBlock || !evalBlock.text) {
-                throw new Error('Failed to retrieve evaluation from LLM.');
-            }
-            const evalText = evalBlock.text.trim().replace(/^```json/, '').replace(/```$/, '').trim();
-            const evalJson = JSON.parse(evalText);
-            const winningProposal = evalJson.winningProposal;
-            if (!winningProposal || !winningProposal.targetFile || !winningProposal.refactorGoal) {
-                throw new Error('Invalid JSON structure returned for winning proposal.');
-            }
-            console.log(`\n\x1b[32m✔\x1b[0m AGP - Scan: Selected best proposal: ${winningProposal.targetFile} (Impact: ${winningProposal.impactScore || 'N/A'}, Feasibility: ${winningProposal.feasibilityScore || 'N/A'})`);
-            scanSpinner.stop(true, 'AGP - Scan: Codebase audit complete.');
-            return {
-                targetFile: winningProposal.targetFile,
-                refactorGoal: winningProposal.refactorGoal
-            };
-        }
-        catch (err) {
-            scanSpinner.stop(false, 'AGP - Scan: Codebase audit failed.');
-            throw new Error(`Refactoring Analysis Failed: ${err.message}`);
-        }
-    }
-    /**
-     * Scans codebase for refactoring opportunities and triggers an autonomous evolution run.
-     */
-    async runAutonomousRefactor() {
-        const proposal = await this.getAutonomousRefactorProposal();
-        console.log('\n\x1b[35m┌── Autonomous Refactoring Proposal ──────────────────────────────────────────────┐\x1b[0m');
-        console.log(`\x1b[35m│\x1b[0m Target File:   \x1b[1m\x1b[32m${proposal.targetFile}\x1b[0m`);
-        console.log(`\x1b[35m│\x1b[0m Refactor Goal: \x1b[33m${proposal.refactorGoal}\x1b[0m`);
-        console.log('\x1b[35m└─────────────────────────────────────────────────────────────────────────────────┘\x1b[0m\n');
-        (0, state_manager_1.updateEvolutionState)({
-            lastRefactorProposal: {
-                targetFile: proposal.targetFile,
-                refactorGoal: proposal.refactorGoal,
-                time: new Date().toISOString()
-            }
-        });
-        const taskText = `Refactor the file "${proposal.targetFile}" to achieve the following goal: ${proposal.refactorGoal}. Do not modify any other file unless required for compilation. Compile and verify tests pass.`;
-        // Delegate to evolution loop
-        await this.runEvolutionStep(taskText);
-    }
-    /**
-     * High-Level Autogenesis Evolution Run
-     */
-    async runEvolutionStep(targetTask) {
-        console.log('\x1b[35m=== STARTING AUTOGENESIS PROTOCOL EVOLUTION STEP ===\x1b[0m');
-        // Start active research session
-        research_manager_1.ResearchManager.startSession(targetTask, this.effort);
-        (0, state_manager_1.updateEvolutionState)({
-            status: 'reflecting',
-            currentTask: `Executing task: "${targetTask}"`
-        });
-        // 1. Reflect
-        const analysis = await this.reflect();
-        (0, state_manager_1.updateEvolutionState)({
-            status: 'scanning',
-            currentTask: 'Selecting mutation plan'
-        });
-        // 2. Select
-        const proposal = this.select(analysis, targetTask);
-        (0, state_manager_1.updateEvolutionState)({
-            status: 'refactoring',
-            currentTask: `Mutating codebase for task: "${targetTask}"`
-        });
-        // 3. Improve & 4. Evaluate (The Meta-Agent execution is self-safeguarded by SAHOO)
-        let executionSuccess = false;
-        let failReason = '';
-        try {
-            await this.improve(proposal, targetTask);
-            (0, state_manager_1.updateEvolutionState)({
-                status: 'evaluating',
-                currentTask: 'Running verification test suite'
-            });
-            // Double check overall workspace via AGP evaluate
-            const evalResult = await this.evaluate();
-            if (evalResult.success) {
-                executionSuccess = true;
-            }
-            else {
-                failReason = evalResult.message;
-            }
-        }
-        catch (err) {
-            failReason = err.message;
-        }
-        // 5. Commit or Rollback
-        (0, state_manager_1.updateEvolutionState)({
-            status: executionSuccess ? 'committing' : 'rolling_back',
-            currentTask: executionSuccess ? 'Committing changes to Git' : 'Rolling back workspace modifications'
-        });
-        await this.commit(executionSuccess, failReason, targetTask);
-        // End active research session
-        research_manager_1.ResearchManager.endSession(executionSuccess ? 'success' : 'failed');
-        const targetFile = targetTask.includes('Refactor the file "')
-            ? targetTask.split('"')[1]
-            : (targetTask.includes('file "') ? targetTask.split('"')[1] : 'Workspace');
-        const currentRefactorResult = (0, state_manager_1.getEvolutionState)().lastRefactorResult;
-        (0, state_manager_1.updateEvolutionState)({
-            status: 'idle',
-            currentTask: null,
-            lastRefactorResult: {
-                success: executionSuccess,
-                targetFile: targetFile,
-                message: executionSuccess ? 'Evolution succeeded.' : `Evolution failed: ${failReason}`,
-                time: new Date().toISOString(),
-                reason: executionSuccess ? undefined : failReason,
-                metrics: currentRefactorResult?.metrics
-            }
-        });
-        (0, state_manager_1.appendHistory)({
-            cycle: (0, state_manager_1.getEvolutionState)().currentCycle,
-            type: 'refactor',
-            description: targetTask.length > 80 ? targetTask.substring(0, 80) + '...' : targetTask,
-            success: executionSuccess,
-            details: executionSuccess ? undefined : failReason
-        });
-        console.log('\x1b[35m=== AUTOGENESIS STEP COMPLETED ===\x1b[0m\n');
-    }
-    runChildProcess(args) {
-        return new Promise((resolve) => {
-            const child = (0, child_process_1.spawn)('node', args, {
-                stdio: 'inherit',
-                env: { ...process.env, CLAUDE_CODE_EFFORT_LEVEL: this.effort }
-            });
-            child.on('close', (code) => {
-                resolve(code ?? 1);
-            });
-            child.on('error', () => {
-                resolve(1);
-            });
-        });
-    }
-    /**
-     * Continuous Self-Evolution Daemon Loop
-     */
-    async runContinuousEvolution(maxCycles, tokenBudget) {
-        const historyPath = path.join(process.cwd(), 'evolution-history.json');
-        const tokenPath = path.join(process.cwd(), 'session-tokens.json');
-        // Clear previous token file on start
-        if (fs.existsSync(tokenPath)) {
-            try {
-                fs.unlinkSync(tokenPath);
-            }
-            catch (e) { }
-        }
-        (0, state_manager_1.updateEvolutionState)({
-            status: 'idle',
-            currentCycle: 0,
-            maxCycles,
-            tokenBudget,
-            tokensUsed: { input: 0, output: 0, total: 0 }
-        });
-        let cycle = 0;
-        let consecutiveFailures = 0;
-        while (true) {
-            cycle++;
-            if (maxCycles > 0 && cycle > maxCycles) {
-                console.log(`\n\x1b[32m[Continuous Evolution] Completed maximum cycles (${maxCycles}). Stopping.\x1b[0m`);
-                (0, state_manager_1.updateEvolutionState)({ status: 'idle', currentTask: null });
-                break;
-            }
-            console.log(`\n\x1b[35m==================================================\x1b[0m`);
-            console.log(`\x1b[35m      STARTING CONTINUOUS EVOLUTION CYCLE ${cycle}     \x1b[0m`);
-            console.log(`\x1b[35m==================================================\x1b[0m\n`);
-            (0, state_manager_1.updateEvolutionState)({
-                status: 'reflecting',
-                currentCycle: cycle,
-                currentTask: 'Checking workspace baseline status'
-            });
-            // 1. Check token budget
-            let totalInput = 0;
-            let totalOutput = 0;
-            if (fs.existsSync(tokenPath)) {
-                try {
-                    const data = JSON.parse(fs.readFileSync(tokenPath, 'utf-8'));
-                    totalInput = data.inputTokens || 0;
-                    totalOutput = data.outputTokens || 0;
-                }
-                catch (e) { }
-            }
-            const totalTokens = totalInput + totalOutput;
-            console.log(`Current Session Cumulative Token Usage: ${totalTokens} / ${tokenBudget}`);
-            (0, state_manager_1.updateEvolutionState)({
-                tokensUsed: {
-                    input: totalInput,
-                    output: totalOutput,
-                    total: totalTokens
-                }
-            });
-            if (totalTokens > tokenBudget) {
-                console.log(`\n\x1b[31;1m[Budget Exceeded] Token usage (${totalTokens}) has exceeded the budget cap (${tokenBudget}). Halting daemon.\x1b[0m`);
-                (0, state_manager_1.updateEvolutionState)({ status: 'idle', currentTask: 'Token budget exceeded' });
-                break;
-            }
-            (0, state_manager_1.updateEvolutionState)({
-                status: 'scanning',
-                currentTask: 'Generating next mutation proposal'
-            });
-            // 2. Fetch Refactor Proposal and check history to avoid ping-pong loops
-            let proposal;
-            try {
-                proposal = await this.getAutonomousRefactorProposal();
-                let historyList = [];
-                if (fs.existsSync(historyPath)) {
-                    try {
-                        historyList = JSON.parse(fs.readFileSync(historyPath, 'utf-8')) || [];
-                    }
-                    catch (e) { }
-                }
-                const proposalKey = `${proposal.targetFile}::${proposal.refactorGoal}`;
-                if (historyList.includes(proposalKey)) {
-                    console.log(`\n\x1b[33m[Divergence Prevention] Proposal "${proposalKey}" has been successfully executed recently. Skipping to prevent cycles.\x1b[0m`);
-                    // Try a second time to get a different proposal
-                    proposal = await this.getAutonomousRefactorProposal();
-                }
-            }
-            catch (err) {
-                console.error(`\n\x1b[31m[Proposal Error] Failed to scan proposal: ${err.message}\x1b[0m`);
-            }
-            if (proposal) {
-                const proposalKey = `${proposal.targetFile}::${proposal.refactorGoal}`;
-                console.log(`\n\x1b[36m[Daemon Worker] Spawning refactor child worker for target: ${proposal.targetFile}...\x1b[0m`);
-                (0, state_manager_1.updateEvolutionState)({
-                    status: 'refactoring',
-                    currentTask: `Refactoring: ${proposal.refactorGoal}`,
-                    lastRefactorProposal: {
-                        targetFile: proposal.targetFile,
-                        refactorGoal: proposal.refactorGoal,
-                        time: new Date().toISOString()
-                    }
-                });
-                // Spawn --refactor worker
-                const refactorExit = await this.runChildProcess(['dist/index.js', '--refactor']);
-                if (refactorExit === 0) {
-                    console.log(`\n\x1b[32m✔ [Daemon Worker] Refactor cycle completed successfully.\x1b[0m`);
-                    consecutiveFailures = 0; // Reset failures on success
-                    // Append to history cache
-                    let historyList = [];
-                    if (fs.existsSync(historyPath)) {
-                        try {
-                            historyList = JSON.parse(fs.readFileSync(historyPath, 'utf-8')) || [];
-                        }
-                        catch (e) { }
-                    }
-                    historyList.push(proposalKey);
-                    if (historyList.length > 20) {
-                        historyList.shift();
-                    }
-                    fs.writeFileSync(historyPath, JSON.stringify(historyList, null, 2), 'utf-8');
-                }
-                else {
-                    console.log(`\n\x1b[31m❌ [Daemon Worker] Refactor cycle failed or was rolled back. (Exit Code: ${refactorExit})\x1b[0m`);
-                    consecutiveFailures++;
-                    // Ensure git rollback just in case the child process crashed mid-way or didn't roll back
-                    await this.gitResetClean();
-                    // DGM-inspired Evolutionary Backtracking
-                    if (consecutiveFailures >= 2) {
-                        const state = (0, state_manager_1.getEvolutionState)();
-                        const archive = state.archive || [];
-                        if (archive.length > 0) {
-                            const parentNode = archive[archive.length - 1];
-                            console.log(`\n\x1b[31m[DGM Backtracking]\x1b[0m Consecutive failures (${consecutiveFailures}) exceeded limit. Backtracking to parent node cycle ${parentNode.cycle} (commit: ${parentNode.commitHash.substring(0, 7)})...`);
-                            const spinner = new tui_tools_1.Spinner('DGM - Backtracking: Resetting workspace to stable parent node...');
-                            spinner.start();
-                            await (0, shell_tools_1.runCommand)(`git reset --hard ${parentNode.commitHash}`);
-                            await (0, shell_tools_1.runCommand)('git clean -fd');
-                            spinner.stop(true, 'DGM - Backtracking: Workspace successfully restored to stable parent node.');
-                            consecutiveFailures = 0; // Reset consecutive failures after backtracking
-                        }
-                    }
-                }
-            }
-            // 3. Spawns Prompt Optimizer
-            console.log(`\n\x1b[36m[Daemon Worker] Spawning prompt optimization child worker...\x1b[0m`);
-            (0, state_manager_1.updateEvolutionState)({
-                status: 'optimizing_prompt',
-                currentTask: 'Optimizing System Prompt Benchmarks'
-            });
-            const optimizeExit = await this.runChildProcess(['dist/index.js', '--optimize-prompt']);
-            if (optimizeExit === 0) {
-                console.log(`\n\x1b[32m✔ [Daemon Worker] Prompt optimization benchmark completed.\x1b[0m`);
-            }
-            else {
-                console.log(`\n\x1b[31m❌ [Daemon Worker] Prompt optimization benchmark failed. (Exit Code: ${optimizeExit})\x1b[0m`);
-                await this.gitResetClean();
-            }
-            console.log(`\n\x1b[33m[Daemon Cooldown] Sleeping for 60 seconds before next cycle...\x1b[0m`);
-            (0, state_manager_1.updateEvolutionState)({
-                status: 'cooldown',
-                currentTask: 'Cooldown period (60s)'
-            });
-            await new Promise(resolve => setTimeout(resolve, 60000));
-        }
-    }
-    /**
-     * DGM Evolution Loop
-     * Implements Darwin Gödel Machine open-ended evolution:
-     * 1. Measure baseline fitness
-     * 2. Select parent from archive (fitness-weighted)
-     * 3. Select mutation strategy (adaptive)
-     * 4. Apply mutation via Meta-Agent
-     * 5. Evaluate candidate fitness empirically
-     * 6. Add to archive if fitness improved or maintained
-     * 7. Commit if better; rollback if worse
-     */
-    async runDGMEvolution(task, maxGenerations = 5) {
-        console.log('\x1b[35m=== STARTING DGM (Darwin Gödel Machine) EVOLUTION ===\x1b[0m');
-        console.log(`Task: "${task}"`);
-        console.log(`Max Generations: ${maxGenerations}\n`);
-        const archive = new dgm_archive_1.DGMArchive(process.cwd());
-        research_manager_1.ResearchManager.startSession(`DGM Evolution: ${task}`, this.effort);
-        // Step 1: Measure baseline fitness
-        (0, state_manager_1.updateEvolutionState)({ status: 'reflecting', currentTask: 'DGM: Measuring baseline fitness' });
-        console.log('\x1b[34m[DGM]\x1b[0m Measuring baseline fitness...');
-        const baselineFitness = await (0, fitness_evaluator_1.evaluateFitness)();
-        console.log(`\x1b[32m[DGM]\x1b[0m Baseline: ${baselineFitness.summary}`);
-        // Register initial baseline into archive if empty
-        const archiveStats = archive.getStats();
-        let baselineEntry = archiveStats.bestEntryId ? archive.findById(archiveStats.bestEntryId) : null;
-        if (!baselineEntry) {
-            const gitHeadRes = await (0, shell_tools_1.runCommand)('git rev-parse HEAD');
-            const commitHash = gitHeadRes.exitCode === 0 ? gitHeadRes.stdout.trim() : 'unknown';
-            baselineEntry = archive.addEntry({
-                commitHash,
-                parentId: null,
-                fitness: baselineFitness.score,
-                mutationStrategy: 'baseline',
-                task: 'Initial baseline snapshot',
-                metadata: {
-                    passCount: baselineFitness.passCount,
-                    failCount: baselineFitness.failCount,
-                    totalTests: baselineFitness.totalTests,
-                    passRate: baselineFitness.passRate
-                }
-            });
-            console.log(`\x1b[34m[DGM]\x1b[0m Registered baseline snapshot: ${baselineEntry.id} (fitness: ${(baselineFitness.score * 100).toFixed(1)}%)`);
-        }
-        (0, state_manager_1.updateEvolutionState)({
-            currentFitness: baselineFitness.score,
-            bestFitness: Math.max((0, state_manager_1.getEvolutionState)().bestFitness, baselineFitness.score),
-            dgmPopulationSize: archive.getStats().totalEntries,
-            dgmBestEntryId: archive.getStats().bestEntryId
-        });
-        let currentBestFitness = baselineFitness.score;
-        // Step 2-7: Evolution loop
-        for (let gen = 1; gen <= maxGenerations; gen++) {
-            console.log(`\n\x1b[35m─── DGM Generation ${gen}/${maxGenerations} ───\x1b[0m`);
-            // 2a. Select parent from archive (fitness-weighted)
-            const parent = archive.getBestParent('fitness_weighted');
-            if (parent) {
-                console.log(`\x1b[34m[DGM]\x1b[0m Selected parent: ${parent.id} (fitness: ${(parent.fitness * 100).toFixed(1)}%, strategy: ${parent.mutationStrategy})`);
-            }
-            // 2b. Select mutation strategy (adaptive)
-            (0, state_manager_1.updateEvolutionState)({ status: 'scanning', currentTask: `DGM Gen ${gen}: Selecting mutation strategy` });
-            const mutationSel = (0, mutation_strategies_1.selectMutationStrategy)(archive, task, currentBestFitness);
-            console.log(`\x1b[34m[DGM]\x1b[0m Mutation: \x1b[33m${mutationSel.strategy}\x1b[0m — ${mutationSel.rationale}`);
-            // 2c. Generate mutation prompt
-            const mutationTask = (0, mutation_strategies_1.generateMutationPrompt)(mutationSel.strategy, task, {
-                parentEntry: parent,
-                currentFitness: currentBestFitness
-            });
-            // 3. Apply mutation via Meta-Agent
-            (0, state_manager_1.updateEvolutionState)({ status: 'refactoring', currentTask: `DGM Gen ${gen}: Applying ${mutationSel.strategy} mutation` });
-            research_manager_1.ResearchManager.logDecision('DGM Mutation', `Gen ${gen}: Applying strategy ${mutationSel.strategy}`, 'info');
-            let mutationSucceeded = false;
-            try {
-                await (0, meta_agent_1.runSelfImprovingTask)(mutationTask, this.effort);
-                mutationSucceeded = true;
-            }
-            catch (err) {
-                console.error(`\x1b[31m[DGM Gen ${gen}]\x1b[0m Mutation failed: ${err.message}`);
-                research_manager_1.ResearchManager.logDecision('DGM Mutation', `Gen ${gen}: Mutation error — ${err.message}`, 'failure');
-            }
-            if (!mutationSucceeded) {
-                console.log(`\x1b[33m[DGM Gen ${gen}]\x1b[0m Skipping fitness evaluation due to mutation failure.`);
-                continue;
-            }
-            // 4. Evaluate candidate fitness empirically
-            (0, state_manager_1.updateEvolutionState)({ status: 'evaluating', currentTask: `DGM Gen ${gen}: Evaluating candidate fitness` });
-            console.log(`\x1b[34m[DGM Gen ${gen}]\x1b[0m Evaluating candidate fitness...`);
-            const candidateFitness = await (0, fitness_evaluator_1.evaluateFitness)();
-            const comparison = (0, fitness_evaluator_1.compareToBaseline)(candidateFitness, { ...baselineFitness });
-            console.log(`\x1b[${comparison.improved ? '32' : '33'}m[DGM Gen ${gen}]\x1b[0m ${comparison.message}`);
-            research_manager_1.ResearchManager.logDecision('DGM Fitness', `Gen ${gen}: ${comparison.message}`, comparison.improved ? 'success' : 'info');
-            // 5. Add to archive + commit/rollback decision
-            (0, state_manager_1.updateEvolutionState)({ status: comparison.improved ? 'committing' : 'rolling_back', currentTask: `DGM Gen ${gen}: ${comparison.improved ? 'Committing' : 'Rolling back'}` });
-            if (candidateFitness.compileSuccess && candidateFitness.score >= currentBestFitness) {
-                // Commit the mutation
-                const commitRes = await this.commitAll();
-                let newCommitHash = 'unknown';
-                if (commitRes.exitCode === 0) {
-                    const revRes = await (0, shell_tools_1.runCommand)('git rev-parse HEAD');
-                    newCommitHash = revRes.exitCode === 0 ? revRes.stdout.trim() : 'unknown';
-                }
-                // Add to DGM archive
-                const newEntry = archive.addEntry({
-                    commitHash: newCommitHash,
-                    parentId: parent?.id ?? baselineEntry.id,
-                    fitness: candidateFitness.score,
-                    mutationStrategy: mutationSel.strategy,
-                    task,
-                    metadata: {
-                        passCount: candidateFitness.passCount,
-                        failCount: candidateFitness.failCount,
-                        totalTests: candidateFitness.totalTests,
-                        passRate: candidateFitness.passRate
-                    }
-                });
-                archive.pruneOldEntries();
-                currentBestFitness = Math.max(currentBestFitness, candidateFitness.score);
-                console.log(`\x1b[32m[DGM Gen ${gen}]\x1b[0m Committed & archived: ${newEntry.id} (fitness: ${(candidateFitness.score * 100).toFixed(1)}%)`);
-                (0, state_manager_1.appendHistory)({
-                    cycle: gen,
-                    type: 'dgm_evolution',
-                    description: `DGM Gen ${gen}: ${mutationSel.strategy} → fitness ${(candidateFitness.score * 100).toFixed(1)}%`,
-                    success: true
-                });
-            }
-            else {
-                // Rollback — candidate did not improve fitness
-                console.log(`\x1b[31m[DGM Gen ${gen}]\x1b[0m Rolling back — candidate did not improve fitness.`);
-                await this.gitResetClean();
-                research_manager_1.ResearchManager.logDecision('DGM Rollback', `Gen ${gen}: Reverted — fitness did not improve`, 'info');
-                (0, state_manager_1.appendHistory)({
-                    cycle: gen,
-                    type: 'dgm_evolution',
-                    description: `DGM Gen ${gen}: ${mutationSel.strategy} → rolled back (fitness unchanged or regressed)`,
-                    success: false
-                });
-            }
-            // Update state
-            const updatedStats = archive.getStats();
-            (0, state_manager_1.updateEvolutionState)({
-                currentFitness: candidateFitness.score,
-                bestFitness: currentBestFitness,
-                dgmPopulationSize: updatedStats.totalEntries,
-                dgmBestEntryId: updatedStats.bestEntryId
-            });
-        }
-        research_manager_1.ResearchManager.endSession(currentBestFitness > baselineFitness.score ? 'success' : 'failed');
-        const finalStats = archive.getStats();
-        console.log(`\n\x1b[35m=== DGM EVOLUTION COMPLETE ===\x1b[0m`);
-        console.log(`Final best fitness: ${(currentBestFitness * 100).toFixed(1)}% (started: ${(baselineFitness.score * 100).toFixed(1)}%)`);
-        console.log(`Archive size: ${finalStats.totalEntries} snapshots`);
-        console.log(`Generation depth: ${finalStats.generationDepth}`);
-        (0, state_manager_1.updateEvolutionState)({ status: 'idle', currentTask: null });
-    }
-}
-exports.AutogenesisEngine = AutogenesisEngine;