claude-evolve 1.11.1 → 1.11.2

package/lib/ai-cli.sh

@@ -55,6 +55,7 @@ EOF
 call_ai_model_configured() {
   local model_name="$1"
   local prompt="$2"
+  local codex_gpt5_model="${CODEX_GPT5_MODEL:-gpt-5.3}"
   
   # Record start time
   local start_time=$(date +%s)
@@ -96,12 +97,12 @@ $prompt"
       ;;
     gpt5high)
       local ai_output
-      ai_output=$(timeout -k 30 600 codex exec -m gpt-5.2 -c model_reasoning_effort="high" --dangerously-bypass-approvals-and-sandbox "$prompt" 2>&1)
+      ai_output=$(timeout -k 30 600 codex exec -m "$codex_gpt5_model" -c model_reasoning_effort="high" --dangerously-bypass-approvals-and-sandbox "$prompt" 2>&1)
       local ai_exit_code=$?
       ;;
     gpt5)
       local ai_output
-      ai_output=$(timeout -k 30 600 codex exec -m gpt-5.2 --dangerously-bypass-approvals-and-sandbox "$prompt" 2>&1)
+      ai_output=$(timeout -k 30 600 codex exec -m "$codex_gpt5_model" --dangerously-bypass-approvals-and-sandbox "$prompt" 2>&1)
       local ai_exit_code=$?
       ;;
     o3high)

package/lib/evolution_csv.py

@@ -747,6 +747,39 @@ class EvolutionCSV:
 
         return max_gen
 
+    def get_generation_count(self, generation: int) -> int:
+        """
+        Count the number of items in a specific generation.
+
+        Args:
+            generation: Generation number
+
+        Returns:
+            Number of items in that generation
+        """
+        rows = self._read_csv()
+        if not rows:
+            return 0
+
+        gen_prefix = f"gen{generation:02d}" if generation < 100 else f"gen{generation}"
+        has_header = rows and rows[0] and rows[0][0].lower() == 'id'
+        start_idx = 1 if has_header else 0
+
+        count = 0
+        for row in rows[start_idx:]:
+            if not self.is_valid_candidate_row(row):
+                continue
+
+            candidate_id = row[0].strip().strip('"')
+            # Must match exactly gen{N}- to avoid gen92 matching gen920
+            if candidate_id.startswith(gen_prefix + '-'):
+                # Extra check: ensure the part after gen prefix is the dash
+                gen_part = candidate_id.split('-')[0]
+                if gen_part == gen_prefix:
+                    count += 1
+
+        return count
+
     def get_next_id(self, generation: int) -> str:
         """
         Get the next available ID for a generation.

package/lib/evolve_ideate.py

@@ -25,6 +25,11 @@ sys.path.insert(0, str(SCRIPT_DIR.parent))
 from lib.evolution_csv import EvolutionCSV
 from lib.ai_cli import call_ai_with_backoff, get_git_protection_warning, AIError
 from lib.embedding import check_novelty as check_embedding_novelty, get_embedding, set_cache_file, save_cache
+from lib.log import init_file_logging, log as _log_base
+
+def _log(msg: str):
+    """Log with IDEATE prefix."""
+    _log_base(msg, prefix="IDEATE")
 
 
 def sample_parent_powerlaw(parents: List[Dict], alpha: float = 1.0) -> Dict:
@@ -178,34 +183,54 @@ class IdeationStrategy(ABC):
                 parent = self._get_default_parent(context)
                 f.write(f'{id},{parent},"[PLACEHOLDER: Replace with algorithmic idea]",,pending\n')
 
+        # AIDEV-NOTE: Retry loop for when AI "succeeds" but doesn't edit the file
+        # Non-agentic models (kimi, grok) return text but can't edit files
+        max_parse_retries = 3
         try:
-            # Build prompt
-            prompt = self.build_prompt(context, ids, temp_csv.name)
-
-            # Call AI with round-based retry and backoff
-            output, model = call_ai_with_backoff(
-                prompt,
-                command="ideate",
-                working_dir=self.config.evolution_dir,
-                max_rounds=max_rounds,
-                initial_wait=initial_wait,
-                max_wait=max_wait
-            )
+            for parse_attempt in range(max_parse_retries):
+                try:
+                    # Build prompt
+                    prompt = self.build_prompt(context, ids, temp_csv.name)
+
+                    # Call AI with round-based retry and backoff
+                    output, model = call_ai_with_backoff(
+                        prompt,
+                        command="ideate",
+                        working_dir=self.config.evolution_dir,
+                        max_rounds=max_rounds,
+                        initial_wait=initial_wait,
+                        max_wait=max_wait
+                    )
 
-            # Parse results from modified CSV
-            ideas = self._parse_results(temp_csv, ids)
+                    # Parse results from modified CSV
+                    ideas = self._parse_results(temp_csv, ids)
 
-            if ideas:
-                # Record model used
-                for idea in ideas:
-                    idea.strategy = f"{self.name} ({model})"
-                return ideas
-            else:
-                print(f"[IDEATE] AI completed but no ideas parsed from output", file=sys.stderr)
-                return []
-
-        except AIError as e:
-            print(f"[IDEATE] All retries exhausted in {self.name}: {e}", file=sys.stderr)
+                    if ideas:
+                        # Record model used
+                        for idea in ideas:
+                            idea.strategy = f"{self.name} ({model})"
+                        return ideas
+                    else:
+                        # AI returned but didn't edit the file - retry with different model
+                        if parse_attempt < max_parse_retries - 1:
+                            print(f"[IDEATE] {model} didn't edit file (attempt {parse_attempt + 1}/{max_parse_retries}), retrying...", file=sys.stderr)
+                            # Reset temp CSV for next attempt
+                            shutil.copy(self.config.csv_path, temp_csv)
+                            with open(temp_csv, 'a') as f:
+                                for id in ids:
+                                    parent = self._get_default_parent(context)
+                                    f.write(f'{id},{parent},"[PLACEHOLDER: Replace with algorithmic idea]",,pending\n')
+                            continue
+                        else:
+                            print(f"[IDEATE] AI completed but no ideas parsed after {max_parse_retries} attempts", file=sys.stderr)
+                            return []
+
+                except AIError as e:
+                    print(f"[IDEATE] All retries exhausted in {self.name}: {e}", file=sys.stderr)
+                    return []
+
+            # Should not reach here
+            print(f"[IDEATE] {self.name} failed after all attempts", file=sys.stderr)
             return []
 
         finally:
@@ -427,7 +452,21 @@ class Ideator:
         with EvolutionCSV(self.config.csv_path) as csv:
             top_performers = csv.get_top_performers(self.config.num_elites)
             existing_descriptions = csv.get_all_descriptions()
-            generation = csv.get_highest_generation() + 1
+
+            # AIDEV-NOTE: Check if highest generation is complete before creating new one
+            # This prevents sparse generations from accumulating
+            highest_gen = csv.get_highest_generation()
+            if highest_gen > 0:
+                gen_count = csv.get_generation_count(highest_gen)
+                if gen_count < self.config.total_ideas:
+                    # Continue incomplete generation
+                    generation = highest_gen
+                    print(f"[IDEATE] Continuing incomplete gen{highest_gen} ({gen_count}/{self.config.total_ideas} items)", file=sys.stderr)
+                else:
+                    # Start new generation
+                    generation = highest_gen + 1
+            else:
+                generation = 1
 
         # Read brief
         brief_content = ""
@@ -605,6 +644,9 @@ def main():
     try:
         config = load_config(args.config)
 
+        # Initialize file logging in the evolution directory
+        init_file_logging(config.evolution_dir)
+
         ideator = Ideator(config)
         count = ideator.run()
 

package/lib/evolve_run.py

@@ -26,7 +26,7 @@ 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
+from lib.log import log, log_error, log_warn, set_prefix, init_file_logging
 from lib.meta_learning import process_new_generations
 set_prefix("RUN")
 
@@ -388,6 +388,9 @@ def main():
     try:
         config = load_config(args.config)
 
+        # Initialize file logging in the evolution directory
+        init_file_logging(config.evolution_dir)
+
         if args.sequential:
             config.max_workers = 1
         elif args.parallel:

package/lib/evolve_worker.py

@@ -30,7 +30,7 @@ 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
+from lib.log import log, log_error, log_warn, log_debug, set_prefix, init_file_logging
 set_prefix("WORKER")
 
 from lib.evolution_csv import EvolutionCSV
@@ -750,6 +750,9 @@ def main():
         if args.timeout:
             config.timeout_seconds = args.timeout
 
+        # Initialize file logging in the evolution directory
+        init_file_logging(config.evolution_dir)
+
         worker = Worker(config)
         sys.exit(worker.run())
 

package/lib/log.py

@@ -2,15 +2,24 @@
 """
 Simple timestamped logging for claude-evolve.
 Uses stderr with flush=True for real-time output.
+Also writes to a log file if configured.
+
+AIDEV-NOTE: Set CLAUDE_EVOLVE_LOG_DIR or call init_file_logging() to enable file logging.
 """
 
 import os
 import sys
 from datetime import datetime
+from pathlib import Path
+from typing import Optional
 
 # Default prefix, can be set per-module
 _prefix = "EVOLVE"
 
+# File logging
+_log_file = None
+_log_dir = None
+
 
 def set_prefix(prefix: str):
     """Set the log prefix (e.g., 'WORKER', 'IDEATE', 'RUN')."""
@@ -18,12 +27,64 @@ def set_prefix(prefix: str):
     _prefix = prefix
 
 
+def init_file_logging(log_dir: Optional[str] = None):
+    """
+    Initialize file logging to the specified directory.
+
+    Creates a log file named evolve_YYYYMMDD.log in the log directory.
+    If log_dir is None, uses CLAUDE_EVOLVE_LOG_DIR env var or the current directory.
+    """
+    global _log_file, _log_dir
+
+    if log_dir:
+        _log_dir = Path(log_dir)
+    elif os.environ.get('CLAUDE_EVOLVE_LOG_DIR'):
+        _log_dir = Path(os.environ['CLAUDE_EVOLVE_LOG_DIR'])
+    elif os.environ.get('CLAUDE_EVOLVE_CONFIG'):
+        # Use the directory containing the config file
+        _log_dir = Path(os.environ['CLAUDE_EVOLVE_CONFIG']).parent
+    else:
+        _log_dir = Path.cwd()
+
+    _log_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create daily log file
+    date_str = datetime.now().strftime("%Y%m%d")
+    log_path = _log_dir / f"evolve_{date_str}.log"
+
+    try:
+        _log_file = open(log_path, 'a', buffering=1)  # Line buffered
+        log(f"File logging initialized: {log_path}")
+    except Exception as e:
+        print(f"[WARN] Could not open log file {log_path}: {e}", file=sys.stderr)
+        _log_file = None
+
+
+def _write_to_file(msg: str):
+    """Write message to log file if configured."""
+    global _log_file
+    if _log_file:
+        try:
+            _log_file.write(msg + "\n")
+            _log_file.flush()
+        except Exception:
+            pass  # Don't fail on log write errors
+
+
 def log(msg: str, prefix: str = None):
     """Log with timestamp. Always flushes for real-time output."""
     ts = datetime.now().strftime("%H:%M:%S")
+    date_ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     p = prefix or _prefix
     pid = os.getpid()
-    print(f"[{ts}] [{p}-{pid}] {msg}", file=sys.stderr, flush=True)
+
+    # Console output (short timestamp)
+    console_msg = f"[{ts}] [{p}-{pid}] {msg}"
+    print(console_msg, file=sys.stderr, flush=True)
+
+    # File output (full timestamp)
+    file_msg = f"[{date_ts}] [{p}-{pid}] {msg}"
+    _write_to_file(file_msg)
 
 
 def log_debug(msg: str, prefix: str = None):
@@ -40,3 +101,19 @@ def log_error(msg: str, prefix: str = None):
 def log_warn(msg: str, prefix: str = None):
     """Log warning message."""
     log(f"[WARN] {msg}", prefix)
+
+
+def close_log():
+    """Close the log file."""
+    global _log_file
+    if _log_file:
+        try:
+            _log_file.close()
+        except Exception:
+            pass
+        _log_file = None
+
+
+# Auto-initialize file logging if env var is set
+if os.environ.get('CLAUDE_EVOLVE_LOG_DIR') or os.environ.get('CLAUDE_EVOLVE_CONFIG'):
+    init_file_logging()

package/package.json

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