claude-evolve 1.11.8 → 1.11.11

package/bin/claude-evolve-check

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+# claude-evolve-check - Health check for AI model configurations
+# Tests all configured AI models to verify they're working before starting evolution runs
+
+set -e
+
+# Colors for output
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "$(readlink -f "${BASH_SOURCE[0]}" 2>/dev/null || echo "${BASH_SOURCE[0]}")")" && pwd)"
+LIB_DIR="$(dirname "$SCRIPT_DIR")/lib"
+
+# Source configuration
+source "$LIB_DIR/config.sh"
+load_config
+
+# Source AI CLI for model calls
+source "$LIB_DIR/ai-cli.sh"
+
+# Test timeout in seconds (short to fail fast)
+TEST_TIMEOUT=30
+
+# Simple test prompt
+TEST_PROMPT="Say hello in exactly 3 words."
+
+echo -e "${CYAN}🔍 Claude Evolve - AI Model Health Check${NC}"
+echo "============================================"
+echo
+
+# Collect all unique models into a simple list
+ALL_MODELS=""
+for model in $LLM_RUN $LLM_RUN_FALLBACK $LLM_IDEATE $LLM_IDEATE_FALLBACK; do
+  # Check if model already in list
+  if ! echo "$ALL_MODELS" | grep -q -w "$model"; then
+    ALL_MODELS="$ALL_MODELS $model"
+  fi
+done
+ALL_MODELS=$(echo "$ALL_MODELS" | xargs)  # Trim whitespace
+
+echo "Models to test: $ALL_MODELS"
+echo
+
+# Track results
+PASSED=0
+FAILED=0
+FAILED_MODELS=""
+TIMEOUT_MODELS=""
+
+# Test each model
+for model in $ALL_MODELS; do
+  echo -n "Testing $model... "
+
+  # Run the test with timeout
+  START_TIME=$(date +%s)
+
+  # Call the model directly using the configured command
+  set +e
+  OUTPUT=$(timeout -k 5 $TEST_TIMEOUT bash -c "
+    source '$LIB_DIR/config.sh'
+    load_config
+    source '$LIB_DIR/ai-cli.sh'
+    call_ai_model_configured '$model' '$TEST_PROMPT' 2>/dev/null
+  " 2>&1)
+  EXIT_CODE=$?
+  set -e
+
+  END_TIME=$(date +%s)
+  DURATION=$((END_TIME - START_TIME))
+
+  # Check result
+  if [[ $EXIT_CODE -eq 0 ]] && [[ -n "$OUTPUT" ]] && [[ ${#OUTPUT} -gt 10 ]]; then
+    echo -e "${GREEN}✓ OK${NC} (${DURATION}s, ${#OUTPUT} chars)"
+    ((PASSED++))
+  elif [[ $EXIT_CODE -eq 124 ]]; then
+    echo -e "${RED}✗ TIMEOUT${NC} (${TEST_TIMEOUT}s - likely permission dialog or hanging)"
+    TIMEOUT_MODELS="$TIMEOUT_MODELS $model"
+    ((FAILED++))
+  else
+    echo -e "${RED}✗ FAILED${NC} (exit=$EXIT_CODE, ${#OUTPUT} chars)"
+    if [[ -n "$OUTPUT" ]] && [[ ${#OUTPUT} -lt 200 ]]; then
+      echo "    Output: $OUTPUT"
+    fi
+    FAILED_MODELS="$FAILED_MODELS $model"
+    ((FAILED++))
+  fi
+done
+
+echo
+echo "============================================"
+echo -e "${CYAN}Summary${NC}"
+echo "============================================"
+echo -e "Passed: ${GREEN}$PASSED${NC}"
+echo -e "Failed: ${RED}$FAILED${NC}"
+echo
+
+# Show model lists with status
+echo "Model Configuration:"
+echo -e "  LLM_RUN: $LLM_RUN"
+echo -e "  LLM_RUN_FALLBACK: $LLM_RUN_FALLBACK"
+echo -e "  LLM_IDEATE: $LLM_IDEATE"
+echo -e "  LLM_IDEATE_FALLBACK: $LLM_IDEATE_FALLBACK"
+echo
+
+# Recommendations
+if [[ $FAILED -gt 0 ]]; then
+  echo -e "${YELLOW}⚠️  Recommendations:${NC}"
+  for model in $TIMEOUT_MODELS; do
+    echo "  - $model: Check for permission dialogs (try running interactively first)"
+  done
+  for model in $FAILED_MODELS; do
+    echo "  - $model: Check authentication and CLI installation"
+  done
+  echo
+  echo "Consider reordering your model lists to put working models first."
+  exit 1
+else
+  echo -e "${GREEN}✅ All models are working!${NC}"
+  exit 0
+fi

package/bin/claude-evolve-main

@@ -59,6 +59,7 @@ USAGE:
 
 COMMANDS:
     setup              Initialize evolution workspace
+    check              Test all configured AI models (health check)
     ideate             Generate new algorithm ideas
     run                Execute evolution candidates
     analyze            Analyze evolution results
@@ -95,14 +96,15 @@ show_menu() {
   echo "What would you like to do?"
   echo
   echo "  1) setup           - Initialize evolution workspace"
-  echo "  2) ideate          - Generate new algorithm ideas"
-  echo "  3) run             - Execute evolution candidates"
-  echo "  4) analyze         - Analyze evolution results"
-  echo "  5) edit            - Manage candidate statuses by generation"
-  echo "  6) status          - Show evolution progress and current leader"
-  echo "  7) autostatus      - Auto-updating status display (real-time)"
-  echo "  8) clean-corrupted - Remove corrupted records from CSV"
-  echo "  9) config          - Manage configuration settings"
+  echo "  2) check           - Test all configured AI models"
+  echo "  3) ideate          - Generate new algorithm ideas"
+  echo "  4) run             - Execute evolution candidates"
+  echo "  5) analyze         - Analyze evolution results"
+  echo "  6) edit            - Manage candidate statuses by generation"
+  echo "  7) status          - Show evolution progress and current leader"
+  echo "  8) autostatus      - Auto-updating status display (real-time)"
+  echo "  9) clean-corrupted - Remove corrupted records from CSV"
+  echo "  c) config          - Manage configuration settings"
   echo "  k) killall         - Kill all running evolution processes"
   echo "  h) help            - Show help message"
   echo "  0) exit            - Exit"
@@ -156,18 +158,19 @@ check_for_updates
 # Main logic
 if [[ $# -eq 0 ]]; then
   show_menu
-  read -r -p "Enter your choice (1-9, k, h, 0): " choice
+  read -r -p "Enter your choice (1-9, c, k, h, 0): " choice
 
   case $choice in
   1) exec "$SCRIPT_DIR/claude-evolve-setup" ;;
-  2) exec "$SCRIPT_DIR/claude-evolve-ideate" ;;
-  3) exec "$SCRIPT_DIR/claude-evolve-run" ;;
-  4) exec "$SCRIPT_DIR/claude-evolve-analyze" ;;
-  5) exec "$SCRIPT_DIR/claude-evolve-edit" ;;
-  6) exec "$SCRIPT_DIR/claude-evolve-status" ;;
-  7) exec "$SCRIPT_DIR/claude-evolve-autostatus" ;;
-  8) exec "$SCRIPT_DIR/claude-evolve-clean-corrupted" ;;
-  9) exec "$SCRIPT_DIR/claude-evolve-config" ;;
+  2) exec "$SCRIPT_DIR/claude-evolve-check" ;;
+  3) exec "$SCRIPT_DIR/claude-evolve-ideate" ;;
+  4) exec "$SCRIPT_DIR/claude-evolve-run" ;;
+  5) exec "$SCRIPT_DIR/claude-evolve-analyze" ;;
+  6) exec "$SCRIPT_DIR/claude-evolve-edit" ;;
+  7) exec "$SCRIPT_DIR/claude-evolve-status" ;;
+  8) exec "$SCRIPT_DIR/claude-evolve-autostatus" ;;
+  9) exec "$SCRIPT_DIR/claude-evolve-clean-corrupted" ;;
+  c|C) exec "$SCRIPT_DIR/claude-evolve-config" ;;
   k|K) exec "$SCRIPT_DIR/claude-evolve-killall" ;;
   h|H) show_help ;;
   0)
@@ -175,7 +178,7 @@ if [[ $# -eq 0 ]]; then
     exit 0
     ;;
   *)
-    echo -e "${RED}Invalid choice. Please select 1-9, k, h, or 0.${NC}"
+    echo -e "${RED}Invalid choice. Please select 1-9, c, k, h, or 0.${NC}"
     exit 1
     ;;
   esac
@@ -192,6 +195,10 @@ setup)
   shift
   exec "$SCRIPT_DIR/claude-evolve-setup" "$@"
   ;;
+check)
+  shift
+  exec "$SCRIPT_DIR/claude-evolve-check" "$@"
+  ;;
 ideate)
   shift
   exec "$SCRIPT_DIR/claude-evolve-ideate" "$@"

package/lib/ai-cli.sh

@@ -151,12 +151,26 @@ $prompt"
       ai_output=$(timeout -k 30 600 opencode -m openrouter/z-ai/glm-4.7 run "$prompt" 2>&1)
       local ai_exit_code=$?
       ;;
+    glm-5)
+      local ai_output
+      # GLM-5: 744B MoE model, very cheap ($0.80/$2.56 per 1M tokens), 200K context
+      # Released Feb 2026 - scores 77.8% SWE-bench, MIT license
+      ai_output=$(timeout -k 30 600 opencode -m openrouter/z-ai/glm-5 run "$prompt" 2>&1)
+      local ai_exit_code=$?
+      ;;
     glm-zai)
-      # GLM -- can be slow sometimes
+      # GLM 4.7 via Z.AI agentic mode -- can be slow sometimes
       local ai_output
       ai_output=$(timeout -k 30 1800 opencode -m zai-coding-plan/glm-4.7 run "$prompt" 2>&1)
       local ai_exit_code=$?
       ;;
+    glm-5-zai)
+      # GLM-5 via Z.AI agentic mode - supports file editing for ideation
+      # 744B MoE, strong reasoning, can edit files
+      local ai_output
+      ai_output=$(timeout -k 30 1800 opencode -m zai-coding-plan/glm-5 run "$prompt" 2>&1)
+      local ai_exit_code=$?
+      ;;
     deepseek-openrouter)
       local ai_output
       ai_output=$(timeout -k 30 600 opencode -m openrouter/deepseek/deepseek-v3.2 run "$prompt" 2>&1)
@@ -297,13 +311,13 @@ clean_ai_output() {
   echo "$output"
 }
 
-# Get models for a specific command (run or ideate)
+# Get primary models for a specific command (run or ideate)
 # Usage: get_models_for_command <command>
-# Returns: Array of model names
+# Returns: Space-separated list of model names
 get_models_for_command() {
   local command="$1"
   local model_list=""
-  
+
   case "$command" in
     run)
       model_list="$LLM_RUN"
@@ -316,8 +330,30 @@ get_models_for_command() {
       return 1
       ;;
   esac
-  
-  # Convert space-separated list to array
+
+  echo "$model_list"
+}
+
+# Get fallback models for a specific command (run or ideate)
+# Usage: get_fallback_models_for_command <command>
+# Returns: Space-separated list of fallback model names
+get_fallback_models_for_command() {
+  local command="$1"
+  local model_list=""
+
+  case "$command" in
+    run)
+      model_list="$LLM_RUN_FALLBACK"
+      ;;
+    ideate)
+      model_list="$LLM_IDEATE_FALLBACK"
+      ;;
+    *)
+      echo "[ERROR] Unknown command: $command" >&2
+      return 1
+      ;;
+  esac
+
   echo "$model_list"
 }
 

package/lib/ai_cli.py

@@ -166,7 +166,7 @@ def call_ai(
 
 def get_models_for_command(command: str) -> List[str]:
     """
-    Get the list of available models for a command.
+    Get the list of primary models for a command.
 
     Args:
         command: Either "run" or "ideate"
@@ -199,6 +199,41 @@ def get_models_for_command(command: str) -> List[str]:
     return model_list.split()
 
 
+def get_fallback_models_for_command(command: str) -> List[str]:
+    """
+    Get the list of fallback models for a command.
+
+    Args:
+        command: Either "run" or "ideate"
+
+    Returns:
+        List of fallback model names
+    """
+    bash_script = f'''
+        source "{SCRIPT_DIR}/config.sh"
+        load_config
+        case "$1" in
+            run) echo "$LLM_RUN_FALLBACK" ;;
+            ideate) echo "$LLM_IDEATE_FALLBACK" ;;
+        esac
+    '''
+
+    result = subprocess.run(
+        ["bash", "-c", bash_script, "bash", command],
+        capture_output=True,
+        text=True
+    )
+
+    if result.returncode != 0:
+        return []
+
+    model_list = result.stdout.strip()
+    if not model_list:
+        return []
+
+    return model_list.split()
+
+
 def call_ai_model(
     prompt: str,
     model_name: str,
@@ -268,6 +303,54 @@ def call_ai_model(
         raise AIError(f"Failed to call AI: {e}")
 
 
+def _try_models_with_backoff(
+    prompt: str,
+    models: List[str],
+    tier_name: str,
+    working_dir: Optional[str],
+    env_vars: Optional[dict],
+    max_rounds: int,
+    initial_wait: int,
+    max_wait: int
+) -> Tuple[Optional[str], Optional[str], dict]:
+    """
+    Try a list of models with round-based retries and exponential backoff.
+
+    Returns:
+        Tuple of (output, model_name, last_errors)
+        output/model_name are None if all models failed
+    """
+    wait_time = initial_wait
+    last_errors = {}
+
+    for round_num in range(max_rounds):
+        shuffled_models = models.copy()
+        random.shuffle(shuffled_models)
+
+        _log(f"{tier_name} 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:
+                    _log(f"Succeeded on round {round_num + 1} with {model}")
+                else:
+                    _log(f"Success with {model}")
+                return output, model_name, last_errors
+            except AIError as e:
+                _log(f"{model} failed: {str(e)[:60]}...")
+                last_errors[model] = str(e)
+
+        # All models failed in this round
+        if round_num < max_rounds - 1:
+            _log(f"All {tier_name} models failed in round {round_num + 1}, waiting {wait_time}s...")
+            time.sleep(wait_time)
+            wait_time = min(wait_time * 2, max_wait)
+
+    return None, None, last_errors
+
+
 def call_ai_with_backoff(
     prompt: str,
     command: str = "ideate",
@@ -275,69 +358,68 @@ def call_ai_with_backoff(
     env_vars: Optional[dict] = None,
     max_rounds: int = 10,
     initial_wait: int = 60,
-    max_wait: int = 600
+    max_wait: int = 600,
+    use_fallback: bool = True
 ) -> Tuple[str, str]:
     """
-    Call AI with round-based retries and exponential backoff.
+    Call AI with tiered fallback and round-based retries with exponential backoff.
 
-    AIDEV-NOTE: This is the robust retry mechanism for handling rate limits.
-    - Tries each model in the pool (shuffled order)
-    - If all models fail in a round, waits with exponential backoff
-    - Keeps going until success or max_rounds exhausted
+    AIDEV-NOTE: Tiered fallback system:
+    1. First tries all primary models with backoff
+    2. If primary exhausted and use_fallback=True, tries fallback models
+    3. Fallback models are cheaper/simpler backups (haiku, flash, etc.)
 
     Args:
         prompt: The prompt to send
         command: "run" or "ideate" - determines model pool
         working_dir: Directory for file operations
         env_vars: Additional environment variables
-        max_rounds: Maximum number of full rounds to attempt
+        max_rounds: Maximum number of full rounds per tier
         initial_wait: Initial wait time in seconds after first failed round
         max_wait: Maximum wait time in seconds between rounds
+        use_fallback: Whether to try fallback tier if primary fails
 
     Returns:
         Tuple of (output, model_name)
 
     Raises:
-        AIError: If all rounds exhausted without success
+        AIError: If all tiers exhausted without success
     """
-    models = get_models_for_command(command)
-    if not models:
-        raise AIError(f"No models configured for command: {command}")
+    # Try primary tier first
+    primary_models = get_models_for_command(command)
+    if not primary_models:
+        raise AIError(f"No primary models configured for command: {command}")
+
+    output, model_name, primary_errors = _try_models_with_backoff(
+        prompt, primary_models, "Primary",
+        working_dir, env_vars, max_rounds, initial_wait, max_wait
+    )
 
-    wait_time = initial_wait
-    last_errors = {}
+    if output is not None:
+        return output, model_name
 
-    for round_num in range(max_rounds):
-        # Shuffle models each round for fairness
-        shuffled_models = models.copy()
-        random.shuffle(shuffled_models)
+    # Primary exhausted - try fallback if enabled
+    if use_fallback:
+        fallback_models = get_fallback_models_for_command(command)
+        if fallback_models:
+            _log(f"Primary tier exhausted, trying {len(fallback_models)} fallback models...")
 
-        _log(f"Round {round_num + 1}/{max_rounds}: trying {len(shuffled_models)} models")
+            output, model_name, fallback_errors = _try_models_with_backoff(
+                prompt, fallback_models, "Fallback",
+                working_dir, env_vars, max_rounds, initial_wait, max_wait
+            )
 
-        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:
-                    _log(f"Succeeded on round {round_num + 1} with {model}")
-                else:
-                    _log(f"Success with {model}")
+            if output is not None:
                 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:
-            _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)
+            # Both tiers exhausted
+            all_errors = {**primary_errors, **fallback_errors}
+            error_summary = "; ".join(f"{m}: {e[:50]}" for m, e in list(all_errors.items())[:3])
+            raise AIError(f"All tiers exhausted ({max_rounds} rounds each). Last errors: {error_summary}")
 
-    # All rounds exhausted
-    error_summary = "; ".join(f"{m}: {e[:50]}" for m, e in list(last_errors.items())[:3])
-    raise AIError(f"All {max_rounds} rounds exhausted. Last errors: {error_summary}")
+    # Primary exhausted, no fallback
+    error_summary = "; ".join(f"{m}: {e[:50]}" for m, e in list(primary_errors.items())[:3])
+    raise AIError(f"Primary tier exhausted ({max_rounds} rounds). Last errors: {error_summary}")
 
 
 def call_ai_for_file_edit(

package/lib/config.sh

@@ -57,14 +57,20 @@ DEFAULT_MEMORY_LIMIT_MB=12288
 # Workers will exit after processing this many candidates to pick up library updates
 DEFAULT_WORKER_MAX_CANDIDATES=3
 
-# Default LLM CLI configuration
-# Run: Kimi K2.5 is now the primary model (stronger than GLM-4.7 as of Jan 2025)
-DEFAULT_LLM_RUN="kimi-k2.5 kimi-k2.5 kimi-k2.5 glm-zai glm-zai gemini-3-flash codex-oss-local haiku"
+# Default LLM CLI configuration - tiered fallback system
+# Primary: Strong models used in normal operation
+# Fallback: Cheap/backup models used only when primary tier exhausted
+#
+# Run: GLM-5 is now the primary model (744B MoE, $0.80/M tokens, 77.8% SWE-bench)
+DEFAULT_LLM_RUN="glm-5 glm-5 glm-5 kimi-k2.5 kimi-k2.5"
+DEFAULT_LLM_RUN_FALLBACK="gemini-3-flash codex-oss-local haiku"
+#
 # Ideate: Only agentic models that can edit files reliably
 # AIDEV-NOTE: Ideation REQUIRES file editing - non-agentic models (opencode run, codex) return text
-# but don't actually edit files. Only use claude/gemini CLI with -y flag or cursor-agent.
+# but don't actually edit files. Only use claude/gemini CLI, cursor-agent, or zai-coding-plan models.
 # OpenRouter models (via opencode) are chat-only and CANNOT edit files for ideation.
-DEFAULT_LLM_IDEATE="opus-think sonnet-think gemini-pro kimi-coder"
+DEFAULT_LLM_IDEATE="opus-think sonnet-think glm-5-zai gemini-pro kimi-coder"
+DEFAULT_LLM_IDEATE_FALLBACK="sonnet glm-zai haiku"
 
 # Load configuration from a YAML file and update variables
 _load_yaml_config() {
@@ -141,10 +147,12 @@ _load_yaml_config() {
         lock_timeout) LOCK_TIMEOUT="$value" ;;
       esac
     elif [[ $in_llm_cli_section == true ]]; then
-      if [[ $key == "run" || $key == "ideate" ]]; then
+      if [[ $key == "run" || $key == "ideate" || $key == "run_fallback" || $key == "ideate_fallback" ]]; then
         case $key in
           run) LLM_RUN="$value" ;;
+          run_fallback) LLM_RUN_FALLBACK="$value" ;;
           ideate) LLM_IDEATE="$value" ;;
+          ideate_fallback) LLM_IDEATE_FALLBACK="$value" ;;
         esac
       else
         value=$(echo "$value" | sed "s/^'//;s/'$//")
@@ -215,7 +223,9 @@ load_config() {
   WORKER_MAX_CANDIDATES="$DEFAULT_WORKER_MAX_CANDIDATES"
   
   LLM_RUN="$DEFAULT_LLM_RUN"
+  LLM_RUN_FALLBACK="$DEFAULT_LLM_RUN_FALLBACK"
   LLM_IDEATE="$DEFAULT_LLM_IDEATE"
+  LLM_IDEATE_FALLBACK="$DEFAULT_LLM_IDEATE_FALLBACK"
 
   # Determine local config file path relative to EVOLUTION_DIR
   local local_config_file="$EVOLUTION_DIR/config.yaml"
@@ -319,5 +329,7 @@ show_config() {
     fi
   done
   echo "  LLM for run: $LLM_RUN"
+  echo "  LLM for run (fallback): $LLM_RUN_FALLBACK"
   echo "  LLM for ideate: $LLM_IDEATE"
+  echo "  LLM for ideate (fallback): $LLM_IDEATE_FALLBACK"
 }

package/lib/evolve_ideate.py

@@ -213,13 +213,16 @@ class IdeationStrategy(ABC):
                         return ideas
                     else:
                         # AI returned but didn't edit the file - show what it returned
-                        output_preview = output[:500] if output else "(empty)"
-                        if '\n' in output_preview:
-                            # Show first few lines
-                            lines = output_preview.split('\n')[:5]
-                            output_preview = '\n'.join(lines)
-                            if len(output.split('\n')) > 5:
-                                output_preview += f"\n... ({len(output)} chars total)"
+                        if output:
+                            all_lines = output.split('\n')
+                            if len(all_lines) > 5:
+                                # Show last 5 lines (first lines are usually just the git warning banner)
+                                lines = all_lines[-5:]
+                                output_preview = f"... ({len(output)} chars total)\n" + '\n'.join(lines)
+                            else:
+                                output_preview = output[:500]
+                        else:
+                            output_preview = "(empty)"
 
                         if parse_attempt < max_parse_retries - 1:
                             print(f"[IDEATE] {model} didn't edit file (attempt {parse_attempt + 1}/{max_parse_retries})", file=sys.stderr, flush=True)

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "claude-evolve",
-  "version": "1.11.8",
+  "version": "1.11.11",
   "bin": {
     "claude-evolve": "bin/claude-evolve",
     "claude-evolve-main": "bin/claude-evolve-main",
     "claude-evolve-setup": "bin/claude-evolve-setup",
+    "claude-evolve-check": "bin/claude-evolve-check",
     "claude-evolve-ideate": "bin/claude-evolve-ideate",
     "claude-evolve-run": "bin/claude-evolve-run",
     "claude-evolve-worker": "bin/claude-evolve-worker",