claude-evolve 1.4.11 → 1.4.13

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=""
 
-# Parse arguments
+# 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 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,15 @@ 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
+
 # Validate paths
 if [[ ! -f "$FULL_CSV_PATH" ]]; then
   echo "[WORKER-$$] CSV file not found: $FULL_CSV_PATH" >&2
@@ -58,11 +109,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"
     
@@ -100,13 +161,29 @@ The modification should be substantial and follow the description exactly. Make
 
 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
+      local claude_output
+      claude_output=$(echo "$evolution_prompt" | claude --dangerously-skip-permissions -p 2>&1)
+      local claude_exit_code=$?
+      
+      # Check for usage limits
+      if echo "$claude_output" | grep -q "Claude AI usage limit reached"; then
+        echo "[WORKER-$$] ERROR: Claude AI usage limit reached!" >&2
+        echo "[WORKER-$$] ERROR: Cannot continue processing - API limits exceeded" >&2
+        rm -f "$target_file"  # Clean up on failure
+        # Exit with special code 3 to indicate API limit
+        exit 3
+      fi
+      
+      if [[ $claude_exit_code -ne 0 ]]; then
+        echo "[WORKER-$$] ERROR: Claude evolution failed with exit code $claude_exit_code" >&2
+        echo "[WORKER-$$] ERROR: Claude output: $claude_output" >&2
+        rm -f "$target_file"  # Clean up on failure
+        return 1
+      fi
+      
+      echo "[WORKER-$$] Evolution applied successfully"
     fi
-    
-    echo "[WORKER-$$] Evolution applied successfully"
   fi
   
   # Run evaluation
@@ -115,7 +192,13 @@ Important: Make meaningful changes that match the description. Don't just add co
   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 +311,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 +358,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 +369,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

package/lib/validate_parent_ids.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""
+Validate parent IDs in AI-generated ideas for claude-evolve ideation.
+"""
+
+import csv
+import json
+import sys
+import re
+from typing import List, Set, Dict, Tuple, Optional
+
+
+def get_valid_parent_ids(csv_path: str) -> Set[str]:
+    """Extract all valid candidate IDs from the CSV that can be used as parents."""
+    valid_ids = set()
+    valid_ids.add("")  # Empty string is valid for novel ideas
+    valid_ids.add("000")  # Special ID for baseline algorithm
+    valid_ids.add("0")  # Alternative baseline ID
+    valid_ids.add("gen00-000")  # Another baseline format
+    
+    try:
+        with open(csv_path, 'r') as f:
+            reader = csv.reader(f)
+            next(reader, None)  # Skip header
+            for row in reader:
+                if row and len(row) > 0:
+                    candidate_id = row[0].strip()
+                    if candidate_id:
+                        valid_ids.add(candidate_id)
+    except Exception as e:
+        print(f"[ERROR] Failed to read CSV: {e}", file=sys.stderr)
+        
+    return valid_ids
+
+
+def validate_and_fix_parent_id(parent_id: str, valid_ids: Set[str], idea_type: str, 
+                                top_performers: Optional[List[Tuple[str, str, float]]] = None) -> str:
+    """
+    Validate a parent ID and fix it if invalid.
+    
+    Args:
+        parent_id: The parent ID to validate
+        valid_ids: Set of valid parent IDs
+        idea_type: Type of idea (novel, hill-climbing, structural, crossover)
+        top_performers: List of (id, description, score) tuples for non-novel ideas
+        
+    Returns:
+        A valid parent ID (may be fixed)
+    """
+    # Novel ideas should have empty parent
+    if idea_type == "novel":
+        return ""
+    
+    # Check if parent ID is valid
+    if parent_id in valid_ids:
+        return parent_id
+    
+    # For non-novel ideas, we need a valid parent
+    if top_performers and len(top_performers) > 0:
+        # Return the first top performer's ID
+        return top_performers[0][0]
+    
+    # If no top performers, return empty (will be caught as error later)
+    return ""
+
+
+def parse_ai_line(line: str, idea_type: str) -> Tuple[str, str]:
+    """
+    Parse a line from AI output to extract parent ID and description.
+    
+    Returns:
+        Tuple of (parent_id, description)
+    """
+    line = line.strip()
+    parent_id = ""
+    description = line
+    
+    if idea_type != "novel":
+        # Look for "From X:" pattern
+        match = re.match(r'^From\s+([^:]+):\s*(.+)$', line, re.IGNORECASE)
+        if match:
+            parent_id = match.group(1).strip()
+            description = match.group(2).strip()
+    
+    return parent_id, description
+
+
+def validate_ai_output(ai_output: str, count: int, idea_type: str, csv_path: str,
+                      top_performers_str: str = "") -> List[Dict[str, str]]:
+    """
+    Validate AI output and return validated ideas.
+    
+    Args:
+        ai_output: Raw AI output
+        count: Expected number of ideas
+        idea_type: Type of idea (novel, hill-climbing, structural, crossover)
+        csv_path: Path to CSV file
+        top_performers_str: String containing top performers (format: "id,description,score\n...")
+        
+    Returns:
+        List of validated ideas with 'parent_id' and 'description' keys
+    """
+    # Get valid parent IDs
+    valid_ids = get_valid_parent_ids(csv_path)
+    
+    # Parse top performers
+    top_performers = []
+    if top_performers_str:
+        for line in top_performers_str.strip().split('\n'):
+            if line:
+                parts = line.split(',', 2)
+                if len(parts) >= 3:
+                    try:
+                        top_performers.append((parts[0], parts[1], float(parts[2])))
+                    except ValueError:
+                        pass
+    
+    # Process AI output
+    validated_ideas = []
+    lines = ai_output.strip().split('\n')
+    
+    print(f"[DEBUG] Processing {len(lines)} lines from AI output for {idea_type} ideas", file=sys.stderr)
+    
+    for line in lines:
+        # Skip empty lines and metadata
+        if not line or line.strip() == '' or line.startswith('#') or line.startswith('[') or line.startswith('=='):
+            continue
+        
+        # Skip debug/info messages from AI tools
+        if line.strip().startswith('[INFO]') or line.strip().startswith('[WARN]') or line.strip().startswith('[ERROR]') or line.strip().startswith('[DEBUG]'):
+            continue
+        
+        # Clean the line
+        line = line.strip()
+        line = re.sub(r'^[0-9]+\.?\s*', '', line)  # Remove numbering
+        line = re.sub(r'^-\s*', '', line)  # Remove bullet points
+        
+        # Parse parent ID and description
+        parent_id, description = parse_ai_line(line, idea_type)
+        
+        # Validate parent ID
+        if parent_id and parent_id not in valid_ids:
+            print(f"[WARN] Invalid parent ID '{parent_id}' for {idea_type} idea - fixing...", file=sys.stderr)
+            print(f"[INFO] Valid parent IDs are: {', '.join(sorted([id for id in valid_ids if id]))[:200]}...", file=sys.stderr)
+            parent_id = validate_and_fix_parent_id(parent_id, valid_ids, idea_type, top_performers)
+            print(f"[INFO] Fixed parent ID to: '{parent_id}'", file=sys.stderr)
+        
+        # For non-novel ideas, ensure we have a parent
+        if idea_type != "novel" and not parent_id:
+            if top_performers:
+                parent_id = top_performers[0][0]
+                print(f"[INFO] Assigned parent ID '{parent_id}' to idea without parent", file=sys.stderr)
+            else:
+                print(f"[ERROR] Non-novel idea without parent and no top performers available", file=sys.stderr)
+                continue
+        
+        # Skip if description is too short or contains shell artifacts
+        if len(description) < 20:
+            continue
+        
+        if any(word in description for word in ['EOF', '/dev/null', '<<<', '>>>', '#!/bin/bash']):
+            print(f"[WARN] Skipping description with shell artifacts: {description[:50]}...", file=sys.stderr)
+            continue
+        
+        validated_ideas.append({
+            'parent_id': parent_id,
+            'description': description
+        })
+        
+        if len(validated_ideas) >= count:
+            break
+    
+    return validated_ideas
+
+
+def main():
+    """Main entry point for validation script."""
+    if len(sys.argv) < 5:
+        print("Usage: validate_parent_ids.py <ai_output_file> <count> <idea_type> <csv_path> [top_performers_file]", file=sys.stderr)
+        sys.exit(1)
+    
+    ai_output_file = sys.argv[1]
+    count = int(sys.argv[2])
+    idea_type = sys.argv[3]
+    csv_path = sys.argv[4]
+    top_performers_file = sys.argv[5] if len(sys.argv) > 5 else None
+    
+    try:
+        # Read AI output
+        with open(ai_output_file, 'r') as f:
+            ai_output = f.read()
+    except Exception as e:
+        print(f"[ERROR] Failed to read AI output file {ai_output_file}: {e}", file=sys.stderr)
+        sys.exit(1)
+    
+    # Read top performers if provided
+    top_performers_str = ""
+    if top_performers_file and top_performers_file != "none":
+        try:
+            with open(top_performers_file, 'r') as f:
+                top_performers_str = f.read()
+        except Exception as e:
+            print(f"[WARN] Failed to read top performers file {top_performers_file}: {e}", file=sys.stderr)
+    
+    # Check if AI output is empty or looks like an error
+    if not ai_output.strip():
+        print(f"[ERROR] AI output is empty", file=sys.stderr)
+        sys.exit(1)
+    
+    if len(ai_output) < 50:
+        print(f"[WARN] AI output is suspiciously short: {ai_output}", file=sys.stderr)
+    
+    # Validate
+    validated_ideas = validate_ai_output(ai_output, count, idea_type, csv_path, top_performers_str)
+    
+    # Output validated ideas as JSON
+    print(json.dumps(validated_ideas))
+    
+    # Return error ONLY if no valid ideas at all
+    if len(validated_ideas) == 0:
+        print(f"[ERROR] No valid ideas found in AI output. First 500 chars:", file=sys.stderr)
+        print(ai_output[:500], file=sys.stderr)
+        sys.exit(1)
+    elif len(validated_ideas) < count:
+        print(f"[WARN] Only validated {len(validated_ideas)} out of {count} requested {idea_type} ideas", file=sys.stderr)
+        print(f"[INFO] AI appears to have generated fewer ideas than requested.", file=sys.stderr)
+        print(f"[INFO] Proceeding with {len(validated_ideas)} valid ideas.", file=sys.stderr)
+        # Don't exit with error - we have some valid ideas!
+
+
+if __name__ == "__main__":
+    main()

package/package.json

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