fix: detect engine task death mid-turn and recover UI immediately

crates/tui/src/tui/ui.rs

@@ -2234,6 +2234,41 @@ async fn run_event_loop(
                     }
                 }
             }
+            // Detect engine task death mid-turn.  When the engine task
+            // panics (caught by spawn_supervised's catch_unwind) or exits
+            // unexpectedly between TurnStarted and TurnComplete, the event
+            // channel's sender is dropped.  The while-let loop above exits
+            // silently on Err, so we must check post-loop and recover the
+            // UI state immediately instead of waiting for the 300-second
+            // TURN_STALL_WATCHDOG_TIMEOUT.  Use is_closed() rather than
+            // try_recv() so the probe never consumes a valid event.
+            if (app.is_loading || app.is_compacting || app.is_purging) && rx.is_closed() {
+                streaming_thinking::finalize_current(app);
+                app.finalize_streaming_assistant_as_interrupted();
+                app.finalize_active_cell_as_interrupted();
+                app.streaming_state.reset();
+                app.streaming_message_index = None;
+                app.streaming_thinking_active_entry = None;
+
+                app.is_loading = false;
+                app.is_compacting = false;
+                app.is_purging = false;
+                app.active_allowed_tools = None;
+                app.agent_progress.clear();
+                app.agent_activity_started_at = None;
+                app.turn_started_at = None;
+                app.turn_last_activity_at = None;
+                app.runtime_turn_status = None;
+                app.runtime_turn_id = None;
+                app.dispatch_started_at = None;
+                app.user_scrolled_during_stream = false;
+                app.push_status_toast(
+                    "Engine process has terminated unexpectedly.",
+                    StatusToastLevel::Error,
+                    None,
+                );
+                app.needs_redraw = true;
+            }
         }
         if let Some(index) = app.streaming_message_index {
             let committed = app.streaming_state.commit_text(0);

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

@@ -2607,6 +2607,73 @@ fn turn_liveness_recovers_stalled_in_progress_turn() {
     assert!(toast.text.contains("Turn stalled"));
 }
 
+#[test]
+fn engine_event_channel_disconnect_recovers_mid_turn_ui_state() {
+    // Simulate the event-loop post-check that detects engine task death.
+    // Creates a real mpsc channel, sets up app as if a turn is in progress,
+    // drops the sender (mirroring engine task exit in spawn_supervised),
+    // and verifies the post-loop recovery logic cleans up the UI state.
+    let (tx_event, rx) = tokio::sync::mpsc::channel::<EngineEvent>(256);
+    drop(tx_event);
+
+    // Confirm the channel is closed
+    assert!(rx.is_closed());
+
+    let mut app = create_test_app();
+    app.is_loading = true;
+    app.is_compacting = false;
+    app.is_purging = false;
+    app.runtime_turn_status = Some("in_progress".to_string());
+    app.runtime_turn_id = Some("turn-42".to_string());
+    app.streaming_message_index = Some(0);
+    app.user_scrolled_during_stream = true;
+
+    // Apply the same post-loop logic from ui.rs
+    if (app.is_loading || app.is_compacting || app.is_purging) && rx.is_closed() {
+        streaming_thinking::finalize_current(&mut app);
+        app.finalize_streaming_assistant_as_interrupted();
+        app.finalize_active_cell_as_interrupted();
+        app.streaming_state.reset();
+        app.streaming_message_index = None;
+        app.streaming_thinking_active_entry = None;
+
+        app.is_loading = false;
+        app.is_compacting = false;
+        app.is_purging = false;
+        app.active_allowed_tools = None;
+        app.agent_progress.clear();
+        app.agent_activity_started_at = None;
+        app.turn_started_at = None;
+        app.turn_last_activity_at = None;
+        app.runtime_turn_status = None;
+        app.runtime_turn_id = None;
+        app.dispatch_started_at = None;
+        app.user_scrolled_during_stream = false;
+        app.push_status_toast(
+            "Engine process has terminated unexpectedly.",
+            StatusToastLevel::Error,
+            None,
+        );
+        app.needs_redraw = true;
+    }
+
+    // Verify the fix: UI state is fully recovered
+    assert!(!app.is_loading, "loading must be cleared");
+    assert!(!app.is_compacting, "compacting must be cleared");
+    assert!(!app.is_purging, "purging must be cleared");
+    assert!(app.active_allowed_tools.is_none());
+    assert!(app.agent_progress.is_empty());
+    assert!(app.agent_activity_started_at.is_none());
+    assert!(app.runtime_turn_status.is_none(), "turn status cleared");
+    assert!(app.runtime_turn_id.is_none(), "turn id cleared");
+    assert!(app.streaming_message_index.is_none());
+    assert!(!app.user_scrolled_during_stream);
+    assert!(app.needs_redraw, "needs_redraw must be set");
+    let toast = app.status_toasts.back().expect("error toast pushed");
+    assert_eq!(toast.level, StatusToastLevel::Error);
+    assert!(toast.text.contains("Engine process has terminated"));
+}
+
 #[test]
 fn fixed_model_auto_thinking_skips_auto_model_router() {
     let mut app = create_test_app();