@pheem49/mint 1.14.0 → 1.16.0

package/crates/mint-cli/src/agent/live_status.rs

@@ -222,38 +222,12 @@ pub(super) fn print_table_block(table_lines: &[String], is_first: &mut bool) {
     }
 }
 
-pub(super) fn should_show_verification(verification: &str) -> bool {
-    let normalized = verification.trim().to_ascii_lowercase();
-    if normalized.is_empty() {
-        return false;
-    }
-    if normalized.starts_with("information retrieved from web search")
-        || normalized.starts_with("successfully ran background command")
-        || normalized.starts_with("opened ")
-        || normalized.contains("background command to open")
-        || normalized.contains("web search results")
-    {
-        return false;
-    }
-    !matches!(
-        normalized.as_str(),
-        "not run"
-            | "not run."
-            | "no checks run"
-            | "no checks run."
-            | "no technical task requested"
-            | "no technical task requested."
-            | "no technical task requested, just a greeting."
-            | "not required"
-            | "not required."
-            | "none"
-            | "n/a"
-    )
-}
-
 #[derive(Debug, Default)]
 pub(super) struct LiveStatus {
+    pub(super) tui: Option<crate::interactive::TuiHandle>,
     pub(super) thinking: Option<String>,
+    pub(super) compaction_started: Option<Instant>,
+    pub(super) compaction_scopes: std::collections::BTreeMap<String, usize>,
     /// Context-window usage (0-100) as of the last completed step —
     /// mirrored here (not just built into `thinking`'s label text) so the
     /// 150ms elapsed-time ticker in `run_code_agent_with_options` can keep
@@ -305,6 +279,9 @@ pub(super) struct LiveStatus {
     pub(super) committed_activities: usize,
     pub(super) committed_tasks: usize,
     pub(super) spinner_tick: usize,
+    /// When the currently running tool began executing — used to animate an
+    /// inline spinner and elapsed timer directly on the active tool line.
+    pub(super) active_tool_started: Option<Instant>,
     /// Sources collected from web_search ToolEnd results (title, url)
     pub(super) web_sources: Vec<(String, String)>,
     pub(super) inline_tui: InlineTui,
@@ -562,15 +539,43 @@ pub(super) fn strip_ansi_escapes(s: &str) -> String {
     result
 }
 
-pub(super) fn is_thai_combining(c: char) -> bool {
-    matches!(c,
-        '\u{0e31}' | '\u{0e34}'..='\u{0e37}' | '\u{0e38}'..='\u{0e39}' |
-        '\u{0e47}'..='\u{0e4e}'
+pub(super) fn compaction_label(elapsed: Duration) -> String {
+    format!(
+        "Compacting context · {}s • Esc to interrupt",
+        elapsed.as_secs()
     )
 }
 
+pub(super) fn update_context_compaction(
+    status: &mut LiveStatus,
+    phase: &str,
+    scope: Option<&str>,
+    now: Instant,
+) {
+    let key = scope.unwrap_or("").to_owned();
+    if phase == "started" {
+        *status.compaction_scopes.entry(key).or_default() += 1;
+        status.compaction_started.get_or_insert(now);
+    } else {
+        if let Some(count) = status.compaction_scopes.get_mut(&key) {
+            *count -= 1;
+            if *count == 0 {
+                status.compaction_scopes.remove(&key);
+            }
+        }
+        if status.compaction_scopes.is_empty() {
+            status.compaction_started = None;
+        }
+    }
+    status.waiting_for_network = None;
+}
+
 pub(super) fn apply_wave_effect(text: &str, tick: usize) -> String {
-    let (label, metadata) = if let Some(idx) = text.rfind(" • Esc to interrupt)") {
+    let (label, metadata) = if text.starts_with("Compacting context")
+        && let Some(idx) = text.find(" · ")
+    {
+        (&text[..idx], &text[idx..])
+    } else if let Some(idx) = text.rfind(" • Esc to interrupt)") {
         if let Some(open_paren_idx) = text[..idx].rfind('(') {
             (&text[..open_paren_idx], &text[open_paren_idx..])
         } else {
@@ -606,33 +611,10 @@ pub(super) fn apply_wave_effect(text: &str, tick: usize) -> String {
         let x = (i as f32 * 0.4) - phase;
         let t = (x.sin() + 1.0) / 2.0; // Oscillates in [0.0, 1.0]
 
-        // Stop colors: Dim Gray (70, 70, 70) -> Mint Green (105, 230, 166) -> Cyan (78, 201, 216)
-        let (r, g, b) = if t < 0.3 {
-            let local_t = t / 0.3;
-            let r = 70.0 + (105.0 - 70.0) * local_t;
-            let g = 70.0 + (230.0 - 70.0) * local_t;
-            let b = 70.0 + (166.0 - 70.0) * local_t;
-            (r, g, b)
-        } else if t < 0.7 {
-            let local_t = (t - 0.3) / 0.4;
-            let r = 105.0 + (78.0 - 105.0) * local_t;
-            let g = 230.0 + (201.0 - 230.0) * local_t;
-            let b = 166.0 + (216.0 - 166.0) * local_t;
-            (r, g, b)
-        } else {
-            let local_t = (t - 0.7) / 0.3;
-            let r = 78.0 + (70.0 - 78.0) * local_t;
-            let g = 201.0 + (70.0 - 201.0) * local_t;
-            let b = 216.0 + (70.0 - 216.0) * local_t;
-            (r, g, b)
-        };
-
+        let emphasis = if t > 0.72 { BOLD } else { "" };
         animated_label.push_str(&format!(
-            "\x1b[1m\x1b[38;2;{};{};{}m{}\x1b[0m",
-            r.round() as u8,
-            g.round() as u8,
-            b.round() as u8,
-            c
+            "{emphasis}{}{c}{RESET}",
+            crate::terminal_theme::ANSI_ACCENT
         ));
     }
 
@@ -715,7 +697,10 @@ pub(super) fn compose_queue_box(
     (lines, cursor_x, cursor_y)
 }
 
-pub(super) fn render_live_status(status: &mut LiveStatus) {
+/// Renders the live viewport and reports whether a terminal was available to
+/// draw it. Callers use the result to fall back to plain output when Mint is
+/// run without an interactive terminal.
+pub(super) fn render_live_status(status: &mut LiveStatus) -> bool {
     let mut lines = Vec::new();
     let explored_start = status.committed_explored.min(status.explored.len());
     let activities_start = status.committed_activities.min(status.activities.len());
@@ -729,13 +714,17 @@ pub(super) fn render_live_status(status: &mut LiveStatus) {
     status.spinner_tick += 1;
 
     lines.extend(plan_lines(&status.plan_steps, true, tick));
-    lines.extend(activity_block_lines(
-        &status.tasks[tasks_start..],
-        &status.activities[activities_start..],
-        &status.explored[explored_start..],
-        true,
-        tick,
-    ));
+    if status.tui.is_none() {
+        lines.extend(activity_block_lines(
+            &status.tasks[tasks_start..],
+            &status.activities[activities_start..],
+            &status.explored[explored_start..],
+            true,
+            tick,
+            status.active_tool_started,
+            true,
+        ));
+    }
     // Built here (not inline below) so both destinations for it — the old
     // trailing-line spot in `lines`, and the queue box's own pinned row —
     // share one animation. When the queue box is about to be drawn, it's
@@ -747,26 +736,6 @@ pub(super) fn render_live_status(status: &mut LiveStatus) {
     // that — same information, anchored to the thing it describes instead
     // of to whatever happened to print last.
     let thinking_display = status.thinking.as_ref().map(|thinking| {
-        // Moon phases, forced to *text* presentation via `\u{FE0E}` so they
-        // stay single-column-width instead of the wide (2-column) emoji
-        // glyph — deliberate, even though it means some terminal fonts only
-        // ship one fallback glyph for all 8 text-style variants and the
-        // spin won't visibly animate there. Width consistency was chosen
-        // over guaranteed animation; swap to a plain-text spinner (e.g.
-        // Braille patterns) instead of dropping this selector if that
-        // trade-off ever needs to flip back.
-        let frames = &[
-            "🌑\u{FE0E}",
-            "🌒\u{FE0E}",
-            "🌓\u{FE0E}",
-            "🌔\u{FE0E}",
-            "🌕\u{FE0E}",
-            "🌖\u{FE0E}",
-            "🌗\u{FE0E}",
-            "🌘\u{FE0E}",
-        ];
-        let frame = frames[status.spinner_tick % frames.len()];
-
         let dots_frames = &["", ".", "..", "..."];
         let dots = dots_frames[(status.spinner_tick / 2) % dots_frames.len()];
 
@@ -781,12 +750,16 @@ pub(super) fn render_live_status(status: &mut LiveStatus) {
 
         let waved_thinking = apply_wave_effect(&custom_thinking, status.spinner_tick);
 
-        format!("{MINT}{frame}{RESET} {waved_thinking}")
+        // A single-column text star matches the GUI and joins the TUI glow.
+        format!("{MINT}✦{RESET} {waved_thinking}")
     });
     let queue_box_will_show = status.queue_enabled && status.accepting_input;
     if !queue_box_will_show && let Some(display) = &thinking_display {
         lines.push(format!("  {display}"));
     }
+    if status.compaction_started.is_some() {
+        lines.push("    Summarizing earlier steps to continue working".into());
+    }
     // The queueing follow-up box (see `AgentOptions::queueing`) is appended
     // after everything above, so it's always the bottom-most thing in the
     // live region. Deliberately a *different* style from
@@ -831,18 +804,23 @@ pub(super) fn render_live_status(status: &mut LiveStatus) {
         }
     }
 
+    if let Some(tui) = &status.tui {
+        tui.set_status(lines.iter().map(|line| strip_ansi_escapes(line)).collect());
+        return true;
+    }
+
     if lines.is_empty() && box_lines.is_empty() {
         status.inline_tui.teardown();
-        return;
+        return false;
     }
 
     let Ok(terminal) = status.inline_tui.ensure() else {
-        return;
+        return false;
     };
     // `draw()` itself only queries the cursor position on the rare path
     // where it detects the terminal window was actually resized since the
     // last frame — bracket it too, defensively, for that case.
-    let _ = with_raw_mode_for_cursor_query(|| {
+    with_raw_mode_for_cursor_query(|| {
         terminal.draw(|frame| {
             let area = frame.area();
             // The box (the "Ask anything..." input) claims its own rows
@@ -856,7 +834,7 @@ pub(super) fn render_live_status(status: &mut LiveStatus) {
             let box_height = (box_lines.len() as u16).min(area.height);
             let available_for_status = area.height.saturating_sub(box_height);
 
-            let mut status_line_count: u16 = 0;
+            let mut status_height: u16 = 0;
             let mut status_paragraph = None;
             if !lines.is_empty()
                 && let Ok(status_text) = lines.join("\n").into_text()
@@ -874,17 +852,18 @@ pub(super) fn render_live_status(status: &mut LiveStatus) {
                 // bottom of the frame. (`Paragraph::line_count` would do this
                 // exactly, but it's gated behind an unstable ratatui feature.)
                 let wrap_width = area.width.max(1);
-                status_line_count = status_text
+                let status_line_count: u16 = status_text
                     .lines
                     .iter()
                     .map(|line| (line.width().max(1) as u16).div_ceil(wrap_width))
                     .sum();
+                status_height = status_line_count.min(available_for_status);
                 status_paragraph = Some(
                     ratatui::widgets::Paragraph::new(status_text)
-                        .wrap(ratatui::widgets::Wrap { trim: false }),
+                        .wrap(ratatui::widgets::Wrap { trim: false })
+                        .scroll((status_line_count.saturating_sub(status_height), 0)),
                 );
             }
-            let status_height = status_line_count.min(available_for_status);
             let status_area = ratatui::layout::Rect {
                 height: status_height,
                 ..area
@@ -909,14 +888,31 @@ pub(super) fn render_live_status(status: &mut LiveStatus) {
                 ));
             }
         })
-    });
+    })
+    .is_ok()
 }
 
 /// Freezes any in-flight activity into scrollback. Returns whether it
 /// actually committed anything — callers that print their own leading blank
 /// line right after (e.g. the final answer) use this to skip it when this
 /// already ended on one, instead of stacking two.
+pub(super) fn commit_activity_snapshot_if_idle(
+    status: &mut LiveStatus,
+    active_tools: usize,
+) -> bool {
+    if active_tools > 0 {
+        return false;
+    }
+    commit_activity_snapshot(status)
+}
+
 pub(super) fn commit_activity_snapshot(status: &mut LiveStatus) -> bool {
+    if status.tui.is_some() {
+        status.committed_explored = status.explored.len();
+        status.committed_activities = status.activities.len();
+        status.committed_tasks = status.tasks.len();
+        return false;
+    }
     let explored_start = status.committed_explored.min(status.explored.len());
     let activities_start = status.committed_activities.min(status.activities.len());
     let tasks_start = status.committed_tasks.min(status.tasks.len());
@@ -927,16 +923,16 @@ pub(super) fn commit_activity_snapshot(status: &mut LiveStatus) -> bool {
         &status.explored[explored_start..],
         false,
         0,
+        None,
+        true,
     );
     if lines.is_empty() {
         return false;
     }
 
     let (tw, _) = markdown::terminal_size_or_default();
-    let width = tw as usize;
-    lines.push(String::new());
-    lines.push(format!("{DIM}{}{RESET}", "─".repeat(width)));
-    lines.push(String::new());
+    let width = (tw as usize).saturating_sub(8).max(40);
+    lines.push(format!("{DIM}  {}{RESET}", "─".repeat(width)));
     insert_permanent_lines(status, &lines);
 
     status.committed_explored = status.explored.len();
@@ -945,19 +941,202 @@ pub(super) fn commit_activity_snapshot(status: &mut LiveStatus) -> bool {
     true
 }
 
-pub(super) fn print_timeline_note(status: &mut LiveStatus, thought: &str) {
+#[cfg(test)]
+mod concurrent_activity_tests {
+    use super::*;
+
+    #[test]
+    fn unrelated_thought_keeps_in_flight_shell_activity_live() {
+        let mut status = LiveStatus::default();
+        status.tasks.push(TaskEntry {
+            label: "[run_shell] Running command: `sleep 1`...".to_owned(),
+            output: Vec::new(),
+        });
+
+        assert!(!commit_activity_snapshot_if_idle(&mut status, 1));
+        assert_eq!(status.committed_tasks, 0);
+        let live_lines = activity_block_lines(
+            &status.tasks[status.committed_tasks..],
+            &[],
+            &[],
+            true,
+            0,
+            Some(Instant::now()),
+            true,
+        );
+        assert!(
+            live_lines
+                .iter()
+                .any(|line| line.contains("Running 1 shell command"))
+        );
+        assert!(live_lines.iter().any(|line| line.contains("sleep 1")));
+    }
+}
+
+#[cfg(test)]
+mod compact_tui_status_tests {
+    use super::*;
+
+    #[test]
+    fn completed_shell_output_does_not_push_command_labels_out_of_live_view() {
+        let tasks = vec![
+            TaskEntry {
+                label: "[run_shell] Running command: `time sleep 10`...".into(),
+                output: Vec::new(),
+            },
+            TaskEntry {
+                label: "Finished command: `time sleep 10`".into(),
+                output: vec![
+                    "stdout:".into(),
+                    "stderr:".into(),
+                    "real 0m10.002s".into(),
+                    "user 0m0.002s".into(),
+                    "sys 0m0.002s".into(),
+                ],
+            },
+        ];
+        let mut lines = activity_block_lines(&tasks, &[], &[], true, 0, None, false);
+        lines.push("  Herding...".into());
+        let visible = &lines[lines.len().saturating_sub(8)..];
+        assert!(
+            visible
+                .iter()
+                .any(|line| line.contains("Running 1 shell command"))
+        );
+        assert!(visible.iter().any(|line| line.contains("[run_shell]")));
+        assert!(visible.iter().any(|line| line.contains("Finished command")));
+        assert!(!visible.iter().any(|line| line.contains("real 0m10.002s")));
+        let committed = activity_block_lines(&tasks, &[], &[], false, 0, None, true);
+        assert!(committed.iter().any(|line| line.contains("real 0m10.002s")));
+    }
+}
+
+pub(super) fn is_internal_cot(text: &str) -> bool {
+    mint_core::orchestration::is_internal_cot(text)
+}
+
+pub(super) fn print_extended_thinking(
+    status: &mut LiveStatus,
+    thought: &str,
+    elapsed: Duration,
+    stream_id: Option<&str>,
+) {
+    if let Some(tui) = &status.tui {
+        crate::interactive::finish_thought(
+            stream_id,
+            thought,
+            &crate::interactive::format_thought_elapsed(elapsed),
+        );
+        tui.finish_thought(stream_id, thought, elapsed);
+    } else {
+        print_timeline_note(status, thought, elapsed, stream_id);
+    }
+}
+
+#[cfg(test)]
+mod tui_thought_progress_tests {
+    use super::*;
+
+    #[test]
+    fn short_extended_thinking_collapses_in_tui_instead_of_printing_raw_text() {
+        let state = std::sync::Arc::new(std::sync::Mutex::new(
+            crate::interactive::ChatViewState::default(),
+        ));
+        let tui = crate::interactive::ChatTui::handle(state.clone());
+        tui.append_thought_delta("one", "Checking", Duration::from_millis(1200));
+        let mut status = LiveStatus {
+            tui: Some(tui),
+            ..Default::default()
+        };
+        print_extended_thinking(
+            &mut status,
+            "Checking files",
+            Duration::from_millis(1900),
+            Some("one"),
+        );
+        let state = state.lock().unwrap();
+        assert_eq!(state.transcript.len(), 1);
+        assert_eq!(state.transcript[0].text, "Thought · 1.9s (Ctrl+T to view)");
+    }
+}
+
+pub(super) fn print_timeline_note(
+    status: &mut LiveStatus,
+    thought: &str,
+    elapsed: Duration,
+    stream_id: Option<&str>,
+) {
     let thought = thought.trim();
     if thought.is_empty() {
         return;
     }
-    let (tw, _) = markdown::terminal_size_or_default();
-    let width = tw as usize;
-    let options = textwrap::Options::new(width)
-        .initial_indent("  • ")
-        .subsequent_indent("    ")
-        .break_words(true);
-    let wrapped = textwrap::fill(thought, &options);
-    insert_permanent_lines(status, &[wrapped]);
+    let elapsed_str = crate::interactive::format_thought_elapsed(elapsed);
+    crate::interactive::finish_thought(stream_id, thought, &elapsed_str);
+
+    if is_internal_cot(thought) {
+        if let Some(tui) = &status.tui {
+            tui.finish_thought(stream_id, thought, elapsed);
+            return;
+        }
+        let summary = format!(
+            "{muted}  • Thought for {elapsed_str}{reset} {muted}(Ctrl+T to view){reset}",
+            muted = crate::terminal_theme::ANSI_MUTED,
+            reset = crate::terminal_theme::ANSI_RESET
+        );
+        insert_permanent_lines(status, &[summary]);
+    } else {
+        let clean_note = thought
+            .strip_prefix("•")
+            .or_else(|| thought.strip_prefix("-"))
+            .unwrap_or(thought)
+            .trim();
+        let clean_note = strip_intermediate_greeting(clean_note);
+        let (tw, _) = markdown::terminal_size_or_default();
+        let width = (tw as usize).saturating_sub(2).max(20);
+        let options = textwrap::Options::new(width)
+            .initial_indent("  ")
+            .subsequent_indent("  ")
+            .break_words(true);
+        let wrapped = textwrap::fill(clean_note, &options);
+        let formatted = format!("{WHITE}{wrapped}{RESET}");
+        insert_permanent_lines(status, &[formatted]);
+    }
+}
+
+fn strip_intermediate_greeting(text: &str) -> &str {
+    let mut s = text.trim();
+    for prefix in &[
+        "สวัสดีค่ะ",
+        "สวัสดีครับ",
+        "หวัดดีค่ะ",
+        "หวัดดีครับ",
+        "สวัสดี",
+        "Hello",
+        "Hi",
+        "Hey",
+    ] {
+        if let Some(rest) = s.strip_prefix(prefix) {
+            s = rest.trim_start();
+            break;
+        }
+    }
+    if let Some(rest) = s.strip_prefix("พี่") {
+        if let Some(space_idx) = rest.find(' ') {
+            s = rest[space_idx..].trim_start();
+        }
+    } else if let Some(rest) = s.strip_prefix("คุณ") {
+        if let Some(space_idx) = rest.find(' ') {
+            s = rest[space_idx..].trim_start();
+        }
+    }
+    for emoji in &["🌿", "🍃", "✨", "🌱"] {
+        if let Some(rest) = s.strip_prefix(emoji) {
+            s = rest.trim_start();
+        }
+    }
+    let trimmed =
+        s.trim_start_matches(|c: char| c == ',' || c == '-' || c == '—' || c == ' ' || c == '•');
+    if trimmed.is_empty() { text } else { trimmed }
 }
 
 /// Inserts already ANSI-formatted `lines` as permanent content above the
@@ -979,6 +1158,10 @@ pub(super) fn print_timeline_note(status: &mut LiveStatus, thought: &str) {
 /// Falls back to plain `println!` if no inline terminal is currently live
 /// (e.g. committing before anything has rendered yet this turn).
 pub(super) fn insert_permanent_lines(status: &mut LiveStatus, lines: &[String]) {
+    if let Some(tui) = &status.tui {
+        tui.push_notice(lines.join("\n"));
+        return;
+    }
     let Some(terminal) = status.inline_tui.terminal.as_mut() else {
         // Defensive, same reasoning as `approve_cb`/`on_chunk`: this is a
         // plain `println!`, so it needs cooked mode regardless of whether
@@ -991,39 +1174,31 @@ pub(super) fn insert_permanent_lines(status: &mut LiveStatus, lines: &[String])
         return;
     };
 
-    let (tw, _) = markdown::terminal_size_or_default();
-    let width = tw as usize;
-    let mut height: u16 = 0;
-    for line in lines {
-        let stripped = strip_ansi_escapes(line);
-        let line_len = stripped.chars().filter(|&c| !is_thai_combining(c)).count();
-        let physical_lines = if width > 0 {
-            line_len.div_ceil(width)
-        } else {
-            1
-        }
-        .max(1);
-        height = height.saturating_add(physical_lines as u16);
-    }
-
     let Ok(text) = lines.join("\n").into_text() else {
         return;
     };
+    let (width, _) = markdown::terminal_size_or_default();
+    let height = wrapped_text_height(&text, width);
     let _ = terminal.insert_before(height, |buf| {
         use ratatui::widgets::Widget as _;
-        // `height` above is computed assuming lines longer than the
-        // terminal width wrap onto extra rows; without `.wrap(...)` here
-        // the `Paragraph` instead clips each source line to a single row,
-        // so a long committed line (e.g. a full shell command) reserved
-        // more rows than it painted — leaving stray blank rows behind in
-        // the scrollback. Wrapping keeps what's actually drawn in sync
-        // with what was reserved.
+        // Measure and render with the same Paragraph/Wrap implementation.
+        // Counting Rust chars here under-reserved rows for wide Unicode,
+        // emoji, ANSI-styled spans, and word-boundary wrapping, clipping the
+        // tail of otherwise complete assistant responses in scrollback.
         ratatui::widgets::Paragraph::new(text)
             .wrap(ratatui::widgets::Wrap { trim: false })
             .render(buf.area, buf);
     });
 }
 
+fn wrapped_text_height(text: &ratatui::text::Text<'_>, width: u16) -> u16 {
+    ratatui::widgets::Paragraph::new(text.clone())
+        .wrap(ratatui::widgets::Wrap { trim: false })
+        .line_count(width)
+        .max(1)
+        .min(u16::MAX as usize) as u16
+}
+
 /// Tears down the shared inline `ratatui` terminal (if one is currently
 /// live), so whatever prints next — an approval card, a committed activity
 /// snapshot, the final AI answer — starts from a clean, un-managed cursor
@@ -1033,6 +1208,10 @@ pub(super) fn insert_permanent_lines(status: &mut LiveStatus, lines: &[String])
 /// `render_live_status` call reconstructs it fresh, re-querying the
 /// terminal for where the cursor actually is now.
 pub(super) fn clear_live_status(status: &mut LiveStatus) {
+    if let Some(tui) = &status.tui {
+        tui.clear_status();
+        return;
+    }
     if status.inline_tui.terminal.is_none() {
         clear_working_status();
         return;
@@ -1092,7 +1271,46 @@ pub(super) fn activity_summary_line(
     let web_count = activities.len();
     let shell_count = tasks
         .iter()
-        .filter(|t| t.label.starts_with("[run_shell]"))
+        .filter(|t| {
+            t.label.starts_with("[run_shell]")
+                || t.label.starts_with("[shell_output]")
+                || t.label.starts_with("[kill_shell]")
+        })
+        .count();
+    let edit_count = tasks
+        .iter()
+        .filter(|t| {
+            t.label.starts_with("[write_file]")
+                || t.label.starts_with("[apply_patch]")
+                || t.label.starts_with("[note_write]")
+        })
+        .count();
+    let git_count = tasks
+        .iter()
+        .filter(|t| t.label.starts_with("[git_"))
+        .count();
+    let subagent_count = tasks
+        .iter()
+        .filter(|t| {
+            t.label.contains("[dispatch_subagent]")
+                || t.label.contains("Subagent dispatched")
+                || t.label.contains("subagent")
+        })
+        .count();
+    let other_count = tasks
+        .iter()
+        .filter(|t| {
+            !t.label.starts_with("[run_shell]")
+                && !t.label.starts_with("[shell_output]")
+                && !t.label.starts_with("[kill_shell]")
+                && !t.label.starts_with("[write_file]")
+                && !t.label.starts_with("[apply_patch]")
+                && !t.label.starts_with("[note_write]")
+                && !t.label.starts_with("[git_")
+                && !t.label.contains("[dispatch_subagent]")
+                && !t.label.contains("Subagent dispatched")
+                && !t.label.contains("subagent")
+        })
         .count();
 
     let mut parts: Vec<String> = Vec::new();
@@ -1108,6 +1326,12 @@ pub(super) fn activity_summary_line(
             if file_count == 1 { "" } else { "s" }
         ));
     }
+    if edit_count > 0 {
+        parts.push(format!(
+            "editing {edit_count} file{}",
+            if edit_count == 1 { "" } else { "s" }
+        ));
+    }
     if dir_count > 0 {
         parts.push(format!(
             "listing {dir_count} director{}",
@@ -1132,8 +1356,33 @@ pub(super) fn activity_summary_line(
             if shell_count == 1 { "" } else { "s" }
         ));
     }
+    if git_count > 0 {
+        parts.push(format!(
+            "checking repository {git_count} time{}",
+            if git_count == 1 { "" } else { "s" }
+        ));
+    }
+    if subagent_count > 0 {
+        parts.push(format!(
+            "dispatching {subagent_count} subagent{}",
+            if subagent_count == 1 { "" } else { "s" }
+        ));
+    }
+    if other_count > 0 {
+        parts.push(format!(
+            "running {other_count} tool{}",
+            if other_count == 1 { "" } else { "s" }
+        ));
+    }
 
     if parts.is_empty() {
+        let total = tasks.len() + activities.len() + explored.len();
+        if total > 0 {
+            return Some(format!(
+                "Running {total} tool{}…",
+                if total == 1 { "" } else { "s" }
+            ));
+        }
         return None;
     }
     let sentence = parts.join(", ");
@@ -1154,20 +1403,68 @@ pub(super) fn activity_block_lines(
     explored: &[ExploredAction],
     animate: bool,
     tick: usize,
+    active_tool_started: Option<Instant>,
+    // Whether to render stored command-output preview lines.
+    include_output: bool,
 ) -> Vec<String> {
     if tasks.is_empty() && activities.is_empty() && explored.is_empty() {
         return Vec::new();
     }
     let char_str = bullet_char(animate, tick);
-    let header_text =
-        activity_summary_line(tasks, activities, explored).unwrap_or_else(|| "activity".into());
+    let header_text = activity_summary_line(tasks, activities, explored)
+        .unwrap_or_else(|| "Running tools…".into());
     let mut lines = vec![format!("  {BLUE}{char_str}{RESET} {header_text}")];
-    lines.extend(tasks_lines(tasks));
-    lines.extend(activities_lines(activities));
-    lines.extend(explored_lines(explored));
+
+    // Collect all items with their output lines
+    let mut all_items: Vec<(String, Vec<String>)> = Vec::new();
+    for task in tasks.iter().take(24) {
+        all_items.push((task.label.clone(), task.output.clone()));
+    }
+    for act in activities.iter().take(24) {
+        all_items.push((act.clone(), Vec::new()));
+    }
+    let grouped = grouped_explored_actions(explored);
+    for action in grouped.into_iter().take(24) {
+        all_items.push((action, Vec::new()));
+    }
+
+    let total_items = all_items.len();
+    const SPINNER_FRAMES: &[&str] = &["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let spinner = SPINNER_FRAMES[tick % SPINNER_FRAMES.len()];
+
+    for (idx, (label, output)) in all_items.into_iter().enumerate() {
+        let is_active = animate && active_tool_started.is_some() && idx == total_items - 1;
+        let prefix = if idx == 0 {
+            format!("{DIM}    └{RESET}")
+        } else {
+            "      ".to_string()
+        };
+
+        if is_active {
+            let elapsed_secs = active_tool_started.unwrap().elapsed().as_secs_f64();
+            let timer_suffix = format!(" ({:.1}s)", elapsed_secs);
+            lines.push(format!(
+                "{prefix} {CYAN}{spinner}{RESET} {WHITE}{label}{RESET}{DIM}{timer_suffix}{RESET}"
+            ));
+        } else {
+            lines.push(format!("{prefix} {MINT}✓{RESET} {WHITE}{label}{RESET}"));
+        }
+
+        if include_output {
+            for out_line in &output {
+                lines.push(format!("{DIM}       │ {}{RESET}", out_line));
+            }
+        }
+    }
+
+    let raw_total = tasks.len() + activities.len() + explored.len();
+    if raw_total > 24 {
+        lines.push(format!("{DIM}     ... {} more{RESET}", raw_total - 24));
+    }
     lines
 }
 
+#[allow(dead_code)]
 pub(super) fn explored_lines(actions: &[ExploredAction]) -> Vec<String> {
     if actions.is_empty() {
         return Vec::new();
@@ -1178,8 +1475,12 @@ pub(super) fn explored_lines(actions: &[ExploredAction]) -> Vec<String> {
         .take(24)
         .enumerate()
         .map(|(index, action)| {
-            let prefix = if index == 0 { "    └" } else { "     " };
-            format!("{DIM}{prefix} {action}{RESET}")
+            if index == 0 {
+                // └ connector in DIM, tool text in WHITE (plain white)
+                format!("{DIM}    └{RESET} {WHITE}{action}{RESET}")
+            } else {
+                format!("      {WHITE}{action}{RESET}")
+            }
         })
         .collect();
     if grouped.len() > 24 {
@@ -1267,10 +1568,13 @@ pub(super) fn skill_names_from_memory_recall(result: &str) -> Vec<String> {
         .collect()
 }
 
-pub(super) fn skill_card(skill_name: &str) -> TaskEntry {
-    TaskEntry {
-        label: format!("Skill({skill_name})"),
-        output: vec!["Successfully loaded skill".to_string()],
+pub(super) fn skill_read_label(skill_name: &str, result: &str) -> String {
+    if result.starts_with(&format!("[Loaded skill: {skill_name}]\n")) {
+        format!("Loaded skill: {skill_name}")
+    } else if result.starts_with("Error:") || result.starts_with("Blocked") {
+        format!("Failed to read skill: {skill_name}")
+    } else {
+        format!("Read skill preview: {skill_name}")
     }
 }
 
@@ -1325,6 +1629,7 @@ pub(super) fn truncate_line(line: &str, max_chars: usize) -> String {
     format!("{head}…")
 }
 
+#[allow(dead_code)]
 pub(super) fn activities_lines(activities: &[String]) -> Vec<String> {
     if activities.is_empty() {
         return Vec::new();
@@ -1334,8 +1639,12 @@ pub(super) fn activities_lines(activities: &[String]) -> Vec<String> {
         .take(24)
         .enumerate()
         .map(|(index, act)| {
-            let prefix = if index == 0 { "    └" } else { "     " };
-            format!("{DIM}{prefix} {act}{RESET}")
+            if index == 0 {
+                // └ connector in DIM, activity text in WHITE (plain white)
+                format!("{DIM}    └{RESET} {WHITE}{act}{RESET}")
+            } else {
+                format!("      {WHITE}{act}{RESET}")
+            }
         })
         .collect();
     if activities.len() > 24 {
@@ -1396,14 +1705,19 @@ pub(super) fn plan_lines(steps: &[String], animate: bool, tick: usize) -> Vec<St
     lines
 }
 
+#[allow(dead_code)]
 pub(super) fn tasks_lines(tasks: &[TaskEntry]) -> Vec<String> {
     if tasks.is_empty() {
         return Vec::new();
     }
     let mut lines = Vec::new();
     for (index, task) in tasks.iter().take(24).enumerate() {
-        let prefix = if index == 0 { "    └" } else { "     " };
-        lines.push(format!("{DIM}{prefix} {}{RESET}", task.label));
+        if index == 0 {
+            // └ connector in DIM, task label in WHITE (plain white)
+            lines.push(format!("{DIM}    └{RESET} {WHITE}{}{RESET}", task.label));
+        } else {
+            lines.push(format!("      {WHITE}{}{RESET}", task.label));
+        }
         for out_line in &task.output {
             lines.push(format!("{DIM}       │ {}{RESET}", out_line));
         }
@@ -1452,6 +1766,18 @@ mod format_token_count_tests {
     }
 }
 
+#[cfg(test)]
+mod scrollback_layout_tests {
+    use super::*;
+
+    #[test]
+    fn scrollback_height_accounts_for_wide_unicode() {
+        let text = ratatui::text::Text::raw("🙂🙂🙂");
+
+        assert_eq!(wrapped_text_height(&text, 4), 2);
+    }
+}
+
 #[cfg(test)]
 mod project_tokens_tests {
     use super::*;
@@ -1498,3 +1824,74 @@ mod ramp_estimate_tests {
         assert_eq!(ramp_estimate(5000, 60.0), 5000);
     }
 }
+
+#[cfg(test)]
+mod context_compaction_status_tests {
+    use super::*;
+    #[test]
+    fn compaction_lifecycle_keeps_its_timer_until_success_or_failure() {
+        let now = Instant::now();
+        let mut status = LiveStatus::default();
+        update_context_compaction(&mut status, "started", None, now);
+        assert_eq!(status.compaction_started, Some(now));
+        assert_eq!(
+            compaction_label(Duration::from_secs(12)),
+            "Compacting context · 12s • Esc to interrupt"
+        );
+        for phase in ["completed", "failed"] {
+            update_context_compaction(&mut status, phase, None, now);
+            assert!(status.compaction_started.is_none());
+            update_context_compaction(&mut status, "started", None, now);
+        }
+    }
+    #[test]
+    fn compaction_gradient_moves_while_timer_and_cancel_hint_stay_plain() {
+        let label = compaction_label(Duration::from_secs(12));
+        let first = apply_wave_effect(&label, 0);
+        let next = apply_wave_effect(&label, 12);
+        assert_ne!(first, next);
+        assert!(strip_ansi_escapes(&first).ends_with(" · 12s • Esc to interrupt"));
+        assert!(strip_ansi_escapes(&next).ends_with(" · 12s • Esc to interrupt"));
+        assert_eq!(
+            first.split_once(" · ").unwrap().1,
+            next.split_once(" · ").unwrap().1
+        );
+    }
+}
+
+#[cfg(test)]
+mod parallel_compaction_tests {
+    use super::*;
+    #[test]
+    fn one_child_finishing_does_not_clear_another_child_timer() {
+        let mut status = LiveStatus::default();
+        let now = Instant::now();
+        update_context_compaction(&mut status, "started", Some("A"), now);
+        update_context_compaction(
+            &mut status,
+            "started",
+            Some("B"),
+            now + Duration::from_secs(2),
+        );
+        update_context_compaction(&mut status, "completed", Some("A"), now);
+        assert_eq!(status.compaction_started, Some(now));
+        update_context_compaction(&mut status, "failed", Some("B"), now);
+        assert!(status.compaction_started.is_none());
+    }
+}
+
+#[cfg(test)]
+mod repeated_name_compaction_tests {
+    use super::*;
+    #[test]
+    fn repeated_child_name_keeps_timer_until_both_finish() {
+        let mut status = LiveStatus::default();
+        let now = Instant::now();
+        update_context_compaction(&mut status, "started", Some("reviewer"), now);
+        update_context_compaction(&mut status, "started", Some("reviewer"), now);
+        update_context_compaction(&mut status, "completed", Some("reviewer"), now);
+        assert_eq!(status.compaction_started, Some(now));
+        update_context_compaction(&mut status, "failed", Some("reviewer"), now);
+        assert!(status.compaction_started.is_none());
+    }
+}