claude-evolve 1.5.1 → 1.5.2

package/bin/claude-evolve-run

@@ -518,10 +518,22 @@ while true; do
       
       # Generate new ideas using the multi-strategy approach
       echo "[DISPATCHER] Calling claude-evolve-ideate to generate new candidates..."
+      # Export config path for ideate script
+      if [[ -n $WORKER_CONFIG_PATH ]]; then
+        export CLAUDE_EVOLVE_CONFIG="$WORKER_CONFIG_PATH"
+      fi
       if ! "$ideate_script"; then
-        echo "[ERROR] Failed to generate new ideas" >&2
-        echo "[DISPATCHER] Evolution complete - ideation failed."
-        break
+        echo "[WARN] Ideation failed to generate new ideas" >&2
+        if [[ "${CONTINUE_ON_IDEATION_FAILURE:-false}" == "true" ]]; then
+          echo "[DISPATCHER] Continuing despite ideation failure (CONTINUE_ON_IDEATION_FAILURE=true)" >&2
+          echo "[DISPATCHER] Waiting 60 seconds before retry..." >&2
+          sleep 60
+          continue
+        else
+          echo "[DISPATCHER] Evolution complete - ideation failed."
+          echo "[DISPATCHER] Set CONTINUE_ON_IDEATION_FAILURE=true to continue despite failures"
+          break
+        fi
       fi
       
       echo "[DISPATCHER] New ideas generated successfully. Continuing evolution..."

package/bin/claude-evolve-worker

@@ -5,6 +5,7 @@ set -e
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &> /dev/null && pwd)"
 source "$SCRIPT_DIR/../lib/config.sh"
 source "$SCRIPT_DIR/../lib/csv-lock.sh"
+source "$SCRIPT_DIR/../lib/ai-cli.sh"
 
 # Track current candidate for cleanup
 CURRENT_CANDIDATE_ID=""
@@ -79,148 +80,6 @@ else
   load_config
 fi
 
-# Call an AI model with a prompt - handles model-specific invocation
-call_ai_model() {
-  local model="$1"
-  local prompt="$2"
-  local ai_output
-  local ai_exit_code
-  
-  case "$model" in
-    "claude")
-      # Pass prompt as argument, not via stdin
-      ai_output=$(timeout 300 claude --dangerously-skip-permissions -p "$prompt" 2>&1)
-      ai_exit_code=$?
-      ;;
-      
-    "gemini")
-      # Pass prompt as argument, not via stdin
-      ai_output=$(timeout 300 gemini -y -p "$prompt" 2>&1)
-      ai_exit_code=$?
-      ;;
-      
-    "codex")
-      # Pass prompt as argument, not via stdin
-      ai_output=$(timeout 300 codex exec --dangerously-bypass-approvals-and-sandbox "$prompt" 2>&1)
-      ai_exit_code=$?
-      ;;
-      
-    *)
-      echo "[WORKER-$$] ERROR: Unknown AI model: $model" >&2
-      return 1
-      ;;
-  esac
-  
-  # Return output via stdout
-  echo "$ai_output"
-  return $ai_exit_code
-}
-
-# Check if AI output indicates a usage limit was hit
-is_usage_limit_error() {
-  local output="$1"
-  local model="$2"
-  
-  case "$model" in
-    "claude")
-      echo "$output" | grep -q "Claude AI usage limit reached"
-      ;;
-    "gemini")
-      echo "$output" | grep -q "Quota exceeded.*Gemini"
-      ;;
-    "codex")
-      # Add codex-specific limit patterns if they exist
-      false
-      ;;
-    *)
-      false
-      ;;
-  esac
-}
-
-# Validate if AI output is successful
-is_valid_ai_output() {
-  local output="$1"
-  local model="$2"
-  local exit_code="$3"
-  
-  # First check exit code
-  [[ $exit_code -ne 0 ]] && return 1
-  
-  # Model-specific validation
-  case "$model" in
-    "claude")
-      # Claude is straightforward - exit code 0 means success
-      return 0
-      ;;
-      
-    "gemini")
-      # Gemini needs extra validation for auth messages
-      if echo "$output" | grep -q "Attempting to authenticate\|Authenticating\|Loading\|Initializing"; then
-        return 1
-      fi
-      # Also check for minimal output
-      if [[ -z "$output" ]] || [[ $(echo "$output" | wc -l) -lt 2 ]]; then
-        return 1
-      fi
-      return 0
-      ;;
-      
-    "codex")
-      # Codex might return JSON that needs extraction
-      if echo "$output" | grep -q '"content"'; then
-        # Will be cleaned later, just check it's not an error
-        if echo "$output" | grep -q "error\|failed\|exception"; then
-          return 1
-        fi
-      fi
-      [[ -n "$output" ]]
-      ;;
-      
-    *)
-      return 1
-      ;;
-  esac
-}
-
-# Clean AI output if needed (e.g., extract from JSON)
-clean_ai_output() {
-  local output="$1"
-  local model="$2"
-  
-  case "$model" in
-    "codex")
-      # Clean codex output - extract content between "codex" marker and "tokens used"
-      if echo "$output" | grep -q "^\[.*\] codex$"; then
-        # Extract content between "codex" line and "tokens used" line
-        output=$(echo "$output" | awk '/\] codex$/{flag=1;next}/\] tokens used/{flag=0}flag')
-      elif echo "$output" | grep -q '"content"'; then
-        # Old JSON format
-        output=$(echo "$output" | python3 -c "
-import sys
-import json
-try:
-    data = json.load(sys.stdin)
-    if 'content' in data:
-        print(data['content'])
-    elif 'response' in data:
-        print(data['response'])
-    elif 'text' in data:
-        print(data['text'])
-    else:
-        print(json.dumps(data))
-except:
-    print(sys.stdin.read())
-" 2>/dev/null || echo "$output")
-      fi
-      # Trim whitespace
-      output=$(echo "$output" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')
-      ;;
-  esac
-  
-  echo "$output"
-}
-
 # AI round-robin with fallback function for code evolution
 call_ai_for_evolution() {
   local prompt="$1"
@@ -237,83 +96,26 @@ call_ai_for_evolution() {
   # Calculate hash for round-robin (combine generation and ID)
   local hash_value=$((gen_num * 1000 + id_num))
   
-  # Check which AI tools are available
-  local available_models=()
-  if command -v claude >/dev/null 2>&1; then
-    available_models+=("claude")
-  fi
-  if command -v gemini >/dev/null 2>&1; then
-    available_models+=("gemini")
-  fi
-  if command -v codex >/dev/null 2>&1; then
-    available_models+=("codex")
-  fi
-  
-  if [[ ${#available_models[@]} -eq 0 ]]; then
-    echo "[WORKER-$$] ERROR: No AI models available!" >&2
-    return 1
-  fi
-  
-  # Create ordered list based on round-robin for this candidate
-  local num_models=${#available_models[@]}
-  local start_index=$((hash_value % num_models))
-  local models=()
-  
-  # Add models in round-robin order starting from the calculated index
-  for ((i=0; i<num_models; i++)); do
-    local idx=$(((start_index + i) % num_models))
-    models+=("${available_models[$idx]}")
-  done
-  
-  echo "[WORKER-$$] Model order for $candidate_id (round-robin): ${models[*]}" >&2
-  
-  # Track if any model hit usage limits
-  local hit_usage_limit=false
-  local limited_models=()
-  
-  # Try each model in the ordered sequence
-  for model in "${models[@]}"; do
-    echo "[WORKER-$$] Attempting code evolution with $model" >&2
-    
-    # Call the AI model
-    local ai_output
-    ai_output=$(call_ai_model "$model" "$prompt")
-    local ai_exit_code=$?
-    
-    # Check for usage limits
-    if is_usage_limit_error "$ai_output" "$model"; then
-      echo "[WORKER-$$] $model hit usage limit - trying next model" >&2
-      hit_usage_limit=true
-      limited_models+=("$model")
-      continue
-    fi
-    
-    # Validate output
-    if is_valid_ai_output "$ai_output" "$model" "$ai_exit_code"; then
-      # Clean output if needed
-      ai_output=$(clean_ai_output "$ai_output" "$model")
-      echo "[WORKER-$$] $model succeeded" >&2
-      # Output the cleaned result for the worker to use
-      echo "$ai_output"
-      return 0
-    fi
-    
-    echo "[WORKER-$$] $model failed (exit code $ai_exit_code), trying next model..." >&2
-    if [[ -n "$ai_output" ]]; then
-      echo "[WORKER-$$] $model error: $(echo "$ai_output" | head -5)" >&2
-    fi
-  done
-  
-  # All models have been tried
-  echo "[WORKER-$$] All AI models failed for code evolution" >&2
+  # Use the centralized AI library for evolution (run command)
+  local ai_output
+  ai_output=$(call_ai_with_round_robin "$prompt" "run" "$hash_value")
+  local ai_exit_code=$?
   
-  # If any model hit usage limits and we couldn't complete the task
-  if [[ "$hit_usage_limit" == "true" ]]; then
-    echo "[WORKER-$$] Models hit usage limits: ${limited_models[*]}" >&2
+  # Handle special exit codes
+  if [[ $ai_exit_code -eq 3 ]]; then
+    echo "[WORKER-$$] All models hit usage limits" >&2
     echo "[WORKER-$$] Unable to complete evolution due to API limits" >&2
     exit 3
   fi
   
+  if [[ $ai_exit_code -eq 0 ]]; then
+    echo "[WORKER-$$] AI succeeded" >&2
+    # Output the result for the worker to use
+    echo "$ai_output"
+    return 0
+  fi
+  
+  echo "[WORKER-$$] All AI models failed" >&2
   return 1
 }
 
@@ -400,7 +202,9 @@ with EvolutionCSV('$FULL_CSV_PATH') as csv:
     
 The modification should be substantial and follow the description exactly. Make sure the algorithm still follows all interface requirements and can run properly.
 
-Important: Make meaningful changes that match the description. Don't just add comments or make trivial adjustments."
+Important: Make meaningful changes that match the description. Don't just add comments or make trivial adjustments.
+
+CRITICAL: Do NOT use any git commands (git add, git commit, git reset, etc.). Only modify the file directly."
     
     if [[ "$is_baseline" != "true" ]]; then
       # Change to evolution directory so AI can access files

package/lib/ai-cli.sh

@@ -0,0 +1,221 @@
+#!/bin/bash
+# Centralized AI CLI invocation library for claude-evolve
+
+# Source config to get LLM_CLI array and model lists
+# This will be sourced after config.sh in the main scripts
+
+# Call an AI model using the configured command template
+# Usage: call_ai_model_configured <model_name> <prompt>
+# Returns: 0 on success, non-zero on failure
+# Output: AI response on stdout
+call_ai_model_configured() {
+  local model_name="$1"
+  local prompt="$2"
+  
+  # Build command directly based on model
+  case "$model_name" in
+    opus|sonnet)
+      local ai_output
+      ai_output=$(timeout 300 claude --dangerously-skip-permissions --model "$model_name" -p "$prompt" 2>&1)
+      local ai_exit_code=$?
+      ;;
+    o3)
+      local ai_output
+      ai_output=$(timeout 300 codex exec -m o3 --dangerously-bypass-approvals-and-sandbox "$prompt" 2>&1)
+      local ai_exit_code=$?
+      ;;
+    codex)
+      local ai_output
+      ai_output=$(timeout 300 codex exec --dangerously-bypass-approvals-and-sandbox "$prompt" 2>&1)
+      local ai_exit_code=$?
+      ;;
+    gemini)
+      # Debug: Show exact command
+      echo "[DEBUG] Running: timeout 300 gemini -y -p <prompt>" >&2
+      echo "[DEBUG] Working directory: $(pwd)" >&2
+      echo "[DEBUG] Files in current dir:" >&2
+      ls -la temp-csv-*.csv 2>&1 | head -5 >&2
+      local ai_output
+      ai_output=$(timeout 300 gemini -y -p "$prompt" 2>&1)
+      local ai_exit_code=$?
+      ;;
+    *)
+      echo "[ERROR] Unknown model: $model_name" >&2
+      return 1
+      ;;
+  esac
+  
+  # Debug: log model and prompt size
+  echo "[DEBUG] Calling $model_name with prompt of ${#prompt} characters" >&2
+  
+  # Always log basic info
+  echo "[AI] $model_name exit code: $ai_exit_code, output length: ${#ai_output} chars" >&2
+  
+  # Show detailed output if verbose or if there was an error
+  if [[ "${VERBOSE_AI_OUTPUT:-false}" == "true" ]] || [[ $ai_exit_code -ne 0 ]]; then
+    echo "[AI] Raw output from $model_name:" >&2
+    echo "----------------------------------------" >&2
+    if [[ ${#ai_output} -gt 2000 ]]; then
+      echo "$ai_output" | head -50 >&2
+      echo "... (truncated from ${#ai_output} characters to first 50 lines) ..." >&2
+    else
+      echo "$ai_output" >&2
+    fi
+    echo "----------------------------------------" >&2
+  fi
+  
+  # Debug: save full output if debugging is enabled
+  if [[ "${DEBUG_AI_CALLS:-}" == "true" ]]; then
+    local debug_file="/tmp/claude-evolve-ai-${model_name}-$$.log"
+    echo "Model: $model_name" > "$debug_file"
+    echo "Exit code: $ai_exit_code" >> "$debug_file"
+    echo "Prompt length: ${#prompt}" >> "$debug_file"
+    echo "Output:" >> "$debug_file"
+    echo "$ai_output" >> "$debug_file"
+    echo "[DEBUG] Full output saved to: $debug_file" >&2
+  fi
+  
+  # Output the result
+  echo "$ai_output"
+  return $ai_exit_code
+}
+
+# DEPRECATED - Keep for compatibility but always return false
+is_usage_limit_error() {
+  return 1
+}
+
+# DEPRECATED - Just check exit code now
+is_valid_ai_output() {
+  local output="$1"
+  local exit_code="$2"
+  
+  # Only check exit code - let the caller verify file changes
+  return $exit_code
+}
+
+# Clean AI output if needed (e.g., extract from JSON)
+clean_ai_output() {
+  local output="$1"
+  local model_name="$2"
+  
+  # Handle codex-specific output format
+  if [[ "$model_name" == "codex" || "$model_name" == "o3" ]]; then
+    # Clean codex output - extract content between "codex" marker and "tokens used"
+    if echo "$output" | grep -q "^\[.*\] codex$"; then
+      # Extract content between "codex" line and "tokens used" line
+      output=$(echo "$output" | awk '/\] codex$/{flag=1;next}/\] tokens used/{flag=0}flag')
+    fi
+  fi
+  
+  # Trim whitespace
+  output=$(echo "$output" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')
+  
+  echo "$output"
+}
+
+# Get models for a specific command (run or ideate)
+# Usage: get_models_for_command <command>
+# Returns: Array of model names
+get_models_for_command() {
+  local command="$1"
+  local model_list=""
+  
+  case "$command" in
+    run)
+      model_list="$LLM_RUN"
+      ;;
+    ideate)
+      model_list="$LLM_IDEATE"
+      ;;
+    *)
+      echo "[ERROR] Unknown command: $command" >&2
+      return 1
+      ;;
+  esac
+  
+  # Convert space-separated list to array
+  echo "$model_list"
+}
+
+# Call AI with round-robin and fallback support
+# Usage: call_ai_with_round_robin <prompt> <command> <hash_value>
+# command: "run" or "ideate"
+# hash_value: numeric value for round-robin selection (e.g., candidate ID hash)
+call_ai_with_round_robin() {
+  local prompt="$1"
+  local command="$2"
+  local hash_value="${3:-0}"
+  
+  # Get model list for this command
+  local model_list
+  model_list=$(get_models_for_command "$command")
+  if [[ -z "$model_list" ]]; then
+    echo "[ERROR] No models configured for command: $command" >&2
+    return 1
+  fi
+  
+  # Convert to array
+  local models=()
+  read -ra models <<< "$model_list"
+  
+  if [[ ${#models[@]} -eq 0 ]]; then
+    echo "[ERROR] No models available for $command" >&2
+    return 1
+  fi
+  
+  # Calculate starting index for round-robin
+  local num_models=${#models[@]}
+  local start_index=$((hash_value % num_models))
+  
+  # Create ordered list based on round-robin
+  local ordered_models=()
+  for ((i=0; i<num_models; i++)); do
+    local idx=$(((start_index + i) % num_models))
+    ordered_models+=("${models[$idx]}")
+  done
+  
+  echo "[AI] Model order for $command (round-robin): ${ordered_models[*]}" >&2
+  
+  # Track models that hit usage limits
+  local limited_models=()
+  local tried_models=()
+  
+  # Try each model in order
+  for model in "${ordered_models[@]}"; do
+    echo "[AI] Attempting $command with $model" >&2
+    tried_models+=("$model")
+    
+    # Call the AI model
+    local ai_output
+    ai_output=$(call_ai_model_configured "$model" "$prompt")
+    local ai_exit_code=$?
+    
+    # Just check exit code - no interpretation
+    if [[ $ai_exit_code -eq 0 ]]; then
+      # Clean output if needed
+      ai_output=$(clean_ai_output "$ai_output" "$model")
+      echo "[AI] $model returned exit code 0" >&2
+      # Debug: log what AI returned on success
+      if [[ "${DEBUG_AI_SUCCESS:-}" == "true" ]]; then
+        echo "[AI] $model success output preview:" >&2
+        echo "$ai_output" | head -10 >&2
+        echo "[AI] (truncated to first 10 lines)" >&2
+      fi
+      # Output the cleaned result
+      echo "$ai_output"
+      return 0
+    fi
+    
+    echo "[AI] $model returned exit code $ai_exit_code, trying next model..." >&2
+  done
+  
+  # All models have been tried
+  echo "[AI] All models have been tried without success" >&2
+  return 1
+}
+
+# Legacy function name for compatibility
+call_ai_with_fallbacks() {
+  call_ai_with_round_robin "$@"
+}

package/lib/config.sh

@@ -49,6 +49,18 @@ DEFAULT_AUTO_IDEATE=true
 # Default retry value
 DEFAULT_MAX_RETRIES=3
 
+# Default LLM CLI configuration (using eval for compatibility)
+declare -a DEFAULT_LLM_CLI_KEYS
+declare -a DEFAULT_LLM_CLI_VALUES
+DEFAULT_LLM_CLI_KEYS=(o3 codex gemini opus sonnet)
+DEFAULT_LLM_CLI_VALUES[0]='codex exec -m o3 --dangerously-bypass-approvals-and-sandbox "{{PROMPT}}"'
+DEFAULT_LLM_CLI_VALUES[1]='codex exec --dangerously-bypass-approvals-and-sandbox "{{PROMPT}}"'
+DEFAULT_LLM_CLI_VALUES[2]='gemini -y -p "{{PROMPT}}"'
+DEFAULT_LLM_CLI_VALUES[3]='claude --dangerously-skip-permissions --model opus -p "{{PROMPT}}"'
+DEFAULT_LLM_CLI_VALUES[4]='claude --dangerously-skip-permissions --model sonnet -p "{{PROMPT}}"'
+DEFAULT_LLM_RUN="sonnet gemini"
+DEFAULT_LLM_IDEATE="opus o3"
+
 # Load configuration from config file
 load_config() {
   # Accept config file path as parameter
@@ -84,12 +96,25 @@ load_config() {
   # Set retry default
   MAX_RETRIES="$DEFAULT_MAX_RETRIES"
   
+  # Set LLM CLI defaults (compatibility for older bash)
+  # Initialize associative array for LLM commands
+  # Use simpler approach for compatibility
+  LLM_CLI_o3='codex exec -m o3 --dangerously-bypass-approvals-and-sandbox "{{PROMPT}}"'
+  LLM_CLI_codex='codex exec --dangerously-bypass-approvals-and-sandbox "{{PROMPT}}"'
+  LLM_CLI_gemini='gemini -y -p "{{PROMPT}}"'
+  LLM_CLI_opus='claude --dangerously-skip-permissions --model opus -p "{{PROMPT}}"'
+  LLM_CLI_sonnet='claude --dangerously-skip-permissions --model sonnet -p "{{PROMPT}}"'
+  LLM_RUN="$DEFAULT_LLM_RUN"
+  LLM_IDEATE="$DEFAULT_LLM_IDEATE"
+  
   # Load config if found
   if [[ -f "$config_file" ]]; then
     echo "[DEBUG] Loading configuration from: $config_file" >&2
     # Simple YAML parsing for key: value pairs and nested structures
     local in_ideation_section=false
     local in_parallel_section=false
+    local in_llm_cli_section=false
+    local llm_cli_subsection=""
     while IFS='' read -r line; do
       # Skip comments and empty lines
       [[ $line =~ ^[[:space:]]*# ]] || [[ -z $line ]] && continue
@@ -110,6 +135,11 @@ load_config() {
       key=$(echo "$key" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
       value=$(echo "$value" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
       
+      # Debug before comment removal
+      if [[ "${DEBUG_CONFIG:-}" == "true" ]]; then
+        echo "[CONFIG DEBUG] Before comment removal: key='$key' value='$value'" >&2
+      fi
+      
       # Remove inline comments from value
       value=$(echo "$value" | sed 's/[[:space:]]*#.*$//')
       
@@ -120,15 +150,25 @@ load_config() {
       if [[ $key == "ideation_strategies" ]]; then
         in_ideation_section=true
         in_parallel_section=false
+        in_llm_cli_section=false
         continue
       elif [[ $key == "parallel" ]]; then
         in_parallel_section=true
         in_ideation_section=false
+        in_llm_cli_section=false
         continue
-      elif [[ $is_indented == false ]] && [[ $in_ideation_section == true || $in_parallel_section == true ]]; then
+      elif [[ $key == "llm_cli" ]]; then
+        in_llm_cli_section=true
+        in_ideation_section=false
+        in_parallel_section=false
+        llm_cli_subsection=""
+        continue
+      elif [[ $is_indented == false ]] && [[ $in_ideation_section == true || $in_parallel_section == true || $in_llm_cli_section == true ]]; then
         # Non-indented key found while in a section, exit nested sections
         in_ideation_section=false
         in_parallel_section=false
+        in_llm_cli_section=false
+        llm_cli_subsection=""
       fi
       
       if [[ $in_ideation_section == true ]]; then
@@ -149,6 +189,26 @@ load_config() {
           max_workers) MAX_WORKERS="$value" ;;
           lock_timeout) LOCK_TIMEOUT="$value" ;;
         esac
+      elif [[ $in_llm_cli_section == true ]]; then
+        # Handle indented keys in llm_cli section
+        # Check if this is a model definition (o3, codex, gemini, etc.) or a command list (run, ideate)
+        if [[ $key == "run" || $key == "ideate" ]]; then
+          # Command list - value is a space-separated list of models
+          case $key in
+            run) LLM_RUN="$value" ;;
+            ideate) LLM_IDEATE="$value" ;;
+          esac
+        else
+          # Model definition - key is model name, value is command template
+          # Remove single quotes from value if present
+          value=$(echo "$value" | sed "s/^'//;s/'$//")
+          # Debug config loading
+          if [[ "${DEBUG_CONFIG:-}" == "true" ]]; then
+            echo "[CONFIG DEBUG] Setting LLM_CLI_${key} = '$value'" >&2
+          fi
+          # Use dynamic variable name for compatibility
+          eval "LLM_CLI_${key}=\"$value\""
+        fi
       else
         # Handle top-level keys
         case $key in
@@ -256,4 +316,14 @@ show_config() {
   echo "  Lock timeout: $LOCK_TIMEOUT"
   echo "  Auto ideate: $AUTO_IDEATE"
   echo "  Max retries: $MAX_RETRIES"
+  echo "  LLM configuration:"
+  # Show LLM configurations using dynamic variable names
+  for model in o3 codex gemini opus sonnet; do
+    var_name="LLM_CLI_${model}"
+    if [[ -n "${!var_name}" ]]; then
+      echo "    $model: ${!var_name}"
+    fi
+  done
+  echo "  LLM for run: $LLM_RUN"
+  echo "  LLM for ideate: $LLM_IDEATE"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-evolve",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "bin": {
     "claude-evolve": "./bin/claude-evolve",
     "claude-evolve-main": "./bin/claude-evolve-main",

package/templates/config.yaml

@@ -55,4 +55,20 @@ parallel:
   max_workers: 4
   
   # Timeout in seconds when waiting for CSV locks
-  lock_timeout: 30
+  lock_timeout: 30
+
+# LLM/AI CLI configuration
+llm_cli:
+  # How to run each CLI for each LLM option
+  # {{PROMPT}} will be replaced with the actual prompt text
+  o3: 'codex exec -m o3 --dangerously-bypass-approvals-and-sandbox "{{PROMPT}}"'
+  codex: 'codex exec --dangerously-bypass-approvals-and-sandbox "{{PROMPT}}"'
+  gemini: 'gemini -y -p "{{PROMPT}}"'
+  opus: 'claude --dangerously-skip-permissions --model opus -p "{{PROMPT}}"'
+  sonnet: 'claude --dangerously-skip-permissions --model sonnet -p "{{PROMPT}}"'
+
+  # What to run for each sub-command
+  # Models are tried in order, with round-robin distribution across candidates
+  # You can repeat models for weighted selection (e.g., "sonnet sonnet gemini" for 2:1 ratio)
+  run: sonnet gemini
+  ideate: opus o3