claude-evolve 1.9.7 → 1.9.9

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
 
@@ -47,6 +50,7 @@ class Config:
     memory_limit_mb: int = 0
     timeout_seconds: int = 600
     max_candidates: int = 5
+    max_validation_retries: int = 3  # Max attempts to fix validation errors (if validator.py exists)
     # Retry configuration with exponential backoff
     max_rounds: int = 10
     initial_wait: int = 60
@@ -78,10 +82,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 +94,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 +173,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]:
@@ -199,6 +203,136 @@ CRITICAL: If you do not know how to implement what was asked for, or if the requ
         except Exception:
             return False
 
+    def _find_validator(self) -> Optional[Path]:
+        """
+        Auto-detect validator.py in the evolution directory.
+        No config required - if validator.py exists, we use it.
+        """
+        validator_path = Path(self.config.evolution_dir) / "validator.py"
+        if validator_path.exists():
+            return validator_path
+        return None
+
+    def _run_validator(self, candidate_id: str) -> Tuple[bool, Dict[str, Any]]:
+        """
+        Run the validator (fast smoke test) before full evaluation.
+
+        AIDEV-NOTE: Auto-detects validator.py in evolution directory.
+        Returns exit code 0 on success, non-zero on failure.
+        Resilient to any output format - handles JSON, plain text, or nothing.
+
+        Returns:
+            Tuple of (success, error_info_dict)
+            - success: True if validation passed
+            - error_info: Dict with whatever info we could extract from output
+        """
+        validator_path = self._find_validator()
+        if not validator_path:
+            return True, {}  # No validator found, skip
+
+        cmd = [self.config.python_cmd, str(validator_path), candidate_id]
+        log(f"Running validator: {' '.join(cmd)}")
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30,  # Validator should be fast (~3 seconds)
+                cwd=self.config.evolution_dir
+            )
+
+            # Combine stdout and stderr for full context
+            stdout = result.stdout.strip() if result.stdout else ""
+            stderr = result.stderr.strip() if result.stderr else ""
+            combined_output = f"{stdout}\n{stderr}".strip()
+
+            # Try to extract structured info, but be resilient to any format
+            error_info = {'raw_output': combined_output}
+
+            # Try to parse JSON from stdout (validator may output JSON)
+            if stdout.startswith('{'):
+                try:
+                    parsed = json.loads(stdout)
+                    if isinstance(parsed, dict):
+                        error_info.update(parsed)
+                except json.JSONDecodeError:
+                    pass  # Not valid JSON, that's fine
+
+            # If no structured error, use the raw output
+            if 'error' not in error_info and combined_output:
+                error_info['error'] = combined_output
+
+            if result.returncode == 0:
+                log("Validation passed")
+                return True, error_info
+            else:
+                error_type = error_info.get('error_type', 'validation_failed')
+                log_warn(f"Validation failed: {error_type}")
+                return False, error_info
+
+        except subprocess.TimeoutExpired:
+            log_error("Validator timed out")
+            return False, {'error': 'Validator timed out after 30 seconds', 'error_type': 'timeout'}
+        except Exception as e:
+            log_error(f"Validator error: {e}")
+            return False, {'error': str(e), 'error_type': 'exception'}
+
+    def _build_fix_prompt(self, candidate: Candidate, target_basename: str, error_info: Dict[str, Any]) -> str:
+        """
+        Build AI prompt to fix validation errors.
+
+        AIDEV-NOTE: Resilient to any error_info structure - uses whatever is available.
+        """
+        prompt = f"""{get_git_protection_warning()}
+
+The code in {target_basename} failed validation. Please fix the errors and try again.
+
+## Validator Output
+
+"""
+        # Include whatever structured fields we have
+        if error_info.get('error_type'):
+            prompt += f"**Error Type:** {error_info['error_type']}\n\n"
+
+        if error_info.get('error'):
+            prompt += f"**Error:**\n{error_info['error']}\n\n"
+
+        if error_info.get('suggestion'):
+            prompt += f"**Suggested Fix:**\n{error_info['suggestion']}\n\n"
+
+        if error_info.get('traceback'):
+            tb = error_info['traceback']
+            # Truncate if too long
+            if len(tb) > 1500:
+                tb = "..." + tb[-1500:]
+            prompt += f"**Traceback:**\n```\n{tb}\n```\n\n"
+
+        # If we only have raw output (no structured fields), show that
+        if not any(error_info.get(k) for k in ('error', 'error_type', 'suggestion', 'traceback')):
+            raw = error_info.get('raw_output', 'No output captured')
+            # Truncate if needed
+            if len(raw) > 2000:
+                raw = raw[:2000] + "\n... (truncated)"
+            prompt += f"```\n{raw}\n```\n\n"
+
+        prompt += f"""## Instructions
+
+1. Read the file {target_basename} to understand the current code
+2. Identify the issue based on the validator output above
+3. Fix the code to resolve the validation error
+4. The fix should still implement: {candidate.description}
+
+**CRITICAL:** Make sure to actually fix the error. Do not just add comments or make cosmetic changes.
+
+To help debug, you can run the validator yourself:
+```
+python validator.py {target_basename}
+```
+"""
+
+        return prompt
+
     def _run_evaluator(self, candidate_id: str, is_baseline: bool) -> Tuple[Optional[float], Dict[str, Any]]:
         """
         Run the evaluator.
@@ -217,7 +351,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 +363,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 +431,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 +442,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 +450,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 +461,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 +472,69 @@ 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 validator with retry loop
+            # AIDEV-NOTE: Validator catches structural errors before expensive full evaluation.
+            # If validation fails, we give the AI feedback and ask it to fix the code.
+            validation_passed = False
+            for validation_attempt in range(self.config.max_validation_retries + 1):
+                valid, error_info = self._run_validator(candidate.id)
+
+                if valid:
+                    validation_passed = True
+                    break
+
+                if validation_attempt >= self.config.max_validation_retries:
+                    log_error(f"Validation failed after {self.config.max_validation_retries} fix attempts")
+                    break
+
+                # Ask AI to fix the validation error
+                log(f"Validation failed (attempt {validation_attempt + 1}), asking AI to fix...")
+                fix_prompt = self._build_fix_prompt(candidate, target_file.name, error_info)
+                success, fix_model = self._call_ai_with_backoff(fix_prompt, target_file)
+
+                if not success:
+                    log_error("AI failed to fix validation error")
+                    break
+
+                # Record that we used an additional model call for fixing
+                if fix_model:
+                    with EvolutionCSV(self.config.csv_path) as csv:
+                        current_llm = csv.get_candidate_info(candidate.id).get('run-LLM', '')
+                        new_llm = f"{current_llm}+{fix_model}" if current_llm else fix_model
+                        csv.update_candidate_field(candidate.id, 'run-LLM', new_llm)
+
+                # Re-check syntax after fix
+                if not self._check_syntax(target_file):
+                    log_error("Fix introduced syntax error")
+                    # Don't break - try again if we have retries left
+
+            if not validation_passed:
+                # Validation failed after all retries
+                with EvolutionCSV(self.config.csv_path) as csv:
+                    csv.update_candidate_status(candidate.id, 'failed-validation')
+                    # Store the last error for debugging
+                    if error_info:
+                        error_summary = f"{error_info.get('error_type', 'unknown')}: {error_info.get('error', '')[:100]}"
+                        csv.update_candidate_field(candidate.id, 'validation_error', error_summary)
+                return 1
+
         # 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 +556,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 +565,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 +575,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 +598,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
 
 
@@ -467,6 +647,7 @@ def load_config_from_yaml(config_path: Optional[str] = None) -> Config:
         memory_limit_mb=data.get('memory_limit_mb', 0),
         timeout_seconds=data.get('timeout_seconds', 600),
         max_candidates=data.get('worker_max_candidates', 5),
+        max_validation_retries=data.get('max_validation_retries', 3),
         max_rounds=ideation.get('max_rounds', 10),
         initial_wait=ideation.get('initial_wait', 60),
         max_wait=ideation.get('max_wait', 600)
@@ -488,10 +669,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.9",
   "bin": {
     "claude-evolve": "bin/claude-evolve",
     "claude-evolve-main": "bin/claude-evolve-main",