claude-evolve 1.9.6 → 1.9.8

package/lib/ai_cli.py

@@ -10,9 +10,16 @@ import subprocess
 import sys
 import tempfile
 import time
+from datetime import datetime
 from pathlib import Path
 from typing import Optional, Tuple, List
 
+
+def _log(msg: str):
+    """Log with timestamp. AI CLI uses its own logging to avoid import cycles."""
+    ts = datetime.now().strftime("%H:%M:%S")
+    print(f"[{ts}] [AI] {msg}", file=sys.stderr, flush=True)
+
 # Path to ai-cli.sh relative to this file
 SCRIPT_DIR = Path(__file__).parent
 AI_CLI_PATH = SCRIPT_DIR / "ai-cli.sh"
@@ -305,21 +312,25 @@ def call_ai_with_backoff(
         shuffled_models = models.copy()
         random.shuffle(shuffled_models)
 
-        print(f"[AI] Round {round_num + 1}/{max_rounds}: trying {len(shuffled_models)} models", file=sys.stderr)
+        _log(f"Round {round_num + 1}/{max_rounds}: trying {len(shuffled_models)} models")
 
         for model in shuffled_models:
             try:
+                _log(f"Trying {model}...")
                 output, model_name = call_ai_model(prompt, model, working_dir, env_vars)
                 if round_num > 0:
-                    print(f"[AI] Succeeded on round {round_num + 1} with {model}", file=sys.stderr)
+                    _log(f"Succeeded on round {round_num + 1} with {model}")
+                else:
+                    _log(f"Success with {model}")
                 return output, model_name
             except AIError as e:
+                _log(f"{model} failed: {str(e)[:60]}...")
                 last_errors[model] = str(e)
                 # Continue to next model
 
         # All models failed in this round
         if round_num < max_rounds - 1:
-            print(f"[AI] All models failed in round {round_num + 1}, waiting {wait_time}s before retry...", file=sys.stderr)
+            _log(f"All models failed in round {round_num + 1}, waiting {wait_time}s...")
             time.sleep(wait_time)
             # Exponential backoff: 60 -> 120 -> 240 -> 480 (capped at max_wait)
             wait_time = min(wait_time * 2, max_wait)

package/lib/evolution_csv.py

@@ -778,16 +778,22 @@ class EvolutionCSV:
 
         return f"{gen_prefix}-{max_id + 1:03d}"
 
-    def get_next_ids(self, generation: int, count: int) -> List[str]:
+    def get_next_ids(self, generation: int, count: int, claimed_ids: Optional[List[str]] = None) -> List[str]:
         """
         Get multiple next available IDs for a generation.
 
         Args:
             generation: Generation number
             count: Number of IDs to generate
+            claimed_ids: Optional list of IDs already claimed in this session
+                        (not yet written to CSV). Prevents duplicate IDs.
 
         Returns:
             List of ID strings
+
+        AIDEV-NOTE: The claimed_ids parameter is critical for ideation where
+        multiple strategies run before writing to CSV. Without it, each strategy
+        would get overlapping IDs like gen75-001, gen75-002 for each strategy.
         """
         rows = self._read_csv()
         gen_prefix = f"gen{generation:02d}"
@@ -796,6 +802,7 @@ class EvolutionCSV:
         has_header = rows and rows[0] and rows[0][0].lower() == 'id'
         start_idx = 1 if has_header else 0
 
+        # Check CSV for existing IDs
         for row in rows[start_idx:]:
             if not self.is_valid_candidate_row(row):
                 continue
@@ -808,6 +815,16 @@ class EvolutionCSV:
                 except (ValueError, IndexError):
                     pass
 
+        # Also check claimed IDs (not yet in CSV)
+        if claimed_ids:
+            for claimed_id in claimed_ids:
+                if claimed_id.startswith(gen_prefix + '-'):
+                    try:
+                        id_num = int(claimed_id.split('-')[1])
+                        max_id = max(max_id, id_num)
+                    except (ValueError, IndexError):
+                        pass
+
         return [f"{gen_prefix}-{max_id + 1 + i:03d}" for i in range(count)]
 
     def append_candidates(self, candidates: List[Dict[str, str]]) -> int:
@@ -855,6 +872,9 @@ class EvolutionCSV:
 
         Returns:
             Dict with total, pending, complete, failed counts
+
+        AIDEV-NOTE: Uses is_pending_candidate() for pending count to ensure
+        consistency between stats and what workers actually find.
         """
         rows = self._read_csv()
         if not rows:
@@ -870,16 +890,19 @@ class EvolutionCSV:
                 continue
 
             stats['total'] += 1
-            status = row[4].strip().lower() if len(row) > 4 else ''
 
-            if status == 'complete':
-                stats['complete'] += 1
-            elif status == 'running':
-                stats['running'] += 1
-            elif status.startswith('failed'):
-                stats['failed'] += 1
-            else:
+            # Use is_pending_candidate for consistency with workers
+            if self.is_pending_candidate(row):
                 stats['pending'] += 1
+            else:
+                status = row[4].strip().lower() if len(row) > 4 else ''
+                if status == 'complete':
+                    stats['complete'] += 1
+                elif status == 'running':
+                    stats['running'] += 1
+                elif status.startswith('failed'):
+                    stats['failed'] += 1
+                # Anything else that's not pending gets counted as failed/other
 
         return stats
 

package/lib/evolve_ideate.py

@@ -93,20 +93,28 @@ class IdeationStrategy(ABC):
         pass
 
     def generate(self, context: IdeationContext, count: int,
-                 max_rounds: int = 10, initial_wait: int = 60, max_wait: int = 600) -> List[Idea]:
+                 max_rounds: int = 10, initial_wait: int = 60, max_wait: int = 600,
+                 claimed_ids: List[str] = None) -> List[Idea]:
         """Generate ideas using this strategy with round-based retry and backoff.
 
         AIDEV-NOTE: Uses call_ai_with_backoff for robust retry handling.
         Each round tries ALL models. If all fail, waits with exponential backoff.
+        claimed_ids tracks IDs already claimed by previous strategies in this run.
+        IDs are added to claimed_ids immediately to prevent reuse even on failure.
         """
         if count <= 0:
             return []
+        if claimed_ids is None:
+            claimed_ids = []
 
-        print(f"[IDEATE] Running {self.name} strategy for {count} ideas", file=sys.stderr)
+        print(f"[IDEATE] Running {self.name} strategy for {count} ideas", file=sys.stderr, flush=True)
 
-        # Get next IDs
-        ids = self.csv.get_next_ids(context.generation, count)
-        print(f"[IDEATE] Using IDs: {', '.join(ids)}", file=sys.stderr)
+        # Get next IDs, avoiding any already claimed in this ideation run
+        ids = self.csv.get_next_ids(context.generation, count, claimed_ids=claimed_ids)
+        print(f"[IDEATE] Using IDs: {', '.join(ids)}", file=sys.stderr, flush=True)
+
+        # Immediately claim these IDs (even if AI fails, don't reuse them)
+        claimed_ids.extend(ids)
 
         # Create temp CSV with stub rows
         temp_csv = Path(self.config.evolution_dir) / f"temp-csv-{os.getpid()}.csv"
@@ -398,6 +406,7 @@ class Ideator:
         print(f"[IDEATE] Top performers: {len(context.top_performers)}", file=sys.stderr)
 
         all_ideas: List[Idea] = []
+        claimed_ids: List[str] = []  # Track IDs claimed across all strategies
         strategies_succeeded = 0
 
         for strategy, count in self.strategies:
@@ -408,10 +417,12 @@ class Ideator:
                 context, count,
                 max_rounds=self.config.max_rounds,
                 initial_wait=self.config.initial_wait,
-                max_wait=self.config.max_wait
+                max_wait=self.config.max_wait,
+                claimed_ids=claimed_ids  # Pass already-claimed IDs
             )
 
             if ideas:
+                # IDs are already tracked in generate(), just count success
                 strategies_succeeded += 1
 
                 # Filter for novelty

package/lib/evolve_run.py

@@ -26,6 +26,8 @@ SCRIPT_DIR = Path(__file__).parent
 sys.path.insert(0, str(SCRIPT_DIR.parent))
 
 from lib.evolution_csv import EvolutionCSV
+from lib.log import log, log_error, log_warn, set_prefix
+set_prefix("RUN")
 
 
 @dataclass
@@ -56,24 +58,22 @@ class WorkerPool:
         if len(self.workers) >= self.max_workers:
             return None
 
-        cmd = [sys.executable, str(self.worker_script)]
+        # Use -u for unbuffered output so logs stream in real-time
+        cmd = [sys.executable, '-u', str(self.worker_script)]
         if self.config_path:
             cmd.extend(['--config', self.config_path])
         if self.timeout:
             cmd.extend(['--timeout', str(self.timeout)])
 
         try:
-            proc = subprocess.Popen(
-                cmd,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                text=True
-            )
+            # Don't capture output - let it stream directly to terminal
+            # This provides real-time visibility into which models are being used
+            proc = subprocess.Popen(cmd)
             self.workers[proc.pid] = proc
-            print(f"[RUN] Spawned worker {proc.pid}", file=sys.stderr)
+            log(f"Spawned worker {proc.pid}")
             return proc.pid
         except Exception as e:
-            print(f"[RUN] Failed to spawn worker: {e}", file=sys.stderr)
+            log_error(f"Failed to spawn worker: {e}")
             return None
 
     def cleanup_finished(self) -> List[int]:
@@ -86,15 +86,7 @@ class WorkerPool:
             if ret is not None:
                 finished_pids.append(pid)
                 exit_codes.append(ret)
-
-                # Log output
-                if proc.stdout:
-                    output = proc.stdout.read()
-                    if output:
-                        for line in output.strip().split('\n'):
-                            print(f"[WORKER-{pid}] {line}", file=sys.stderr)
-
-                print(f"[RUN] Worker {pid} exited with code {ret}", file=sys.stderr)
+                log(f"Worker {pid} exited with code {ret}")
 
         for pid in finished_pids:
             del self.workers[pid]
@@ -106,7 +98,7 @@ class WorkerPool:
         if not self.workers:
             return
 
-        print(f"[RUN] Shutting down {len(self.workers)} workers...", file=sys.stderr)
+        log(f"Shutting down {len(self.workers)} workers...")
 
         # Send SIGTERM
         for pid, proc in self.workers.items():
@@ -126,7 +118,7 @@ class WorkerPool:
         for pid, proc in list(self.workers.items()):
             try:
                 proc.kill()
-                print(f"[RUN] Force killed worker {pid}", file=sys.stderr)
+                log(f"Force killed worker {pid}")
             except Exception:
                 pass
 
@@ -162,36 +154,36 @@ class EvolutionRunner:
     def _handle_signal(self, signum, frame):
         """Handle termination signal."""
         sig_name = signal.Signals(signum).name
-        print(f"\n[RUN] Received {sig_name}, shutting down...", file=sys.stderr)
+        log(f"Received {sig_name}, shutting down...")
         self.shutdown_requested = True
         self.pool.shutdown()
         sys.exit(128 + signum)
 
     def cleanup_csv(self):
         """Clean up CSV at startup."""
-        print("[RUN] Cleaning up CSV...", file=sys.stderr)
+        log("Cleaning up CSV...")
         with EvolutionCSV(self.config.csv_path) as csv:
             # Remove duplicates
             removed = csv.remove_duplicate_candidates()
             if removed:
-                print(f"[RUN] Removed {removed} duplicate candidates", file=sys.stderr)
+                log(f"Removed {removed} duplicate candidates")
 
             # Reset stuck candidates
             reset = csv.reset_stuck_candidates()
             if reset:
-                print(f"[RUN] Reset {reset} stuck candidates", file=sys.stderr)
+                log(f"Reset {reset} stuck candidates")
 
             # Clean corrupted status fields
             fixed = csv.cleanup_corrupted_status_fields()
             if fixed:
-                print(f"[RUN] Fixed {fixed} corrupted status fields", file=sys.stderr)
+                log(f"Fixed {fixed} corrupted status fields")
 
     def ensure_baseline(self):
         """Ensure baseline entry exists in CSV."""
         with EvolutionCSV(self.config.csv_path) as csv:
             info = csv.get_candidate_info('baseline-000')
             if not info:
-                print("[RUN] Adding baseline-000 entry", file=sys.stderr)
+                log("Adding baseline-000 entry")
                 csv.append_candidates([{
                     'id': 'baseline-000',
                     'basedOnId': '',
@@ -211,14 +203,14 @@ class EvolutionRunner:
 
         # Need minimum completed algorithms to learn from
         if stats['complete'] < self.config.min_completed_for_ideation:
-            print(f"[RUN] Not enough completed ({stats['complete']} < {self.config.min_completed_for_ideation})", file=sys.stderr)
+            log(f"Not enough completed ({stats['complete']} < {self.config.min_completed_for_ideation})")
             return False
 
         return True
 
     def run_ideation(self) -> bool:
         """Run ideation. Returns True on success."""
-        print("[RUN] Running ideation...", file=sys.stderr)
+        log("Running ideation...")
 
         cmd = [sys.executable, str(self.ideate_script)]
         if self.config.config_path:
@@ -232,18 +224,18 @@ class EvolutionRunner:
                 cwd=self.config.evolution_dir
             )
 
-            # Log output
+            # Forward ideation output (already has timestamps from ideate module)
             if result.stdout:
                 for line in result.stdout.strip().split('\n'):
-                    print(f"[IDEATE] {line}", file=sys.stderr)
+                    print(line, file=sys.stderr, flush=True)
             if result.stderr:
                 for line in result.stderr.strip().split('\n'):
-                    print(f"[IDEATE] {line}", file=sys.stderr)
+                    print(line, file=sys.stderr, flush=True)
 
             return result.returncode == 0
 
         except Exception as e:
-            print(f"[RUN] Ideation failed: {e}", file=sys.stderr)
+            log_error(f"Ideation failed: {e}")
             return False
 
     def run(self) -> int:
@@ -253,9 +245,9 @@ class EvolutionRunner:
         Returns:
             Exit code
         """
-        print("[RUN] Starting evolution run", file=sys.stderr)
-        print(f"[RUN] Max workers: {self.config.max_workers}", file=sys.stderr)
-        print(f"[RUN] Auto ideate: {self.config.auto_ideate}", file=sys.stderr)
+        log("Starting evolution run")
+        log(f"Max workers: {self.config.max_workers}")
+        log(f"Auto ideate: {self.config.auto_ideate}")
 
         # Startup cleanup
         self.cleanup_csv()
@@ -271,7 +263,7 @@ class EvolutionRunner:
 
             # Check for API limit
             if 2 in exit_codes or 3 in exit_codes:
-                print("[RUN] API limit reached, waiting 5 minutes...", file=sys.stderr)
+                log("API limit reached, waiting 5 minutes...")
                 self.api_limit_reached = True
                 time.sleep(300)  # 5 minute wait
                 self.api_limit_reached = False
@@ -285,7 +277,7 @@ class EvolutionRunner:
 
             # Get stats
             stats = self.get_stats()
-            print(f"[RUN] Stats: {stats['pending']} pending, {stats['complete']} complete, {stats['running']} running", file=sys.stderr)
+            log(f"Stats: {stats['pending']} pending, {stats['complete']} complete, {stats['running']} running")
 
             # Check if we need ideation
             if stats['pending'] == 0 and self.pool.active_count == 0:
@@ -301,11 +293,11 @@ class EvolutionRunner:
                         if self.run_ideation():
                             continue  # Loop back to check for new work
                         else:
-                            print("[RUN] Ideation failed, waiting...", file=sys.stderr)
+                            log_warn("Ideation failed, waiting...")
                             time.sleep(30)
                             continue
                     else:
-                        print("[RUN] Evolution complete!", file=sys.stderr)
+                        log("Evolution complete!")
                         break
 
             # Spawn workers for pending work
@@ -320,7 +312,7 @@ class EvolutionRunner:
 
         # Cleanup
         self.pool.shutdown()
-        print("[RUN] Exiting", file=sys.stderr)
+        log("Exiting")
         return 0
 
 
@@ -389,10 +381,10 @@ def main():
         sys.exit(runner.run())
 
     except FileNotFoundError as e:
-        print(f"Error: {e}", file=sys.stderr)
+        log_error(f"Config error: {e}")
         sys.exit(1)
     except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
+        log_error(f"Error: {e}")
         import traceback
         traceback.print_exc()
         sys.exit(1)

package/lib/evolve_worker.py

@@ -30,8 +30,11 @@ from typing import Optional, Tuple, Dict, Any
 SCRIPT_DIR = Path(__file__).parent
 sys.path.insert(0, str(SCRIPT_DIR.parent))
 
+from lib.log import log, log_error, log_warn, log_debug, set_prefix
+set_prefix("WORKER")
+
 from lib.evolution_csv import EvolutionCSV
-from lib.ai_cli import call_ai, get_git_protection_warning, AIError, RateLimitError, APIExhaustedError, TimeoutError
+from lib.ai_cli import call_ai_with_backoff, get_git_protection_warning, AIError
 
 
 @dataclass
@@ -46,8 +49,11 @@ class Config:
     python_cmd: str = "python3"
     memory_limit_mb: int = 0
     timeout_seconds: int = 600
-    max_ai_retries: int = 3
     max_candidates: int = 5
+    # Retry configuration with exponential backoff
+    max_rounds: int = 10
+    initial_wait: int = 60
+    max_wait: int = 600
 
 
 @dataclass
@@ -75,10 +81,10 @@ class Worker:
     def _handle_signal(self, signum, frame):
         """Handle termination signal - reset current candidate to pending."""
         sig_name = signal.Signals(signum).name
-        print(f"[WORKER-{os.getpid()}] Received {sig_name}", file=sys.stderr)
+        log(f"Received {sig_name}")
 
         if self.current_candidate_id:
-            print(f"[WORKER-{os.getpid()}] Resetting {self.current_candidate_id} to pending", file=sys.stderr)
+            log(f"Resetting {self.current_candidate_id} to pending")
             try:
                 with EvolutionCSV(self.config.csv_path) as csv:
                     info = csv.get_candidate_info(self.current_candidate_id)
@@ -87,7 +93,7 @@ class Worker:
                     if status not in ('complete', 'failed', 'failed-ai-retry', 'failed-parent-missing'):
                         csv.update_candidate_status(self.current_candidate_id, 'pending')
             except Exception as e:
-                print(f"[WORKER-{os.getpid()}] Error resetting status: {e}", file=sys.stderr)
+                log(f"Error resetting status: {e}")
 
         sys.exit(128 + signum)
 
@@ -139,52 +145,42 @@ This is especially important for models with smaller context windows (like GLM).
 
 CRITICAL: If you do not know how to implement what was asked for, or if the requested change is unclear or not feasible, you MUST refuse to make any changes. DO NOT modify the code if you are uncertain about the implementation. Simply respond that you cannot implement the requested change and explain why. It is better to refuse than to make incorrect or random changes."""
 
-    def _call_ai_with_retries(self, prompt: str, target_file: Path, source_file: Path) -> Tuple[bool, str]:
+    def _call_ai_with_backoff(self, prompt: str, target_file: Path) -> Tuple[bool, str]:
         """
-        Call AI with retries.
+        Call AI with round-based retry and exponential backoff.
+
+        AIDEV-NOTE: Uses call_ai_with_backoff which tries all models in the pool,
+        then waits with exponential backoff if all fail, and repeats.
 
         Returns:
             Tuple of (success, model_name)
         """
-        for attempt in range(1, self.config.max_ai_retries + 1):
-            print(f"[WORKER-{os.getpid()}] AI attempt {attempt}/{self.config.max_ai_retries}", file=sys.stderr)
+        # Get file hash before AI call
+        hash_before = self._file_hash(target_file) if target_file.exists() else None
+
+        try:
+            output, model = call_ai_with_backoff(
+                prompt,
+                command="run",
+                working_dir=self.config.evolution_dir,
+                max_rounds=self.config.max_rounds,
+                initial_wait=self.config.initial_wait,
+                max_wait=self.config.max_wait
+            )
 
-            # Re-copy source if this is a retry
-            if attempt > 1:
-                print(f"[WORKER-{os.getpid()}] Re-copying source file for retry", file=sys.stderr)
-                shutil.copy(source_file, target_file)
+            # Check if file was modified
+            hash_after = self._file_hash(target_file) if target_file.exists() else None
 
-            # Get file hash before AI call
-            hash_before = self._file_hash(target_file) if target_file.exists() else None
+            if hash_before != hash_after and hash_after is not None:
+                log(f"AI successfully modified file (model: {model})")
+                return True, model
+            else:
+                log(f"AI completed but did not modify file")
+                return False, model
 
-            try:
-                output, model = call_ai(prompt, command="run", working_dir=self.config.evolution_dir)
-
-                # Check if file was modified
-                hash_after = self._file_hash(target_file) if target_file.exists() else None
-
-                if hash_before != hash_after and hash_after is not None:
-                    print(f"[WORKER-{os.getpid()}] AI successfully modified file (model: {model})", file=sys.stderr)
-                    return True, model
-                else:
-                    print(f"[WORKER-{os.getpid()}] AI did not modify file", file=sys.stderr)
-
-            except RateLimitError as e:
-                print(f"[WORKER-{os.getpid()}] Rate limit: {e}", file=sys.stderr)
-                raise  # Propagate to caller
-            except APIExhaustedError as e:
-                print(f"[WORKER-{os.getpid()}] API exhausted: {e}", file=sys.stderr)
-                raise  # Propagate to caller
-            except TimeoutError as e:
-                print(f"[WORKER-{os.getpid()}] Timeout: {e}", file=sys.stderr)
-            except AIError as e:
-                print(f"[WORKER-{os.getpid()}] AI error: {e}", file=sys.stderr)
-
-            if attempt < self.config.max_ai_retries:
-                print(f"[WORKER-{os.getpid()}] Will retry with different model...", file=sys.stderr)
-                time.sleep(2)
-
-        return False, ""
+        except AIError as e:
+            log_error(f"All AI retries exhausted: {e}")
+            return False, ""
 
     def _file_hash(self, path: Path) -> Optional[str]:
         """Get file hash."""
@@ -224,7 +220,7 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
 
         cmd.extend([self.config.evaluator_path, eval_arg])
 
-        print(f"[WORKER-{os.getpid()}] Running evaluator: {' '.join(cmd)}", file=sys.stderr)
+        log(f"Running evaluator: {' '.join(cmd)}")
 
         try:
             result = subprocess.run(
@@ -236,17 +232,17 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
             )
 
             if result.returncode != 0:
-                print(f"[WORKER-{os.getpid()}] Evaluator failed: {result.stderr}", file=sys.stderr)
+                log_error(f"Evaluator failed: {result.stderr}")
                 return None, {}
 
             output = result.stdout + result.stderr
             return self._parse_evaluator_output(output)
 
         except subprocess.TimeoutExpired:
-            print(f"[WORKER-{os.getpid()}] Evaluator timed out", file=sys.stderr)
+            log_error("Evaluator timed out")
             return None, {}
         except Exception as e:
-            print(f"[WORKER-{os.getpid()}] Evaluator error: {e}", file=sys.stderr)
+            log_error(f"Evaluator error: {e}")
             return None, {}
 
     def _parse_evaluator_output(self, output: str) -> Tuple[Optional[float], Dict[str, Any]]:
@@ -304,9 +300,9 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
             Exit code (0=success, 77=AI failed, 78=missing parent, etc.)
         """
         self.current_candidate_id = candidate.id
-        print(f"[WORKER-{os.getpid()}] Processing: {candidate.id}", file=sys.stderr)
-        print(f"[WORKER-{os.getpid()}] Description: {candidate.description}", file=sys.stderr)
-        print(f"[WORKER-{os.getpid()}] Based on: {candidate.based_on_id or 'baseline'}", file=sys.stderr)
+        log(f"Processing: {candidate.id}")
+        log(f"Description: {candidate.description[:80]}..." if len(candidate.description) > 80 else f"Description: {candidate.description}")
+        log(f"Based on: {candidate.based_on_id or 'baseline'}")
 
         is_baseline = self._is_baseline(candidate.id, candidate.based_on_id)
         target_file = Path(self.config.output_dir) / f"evolution_{candidate.id}.py"
@@ -315,7 +311,7 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
         resolved_parent, source_file = self._resolve_parent_id(candidate.based_on_id)
 
         if source_file is None and not is_baseline:
-            print(f"[WORKER-{os.getpid()}] ERROR: Parent not found: {candidate.based_on_id}", file=sys.stderr)
+            log_error(f"Parent not found: {candidate.based_on_id}")
             return 78  # Missing parent
 
         if source_file is None:
@@ -323,59 +319,45 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
 
         # Check if target already exists
         if target_file.exists():
-            print(f"[WORKER-{os.getpid()}] File already exists, running evaluation only", file=sys.stderr)
+            log("File already exists, running evaluation only")
         elif not is_baseline:
             # Copy source to target
-            print(f"[WORKER-{os.getpid()}] Copying {source_file} to {target_file}", file=sys.stderr)
+            log(f"Copying {source_file.name} to {target_file.name}")
             shutil.copy(source_file, target_file)
 
-            # Call AI to modify
+            # Call AI to modify (uses round-based retry with backoff)
             prompt = self._build_prompt(candidate, target_file.name)
+            success, model = self._call_ai_with_backoff(prompt, target_file)
 
-            try:
-                success, model = self._call_ai_with_retries(prompt, target_file, source_file)
-
-                if not success:
-                    print(f"[WORKER-{os.getpid()}] AI failed after all retries", file=sys.stderr)
-                    target_file.unlink(missing_ok=True)
-                    return 77  # AI generation failed
-
-                # Record model used
-                if model:
-                    with EvolutionCSV(self.config.csv_path) as csv:
-                        csv.update_candidate_field(candidate.id, 'run-LLM', model)
-
-            except RateLimitError:
+            if not success:
+                log_error("AI failed after all retries")
                 target_file.unlink(missing_ok=True)
-                with EvolutionCSV(self.config.csv_path) as csv:
-                    csv.update_candidate_status(candidate.id, 'pending')
-                return 2  # Rate limit
+                return 77  # AI generation failed
 
-            except APIExhaustedError:
-                target_file.unlink(missing_ok=True)
+            # Record model used
+            if model:
                 with EvolutionCSV(self.config.csv_path) as csv:
-                    csv.update_candidate_status(candidate.id, 'pending')
-                return 3  # API exhausted
+                    csv.update_candidate_field(candidate.id, 'run-LLM', model)
 
             # Check syntax
             if not self._check_syntax(target_file):
-                print(f"[WORKER-{os.getpid()}] Syntax error in generated file", file=sys.stderr)
+                log_error("Syntax error in generated file")
                 target_file.unlink(missing_ok=True)
                 with EvolutionCSV(self.config.csv_path) as csv:
                     csv.update_candidate_status(candidate.id, 'pending')
                 return 0  # Will retry
 
         # Run evaluator
-        print(f"[WORKER-{os.getpid()}] Running evaluator...", file=sys.stderr)
+        log("Running evaluator...")
         score, json_data = self._run_evaluator(candidate.id, is_baseline)
 
         if score is None:
-            print(f"[WORKER-{os.getpid()}] Evaluation failed - no score", file=sys.stderr)
+            log_error("Evaluation failed - no score")
             with EvolutionCSV(self.config.csv_path) as csv:
                 csv.update_candidate_status(candidate.id, 'failed')
             return 1
 
-        print(f"[WORKER-{os.getpid()}] Score: {score}", file=sys.stderr)
+        log(f"Score: {score}")
 
         # Update CSV
         with EvolutionCSV(self.config.csv_path) as csv:
@@ -397,7 +379,7 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
         Returns:
             Exit code
         """
-        print(f"[WORKER-{os.getpid()}] Started (max {self.config.max_candidates} candidates)", file=sys.stderr)
+        log(f"Started (max {self.config.max_candidates} candidates)")
         processed = 0
 
         while processed < self.config.max_candidates:
@@ -406,7 +388,7 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
                 result = csv.get_next_pending_candidate()
 
             if not result:
-                print(f"[WORKER-{os.getpid()}] No pending candidates", file=sys.stderr)
+                log("No pending candidates")
                 break
 
             candidate_id, _ = result
@@ -416,7 +398,7 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
                 info = csv.get_candidate_info(candidate_id)
 
             if not info:
-                print(f"[WORKER-{os.getpid()}] Candidate info not found: {candidate_id}", file=sys.stderr)
+                log_warn(f"Candidate info not found: {candidate_id}")
                 continue
 
             candidate = Candidate(
@@ -439,9 +421,9 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
             elif exit_code == 3:  # API exhausted
                 return 3
 
-            print(f"[WORKER-{os.getpid()}] Processed {processed}/{self.config.max_candidates}", file=sys.stderr)
+            log(f"Processed {processed}/{self.config.max_candidates}")
 
-        print(f"[WORKER-{os.getpid()}] Exiting", file=sys.stderr)
+        log("Exiting")
         return 0
 
 
@@ -475,6 +457,8 @@ def load_config_from_yaml(config_path: Optional[str] = None) -> Config:
             p = base_dir / p
         return str(p.resolve())
 
+    ideation = data.get('ideation', {})
+
     return Config(
         csv_path=resolve(data.get('csv_file', 'evolution.csv')),
         evolution_dir=str(base_dir.resolve()),
@@ -485,8 +469,10 @@ def load_config_from_yaml(config_path: Optional[str] = None) -> Config:
         python_cmd=data.get('python_cmd', 'python3'),
         memory_limit_mb=data.get('memory_limit_mb', 0),
         timeout_seconds=data.get('timeout_seconds', 600),
-        max_ai_retries=data.get('max_retries', 3),
-        max_candidates=data.get('worker_max_candidates', 5)
+        max_candidates=data.get('worker_max_candidates', 5),
+        max_rounds=ideation.get('max_rounds', 10),
+        initial_wait=ideation.get('initial_wait', 60),
+        max_wait=ideation.get('max_wait', 600)
     )
 
 
@@ -505,10 +491,10 @@ def main():
         sys.exit(worker.run())
 
     except FileNotFoundError as e:
-        print(f"Error: {e}", file=sys.stderr)
+        log_error(f"Config error: {e}")
         sys.exit(1)
     except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
+        log_error(f"Error: {e}")
         import traceback
         traceback.print_exc()
         sys.exit(1)

package/lib/log.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""
+Simple timestamped logging for claude-evolve.
+Uses stderr with flush=True for real-time output.
+"""
+
+import os
+import sys
+from datetime import datetime
+
+# Default prefix, can be set per-module
+_prefix = "EVOLVE"
+
+
+def set_prefix(prefix: str):
+    """Set the log prefix (e.g., 'WORKER', 'IDEATE', 'RUN')."""
+    global _prefix
+    _prefix = prefix
+
+
+def log(msg: str, prefix: str = None):
+    """Log with timestamp. Always flushes for real-time output."""
+    ts = datetime.now().strftime("%H:%M:%S")
+    p = prefix or _prefix
+    pid = os.getpid()
+    print(f"[{ts}] [{p}-{pid}] {msg}", file=sys.stderr, flush=True)
+
+
+def log_debug(msg: str, prefix: str = None):
+    """Log debug message (only if DEBUG env var set)."""
+    if os.environ.get('DEBUG') or os.environ.get('VERBOSE'):
+        log(f"[DEBUG] {msg}", prefix)
+
+
+def log_error(msg: str, prefix: str = None):
+    """Log error message."""
+    log(f"[ERROR] {msg}", prefix)
+
+
+def log_warn(msg: str, prefix: str = None):
+    """Log warning message."""
+    log(f"[WARN] {msg}", prefix)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-evolve",
-  "version": "1.9.6",
+  "version": "1.9.8",
   "bin": {
     "claude-evolve": "bin/claude-evolve",
     "claude-evolve-main": "bin/claude-evolve-main",