Route RunStatus-sensitive branches through the enum, not literals

batch.rs, comparison.rs, dashboard.rs, alerts.rs, and pages.rs were all
matching on bare string literals ("queued" / "running" / "completed"
etc.) when deciding how to bucket runs. That made it easy for a typo
or a new status value to silently fall through to the "_ =>" default
and flip terminal/in-flight classification.

Parse incoming strings into RunStatus once and match on the enum. The
compiler now flags missing variants, and new RunStatus variants will
force us to visit every decision point. Domain-specific composites
outside the enum (e.g. batch.rs's "failed_partial") are left as
string constants with an inline comment explaining why.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>

Author: morganlinton

src/routes/pages.rs

@@ -497,10 +497,13 @@ pub async fn batch_detail(
         })
         .collect();
     let has_pending_runs = batch_runs.iter().any(|run| {
-        run.status != "completed"
-            && run.status != "failed"
-            && run.status != "failed_partial"
-            && run.status != "cancelled"
+        // A run is "pending" if it is still in-flight. We additionally treat
+        // "failed_partial" (a composite batch-level state set by
+        // services::batch, not a RunStatus) as terminal.
+        let is_terminal = RunStatus::parse(&run.status)
+            .map(RunStatus::is_terminal)
+            .unwrap_or(false);
+        !is_terminal && run.status != "failed_partial"
     });
 
     Ok(Html(
@@ -792,7 +795,9 @@ pub async fn scanner_index(State(state): State<AppState>) -> AppResult<Html<Stri
         .collect();
 
     let has_scan_running = has_latest_scan_run
-        && (latest_scan_run_status == "running" || latest_scan_run_status == "queued");
+        && RunStatus::parse(&latest_scan_run_status)
+            .map(RunStatus::is_in_flight)
+            .unwrap_or(false);
 
     let html = ScannerTemplate {
         has_latest_scan_run,

src/services/alerts.rs

@@ -1,4 +1,4 @@
-use crate::{app_state::AppState, models::AlertRule};
+use crate::{app_state::AppState, models::AlertRule, status::RunStatus};
 use anyhow::Result;
 use chrono::Utc;
 
@@ -198,7 +198,13 @@ async fn build_snapshot(state: &AppState, ticker: &str) -> Result<TickerAlertSna
 }
 
 fn should_skip_status(status: &str) -> bool {
-    matches!(status, "queued" | "running" | "no_data")
+    if status == "no_data" {
+        return true;
+    }
+    matches!(
+        RunStatus::parse(status),
+        Some(RunStatus::Queued | RunStatus::Running)
+    )
 }
 
 fn is_decision_downgrade(previous: Option<&str>, current: &str) -> bool {
@@ -230,10 +236,12 @@ fn classify_decision(
     latest_score: Option<f64>,
     evidence_freshness: &str,
 ) -> String {
-    match latest_status {
-        "no_data" => "no_coverage".to_string(),
-        "queued" | "running" => "researching".to_string(),
-        "failed" | "cancelled" => "attention".to_string(),
+    if latest_status == "no_data" {
+        return "no_coverage".to_string();
+    }
+    match RunStatus::parse(latest_status) {
+        Some(RunStatus::Queued | RunStatus::Running) => "researching".to_string(),
+        Some(RunStatus::Failed | RunStatus::Cancelled) => "attention".to_string(),
         _ => match latest_score {
             Some(score) if score >= 8.0 && evidence_freshness == "fresh" => {
                 "high_conviction".to_string()

src/services/batch.rs

@@ -1,4 +1,4 @@
-use crate::{app_state::AppState, models::BatchJobRunWithDetails};
+use crate::{app_state::AppState, models::BatchJobRunWithDetails, status::RunStatus};
 use anyhow::Result;
 
 pub async fn sync_batch_jobs_for_run(state: &AppState, run_id: &str) -> Result<()> {
@@ -14,7 +14,7 @@ async fn sync_single_batch_job(state: &AppState, batch_job_id: &str) -> Result<(
     if batch_job_runs.is_empty() {
         state
             .db
-            .update_batch_job_status(batch_job_id, "queued")
+            .update_batch_job_status(batch_job_id, RunStatus::Queued.as_str())
             .await?;
         return Ok(());
     }
@@ -25,26 +25,30 @@ async fn sync_single_batch_job(state: &AppState, batch_job_id: &str) -> Result<(
     let mut has_queued = false;
 
     for batch_job_run in &batch_job_runs {
+        // Any status the DB returns that we don't recognise (e.g. a future
+        // "retrying" state) is treated as in-flight so we don't prematurely
+        // finalise the batch.
         let status = batch_job_run
             .run
             .as_ref()
-            .map(|run| run.status.as_str())
-            .unwrap_or("queued");
+            .and_then(|run| RunStatus::parse(&run.status))
+            .unwrap_or(RunStatus::Queued);
         match status {
-            "completed" => completed_count += 1,
-            "failed" | "cancelled" => failed_count += 1,
-            "queued" => has_queued = true,
-            _ => has_running = true,
+            RunStatus::Completed => completed_count += 1,
+            RunStatus::Failed | RunStatus::Cancelled => failed_count += 1,
+            RunStatus::Queued => has_queued = true,
+            RunStatus::Running => has_running = true,
         }
     }
 
     let all_terminal = completed_count + failed_count == batch_job_runs.len();
     if all_terminal {
         let status = if failed_count == 0 {
-            "completed"
+            RunStatus::Completed.as_str()
         } else if completed_count == 0 {
-            "failed"
+            RunStatus::Failed.as_str()
         } else {
+            // Domain-specific composite status that doesn't map to RunStatus.
             "failed_partial"
         };
         let summary = build_batch_summary(&batch_job_runs, completed_count, failed_count);
@@ -54,15 +58,15 @@ async fn sync_single_batch_job(state: &AppState, batch_job_id: &str) -> Result<(
             .await?;
     } else {
         let status = if has_running {
-            "running"
+            RunStatus::Running
         } else if has_queued {
-            "queued"
+            RunStatus::Queued
         } else {
-            "running"
+            RunStatus::Running
         };
         state
             .db
-            .update_batch_job_status(batch_job_id, status)
+            .update_batch_job_status(batch_job_id, status.as_str())
             .await?;
     }
     Ok(())

src/services/comparison.rs

@@ -1,4 +1,4 @@
-use crate::{app_state::AppState, models::ComparisonRunWithDetails};
+use crate::{app_state::AppState, models::ComparisonRunWithDetails, status::RunStatus};
 use anyhow::Result;
 
 pub async fn sync_comparisons_for_run(state: &AppState, run_id: &str) -> Result<()> {
@@ -14,7 +14,7 @@ async fn sync_single_comparison(state: &AppState, comparison_id: &str) -> Result
     if comparison_runs.is_empty() {
         state
             .db
-            .update_comparison_status(comparison_id, "queued")
+            .update_comparison_status(comparison_id, RunStatus::Queued.as_str())
             .await?;
         return Ok(());
     }
@@ -28,13 +28,13 @@ async fn sync_single_comparison(state: &AppState, comparison_id: &str) -> Result
         let status = comparison_run
             .run
             .as_ref()
-            .map(|run| run.status.as_str())
-            .unwrap_or("queued");
+            .and_then(|run| RunStatus::parse(&run.status))
+            .unwrap_or(RunStatus::Queued);
         match status {
-            "completed" => completed_count += 1,
-            "failed" | "cancelled" => failed_count += 1,
-            "queued" => has_queued = true,
-            _ => has_running = true,
+            RunStatus::Completed => completed_count += 1,
+            RunStatus::Failed | RunStatus::Cancelled => failed_count += 1,
+            RunStatus::Queued => has_queued = true,
+            RunStatus::Running => has_running = true,
         }
     }
 
@@ -48,15 +48,15 @@ async fn sync_single_comparison(state: &AppState, comparison_id: &str) -> Result
             .await?;
     } else {
         let status = if has_running {
-            "running"
+            RunStatus::Running
         } else if has_queued {
-            "queued"
+            RunStatus::Queued
         } else {
-            "running"
+            RunStatus::Running
         };
         state
             .db
-            .update_comparison_status(comparison_id, status)
+            .update_comparison_status(comparison_id, status.as_str())
             .await?;
     }
 
@@ -69,10 +69,11 @@ fn build_terminal_rollup(
     failed_count: usize,
 ) -> (&'static str, Option<String>, String) {
     let status = if failed_count == 0 {
-        "completed"
+        RunStatus::Completed.as_str()
     } else if completed_count == 0 {
-        "failed"
+        RunStatus::Failed.as_str()
     } else {
+        // Domain-specific composite status outside the RunStatus enum.
         "failed_partial"
     };
 
@@ -83,7 +84,7 @@ fn build_terminal_rollup(
                 .run
                 .as_ref()
                 .map(|run| run.status.as_str())
-                .unwrap_or("queued");
+                .unwrap_or(RunStatus::Queued.as_str());
             let run_summary = comparison_run
                 .run
                 .as_ref()
@@ -108,7 +109,7 @@ fn build_terminal_rollup(
                 .run
                 .as_ref()
                 .map(|run| run.status.as_str())
-                .unwrap_or("queued");
+                .unwrap_or(RunStatus::Queued.as_str());
             let run_summary = comparison_run
                 .run
                 .as_ref()

src/services/dashboard.rs

@@ -2,6 +2,7 @@ use crate::{
     app_state::AppState,
     models::{DashboardResponse, DashboardTickerRow},
     services::alerts::{self, TickerAlertSnapshot},
+    status::RunStatus,
 };
 use anyhow::{anyhow, Result};
 use chrono::Utc;
@@ -144,10 +145,12 @@ fn classify_decision(
     latest_score: Option<f64>,
     evidence_freshness: &str,
 ) -> String {
-    match latest_status {
-        "no_data" => "no_coverage".to_string(),
-        "queued" | "running" => "researching".to_string(),
-        "failed" | "cancelled" => "attention".to_string(),
+    if latest_status == "no_data" {
+        return "no_coverage".to_string();
+    }
+    match RunStatus::parse(latest_status) {
+        Some(RunStatus::Queued | RunStatus::Running) => "researching".to_string(),
+        Some(RunStatus::Failed | RunStatus::Cancelled) => "attention".to_string(),
         _ => match latest_score {
             Some(score) if score >= 8.0 && evidence_freshness == "fresh" => {
                 "high_conviction".to_string()