claude-evolve 1.7.23 → 1.7.26

package/bin/claude-evolve-worker

@@ -28,17 +28,32 @@ cleanup_on_exit() {
     echo "[WORKER-$$] Worker terminated while processing $CURRENT_CANDIDATE_ID" >&2
     # Grab current status; only reset if it is not already a failure or complete
     echo "[WORKER-$$] Determining status before resetting" >&2
-    "$PYTHON_CMD" -c "
+
+    local reset_output
+    local reset_exit_code
+    reset_output=$("$PYTHON_CMD" -c "
 import sys
 sys.path.insert(0, '$SCRIPT_DIR/..')
 from lib.evolution_csv import EvolutionCSV
 csv = EvolutionCSV('$FULL_CSV_PATH')
 info = csv.get_candidate_info('$CURRENT_CANDIDATE_ID')
 status = info.get('status', '').lower() if info else ''
+print(f'Current status: {status}', file=sys.stderr)
 # Do not reset if already failed, failed-ai-retry, or complete
-    if status and status not in ('complete', 'failed', 'failed-ai-retry', 'failed-parent-missing'):
+if status and status not in ('complete', 'failed', 'failed-ai-retry', 'failed-parent-missing'):
+    print(f'Resetting {status} -> pending', file=sys.stderr)
     csv.update_candidate_status('$CURRENT_CANDIDATE_ID', 'pending')
-" 2>/dev/null || echo "[WORKER-$$] Warning: failed to reset status" >&2
+else:
+    print(f'Status {status} does not need reset', file=sys.stderr)
+" 2>&1)
+    reset_exit_code=$?
+
+    if [[ $reset_exit_code -ne 0 ]]; then
+      echo "[WORKER-$$] Warning: Failed to reset status for $CURRENT_CANDIDATE_ID (exit code $reset_exit_code)" >&2
+      echo "[WORKER-$$] Error details: $reset_output" >&2
+    else
+      echo "[WORKER-$$] Status check result: $reset_output" >&2
+    fi
   fi
 }
 
@@ -596,19 +611,34 @@ with EvolutionCSV('$FULL_CSV_PATH') as csv:
     csv.update_candidate_status('$candidate_id', 'failed-ai-retry')
 " 2>/dev/null || true
   elif [[ $process_exit_code -eq 78 ]]; then
-    # Missing parent; mark as failed-parent-missing for clarity
-    echo "[WORKER-$$] Parent missing for $candidate_id - marking failed-parent-missing"
+    # Missing parent; mark child as failed and auto-recover parent
+    echo "[WORKER-$$] Parent '$parent_id' missing for $candidate_id"
+    echo "[WORKER-$$] Marking $candidate_id as failed-parent-missing"
+    echo "[WORKER-$$] Auto-recovering: marking parent '$parent_id' as pending"
+
     "$PYTHON_CMD" -c "
 import sys
 sys.path.insert(0, '$SCRIPT_DIR/..')
 from lib.evolution_csv import EvolutionCSV
 with EvolutionCSV('$FULL_CSV_PATH') as csv:
+    # Mark child as failed
     csv.update_candidate_status('$candidate_id', 'failed-parent-missing')
-" 2>/dev/null || true
-    # Clear current candidate to avoid cleanup resetting it
+
+    # Auto-recover: mark parent as pending so it gets processed
+    parent_info = csv.get_candidate_info('$parent_id')
+    if parent_info:
+        parent_status = parent_info.get('status', '').lower()
+        if parent_status in ('', 'skipped', 'failed-parent-missing'):
+            csv.update_candidate_status('$parent_id', 'pending')
+            print(f'Auto-recovered parent $parent_id: {parent_status} -> pending', file=sys.stderr)
+        else:
+            print(f'Parent $parent_id has status: {parent_status} (not auto-recovering)', file=sys.stderr)
+    else:
+        print(f'Warning: parent $parent_id not found in CSV', file=sys.stderr)
+" 2>&1 | grep -E "Auto-recovered|Parent.*status|Warning" || true
+
+    # Clear current candidate and continue to next (don't break)
     CURRENT_CANDIDATE_ID=""
-    # Stop looping so we don't keep retrying for missing dependency
-    break
   else
     echo "[WORKER-$$] Failed to process $candidate_id"
     # Other failures (evaluation errors, etc) mark as failed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-evolve",
-  "version": "1.7.23",
+  "version": "1.7.26",
   "bin": {
     "claude-evolve": "./bin/claude-evolve",
     "claude-evolve-main": "./bin/claude-evolve-main",

package/bin/claude-evolve-ideate-py

@@ -1,97 +0,0 @@
-#!/bin/bash
-# Python-based ideation wrapper for claude-evolve
-# This is a simple wrapper that calls the Python ideation helper
-
-set -e
-
-# Load configuration to ensure paths are set up
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=../lib/config.sh
-source "$SCRIPT_DIR/../lib/config.sh"
-
-# Use CLAUDE_EVOLVE_CONFIG if set, otherwise default
-if [[ -n ${CLAUDE_EVOLVE_CONFIG:-} ]]; then
-  load_config "$CLAUDE_EVOLVE_CONFIG"
-else
-  # Check if config.yaml exists in current directory
-  if [[ -f "config.yaml" ]]; then
-    CONFIG_FILE="$(pwd)/config.yaml"
-    load_config "$CONFIG_FILE"
-  else
-    load_config
-  fi
-fi
-
-# Setup logging to file
-if [[ -n "${FULL_EVOLUTION_DIR:-}" ]]; then
-  LOG_DIR="$FULL_EVOLUTION_DIR/logs"
-  mkdir -p "$LOG_DIR"
-  LOG_FILE="$LOG_DIR/ideate-py-$$-$(date +%Y%m%d-%H%M%S).log"
-
-  # Log to both terminal and file with timestamps
-  exec > >(while IFS= read -r line; do echo "$(date '+%Y-%m-%d %H:%M:%S'): $line"; done | tee -a "$LOG_FILE") 2>&1
-  echo "[IDEATE-PY-$$] Logging to: $LOG_FILE"
-fi
-
-# Parse arguments
-use_strategies=true
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-  --help)
-    cat <<EOF
-claude-evolve ideate (Python version) - Generate new algorithm ideas
-
-USAGE:
-  claude-evolve ideate-py [--legacy N]
-
-OPTIONS:
-  --legacy N  Use legacy mode with N ideas (ignores strategy config)
-  --help      Show this help message
-
-DESCRIPTION:
-  Python-based ideation that uses MD5 hashing to verify AI actually modified files.
-  This solves the problem where AIs claim they edited files but didn't.
-
-  Uses multi-strategy evolutionary approach:
-  - Novel exploration: Pure creativity, global search
-  - Hill climbing: Parameter tuning of top performers
-  - Structural mutation: Algorithmic changes to top performers
-  - Crossover hybrid: Combine successful approaches
-
-  Strategy distribution is configured in evolution/config.yaml
-EOF
-    exit 0
-    ;;
-  --legacy)
-    use_strategies=false
-    shift
-    if [[ $1 =~ ^[0-9]+$ ]]; then
-      export LEGACY_IDEA_COUNT=$1
-      shift
-    else
-      echo "[ERROR] --legacy requires a number" >&2
-      exit 1
-    fi
-    ;;
-  *)
-    echo "[ERROR] Unknown option: $1" >&2
-    exit 1
-    ;;
-  esac
-done
-
-# Check workspace using config
-if [[ ! -d "$FULL_EVOLUTION_DIR" ]]; then
-  echo "[ERROR] Evolution workspace not found: $FULL_EVOLUTION_DIR. Run 'claude-evolve setup' first." >&2
-  exit 1
-fi
-
-# Call Python helper
-echo "[INFO] Using Python ideation helper (more reliable AI result verification)"
-
-if [[ $use_strategies == true ]]; then
-  exec "$PYTHON_CMD" "$SCRIPT_DIR/../lib/ideation_helper.py" run
-else
-  exec "$PYTHON_CMD" "$SCRIPT_DIR/../lib/ideation_helper.py" run --legacy "$LEGACY_IDEA_COUNT"
-fi

package/lib/ideation_helper.py

@@ -1,745 +0,0 @@
-#!/usr/bin/env python3
-"""
-Python ideation helper for claude-evolve.
-Replaces the complex shell script logic in claude-evolve-ideate.
-"""
-
-import os
-import sys
-import csv
-import re
-import subprocess
-import tempfile
-import shutil
-import time
-from pathlib import Path
-from typing import List, Tuple, Optional, Dict
-from dataclasses import dataclass
-
-from evolution_csv import EvolutionCSV
-from config import Config
-
-
-@dataclass
-class IdeationStrategy:
-    """Configuration for a single ideation strategy."""
-    name: str
-    count: int
-    parent_required: bool = False
-
-
-class IdeationHelper:
-    """Handles all ideation logic for claude-evolve."""
-
-    def __init__(self, config: Config):
-        """Initialize with configuration."""
-        self.config = config
-        self.working_dir = Path(config.working_dir)
-        self.csv_path = self.working_dir / config.data['csv_file']
-        self.brief_path = self.working_dir / config.data['brief_file']
-        self.output_dir = self.working_dir / (config.data.get('output_dir') or '')
-
-        # Ideation config
-        ideation = config.data.get('ideation', {})
-        self.total_ideas = ideation.get('total_ideas', 15)
-        self.novel_exploration = ideation.get('novel_exploration', 3)
-        self.hill_climbing = ideation.get('hill_climbing', 5)
-        self.structural_mutation = ideation.get('structural_mutation', 3)
-        self.crossover_hybrid = ideation.get('crossover_hybrid', 4)
-        self.num_elites = ideation.get('num_elites', 3)
-        self.num_revolution = ideation.get('num_revolution', 2)
-
-        # Python command
-        self.python_cmd = config.data.get('python_cmd', 'python3')
-
-        # Paths to library scripts
-        self.script_dir = Path(__file__).parent.parent / 'bin'
-        self.lib_dir = Path(__file__).parent
-
-    def get_next_generation(self) -> str:
-        """
-        Get the next generation number that doesn't have existing Python files.
-        Returns formatted generation string like '01', '02', etc.
-        """
-        # Start with generation 1
-        start_gen = 1
-
-        if self.csv_path.exists():
-            # Find max generation from CSV
-            with EvolutionCSV(str(self.csv_path)) as csv_ops:
-                rows = csv_ops._read_csv()
-                max_gen = 0
-
-                for row in rows[1:]:  # Skip header
-                    if row and len(row) > 0:
-                        id_field = row[0].strip()
-                        if id_field.startswith('gen') and '-' in id_field:
-                            try:
-                                gen_part = id_field.split('-')[0]  # e.g., 'gen01'
-                                gen_num = int(gen_part[3:])  # Extract number after 'gen'
-                                max_gen = max(max_gen, gen_num)
-                            except (ValueError, IndexError):
-                                pass
-
-                start_gen = max_gen + 1
-
-        # Keep incrementing until we find a generation with no Python files
-        candidate_gen = start_gen
-        while candidate_gen < 1000:  # Safety limit
-            gen_formatted = f"{candidate_gen:02d}"
-
-            # Check if any Python files exist for this generation
-            py_pattern = self.output_dir / f"evolution_gen{gen_formatted}-*.py"
-            if not list(self.output_dir.glob(f"evolution_gen{gen_formatted}-*.py")):
-                return gen_formatted
-
-            print(f"[WARN] Generation {gen_formatted} already has Python files, skipping",
-                  file=sys.stderr)
-            candidate_gen += 1
-
-        raise RuntimeError("Could not find a safe generation number (checked up to 999)")
-
-    def get_next_id(self, generation: str) -> str:
-        """Get the next available ID for the given generation."""
-        if not self.csv_path.exists():
-            return f"gen{generation}-001"
-
-        max_id = 0
-        pattern = re.compile(rf'^gen{generation}-(\d+)$')
-
-        with EvolutionCSV(str(self.csv_path)) as csv_ops:
-            rows = csv_ops._read_csv()
-            for row in rows[1:]:  # Skip header
-                if row and len(row) > 0:
-                    id_field = row[0].strip()
-                    match = pattern.match(id_field)
-                    if match:
-                        id_num = int(match.group(1))
-                        max_id = max(max_id, id_num)
-
-        return f"gen{generation}-{max_id + 1:03d}"
-
-    def get_next_ids(self, generation: str, count: int) -> List[str]:
-        """Get the next N available IDs for the given generation."""
-        if not self.csv_path.exists():
-            start_id = 1
-        else:
-            max_id = 0
-            pattern = re.compile(rf'^gen{generation}-(\d+)$')
-
-            with EvolutionCSV(str(self.csv_path)) as csv_ops:
-                rows = csv_ops._read_csv()
-                for row in rows[1:]:  # Skip header
-                    if row and len(row) > 0:
-                        id_field = row[0].strip()
-                        match = pattern.match(id_field)
-                        if match:
-                            id_num = int(match.group(1))
-                            max_id = max(max_id, id_num)
-
-            start_id = max_id + 1
-
-        return [f"gen{generation}-{start_id + i:03d}" for i in range(count)]
-
-    def get_top_performers(self, num_requested: int) -> List[Tuple[str, str, float]]:
-        """
-        Get top performing algorithms.
-        Returns list of (id, description, score) tuples.
-        """
-        if not self.csv_path.exists():
-            return []
-
-        with EvolutionCSV(str(self.csv_path)) as csv_ops:
-            rows = csv_ops._read_csv()
-
-            completed = []
-            novel = []
-
-            # Skip header
-            for row in rows[1:]:
-                if len(row) >= 5 and row[3] and row[4] == 'complete':
-                    try:
-                        candidate_id = row[0]
-                        parent_id = row[1] if len(row) > 1 else ''
-                        description = row[2] if len(row) > 2 else ''
-                        score = float(row[3])
-
-                        completed.append((candidate_id, description, score))
-
-                        # Track novel candidates separately
-                        if not parent_id:
-                            novel.append((candidate_id, description, score))
-                    except ValueError:
-                        pass
-
-            # Sort by score (descending)
-            completed.sort(key=lambda x: x[2], reverse=True)
-            novel.sort(key=lambda x: x[2], reverse=True)
-
-            # Collect top performers
-            selected_ids = set()
-            results = []
-
-            # Add top absolute performers
-            for candidate_id, description, score in completed[:num_requested]:
-                results.append((candidate_id, description, score))
-                selected_ids.add(candidate_id)
-
-            # Add top novel candidates (if not already selected)
-            for candidate_id, description, score in novel:
-                if candidate_id not in selected_ids and len([r for r in results if r[0] not in selected_ids]) < self.num_revolution:
-                    results.append((candidate_id, description, score))
-                    selected_ids.add(candidate_id)
-
-            return results
-
-    def call_ai_model(self, model_name: str, prompt: str, timeout: int = 300) -> Tuple[str, int]:
-        """
-        Call an AI model using subprocess.
-        Returns (output, exit_code).
-        """
-        # Map model names to commands
-        model_commands = {
-            'opus': ['claude', '--dangerously-skip-permissions', '--mcp-config', '', '--model', 'opus', '-p', prompt],
-            'sonnet': ['claude', '--dangerously-skip-permissions', '--mcp-config', '', '--model', 'sonnet', '-p', prompt],
-            'haiku': ['claude', '--dangerously-skip-permissions', '--mcp-config', '', '--model', 'haiku', '-p', prompt],
-            'gemini-pro': ['gemini', '-y', '-m', 'gemini-2.5-pro', '-p', prompt],
-            'gemini-flash': ['gemini', '-y', '-m', 'gemini-2.5-flash', '-p', prompt],
-        }
-
-        if model_name not in model_commands:
-            return f"Unknown model: {model_name}", 1
-
-        try:
-            result = subprocess.run(
-                model_commands[model_name],
-                capture_output=True,
-                text=True,
-                timeout=timeout
-            )
-            return result.stdout + result.stderr, result.returncode
-        except subprocess.TimeoutExpired:
-            return f"Model {model_name} timed out after {timeout}s", 124
-        except Exception as e:
-            return f"Error calling model {model_name}: {e}", 1
-
-    def prepopulate_csv_stubs(self, temp_csv: Path, ids: List[str],
-                              placeholder_text: str, parent_id: str = "") -> None:
-        """Pre-populate CSV with stub rows containing placeholders."""
-        print(f"[INFO] Pre-populating CSV with stub rows: {' '.join(ids)}")
-
-        with open(temp_csv, 'a') as f:
-            for id_str in ids:
-                f.write(f'{id_str},{parent_id},"{placeholder_text}",,pending\n')
-
-    def validate_csv_modification(self, temp_csv: Path, expected_count: int,
-                                 original_count: int, required_ids: List[str]) -> bool:
-        """
-        Validate that AI correctly modified the CSV.
-        Returns True if valid, False otherwise.
-        """
-        if not temp_csv.exists():
-            print("[ERROR] CSV file was not found after AI modification", file=sys.stderr)
-            return False
-
-        # Count data rows (skip header, skip empty lines)
-        with open(temp_csv, 'r') as f:
-            lines = [line for line in f if line.strip()]
-            new_count = len(lines) - 1  # Subtract header
-
-        if new_count < original_count:
-            print(f"[ERROR] AI overwrote CSV instead of editing ({new_count} < {original_count})",
-                  file=sys.stderr)
-            return False
-
-        if new_count != original_count:
-            print(f"[ERROR] Row count changed ({new_count} != {original_count})", file=sys.stderr)
-            return False
-
-        # Check that no placeholders remain
-        with open(temp_csv, 'r') as f:
-            content = f.read()
-            if 'PLACEHOLDER' in content:
-                placeholder_count = content.count('PLACEHOLDER')
-                print(f"[ERROR] {placeholder_count} placeholders remain unfilled", file=sys.stderr)
-                return False
-
-        # Validate IDs are correct
-        with open(temp_csv, 'r') as f:
-            reader = csv.reader(f)
-            next(reader)  # Skip header
-            rows = list(reader)
-            actual_ids = [row[0].strip('"') for row in rows[-len(required_ids):]]
-
-        if actual_ids != required_ids:
-            print(f"[ERROR] AI used wrong IDs!", file=sys.stderr)
-            print(f"[ERROR] Expected: {required_ids}", file=sys.stderr)
-            print(f"[ERROR] Got: {actual_ids}", file=sys.stderr)
-            return False
-
-        print(f"[INFO] ✓ AI correctly used the specified IDs: {' '.join(actual_ids)}")
-        return True
-
-    def apply_csv_changes(self, temp_csv: Path, added_count: int,
-                         ai_model: str) -> bool:
-        """
-        Apply changes from temp CSV to main CSV with proper locking.
-        """
-        print("[INFO] Acquiring CSV lock to apply changes...")
-
-        try:
-            with EvolutionCSV(str(self.csv_path)) as csv_ops:
-                # Get the original line count
-                with open(self.csv_path, 'r') as f:
-                    original_lines = len(f.readlines())
-
-                # Append only the new lines from temp CSV
-                with open(temp_csv, 'r') as f_temp:
-                    temp_lines = f_temp.readlines()
-                    new_lines = temp_lines[original_lines:]
-
-                with open(self.csv_path, 'a') as f_main:
-                    f_main.writelines(new_lines)
-
-                # Update idea-LLM field for newly added rows
-                if ai_model:
-                    print(f"[INFO] Recording that {ai_model} generated the ideas")
-                    # Get IDs of newly added rows
-                    reader = csv.reader(new_lines)
-                    for row in reader:
-                        if row and row[0] and row[0] != 'id':
-                            candidate_id = row[0].strip('"')
-                            csv_ops.update_candidate_field(candidate_id, 'idea-LLM', ai_model)
-
-            print(f"[INFO] Successfully added {added_count} ideas to CSV")
-            return True
-
-        except Exception as e:
-            print(f"[ERROR] Failed to apply CSV changes: {e}", file=sys.stderr)
-            return False
-
-    def call_ai_for_ideation(self, prompt: str, generation: str, expected_count: int,
-                            temp_csv_path: Path) -> Optional[str]:
-        """
-        Call AI models in round-robin fashion until one successfully fills placeholders.
-
-        This is the critical function that addresses the main problem:
-        - Takes MD5 hash of CSV before calling AI
-        - Takes MD5 hash after AI completes
-        - Only accepts result if:
-          1. File actually changed (hash is different)
-          2. Row count stayed the same (no adds/deletes)
-          3. All PLACEHOLDERs are gone (AI filled them in)
-
-        Returns the model name that succeeded, or None if all failed.
-        """
-        import hashlib
-
-        # Get models for ideation (hardcoded for now, could be from config)
-        models = ['sonnet', 'gemini-pro', 'opus']
-
-        # Calculate starting index for round-robin
-        gen_num = int(generation.lstrip('0')) if generation.lstrip('0') else 1
-        start_index = gen_num % len(models)
-
-        # Create ordered list based on round-robin
-        ordered_models = [models[(start_index + i) % len(models)] for i in range(len(models))]
-
-        print(f"[AI] Model order for ideate (round-robin): {' '.join(ordered_models)}",
-              file=sys.stderr)
-
-        # Get original CSV count and hash BEFORE calling AI
-        with open(temp_csv_path, 'rb') as f:
-            original_content = f.read()
-            original_hash = hashlib.md5(original_content).hexdigest()
-            original_lines = [line for line in original_content.decode('utf-8').split('\n') if line.strip()]
-            original_count = len(original_lines) - 1  # Subtract header
-
-        print(f"[DEBUG] Pre-AI state: {original_count} rows, hash={original_hash[:8]}...", file=sys.stderr)
-
-        # Backup temp CSV
-        temp_csv_backup = Path(str(temp_csv_path) + '.backup')
-        shutil.copy(temp_csv_path, temp_csv_backup)
-
-        # Try each model
-        for model in ordered_models:
-            print(f"[AI] Attempting ideate with {model}", file=sys.stderr)
-
-            # Restore temp CSV from backup before each attempt
-            shutil.copy(temp_csv_backup, temp_csv_path)
-
-            # Re-hash after restore to ensure we start from known state
-            with open(temp_csv_path, 'rb') as f:
-                pre_call_hash = hashlib.md5(f.read()).hexdigest()
-
-            print(f"[DEBUG] Before {model}: hash={pre_call_hash[:8]}...", file=sys.stderr)
-
-            # Call the model
-            output, exit_code = self.call_ai_model(model, prompt)
-
-            # CRITICAL: Hash the file AFTER the AI call to detect if it actually changed
-            with open(temp_csv_path, 'rb') as f:
-                post_call_content = f.read()
-                post_call_hash = hashlib.md5(post_call_content).hexdigest()
-                post_call_lines = [line for line in post_call_content.decode('utf-8').split('\n') if line.strip()]
-                new_count = len(post_call_lines) - 1  # Subtract header
-
-            print(f"[DEBUG] After {model}: {new_count} rows, hash={post_call_hash[:8]}...", file=sys.stderr)
-
-            # Check 1: Did the file actually change?
-            if post_call_hash == pre_call_hash:
-                print(f"[WARN] {model} CLAIMED to edit but file hash is IDENTICAL - file was NOT modified!",
-                      file=sys.stderr)
-                print(f"[DEBUG] AI output (last 500 chars): ...{output[-500:]}", file=sys.stderr)
-                continue
-
-            print(f"[INFO] ✓ {model} actually modified the file (hash changed)", file=sys.stderr)
-
-            # Check 2: Row count should stay the same (we're editing, not adding)
-            if new_count != original_count:
-                print(f"[WARN] {model} changed row count ({original_count} -> {new_count}) - should only edit, not add/delete",
-                      file=sys.stderr)
-                continue
-
-            print(f"[INFO] ✓ Row count unchanged ({new_count} rows)", file=sys.stderr)
-
-            # Check 3: All placeholders should be gone
-            content_str = post_call_content.decode('utf-8')
-            placeholder_count = content_str.count('PLACEHOLDER')
-
-            if placeholder_count > 0:
-                print(f"[WARN] {model} left {placeholder_count} PLACEHOLDERs unfilled - trying next model",
-                      file=sys.stderr)
-                # Show which rows still have placeholders for debugging
-                for i, line in enumerate(content_str.split('\n')):
-                    if 'PLACEHOLDER' in line:
-                        print(f"[DEBUG] Row {i} still has PLACEHOLDER: {line[:100]}", file=sys.stderr)
-                continue
-
-            print(f"[INFO] ✓ All {expected_count} placeholders filled", file=sys.stderr)
-
-            # All checks passed! This is a successful edit
-            print(f"[INFO] CSV successfully modified by {model}: filled {expected_count} placeholder rows ✓",
-                  file=sys.stderr)
-
-            # Run CSV fixer to ensure proper formatting
-            fixed_csv = Path(str(temp_csv_path) + '.fixed')
-            result = subprocess.run(
-                [self.python_cmd, str(self.lib_dir / 'csv_fixer.py'),
-                 str(temp_csv_path), str(fixed_csv)],
-                capture_output=True
-            )
-
-            if result.returncode == 0:
-                shutil.move(fixed_csv, temp_csv_path)
-                print("[INFO] CSV format validated and fixed if needed", file=sys.stderr)
-            else:
-                print(f"[WARN] CSV fixer failed, using original: {result.stderr.decode()}", file=sys.stderr)
-
-            # Cleanup backup
-            temp_csv_backup.unlink()
-            return model
-
-        # All models failed
-        temp_csv_backup.unlink()
-        print("[ERROR] All AI models failed to generate ideas", file=sys.stderr)
-        print("[ERROR] Either they claimed to edit but didn't, or they added/removed rows instead of editing",
-              file=sys.stderr)
-        return None
-
-    def generate_strategy_ideas(self, strategy_name: str, count: int, generation: str,
-                               top_performers: List[Tuple[str, str, float]]) -> bool:
-        """
-        Generate ideas for a specific strategy.
-        Returns True if successful, False otherwise.
-        """
-        print(f"[INFO] Generating {count} {strategy_name} ideas")
-
-        # Get next IDs
-        next_ids = self.get_next_ids(generation, count)
-        print(f"[INFO] Using IDs: {' '.join(next_ids)}")
-
-        # Create temp CSV
-        temp_csv = self.working_dir / f"temp-csv-{os.getpid()}.csv"
-        shutil.copy(self.csv_path, temp_csv)
-
-        # Pre-populate with stubs
-        placeholder_map = {
-            'novel': '[PLACEHOLDER: Replace this with your algorithmic idea]',
-            'hill-climbing': '[PLACEHOLDER: Replace with parameter tuning idea]',
-            'structural': '[PLACEHOLDER: Replace with structural modification idea]',
-            'crossover': '[PLACEHOLDER: Replace with crossover hybrid idea]'
-        }
-        placeholder_text = placeholder_map.get(strategy_name, '[PLACEHOLDER]')
-
-        # Get parent ID for non-novel strategies
-        parent_id = ""
-        if strategy_name != 'novel' and top_performers:
-            parent_id = top_performers[0][0]
-
-        self.prepopulate_csv_stubs(temp_csv, next_ids, placeholder_text, parent_id)
-
-        # Count lines for offset calculation
-        with open(temp_csv, 'r') as f:
-            total_lines = len(f.readlines())
-        read_offset = max(1, total_lines - 25)
-
-        # Build prompt based on strategy
-        prompt = self._build_strategy_prompt(
-            strategy_name, count, generation, next_ids,
-            top_performers, temp_csv.name, total_lines, read_offset
-        )
-
-        # Change to working directory
-        original_cwd = os.getcwd()
-        os.chdir(self.working_dir)
-
-        try:
-            # Call AI
-            successful_model = self.call_ai_for_ideation(
-                prompt, generation, count, temp_csv
-            )
-
-            if not successful_model:
-                return False
-
-            # Validate
-            with open(self.csv_path, 'r') as f:
-                original_count = len([line for line in f if line.strip()]) - 1
-
-            if not self.validate_csv_modification(temp_csv, count, original_count + count, next_ids):
-                return False
-
-            # Apply changes
-            return self.apply_csv_changes(temp_csv, count, successful_model)
-
-        finally:
-            os.chdir(original_cwd)
-            if temp_csv.exists():
-                temp_csv.unlink()
-
-    def _build_strategy_prompt(self, strategy_name: str, count: int, generation: str,
-                              next_ids: List[str], top_performers: List[Tuple[str, str, float]],
-                              temp_csv_name: str, total_lines: int, read_offset: int) -> str:
-        """Build the AI prompt for a specific strategy."""
-
-        # Common header
-        prompt = f"""I need you to use your file editing capabilities to fill in PLACEHOLDER descriptions in the CSV file: {temp_csv_name}
-
-THE FILE HAS {total_lines} TOTAL LINES. Read from line {read_offset} to see the placeholder rows at the end.
-
-⚠️ CRITICAL FILE READING INSTRUCTIONS ⚠️
-THE CSV FILE IS VERY LARGE (OVER 100,000 TOKENS). YOU WILL RUN OUT OF CONTEXT IF YOU READ IT ALL!
-- DO NOT read the entire file or you will exceed context limits and CRASH
-- Use: Read(file_path='{temp_csv_name}', offset={read_offset}, limit=25)
-- This will read ONLY the last 25 lines where the placeholders are
-- DO NOT READ FROM OFFSET 0 - that will load the entire huge file and fail!
-
-CRITICAL TASK:
-The CSV file already contains {count} stub rows with these IDs: {' '.join(next_ids)}
-Each stub row has a PLACEHOLDER description.
-Your job is to REPLACE each PLACEHOLDER with a real algorithmic idea description.
-
-CRITICAL INSTRUCTIONS:
-1. Read ONLY the last 25 lines using the offset specified above
-2. DO NOT ADD OR DELETE ANY ROWS - only EDIT the placeholder descriptions
-3. DO NOT CHANGE THE IDs - they are already correct
-4. Use the Edit tool to replace EACH PLACEHOLDER text with a real idea
-5. When editing, preserve the CSV structure
-6. ALWAYS wrap descriptions in double quotes
-7. DO NOT use any git commands
-"""
-
-        # Strategy-specific instructions
-        if strategy_name == 'novel':
-            prompt += f"""
-8. Focus on creative, ambitious ideas that haven't been tried yet
-9. Consider machine learning, new indicators, regime detection, risk management, etc.
-10. Each description should be one clear sentence describing a novel algorithmic approach
-
-Current context:
-- Generation: {generation}
-- Brief: {self._get_brief_preview()}
-"""
-
-        elif strategy_name == 'hill-climbing':
-            valid_parent_ids = ','.join([p[0] for p in top_performers])
-            performers_str = '\n'.join([f"{p[0]},{p[1]},{p[2]}" for p in top_performers])
-
-            prompt += f"""
-8. You MUST use one of these exact parent IDs: {valid_parent_ids}
-9. Generate parameter tuning ideas based on these top performers:
-{performers_str}
-
-10. Focus on adjusting specific parameters - include current and new values
-11. Example: "Lower rsi_entry from 21 to 18" or "Increase MA period from 20 to 50"
-12. You may change the parent_id field to reference a different top performer
-"""
-
-        elif strategy_name == 'structural':
-            valid_parent_ids = ','.join([p[0] for p in top_performers])
-            performers_str = '\n'.join([f"{p[0]},{p[1]},{p[2]}" for p in top_performers])
-
-            prompt += f"""
-8. You MUST use one of these exact parent IDs: {valid_parent_ids}
-9. Generate structural modification ideas based on these top performers:
-{performers_str}
-
-10. Focus on architectural/structural changes
-11. DO NOT read evolution_*.py files - generate ideas based on descriptions only
-12. You may change the parent_id field to reference a different top performer
-"""
-
-        elif strategy_name == 'crossover':
-            valid_parent_ids = ','.join([p[0] for p in top_performers])
-            performers_str = '\n'.join([f"{p[0]},{p[1]},{p[2]}" for p in top_performers])
-
-            prompt += f"""
-8. You MUST use ONLY these exact parent IDs: {valid_parent_ids}
-9. Combine 2+ algorithms from these top performers:
-{performers_str}
-
-10. Each description should combine actual elements from 2+ top performers
-11. Reference at least 2 algorithms in each idea
-12. You may change the parent_id field (choose the primary parent)
-"""
-
-        return prompt
-
-    def _get_brief_preview(self) -> str:
-        """Get a preview of the brief file."""
-        if not self.brief_path.exists():
-            return "No brief file found"
-
-        with open(self.brief_path, 'r') as f:
-            lines = f.readlines()[:5]
-            text = ''.join(lines)
-            return text[:500] if len(text) > 500 else text
-
-    def run_ideation(self, generation: str, use_strategies: bool = True) -> bool:
-        """
-        Run the full ideation process.
-        Returns True if successful, False otherwise.
-        """
-        if not self.brief_path.exists():
-            print(f"[ERROR] {self.config.data['brief_file']} not found", file=sys.stderr)
-            return False
-
-        # Ensure CSV exists
-        if not self.csv_path.exists():
-            with open(self.csv_path, 'w') as f:
-                f.write("id,basedOnId,description,performance,status,idea-LLM,run-LLM\n")
-
-        if use_strategies:
-            # Validate strategy configuration
-            total_check = (self.novel_exploration + self.hill_climbing +
-                          self.structural_mutation + self.crossover_hybrid)
-            if total_check != self.total_ideas:
-                print(f"[ERROR] Strategy counts don't sum to total_ideas ({total_check} != {self.total_ideas})",
-                      file=sys.stderr)
-                return False
-
-            print(f"[INFO] Generating {self.total_ideas} ideas using multi-strategy approach:")
-            print(f"  Novel exploration: {self.novel_exploration}")
-            print(f"  Hill climbing: {self.hill_climbing}")
-            print(f"  Structural mutation: {self.structural_mutation}")
-            print(f"  Crossover hybrid: {self.crossover_hybrid}")
-
-            # Get top performers
-            top_performers = self.get_top_performers(self.num_elites)
-            if not top_performers:
-                print("[INFO] No completed algorithms found, will use baseline for hill climbing")
-                top_performers = [("000", "Baseline Algorithm (algorithm.py)", 0.0)]
-
-            # Run each strategy
-            strategies_attempted = 0
-            strategies_succeeded = 0
-
-            strategies = [
-                ('novel', self.novel_exploration, False),
-                ('hill-climbing', self.hill_climbing, True),
-                ('structural', self.structural_mutation, True),
-                ('crossover', self.crossover_hybrid, True),
-            ]
-
-            for strategy_name, count, needs_parents in strategies:
-                if count > 0:
-                    strategies_attempted += 1
-                    parents = top_performers if needs_parents else []
-
-                    if self.generate_strategy_ideas(strategy_name, count, generation, parents):
-                        strategies_succeeded += 1
-                    else:
-                        print(f"[WARN] {strategy_name} strategy failed", file=sys.stderr)
-
-            print(f"[INFO] Strategy results: {strategies_succeeded}/{strategies_attempted} succeeded")
-
-            # REQUIRE ALL strategies to succeed
-            if strategies_succeeded == strategies_attempted:
-                return True
-            else:
-                print(f"[ERROR] Not all strategies succeeded ({strategies_succeeded}/{strategies_attempted})",
-                      file=sys.stderr)
-                print("[ERROR] Rejecting partial results - will retry with exponential backoff",
-                      file=sys.stderr)
-                return False
-        else:
-            # Legacy mode - not implemented yet
-            print("[ERROR] Legacy mode not implemented in Python helper yet", file=sys.stderr)
-            return False
-
-
-def main():
-    """CLI interface for testing."""
-    if len(sys.argv) < 2:
-        print("Usage: ideation_helper.py <command> [args...]")
-        print("Commands:")
-        print("  run [--legacy N]  - Run ideation")
-        sys.exit(1)
-
-    command = sys.argv[1]
-
-    # Load config
-    config = Config()
-    config_path = os.environ.get('CLAUDE_EVOLVE_CONFIG')
-    if config_path:
-        config.load(config_path)
-    elif Path('config.yaml').exists():
-        config.load('config.yaml')
-    else:
-        config.load()
-
-    helper = IdeationHelper(config)
-
-    if command == 'run':
-        use_strategies = True
-        if len(sys.argv) > 2 and sys.argv[2] == '--legacy':
-            use_strategies = False
-
-        generation = helper.get_next_generation()
-        print(f"[INFO] Starting ideation for generation {generation}")
-
-        # Run with retry logic
-        retry_count = 0
-        wait_seconds = 300  # 5 minutes
-        max_wait_seconds = 1800  # 30 minutes
-
-        while True:
-            if helper.run_ideation(generation, use_strategies):
-                print(f"[INFO] Ideation complete! Check {helper.csv_path} for new ideas.")
-                sys.exit(0)
-
-            retry_count += 1
-            print(f"[WARN] All ideation attempts failed (retry #{retry_count})", file=sys.stderr)
-            print(f"[INFO] Waiting {wait_seconds} seconds before retrying...", file=sys.stderr)
-
-            time.sleep(wait_seconds)
-
-            wait_seconds = min(wait_seconds * 2, max_wait_seconds)
-    else:
-        print(f"Unknown command: {command}")
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    main()