claude-evolve 1.3.41 → 1.3.43

package/bin/claude-evolve-csv-fix

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+Clean up malformed CSV files by removing excessive trailing empty fields.
+Fixes issues where rows have too many trailing commas.
+"""
+
+import csv
+import sys
+import os
+import argparse
+from typing import List
+
+def clean_csv_row(row: List[str], expected_min_cols: int = 5) -> List[str]:
+    """Remove trailing empty fields from a CSV row, keeping minimum required columns."""
+    # Remove trailing empty strings
+    while len(row) > expected_min_cols and row[-1] == '':
+        row.pop()
+    
+    # Ensure we have at least the minimum required columns
+    while len(row) < expected_min_cols:
+        row.append('')
+    
+    return row
+
+def clean_csv_file(filepath: str, backup: bool = True, dry_run: bool = False) -> int:
+    """Clean a CSV file by removing excessive trailing empty fields."""
+    
+    if not os.path.exists(filepath):
+        print(f"❌ File not found: {filepath}")
+        return 1
+    
+    # Read the original CSV
+    with open(filepath, 'r') as f:
+        reader = csv.reader(f)
+        headers = next(reader, [])
+        rows = list(reader)
+    
+    if not headers:
+        print(f"❌ Empty CSV file: {filepath}")
+        return 1
+    
+    print(f"📊 Original CSV: {len(rows)} rows, max {max(len(row) for row in rows) if rows else 0} columns")
+    
+    # Clean each row
+    cleaned_rows = []
+    changes_made = 0
+    
+    for i, row in enumerate(rows):
+        original_len = len(row)
+        cleaned_row = clean_csv_row(row.copy())
+        cleaned_rows.append(cleaned_row)
+        
+        if len(cleaned_row) != original_len:
+            changes_made += 1
+            if dry_run:
+                print(f"  🔧 Row {i+2}: {original_len} → {len(cleaned_row)} columns")
+    
+    if changes_made == 0:
+        print("✅ No changes needed - CSV is already clean")
+        return 0
+    
+    print(f"🔧 Cleaned {changes_made} rows")
+    
+    if dry_run:
+        print("🔍 Dry run mode - no changes written")
+        return 0
+    
+    # Create backup if requested
+    if backup:
+        backup_file = f"{filepath}.backup.{os.getpid()}"
+        os.rename(filepath, backup_file)
+        print(f"💾 Backup created: {backup_file}")
+    
+    # Write cleaned CSV
+    with open(filepath, 'w', newline='') as f:
+        writer = csv.writer(f)
+        writer.writerow(headers)
+        writer.writerows(cleaned_rows)
+    
+    new_max_cols = max(len(row) for row in cleaned_rows) if cleaned_rows else 0
+    print(f"✅ Cleaned CSV: {len(cleaned_rows)} rows, max {new_max_cols} columns")
+    
+    return 0
+
+def main():
+    parser = argparse.ArgumentParser(description="Clean up malformed CSV files")
+    parser.add_argument("csv_file", help="Path to CSV file to clean")
+    parser.add_argument("--no-backup", action="store_true", help="Don't create backup file")
+    parser.add_argument("--dry-run", action="store_true", help="Show what would be changed without making changes")
+    
+    args = parser.parse_args()
+    
+    try:
+        return clean_csv_file(args.csv_file, backup=not args.no_backup, dry_run=args.dry_run)
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

package/bin/claude-evolve-edit

@@ -25,23 +25,27 @@ USAGE:
 SELECTORS:
   gen01, gen02, etc.  Target specific generation
   all                 Target all generations
-  failed              Target all candidates with failed status
+  failed              Target all candidates with failed status (includes retries)
   complete            Target all candidates with complete status
   pending             Target all candidates with pending status
   running             Target all candidates with running status
 
 ACTIONS:
-  failed    Mark candidates as failed (keeps scores)
-  complete  Mark candidates as complete (keeps scores)  
-  pending   Mark candidates as pending (keeps scores)
-  reboot    Reset completely (delete .py files, clear scores, set pending)
+  failed           Mark candidates as failed (keeps scores)
+  complete         Mark candidates as complete (keeps scores)  
+  pending          Mark candidates as pending (keeps scores)
+  failed-retry1    Mark candidates for retry attempt 1 (bug fixing)
+  failed-retry2    Mark candidates for retry attempt 2 (bug fixing)
+  failed-retry3    Mark candidates for retry attempt 3 (bug fixing)
+  reboot           Reset completely (delete .py files, clear scores, set pending)
 
 EXAMPLES:
-  claude-evolve edit gen03 failed     # Mark all gen03 as failed
-  claude-evolve edit failed pending   # Reset all failed candidates to pending
-  claude-evolve edit complete failed  # Mark all complete as failed for re-run
-  claude-evolve edit all pending      # Mark everything as pending for re-run
-  claude-evolve edit gen02 reboot     # Full reset of gen02 (delete files + clear data)
+  claude-evolve edit gen03 failed        # Mark all gen03 as failed
+  claude-evolve edit failed pending      # Reset all failed candidates to pending
+  claude-evolve edit failed failed-retry1 # Convert failed to retry status (bug fixing)
+  claude-evolve edit complete failed     # Mark all complete as failed for re-run
+  claude-evolve edit all pending         # Mark everything as pending for re-run
+  claude-evolve edit gen02 reboot        # Full reset of gen02 (delete files + clear data)
 
 DESCRIPTION:
   This command helps manage evolution runs when you need to re-evaluate candidates.
@@ -73,9 +77,9 @@ fi
 
 # Validate action
 case "$ACTION" in
-  failed|complete|pending|reboot) ;;
+  failed|complete|pending|failed-retry1|failed-retry2|failed-retry3|reboot) ;;
   *)
-    echo "[ERROR] Action must be one of: failed, complete, pending, reboot" >&2
+    echo "[ERROR] Action must be one of: failed, complete, pending, failed-retry1, failed-retry2, failed-retry3, reboot" >&2
     exit 1
     ;;
 esac
@@ -100,12 +104,14 @@ update_candidates_status() {
 import csv
 import sys
 import os
+import re
 
 csv_file = '$FULL_CSV_PATH'
 selector = '$selector'
 new_status = '$new_status'
 clear_scores = '$clear_scores' == 'true'
 
+
 try:
     # Read CSV
     with open(csv_file, 'r') as f:
@@ -139,6 +145,8 @@ try:
             # Status selector
             if selector == 'pending':
                 matches = current_status == '' or current_status == 'pending'
+            elif selector == 'failed':
+                matches = current_status.startswith('failed')
             else:
                 matches = current_status == selector
         
@@ -210,10 +218,12 @@ delete_evolution_files() {
     candidates_to_delete=$("$PYTHON_CMD" -c "
 import csv
 import sys
+import re
 
 csv_file = '$FULL_CSV_PATH'
 selector = '$selector'
 
+
 try:
     with open(csv_file, 'r') as f:
         reader = csv.reader(f)
@@ -231,6 +241,8 @@ try:
             matches = False
             if selector == 'pending':
                 matches = current_status == '' or current_status == 'pending'
+            elif selector == 'failed':
+                matches = current_status.startswith('failed')
             else:
                 matches = current_status == selector
             
@@ -278,6 +290,15 @@ case "$ACTION" in
   pending)
     update_candidates_status "$SELECTOR" "" "false"  # Empty status means pending
     ;;
+  failed-retry1)
+    update_candidates_status "$SELECTOR" "failed-retry1" "false"
+    ;;
+  failed-retry2)
+    update_candidates_status "$SELECTOR" "failed-retry2" "false"
+    ;;
+  failed-retry3)
+    update_candidates_status "$SELECTOR" "failed-retry3" "false"
+    ;;
   reboot)
     echo "[INFO] Performing full reboot of '$SELECTOR'..."
     delete_evolution_files "$SELECTOR"

package/bin/claude-evolve-ideate

@@ -328,10 +328,25 @@ CRITICAL CSV FORMAT RULES:
   * Are impossible given the codebase structure
   * Would break the algorithm interface requirements
 
+⚠️ AVOID ONLY: Kelly floor/cap adjustments that assume leverage > 1.0 (these get clamped and have no effect)
+
+✅ EXPLORE ANY CREATIVE IDEAS INCLUDING:
+- **Machine Learning**: Neural networks, decision trees, ensemble methods (use train() method properly)
+- **New Indicators**: Custom combinations, alternative calculations, multi-timeframe signals
+- **Market Regime Detection**: VIX patterns, correlation shifts, volume analysis, cross-asset signals
+- **Risk Management**: Dynamic stops, correlation-based position sizing, drawdown protection
+- **Timing**: Time-of-day effects, calendar patterns, volatility timing
+- **Alternative Strategies**: New sub-strategies, momentum scoring, mean reversion variants
+- **Cross-Asset Signals**: Bond yields, sector rotation, crypto correlations
+- **Multi-Timeframe**: Combining 30m/1h/daily signals for confirmation
+- **Advanced Exits**: Profit targets, time-based exits, volatility-based exits
+
+Think outside the box! The codebase supports sophisticated approaches - be creative and ambitious.
+
 Example descriptions:
-- Use ensemble of 3 random forests with different feature subsets
-- Replace neural network with gradient boosting decision trees
-- Implement Monte Carlo tree search for feature selection
+- Train LSTM network on 30-day OHLCV sequences to predict next-day direction probability
+- Add cross-correlation filter that reduces positions when TQQQ correlation with QQQ breaks down
+- Implement intraday momentum using 30-minute data to adjust daily position sizes
 
 Add exactly $count rows to the CSV file now."
 
@@ -391,10 +406,22 @@ CRITICAL CSV FORMAT RULES:
   * What changes made this algorithm successful vs its parent
   * What parameter ranges make sense given the implementation
 
+⚠️ AVOID ONLY: Kelly floor/cap adjustments that assume leverage > 1.0 (these get clamped and have no effect)
+
+✅ EXPLORE PARAMETER TUNING INCLUDING:
+- **Entry/Exit Thresholds**: IBS_BUY_THRESHOLD, LARISSA_LOW_THRESHOLD, RSI levels, etc.
+- **Indicator Periods**: ATR_PERIOD, RSI_PERIOD, moving average lengths, etc.
+- **Strategy Weights**: Emphasize best performers or rebalance for diversification
+- **Risk Parameters**: Stop levels, timeout periods, correlation thresholds
+- **Regime Parameters**: Volatility thresholds, trend detection sensitivity
+- **ML Hyperparameters**: Learning rates, network sizes, ensemble weights (if using ML)
+
+Be creative with parameter combinations and ranges - the system is sophisticated!
+
 Example descriptions:
-- Increase learning rate from 0.001 to 0.01 for faster convergence
-- Reduce batch size from 32 to 16 to improve gradient estimates
-- Set dropout rate to 0.3 instead of 0.1 to prevent overfitting
+- Lower IBS_BUY_THRESHOLD from 0.15 to 0.12 to enter deeper oversold conditions
+- Increase TRS_RSI_PERIOD from 2 to 3 for smoother RSI signals
+- Raise WEIGHT_TDD from 0.38 to 0.42 to emphasize best performing strategy
 
 Add exactly $count parameter tuning rows to the CSV file now."
 
@@ -454,10 +481,23 @@ CRITICAL CSV FORMAT RULES:
   * What architectural decisions led to this algorithm's success
   * Which components are essential vs which can be replaced
 
+⚠️ AVOID ONLY: Kelly floor/cap adjustments that assume leverage > 1.0 (these get clamped and have no effect)
+
+✅ EXPLORE STRUCTURAL INNOVATIONS INCLUDING:
+- **Algorithm Architecture**: Replace sub-strategies, change combination logic, add new layers
+- **Indicator Swaps**: RSI → Stochastic, SMA → Hull MA, Bollinger → Keltner, etc.
+- **Machine Learning Integration**: Add neural networks, decision trees, reinforcement learning
+- **Market Regime Systems**: Multi-regime detection, regime-specific strategies
+- **Risk Management Overhauls**: Portfolio heat, correlation-based sizing, adaptive stops
+- **Multi-Asset Integration**: Cross-asset signals, sector rotation, bond/equity relationships
+- **Time-Based Innovations**: Intraday patterns, calendar effects, volatility timing
+
+The codebase is flexible - think architecturally about major improvements!
+
 Example descriptions:
-- Replace linear layers with convolutional layers for spatial feature learning
-- Use bidirectional LSTM instead of unidirectional for better context
-- Add residual connections between layers to improve gradient flow
+- Replace 2-period RSI with LSTM-predicted momentum scores for TRS strategy
+- Add ensemble voting system where sub-strategies vote on market regime
+- Implement hierarchical risk budgeting with correlation-adjusted position sizing
 
 Add exactly $count structural modification rows to the CSV file now."
 
@@ -517,10 +557,23 @@ CRITICAL CSV FORMAT RULES:
   * Understand which components are compatible for merging
   * Ensure the combined approach is technically feasible in the codebase
 
+⚠️ AVOID ONLY: Kelly floor/cap adjustments that assume leverage > 1.0 (these get clamped and have no effect)
+
+✅ EXPLORE CREATIVE COMBINATIONS INCLUDING:
+- **Strategy Fusion**: Merge successful sub-strategies, combine entry/exit logic
+- **Indicator Blending**: Mix different technical analysis approaches from successful algorithms
+- **Machine Learning Hybrids**: Combine ML predictions with rule-based systems
+- **Multi-Regime Integration**: Blend different regime detection methods
+- **Risk System Combinations**: Merge multiple risk management approaches
+- **Cross-Asset Blends**: Combine internal signals with external market data
+- **Multi-Timeframe Fusion**: Blend signals from different time horizons
+
+Think creatively about what worked in different algorithms and how to combine them!
+
 Example descriptions:
-- Combine ensemble voting from algorithm 3 with feature selection from algorithm 5
-- Use the attention mechanism from algorithm 2 with the optimizer from algorithm 4
-- Merge the preprocessing pipeline from algorithm 1 with the architecture from algorithm 6
+- Combine VIX regime filter from algorithm 3 with LSTM predictions from algorithm 5
+- Merge volatility regime detection with machine learning momentum scoring
+- Integrate multi-timeframe signals with correlation-based position adjustments
 
 Add exactly $count hybrid combination rows to the CSV file now."
 
@@ -591,6 +644,20 @@ CRITICAL CSV FORMAT RULES:
 - Leave performance and status fields completely empty (just commas)
 - Use proper CSV quoting only when descriptions contain commas
 
+⚠️ AVOID ONLY: Kelly floor/cap adjustments that assume leverage > 1.0 (these get clamped and have no effect)
+
+✅ EXPLORE ALL CREATIVE POSSIBILITIES INCLUDING:
+- **Machine Learning**: Neural networks, ensemble methods, reinforcement learning (use train() method)
+- **Advanced Indicators**: Custom combinations, multi-timeframe signals, cross-asset indicators
+- **Market Regime Detection**: VIX patterns, correlation analysis, volatility clustering
+- **Risk Management**: Dynamic stops, portfolio heat, correlation-based position sizing
+- **Alternative Strategies**: New sub-strategies, momentum variants, mean reversion innovations
+- **Multi-Asset Signals**: Sector rotation, bond yields, commodity signals
+- **Time-Based Patterns**: Intraday effects, calendar anomalies, volatility timing
+- **Parameter Optimization**: Entry thresholds, indicator periods, strategy weights
+
+Think outside the box - the system is sophisticated and can handle advanced approaches!
+
 Add exactly $TOTAL_IDEAS algorithm variation rows to the CSV file now."
 
   echo "[INFO] Generating $TOTAL_IDEAS ideas (legacy mode)..."

package/bin/claude-evolve-run

@@ -236,7 +236,6 @@ cleanup_workers() {
       # Worker finished
       if wait "$pid" 2>/dev/null; then
         echo "[DISPATCHER] Worker $pid completed successfully"
-        consecutive_failures=0  # Reset counter on success
       else
         local exit_code=$?
         if [[ $exit_code -eq 2 ]]; then
@@ -244,24 +243,7 @@ cleanup_workers() {
           # Rate limits don't count as consecutive failures
         else
           echo "[DISPATCHER] Worker $pid failed with exit code $exit_code"
-          ((consecutive_failures++))
-          
-          # Check if we've hit the failure limit
-          if [[ $consecutive_failures -ge $MAX_CONSECUTIVE_FAILURES ]]; then
-            echo "" >&2
-            echo "⚠️  EVOLUTION PAUSED: Multiple consecutive failures detected" >&2
-            echo "⚠️  $consecutive_failures consecutive worker failures - indicates systemic issues" >&2
-            echo "⚠️  Possible causes: Claude API issues, evaluator bugs, configuration problems" >&2
-            echo "⚠️  Check recent worker logs in logs/ directory for specific error details" >&2
-            echo "⚠️  Fix issues before restarting evolution" >&2
-            echo "" >&2
-            
-            # Shutdown all workers and exit
-            shutdown_workers
-            exit 1
-          fi
-          
-          echo "[DISPATCHER] Consecutive failures: $consecutive_failures/$MAX_CONSECUTIVE_FAILURES"
+          # With retry mechanism, failures are normal - just keep processing
         fi
       fi
     fi
@@ -406,9 +388,8 @@ else
   echo "[DISPATCHER] No cleanup issues detected - proceeding with run"
 fi
 
-# Consecutive failure tracking
-consecutive_failures=0
-MAX_CONSECUTIVE_FAILURES=5
+# With retry mechanism, we don't need consecutive failure tracking
+# Failures are handled gracefully through the retry system
 
 # Main dispatch loop
 while true; do

package/bin/claude-evolve-status

@@ -105,12 +105,23 @@ fi
 "$PYTHON_CMD" -c "
 import csv
 import sys
+import re
 
 csv_file = '$FULL_CSV_PATH'
 show_brief = '$SHOW_BRIEF' == 'true'
 show_winner_only = '$SHOW_WINNER_ONLY' == 'true'
 evolution_context = '$EVOLUTION_CONTEXT'
 
+def normalize_status(status):
+    '''Convert retry statuses to base status for counting.'''
+    if status.startswith('failed'):
+        return 'failed'
+    return status
+
+def is_retry_status(status):
+    '''Check if status is a retry status.'''
+    return bool(re.match(r'^failed-retry[0-9]+$', status))
+
 try:
     with open(csv_file, 'r') as f:
         reader = csv.reader(f)
@@ -126,6 +137,7 @@ try:
     all_candidates = []
     stats_by_gen = {}
     total_stats = {'pending': 0, 'complete': 0, 'failed': 0, 'running': 0}
+    retry_count = 0
     
     for row in rows[1:]:
         if len(row) >= 1 and row[0]:  # Must have an ID
@@ -139,19 +151,26 @@ try:
                 status = row[4] if len(row) > 4 and row[4] else 'pending'
                 performance = row[3] if len(row) > 3 and row[3] else ''
                 
+                # Normalize status (failed-retry* becomes failed)
+                normalized_status = normalize_status(status)
+                
+                # Count retries
+                if is_retry_status(status):
+                    retry_count += 1
+                
                 # Track by generation
                 if gen not in stats_by_gen:
                     stats_by_gen[gen] = {'pending': 0, 'complete': 0, 'failed': 0, 'running': 0}
                 
-                if status in stats_by_gen[gen]:
-                    stats_by_gen[gen][status] += 1
-                    total_stats[status] += 1
+                if normalized_status in stats_by_gen[gen]:
+                    stats_by_gen[gen][normalized_status] += 1
+                    total_stats[normalized_status] += 1
                 else:
                     stats_by_gen[gen]['pending'] += 1
                     total_stats['pending'] += 1
                 
                 # Collect for winner analysis (only completed with valid scores)
-                if status == 'complete' and performance:
+                if normalized_status == 'complete' and performance:
                     try:
                         score = float(performance)
                         description = row[2] if len(row) > 2 else 'No description'
@@ -183,7 +202,10 @@ try:
         print(f'📊 OVERALL: {total_candidates} total candidates')
         print(f'   • {total_stats[\"pending\"]} pending')
         print(f'   • {total_stats[\"complete\"]} complete') 
-        print(f'   • {total_stats[\"failed\"]} failed')
+        failed_display = f'{total_stats[\"failed\"]} failed'
+        if retry_count > 0:
+            failed_display += f' ({retry_count} retries)'
+        print(f'   • {failed_display}')
         print(f'   • {total_stats[\"running\"]} running')
         print()
     

package/bin/claude-evolve-worker

@@ -18,6 +18,59 @@ cleanup_temp() {
 # Set trap to clean up temp files on exit
 trap cleanup_temp EXIT INT TERM
 
+# Function to handle failures with retry logic
+handle_failure() {
+  local candidate_id="$1"
+  local current_status="$2"
+  local performance="${3:-0}"
+  
+  # If this is already a retry, increment the retry count
+  if [[ $current_status =~ ^failed-retry([0-9]+)$ ]]; then
+    local retry_num=${BASH_REMATCH[1]}
+    local new_retry_num=$((retry_num + 1))
+    
+    if [[ $new_retry_num -le $MAX_RETRIES ]]; then
+      local new_status="failed-retry${new_retry_num}"
+      update_csv_row_with_lock "$candidate_id" "status" "$new_status"
+      update_csv_row_with_lock "$candidate_id" "performance" "$performance"
+      echo "[WORKER-$$] ✗ Retry $retry_num failed, marked as $new_status"
+      exit 1
+    else
+      update_csv_row_with_lock "$candidate_id" "status" "failed"
+      update_csv_row_with_lock "$candidate_id" "performance" "$performance"
+      echo "[WORKER-$$] ✗ Max retries ($MAX_RETRIES) exceeded, marking as permanently failed"
+      exit 1
+    fi
+  elif [[ $current_status == "failed" ]]; then
+    # Initial failure, convert to retry1 if retries are enabled
+    if [[ $MAX_RETRIES -gt 0 ]]; then
+      update_csv_row_with_lock "$candidate_id" "status" "failed-retry1"
+      update_csv_row_with_lock "$candidate_id" "performance" "$performance"
+      echo "[WORKER-$$] ✗ Initial failure, marked as failed-retry1 for retry"
+      exit 1
+    else
+      update_csv_row_with_lock "$candidate_id" "status" "failed"
+      update_csv_row_with_lock "$candidate_id" "performance" "$performance"
+      echo "[WORKER-$$] ✗ Failed (retries disabled)"
+      # Use exit code 1 - systemic issue since retries are disabled
+      exit 1
+    fi
+  else
+    # Not a failure scenario, convert to retry1 if retries enabled
+    if [[ $MAX_RETRIES -gt 0 ]]; then
+      update_csv_row_with_lock "$candidate_id" "status" "failed-retry1"
+      update_csv_row_with_lock "$candidate_id" "performance" "$performance"
+      echo "[WORKER-$$] ✗ Evaluation failed, marked as failed-retry1 for retry"
+      exit 1
+    else
+      update_csv_row_with_lock "$candidate_id" "status" "failed"
+      update_csv_row_with_lock "$candidate_id" "performance" "$performance"
+      echo "[WORKER-$$] ✗ Evaluation failed (retries disabled)"
+      exit 1
+    fi
+  fi
+}
+
 # Load configuration
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=../lib/config.sh
@@ -59,14 +112,25 @@ done
 
 # If no ID provided, find next pending
 if [[ -z $candidate_id ]]; then
-  candidate_id=$(find_next_pending_with_lock)
-  if [[ -z $candidate_id ]]; then
+  candidate_result=$(find_next_pending_with_lock)
+  if [[ -z $candidate_result ]]; then
     echo "[DEBUG] No pending candidates found" >&2
     exit 0
   fi
+  
+  # Parse candidate_id|original_status format
+  if [[ $candidate_result == *"|"* ]]; then
+    candidate_id="${candidate_result%|*}"  # Everything before |
+    original_candidate_status="${candidate_result#*|}"  # Everything after |
+  else
+    # Fallback for old format (shouldn't happen)
+    candidate_id="$candidate_result"
+    original_candidate_status=""
+  fi
 else
   # Mark specified candidate as running
   update_csv_row_with_lock "$candidate_id" "status" "running"
+  original_candidate_status=""  # Unknown for manually specified candidates
 fi
 
 echo "[WORKER-$$] Processing candidate ID: $candidate_id"
@@ -124,6 +188,23 @@ fi
 echo "[WORKER-$$] Description: $description"
 echo "[WORKER-$$] Based on ID: $based_on_id"
 
+# AIDEV-NOTE: Retry logic - detect if this is a retry attempt
+is_retry=false
+retry_count=0
+# Use original_candidate_status for retry detection (if available), otherwise fall back to CSV status
+retry_status="$original_candidate_status"
+if [[ -z "$retry_status" ]]; then
+  retry_status="$status"
+fi
+
+if [[ $retry_status =~ ^failed-retry([0-9]+)$ ]]; then
+  is_retry=true
+  retry_count=${BASH_REMATCH[1]}
+  echo "[WORKER-$$] 🔄 Processing retry attempt #$retry_count"
+elif [[ $retry_status == "failed" ]]; then
+  echo "[WORKER-$$] ⚠️ Initial failure detected - this should be converted to failed-retry1 to enable retries"
+fi
+
 # AIDEV-NOTE: Using common evolution processor logic for consistent handling
 # Determine parent algorithm
 if [[ -z $based_on_id || $based_on_id == "0" || $based_on_id == '""' ]]; then
@@ -139,7 +220,7 @@ else
   
   if [[ ! -f $parent_file ]]; then
     echo "[ERROR] Parent algorithm not found: $parent_file" >&2
-    update_csv_row_with_lock "$candidate_id" "status" "failed"
+    handle_failure "$candidate_id" "$retry_status" "0"
     exit 1
   fi
 fi
@@ -155,11 +236,28 @@ fi
 temp_file="${output_file}.tmp$$"
 
 # Check if processing should be skipped using common logic
+# Set environment variable for retry detection
+if [[ $is_retry == "true" ]]; then
+  export RETRY_CANDIDATE=true
+else
+  export RETRY_CANDIDATE=false
+fi
+
 eval "$("$PYTHON_CMD" "$SCRIPT_DIR/../lib/evolution_processor.py" "$id" "$based_on_id" "$FULL_OUTPUT_DIR" "$ROOT_DIR" "$parent_file" "$output_file")"
 
 # Handle copy operation to temp file
 if [[ "$skip_copy" == "True" ]]; then
   echo "[WORKER-$$] ⚠️  Skipping copy - $reason"
+elif [[ $is_retry == "true" ]]; then
+  # For retries, edit the existing failed algorithm in-place
+  if [[ -f "$output_file" ]]; then
+    cp "$output_file" "$temp_file"
+    echo "[WORKER-$$] 🔄 Copied existing algorithm for retry: $temp_file"
+  else
+    # Fallback to parent if existing file doesn't exist
+    cp "$parent_file" "$temp_file"
+    echo "[WORKER-$$] ⚠️ Existing algorithm not found, using parent: $temp_file"
+  fi
 else
   cp "$parent_file" "$temp_file"
   echo "[WORKER-$$] Copied parent to temp file: $temp_file"
@@ -178,15 +276,28 @@ else
   claude_cmd="${CLAUDE_CMD:-claude}"
   if ! command -v "$claude_cmd" >/dev/null 2>&1; then
     echo "[ERROR] Claude CLI not found" >&2
-    update_csv_row_with_lock "$candidate_id" "status" "failed"
+    handle_failure "$candidate_id" "$retry_status" "0"
     exit 1
   fi
   
   CLAUDE_MODEL="sonnet"
   echo "[WORKER-$$] Using Claude $CLAUDE_MODEL for mutation"
   
-  # Create mutation prompt
-  prompt="Edit the file $temp_file to implement this specific change: $description
+  # Create mutation prompt (different for retries vs initial attempts)
+  if [[ $is_retry == "true" ]]; then
+    prompt="Fix the bugs in the file $temp_file. This algorithm was attempting to implement: $description
+
+The algorithm failed during evaluation. Please:
+- Analyze the code for potential bugs (syntax errors, logical issues, missing imports, etc.)
+- Fix any problems you find
+- Ensure the code runs without errors
+- Make sure it still implements the intended change: $description
+- Add appropriate error handling and validation
+- If possible, suggest a simple way to test this fix
+
+This is retry attempt #$retry_count. Focus on making the code robust and correct."
+  else
+    prompt="Edit the file $temp_file to implement this specific change: $description
 
 Requirements:
 - Edit the file directly (don't just provide comments or suggestions)
@@ -196,6 +307,7 @@ Requirements:
 - Add proper error handling if needed
 
 The file currently contains the parent algorithm. Modify it according to the description above."
+  fi
   
   # Log prompt
   {
@@ -235,7 +347,7 @@ The file currently contains the parent algorithm. Modify it according to the des
       rm "$temp_file"
       echo "[WORKER-$$] Cleaned up temp file due to Claude failure" >&2
     fi
-    update_csv_row_with_lock "$candidate_id" "status" "failed"
+    handle_failure "$candidate_id" "$retry_status" "0"
     exit 1
   fi
   
@@ -249,7 +361,7 @@ The file currently contains the parent algorithm. Modify it according to the des
       
       # Clean up temp file and mark as failed
       rm "$temp_file"
-      update_csv_row_with_lock "$candidate_id" "status" "failed"
+      handle_failure "$candidate_id" "$retry_status" "0"
       exit 1
     else
       # Changes were made - move temp file to final location
@@ -306,9 +418,7 @@ if [[ $eval_exit_code -eq 0 ]]; then
   if [[ $eval_output =~ ^[[:space:]]*-?[0-9]+\.?[0-9]*[[:space:]]*$ ]]; then
     score=$(echo "$eval_output" | tr -d ' ')
     if [[ $(echo "$score == 0" | bc -l) == "1" ]]; then
-      update_csv_row_with_lock "$candidate_id" "status" "failed"
-      update_csv_row_with_lock "$candidate_id" "performance" "$score"
-      echo "[WORKER-$$] ✗ Evaluation failed with score 0"
+      handle_failure "$candidate_id" "$retry_status" "$score"
       exit 1
     else
       update_csv_row_with_lock "$candidate_id" "performance" "$score"
@@ -348,9 +458,7 @@ if [[ $eval_exit_code -eq 0 ]]; then
   if score=$(echo "$eval_output" | grep -o '"score"[[:space:]]*:[[:space:]]*[0-9.]*' | cut -d: -f2 | tr -d ' '); then
     if [[ -n $score ]]; then
       if [[ $(echo "$score == 0" | bc -l) == "1" ]]; then
-        update_csv_row_with_lock "$candidate_id" "status" "failed"
-        update_csv_row_with_lock "$candidate_id" "performance" "$score"
-        echo "[WORKER-$$] ✗ Evaluation failed with score 0"
+        handle_failure "$candidate_id" "$retry_status" "$score"
         exit 1
       else
         update_csv_row_with_lock "$candidate_id" "performance" "$score"
@@ -365,9 +473,7 @@ if [[ $eval_exit_code -eq 0 ]]; then
   if score=$(echo "$eval_output" | grep -o '"performance"[[:space:]]*:[[:space:]]*[0-9.]*' | cut -d: -f2 | tr -d ' '); then
     if [[ -n $score ]]; then
       if [[ $(echo "$score == 0" | bc -l) == "1" ]]; then
-        update_csv_row_with_lock "$candidate_id" "status" "failed"
-        update_csv_row_with_lock "$candidate_id" "performance" "$score"
-        echo "[WORKER-$$] ✗ Evaluation failed with score 0"
+        handle_failure "$candidate_id" "$retry_status" "$score"
         exit 1
       else
         update_csv_row_with_lock "$candidate_id" "performance" "$score"
@@ -382,10 +488,10 @@ if [[ $eval_exit_code -eq 0 ]]; then
   echo "[ERROR] Expected: plain number (e.g., 1.23) or JSON with 'score' or 'performance' field" >&2
   echo "[ERROR] Actual evaluator output was:" >&2
   echo "$eval_output" >&2
-  update_csv_row_with_lock "$candidate_id" "status" "failed"
+  handle_failure "$candidate_id" "$retry_status" "0"
   exit 1
 else
   echo "[ERROR] Evaluator failed with exit code $eval_exit_code" >&2
-  update_csv_row_with_lock "$candidate_id" "status" "failed"
+  handle_failure "$candidate_id" "$retry_status" "0"
   exit 1
 fi

package/lib/config.sh

@@ -45,6 +45,9 @@ DEFAULT_LOCK_TIMEOUT=10
 # Default auto ideation value
 DEFAULT_AUTO_IDEATE=true
 
+# Default retry value
+DEFAULT_MAX_RETRIES=3
+
 # Load configuration from config file
 load_config() {
   # Accept config file path as parameter
@@ -76,6 +79,9 @@ load_config() {
   # Set auto ideation default
   AUTO_IDEATE="$DEFAULT_AUTO_IDEATE"
   
+  # Set retry default
+  MAX_RETRIES="$DEFAULT_MAX_RETRIES"
+  
   # Load config if found
   if [[ -f "$config_file" ]]; then
     echo "[DEBUG] Loading configuration from: $config_file" >&2
@@ -151,6 +157,7 @@ load_config() {
           parent_selection) PARENT_SELECTION="$value" ;;
           python_cmd) PYTHON_CMD="$value" ;;
           auto_ideate) AUTO_IDEATE="$value" ;;
+          max_retries) MAX_RETRIES="$value" ;;
           evolution_dir) 
             echo "[WARN] evolution_dir in config is ignored - automatically inferred from config file location" >&2
             ;;
@@ -245,4 +252,5 @@ show_config() {
   echo "  Max workers: $MAX_WORKERS"
   echo "  Lock timeout: $LOCK_TIMEOUT"
   echo "  Auto ideate: $AUTO_IDEATE"
+  echo "  Max retries: $MAX_RETRIES"
 }

package/lib/csv-lock.sh

@@ -230,29 +230,42 @@ find_next_pending_with_lock() {
         return 1
     fi
     
-    # Find oldest pending candidate and update to running using Python
+    # Find oldest pending candidate (including retries) and update to running using Python
     local candidate=$("$PYTHON_CMD" -c "
 import csv
 import sys
+import re
+
+def is_pending_retry(status):
+    '''Check if status is pending (empty, pending, or retry status).'''
+    if not status or status == 'pending':
+        return True
+    return status.startswith('failed-retry')
 
 # Read CSV
 with open('$csv_file', 'r') as f:
     reader = csv.reader(f)
     rows = list(reader)
 
-# Find first pending candidate
+# Find first pending candidate (including retries)
 candidate_id = None
+original_status = None
 for i in range(1, len(rows)):
+    # Skip empty rows
+    if not rows[i] or len(rows[i]) == 0:
+        continue
     # If row has fewer than 5 fields, it's pending
     if len(rows[i]) < 5:
         candidate_id = rows[i][0]
+        original_status = ''  # Empty status means pending
         # Ensure row has 5 fields before setting status
         while len(rows[i]) < 5:
             rows[i].append('')
         rows[i][4] = 'running'  # Update status
         break
-    elif len(rows[i]) >= 5 and (rows[i][4] == 'pending' or rows[i][4] == ''):
+    elif len(rows[i]) >= 5 and is_pending_retry(rows[i][4]):
         candidate_id = rows[i][0]
+        original_status = rows[i][4]  # Save original status before overwriting
         rows[i][4] = 'running'  # Update status
         break
 
@@ -261,7 +274,7 @@ if candidate_id:
     with open('${csv_file}.tmp', 'w', newline='') as f:
         writer = csv.writer(f)
         writer.writerows(rows)
-    print(candidate_id)
+    print(f'{candidate_id}|{original_status}')  # Return both ID and original status
 ")
     
     if [ -n "$candidate" ]; then

package/lib/csv_helper.py

@@ -8,6 +8,7 @@ import csv
 import json
 import sys
 import os
+import re
 from typing import Dict, List, Any
 
 
@@ -50,6 +51,40 @@ def ensure_columns(headers: list[str], rows: list[list[str]], new_fields: dict)
     return headers, rows
 
 
+def parse_retry_status(status: str) -> tuple[str, int]:
+    """Parse retry status and return (base_status, retry_count).
+    
+    Examples:
+        'failed' -> ('failed', 0)
+        'failed-retry1' -> ('failed', 1)
+        'failed-retry3' -> ('failed', 3)
+        'complete' -> ('complete', 0)
+    """
+    if not status:
+        return ('', 0)
+    
+    match = re.match(r'^(.*)-retry(\d+)$', status)
+    if match:
+        base_status = match.group(1)
+        retry_count = int(match.group(2))
+        return (base_status, retry_count)
+    else:
+        return (status, 0)
+
+
+def is_retry_candidate(status: str) -> bool:
+    """Check if a status represents a retry candidate."""
+    base_status, _ = parse_retry_status(status)
+    return base_status == 'failed' and status.startswith('failed-retry')
+
+
+def is_pending_retry(status: str) -> bool:
+    """Check if status is pending (empty, 'pending', or retry status)."""
+    if not status or status == 'pending':
+        return True
+    return is_retry_candidate(status)
+
+
 def update_row_with_fields(headers: list[str], rows: list[list[str]], target_id: str, fields: dict):
     """Update a specific row with multiple fields."""
     # Find column indices
@@ -162,9 +197,12 @@ def main():
         try:
             headers, rows = read_csv(csv_file)
             
-            # Find first row with empty status or status == "pending"
+            # Find first row with empty status, "pending", or retry status
             for i, row in enumerate(rows, start=2):  # Start at 2 (1-indexed, skip header)
-                if len(row) < 5 or row[4] == '' or row[4] == 'pending':
+                if len(row) < 5:
+                    print(i)
+                    sys.exit(0)
+                elif len(row) >= 5 and is_pending_retry(row[4]):
                     print(i)
                     sys.exit(0)
             

package/lib/evolution_processor.py

@@ -14,7 +14,8 @@ def should_skip_processing(id_val, based_on_id, parent_file, output_file):
     """
     Determine if evolution processing should be skipped.
     
-    Simple rule: If file exists, skip everything. This handles all edge cases cleanly.
+    Simple rule: If file exists, skip everything UNLESS this is a retry candidate.
+    For retry candidates, we want Claude to process the existing file to fix bugs.
     
     Returns tuple: (skip_copy, skip_claude, reason)
     """
@@ -23,9 +24,15 @@ def should_skip_processing(id_val, based_on_id, parent_file, output_file):
         return True, True, "Baseline algorithm - no processing needed"
     
     # File existence check - if file exists, skip both copy and Claude
-    # This automatically handles self-parent cases and re-runs
+    # EXCEPT for retry candidates which need Claude to fix the existing file
     if os.path.exists(output_file):
-        return True, True, "File already exists - skipping all processing"
+        # Check if this might be a retry candidate by looking for retry status in environment
+        # The worker sets RETRY_CANDIDATE=true for retry processing
+        retry_env = os.environ.get('RETRY_CANDIDATE')
+        if retry_env == 'true':
+            return True, False, "Retry candidate - skip copy but run Claude for bug fixing"
+        else:
+            return True, True, "File already exists - skipping all processing"
     
     # File doesn't exist - proceed with copy and Claude
     return False, False, None

package/package.json

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

package/templates/config.yaml

@@ -42,6 +42,10 @@ python_cmd: "python3"
 # When true, automatically generate new ideas when no pending candidates remain
 auto_ideate: true
 
+# Retry configuration
+# Maximum number of retries for failed candidates before marking as permanently failed
+max_retries: 3
+
 # Parallel execution configuration
 parallel:
   # Enable parallel execution of evolution candidates