fix(tui): live status supersedes the unread marker

agent-of-empires#2088 review: a Running session that also carried an unread marker kept
showing the solid unread dot — the color was gated to resting states
(Idle/Unknown) but the icon + bold weren't, so the dot replaced the running
spinner. Gate the whole unread treatment (color, dot, bold) on resting
status so any live status (Running/Waiting/Starting/...) keeps its own color
and spinner. Adds a render regression test.

🤖 Generated with Claude Code

Author: Eric162

src/tui/home/render.rs

@@ -1013,22 +1013,24 @@ impl HomeView {
                                 Status::Deleting => ICON_DELETING,
                                 Status::Creating => spinner_starting(&inst.created_at),
                             };
-                            // Unread overlays the resting (Idle/Unknown)
-                            // color with `theme.unread`. Auto-unread only
-                            // ever lands on Idle; a manual flag on a live
-                            // row keeps the live status color (more urgent
-                            // than "unread"). Archived/snoozed/urgent/
-                            // favorite below still override as usual.
-                            let unread_overlay =
-                                crate::session::unread_enabled() && inst.is_unread();
+                            // Unread paints only on resting rows
+                            // (Idle/Unknown): a live status (Running/Waiting/
+                            // Starting/...) supersedes it and keeps its own
+                            // color AND spinner. Auto-unread only ever lands
+                            // on Idle; a manual flag on a live row defers to
+                            // the live state. Archived/snoozed/urgent below
+                            // still override on top.
+                            let unread_resting = crate::session::unread_enabled()
+                                && inst.is_unread()
+                                && matches!(inst.status, Status::Idle | Status::Unknown);
                             let color = match inst.status {
                                 Status::Running => theme.running,
                                 Status::Waiting => theme.waiting,
-                                Status::Idle if unread_overlay => theme.unread,
+                                Status::Idle if unread_resting => theme.unread,
                                 Status::Idle => {
                                     theme.idle_color_at_age(idle_age, self.idle_decay_window)
                                 }
-                                Status::Unknown if unread_overlay => theme.unread,
+                                Status::Unknown if unread_resting => theme.unread,
                                 Status::Unknown => theme.waiting,
                                 Status::Stopped => theme.dimmed,
                                 Status::Error => theme.error,
@@ -1037,7 +1039,7 @@ impl HomeView {
                                 Status::Creating => theme.accent,
                             };
                             let mut style = Style::default().fg(color);
-                            if unread_overlay {
+                            if unread_resting {
                                 // Make unread unmistakable: a solid dot glyph
                                 // plus bold, on top of the `theme.unread`
                                 // color set above. A plain color swap read as

src/tui/home/tests.rs

@@ -575,6 +575,58 @@ fn preview_visible_rows_equal_output_area_with_info_shown() {
     );
 }
 
+/// Precedence: unread paints only on resting (Idle/Unknown) rows. A live
+/// status supersedes it, keeping its own spinner — so a Running session that
+/// also carries an unread marker must NOT show the solid unread dot. See the
+/// #2088 review note about jumbled precedence.
+#[test]
+#[serial]
+fn unread_dot_yields_to_a_running_status() {
+    use crate::tui::styles::load_theme;
+    use ratatui::backend::TestBackend;
+    use ratatui::Terminal;
+
+    let mut env = create_test_env_with_sessions(1);
+    let id = env.view.instances()[0].id.clone();
+    let theme = load_theme("empire");
+
+    let render = |env: &mut TestEnv| -> String {
+        let backend = TestBackend::new(120, 40);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|f| env.view.render(f, f.area(), &theme, None, None, None))
+            .unwrap();
+        let buf = terminal.backend().buffer();
+        let mut out = String::new();
+        for y in 0..buf.area.height {
+            for x in 0..buf.area.width {
+                out.push_str(buf[(x, y)].symbol());
+            }
+        }
+        out
+    };
+
+    // Idle + unread: the row shows the solid unread dot.
+    env.view.mutate_instance(&id, |inst| {
+        inst.status = crate::session::Status::Idle;
+        inst.mark_unread_manual();
+    });
+    env.view.flat_items = env.view.build_flat_items();
+    assert!(
+        render(&mut env).contains('●'),
+        "an idle unread row should paint the unread dot"
+    );
+
+    // Running + still unread: the live status wins; no unread dot.
+    env.view
+        .mutate_instance(&id, |inst| inst.status = crate::session::Status::Running);
+    env.view.flat_items = env.view.build_flat_items();
+    assert!(
+        !render(&mut env).contains('●'),
+        "a running row must keep its spinner, not the unread dot"
+    );
+}
+
 #[test]
 #[serial]
 fn test_q_returns_quit_action() {