@pheem49/mint 1.15.0 → 1.17.0

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

@@ -10,8 +10,8 @@ use ansi_to_tui::IntoText;
 use anyhow::{Result, anyhow};
 use mint_core::{
     AgentApproval, AgentProgress, AgentResult, ApprovalOutcome, AskUserOption, CHAT_CLI_ID,
-    MemoryStore, MintConfig, OrchestrationError, PermissionDecision, PermissionRule,
-    orchestrate_agent_loop, permission_decision_for,
+    ExecutionState, MemoryStore, MintConfig, OrchestrationError, PermissionDecision,
+    PermissionRule, orchestrate_agent_loop, permission_decision_for,
 };
 use syntect::easy::HighlightLines;
 use syntect::highlighting::ThemeSet;
@@ -62,6 +62,7 @@ pub struct AgentOptions {
     pub pinned_mcp_server: Option<String>,
     /// Chat ID / session ID for this turn. Defaults to `CHAT_CLI_ID` if omitted.
     pub chat_id: Option<String>,
+    pub image_name: Option<String>,
     /// Full-screen UI event sink. When present, agent output never writes
     /// directly to stdout and stdin remains owned by the TUI controller.
     pub tui: Option<crate::interactive::TuiHandle>,
@@ -97,8 +98,9 @@ pub async fn run_code_agent_with_image(
 fn get_field_alias<'a>(input: &'a serde_json::Value, keys: &[&str]) -> Option<&'a str> {
     for &k in keys {
         if let Some(v) = input.get(k).and_then(|v| v.as_str()) {
-            if !v.trim().is_empty() {
-                return Some(v.trim());
+            let trimmed = v.trim();
+            if !trimmed.is_empty() && !mint_core::is_dummy_value(trimmed) {
+                return Some(trimmed);
             }
         }
     }
@@ -131,7 +133,11 @@ fn generic_tool_label(action: &str, input: &serde_json::Value) -> (bool, String)
             )
         }
         "run_shell" => {
-            let command = get_field_alias(input, &["command", "cmd"]).unwrap_or("");
+            let command = get_field_alias(
+                input,
+                &["command", "cmd", "script", "exec", "code", "bash", "sh"],
+            )
+            .unwrap_or("");
             let background = input
                 .get("background")
                 .and_then(|v| v.as_bool())
@@ -195,6 +201,17 @@ fn generic_tool_label(action: &str, input: &serde_json::Value) -> (bool, String)
             let name = input.get("name").and_then(|v| v.as_str()).unwrap_or("");
             (false, format!("[run_plugin] Running plugin: {}...", name))
         }
+        "dispatch_agents" => {
+            let tasks_len = input
+                .get("tasks")
+                .and_then(|v| v.as_array())
+                .map(|a| a.len())
+                .unwrap_or(1);
+            (
+                false,
+                format!("├── [{CYAN}swarm{RESET}] Dispatching {tasks_len} sub-agent(s)..."),
+            )
+        }
         "dispatch_subagent" => {
             let name = input
                 .get("name")
@@ -387,6 +404,10 @@ fn tui_approval(
         _ => ApprovalOutcome::Denied,
     };
     Ok(match approval {
+        AgentApproval::SkillWrite { path, diff, .. } => yes_no(
+            "Save skill?",
+            format!("Changes instructions used in future tasks.\nPath: {path}\n\n{diff}"),
+        ),
         AgentApproval::WriteFile { path, diff, .. } => tui_persistable_approval(
             tui,
             "write_file",
@@ -515,6 +536,194 @@ fn tui_approval(
     })
 }
 
+pub(crate) fn mcp_progress_notes(event: &AgentProgress) -> Option<Vec<String>> {
+    Some(match event {
+        AgentProgress::ToolDiscovery {
+            server,
+            tool,
+            message,
+        } => vec![format!("[MCP discovery {server}/{tool}] {message}")],
+        AgentProgress::DeviceState {
+            server,
+            tool,
+            update,
+            ..
+        } => vec![format!(
+            "[Device {server}/{tool}] {:?}: {} (target {}, actual {})",
+            update.state, update.message, update.target, update.actual
+        )],
+        AgentProgress::ToolProgress {
+            server,
+            tool,
+            update,
+            ..
+        } => {
+            let detail = update
+                .total
+                .map(|total| format!("{:.0}%", update.progress / total * 100.0))
+                .unwrap_or_else(|| format!("{}s", update.elapsed_secs));
+            vec![format!(
+                "[MCP {server}/{tool}] {detail} {}",
+                update.message.as_deref().unwrap_or_default()
+            )]
+        }
+        AgentProgress::ExecutionUpdate { executions, .. } => executions
+            .iter()
+            .map(|e| {
+                let kind = if e.check { "Check" } else { "Command" };
+                let state_str = match e.state {
+                    ExecutionState::Succeeded => {
+                        format!(
+                            "{}Succeeded{RESET}",
+                            crate::terminal_theme::ANSI_ACCENT_BOLD
+                        )
+                    }
+                    ExecutionState::Failed => {
+                        format!("{}Failed{RESET}", crate::terminal_theme::ANSI_ERROR_BOLD)
+                    }
+                    ExecutionState::Running => {
+                        format!("{}Running{RESET}", crate::terminal_theme::ANSI_BLUE_BOLD)
+                    }
+                    ExecutionState::Cancelled => {
+                        format!("{DIM}Cancelled{RESET}")
+                    }
+                    ExecutionState::Unknown => {
+                        format!("{}Unknown{RESET}", crate::terminal_theme::ANSI_WARNING_BOLD)
+                    }
+                };
+                let exit = e
+                    .exit_code
+                    .map(|c| {
+                        if c == 0 {
+                            format!(" · {DIM}exit {c}{RESET}")
+                        } else {
+                            format!(" · {RED}exit {c}{RESET}")
+                        }
+                    })
+                    .unwrap_or_default();
+                let job = e
+                    .job_id
+                    .as_ref()
+                    .map(|j| format!(" · {DIM}job {j}{RESET}"))
+                    .unwrap_or_default();
+                format!("[{kind}] {state_str} · {}{exit}{job}", e.command)
+            })
+            .collect(),
+        AgentProgress::ToolArtifacts {
+            artifacts,
+            warnings,
+            ..
+        } => {
+            let mut notes = artifacts
+                .iter()
+                .map(|artifact| {
+                    let location = artifact.uri.clone().unwrap_or_else(|| {
+                        mint_core::integrations::mcp_result::artifact_directory()
+                            .unwrap_or_default()
+                            .join(&artifact.id)
+                            .display()
+                            .to_string()
+                    });
+                    let tag = match artifact.server.as_str() {
+                        "browser" => "Screenshot".into(),
+                        "view_image" => "Viewed image".into(),
+                        other if !other.is_empty() => format!("MCP {other}"),
+                        _ => format!("MCP {}", artifact.kind),
+                    };
+                    format!("[{tag}] {}: {location}", artifact.name)
+                })
+                .collect::<Vec<_>>();
+            notes.extend(
+                warnings
+                    .iter()
+                    .map(|warning| format!("[Warning] {warning}")),
+            );
+            notes
+        }
+        _ => return None,
+    })
+}
+
+pub(crate) fn publish_mcp_progress(
+    tui: Option<&crate::interactive::TuiHandle>,
+    event: &AgentProgress,
+) -> bool {
+    // In Full-Screen TUI, executions are already rendered as interactive ToolActivity cards.
+    // Suppress redundant [Command]/[Check] text notices in TUI while preserving them for Classic CLI.
+    if tui.is_some() && matches!(event, AgentProgress::ExecutionUpdate { .. }) {
+        return false;
+    }
+    let Some(notes) = mcp_progress_notes(event) else {
+        return false;
+    };
+    for note in notes {
+        if let Some(tui) = tui {
+            tui.push_notice(note);
+        } else {
+            println!("{note}");
+        }
+    }
+    true
+}
+
+pub(crate) fn run_summary_lines(
+    summary: &mint_core::orchestration::RunTelemetrySummary,
+) -> Vec<String> {
+    let failed_tools: Vec<_> = summary
+        .tool_timeline
+        .iter()
+        .filter(|record| !record.success)
+        .collect();
+    let outcome = match summary.outcome.as_str() {
+        "FAILED" => format!("{RED}✗ Failed{RESET}"),
+        "BLOCKED" => format!("{YELLOW}○ Blocked{RESET}"),
+        "UNVERIFIED" => format!("{YELLOW}? Unverified{RESET}"),
+        "ROLLED_BACK" => format!("{YELLOW}↺ Rolled back{RESET}"),
+        _ if !failed_tools.is_empty() => format!(
+            "{YELLOW}⚠ Completed with {} previous failure{}{RESET}",
+            failed_tools.len(),
+            if failed_tools.len() == 1 { "" } else { "s" }
+        ),
+        "VERIFIED" => format!("{GREEN}✓ Verified{RESET}"),
+        _ => format!("{GREEN}✓ Completed{RESET}"),
+    };
+    let file_count = summary.files_changed.len();
+    let mut lines = vec![format!(
+        "  {outcome} {DIM}in {:.1}s · {} tool{} · {} file{} changed{RESET}",
+        summary.duration_secs,
+        summary.tool_calls_count,
+        if summary.tool_calls_count == 1 {
+            ""
+        } else {
+            "s"
+        },
+        file_count,
+        if file_count == 1 { "" } else { "s" },
+    )];
+
+    if file_count > 0 {
+        let mut names: Vec<String> = summary
+            .files_changed
+            .iter()
+            .take(6)
+            .map(|path| display_tool_target(path))
+            .collect();
+        if file_count > names.len() {
+            names.push(format!("+{} more", file_count - names.len()));
+        }
+        lines.push(format!("    {DIM}└ {}{RESET}", names.join(", ")));
+    }
+    for record in failed_tools.into_iter().take(3) {
+        let target = if record.target.is_empty() {
+            record.action.clone()
+        } else {
+            format!("{} [{}]", record.action, truncate_line(&record.target, 72))
+        };
+        lines.push(format!("    {RED}└ {target} failed{RESET}"));
+    }
+    lines
+}
+
 pub async fn run_code_agent_with_options(
     task: &str,
     root: &Path,
@@ -525,8 +734,26 @@ pub async fn run_code_agent_with_options(
     queued_out: Arc<Mutex<Vec<String>>>,
     draft_out: Arc<Mutex<Option<String>>>,
 ) -> Result<AgentResult> {
+    let target_chat_id = options.chat_id.as_deref().unwrap_or(CHAT_CLI_ID);
+    let receipt = crate::image::prepare_attachments(
+        config,
+        target_chat_id,
+        task,
+        image_data_uri.as_deref(),
+        video_data_uri.as_deref(),
+        options.image_name.as_deref(),
+    )
+    .await?;
+    if receipt.is_some()
+        && let Some(tui) = &options.tui
+    {
+        tui.set_notice("Attachments saved to Library");
+    }
     let started_at = Instant::now();
     crate::interactive::clear_last_thought();
+    if let Some(tui) = &options.tui {
+        tui.reset_thoughts();
+    }
     let thinking_verb = random_thinking_verb();
     let approval_active = Arc::new(AtomicBool::new(false));
     let agent_done = Arc::new(AtomicBool::new(false));
@@ -590,6 +817,21 @@ pub async fn run_code_agent_with_options(
         let _guard = ApprovalGuard(Arc::clone(&approve_approval_active));
 
         match approval {
+            AgentApproval::SkillWrite { path, diff, .. } => {
+                let (additions, deletions) = diff_stats(diff);
+                print_diff_header("Save skill", path, additions, deletions);
+                print_colored_diff(diff);
+                Ok(
+                    if confirm_pausing_interrupt(
+                        "Save these instructions for future tasks?",
+                        &approve_approval_active,
+                    ) {
+                        ApprovalOutcome::Approved
+                    } else {
+                        ApprovalOutcome::Denied
+                    },
+                )
+            }
             AgentApproval::WriteFile { path, diff, .. } => confirm_with_persistence(
                 "write_file",
                 path,
@@ -798,18 +1040,18 @@ pub async fn run_code_agent_with_options(
                         break;
                     }
                     if timer_tool_running.load(Ordering::Relaxed) == 0 {
-                        status.thinking = Some(
-                            if let Some((attempt, max_attempts)) = status.waiting_for_network {
-                                waiting_for_network_label(attempt, max_attempts)
-                            } else {
-                                let context_suffix = context_pct_suffix(status.context_pct);
-                                let tokens_suffix = live_tokens_suffix(&status);
-                                format!(
-                                    "{thinking_verb} ({}{tokens_suffix}{context_suffix} • Esc to interrupt)",
-                                    format_elapsed(timer_started_at.elapsed())
-                                )
-                            },
-                        );
+                        status.thinking = Some(if let Some(started) = status.compaction_started {
+                            compaction_label(started.elapsed())
+                        } else if let Some((attempt, max_attempts)) = status.waiting_for_network {
+                            waiting_for_network_label(attempt, max_attempts)
+                        } else {
+                            let context_suffix = context_pct_suffix(status.context_pct);
+                            let tokens_suffix = live_tokens_suffix(&status);
+                            format!(
+                                "{thinking_verb} ({}{tokens_suffix}{context_suffix} • Esc to interrupt)",
+                                format_elapsed(timer_started_at.elapsed())
+                            )
+                        });
                     }
                     render_live_status(&mut status);
                 }
@@ -831,7 +1073,15 @@ pub async fn run_code_agent_with_options(
         mint_core::avatar_bridge::AvatarBridgeConfig::from_mint_config(config),
     );
     let progress_cb = |progress: AgentProgress| {
+        if !options.fast_mode
+            && let Some(tui) = &options.tui
+        {
+            tui.tool_progress(&progress);
+        }
         avatar_bridge.on_agent_progress(&progress);
+        if publish_mcp_progress(options.tui.as_ref(), &progress) {
+            return;
+        }
         match progress {
             AgentProgress::Thinking {
                 elapsed_secs,
@@ -888,6 +1138,40 @@ pub async fn run_code_agent_with_options(
                     render_live_status(&mut status);
                 }
             }
+            AgentProgress::ContextCompaction {
+                subagent,
+                status: phase,
+                message,
+            } => {
+                if !options.fast_mode
+                    && let Ok(mut status) = progress_live_status.lock()
+                {
+                    update_context_compaction(
+                        &mut status,
+                        &phase,
+                        subagent.as_deref(),
+                        Instant::now(),
+                    );
+                    if subagent.is_none() {
+                        if phase == "started" {
+                            status.thinking = Some(compaction_label(Duration::ZERO));
+                        } else {
+                            print_timeline_note(&mut status, &message, started_at.elapsed(), None);
+                            status.context_pct = None;
+                            status.thinking =
+                                Some(if let Some(started) = status.compaction_started {
+                                    compaction_label(started.elapsed())
+                                } else {
+                                    format!(
+                                        "{thinking_verb} ({} • Esc to interrupt)",
+                                        format_elapsed(started_at.elapsed())
+                                    )
+                                });
+                        }
+                    }
+                    render_live_status(&mut status);
+                }
+            }
             AgentProgress::WaitingForNetwork {
                 attempt,
                 max_attempts,
@@ -927,6 +1211,9 @@ pub async fn run_code_agent_with_options(
                     let elapsed = Duration::from_millis(elapsed_ms);
                     let elapsed_str = crate::interactive::format_thought_elapsed(elapsed);
                     crate::interactive::append_thought_delta(&id, &delta, &elapsed_str);
+                    if let Some(tui) = &options.tui {
+                        tui.append_thought_delta(&id, &delta, elapsed);
+                    }
                 }
             }
             AgentProgress::ExtendedThinking {
@@ -945,11 +1232,7 @@ pub async fn run_code_agent_with_options(
                     let elapsed = elapsed_ms
                         .map(Duration::from_millis)
                         .unwrap_or_else(|| started_at.elapsed());
-                    // Extended thinking gets the same timeline-note treatment
-                    // as regular Thought — `print_timeline_note` already
-                    // distinguishes internal CoT (long) from short notes via
-                    // `is_internal_cot` and renders accordingly.
-                    print_timeline_note(&mut status, &thought, elapsed, id.as_deref());
+                    print_extended_thinking(&mut status, &thought, elapsed, id.as_deref());
                     status.thinking = None;
                     status.waiting_for_network = None;
                     render_live_status(&mut status);
@@ -959,6 +1242,7 @@ pub async fn run_code_agent_with_options(
                 action,
                 input,
                 subagent,
+                ..
             } => {
                 progress_tool_running.fetch_add(1, Ordering::Relaxed);
                 if !options.fast_mode
@@ -1001,13 +1285,26 @@ pub async fn run_code_agent_with_options(
                         return;
                     }
                     if action == "read_file"
-                        && let Some(path) = input.get("path").and_then(|v| v.as_str())
-                        && skill_name_for_read_path(path).is_some()
+                        && let Some(skill_name) = input
+                            .get("skill_name")
+                            .and_then(|v| v.as_str())
+                            .map(str::to_owned)
+                            .or_else(|| {
+                                input
+                                    .get("path")
+                                    .and_then(|v| v.as_str())
+                                    .and_then(skill_name_for_read_path)
+                            })
                     {
-                        // The agent chose to read a skill file on its own initiative
-                        // (as opposed to the human typing `$skillname`). Skip the
-                        // generic explored-files grouping — ToolEnd below renders a
-                        // dedicated Skill(...) card for this instead.
+                        if let Ok(mut status) = progress_live_status.lock() {
+                            status.thinking = None;
+                            status.waiting_for_network = None;
+                            status.tasks.push(TaskEntry {
+                                label: format!("Reading skill: {skill_name}"),
+                                output: Vec::new(),
+                            });
+                            render_live_status(&mut status);
+                        }
                         return;
                     }
                     if let Some(label) = explored_action_label(&action, &input) {
@@ -1039,6 +1336,7 @@ pub async fn run_code_agent_with_options(
                 input,
                 result,
                 subagent,
+                ..
             } => {
                 let remaining = progress_tool_running
                     .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |running| {
@@ -1112,13 +1410,29 @@ pub async fn run_code_agent_with_options(
                         }
                         render_live_status(&mut status);
                     } else if action == "read_file"
-                        && let Some(path) = input.get("path").and_then(|v| v.as_str())
-                        && let Some(skill_name) = skill_name_for_read_path(path)
+                        && let Some(skill_name) = input
+                            .get("skill_name")
+                            .and_then(|v| v.as_str())
+                            .map(str::to_owned)
+                            .or_else(|| {
+                                input
+                                    .get("path")
+                                    .and_then(|v| v.as_str())
+                                    .and_then(skill_name_for_read_path)
+                            })
                         && let Ok(mut status) = progress_live_status.lock()
                     {
                         status.thinking = None;
                         status.waiting_for_network = None;
-                        status.tasks.push(skill_card(&skill_name));
+                        if let Some(task) = status
+                            .tasks
+                            .iter_mut()
+                            .rev()
+                            .find(|task| task.label == format!("Reading skill: {skill_name}"))
+                        {
+                            task.label = skill_read_label(&skill_name, &result);
+                            task.output = command_output_preview(&result);
+                        }
                         render_live_status(&mut status);
                     } else if action == "memory_recall" {
                         let skill_names = skill_names_from_memory_recall(&result);
@@ -1128,7 +1442,10 @@ pub async fn run_code_agent_with_options(
                             status.thinking = None;
                             status.waiting_for_network = None;
                             for name in skill_names {
-                                status.tasks.push(skill_card(&name));
+                                status.tasks.push(TaskEntry {
+                                    label: format!("Found skill: {name}"),
+                                    output: Vec::new(),
+                                });
                             }
                             render_live_status(&mut status);
                         }
@@ -1144,6 +1461,13 @@ pub async fn run_code_agent_with_options(
                     status.web_sources.extend(sources);
                 }
             }
+            AgentProgress::ToolDiscovery { .. }
+            | AgentProgress::DeviceState { .. }
+            | AgentProgress::ToolProgress { .. }
+            | AgentProgress::ToolArtifacts { .. }
+            | AgentProgress::SubagentStarted { .. }
+            | AgentProgress::SubagentFinished { .. }
+            | AgentProgress::ExecutionUpdate { .. } => {}
             AgentProgress::PlanUpdated { plan } => {
                 if let Ok(mut status) = progress_live_status.lock() {
                     status.thinking = None;
@@ -1178,58 +1502,7 @@ pub async fn run_code_agent_with_options(
                     status.waiting_for_network = None;
                     commit_activity_snapshot(&mut status);
 
-                    let failed_tools: Vec<_> = summary
-                        .tool_timeline
-                        .iter()
-                        .filter(|record| !record.success)
-                        .collect();
-                    let outcome = if !failed_tools.is_empty() {
-                        format!(
-                            "{YELLOW}⚠ Completed with {} failure{}{RESET}",
-                            failed_tools.len(),
-                            if failed_tools.len() == 1 { "" } else { "s" }
-                        )
-                    } else if summary.outcome == "ROLLED_BACK" {
-                        format!("{YELLOW}↺ Rolled back{RESET}")
-                    } else if summary.outcome == "FAILED" {
-                        format!("{RED}✗ Failed{RESET}")
-                    } else {
-                        format!("{GREEN}✓ Completed{RESET}")
-                    };
-                    let file_count = summary.files_changed.len();
-                    let mut lines = vec![format!(
-                        "  {outcome} {DIM}in {:.1}s · {} tool{} · {} file{} changed{RESET}",
-                        summary.duration_secs,
-                        summary.tool_calls_count,
-                        if summary.tool_calls_count == 1 {
-                            ""
-                        } else {
-                            "s"
-                        },
-                        file_count,
-                        if file_count == 1 { "" } else { "s" },
-                    )];
-
-                    if file_count > 0 {
-                        let mut names: Vec<String> = summary
-                            .files_changed
-                            .iter()
-                            .take(6)
-                            .map(|path| display_tool_target(path))
-                            .collect();
-                        if file_count > names.len() {
-                            names.push(format!("+{} more", file_count - names.len()));
-                        }
-                        lines.push(format!("    {DIM}└ {}{RESET}", names.join(", ")));
-                    }
-                    for record in failed_tools.into_iter().take(3) {
-                        let target = if record.target.is_empty() {
-                            record.action.clone()
-                        } else {
-                            format!("{} [{}]", record.action, truncate_line(&record.target, 72))
-                        };
-                        lines.push(format!("    {RED}└ {target} failed{RESET}"));
-                    }
+                    let lines = run_summary_lines(&summary);
                     insert_permanent_lines(&mut status, &lines);
                 }
             }
@@ -1246,22 +1519,32 @@ pub async fn run_code_agent_with_options(
 
     let target_chat_id = options.chat_id.as_deref().unwrap_or(CHAT_CLI_ID);
 
-    let agent_loop = orchestrate_agent_loop(
-        config,
-        task,
-        root,
-        image_data_uri,
-        None,
-        video_data_uri,
-        Some(target_chat_id),
-        None,
-        user_name.as_deref(),
-        options.pinned_mcp_server.as_deref(),
-        options.fast_mode,
-        options.plan_mode,
-        approve_cb,
-        progress_cb,
-        on_chunk,
+    let agent_loop = mint_core::with_turn_start_listener(
+        target_chat_id.to_owned(),
+        move |id| {
+            if let Some(receipt) = &receipt
+                && let Err(error) = receipt.bind(id)
+            {
+                eprintln!("Library reference: {error}")
+            }
+        },
+        orchestrate_agent_loop(
+            config,
+            task,
+            root,
+            image_data_uri,
+            None,
+            video_data_uri,
+            Some(target_chat_id),
+            None,
+            user_name.as_deref(),
+            options.pinned_mcp_server.as_deref(),
+            options.fast_mode,
+            options.plan_mode,
+            approve_cb,
+            progress_cb,
+            on_chunk,
+        ),
     );
     let res = tokio::select! {
         res = agent_loop => res,
@@ -1349,14 +1632,11 @@ pub async fn run_code_agent_with_options(
         if let Ok(mut status) = live_status.lock()
             && !status.web_sources.is_empty()
         {
-            let sources = status
-                .web_sources
-                .drain(..)
-                .enumerate()
-                .map(|(index, (title, url))| format!("{}. {title}\n   {url}", index + 1))
-                .collect::<Vec<_>>()
-                .join("\n");
-            tui.push_notice(format!("Sources:\n{sources}"));
+            let sources = status.web_sources.drain(..).collect::<Vec<_>>();
+            let text = format_tui_web_sources(&sources, MAX_TUI_WEB_SOURCES);
+            if !text.is_empty() {
+                tui.push_notice(text);
+            }
         }
         tui.push_notice(worked_line);
         avatar_bridge.on_talking(false);
@@ -1601,6 +1881,26 @@ mod command_output_preview_tests {
 mod skill_card_tests {
     use super::*;
 
+    #[test]
+    fn skill_labels_distinguish_full_load_failure_and_preview() {
+        assert_eq!(
+            skill_read_label("review", "[Loaded skill: review]\nbody"),
+            "Loaded skill: review"
+        );
+        assert_eq!(
+            skill_read_label("review", "Error: denied"),
+            "Failed to read skill: review"
+        );
+        assert_eq!(
+            skill_read_label("review", "Blocked by hook: denied"),
+            "Failed to read skill: review"
+        );
+        assert_eq!(
+            skill_read_label("review", "1 | header"),
+            "Read skill preview: review"
+        );
+    }
+
     #[test]
     fn recognizes_workspace_skill_paths() {
         assert_eq!(
@@ -1654,4 +1954,72 @@ mod skill_card_tests {
         let result = "[2026-08-01] You: hi\nMint: hello";
         assert!(skill_names_from_memory_recall(result).is_empty());
     }
+
+    #[test]
+    fn execution_update_progress_notes_highlight_succeeded_and_failed() {
+        use mint_core::{ExecutionEvidence, ExecutionState};
+        let update = 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,
+                },
+                ExecutionEvidence {
+                    call_id: "test2".into(),
+                    command: "cargo check".into(),
+                    state: ExecutionState::Failed,
+                    exit_code: Some(1),
+                    job_id: None,
+                    revision: 2,
+                    check: true,
+                    condition_verified: None,
+                },
+            ],
+        };
+        let notes = mcp_progress_notes(&update).expect("should produce notes");
+        assert_eq!(notes.len(), 2);
+        assert!(notes[0].contains("[Command]"));
+        assert!(notes[0].contains("Succeeded"));
+        assert!(notes[0].contains("exit 0"));
+        assert!(notes[1].contains("[Check]"));
+        assert!(notes[1].contains("Failed"));
+        assert!(notes[1].contains("exit 1"));
+    }
+
+    #[test]
+    fn format_tui_web_sources_handles_empty_under_limit_and_over_limit() {
+        assert_eq!(format_tui_web_sources(&[], 5), "");
+
+        let three_items = vec![
+            ("Site 1".into(), "https://example.com/1".into()),
+            ("Site 2".into(), "https://example.com/2".into()),
+            ("Site 3".into(), "https://example.com/3".into()),
+        ];
+        let out = format_tui_web_sources(&three_items, 5);
+        assert!(out.starts_with("Sources:\n"));
+        assert!(out.contains("1. Site 1\n   https://example.com/1"));
+        assert!(out.contains("2. Site 2\n   https://example.com/2"));
+        assert!(out.contains("3. Site 3\n   https://example.com/3"));
+        assert!(!out.contains("more sources"));
+        assert!(!out.contains("Ctrl+O details"));
+
+        let eight_items: Vec<_> = (1..=8)
+            .map(|i| (format!("Site {i}"), format!("https://example.com/{i}")))
+            .collect();
+        let out = format_tui_web_sources(&eight_items, 5);
+        assert!(out.contains("1. Site 1\n   https://example.com/1"));
+        assert!(out.contains("5. Site 5\n   https://example.com/5"));
+        assert!(!out.contains("6. Site 6"));
+        assert!(out.contains("… [+3 more sources] · "));
+        assert!(out.contains("Ctrl+O view web_search"));
+        assert!(out.contains(crate::terminal_theme::ANSI_MUTED));
+        assert!(out.contains(crate::terminal_theme::ANSI_BLUE));
+    }
 }