feat(reviewer): propagate provider errors; pass prompts dir to review tool

Change Reviewer::new to async fn new() -> Result<Self>, replacing
.expect() with ? for error propagation on BaselineRegistry and
create_provider_cached. Update main.rs call site to match on
Result. Add --prompts arg to run_review_tool using
settings.get_prompts_dir(). Update src/bin/review.rs to use
ToolBox::with_config, PromptRegistry::with_settings, and
Option<PathBuf> for --prompts arg.

Signed-off-by: derekbarbosa <derekasobrab@gmail.com>

Author: derekbarbosa

src/bin/review.rs

@@ -43,8 +43,8 @@ struct Args {
     #[arg(long)]
     worktree_dir: Option<PathBuf>,
 
-    #[arg(long, default_value = "third_party/prompts/kernel")]
-    prompts: PathBuf,
+    #[arg(long)]
+    prompts: Option<PathBuf>,
 
     /// If set, only review the patch with this index (1-based usually).
     /// Previous patches (with lower index) will be applied but not reviewed.
@@ -366,11 +366,25 @@ async fn main() -> Result<()> {
                         let provider = sashiko::ai::create_provider(&settings).expect("Failed to create AI provider");
 
                         // Enable read_prompt tool only if explicit caching is NOT used.
-                        let prompts_dir = PathBuf::from("third_party/prompts/kernel");
+                        let prompts_dir = args
+                            .prompts
+                            .clone()
+                            .unwrap_or_else(|| PathBuf::from(settings.get_prompts_dir()));
                         let prompts_tool_path = Some(prompts_dir.join("tool.md"));
 
-                        let tools = ToolBox::new(worktree.path.clone(), prompts_tool_path);
-                        let prompts = PromptRegistry::new(args.prompts.clone());
+                        let tools = ToolBox::with_config(
+                            worktree.path.clone(),
+                            prompts_tool_path,
+                            settings.tools.as_ref(),
+                        );
+
+                        let prompts = if settings.prompts.is_some() {
+                            PromptRegistry::with_settings(settings.prompts.as_ref())
+                                .await
+                                .expect("Failed to load prompts with settings")
+                        } else {
+                            PromptRegistry::new(prompts_dir)
+                        };
 
                         // Calculate series range (baseline..last_patch)
                         let series_range = calculate_series_range(

src/main.rs

@@ -570,10 +570,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     // Start Reviewer Service
-    let reviewer = Reviewer::new(db.clone(), settings.clone()).await;
-    tokio::spawn(async move {
-        reviewer.start().await;
-    });
+    match Reviewer::new(db.clone(), settings.clone()).await {
+        Ok(reviewer) => {
+            tokio::spawn(async move {
+                reviewer.start().await;
+            });
+        }
+        Err(e) => {
+            error!("Failed to initialize Reviewer service: {}", e);
+        }
+    }
 
     let metrics_db = db.clone();
     tokio::spawn(async move {

src/reviewer.rs

@@ -90,43 +90,30 @@ impl Reviewer {
     ///
     /// * `db` - The database connection.
     /// * `settings` - Application settings.
-    pub async fn new(db: Arc<Database>, settings: Settings) -> Self {
+    pub async fn new(db: Arc<Database>, settings: Settings) -> Result<Self> {
         let concurrency = settings.review.concurrency;
         let repo_path = PathBuf::from(&settings.git.repository_path);
 
-        let baseline_registry =
-            match BaselineRegistry::new(&repo_path, settings.git.custom_remotes.clone()) {
-                Ok(r) => Arc::new(r),
-                Err(e) => {
-                    error!(
-                        "Failed to initialize BaselineRegistry: {}. Using empty registry.",
-                        e
-                    );
-                    Arc::new(
-                        BaselineRegistry::new(&repo_path, settings.git.custom_remotes.clone())
-                            .unwrap_or_else(|_| {
-                                panic!("Critical error initializing BaselineRegistry: {}", e)
-                            }),
-                    )
-                }
-            };
+        let baseline_registry = Arc::new(BaselineRegistry::new(
+            &repo_path,
+            settings.git.custom_remotes.clone(),
+        )?);
 
         let provider = create_provider_cached(
             &settings,
             settings.ai.response_cache,
             settings.ai.response_cache_ttl_days,
         )
-        .await
-        .expect("Failed to create AI provider");
+        .await?;
 
-        Self {
+        Ok(Self {
             db,
             settings,
             semaphore: Arc::new(Semaphore::new(concurrency)),
             baseline_registry,
             quota_manager: Arc::new(QuotaManager::new()),
             provider,
-        }
+        })
     }
 
     /// Starts the reviewer service loop.
@@ -1553,6 +1540,8 @@ async fn run_review_tool(
         cmd.arg("--stages").arg(stages_str);
     }
 
+    cmd.arg("--prompts").arg(settings.get_prompts_dir());
+
     cmd.stdin(Stdio::piped());
     cmd.stdout(Stdio::piped());
     cmd.stderr(Stdio::piped());