Add model selection, CLI availability checks, and advanced options flipper

Adds per-backend model selection when creating sessions. Each provider
discovers available models from local sources: Claude reads
~/.claude/settings.json, Codex reads ~/.codex/models_cache.json, Copilot
reads ~/.copilot/config.json, and Cursor runs cursor-agent --list-models.
The --model flag is passed to each backend CLI when a non-default model
is selected.

Backend availability is now checked via PATH lookup, with unavailable
backends greyed out in the dropdown. Branch, main branch, and model
fields are grouped under a collapsible "Advanced" section. The session
list shows an abbreviated model name alongside the backend.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mikkeldamsgaard

Cargo.lock

@@ -38,6 +38,10 @@ struct Cli {
     /// AI backend to use
     #[arg(short = 'B', long, default_value = "claude")]
     backend: AiTool,
+
+    /// Model to use (backend-specific, e.g. "sonnet", "opus", "o3")
+    #[arg(short = 'm', long)]
+    model: Option<String>,
 }
 
 #[tokio::main]
@@ -85,6 +89,7 @@ async fn main() {
         preamble: cli.preamble,
         tagging_enabled: !cli.no_tag,
         ai_tool: cli.backend,
+        model: cli.model,
     };
 
     let id = SessionId::new();

crates/ralph-cli/src/main.rs

@@ -11,3 +11,4 @@ uuid = { version = "1", features = ["v4", "serde"] }
 async-trait = "0.1"
 anyhow = "1"
 glob = "0.3"
+dirs = "6"

crates/ralph-core/Cargo.toml

@@ -6,7 +6,14 @@ use tokio::sync::{mpsc, watch};
 
 use tokio::io::AsyncReadExt;
 
-use super::{detect_rate_limit, parse_tool_invocation, AiOutput, AiProvider};
+use super::{detect_rate_limit, parse_tool_invocation, AiOutput, AiProvider, BackendModelConfig, ModelInfo};
+
+fn read_claude_current_model() -> Option<String> {
+    let path = dirs::home_dir()?.join(".claude").join("settings.json");
+    let data = std::fs::read_to_string(path).ok()?;
+    let json: serde_json::Value = serde_json::from_str(&data).ok()?;
+    json.get("model").and_then(|v| v.as_str()).map(|s| s.to_string())
+}
 
 pub struct ClaudeProvider;
 
@@ -16,10 +23,47 @@ impl AiProvider for ClaudeProvider {
         "Claude"
     }
 
+    async fn list_models(&self) -> BackendModelConfig {
+        let current = read_claude_current_model();
+        let mut models = vec![
+            ModelInfo { id: "sonnet".into(), label: "Sonnet".into(), is_default: false },
+            ModelInfo { id: "opus".into(), label: "Opus".into(), is_default: false },
+            ModelInfo { id: "haiku".into(), label: "Haiku".into(), is_default: false },
+        ];
+        // Mark the current model as default
+        let matched = if let Some(cur) = &current {
+            models.iter_mut().any(|m| {
+                if m.id == *cur {
+                    m.is_default = true;
+                    true
+                } else {
+                    false
+                }
+            })
+        } else {
+            false
+        };
+        // If no match (e.g. full model name like "claude-sonnet-4-6"), default to opus
+        if !matched {
+            for m in &mut models {
+                if m.id == "opus" {
+                    m.is_default = true;
+                    break;
+                }
+            }
+        }
+        BackendModelConfig {
+            current_model: current.or_else(|| Some("opus".into())),
+            models,
+            supports_freeform: true,
+        }
+    }
+
     async fn run(
         &self,
         working_dir: &Path,
         prompt: &str,
+        model: Option<&str>,
         resume_session_id: Option<&str>,
         output_tx: mpsc::UnboundedSender<AiOutput>,
         mut abort: watch::Receiver<bool>,
@@ -32,6 +76,10 @@ impl AiProvider for ClaudeProvider {
             .arg("stream-json")
             .arg("--verbose");
 
+        if let Some(m) = model {
+            cmd.arg("--model").arg(m);
+        }
+
         if let Some(id) = resume_session_id {
             cmd.arg("--resume").arg(id);
         }

crates/ralph-core/src/provider/claude.rs

@@ -1,12 +1,56 @@
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use tokio::io::AsyncBufReadExt;
 use tokio::process::Command;
 use tokio::sync::{mpsc, watch};
 
 use crate::events::ToolInvocation;
 
-use super::{AiOutput, AiProvider};
+use super::{AiOutput, AiProvider, BackendModelConfig, ModelInfo};
+
+fn codex_models_cache_path() -> Option<PathBuf> {
+    dirs::home_dir().map(|h| h.join(".codex").join("models_cache.json"))
+}
+
+fn parse_codex_models_cache(path: &Path) -> Option<BackendModelConfig> {
+    let data = std::fs::read_to_string(path).ok()?;
+    let json: serde_json::Value = serde_json::from_str(&data).ok()?;
+    let models_arr = json.get("models")?.as_array()?;
+
+    let mut models = Vec::new();
+    let mut first_id = None;
+    for m in models_arr {
+        let visibility = m.get("visibility").and_then(|v| v.as_str()).unwrap_or("");
+        if visibility != "list" {
+            continue;
+        }
+        let slug = m.get("slug").and_then(|v| v.as_str()).unwrap_or("").to_string();
+        let display_name = m
+            .get("display_name")
+            .and_then(|v| v.as_str())
+            .unwrap_or(&slug)
+            .to_string();
+        if first_id.is_none() {
+            first_id = Some(slug.clone());
+        }
+        models.push(ModelInfo {
+            id: slug,
+            label: display_name,
+            is_default: false,
+        });
+    }
+
+    // Mark the first model as default (highest priority in the cache)
+    if let Some(first) = models.first_mut() {
+        first.is_default = true;
+    }
+
+    Some(BackendModelConfig {
+        current_model: first_id,
+        models,
+        supports_freeform: true,
+    })
+}
 
 pub struct CodexProvider;
 
@@ -16,18 +60,38 @@ impl AiProvider for CodexProvider {
         "Codex"
     }
 
+    async fn list_models(&self) -> BackendModelConfig {
+        // Try reading from ~/.codex/models_cache.json (populated by the codex CLI)
+        if let Some(path) = codex_models_cache_path() {
+            if let Some(config) = parse_codex_models_cache(&path) {
+                if !config.models.is_empty() {
+                    return config;
+                }
+            }
+        }
+        // Fallback
+        BackendModelConfig {
+            models: vec![
+                ModelInfo { id: "o3".into(), label: "o3".into(), is_default: true },
+                ModelInfo { id: "o4-mini".into(), label: "o4-mini".into(), is_default: false },
+            ],
+            supports_freeform: true,
+            current_model: Some("o3".into()),
+        }
+    }
+
     async fn run(
         &self,
         working_dir: &Path,
         prompt: &str,
+        model: Option<&str>,
         resume_session_id: Option<&str>,
         output_tx: mpsc::UnboundedSender<AiOutput>,
         mut abort: watch::Receiver<bool>,
     ) -> anyhow::Result<()> {
         let mut cmd = Command::new("codex");
 
         if let Some(id) = resume_session_id {
-            // codex exec resume <thread-id> <prompt> --json ...
             cmd.args(["exec", "resume"])
                 .arg(id)
                 .arg(prompt)
@@ -39,6 +103,10 @@ impl AiProvider for CodexProvider {
                 .arg("--json");
         }
 
+        if let Some(m) = model {
+            cmd.arg("--model").arg(m);
+        }
+
         let mut child = cmd
             .current_dir(working_dir)
             .stdout(std::process::Stdio::piped())

crates/ralph-core/src/provider/codex.rs

@@ -1,11 +1,32 @@
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::time::Instant;
 
 use tokio::io::{AsyncBufReadExt, AsyncReadExt};
 use tokio::process::Command;
 use tokio::sync::{mpsc, watch};
 
-use super::{detect_rate_limit, parse_tool_invocation, AiOutput, AiProvider};
+use super::{detect_rate_limit, parse_tool_invocation, AiOutput, AiProvider, BackendModelConfig, ModelInfo};
+
+fn copilot_config_path() -> Option<PathBuf> {
+    dirs::home_dir().map(|h| h.join(".copilot").join("config.json"))
+}
+
+fn read_copilot_current_model() -> Option<String> {
+    let path = copilot_config_path()?;
+    let data = std::fs::read_to_string(path).ok()?;
+    let json: serde_json::Value = serde_json::from_str(&data).ok()?;
+    json.get("model").and_then(|v| v.as_str()).map(|s| s.to_string())
+}
+
+fn copilot_known_models() -> Vec<ModelInfo> {
+    vec![
+        ModelInfo { id: "claude-sonnet-4.6".into(), label: "Claude Sonnet 4.6".into(), is_default: false },
+        ModelInfo { id: "claude-opus-4.6".into(), label: "Claude Opus 4.6".into(), is_default: false },
+        ModelInfo { id: "gpt-5.2".into(), label: "GPT-5.2".into(), is_default: false },
+        ModelInfo { id: "gpt-5-mini".into(), label: "GPT-5 mini".into(), is_default: false },
+        ModelInfo { id: "gpt-4.1".into(), label: "GPT-4.1".into(), is_default: false },
+    ]
+}
 
 pub struct CopilotProvider;
 
@@ -15,10 +36,41 @@ impl AiProvider for CopilotProvider {
         "Copilot"
     }
 
+    async fn list_models(&self) -> BackendModelConfig {
+        let current = read_copilot_current_model();
+        let mut models = copilot_known_models();
+
+        // Mark the current model as default if found in the list
+        let matched = if let Some(cur) = &current {
+            models.iter_mut().any(|m| {
+                if m.id == *cur {
+                    m.is_default = true;
+                    true
+                } else {
+                    false
+                }
+            })
+        } else {
+            false
+        };
+        if !matched {
+            if let Some(m) = models.first_mut() {
+                m.is_default = true;
+            }
+        }
+
+        BackendModelConfig {
+            current_model: current,
+            models,
+            supports_freeform: true,
+        }
+    }
+
     async fn run(
         &self,
         working_dir: &Path,
         prompt: &str,
+        model: Option<&str>,
         resume_session_id: Option<&str>,
         output_tx: mpsc::UnboundedSender<AiOutput>,
         mut abort: watch::Receiver<bool>,
@@ -32,6 +84,10 @@ impl AiProvider for CopilotProvider {
             .arg("--output-format")
             .arg("json");
 
+        if let Some(m) = model {
+            cmd.arg("--model").arg(m);
+        }
+
         if let Some(id) = resume_session_id {
             cmd.arg(format!("--resume={}", id));
         }