closed-loop-cli 1.0.2 → 1.0.4

package/src/orchestrator/autogenesis.ts

@@ -1,1078 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { spawn } from 'child_process';
-import { runCommand, CommandResult } from '../tools/shell-tools';
-import { runSelfImprovingTask } from './meta-agent';
-import { Spinner } from '../tools/tui-tools';
-import { generateRepoMap } from '../tools/repo-map';
-import Anthropic from '@anthropic-ai/sdk';
-import * as dotenv from 'dotenv';
-import { runTaskAgent } from './task-agent';
-import { updateEvolutionState, getEvolutionState, appendHistory } from './state-manager';
-import { ResearchManager } from './research-manager';
-import { DGMArchive } from './dgm-archive';
-import { evaluateFitness, compareToBaseline } from './fitness-evaluator';
-import { selectMutationStrategy, generateMutationPrompt } from './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]';
-
-// RSPL (Resource Substrate Protocol Layer) Types
-export interface PromptResource {
-  id: string;
-  template: string;
-  version: string;
-}
-
-export interface ToolResource {
-  name: string;
-  description: string;
-  version: string;
-}
-
-export interface AgentResource {
-  id: string;
-  role: string;
-  model: string;
-  version: string;
-}
-
-export interface RSPLSubstrate {
-  prompts: Map<string, PromptResource>;
-  tools: Map<string, ToolResource>;
-  agents: Map<string, AgentResource>;
-  workspaceVersion: string;
-}
-
-// SEPL (Self-Evolution Protocol Layer) Engine
-export class AutogenesisEngine {
-  private substrate: RSPLSubstrate;
-  private effort: 'standard' | 'ultracode' = 'standard';
-  public 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: 'standard' | 'ultracode') {
-    this.effort = effort;
-    console.log(`\x1b[36m[AutogenesisEngine]\x1b[0m Effort level set to: \x1b[32m${this.effort.toUpperCase()}\x1b[0m`);
-  }
-
-  private 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(): Promise<string> {
-    const spinner = new Spinner('AGP - Reflect: Checking codebase compile & test status...');
-    spinner.start();
-    
-    // Check if git is initialized and clean
-    const status = await runCommand('git status --porcelain');
-    
-    // Run tests as a diagnostic baseline
-    const testResult = await 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: string, targetTask: string): string {
-    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: string, targetTask: string): Promise<string> {
-    console.log('\x1b[36m[AGP - Improve]\x1b[0m Triggering Self-Modification Loop...');
-    
-    // Delegate actual code mutation to the Meta-Agent
-    return await 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(): Promise<{ success: boolean; message: string }> {
-    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: boolean, rollbackMessage?: string, targetTask?: string): Promise<void> {
-    if (evaluationSuccess) {
-      const spinner = new 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 runCommand('git rev-parse HEAD');
-        if (revRes.exitCode === 0) {
-          const hash = revRes.stdout.trim();
-          const currentRefactorResult = getEvolutionState().lastRefactorResult;
-          const { appendArchive } = require('./state-manager');
-          appendArchive({
-            commitHash: hash,
-            task: targetTask,
-            cycle: getEvolutionState().currentCycle,
-            metrics: currentRefactorResult?.metrics
-          });
-        }
-      }
-    } else {
-      const spinner = new 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.
-   */
-  public calculatePromptScore(timeSeconds: number, totalTokens: number): number {
-    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.
-   */
-  private async gitResetClean(): Promise<void> {
-    await runCommand('git reset --hard HEAD');
-    await runCommand('git clean -fd');
-  }
-
-  /**
-   * Runs npm run build and npm test with a managed spinner.
-   * Returns success status and a descriptive message.
-   */
-  private async verifyBuildAndTest(): Promise<{ success: boolean; message: string }> {
-    const spinner = new Spinner('Verifying: Running build & test suites...');
-    spinner.start();
-    const compile = await 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 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.
-   */
-  private async commitAll(): Promise<CommandResult> {
-    const spinner = new Spinner('Committing: Staging all changes and committing...');
-    spinner.start();
-    const addRes = await runCommand('git add -A');
-    if (addRes.exitCode !== 0) {
-      spinner.stop(false, 'Commit failed: git add -A failed.');
-      return addRes;
-    }
-    const commitRes = await 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.
-   */
-  private async gitGetDiff(): Promise<CommandResult> {
-    return await runCommand('git diff');
-  }
-
-  /**
-   * Thin wrapper for targeted git add <path>.
-   */
-  private async gitAdd(target: string): Promise<CommandResult> {
-    return await runCommand(`git add ${target}`);
-  }
-
-  /**
-   * Thin wrapper for git commit with a custom message.
-   */
-  private async gitCommit(message: string): Promise<CommandResult> {
-    return await runCommand(`git commit -m "${message}"`);
-  }
-
-  /**
-   * Benchmarks a system prompt on a standard task.
-   * Returns token usage, execution time, and compilation success.
-   */
-  private async benchmarkPrompt(systemPrompt: string): Promise<{ success: boolean; time: number; tokens: number; score: number }> {
-    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 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(): Promise<void> {
-    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 Spinner('AGP - Optimizer: Refinement model generating optimized system prompt...');
-    optimizerSpinner.start();
-
-    const anthropic = new Anthropic({
-      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') as Anthropic.TextBlock | undefined;
-      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: any) {
-      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`);
-    }
-
-    updateEvolutionState({
-      lastPromptOptimization: {
-        success: candidateReport.success,
-        baselineScore: baselineReport.score,
-        candidateScore: candidateReport.score,
-        approved: candidateReport.success && candidateReport.score > baselineReport.score,
-        time: new Date().toISOString()
-      }
-    });
-
-    appendHistory({
-      cycle: 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(): Promise<{ targetFile: string; refactorGoal: string }> {
-    const workspaceRoot = process.cwd();
-    const repoMap = generateRepoMap(workspaceRoot);
-
-    const scanSpinner = new 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 Anthropic({
-      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') as Anthropic.TextBlock | undefined;
-      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: Array<{ targetFile: string }> = 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') as Anthropic.TextBlock | undefined;
-      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: any) {
-      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(): Promise<void> {
-    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');
-
-    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: string): Promise<void> {
-    console.log('\x1b[35m=== STARTING AUTOGENESIS PROTOCOL EVOLUTION STEP ===\x1b[0m');
-    
-    // Start active research session
-    ResearchManager.startSession(targetTask, this.effort);
-
-    updateEvolutionState({
-      status: 'reflecting',
-      currentTask: `Executing task: "${targetTask}"`
-    });
-
-    // 1. Reflect
-    const analysis = await this.reflect();
-    
-    updateEvolutionState({
-      status: 'scanning',
-      currentTask: 'Selecting mutation plan'
-    });
-
-    // 2. Select
-    const proposal = this.select(analysis, targetTask);
-    
-    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);
-      
-      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: any) {
-      failReason = err.message;
-    }
-    
-    // 5. Commit or Rollback
-    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
-    ResearchManager.endSession(executionSuccess ? 'success' : 'failed');
-
-    const targetFile = targetTask.includes('Refactor the file "') 
-      ? targetTask.split('"')[1] 
-      : (targetTask.includes('file "') ? targetTask.split('"')[1] : 'Workspace');
-
-    const currentRefactorResult = getEvolutionState().lastRefactorResult;
-
-    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
-      }
-    });
-
-    appendHistory({
-      cycle: 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');
-  }
-
-  private runChildProcess(args: string[]): Promise<number> {
-    return new Promise((resolve) => {
-      const child = 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: number, tokenBudget: number): Promise<void> {
-    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) {}
-    }
-
-    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`);
-        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`);
-
-      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}`);
-      
-      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`);
-        updateEvolutionState({ status: 'idle', currentTask: 'Token budget exceeded' });
-        break;
-      }
-
-      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: string[] = [];
-        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: any) {
-        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`);
-        
-        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: string[] = [];
-          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 = 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 Spinner('DGM - Backtracking: Resetting workspace to stable parent node...');
-              spinner.start();
-              await runCommand(`git reset --hard ${parentNode.commitHash}`);
-              await 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`);
-      
-      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`);
-      
-      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: string, maxGenerations: number = 5): Promise<void> {
-    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 DGMArchive(process.cwd());
-    ResearchManager.startSession(`DGM Evolution: ${task}`, this.effort);
-
-    // Step 1: Measure baseline fitness
-    updateEvolutionState({ status: 'reflecting', currentTask: 'DGM: Measuring baseline fitness' });
-    console.log('\x1b[34m[DGM]\x1b[0m Measuring baseline fitness...');
-    const baselineFitness = await 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 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)}%)`);
-    }
-
-    updateEvolutionState({
-      currentFitness: baselineFitness.score,
-      bestFitness: Math.max(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)
-      updateEvolutionState({ status: 'scanning', currentTask: `DGM Gen ${gen}: Selecting mutation strategy` });
-      const mutationSel = 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 = generateMutationPrompt(mutationSel.strategy, task, {
-        parentEntry: parent,
-        currentFitness: currentBestFitness
-      });
-
-      // 3. Apply mutation via Meta-Agent
-      updateEvolutionState({ status: 'refactoring', currentTask: `DGM Gen ${gen}: Applying ${mutationSel.strategy} mutation` });
-      ResearchManager.logDecision('DGM Mutation', `Gen ${gen}: Applying strategy ${mutationSel.strategy}`, 'info');
-
-      let mutationSucceeded = false;
-      try {
-        await runSelfImprovingTask(mutationTask, this.effort);
-        mutationSucceeded = true;
-      } catch (err: any) {
-        console.error(`\x1b[31m[DGM Gen ${gen}]\x1b[0m Mutation failed: ${err.message}`);
-        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
-      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 evaluateFitness();
-      const comparison = compareToBaseline(candidateFitness, { ...baselineFitness });
-      console.log(`\x1b[${comparison.improved ? '32' : '33'}m[DGM Gen ${gen}]\x1b[0m ${comparison.message}`);
-      ResearchManager.logDecision('DGM Fitness', `Gen ${gen}: ${comparison.message}`, comparison.improved ? 'success' : 'info');
-
-      // 5. Add to archive + commit/rollback decision
-      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 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)}%)`);
-
-        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();
-        ResearchManager.logDecision('DGM Rollback', `Gen ${gen}: Reverted — fitness did not improve`, 'info');
-
-        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();
-      updateEvolutionState({
-        currentFitness: candidateFitness.score,
-        bestFitness: currentBestFitness,
-        dgmPopulationSize: updatedStats.totalEntries,
-        dgmBestEntryId: updatedStats.bestEntryId
-      });
-    }
-
-    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}`);
-    updateEvolutionState({ status: 'idle', currentTask: null });
-  }
-}