@pheem49/mint 1.14.0 → 1.16.0

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

@@ -2,7 +2,7 @@ use std::io::{self, Write};
 use std::path::Path;
 use std::sync::{
     Arc, Mutex,
-    atomic::{AtomicBool, Ordering},
+    atomic::{AtomicBool, AtomicUsize, Ordering},
 };
 use std::time::{Duration, Instant};
 
@@ -27,19 +27,21 @@ mod markdown_render;
 use approval_prompts::*;
 use diff_render::*;
 pub(crate) use live_status::*;
-use markdown_render::*;
-
-const RESET: &str = "\x1b[0m";
-const MINT: &str = "\x1b[32m";
-const GREEN: &str = "\x1b[32m";
-const RED: &str = "\x1b[31m";
-const BLUE: &str = "\x1b[38;2;78;201;216m";
-const CYAN: &str = "\x1b[38;2;56;189;248m";
-const DIM: &str = "\x1b[90m";
-const BRIGHT: &str = "\x1b[1;97m";
-const BOLD: &str = "\x1b[1m";
-const BG_ADD: &str = "\x1b[48;2;20;53;32m\x1b[38;2;166;226;46m";
-const BG_DEL: &str = "\x1b[48;2;61;23;23m\x1b[38;2;255;121;121m";
+pub(crate) use markdown_render::*;
+
+const RESET: &str = crate::terminal_theme::ANSI_RESET;
+const MINT: &str = crate::terminal_theme::ANSI_ACCENT;
+const GREEN: &str = crate::terminal_theme::ANSI_ACCENT;
+const RED: &str = crate::terminal_theme::ANSI_ERROR;
+const YELLOW: &str = crate::terminal_theme::ANSI_WARNING;
+const BLUE: &str = crate::terminal_theme::ANSI_BLUE;
+const CYAN: &str = crate::terminal_theme::ANSI_BLUE;
+const DIM: &str = crate::terminal_theme::ANSI_MUTED;
+const BRIGHT: &str = crate::terminal_theme::ANSI_BRIGHT_TEXT;
+const WHITE: &str = crate::terminal_theme::ANSI_TEXT;
+const BOLD: &str = crate::terminal_theme::ANSI_BOLD;
+const BG_ADD: &str = crate::terminal_theme::ANSI_ADD;
+const BG_DEL: &str = crate::terminal_theme::ANSI_DELETE;
 
 #[derive(Debug, Clone, Default)]
 pub struct AgentOptions {
@@ -58,6 +60,12 @@ pub struct AgentOptions {
     /// configured MCP server — set by an `@servername` mention in the typed
     /// query, mirroring the GUI composer's `@` mention picker.
     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>,
 }
 
 pub async fn run_code_agent(task: &str, root: &Path, config: &MintConfig) -> Result<AgentResult> {
@@ -327,6 +335,326 @@ fn save_plan_file(root: &Path, plan: &str) -> io::Result<std::path::PathBuf> {
     Ok(path)
 }
 
+fn tui_persistable_approval(
+    tui: &crate::interactive::TuiHandle,
+    tool: &str,
+    subject: &str,
+    title: &str,
+    body: String,
+    root: &Path,
+    permission_rules: &mut Vec<PermissionRule>,
+) -> ApprovalOutcome {
+    if let Some(decision) = permission_decision_for(permission_rules, tool, subject, root) {
+        return match decision {
+            PermissionDecision::Allow => ApprovalOutcome::Approved,
+            PermissionDecision::Deny => ApprovalOutcome::Denied,
+        };
+    }
+    match tui.choose(
+        title,
+        body,
+        vec![
+            "Yes".into(),
+            "Yes, allow for this session".into(),
+            "No".into(),
+        ],
+    ) {
+        Some(0) => ApprovalOutcome::Approved,
+        Some(1) => {
+            permission_rules.push(PermissionRule {
+                tool: tool.to_owned(),
+                pattern: subject.to_owned(),
+                decision: PermissionDecision::Allow,
+                project_root: None,
+            });
+            ApprovalOutcome::Approved
+        }
+        _ => ApprovalOutcome::Denied,
+    }
+}
+
+fn tui_approval(
+    tui: &crate::interactive::TuiHandle,
+    approval: &AgentApproval,
+    root: &Path,
+    permission_rules: &mut Vec<PermissionRule>,
+) -> Result<ApprovalOutcome, String> {
+    let yes_no = |title: &str, body: String| match tui.choose(
+        title,
+        body,
+        vec!["Approve".into(), "Deny".into()],
+    ) {
+        Some(0) => ApprovalOutcome::Approved,
+        _ => 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",
+            path,
+            "Create file",
+            format!("Path: {path}\n\n{diff}"),
+            root,
+            permission_rules,
+        ),
+        AgentApproval::ApplyPatch { path, diff, .. } => tui_persistable_approval(
+            tui,
+            "apply_patch",
+            path,
+            "Update file",
+            format!("Path: {path}\n\n{diff}"),
+            root,
+            permission_rules,
+        ),
+        AgentApproval::RunShell {
+            command,
+            mode,
+            background,
+        } => tui_persistable_approval(
+            tui,
+            "run_shell",
+            command,
+            "Local shell command",
+            format!(
+                "Command: {command}\nMode: {mode}\nBackground: {}",
+                if *background { "yes" } else { "no" }
+            ),
+            root,
+            permission_rules,
+        ),
+        AgentApproval::NoteWrite { path, .. } => tui_persistable_approval(
+            tui,
+            "note_write",
+            path,
+            "Create note",
+            format!("Path: {path}"),
+            root,
+            permission_rules,
+        ),
+        AgentApproval::RunPlugin { name, instruction } => {
+            let subject = format!("{name}: {instruction}");
+            tui_persistable_approval(
+                tui,
+                "run_plugin",
+                &subject,
+                "Run plugin",
+                format!("Plugin: {name}\n\n{instruction}"),
+                root,
+                permission_rules,
+            )
+        }
+        AgentApproval::McpTool {
+            server,
+            tool,
+            arguments,
+        } => {
+            let body = format!("Server: {server}\nTool: {tool}\nArguments: {arguments}");
+            if tui.choose(
+                "MCP tool call",
+                body,
+                vec![format!("Allow all tools on {server}"), "No".into()],
+            ) == Some(0)
+            {
+                ApprovalOutcome::Intercepted(mint_core::MCP_ALLOW_ALL_SENTINEL.to_owned())
+            } else {
+                ApprovalOutcome::Denied
+            }
+        }
+        AgentApproval::UserApproval { title, prompt } => yes_no(title, prompt.to_owned()),
+        AgentApproval::EnterPlanMode { reason } => yes_no("Enter plan mode?", reason.to_owned()),
+        AgentApproval::ExitPlanMode { plan } => {
+            let outcome = yes_no("Review plan", plan.to_owned());
+            if outcome == ApprovalOutcome::Approved {
+                match save_plan_file(root, plan) {
+                    Ok(path) => tui.push_notice(format!("Plan saved to {}", path.display())),
+                    Err(error) => tui.push_notice(format!("Could not save plan: {error}")),
+                }
+            }
+            outcome
+        }
+        AgentApproval::AskUser {
+            question,
+            options,
+            header,
+            multi_select,
+        } => {
+            let title = header.as_deref().unwrap_or("Mint needs your input");
+            if options.is_empty() {
+                tui.prompt_text(title, question)
+                    .map(ApprovalOutcome::Intercepted)
+                    .unwrap_or(ApprovalOutcome::Denied)
+            } else {
+                let labels = options
+                    .iter()
+                    .map(|option| match &option.description {
+                        Some(description) => format!("{} — {description}", option.label),
+                        None => option.label.clone(),
+                    })
+                    .collect::<Vec<_>>();
+                if *multi_select {
+                    let selected = tui.choose_many(title, question, labels);
+                    let answer = selected
+                        .into_iter()
+                        .filter_map(|index| options.get(index))
+                        .map(|option| option.label.as_str())
+                        .collect::<Vec<_>>()
+                        .join(", ");
+                    if answer.is_empty() {
+                        ApprovalOutcome::Denied
+                    } else {
+                        ApprovalOutcome::Intercepted(answer)
+                    }
+                } else {
+                    let choice = tui.choose(title, question, labels);
+                    choice
+                        .and_then(|choice| options.get(choice))
+                        .map(|option| ApprovalOutcome::Intercepted(option.label.clone()))
+                        .unwrap_or(ApprovalOutcome::Denied)
+                }
+            }
+        }
+    })
+}
+
+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::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()
+                    });
+                    format!("[MCP {}] {}: {location}", artifact.kind, artifact.name)
+                })
+                .collect::<Vec<_>>();
+            notes.extend(
+                warnings
+                    .iter()
+                    .map(|warning| format!("[MCP warning] {warning}")),
+            );
+            notes
+        }
+        _ => return None,
+    })
+}
+
+pub(crate) fn publish_mcp_progress(
+    tui: Option<&crate::interactive::TuiHandle>,
+    event: &AgentProgress,
+) -> bool {
+    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 = 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}"));
+    }
+    lines
+}
+
 pub async fn run_code_agent_with_options(
     task: &str,
     root: &Path,
@@ -337,20 +665,42 @@ 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));
-    // True between a tool starting and finishing — tells the periodic timer
+    // Number of tools between start and finish — tells the periodic timer
     // below not to overwrite the live status with "Thinking (Xs)…" text
-    // while a tool (e.g. a shell command) is actually the thing in flight,
-    // without stopping it from still re-rendering (so the bullets keep
-    // pulsing) while that's happening.
-    let tool_running = Arc::new(AtomicBool::new(false));
+    // while any tool (e.g. a shell command) is still in flight. A count is
+    // needed because parallel tools may finish at different times.
+    let tool_running = Arc::new(AtomicUsize::new(0));
     let live_status = Arc::new(Mutex::new(LiveStatus::default()));
     {
         use crossterm::tty::IsTty;
+        if let Ok(mut status) = live_status.lock() {
+            status.tui = options.tui.clone();
+        }
         if options.queueing
+            && options.tui.is_none()
             && !options.fast_mode
             && io::stdout().is_tty()
             && io::stdin().is_tty()
@@ -372,6 +722,11 @@ pub async fn run_code_agent_with_options(
 
     let approve_cb = |approval: &AgentApproval| -> Result<ApprovalOutcome, String> {
         approve_approval_active.store(true, Ordering::Relaxed);
+        if let Some(tui) = &options.tui {
+            let result = tui_approval(tui, approval, root, &mut permission_rules);
+            approve_approval_active.store(false, Ordering::Relaxed);
+            return result;
+        }
         // Synchronous, not polled: `wait_for_escape_interrupt` holds raw
         // mode continuously while the queueing box is live (see its docs),
         // and only reacts to `approval_active` on its next ~15ms tick. Every
@@ -393,6 +748,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,
@@ -600,19 +970,19 @@ pub async fn run_code_agent_with_options(
                     if timer_agent_done.load(Ordering::Relaxed) {
                         break;
                     }
-                    if !timer_tool_running.load(Ordering::Relaxed) {
-                        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())
-                                )
-                            },
-                        );
+                    if timer_tool_running.load(Ordering::Relaxed) == 0 {
+                        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);
                 }
@@ -634,7 +1004,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,
@@ -648,6 +1026,7 @@ pub async fn run_code_agent_with_options(
             } => {
                 if !options.fast_mode
                     && !progress_approval_active.load(Ordering::Relaxed)
+                    && progress_tool_running.load(Ordering::Relaxed) == 0
                     && let Ok(mut status) = progress_live_status.lock()
                 {
                     status.context_pct = context_pct;
@@ -655,6 +1034,7 @@ pub async fn run_code_agent_with_options(
                     status.input_tokens = input_tokens;
                     status.generated_tokens = generated_tokens;
                     status.estimated_tokens = estimated_tokens;
+                    status.active_tool_started = None;
                     // Re-derive the animation rate from this real data point
                     // every time one arrives (cumulative generated tokens /
                     // elapsed turn time so far) — see
@@ -689,12 +1069,44 @@ 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 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,
             } => {
                 if !options.fast_mode
                     && !progress_approval_active.load(Ordering::Relaxed)
+                    && progress_tool_running.load(Ordering::Relaxed) == 0
                     && let Ok(mut status) = progress_live_status.lock()
                 {
                     status.waiting_for_network = Some((attempt, max_attempts));
@@ -707,8 +1119,48 @@ pub async fn run_code_agent_with_options(
                     && !progress_approval_active.load(Ordering::Relaxed)
                     && let Ok(mut status) = progress_live_status.lock()
                 {
-                    commit_activity_snapshot(&mut status);
-                    print_timeline_note(&mut status, &thought);
+                    commit_activity_snapshot_if_idle(
+                        &mut status,
+                        progress_tool_running.load(Ordering::Relaxed),
+                    );
+                    let elapsed = started_at.elapsed();
+                    print_timeline_note(&mut status, &thought, elapsed, None);
+                    status.thinking = None;
+                    status.waiting_for_network = None;
+                    render_live_status(&mut status);
+                }
+            }
+            AgentProgress::ThinkingDelta {
+                id,
+                delta,
+                elapsed_ms,
+            } => {
+                if !options.fast_mode {
+                    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 {
+                id,
+                thought,
+                elapsed_ms,
+            } => {
+                if !options.fast_mode
+                    && !progress_approval_active.load(Ordering::Relaxed)
+                    && let Ok(mut status) = progress_live_status.lock()
+                {
+                    commit_activity_snapshot_if_idle(
+                        &mut status,
+                        progress_tool_running.load(Ordering::Relaxed),
+                    );
+                    let elapsed = elapsed_ms
+                        .map(Duration::from_millis)
+                        .unwrap_or_else(|| started_at.elapsed());
+                    print_extended_thinking(&mut status, &thought, elapsed, id.as_deref());
                     status.thinking = None;
                     status.waiting_for_network = None;
                     render_live_status(&mut status);
@@ -718,9 +1170,15 @@ pub async fn run_code_agent_with_options(
                 action,
                 input,
                 subagent,
+                ..
             } => {
-                progress_tool_running.store(true, Ordering::Relaxed);
-                if !options.fast_mode && !progress_approval_active.load(Ordering::Relaxed) {
+                progress_tool_running.fetch_add(1, Ordering::Relaxed);
+                if !options.fast_mode
+                    && (options.tui.is_some() || !progress_approval_active.load(Ordering::Relaxed))
+                {
+                    if let Ok(mut status) = progress_live_status.lock() {
+                        status.active_tool_started = Some(std::time::Instant::now());
+                    }
                     if let Some(subagent_name) = subagent {
                         // A tool call happening *inside* a running subagent's own
                         // nested loop (tagged by `dispatch_one_subagent`) — render
@@ -755,13 +1213,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) {
@@ -793,9 +1264,22 @@ pub async fn run_code_agent_with_options(
                 input,
                 result,
                 subagent,
+                ..
             } => {
-                progress_tool_running.store(false, Ordering::Relaxed);
-                if !options.fast_mode && !progress_approval_active.load(Ordering::Relaxed) {
+                let remaining = progress_tool_running
+                    .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |running| {
+                        Some(running.saturating_sub(1))
+                    })
+                    .unwrap_or(0)
+                    .saturating_sub(1);
+                if !options.fast_mode
+                    && (options.tui.is_some() || !progress_approval_active.load(Ordering::Relaxed))
+                {
+                    if remaining == 0
+                        && let Ok(mut status) = progress_live_status.lock()
+                    {
+                        status.active_tool_started = None;
+                    }
                     if subagent.is_some() {
                         // Nested call inside a subagent finished — the ToolStart
                         // line already shown covers it; only the command-output
@@ -854,13 +1338,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);
@@ -870,7 +1370,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);
                         }
@@ -886,11 +1389,20 @@ pub async fn run_code_agent_with_options(
                     status.web_sources.extend(sources);
                 }
             }
+            AgentProgress::ToolDiscovery { .. }
+            | AgentProgress::DeviceState { .. }
+            | AgentProgress::ToolProgress { .. }
+            | AgentProgress::ToolArtifacts { .. } => {}
             AgentProgress::PlanUpdated { plan } => {
                 if let Ok(mut status) = progress_live_status.lock() {
                     status.thinking = None;
                     status.waiting_for_network = None;
-                    let mut card = format!("\x1b[1;36m┌─ Plan: {} \x1b[0m\n", plan.objective);
+                    let mut card = format!(
+                        "{}┌─ Plan: {} {}\n",
+                        crate::terminal_theme::ANSI_ACCENT_BOLD,
+                        plan.objective,
+                        crate::terminal_theme::ANSI_RESET
+                    );
                     for task in &plan.tasks {
                         let mark = match task.status.as_str() {
                             "completed" => "\x1b[32m[✓]\x1b[0m",
@@ -900,7 +1412,11 @@ pub async fn run_code_agent_with_options(
                         };
                         card.push_str(&format!("│  {} {}\n", mark, task.title));
                     }
-                    card.push_str("\x1b[1;36m└────────────────────────────────────────\x1b[0m");
+                    card.push_str(&format!(
+                        "{}└────────────────────────────────────────{}",
+                        crate::terminal_theme::ANSI_ACCENT_BOLD,
+                        crate::terminal_theme::ANSI_RESET
+                    ));
                     status.tasks.push(card.into());
                     render_live_status(&mut status);
                 }
@@ -909,190 +1425,51 @@ pub async fn run_code_agent_with_options(
                 if let Ok(mut status) = progress_live_status.lock() {
                     status.thinking = None;
                     status.waiting_for_network = None;
-                    let outcome_str = match summary.outcome.as_str() {
-                        "SUCCESS" => "\x1b[32m✓ Success\x1b[0m",
-                        "FAILED" => "\x1b[31m✗ Failure\x1b[0m",
-                        "ROLLED_BACK" => "\x1b[33m↺ Rolled Back\x1b[0m",
-                        _ => &summary.outcome,
-                    };
-                    let tokens_k = if summary.total_tokens >= 1000 {
-                        format!("{:.1}k", summary.total_tokens as f64 / 1000.0)
-                    } else {
-                        summary.total_tokens.to_string()
-                    };
-                    let created_count = summary.files_created.len();
-                    let modified_count = summary.files_changed.len().saturating_sub(created_count);
-                    let files_str = if created_count > 0 && modified_count > 0 {
-                        format!("{} created, {} modified", created_count, modified_count)
-                    } else if created_count > 0 {
-                        format!("{} created", created_count)
-                    } else {
-                        format!("{} modified", summary.files_changed.len())
-                    };
-                    let mut card = format!(
-                        "\x1b[1;36m┌─ Agent Run #{} ────────────────────────────\x1b[0m\n\
-                         │ Status:   {}\n\
-                         │ Duration: {:.1}s\n\
-                         │ Tokens:   {}\n\
-                         │ Tools:    {} calls ({} retries)\n\
-                         │ Files:    {}\n",
-                        summary.run_id,
-                        outcome_str,
-                        summary.duration_secs,
-                        tokens_k,
-                        summary.tool_calls_count,
-                        summary.retries_count,
-                        files_str,
-                    );
-                    if !summary.tool_timeline.is_empty() {
-                        card.push_str("│\n│ Tool calls timeline:\n");
-                        for rec in &summary.tool_timeline {
-                            let status_icon = if !rec.success {
-                                "\x1b[31m✗\x1b[0m"
-                            } else if rec.retried {
-                                "\x1b[33m↺\x1b[0m"
-                            } else {
-                                "\x1b[32m✓\x1b[0m"
-                            };
-                            let note = if !rec.success {
-                                " (failed)"
-                            } else if rec.retried {
-                                " (self-corrected)"
-                            } else {
-                                ""
-                            };
-                            let target_desc = if rec.target.is_empty() {
-                                String::new()
-                            } else {
-                                format!(" [{}]", rec.target)
-                            };
-                            card.push_str(&format!(
-                                "│  {:02}s {} {}{}{}\n",
-                                rec.step, status_icon, rec.action, target_desc, note
-                            ));
-                        }
-                    }
-                    card.push_str("\x1b[1;36m└────────────────────────────────────────\x1b[0m");
-                    status.tasks.push(card.into());
-                    render_live_status(&mut status);
-                }
-            }
-        }
-    };
-
-    let chunk_live_status = Arc::clone(&live_status);
-    let chunk_agent_done = Arc::clone(&agent_done);
-    let on_chunk = |summary: String| {
-        // Flip this *before* touching anything else — `agent_loop` still has
-        // async work left (memory writes, etc.) after calling `on_chunk`, so
-        // the real "done" store below (after `agent_loop.await`) fires too
-        // late: the periodic status ticker keeps polling every 150ms in the
-        // meantime and, seeing `agent_done` still false, unconditionally
-        // resurrects `status.thinking` and re-renders — reconstructing a
-        // fresh inline TUI viewport mid-print if that lands while the plain
-        // `print!`s below are still spooling out a long answer (e.g. a big
-        // markdown table), corrupting the terminal. Setting it here closes
-        // that window instead of only the (much narrower) one the
-        // `accepting_input` flag below covers.
-        chunk_agent_done.store(true, Ordering::Relaxed);
-        let mut committed_activity = false;
-        if !options.fast_mode
-            && let Ok(mut status) = chunk_live_status.lock()
-        {
-            status.thinking = None;
-            status.waiting_for_network = None;
-            // Stop accepting keystrokes for the queueing box before it's torn
-            // down below — otherwise a keypress landing between this
-            // `clear_live_status` and the final answer's plain `println!`
-            // would resurrect the box (via `render_live_status`'s lazy
-            // `InlineTui::ensure`) at whatever the cursor's current position
-            // happens to be, underneath the answer that just printed.
-            status.accepting_input = false;
-            committed_activity = commit_activity_snapshot(&mut status);
-            clear_live_status(&mut status);
-        }
-        // Same reasoning as `approve_cb`: drop raw mode synchronously,
-        // right here, rather than leaving `wait_for_escape_interrupt` to
-        // notice `accepting_input` went false on its next tick — the prints
-        // below need cooked mode's `\n` → `\r\n` translation immediately.
-        let _ = crossterm::terminal::disable_raw_mode();
-        let formatted_summary = format_markdown_bold(&sanitize_latex(&summary));
-        // `commit_activity_snapshot` above already ended on a blank line when
-        // it committed anything (e.g. a tool-use activity block) — printing
-        // this leading "\n" unconditionally on top of that stacked two blank
-        // lines before every answer that followed tool use.
-        if committed_activity {
-            print!("  {MINT}Mint:{RESET} ");
-        } else {
-            print!("\n  {MINT}Mint:{RESET} ");
-        }
-        avatar_bridge.on_talking(true);
-        render_live_summary(&formatted_summary);
-        avatar_bridge.on_talking(false);
-
-        // Print web search sources if any were collected (grouped by domain)
-        if let Ok(mut status) = chunk_live_status.lock()
-            && !status.web_sources.is_empty()
-        {
-            println!();
-            println!("  {DIM}Sources:{RESET}");
-
-            let mut domain_groups: Vec<(String, Vec<(String, String)>)> = Vec::new();
-            for (title, url) in status.web_sources.drain(..) {
-                let domain = extract_domain(&url);
-                if let Some(group) = domain_groups.iter_mut().find(|(d, _)| d == &domain) {
-                    group.1.push((title, url));
-                } else {
-                    domain_groups.push((domain, vec![(title, url)]));
-                }
-            }
+                    commit_activity_snapshot(&mut status);
 
-            for (i, (domain, items)) in domain_groups.iter().enumerate() {
-                let (first_title, first_url) = &items[0];
-                let extra_count = items.len() - 1;
-                if extra_count > 0 {
-                    println!(
-                        "  {DIM}{}.{RESET} {BLUE}{}{RESET} {DIM}({}){RESET} {CYAN}[+{} extra]{RESET}",
-                        i + 1,
-                        first_title,
-                        domain,
-                        extra_count
-                    );
-                } else {
-                    println!(
-                        "  {DIM}{}.{RESET} {BLUE}{}{RESET} {DIM}({}){RESET}",
-                        i + 1,
-                        first_title,
-                        domain
-                    );
+                    let lines = run_summary_lines(&summary);
+                    insert_permanent_lines(&mut status, &lines);
                 }
-                println!("     {DIM}{}{RESET}", first_url);
             }
         }
-
-        println!();
     };
 
+    // Providers may still stream internally, but the CLI deliberately waits
+    // for AgentResult.summary so it can render one complete Markdown document.
+    let on_chunk = |_summary: String| {};
+
     let user_name = MemoryStore::open_default()
         .ok()
         .and_then(|memory| memory.get_profile("name").ok().flatten());
 
-    let agent_loop = orchestrate_agent_loop(
-        config,
-        task,
-        root,
-        image_data_uri,
-        None,
-        video_data_uri,
-        Some(CHAT_CLI_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 target_chat_id = options.chat_id.as_deref().unwrap_or(CHAT_CLI_ID);
+
+    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,
@@ -1111,51 +1488,53 @@ pub async fn run_code_agent_with_options(
         status.thinking = None;
         status.waiting_for_network = None;
         status.accepting_input = false;
+        commit_activity_snapshot(&mut status);
         if let Ok(mut out) = queued_out.lock() {
-            *out = status.queued.clone();
+            *out = options
+                .tui
+                .as_ref()
+                .map(|tui| tui.take_queued())
+                .unwrap_or_else(|| status.queued.clone());
         }
         if let Ok(mut out) = draft_out.lock() {
-            *out = if status.draft.is_empty() {
-                None
-            } else {
-                Some(status.draft.iter().collect())
-            };
-        }
-        if res.is_err() {
-            commit_activity_snapshot(&mut status);
+            *out = options
+                .tui
+                .as_ref()
+                .and_then(|tui| tui.draft())
+                .or_else(|| (!status.draft.is_empty()).then(|| status.draft.iter().collect()));
         }
         clear_live_status(&mut status);
     }
-    let res = res.map_err(|e| anyhow!("{}", e))?;
-
-    if should_show_verification(&res.verification) {
-        println!("  Verification: {}", res.verification);
+    let mut res = res.map_err(|e| anyhow!("{}", e))?;
+    if let Ok(status) = live_status.lock() {
+        if res.input_tokens == 0 && status.input_tokens > 0 {
+            res.input_tokens = status.input_tokens;
+        }
+        if res.generated_tokens == 0 && status.generated_tokens > 0 {
+            res.generated_tokens = status.generated_tokens;
+        }
     }
-    let badge_plain = if let Some(fb_provider) = &res.fallback {
+
+    let badge_plain = if let Some(orig_provider) = &res.fallback {
+        let reason_suffix = if let Some(reason) = &res.fallback_reason {
+            format!(" ({reason})")
+        } else {
+            String::new()
+        };
         format!(
-            "{} • {} → fallback: {} • {}",
-            config.ai_provider,
-            crate::active_model(&config.ai_provider, config),
-            fb_provider,
+            "{} • {}{} → fallback: {} • {}",
+            orig_provider,
+            crate::active_model(orig_provider, config),
+            reason_suffix,
+            res.provider,
             res.model
         )
     } else {
         format!("{} • {}", res.provider, res.model)
     };
 
-    // "─ Worked for {elapsed} • {provider} • {model}" as one *labeled*
-    // divider — filled out with more "─" to the same width the box's own
-    // two divider lines use — rather than the provider/model badge and the
-    // elapsed-time label as two separate short lines followed by a third,
-    // unlabeled full-width divider directly under them. The three used to
-    // look like unrelated elements stacked on top of each other; folding
-    // both labels into one rule reads as a single line doing all three
-    // jobs, matching the box below it.
     let (tw, _) = markdown::terminal_size_or_default();
-    let width = tw as usize;
-    // `↑` context stays dim with the rest of the footer; `↓` generated drops
-    // out of DIM for its segment so the "what the model actually produced"
-    // number reads a touch stronger than the divider around it.
+    let width = (tw as usize).saturating_sub(6).max(40);
     let tokens_suffix = if res.input_tokens > 0 || res.generated_tokens > 0 {
         format!(
             " • ↑ {} · {RESET}↓ {}{DIM}",
@@ -1169,11 +1548,77 @@ pub async fn run_code_agent_with_options(
         "─ Worked for {}{tokens_suffix} • {badge_plain}",
         format_elapsed(started_at.elapsed())
     );
-    // Count only visible columns for the fill — `tokens_suffix` carries ANSI
-    // codes that don't occupy screen width.
     let label_width = strip_ansi_escapes(&label).chars().count();
-    let fill_len = width.saturating_sub(2).saturating_sub(label_width + 1);
-    println!("  {DIM}{label} {}{RESET}", "─".repeat(fill_len));
+    let fill_len = width.saturating_sub(label_width + 1);
+    let worked_line = format!("{DIM}{label} {}{RESET}", "─".repeat(fill_len));
+
+    if let Some(tui) = &options.tui {
+        tui.push_assistant(res.summary.clone());
+        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}"));
+        }
+        tui.push_notice(worked_line);
+        avatar_bridge.on_talking(false);
+        return Ok(res);
+    }
+
+    let formatted_summary = format_markdown_bold(&sanitize_latex(&res.summary));
+    print!("\n  {MINT}Mint:{RESET} ");
+    avatar_bridge.on_talking(true);
+    render_live_summary(&formatted_summary);
+    avatar_bridge.on_talking(false);
+    println!();
+
+    // Print web search sources once after the streamed answer is complete.
+    if let Ok(mut status) = live_status.lock()
+        && !status.web_sources.is_empty()
+    {
+        println!("  {DIM}Sources:{RESET}");
+
+        let mut domain_groups: Vec<(String, Vec<(String, String)>)> = Vec::new();
+        for (title, url) in status.web_sources.drain(..) {
+            let domain = extract_domain(&url);
+            if let Some(group) = domain_groups.iter_mut().find(|(d, _)| d == &domain) {
+                group.1.push((title, url));
+            } else {
+                domain_groups.push((domain, vec![(title, url)]));
+            }
+        }
+
+        for (i, (domain, items)) in domain_groups.iter().enumerate() {
+            let (first_title, first_url) = &items[0];
+            let extra_count = items.len() - 1;
+            if extra_count > 0 {
+                println!(
+                    "  {DIM}{}.{RESET} {BLUE}{}{RESET} {DIM}({}){RESET} {CYAN}[+{} extra]{RESET}",
+                    i + 1,
+                    first_title,
+                    domain,
+                    extra_count
+                );
+            } else {
+                println!(
+                    "  {DIM}{}.{RESET} {BLUE}{}{RESET} {DIM}({}){RESET}",
+                    i + 1,
+                    first_title,
+                    domain
+                );
+            }
+            println!("     {DIM}{}{RESET}", first_url);
+        }
+        println!();
+    }
+
+    println!("  {worked_line}");
 
     Ok(res)
 }
@@ -1364,6 +1809,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!(