claude-evolve 1.9.7 → 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,7 +58,8 @@ 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:
@@ -67,10 +70,10 @@ class WorkerPool:
             # 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]:
@@ -83,7 +86,7 @@ class WorkerPool:
             if ret is not None:
                 finished_pids.append(pid)
                 exit_codes.append(ret)
-                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]
@@ -95,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():
@@ -115,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
 
@@ -151,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': '',
@@ -200,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:
@@ -221,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:
@@ -242,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()
@@ -260,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
@@ -274,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:
@@ -290,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
@@ -309,7 +312,7 @@ class EvolutionRunner:
 
         # Cleanup
         self.pool.shutdown()
-        print("[RUN] Exiting", file=sys.stderr)
+        log("Exiting")
         return 0
 
 
@@ -378,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,6 +30,9 @@ 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_with_backoff, get_git_protection_warning, AIError
 
@@ -78,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)
@@ -90,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)
 
@@ -169,14 +172,14 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
             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)
+                log(f"AI successfully modified file (model: {model})")
                 return True, model
             else:
-                print(f"[WORKER-{os.getpid()}] AI completed but did not modify file", file=sys.stderr)
+                log(f"AI completed but did not modify file")
                 return False, model
 
         except AIError as e:
-            print(f"[WORKER-{os.getpid()}] All AI retries exhausted: {e}", file=sys.stderr)
+            log_error(f"All AI retries exhausted: {e}")
             return False, ""
 
     def _file_hash(self, path: Path) -> Optional[str]:
@@ -217,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(
@@ -229,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]]:
@@ -297,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"
@@ -308,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:
@@ -316,10 +319,10 @@ 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 (uses round-based retry with backoff)
@@ -327,7 +330,7 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
             success, model = self._call_ai_with_backoff(prompt, target_file)
 
             if not success:
-                print(f"[WORKER-{os.getpid()}] AI failed after all retries", file=sys.stderr)
+                log_error("AI failed after all retries")
                 target_file.unlink(missing_ok=True)
                 return 77  # AI generation failed
 
@@ -338,23 +341,23 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
 
             # 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:
@@ -376,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:
@@ -385,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
@@ -395,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(
@@ -418,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
 
 
@@ -488,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.7",
+  "version": "1.9.8",
   "bin": {
     "claude-evolve": "bin/claude-evolve",
     "claude-evolve-main": "bin/claude-evolve-main",