@pheem49/mint 1.16.0 → 1.17.0

package/crates/mint-cli/src/interactive/chat_tui.rs

@@ -390,9 +390,77 @@ pub(crate) struct ThoughtModalState {
     pub scroll: usize,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum SwarmUiStatus {
+    Running,
+    Success,
+    Failed,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct SwarmAgentUiState {
+    pub label: String,
+    pub profile: String,
+    pub task: String,
+    pub current_action: Option<String>,
+    pub status: SwarmUiStatus,
+    pub started_at: std::time::Instant,
+    pub finished_elapsed_ms: Option<u64>,
+    pub summary_preview: Option<String>,
+}
+
+fn clip_text(text: &str, width: usize) -> String {
+    if UnicodeWidthStr::width(text) <= width {
+        return text.to_owned();
+    }
+    let mut used = 0;
+    let mut clipped = String::new();
+    for ch in text.chars() {
+        let next = unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0);
+        if used + next > width.saturating_sub(1) {
+            break;
+        }
+        used += next;
+        clipped.push(ch);
+    }
+    if width > 0 {
+        clipped.push('…');
+    }
+    clipped
+}
+
+fn format_subagent_tool_action(action: &str, input: &serde_json::Value) -> String {
+    for key in [
+        "description",
+        "command",
+        "cmd",
+        "path",
+        "query",
+        "pattern",
+        "url",
+    ] {
+        if let Some(val) = input.get(key).and_then(|v| v.as_str()) {
+            if let Some(line) = val.lines().find(|l| !l.trim().is_empty()) {
+                let trimmed = line.trim();
+                if trimmed.is_empty() || trimmed.eq_ignore_ascii_case("null") {
+                    continue;
+                }
+                return match key {
+                    "command" | "cmd" => format!("Running `{trimmed}`"),
+                    "pattern" | "query" => format!("Searching for {trimmed}"),
+                    "path" => format!("Reading {trimmed}"),
+                    _ => trimmed.to_string(),
+                };
+            }
+        }
+    }
+    action.replace('_', " ")
+}
+
 #[derive(Debug, Default)]
 pub(crate) struct ChatViewState {
     pub(crate) transcript: Vec<TranscriptEntry>,
+    pub(crate) swarm_agents: Vec<SwarmAgentUiState>,
     chat_id: String,
     mods: Vec<serde_json::Value>,
     mods_open: bool,
@@ -427,6 +495,8 @@ pub(crate) struct ChatViewState {
     tool_viewer: Option<usize>,
     watermark_frame: u8,
     watermark_animating: bool,
+    pub(crate) queued_count: usize,
+    pub(crate) queued_preview: Option<String>,
     pub(crate) theme: crate::terminal_theme::TuiTheme,
 }
 
@@ -1321,6 +1391,91 @@ impl TuiHandle {
 impl ChatViewState {
     fn record_tool_progress(&mut self, progress: &mint_core::AgentProgress) -> Option<usize> {
         use mint_core::AgentProgress;
+        match progress {
+            AgentProgress::SubagentStarted {
+                subagent,
+                profile,
+                task,
+            } => {
+                if let Some(existing) = self.swarm_agents.iter_mut().find(|a| a.label == *subagent)
+                {
+                    existing.profile = profile.clone();
+                    existing.task = task.clone();
+                    existing.status = SwarmUiStatus::Running;
+                    existing.started_at = std::time::Instant::now();
+                } else {
+                    self.swarm_agents.push(SwarmAgentUiState {
+                        label: subagent.clone(),
+                        profile: profile.clone(),
+                        task: task.clone(),
+                        current_action: None,
+                        status: SwarmUiStatus::Running,
+                        started_at: std::time::Instant::now(),
+                        finished_elapsed_ms: None,
+                        summary_preview: None,
+                    });
+                }
+                return None;
+            }
+            AgentProgress::SubagentFinished {
+                subagent,
+                status,
+                elapsed_ms,
+                summary_preview,
+                ..
+            } => {
+                let ui_status = if status == "failed" {
+                    SwarmUiStatus::Failed
+                } else {
+                    SwarmUiStatus::Success
+                };
+                if let Some(existing) = self.swarm_agents.iter_mut().find(|a| a.label == *subagent)
+                {
+                    existing.status = ui_status;
+                    existing.finished_elapsed_ms = Some(*elapsed_ms);
+                    if !summary_preview.is_empty() {
+                        existing.summary_preview = Some(summary_preview.clone());
+                    }
+                } else {
+                    self.swarm_agents.push(SwarmAgentUiState {
+                        label: subagent.clone(),
+                        profile: String::new(),
+                        task: String::new(),
+                        current_action: None,
+                        status: ui_status,
+                        started_at: std::time::Instant::now(),
+                        finished_elapsed_ms: Some(*elapsed_ms),
+                        summary_preview: if summary_preview.is_empty() {
+                            None
+                        } else {
+                            Some(summary_preview.clone())
+                        },
+                    });
+                }
+                return None;
+            }
+            AgentProgress::ToolStart {
+                subagent: Some(agent_label),
+                action,
+                input,
+                ..
+            } => {
+                if let Some(agent) = self
+                    .swarm_agents
+                    .iter_mut()
+                    .find(|a| a.label == *agent_label)
+                {
+                    agent.current_action = Some(format_subagent_tool_action(action, input));
+                }
+                return None;
+            }
+            AgentProgress::ToolEnd {
+                subagent: Some(_), ..
+            } => {
+                return None;
+            }
+            _ => {}
+        }
         let (call_id, action, input, subagent, end) = match progress {
             AgentProgress::ToolStart {
                 call_id,
@@ -1485,7 +1640,8 @@ impl ChatViewState {
             if self.tools.is_empty() {
                 self.set_notice("No tool activity recorded yet");
             } else {
-                self.tool_viewer = Some(self.tools.len() - 1);
+                let target = self.preferred_tool_viewer_index();
+                self.tool_viewer = Some(target);
                 self.refresh_tool_viewer(true);
             }
             return true;
@@ -1493,22 +1649,55 @@ impl ChatViewState {
         false
     }
 
+    fn preferred_tool_viewer_index(&self) -> usize {
+        let has_recent_sources = self.transcript.iter().rev().take(6).any(|entry| {
+            entry.text.starts_with("Sources:\n") || entry.text.contains("Ctrl+O view web_search")
+        });
+
+        if has_recent_sources {
+            if let Some(pos) = self
+                .tools
+                .iter()
+                .rposition(|tool| tool.action == "web_search")
+            {
+                return pos;
+            }
+        }
+        self.tools.len() - 1
+    }
+
     fn live_thought(&self) -> Option<&ThinkingSegment> {
         self.thoughts
             .last()
             .filter(|thought| thought.updated_at.is_some() && !thought.text.trim().is_empty())
     }
 
+    fn thought_total_elapsed_label(&self) -> String {
+        if self.thoughts.iter().all(|thought| thought.elapsed_known) {
+            super::format_thought_elapsed(self.thoughts.iter().map(ThinkingSegment::elapsed).sum())
+        } else {
+            "time unavailable".into()
+        }
+    }
+
     fn thought_record(&self) -> Option<ThoughtModalState> {
-        let latest = self.thoughts.last()?;
+        self.thoughts.last()?;
         Some(ThoughtModalState {
-            elapsed_str: latest.elapsed_label(),
+            elapsed_str: self.thought_total_elapsed_label(),
             lines: self
                 .thoughts
                 .iter()
-                .map(|thought| thought.text.as_str())
+                .enumerate()
+                .map(|(index, thought)| {
+                    format!(
+                        "── Thought {} · {} ──────────────────────────\n{}",
+                        index + 1,
+                        thought.elapsed_label(),
+                        thought.text
+                    )
+                })
                 .collect::<Vec<_>>()
-                .join("\n\n── Next Step ──────────────────────────\n")
+                .join("\n\n")
                 .lines()
                 .map(str::to_owned)
                 .collect(),
@@ -1863,9 +2052,14 @@ impl ChatViewState {
         }
     }
 
-    fn push_saved_activity(&mut self, activity: Option<&serde_json::Value>, turn_status: &str) {
+    fn push_saved_activity(
+        &mut self,
+        activity: Option<&serde_json::Value>,
+        turn_status: &str,
+    ) -> Vec<(String, String)> {
+        let mut sources = Vec::new();
         let Some(events) = activity.and_then(serde_json::Value::as_array) else {
-            return;
+            return sources;
         };
         let first_tool = self.tools.len();
         for value in events {
@@ -1879,7 +2073,7 @@ impl ChatViewState {
                     mint_core::AgentProgress::ToolStart { .. } => {
                         self.record_tool_progress(&event);
                     }
-                    mint_core::AgentProgress::ToolEnd { .. } => {
+                    mint_core::AgentProgress::ToolEnd { action, result, .. } => {
                         if let Some(index) = self.record_tool_progress(&event) {
                             self.tools[index].elapsed = value["data"]["elapsed_ms"]
                                 .as_u64()
@@ -1887,6 +2081,16 @@ impl ChatViewState {
                                 .map(std::time::Duration::from_millis);
                             self.refresh_tool_card(index);
                         }
+                        if action == "web_search"
+                            && !result.starts_with("Web search error:")
+                            && result != "No web search results found."
+                        {
+                            sources.extend(crate::agent::parse_web_search_sources(result));
+                        }
+                    }
+                    mint_core::AgentProgress::SubagentStarted { .. }
+                    | mint_core::AgentProgress::SubagentFinished { .. } => {
+                        self.record_tool_progress(&event);
                     }
                     mint_core::AgentProgress::ExtendedThinking {
                         id,
@@ -1923,9 +2127,12 @@ impl ChatViewState {
                     _ => {}
                 }
             }
-            if let Some(notes) = crate::agent::mcp_progress_notes(&event) {
-                for note in notes {
-                    self.push_notice(note);
+            // Suppress redundant ExecutionUpdate notices in TUI (handled by ToolActivity cards)
+            if !matches!(event, mint_core::AgentProgress::ExecutionUpdate { .. }) {
+                if let Some(notes) = crate::agent::mcp_progress_notes(&event) {
+                    for note in notes {
+                        self.push_notice(note);
+                    }
                 }
             }
         }
@@ -1939,6 +2146,7 @@ impl ChatViewState {
                 self.refresh_tool_card(index);
             }
         }
+        sources
     }
 
     pub fn reload_transcript_with(
@@ -1970,11 +2178,22 @@ impl ChatViewState {
             for row in rows {
                 self.transcript
                     .push(TranscriptEntry::new(TranscriptRole::User, row.user_text));
-                self.push_saved_activity(row.agent_activity.as_ref(), &row.status);
+                let sources = self.push_saved_activity(row.agent_activity.as_ref(), &row.status);
                 match row.status.as_str() {
-                    "completed" => self
-                        .transcript
-                        .push(TranscriptEntry::new(TranscriptRole::Assistant, row.ai_text)),
+                    "completed" => {
+                        self.transcript
+                            .push(TranscriptEntry::new(TranscriptRole::Assistant, row.ai_text));
+                        if !sources.is_empty() {
+                            let text = crate::agent::format_tui_web_sources(
+                                &sources,
+                                crate::agent::MAX_TUI_WEB_SOURCES,
+                            );
+                            if !text.is_empty() {
+                                self.transcript
+                                    .push(TranscriptEntry::new(TranscriptRole::Notice, text));
+                            }
+                        }
+                    }
                     "queued" => self.transcript.push(TranscriptEntry::new(
                         TranscriptRole::Notice,
                         "Queued for this session…",
@@ -2064,12 +2283,24 @@ impl ChatViewState {
                 // Incoming new interaction from an external client (Web/Desktop)
                 self.transcript
                     .push(TranscriptEntry::new(TranscriptRole::User, &row.user_text));
-                self.push_saved_activity(row.agent_activity.as_ref(), &row.status);
+                let sources = self.push_saved_activity(row.agent_activity.as_ref(), &row.status);
                 match row.status.as_str() {
-                    "completed" => self.transcript.push(TranscriptEntry::new(
-                        TranscriptRole::Assistant,
-                        &row.ai_text,
-                    )),
+                    "completed" => {
+                        self.transcript.push(TranscriptEntry::new(
+                            TranscriptRole::Assistant,
+                            &row.ai_text,
+                        ));
+                        if !sources.is_empty() {
+                            let text = crate::agent::format_tui_web_sources(
+                                &sources,
+                                crate::agent::MAX_TUI_WEB_SOURCES,
+                            );
+                            if !text.is_empty() {
+                                self.transcript
+                                    .push(TranscriptEntry::new(TranscriptRole::Notice, text));
+                            }
+                        }
+                    }
                     "queued" => self.transcript.push(TranscriptEntry::new(
                         TranscriptRole::Notice,
                         "Queued for this session…",
@@ -2105,11 +2336,22 @@ impl ChatViewState {
                         }
                     }
                     if append {
-                        self.push_saved_activity(row.agent_activity.as_ref(), &row.status);
+                        let sources =
+                            self.push_saved_activity(row.agent_activity.as_ref(), &row.status);
                         self.transcript.push(TranscriptEntry::new(
                             TranscriptRole::Assistant,
                             &row.ai_text,
                         ));
+                        if !sources.is_empty() {
+                            let text = crate::agent::format_tui_web_sources(
+                                &sources,
+                                crate::agent::MAX_TUI_WEB_SOURCES,
+                            );
+                            if !text.is_empty() {
+                                self.transcript
+                                    .push(TranscriptEntry::new(TranscriptRole::Notice, text));
+                            }
+                        }
                         changed = true;
                     }
                 } else if row.status == "running" {
@@ -2149,6 +2391,7 @@ impl ChatViewState {
         self.transcript
             .push(TranscriptEntry::new(TranscriptRole::User, text));
         self.scroll_from_bottom = 0;
+        self.swarm_agents.clear();
     }
     pub fn push_notice(&mut self, text: impl Into<String>) {
         self.transcript
@@ -2163,6 +2406,7 @@ impl ChatViewState {
     pub fn clear_transcript(&mut self) {
         self.transcript.clear();
         self.tools.clear();
+        self.swarm_agents.clear();
         if self
             .dialog
             .as_ref()
@@ -2698,6 +2942,25 @@ impl ChatViewState {
         let composer_scroll = cursor_row
             .saturating_add(1)
             .saturating_sub(visible_composer_rows);
+        let swarm_height = if self.swarm_agents.is_empty()
+            || self.dialog.is_some()
+            || self.thought_modal.is_some()
+        {
+            0
+        } else {
+            let max_avail = main_area
+                .height
+                .saturating_sub(6 + 3 + status_height + suggestion_height + composer_height + 1);
+            if max_avail == 0 {
+                0
+            } else if main_area.height < 24 || max_avail < 3 {
+                1
+            } else {
+                let needed = (self.swarm_agents.len().min(5) as u16) + 2;
+                needed.min(max_avail)
+            }
+        };
+
         let rows = if dialog_height > 0 {
             let dialog_status_height =
                 status_height.min(main_area.height.saturating_sub(6 + 1 + dialog_height));
@@ -2729,6 +2992,7 @@ impl ChatViewState {
                     Constraint::Length(status_height),
                     Constraint::Length(suggestion_height),
                     Constraint::Length(composer_height),
+                    Constraint::Length(swarm_height),
                     Constraint::Length(1),
                 ])
                 .split(main_area)
@@ -3054,18 +3318,58 @@ impl ChatViewState {
                 let title_height = Paragraph::new(lines.clone())
                     .wrap(Wrap { trim: false })
                     .line_count(width);
-                let body = Paragraph::new(
+                let command_line_count = if dialog.title == "Local shell command"
+                    && dialog.body.starts_with("Command: ")
+                {
+                    dialog
+                        .body
+                        .rfind("\nMode: ")
+                        .map_or(0, |end| dialog.body[..end].lines().count())
+                } else {
+                    0
+                };
+                let detail_lines = self
+                    .tool_viewer
+                    .and_then(|index| self.tools.get(index))
+                    .map(|tool| {
+                        tool.detail_lines()
+                            .into_iter()
+                            .map(|mut line| {
+                                line.spans.insert(0, Span::raw(" "));
+                                line
+                            })
+                            .collect::<Vec<_>>()
+                    });
+                let body = Paragraph::new(detail_lines.unwrap_or_else(|| {
                     dialog
                         .body
                         .lines()
-                        .map(|line| {
+                        .enumerate()
+                        .map(|(index, line)| {
+                            if index < command_line_count {
+                                let (label, command) = if index == 0 {
+                                    (" Command: ", &line["Command: ".len()..])
+                                } else {
+                                    (" ", line)
+                                };
+                                return Line::from(vec![
+                                    Span::styled(
+                                        label,
+                                        Style::default().fg(crate::terminal_theme::TEXT),
+                                    ),
+                                    Span::styled(
+                                        command,
+                                        Style::default().fg(crate::terminal_theme::ACCENT),
+                                    ),
+                                ]);
+                            }
                             Line::styled(
                                 format!(" {line}"),
                                 Style::default().fg(crate::terminal_theme::TEXT),
                             )
                         })
-                        .collect::<Vec<_>>(),
-                )
+                        .collect::<Vec<_>>()
+                }))
                 .wrap(Wrap { trim: false });
                 let body_lines = if dialog.body.is_empty() {
                     0
@@ -3073,7 +3377,7 @@ impl ChatViewState {
                     body.line_count(width)
                 };
                 let hint = if self.tool_viewer.is_some() {
-                    " PgUp/PgDn scroll · Tab next · Ctrl+Y copy all · Esc close"
+                    " Shift+Tab previous · Tab next (wraps)\n PgUp/PgDn scroll · Ctrl+Y copy all · Esc/Ctrl+O close"
                 } else if dialog.update_prompt {
                     " ↑/↓ navigate · 1-3 choose · Enter continue · Esc skip"
                 } else if dialog.input.is_some() {
@@ -3107,7 +3411,8 @@ impl ChatViewState {
                 let fixed_height = title_height + filter_height + 1 + option_height;
                 let body_overflows =
                     body_lines > inner_height.saturating_sub(fixed_height + normal_footer_height);
-                let hint = if body_overflows && dialog.input.is_none() {
+                let hint = if body_overflows && dialog.input.is_none() && self.tool_viewer.is_none()
+                {
                     if dialog.checked.is_some() {
                         " Space toggle · Enter confirm · Esc cancel"
                     } else {
@@ -3341,10 +3646,9 @@ impl ChatViewState {
                     if !body_overflows {
                         lines.push(Line::raw(""));
                     }
-                    lines.push(Line::styled(
-                        hint,
-                        Style::default().fg(crate::terminal_theme::MUTED),
-                    ));
+                    lines.extend(hint.lines().map(|line| {
+                        Line::styled(line, Style::default().fg(crate::terminal_theme::MUTED))
+                    }));
                     if !body_overflows {
                         lines.push(Line::raw(""));
                     }
@@ -3386,16 +3690,18 @@ impl ChatViewState {
         } else if let Some(modal) = &self.thought_modal {
             let panel_area = rows[3];
             let content_width = (panel_area.width as usize).saturating_sub(4).max(20);
-            let mut wrapped_lines: Vec<String> = Vec::new();
+            let mut wrapped_lines: Vec<(String, bool)> = Vec::new();
             for paragraph in &modal.lines {
                 let p_trimmed = paragraph.trim_end();
+                let separator = p_trimmed.starts_with("── Thought ")
+                    && p_trimmed.ends_with(" ──────────────────────────");
                 if p_trimmed.is_empty() {
-                    wrapped_lines.push(String::new());
+                    wrapped_lines.push((String::new(), false));
                 } else {
                     let options = textwrap::Options::new(content_width).break_words(true);
                     let filled = textwrap::fill(p_trimmed, &options);
                     for l in filled.lines() {
-                        wrapped_lines.push(l.to_string());
+                        wrapped_lines.push((l.to_string(), separator));
                     }
                 }
             }
@@ -3404,41 +3710,56 @@ impl ChatViewState {
             let max_scroll = wrapped_lines.len().saturating_sub(inner_height);
             let scroll = modal.scroll.min(max_scroll);
 
-            let scroll_hint = if max_scroll > 0 {
-                format!(
-                    " ↑/↓ scroll {}/{} · Esc / Ctrl+T to close ",
+            let key_style = Style::default().fg(crate::terminal_theme::BLUE);
+            let mut hint_spans = Vec::new();
+            if max_scroll > 0 {
+                hint_spans.push(Span::styled(" ↑/↓", key_style));
+                hint_spans.push(Span::raw(format!(
+                    " scroll {}/{} ·",
                     scroll + 1,
                     max_scroll + 1
-                )
-            } else {
-                " Esc / Ctrl+T to close ".to_string()
-            };
+                )));
+            }
+            hint_spans.extend([
+                Span::styled(" Esc", key_style),
+                Span::raw(" / "),
+                Span::styled("Ctrl+T", key_style),
+                Span::raw(" to close "),
+            ]);
+            let scroll_hint =
+                Line::from(hint_spans).style(Style::default().fg(crate::terminal_theme::MUTED));
 
             let block = Block::default()
                 .borders(Borders::TOP)
                 .border_style(Style::default().fg(crate::terminal_theme::BLUE))
                 .title(Span::styled(
                     format!(
-                        " Thought Process ({}) ",
-                        self.live_thought()
-                            .map(|thought| super::format_thought_elapsed(thought.elapsed()))
-                            .unwrap_or_else(|| modal.elapsed_str.clone())
+                        " Thought Process · {} ",
+                        if self.thoughts.is_empty() {
+                            modal.elapsed_str.clone()
+                        } else {
+                            self.thought_total_elapsed_label()
+                        }
                     ),
                     Style::default()
                         .fg(crate::terminal_theme::BLUE)
                         .add_modifier(Modifier::BOLD),
                 ))
-                .title_bottom(Span::styled(
-                    scroll_hint,
-                    Style::default().fg(crate::terminal_theme::MUTED),
-                ));
+                .title_bottom(scroll_hint);
 
             let visible = &wrapped_lines[scroll..(scroll + inner_height).min(wrapped_lines.len())];
             let mut p_lines: Vec<Line> = Vec::with_capacity(inner_height);
-            for l in visible {
+            for (l, separator) in visible {
                 p_lines.push(Line::from(vec![
                     Span::raw(" "),
-                    Span::styled(l.clone(), Style::default().fg(crate::terminal_theme::TEXT)),
+                    Span::styled(
+                        l.clone(),
+                        Style::default().fg(if *separator {
+                            crate::terminal_theme::ACCENT
+                        } else {
+                            crate::terminal_theme::TEXT
+                        }),
+                    ),
                 ]));
             }
             for _ in visible.len()..inner_height {
@@ -3534,6 +3855,32 @@ impl ChatViewState {
             if !self.collapsed_pastes.is_empty() || self.expanded_paste.is_some() {
                 input_block = input_block.title_bottom(" F2: open/collapse paste ");
             }
+            if self.queued_count > 0 {
+                let preview = self
+                    .queued_preview
+                    .as_deref()
+                    .unwrap_or("")
+                    .chars()
+                    .take(30)
+                    .collect::<String>();
+                let text = if preview.is_empty() {
+                    format!(" Queued ({}) · Ctrl+D drop ", self.queued_count)
+                } else {
+                    format!(
+                        " Queued ({}): \"{}\" · Ctrl+D drop ",
+                        self.queued_count, preview
+                    )
+                };
+                input_block = input_block.title_bottom(
+                    Line::styled(
+                        text,
+                        Style::default()
+                            .fg(crate::terminal_theme::ACCENT)
+                            .add_modifier(Modifier::BOLD),
+                    )
+                    .alignment(ratatui::layout::Alignment::Left),
+                );
+            }
             // Rows already wrap at the content width. A second word-wrap
             // pass would change blank-row and cursor/scroll positions.
             frame.render_widget(
@@ -3543,6 +3890,209 @@ impl ChatViewState {
                 rows[4],
             );
 
+            if rows[5].height > 0 {
+                if rows[5].height == 1 {
+                    let running_count = self
+                        .swarm_agents
+                        .iter()
+                        .filter(|a| a.status == SwarmUiStatus::Running)
+                        .count();
+                    const SPINNER_CHARS: &[char] =
+                        &['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+                    let spinner = SPINNER_CHARS[tick % SPINNER_CHARS.len()];
+                    let line = if running_count > 0 {
+                        Line::from(vec![
+                            Span::styled(
+                                format!(" {spinner} "),
+                                Style::default()
+                                    .fg(crate::terminal_theme::BLUE)
+                                    .add_modifier(Modifier::BOLD),
+                            ),
+                            Span::styled(
+                                format!(
+                                    "Running {running_count} subagent{} ({}/{} completed)",
+                                    if running_count == 1 { "" } else { "s" },
+                                    self.swarm_agents.len() - running_count,
+                                    self.swarm_agents.len(),
+                                ),
+                                Style::default().fg(crate::terminal_theme::TEXT),
+                            ),
+                        ])
+                    } else {
+                        Line::from(vec![
+                            Span::styled(
+                                " ✓ ",
+                                Style::default()
+                                    .fg(crate::terminal_theme::ACCENT)
+                                    .add_modifier(Modifier::BOLD),
+                            ),
+                            Span::styled(
+                                format!("{} subagents finished", self.swarm_agents.len()),
+                                Style::default().fg(crate::terminal_theme::MUTED),
+                            ),
+                        ])
+                    };
+                    frame.render_widget(Paragraph::new(line), rows[5]);
+                } else {
+                    let any_running = self
+                        .swarm_agents
+                        .iter()
+                        .any(|a| a.status == SwarmUiStatus::Running);
+                    let block = Block::default()
+                        .borders(Borders::ALL)
+                        .border_style(Style::default().fg(crate::terminal_theme::MUTED))
+                        .title(Span::styled(
+                            if any_running {
+                                " Running Subagents "
+                            } else {
+                                " Subagents "
+                            },
+                            Style::default()
+                                .fg(if any_running {
+                                    crate::terminal_theme::BLUE
+                                } else {
+                                    crate::terminal_theme::TEXT
+                                })
+                                .add_modifier(Modifier::BOLD),
+                        ));
+
+                    const SPINNER_CHARS: &[char] =
+                        &['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+                    let spinner = SPINNER_CHARS[tick % SPINNER_CHARS.len()];
+                    let inner_width = (rows[5].width as usize).saturating_sub(2);
+                    let max_items = (rows[5].height as usize).saturating_sub(2);
+                    let total_agents = self.swarm_agents.len();
+                    let has_overflow = total_agents > max_items;
+                    let take_count = if has_overflow {
+                        max_items.saturating_sub(1)
+                    } else {
+                        max_items.min(total_agents)
+                    };
+
+                    let mut lines = Vec::new();
+                    for a in self.swarm_agents.iter().take(take_count) {
+                        let (icon_span, icon_width) = match a.status {
+                            SwarmUiStatus::Running => (
+                                Span::styled(
+                                    format!("  {spinner} "),
+                                    Style::default()
+                                        .fg(crate::terminal_theme::BLUE)
+                                        .add_modifier(Modifier::BOLD),
+                                ),
+                                4,
+                            ),
+                            SwarmUiStatus::Success => (
+                                Span::styled(
+                                    "  ✓ ",
+                                    Style::default()
+                                        .fg(crate::terminal_theme::ACCENT)
+                                        .add_modifier(Modifier::BOLD),
+                                ),
+                                4,
+                            ),
+                            SwarmUiStatus::Failed => (
+                                Span::styled(
+                                    "  ✗ ",
+                                    Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),
+                                ),
+                                4,
+                            ),
+                        };
+
+                        let label_str = format!("[{}] ", a.label);
+                        let label_width = UnicodeWidthStr::width(label_str.as_str());
+                        let label_span = Span::styled(
+                            label_str,
+                            Style::default()
+                                .fg(crate::terminal_theme::ACCENT)
+                                .add_modifier(Modifier::BOLD),
+                        );
+
+                        let suffix_str = match a.status {
+                            SwarmUiStatus::Running => {
+                                let secs = a.started_at.elapsed().as_secs();
+                                if secs < 60 {
+                                    format!(" · {secs}s")
+                                } else {
+                                    format!(" · {}m {}s", secs / 60, secs % 60)
+                                }
+                            }
+                            SwarmUiStatus::Success => {
+                                let ms = a.finished_elapsed_ms.unwrap_or(0);
+                                let secs = (ms / 1000).max(1);
+                                if secs < 60 {
+                                    format!(" · done {secs}s")
+                                } else {
+                                    format!(" · done {}m {}s", secs / 60, secs % 60)
+                                }
+                            }
+                            SwarmUiStatus::Failed => {
+                                let ms = a.finished_elapsed_ms.unwrap_or(0);
+                                let secs = (ms / 1000).max(1);
+                                if secs < 60 {
+                                    format!(" · failed {secs}s")
+                                } else {
+                                    format!(" · failed {}m {}s", secs / 60, secs % 60)
+                                }
+                            }
+                        };
+                        let suffix_width = UnicodeWidthStr::width(suffix_str.as_str());
+
+                        let desc = if a.status == SwarmUiStatus::Success
+                            && a.summary_preview.as_deref().is_some_and(|p| !p.is_empty())
+                        {
+                            a.summary_preview.as_deref().unwrap()
+                        } else if let Some(act) = a
+                            .current_action
+                            .as_deref()
+                            .filter(|s| !s.is_empty() && !s.eq_ignore_ascii_case("null"))
+                        {
+                            act
+                        } else if !a.task.is_empty() && !a.task.eq_ignore_ascii_case("null") {
+                            &a.task
+                        } else {
+                            "Working on task..."
+                        };
+
+                        let prefix_width = icon_width + label_width;
+                        let avail_for_desc =
+                            inner_width.saturating_sub(prefix_width + suffix_width + 1);
+                        let clipped_desc = clip_text(desc, avail_for_desc);
+                        let used_width = prefix_width
+                            + UnicodeWidthStr::width(clipped_desc.as_str())
+                            + suffix_width;
+                        let gap = inner_width.saturating_sub(used_width);
+
+                        lines.push(Line::from(vec![
+                            icon_span,
+                            label_span,
+                            Span::styled(
+                                clipped_desc,
+                                Style::default().fg(crate::terminal_theme::TEXT),
+                            ),
+                            Span::raw(" ".repeat(gap)),
+                            Span::styled(
+                                suffix_str,
+                                Style::default().fg(crate::terminal_theme::MUTED),
+                            ),
+                        ]));
+                    }
+
+                    if has_overflow {
+                        let overflow_count = total_agents - take_count;
+                        lines.push(Line::from(vec![
+                            Span::raw("      "),
+                            Span::styled(
+                                format!("+{overflow_count} more subagents..."),
+                                Style::default().fg(crate::terminal_theme::MUTED),
+                            ),
+                        ]));
+                    }
+
+                    frame.render_widget(Paragraph::new(lines).block(block), rows[5]);
+                }
+            }
+
             let mode_label = if self.plan_mode {
                 " [Plan] "
             } else {
@@ -3555,7 +4105,7 @@ impl ChatViewState {
                 + thinking_text.chars().count()
                 + 1;
             let right_len = path_text.chars().count();
-            let available = rows[5].width as usize;
+            let available = rows[6].width as usize;
             let gap = available.saturating_sub(left_len + right_len);
             let footer = if let Some(notice) = self.active_notice() {
                 Line::styled(
@@ -3590,7 +4140,7 @@ impl ChatViewState {
                     Span::styled(path_text, Style::default().fg(crate::terminal_theme::MUTED)),
                 ])
             };
-            frame.render_widget(Paragraph::new(footer), rows[5]);
+            frame.render_widget(Paragraph::new(footer), rows[6]);
 
             if !self.selection_mode {
                 let row_start = self.cursor.saturating_sub(cursor_col);
@@ -3622,7 +4172,9 @@ impl ChatViewState {
                 main_area.x,
                 main_area.y + 6,
                 main_area.width,
-                main_area.height.saturating_sub(6 + composer_height + 1),
+                main_area
+                    .height
+                    .saturating_sub(6 + composer_height + swarm_height + 1),
             ));
             frame.render_widget(ratatui::widgets::Clear, area);
             let mut lines = crate::mods_ui::slot_lines(&self.mods, "side_panel");
@@ -5302,6 +5854,18 @@ impl ChatTui {
             }
         }
     }
+    pub fn run_onboard_wizard(&mut self, config: &mut mint_core::MintConfig) -> Result<bool> {
+        let mut wizard = crate::onboard::OnboardWizard::new(config.clone());
+        let outcome = wizard.run_with_terminal(&mut self.terminal)?;
+        match outcome {
+            crate::onboard::OnboardOutcome::SavedAndLaunch
+            | crate::onboard::OnboardOutcome::SavedAndExit => {
+                *config = wizard.take_config();
+                Ok(true)
+            }
+            crate::onboard::OnboardOutcome::Cancelled => Ok(false),
+        }
+    }
     pub async fn drive_agent<T: Send + 'static>(
         &mut self,
         handle: &TuiHandle,
@@ -5310,6 +5874,10 @@ impl ChatTui {
         use event::{KeyCode, KeyModifiers};
         loop {
             if let Ok(mut state) = handle.state.lock() {
+                if let Ok(queued) = handle.queued.lock() {
+                    state.queued_count = queued.len();
+                    state.queued_preview = queued.last().cloned();
+                }
                 self.scroll_mouse_selection(&mut state);
                 self.draw_state(&state)?;
             }
@@ -5317,6 +5885,8 @@ impl ChatTui {
                 if let Ok(mut state) = handle.state.lock() {
                     state.finish_live_thought();
                     state.finish_running_tools();
+                    state.queued_count = 0;
+                    state.queued_preview = None;
                 }
                 return Ok(task.await?);
             }
@@ -5385,6 +5955,15 @@ impl ChatTui {
                                 continue;
                             }
                             match key.code {
+                                KeyCode::Char('d')
+                                    if key.modifiers.contains(KeyModifiers::CONTROL) =>
+                                {
+                                    if let Ok(mut queued) = handle.queued.lock() {
+                                        queued.pop();
+                                        state.queued_count = queued.len();
+                                        state.queued_preview = queued.last().cloned();
+                                    }
+                                }
                                 KeyCode::Up | KeyCode::Down | KeyCode::Home | KeyCode::End
                                     if state.navigate_composer(key, composer_width) => {}
                                 KeyCode::End => state.scroll_from_bottom = 0,
@@ -5393,6 +5972,8 @@ impl ChatTui {
                                         let text = state.take_prompt();
                                         if let Ok(mut queued) = handle.queued.lock() {
                                             queued.push(text);
+                                            state.queued_count = queued.len();
+                                            state.queued_preview = queued.last().cloned();
                                         }
                                     }
                                 }
@@ -5496,14 +6077,14 @@ mod dialog_tests {
                 .map(|entry| entry.text.as_str())
                 .collect::<Vec<_>>()
                 .join("\n");
-            assert!(text.contains("Shell failed · 3.4s · exit 2"));
+            assert!(text.contains("run_shell failed · 3.4s · exit 2"));
             assert_eq!(text.matches("Thought · 1.9s").count(), 1);
-            assert!(text.contains("Completed with 1 failure"));
+            assert!(text.contains("✗ Failed"));
             assert!(text.contains("16.2s"));
             assert!(!state.tools[0].running());
             assert!(state.handle_thought_key(ctrl_t()));
             assert_eq!(
-                state.thought_modal.as_ref().unwrap().lines,
+                state.thought_modal.as_ref().unwrap().lines[1..],
                 vec!["Saved reasoning"]
             );
             state.handle_thought_key(make_key(KeyCode::Esc));
@@ -5558,6 +6139,29 @@ mod dialog_tests {
         std::fs::remove_dir_all(root).unwrap();
     }
 
+    #[test]
+    fn resume_restores_web_search_sources_in_transcript() {
+        let (root, memory) = saved_activity_fixture(
+            serde_json::json!([
+                {"type":"ToolStart","data":{"callId":"call_1","action":"web_search","input":{"query":"rust ratatui"}}},
+                {"type":"ToolEnd","data":{"callId":"call_1","action":"web_search","input":{"query":"rust ratatui"},"result":"1. Ratatui Docs\n   URL: https://ratatui.rs\n   Terminal UI library"}}
+            ]),
+            "completed",
+        );
+        let mut state = ChatViewState::default();
+        state.reload_transcript_with(&memory, "resume-details", &root);
+        let sources_entry = state.transcript.iter().find(|entry| {
+            entry.role == TranscriptRole::Notice && entry.text.starts_with("Sources:\n")
+        });
+        assert!(
+            sources_entry.is_some(),
+            "Sources notice should be reconstructed upon resume"
+        );
+        let text = &sources_entry.unwrap().text;
+        assert!(text.contains("1. Ratatui Docs\n   https://ratatui.rs"));
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
     #[test]
     fn resume_interrupted_activity_keeps_partial_thought_and_never_restarts_spinner() {
         let events: Vec<mint_core::AgentProgress> = serde_json::from_value(serde_json::json!([
@@ -5577,7 +6181,7 @@ mod dialog_tests {
         assert!(super::super::tool_activity::running_lines(&state.tools, 80, 0).is_empty());
         assert!(state.handle_thought_key(ctrl_t()));
         assert_eq!(
-            state.thought_modal.as_ref().unwrap().lines,
+            state.thought_modal.as_ref().unwrap().lines[1..],
             vec!["unfinished reasoning"]
         );
         state.reload_transcript_with(&memory, "another-session", &root);
@@ -5689,6 +6293,39 @@ mod dialog_tests {
         assert!(rendered.contains("Sample attachment unavailable"));
     }
 
+    #[test]
+    fn tui_suppresses_redundant_execution_update_notices() {
+        use mint_core::{ExecutionEvidence, ExecutionState};
+        let state = Arc::new(Mutex::new(ChatViewState::default()));
+        let tui = TuiHandle {
+            state: Arc::clone(&state),
+            interrupted: Arc::new(AtomicBool::new(false)),
+            queued: Arc::new(Mutex::new(Vec::new())),
+        };
+        let update = mint_core::AgentProgress::ExecutionUpdate {
+            call_id: "test".into(),
+            executions: vec![ExecutionEvidence {
+                call_id: "test1".into(),
+                command: "ls -la".into(),
+                state: ExecutionState::Succeeded,
+                exit_code: Some(0),
+                job_id: None,
+                revision: 1,
+                check: false,
+                condition_verified: None,
+            }],
+        };
+        let published = crate::agent::publish_mcp_progress(Some(&tui), &update);
+        assert!(!published, "ExecutionUpdate should be suppressed in TUI");
+        let transcript = state.lock().unwrap().transcript.clone();
+        assert!(
+            !transcript
+                .iter()
+                .any(|entry| entry.text.contains("[Command]")),
+            "TUI transcript must not receive redundant [Command] notices"
+        );
+    }
+
     #[test]
     fn mint_watermark_frames_fit_available_terminal_height() {
         for height in [3, 7, WATERMARK_HEIGHT as usize] {
@@ -6765,7 +7402,7 @@ mod dialog_tests {
         let state = state.lock().unwrap();
         assert_eq!(state.transcript.len(), 3);
         let screen = thought_screen(&state, 100, 30).join("\n");
-        assert!(screen.contains("Shell completed"));
+        assert!(screen.contains("run_shell completed"));
         assert!(screen.contains("Running 2 tasks · 1 shell command · 1 tool"));
         assert!(!screen.contains("stdout:"));
     }
@@ -6804,7 +7441,7 @@ mod dialog_tests {
         let state = state.lock().unwrap();
         assert_eq!(state.transcript.len(), 2);
         assert_eq!(
-            state.transcript[1].rendered_lines[0].style.fg,
+            state.transcript[1].rendered_lines[0].spans[0].style.fg,
             Some(Color::Red)
         );
         assert!(
@@ -6872,6 +7509,10 @@ mod dialog_tests {
             assert_eq!(text.matches("first complete").count(), 1);
             assert_eq!(text.matches("second complete").count(), 1);
             assert!(!text.contains("partial"));
+            let screen = thought_screen(&state, 100, 30).join("\n");
+            assert!(screen.contains("Thought Process · 3.0s"), "{screen}");
+            assert!(screen.contains("Thought 1 · 1.0s"), "{screen}");
+            assert!(screen.contains("Thought 2 · 2.0s"), "{screen}");
             assert_eq!(state.transcript.len(), 2);
         }
         handle.reset_thoughts();
@@ -6953,7 +7594,7 @@ mod dialog_tests {
         assert_eq!(state.transcript.len(), 1);
         assert!(state.handle_thought_key(ctrl_t()));
         assert_eq!(
-            state.thought_modal.as_ref().unwrap().lines,
+            state.thought_modal.as_ref().unwrap().lines[1..],
             vec!["complete reasoning"]
         );
     }
@@ -6967,7 +7608,7 @@ mod dialog_tests {
         handle.append_thought_delta("one", " second", std::time::Duration::from_secs(1));
         let mut state = state.lock().unwrap();
         assert_eq!(
-            state.thought_modal.as_ref().unwrap().lines,
+            state.thought_modal.as_ref().unwrap().lines[1..],
             vec!["first second"]
         );
         assert!(state.handle_thought_key(make_key(KeyCode::Esc)));
@@ -6993,12 +7634,26 @@ mod dialog_tests {
         );
         assert!(state.handle_thought_key(ctrl_t()));
         assert_eq!(
-            state.thought_modal.as_ref().unwrap().lines,
+            state.thought_modal.as_ref().unwrap().lines[1..],
             vec!["unfinished reasoning"]
         );
         assert_eq!(state.transcript.len(), 1);
     }
 
+    #[test]
+    fn queued_message_shows_in_composer_bottom_title() {
+        let mut state = ChatViewState::default();
+        state.queued_count = 1;
+        state.queued_preview = Some("run next test".into());
+        let rendered = thought_screen(&state, 80, 24).join("\n");
+        assert!(rendered.contains("Queued (1): \"run next test\" · Ctrl+D drop"));
+
+        state.queued_count = 2;
+        state.queued_preview = Some("deploy app".into());
+        let rendered2 = thought_screen(&state, 80, 24).join("\n");
+        assert!(rendered2.contains("Queued (2): \"deploy app\" · Ctrl+D drop"));
+    }
+
     #[test]
     fn update_dialog_requires_explicit_selection_before_installing() {
         let (tx, _rx) = mpsc::channel();
@@ -7851,3 +8506,350 @@ mod mod_surface_tests {
         assert!(text.contains("Write tests"));
     }
 }
+
+#[cfg(test)]
+mod swarm_panel_tests {
+    use super::*;
+
+    #[test]
+    fn swarm_panel_is_hidden_when_empty() {
+        let state = ChatViewState::default();
+        let backend = ratatui::backend::TestBackend::new(100, 30);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|frame| {
+                state.render(frame);
+            })
+            .unwrap();
+        let text = terminal
+            .backend()
+            .buffer()
+            .content
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
+        assert!(!text.contains("Subagents"));
+    }
+
+    #[test]
+    fn swarm_panel_renders_running_and_completed_subagents() {
+        let mut state = ChatViewState::default();
+        state.swarm_agents.push(SwarmAgentUiState {
+            label: "recon".to_string(),
+            profile: "explorer".to_string(),
+            task: "Searching for payment webhook endpoints...".to_string(),
+            current_action: None,
+            status: SwarmUiStatus::Running,
+            started_at: std::time::Instant::now(),
+            finished_elapsed_ms: None,
+            summary_preview: None,
+        });
+        state.swarm_agents.push(SwarmAgentUiState {
+            label: "config".to_string(),
+            profile: "explorer".to_string(),
+            task: "Checking config files".to_string(),
+            current_action: None,
+            status: SwarmUiStatus::Success,
+            started_at: std::time::Instant::now(),
+            finished_elapsed_ms: Some(3000),
+            summary_preview: Some("Checked stripe API keys in .env".to_string()),
+        });
+
+        let backend = ratatui::backend::TestBackend::new(100, 30);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|frame| {
+                state.render(frame);
+            })
+            .unwrap();
+        let text = terminal
+            .backend()
+            .buffer()
+            .content
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
+        assert!(text.contains("Running Subagents"));
+        assert!(text.contains("[recon]"));
+        assert!(text.contains("Searching for payment webhook endpoints..."));
+        assert!(text.contains("[config]"));
+        assert!(text.contains("Checked stripe API keys in .env"));
+        assert!(text.contains("done 3s"));
+    }
+
+    #[test]
+    fn swarm_panel_handles_more_than_5_subagents_with_overflow() {
+        let mut state = ChatViewState::default();
+        for i in 1..=7 {
+            state.swarm_agents.push(SwarmAgentUiState {
+                label: format!("agent-{}", i),
+                profile: "explorer".to_string(),
+                task: format!("Task description for agent {}", i),
+                current_action: None,
+                status: SwarmUiStatus::Running,
+                started_at: std::time::Instant::now(),
+                finished_elapsed_ms: None,
+                summary_preview: None,
+            });
+        }
+
+        let backend = ratatui::backend::TestBackend::new(100, 30);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|frame| {
+                state.render(frame);
+            })
+            .unwrap();
+        let text = terminal
+            .backend()
+            .buffer()
+            .content
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
+        assert!(text.contains("+3 more subagents..."));
+    }
+
+    #[test]
+    fn swarm_panel_compact_mode_on_short_screen() {
+        let mut state = ChatViewState::default();
+        state.swarm_agents.push(SwarmAgentUiState {
+            label: "recon".to_string(),
+            profile: "explorer".to_string(),
+            task: "Searching files".to_string(),
+            current_action: None,
+            status: SwarmUiStatus::Running,
+            started_at: std::time::Instant::now(),
+            finished_elapsed_ms: None,
+            summary_preview: None,
+        });
+
+        let backend = ratatui::backend::TestBackend::new(80, 20);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|frame| {
+                state.render(frame);
+            })
+            .unwrap();
+        let text = terminal
+            .backend()
+            .buffer()
+            .content
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
+        assert!(text.contains("Running 1 subagent"));
+    }
+
+    #[test]
+    fn swarm_agents_cleared_on_user_input_and_clear() {
+        let mut state = ChatViewState::default();
+        state.swarm_agents.push(SwarmAgentUiState {
+            label: "recon".to_string(),
+            profile: "explorer".to_string(),
+            task: "Searching files".to_string(),
+            current_action: None,
+            status: SwarmUiStatus::Running,
+            started_at: std::time::Instant::now(),
+            finished_elapsed_ms: None,
+            summary_preview: None,
+        });
+        assert_eq!(state.swarm_agents.len(), 1);
+
+        state.push_user("hello".to_string());
+        assert!(state.swarm_agents.is_empty());
+
+        state.swarm_agents.push(SwarmAgentUiState {
+            label: "recon".to_string(),
+            profile: "explorer".to_string(),
+            task: "Searching files".to_string(),
+            current_action: None,
+            status: SwarmUiStatus::Running,
+            started_at: std::time::Instant::now(),
+            finished_elapsed_ms: None,
+            summary_preview: None,
+        });
+        state.clear_transcript();
+        assert!(state.swarm_agents.is_empty());
+    }
+
+    #[test]
+    fn record_tool_progress_updates_swarm_state() {
+        let mut state = ChatViewState::default();
+        let start_event = mint_core::AgentProgress::SubagentStarted {
+            subagent: "worker".to_string(),
+            profile: "explorer".to_string(),
+            task: "Investigate database queries".to_string(),
+        };
+        state.record_tool_progress(&start_event);
+        assert_eq!(state.swarm_agents.len(), 1);
+        assert_eq!(state.swarm_agents[0].label, "worker");
+        assert_eq!(state.swarm_agents[0].status, SwarmUiStatus::Running);
+
+        let tool_start = mint_core::AgentProgress::ToolStart {
+            call_id: Some("call-1".to_string()),
+            action: "run_shell".to_string(),
+            input: serde_json::json!({"command": "cargo test"}),
+            subagent: Some("worker".to_string()),
+        };
+        state.record_tool_progress(&tool_start);
+        assert_eq!(
+            state.swarm_agents[0].current_action.as_deref(),
+            Some("Running `cargo test`")
+        );
+        // Subagent tools must NOT be pushed to the main transcript or tools list!
+        assert!(
+            state.transcript.is_empty(),
+            "transcript must stay clean without subagent tool spam"
+        );
+        assert!(
+            state.tools.is_empty(),
+            "tools list must not include subagent micro-tools"
+        );
+
+        let tool_end = mint_core::AgentProgress::ToolEnd {
+            call_id: Some("call-1".to_string()),
+            action: "run_shell".to_string(),
+            input: serde_json::json!({"command": "cargo test"}),
+            result: "test result ok".to_string(),
+            status: Some(mint_core::integrations::mcp_result::ToolStatus::Success),
+            subagent: Some("worker".to_string()),
+            elapsed_ms: Some(120),
+        };
+        state.record_tool_progress(&tool_end);
+        assert!(state.transcript.is_empty());
+        assert!(state.tools.is_empty());
+
+        let finish_event = mint_core::AgentProgress::SubagentFinished {
+            subagent: "worker".to_string(),
+            status: "completed".to_string(),
+            elapsed_ms: 4500,
+            steps: 3,
+            summary_preview: "All queries optimized".to_string(),
+        };
+        state.record_tool_progress(&finish_event);
+        assert_eq!(state.swarm_agents[0].status, SwarmUiStatus::Success);
+        assert_eq!(state.swarm_agents[0].finished_elapsed_ms, Some(4500));
+        assert_eq!(
+            state.swarm_agents[0].summary_preview.as_deref(),
+            Some("All queries optimized")
+        );
+        assert!(state.transcript.is_empty());
+    }
+
+    #[test]
+    fn swarm_panel_renders_smoothly_in_plan_mode() {
+        let mut state = ChatViewState::default();
+        state.plan_mode = true;
+        state.swarm_agents.push(SwarmAgentUiState {
+            label: "recon".to_string(),
+            profile: "explorer".to_string(),
+            task: "Investigating schema for migration".to_string(),
+            current_action: Some("Reading `schema.rs`".to_string()),
+            status: SwarmUiStatus::Running,
+            started_at: std::time::Instant::now(),
+            finished_elapsed_ms: None,
+            summary_preview: None,
+        });
+
+        let backend = ratatui::backend::TestBackend::new(100, 30);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|frame| {
+                state.render(frame);
+            })
+            .unwrap();
+        let text = terminal
+            .backend()
+            .buffer()
+            .content
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
+        assert!(text.contains("Running Subagents"));
+        assert!(text.contains("[recon]"));
+        assert!(text.contains("Reading `schema.rs`"));
+        assert!(text.contains("[Plan]"));
+    }
+
+    #[test]
+    fn tool_viewer_smart_jumps_to_web_search_when_sources_present() {
+        use crate::interactive::tool_activity::ToolActivity;
+        use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+        let mut state = ChatViewState::default();
+        // Tool 0: web_search
+        state.tools.push(ToolActivity {
+            entry: 0,
+            call_id: Some("call_web".into()),
+            action: "web_search".into(),
+            input: serde_json::json!({"query": "cosplay 4khd"}),
+            subagent: None,
+            started: std::time::Instant::now(),
+            elapsed: Some(std::time::Duration::from_millis(1200)),
+            result: Some("1. 4KHD Cosplay\n   URL: https://4khd.com\n   Preview text".into()),
+            status: Some(mint_core::integrations::mcp_result::ToolStatus::Success),
+        });
+        // Tool 1: run_shell (ran afterwards)
+        state.tools.push(ToolActivity {
+            entry: 1,
+            call_id: Some("call_shell".into()),
+            action: "run_shell".into(),
+            input: serde_json::json!({"command": "echo done"}),
+            subagent: None,
+            started: std::time::Instant::now(),
+            elapsed: Some(std::time::Duration::from_millis(500)),
+            result: Some("exit: 0\nstdout:\ndone\nstderr:".into()),
+            status: Some(mint_core::integrations::mcp_result::ToolStatus::Success),
+        });
+
+        let make_key = |code: KeyCode, modifiers: KeyModifiers| KeyEvent::new(code, modifiers);
+
+        // Without Sources notice, Ctrl+O opens the latest tool (index 1: run_shell)
+        let key = make_key(KeyCode::Char('o'), KeyModifiers::CONTROL);
+        assert!(state.handle_tool_key(key));
+        assert_eq!(state.tool_viewer, Some(1));
+        state.handle_tool_key(make_key(KeyCode::Esc, KeyModifiers::NONE));
+        assert_eq!(state.tool_viewer, None);
+
+        // When Sources notice is in recent transcript, Ctrl+O smart jumps to web_search (index 0)
+        state.push_notice("Sources:\n1. 4KHD Cosplay\n   https://4khd.com\n  … [+10 more sources] · Ctrl+O view web_search");
+        state.push_notice("─ Worked for 10s • test ──────────────────────────────");
+
+        assert!(state.handle_tool_key(key));
+        assert_eq!(state.tool_viewer, Some(0));
+        assert_eq!(state.tools[state.tool_viewer.unwrap()].action, "web_search");
+    }
+
+    #[test]
+    fn format_tui_web_sources_renders_with_muted_and_blue_spans_in_transcript_entry() {
+        let sources: Vec<(String, String)> = (1..=10)
+            .map(|i| (format!("Title {i}"), format!("https://example.com/{i}")))
+            .collect();
+        let formatted = crate::agent::format_tui_web_sources(&sources, 5);
+        let entry = TranscriptEntry::new(TranscriptRole::Notice, formatted);
+
+        let more_line = entry
+            .rendered_lines
+            .iter()
+            .find(|line| {
+                line.spans
+                    .iter()
+                    .any(|s| s.content.contains("more sources] · "))
+            })
+            .expect("more sources line should be present");
+
+        let muted_span = more_line
+            .spans
+            .iter()
+            .find(|s| s.content.contains("more sources] · "))
+            .expect("muted span found");
+        assert_eq!(muted_span.style.fg, Some(crate::terminal_theme::MUTED));
+
+        let blue_span = more_line
+            .spans
+            .iter()
+            .find(|s| s.content.contains("Ctrl+O view web_search"))
+            .expect("blue span found");
+        assert_eq!(blue_span.style.fg, Some(crate::terminal_theme::BLUE));
+    }
+}