claude-evolve 1.4.12 → 1.5.0

package/bin/claude-evolve-run

@@ -13,16 +13,23 @@ if [[ -n ${CLAUDE_EVOLVE_CONFIG:-} ]]; then
 else
   # Check if config.yaml exists in current directory
   if [[ -f "config.yaml" ]]; then
-    export CLAUDE_EVOLVE_CONFIG="$(pwd)/config.yaml"
-    load_config "$CLAUDE_EVOLVE_CONFIG"
+    # Don't export to avoid collision with parallel runs
+    CONFIG_FILE="$(pwd)/config.yaml"
+    load_config "$CONFIG_FILE"
   else
     load_config
   fi
 fi
 
-# Export the config path for workers if not already set
-if [[ -z ${CLAUDE_EVOLVE_CONFIG:-} ]] && [[ -f "config.yaml" ]]; then
-  export CLAUDE_EVOLVE_CONFIG="$(pwd)/config.yaml"
+# Store the config path for workers (don't export to avoid collision)
+if [[ -n ${CLAUDE_EVOLVE_CONFIG:-} ]]; then
+  WORKER_CONFIG_PATH="$CLAUDE_EVOLVE_CONFIG"
+elif [[ -n ${CONFIG_FILE:-} ]]; then
+  WORKER_CONFIG_PATH="$CONFIG_FILE"
+elif [[ -f "config.yaml" ]]; then
+  WORKER_CONFIG_PATH="$(pwd)/config.yaml"
+else
+  WORKER_CONFIG_PATH=""
 fi
 
 # Validate configuration
@@ -229,6 +236,7 @@ start_worker() {
   
   local worker_args=()
   [[ -n $timeout_seconds ]] && worker_args+=(--timeout "$timeout_seconds")
+  [[ -n $WORKER_CONFIG_PATH ]] && worker_args+=(--config "$WORKER_CONFIG_PATH")
   
   echo "[DISPATCHER] Starting worker..."
   "$worker_script" "${worker_args[@]}" &
@@ -252,6 +260,12 @@ cleanup_workers() {
         if [[ $exit_code -eq 2 ]]; then
           echo "[DISPATCHER] Worker $pid hit rate limit, will retry later"
           # Rate limits don't count as consecutive failures
+        elif [[ $exit_code -eq 3 ]]; then
+          echo "[DISPATCHER] Worker $pid hit API usage limit - stopping all processing" >&2
+          echo "[DISPATCHER] Cannot continue evolution run due to API limits" >&2
+          echo "[DISPATCHER] Please wait for limits to reset before restarting" >&2
+          # Set a flag to stop the main loop
+          api_limit_reached=true
         else
           echo "[DISPATCHER] Worker $pid failed with exit code $exit_code"
           # With retry mechanism, failures are normal - just keep processing
@@ -290,6 +304,16 @@ get_csv_stats() {
 echo "[DISPATCHER] Starting unified evolution engine"
 echo "[DISPATCHER] Configuration: max_workers=$MAX_WORKERS, timeout=${timeout_seconds:-none}"
 
+# Clean up any stuck 'running' statuses at startup
+if [[ -f "$FULL_CSV_PATH" ]]; then
+  echo "[DISPATCHER] Resetting any stuck 'running' candidates to 'pending'..."
+  if "$SCRIPT_DIR/claude-evolve-edit" running pending >/dev/null 2>&1; then
+    echo "[DISPATCHER] Successfully reset stuck candidates"
+  else
+    echo "[DISPATCHER] No stuck candidates found or edit command not available"
+  fi
+fi
+
 # Validate CSV and clean up stuck statuses and duplicates
 if [[ -f "$FULL_CSV_PATH" ]]; then
   echo "[DISPATCHER] Validating CSV and cleaning up..."
@@ -451,11 +475,20 @@ ensure_baseline_entry
 # With retry mechanism, we don't need consecutive failure tracking
 # Failures are handled gracefully through the retry system
 
+# Flag to track API limit status
+api_limit_reached=false
+
 # Main dispatch loop
 while true; do
   # Clean up finished workers
   cleanup_workers
   
+  # Check if API limit was reached
+  if [[ "$api_limit_reached" == "true" ]]; then
+    echo "[DISPATCHER] Stopping evolution run due to API usage limits" >&2
+    break
+  fi
+  
   # Get current status
   csv_stats=$(get_csv_stats "$FULL_CSV_PATH")
   read -r total_rows complete_count pending_count <<< "$csv_stats"
@@ -514,5 +547,14 @@ done
 
 # Clean shutdown
 shutdown_workers
-echo "[DISPATCHER] Evolution run complete"
-echo "[DISPATCHER] Exiting with code 0"
+
+# Final status message
+if [[ "$api_limit_reached" == "true" ]]; then
+  echo "[DISPATCHER] Evolution run stopped due to API usage limits"
+  echo "[DISPATCHER] Wait for limits to reset, then run 'claude-evolve run' again"
+  echo "[DISPATCHER] Exiting with code 1 (API limits reached)"
+  exit 1
+else
+  echo "[DISPATCHER] Evolution run complete"
+  echo "[DISPATCHER] Exiting with code 0"
+fi

package/bin/claude-evolve-worker

@@ -6,21 +6,63 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &> /dev/null && pwd)"
 source "$SCRIPT_DIR/../lib/config.sh"
 source "$SCRIPT_DIR/../lib/csv-lock.sh"
 
-# Load config using the same logic as dispatcher
-if [[ -n ${CLAUDE_EVOLVE_CONFIG:-} ]]; then
-  load_config "$CLAUDE_EVOLVE_CONFIG"
-else
-  load_config
-fi
+# Track current candidate for cleanup
+CURRENT_CANDIDATE_ID=""
+TERMINATION_SIGNAL=""
+
+# Cleanup function to handle termination
+cleanup_on_exit() {
+  if [[ -n "$CURRENT_CANDIDATE_ID" ]]; then
+    # Only mark as failed if it was a timeout (SIGTERM from timeout command)
+    # For user interruption (Ctrl-C) or kill, leave it for retry
+    if [[ "$TERMINATION_SIGNAL" == "TERM" ]]; then
+      echo "[WORKER-$$] Timeout detected, marking $CURRENT_CANDIDATE_ID as failed" >&2
+      "$PYTHON_CMD" -c "
+import sys
+sys.path.insert(0, '$SCRIPT_DIR/..')
+from lib.evolution_csv import EvolutionCSV
+try:
+    with EvolutionCSV('$FULL_CSV_PATH') as csv:
+        csv.update_candidate_status('$CURRENT_CANDIDATE_ID', 'failed')
+except:
+    pass  # Best effort cleanup
+" 2>/dev/null || true
+    else
+      echo "[WORKER-$$] Interrupted, leaving $CURRENT_CANDIDATE_ID for retry" >&2
+      # Optionally reset to pending instead of leaving as running
+      "$PYTHON_CMD" -c "
+import sys
+sys.path.insert(0, '$SCRIPT_DIR/..')
+from lib.evolution_csv import EvolutionCSV
+try:
+    with EvolutionCSV('$FULL_CSV_PATH') as csv:
+        csv.update_candidate_status('$CURRENT_CANDIDATE_ID', 'pending')
+except:
+    pass  # Best effort cleanup
+" 2>/dev/null || true
+    fi
+  fi
+}
+
+# Set up signal handlers
+trap 'TERMINATION_SIGNAL="TERM"; cleanup_on_exit' TERM
+trap 'TERMINATION_SIGNAL="INT"; cleanup_on_exit' INT
+trap 'TERMINATION_SIGNAL="HUP"; cleanup_on_exit' HUP
+trap 'cleanup_on_exit' EXIT
 
-# Parse arguments
+# Parse arguments first to get config path
 timeout_seconds=""
+config_path=""
 while [[ $# -gt 0 ]]; do
   case "$1" in
     --timeout)
       timeout_seconds="$2"
       shift 2
       ;;
+    --config)
+      config_path="$2"
+      shift 2
+      ;;
     *)
       echo "[ERROR] Unknown argument: $1" >&2
       exit 1
@@ -28,6 +70,141 @@ while [[ $# -gt 0 ]]; do
   esac
 done
 
+# Load config using the provided path, environment variable, or default
+if [[ -n $config_path ]]; then
+  load_config "$config_path"
+elif [[ -n ${CLAUDE_EVOLVE_CONFIG:-} ]]; then
+  load_config "$CLAUDE_EVOLVE_CONFIG"
+else
+  load_config
+fi
+
+# AI round-robin with fallback function for code evolution
+call_ai_for_evolution() {
+  local prompt="$1"
+  local candidate_id="$2"
+  
+  # Extract generation and ID numbers for round-robin calculation
+  local gen_num=0
+  local id_num=0
+  if [[ $candidate_id =~ ^gen([0-9]+)-([0-9]+)$ ]]; then
+    gen_num=$((10#${BASH_REMATCH[1]}))
+    id_num=$((10#${BASH_REMATCH[2]}))
+  fi
+  
+  # Calculate hash for round-robin (combine generation and ID)
+  local hash_value=$((gen_num * 1000 + id_num))
+  
+  # Check which AI tools are available
+  local available_models=()
+  available_models+=("claude")  # Claude Sonnet always available
+  if command -v gemini >/dev/null 2>&1; then
+    available_models+=("gemini")
+  fi
+  if command -v codex >/dev/null 2>&1; then
+    available_models+=("codex")
+  fi
+  
+  # Create ordered list based on round-robin for this candidate
+  local num_models=${#available_models[@]}
+  local start_index=$((hash_value % num_models))
+  local models=()
+  
+  # Add models in round-robin order starting from the calculated index
+  for ((i=0; i<num_models; i++)); do
+    local idx=$(((start_index + i) % num_models))
+    models+=("${available_models[$idx]}")
+  done
+  
+  echo "[WORKER-$$] Model order for $candidate_id (round-robin): ${models[*]}" >&2
+  
+  # Try each model in the ordered sequence
+  for model in "${models[@]}"; do
+    echo "[WORKER-$$] Attempting code evolution with $model" >&2
+    local ai_output
+    local ai_exit_code
+    
+    case "$model" in
+      "claude")
+        ai_output=$(echo "$prompt" | claude --dangerously-skip-permissions -p 2>&1)
+        ai_exit_code=$?
+        
+        # Check for usage limits
+        if echo "$ai_output" | grep -q "Claude AI usage limit reached"; then
+          echo "[WORKER-$$] Claude AI usage limit reached - trying next model" >&2
+          continue
+        fi
+        
+        if [[ $ai_exit_code -eq 0 ]]; then
+          echo "[WORKER-$$] Claude Sonnet succeeded" >&2
+          return 0
+        fi
+        ;;
+        
+      "gemini")
+        ai_output=$(gemini -y -p "$prompt" 2>&1)
+        ai_exit_code=$?
+        
+        # Check for authentication messages or valid response
+        if [[ $ai_exit_code -eq 0 ]]; then
+          if ! echo "$ai_output" | grep -q "Attempting to authenticate\|Authenticating\|Loading\|Initializing"; then
+            if [[ -n "$ai_output" ]] && [[ $(echo "$ai_output" | wc -l) -ge 2 ]]; then
+              echo "[WORKER-$$] Gemini succeeded" >&2
+              return 0
+            fi
+          fi
+        fi
+        ;;
+        
+      "codex")
+        ai_output=$(echo "$prompt" | codex exec --full-auto 2>&1)
+        ai_exit_code=$?
+        
+        if [[ $ai_exit_code -eq 0 ]]; then
+          # Clean codex output if it's JSON
+          if echo "$ai_output" | grep -q '"content"'; then
+            ai_output=$(echo "$ai_output" | python3 -c "
+import sys
+import json
+try:
+    data = json.load(sys.stdin)
+    if 'content' in data:
+        print(data['content'])
+    elif 'response' in data:
+        print(data['response'])
+    elif 'text' in data:
+        print(data['text'])
+    else:
+        print(json.dumps(data))
+except:
+    print(sys.stdin.read())
+" 2>/dev/null || echo "$ai_output")
+          fi
+          
+          if [[ -n "$ai_output" ]] && ! echo "$ai_output" | grep -q "error\|failed\|exception"; then
+            echo "[WORKER-$$] Codex succeeded" >&2
+            return 0
+          fi
+        fi
+        ;;
+    esac
+    
+    echo "[WORKER-$$] $model failed (exit code $ai_exit_code), trying next model..." >&2
+    if [[ -n "$ai_output" ]]; then
+      echo "[WORKER-$$] $model error: $(echo "$ai_output" | head -5)" >&2
+    fi
+  done
+  
+  # All models in round-robin failed, check for API limit exit
+  if echo "${ai_output:-}" | grep -q "Claude AI usage limit reached"; then
+    echo "[WORKER-$$] ERROR: All AI models unavailable - Claude hit usage limit" >&2
+    exit 3
+  fi
+  
+  echo "[WORKER-$$] All AI models failed for code evolution" >&2
+  return 1
+}
+
 # Validate paths
 if [[ ! -f "$FULL_CSV_PATH" ]]; then
   echo "[WORKER-$$] CSV file not found: $FULL_CSV_PATH" >&2
@@ -58,11 +235,21 @@ process_candidate() {
     fi
   fi
   
-  # Target file for evolution
+  # Check if this is a baseline candidate (no parent and specific ID pattern)
+  local is_baseline=false
+  if [[ -z "$parent_id" ]] && [[ "$candidate_id" =~ ^(baseline|baseline-000|000|0|gen00-000)$ ]]; then
+    is_baseline=true
+    echo "[WORKER-$$] Detected baseline candidate - will run algorithm.py directly"
+  fi
+  
+  # Target file for evolution (not used for baseline)
   local target_file="$FULL_OUTPUT_DIR/evolution_${candidate_id}.py"
   
   # Check if processing should be skipped
-  if [[ -f "$target_file" ]]; then
+  if [[ "$is_baseline" == "true" ]]; then
+    # For baseline, skip all file operations
+    echo "[WORKER-$$] Baseline candidate - skipping file operations"
+  elif [[ -f "$target_file" ]]; then
     echo "[WORKER-$$] �  Skipping copy - File already exists - skipping all processing"
     echo "[WORKER-$$] �  Skipping Claude processing - File already exists - skipping all processing"
     
@@ -92,30 +279,50 @@ with EvolutionCSV('$FULL_CSV_PATH') as csv:
     echo "[WORKER-$$] Copying $source_file to $target_file"
     cp "$source_file" "$target_file"
     
-    # Apply evolution using Claude
-    echo "[WORKER-$$] Applying evolution with Claude..."
-    local evolution_prompt="Modify the algorithm in $target_file based on this description: $description
+    # Apply evolution using AI
+    echo "[WORKER-$$] Applying evolution..."
+    
+    # Use relative path for AI prompt
+    local target_basename=$(basename "$target_file")
+    local evolution_prompt="Modify the algorithm in $target_basename based on this description: $description
     
 The modification should be substantial and follow the description exactly. Make sure the algorithm still follows all interface requirements and can run properly.
 
 Important: Make meaningful changes that match the description. Don't just add comments or make trivial adjustments."
     
-    if ! echo "$evolution_prompt" | claude --dangerously-skip-permissions -p 2>&1; then
-      echo "[WORKER-$$] ERROR: Claude evolution failed" >&2
-      rm -f "$target_file"  # Clean up on failure
-      return 1
+    if [[ "$is_baseline" != "true" ]]; then
+      # Change to evolution directory so AI can access files
+      local original_pwd=$(pwd)
+      cd "$FULL_EVOLUTION_DIR"
+      
+      # Try AI models with round-robin based on candidate ID
+      if ! call_ai_for_evolution "$evolution_prompt" "$candidate_id"; then
+        echo "[WORKER-$$] ERROR: All AI models failed to generate code" >&2
+        cd "$original_pwd"
+        rm -f "$target_file"  # Clean up on failure
+        return 1
+      fi
+      
+      # Restore working directory
+      cd "$original_pwd"
+      
+      echo "[WORKER-$$] Evolution applied successfully"
     fi
-    
-    echo "[WORKER-$$] Evolution applied successfully"
   fi
   
   # Run evaluation
   echo "[WORKER-$$] Evaluating algorithm..."
-  local eval_output_file="/tmp/claude-evolve-eval-$$-$candidate_id.out"
+  local eval_output_file="$FULL_EVOLUTION_DIR/temp-eval-$$-$candidate_id.out"
   local eval_start=$(date +%s)
   
   # Prepare evaluation command
-  local eval_cmd=("$PYTHON_CMD" "$FULL_EVALUATOR_PATH" "$candidate_id")
+  # For baseline, pass "baseline" or empty string to evaluator to use algorithm.py
+  local eval_arg="$candidate_id"
+  if [[ "$is_baseline" == "true" ]]; then
+    # Evaluator should interpret this as "use algorithm.py directly"
+    eval_arg=""
+  fi
+  local eval_cmd=("$PYTHON_CMD" "$FULL_EVALUATOR_PATH" "$eval_arg")
   [[ -n "$timeout_seconds" ]] && eval_cmd=(timeout "$timeout_seconds" "${eval_cmd[@]}")
   
   # Run evaluation with tee to both display and capture output
@@ -228,17 +435,20 @@ with EvolutionCSV('$FULL_CSV_PATH') as csv:
     else
       echo "[WORKER-$$] ERROR: No score found in evaluation output" >&2
       echo "[WORKER-$$] Output: $eval_output" >&2
-      rm -f "$eval_output_file"
+      # rm -f "$eval_output_file"  # Keep for debugging
+      echo "[WORKER-$$] Evaluation output saved to: $eval_output_file" >&2
       return 1
     fi
     
-    # Clean up temp file
-    rm -f "$eval_output_file"
+    # Clean up temp file (comment out to keep for debugging)
+    # rm -f "$eval_output_file"
+    echo "[WORKER-$$] Evaluation output saved to: $eval_output_file" >&2
   else
     local exit_code=$?
     # Read any output that was captured before failure
     eval_output=$(<"$eval_output_file")
-    rm -f "$eval_output_file"
+    # rm -f "$eval_output_file"  # Keep for debugging
+    echo "[WORKER-$$] Evaluation output saved to: $eval_output_file" >&2
     
     echo "[WORKER-$$] ERROR: Evaluation failed with exit code $exit_code" >&2
     echo "[WORKER-$$] Output: $eval_output" >&2
@@ -272,7 +482,7 @@ with EvolutionCSV('$FULL_CSV_PATH') as csv:
         # Get full candidate info
         candidate = csv.get_candidate_info(candidate_id)
         if candidate:
-            print(f'{candidate[\"id\"]}|{candidate.get(\"parent_id\", \"\")}|{candidate[\"description\"]}')
+            print(f'{candidate[\"id\"]}|{candidate.get(\"basedOnId\", \"\")}|{candidate[\"description\"]}')
 ")
   
   if [[ -z "$candidate_info" ]]; then
@@ -283,12 +493,26 @@ with EvolutionCSV('$FULL_CSV_PATH') as csv:
   # Parse candidate info
   IFS='|' read -r candidate_id parent_id description <<< "$candidate_info"
   
+  # Set current candidate for cleanup
+  CURRENT_CANDIDATE_ID="$candidate_id"
+  
   # Process the candidate
   if process_candidate "$candidate_id" "$parent_id" "$description"; then
     echo "[WORKER-$$] Successfully processed $candidate_id"
   else
     echo "[WORKER-$$] Failed to process $candidate_id"
+    # Ensure status is set to failed (might already be done in process_candidate)
+    "$PYTHON_CMD" -c "
+import sys
+sys.path.insert(0, '$SCRIPT_DIR/..')
+from lib.evolution_csv import EvolutionCSV
+with EvolutionCSV('$FULL_CSV_PATH') as csv:
+    csv.update_candidate_status('$candidate_id', 'failed')
+" 2>/dev/null || true
   fi
+  
+  # Clear current candidate
+  CURRENT_CANDIDATE_ID=""
 done
 
 echo "[WORKER-$$] No more pending candidates, worker exiting"

package/lib/evolution_csv.py

@@ -121,8 +121,9 @@ class EvolutionCSV:
         # Check status field (5th column, index 4)
         status = row[4].strip().lower() if row[4] else ''
         
-        # Blank, missing, "pending", or "running" all mean pending
-        if not status or status in ['pending', 'running']:
+        # Only blank, missing, or "pending" mean pending
+        # "running" should NOT be considered pending to avoid duplicate processing
+        if not status or status == 'pending':
             return True
             
         # Check for retry statuses
@@ -321,6 +322,39 @@ class EvolutionCSV:
                 
         return None
         
+    def delete_candidate(self, candidate_id: str) -> bool:
+        """Delete a candidate from the CSV file."""
+        rows = self._read_csv()
+        if not rows:
+            return False
+            
+        # Check if we have a header row
+        has_header = rows and rows[0] and rows[0][0].lower() == 'id'
+        
+        # Find and remove the candidate
+        deleted = False
+        new_rows = []
+        
+        # Keep header if it exists
+        if has_header:
+            new_rows.append(rows[0])
+            start_idx = 1
+        else:
+            start_idx = 0
+            
+        for i in range(start_idx, len(rows)):
+            row = rows[i]
+            if self.is_valid_candidate_row(row) and row[0].strip() == candidate_id:
+                deleted = True
+                # Skip this row (delete it)
+                continue
+            new_rows.append(row)
+                
+        if deleted:
+            self._write_csv(new_rows)
+            
+        return deleted
+        
     def has_pending_work(self) -> bool:
         """Check if there are any pending candidates. Used by dispatcher."""
         return self.count_pending_candidates() > 0