fix(tui): account errors to the active route

Prefer the captured active turn route when recording provider health failures after TurnStarted clears the pending route. Keep the pending and selected routes as pre-start fallbacks, and cover the routed-turn case.

Signed-off-by: Nightt <87569709+nightt5879@users.noreply.github.com>

Author: nightt5879

crates/tui/src/tui/ui.rs

@@ -3001,11 +3001,8 @@ async fn run_event_loop(
                         recoverable: _,
                     } => {
                         let provider_before_error = app.api_provider;
-                        let (health_provider, health_model) = app
-                            .pending_turn_route
-                            .as_ref()
-                            .map(|(provider, model, _)| (*provider, model.clone()))
-                            .unwrap_or_else(|| (provider_before_error, app.model.clone()));
+                        let (health_provider, health_model) =
+                            error_health_route(app, provider_before_error);
                         app.provider_health.record_failure(
                             config,
                             health_provider,
@@ -6780,6 +6777,19 @@ fn capture_turn_started_metadata(app: &mut App, event: &EngineEvent) {
     }
 }
 
+fn error_health_route(app: &App, fallback_provider: ApiProvider) -> (ApiProvider, String) {
+    app.active_turn
+        .as_ref()
+        .and_then(|turn| turn.route.as_ref())
+        .map(|route| (route.provider, route.model.clone()))
+        .or_else(|| {
+            app.pending_turn_route
+                .as_ref()
+                .map(|(provider, model, _)| (*provider, model.clone()))
+        })
+        .unwrap_or_else(|| (fallback_provider, app.model.clone()))
+}
+
 fn record_turn_activity(app: &mut App, event: &EngineEvent, now: Instant) {
     if matches!(event, EngineEvent::TurnStarted { .. }) {
         app.turn_last_activity_at = Some(now);

crates/tui/src/tui/ui/tests.rs

@@ -7234,6 +7234,27 @@ fn turn_started_route_is_captured_before_cancel_suppression() {
     assert_eq!(observer.route, Some(route));
 }
 
+#[test]
+fn engine_error_health_accounting_uses_active_turn_route() {
+    let mut app = create_test_app();
+    app.api_provider = ApiProvider::Deepseek;
+    app.model = "current-model".to_string();
+    let event = EngineEvent::TurnStarted {
+        turn_id: "routed-turn".to_string(),
+        created_at: chrono::Utc::now(),
+        route: Some(crate::core::events::TurnRoute {
+            provider: ApiProvider::Openai,
+            model: "gpt-5.5".to_string(),
+            auto_model: true,
+        }),
+    };
+    capture_turn_started_metadata(&mut app, &event);
+
+    let route = error_health_route(&app, app.api_provider);
+
+    assert_eq!(route, (ApiProvider::Openai, "gpt-5.5".to_string()));
+}
+
 #[test]
 fn completion_only_hook_metadata_is_synthetic_and_non_model() {
     let observed_after = chrono::Utc::now();