refactor: replace panics with proper error handling

- Replace expect() with ok_or_else() and descriptive errors
- Replace panic!() with anyhow::bail()
- Use per-mode LLM config (planning_llm, ralph_llm)
- Provide helpful error messages for missing configs
- More robust error handling for unsupported providers
- Update new() methods to return Result
- Replace expect("Task should exist") with context()

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-Authored-By: Claude <[e-mail]>
Co-Authored-By: Happy <[e-mail]>

src/main.rs

···
                 .unwrap_or_else(|| config.rustagent.spec_dir.clone());
 
             // Create and run planning agent
-            let mut agent = planning::PlanningAgent::new(config, dir);
+            let mut agent = planning::PlanningAgent::new(config, dir)?;
             agent.run().await?;
         }
         Commands::Run { spec_file, max_iterations } => {
···
             let config = config::Config::load(&config_path)?;
 
             // Create and run Ralph loop
-            let ralph = ralph::RalphLoop::new(config, spec_file.clone(), *max_iterations);
+            let ralph = ralph::RalphLoop::new(config, spec_file.clone(), *max_iterations)?;
             ralph.run().await?;
         }
     }

src/planning/mod.rs

···
 
 impl PlanningAgent {
     /// Create a new planning agent with the given config
-    pub fn new(config: Config, spec_dir: String) -> Self {
+    pub fn new(config: Config, spec_dir: String) -> anyhow::Result<Self> {
         // Get planning-specific LLM config
         let llm_config = config.planning_llm().clone();
 
         // Create LLM client based on provider
         let client: Box<dyn LlmClient> = match llm_config.provider {
             LlmProvider::Anthropic => {
-                let api_key = config
-                    .anthropic
-                    .expect("Anthropic config required for Anthropic provider")
-                    .api_key;
+                let anthropic_config = config.anthropic
+                    .as_ref()
+                    .ok_or_else(|| anyhow::anyhow!(
+                        "Anthropic provider selected but [anthropic] config missing"
+                    ))?;
+
                 Box::new(AnthropicClient::new(
-                    api_key,
-                    llm_config.model,
+                    anthropic_config.api_key.clone(),
+                    llm_config.model.clone(),
                     llm_config.max_tokens,
                 ))
             }
-            _ => panic!("Unsupported LLM provider"),
+            LlmProvider::OpenAi => {
+                anyhow::bail!("OpenAI provider not yet implemented")
+            }
+            LlmProvider::Ollama => {
+                anyhow::bail!("Ollama provider not yet implemented")
+            }
         };
 
         // Create security validator and permission handler
-        let validator = Arc::new(SecurityValidator::new(config.security.clone()).expect("Failed to create security validator"));
+        let validator = Arc::new(SecurityValidator::new(config.security.clone())?);
         let permission_handler = Arc::new(CliPermissionHandler);
 
         // Create and populate tool registry
···
             content: PLANNING_SYSTEM_PROMPT.to_string(),
         };
 
-        Self {
+        Ok(Self {
             client,
             registry,
             spec_dir,
             conversation: vec![system_message],
-        }
+        })
     }
 
     /// Run the interactive planning loop

src/ralph/mod.rs

···
 }
 
 impl RalphLoop {
-    pub fn new(config: Config, spec_path: String, max_iterations: Option<usize>) -> Self {
+    pub fn new(config: Config, spec_path: String, max_iterations: Option<usize>) -> Result<Self> {
         // Get ralph-specific LLM config
         let llm_config = config.ralph_llm().clone();
 
         // Create LLM client based on provider
         let client: Arc<dyn LlmClient> = match llm_config.provider {
             LlmProvider::Anthropic => {
-                let api_key = config
-                    .anthropic
-                    .expect("Anthropic config required")
-                    .api_key;
+                let anthropic_config = config.anthropic
+                    .as_ref()
+                    .ok_or_else(|| anyhow::anyhow!(
+                        "Anthropic provider selected but [anthropic] config missing"
+                    ))?;
+
                 Arc::new(AnthropicClient::new(
-                    api_key,
-                    llm_config.model,
+                    anthropic_config.api_key.clone(),
+                    llm_config.model.clone(),
                     llm_config.max_tokens,
                 ))
             }
-            _ => panic!("Only Anthropic provider is currently supported"),
+            LlmProvider::OpenAi => {
+                anyhow::bail!("OpenAI provider not yet implemented")
+            }
+            LlmProvider::Ollama => {
+                anyhow::bail!("Ollama provider not yet implemented")
+            }
         };
 
         // Create security validator and permission handler
-        let validator = Arc::new(SecurityValidator::new(config.security.clone()).expect("Failed to create security validator"));
+        let validator = Arc::new(SecurityValidator::new(config.security.clone())?);
         let permission_handler = Arc::new(CliPermissionHandler);
 
         // Register tools
···
             .or(config.rustagent.max_iterations)
             .unwrap_or(DEFAULT_MAX_ITERATIONS);
 
-        Self {
+        Ok(Self {
             client,
             tools,
             spec_path,
             max_iterations,
-        }
+        })
     }
 
     pub async fn run(&self) -> Result<()> {
···
             {
                 let task_mut = spec
                     .find_task_mut(&task.id)
-                    .expect("Task should exist");
+                    .context("Task not found in spec")?;
                 task_mut.status = TaskStatus::InProgress;
             }
             spec.save(&self.spec_path)
···
                             println!("Task completed successfully");
                             let task_mut = spec
                                 .find_task_mut(&task.id)
-                                .expect("Task should exist");
+                                .context("Task not found in spec")?;
                             task_mut.status = TaskStatus::Complete;
                             task_mut.completed_at = Some(Utc::now());
                             spec.save(&self.spec_path)?;
···
                             println!("Task is blocked");
                             let task_mut = spec
                                 .find_task_mut(&task.id)
-                                .expect("Task should exist");
+                                .context("Task not found in spec")?;
                             task_mut.status = TaskStatus::Blocked;
                             spec.save(&self.spec_path)?;
                         }
···
                             // Reset to pending to retry
                             let task_mut = spec
                                 .find_task_mut(&task.id)
-                                .expect("Task should exist");
+                                .context("Task not found in spec")?;
                             task_mut.status = TaskStatus::Pending;
                             spec.save(&self.spec_path)?;
                         }
···
                     let mut spec = Spec::load(&self.spec_path)?;
                     let task_mut = spec
                         .find_task_mut(&task.id)
-                        .expect("Task should exist");
+                        .context("Task not found in spec")?;
                     task_mut.status = TaskStatus::Pending;
                     spec.save(&self.spec_path)?;
                     break;

tests/planning_test.rs

···
 "#).unwrap();
 
     let config = Config::load(&config_path).unwrap();
-    let agent = PlanningAgent::new(config, temp.path().to_str().unwrap().to_string());
+    let agent = PlanningAgent::new(config, temp.path().to_str().unwrap().to_string()).unwrap();
 
     assert!(agent.spec_dir.ends_with(temp.path().to_str().unwrap()));
 }

tests/ralph_test.rs

···
     spec.save(&spec_path).unwrap();
 
     let config = Config::load(&config_path).unwrap();
-    let ralph = RalphLoop::new(config, spec_path.to_str().unwrap().to_string(), None);
+    let ralph = RalphLoop::new(config, spec_path.to_str().unwrap().to_string(), None).unwrap();
 
     assert!(ralph.spec_path.ends_with("test.json"));
 }