@pheem49/mint 1.8.0 → 1.8.2

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

@@ -110,6 +110,8 @@ enum Command {
     },
     /// Run one queued or supplied task through the native CLI agent.
     Agent { task: Option<String> },
+    /// Start the browser automation environment and enable browser actions.
+    Auto,
     /// Launch the web UI and local API server.
     Web,
     /// Start only the local API server.
@@ -453,6 +455,21 @@ enum MemoryCommand {
     },
 }
 
+fn print_mcp_servers(servers: &std::collections::BTreeMap<String, mint_core::mcp::McpServer>) {
+    if servers.is_empty() {
+        println!("{DIM}(No MCP servers configured.){RESET}\n");
+        return;
+    }
+    for (name, srv) in servers {
+        let args_str = srv.args.join(" ");
+        println!(
+            "  {BLUE}●{RESET} {name} {DIM}({} {}){RESET}",
+            srv.command, args_str
+        );
+    }
+    println!();
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
     match Cli::parse().command {
@@ -523,6 +540,99 @@ async fn main() -> Result<()> {
             Command::Agent { task } => {
                 run_cli_agent_task(task).await?;
             }
+            Command::Auto => {
+                println!("🚀 Starting Mint Browser Automation Environment...");
+                let config = mint_core::load_config()?;
+                mint_core::spawn_automation_browser(&config)
+                    .await
+                    .map_err(anyhow::Error::msg)?;
+
+                // Enable the browser tools if they are disabled
+                let mut config_mut = config.clone();
+                let mut changed = false;
+                for tool in &[
+                    "browser_open",
+                    "browser_click",
+                    "browser_type",
+                    "browser_read",
+                ] {
+                    if config_mut.disabled_tools.contains(&tool.to_string()) {
+                        config_mut.disabled_tools.retain(|x| x != *tool);
+                        changed = true;
+                    }
+                }
+                if changed {
+                    mint_core::save_config(&config_mut)?;
+                    println!(
+                        "✅ Enabled browser automation tools in config: browser_open, browser_click, browser_type, browser_read"
+                    );
+                }
+
+                println!(
+                    "🌐 Isolated browser running with remote debugging on http://127.0.0.1:9222"
+                );
+                println!(
+                    "💬 Keep this terminal open while you want Mint to automate browser tasks."
+                );
+                println!("Press Ctrl+C to terminate the automation browser session.");
+                println!("----------------------------------------------------------------------");
+
+                // Start tailing the log file in a background task
+                let log_dir = dirs::config_dir()
+                    .unwrap_or_else(|| std::env::temp_dir())
+                    .join("mint");
+                let log_file = log_dir.join("browser-automation.log");
+
+                // Clear existing log file on startup
+                let _ = std::fs::remove_file(&log_file);
+
+                let log_file_clone = log_file.clone();
+                tokio::spawn(async move {
+                    use std::io::{BufRead, BufReader, Seek, SeekFrom};
+                    let mut file_pos = 0;
+                    loop {
+                        if log_file_clone.exists() {
+                            if let Ok(mut file) = std::fs::File::open(&log_file_clone) {
+                                if let Ok(_) = file.seek(SeekFrom::Start(file_pos)) {
+                                    let reader = BufReader::new(file);
+                                    for line in reader.lines() {
+                                        if let Ok(line_str) = line {
+                                            if line_str.contains("[NAVIGATE]")
+                                                || line_str.contains("[NAVIGATE_SUCCESS]")
+                                            {
+                                                println!("🌐 {line_str}");
+                                            } else if line_str.contains("[CLICK]")
+                                                || line_str.contains("[CLICK_SUCCESS]")
+                                            {
+                                                println!("🖱️ {line_str}");
+                                            } else if line_str.contains("[TYPE]")
+                                                || line_str.contains("[TYPE_SUCCESS]")
+                                            {
+                                                println!("⌨️ {line_str}");
+                                            } else if line_str.contains("[READ]")
+                                                || line_str.contains("[READ_SUCCESS]")
+                                            {
+                                                println!("📖 {line_str}");
+                                            } else if line_str.contains("_ERROR]") {
+                                                println!("❌ {line_str}");
+                                            } else {
+                                                println!("📝 {line_str}");
+                                            }
+                                        }
+                                    }
+                                    if let Ok(pos) = log_file_clone.metadata().map(|m| m.len()) {
+                                        file_pos = pos;
+                                    }
+                                }
+                            }
+                        }
+                        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+                    }
+                });
+
+                tokio::signal::ctrl_c().await.ok();
+                println!("\n👋 Terminating Mint Browser Automation Environment...");
+            }
             Command::Web => {
                 launch_mint_target("web".into()).await?;
             }
@@ -539,7 +649,10 @@ async fn main() -> Result<()> {
                     mcp::add(&name, &command, args, env)?;
                     println!("Added MCP server: {name}");
                 }
-                McpCommand::List => println!("{}", serde_json::to_string_pretty(&mcp::list()?)?),
+                McpCommand::List => {
+                    println!("\n{BLUE}MCP servers:{RESET}");
+                    print_mcp_servers(&mcp::list()?);
+                }
                 McpCommand::Remove { name } => {
                     println!(
                         "{}",
@@ -585,10 +698,55 @@ async fn main() -> Result<()> {
             Command::Learn { path, list, delete } => {
                 let memory = MemoryStore::open_default()?;
                 if list {
-                    println!(
-                        "{}",
-                        serde_json::to_string_pretty(&memory.learned_skills(100)?)?
-                    );
+                    let mut skills = memory.learned_skills(100)?;
+
+                    if let Some(home) = dirs::home_dir() {
+                        let global_skills_path =
+                            home.join(".config").join("mint").join("mint-skills");
+                        mint_core::skills::load_skills_from_dir(&global_skills_path, &mut skills);
+                    }
+                    if let Ok(root) = std::env::current_dir() {
+                        if let Ok(root) = root.canonicalize() {
+                            let workspace_skills_path1 = root.join(".agents").join("skills");
+                            mint_core::skills::load_skills_from_dir(
+                                &workspace_skills_path1,
+                                &mut skills,
+                            );
+
+                            let workspace_skills_path2 = root.join("skills");
+                            mint_core::skills::load_skills_from_dir(
+                                &workspace_skills_path2,
+                                &mut skills,
+                            );
+                        }
+                    }
+
+                    let mut unique_skills = std::collections::BTreeMap::new();
+                    for skill in skills {
+                        let loc = if skill.source_path.contains("/.config/mint/mint-skills") {
+                            "Global"
+                        } else if skill.source_path.contains("/skills")
+                            || skill.source_path.contains("/.agents/skills")
+                        {
+                            "Workspace"
+                        } else {
+                            "Taught"
+                        };
+                        unique_skills.insert(skill.name.clone(), (skill, loc));
+                    }
+
+                    if unique_skills.is_empty() {
+                        println!("No learned skills found.");
+                    } else {
+                        println!("Learned AI Skills:");
+                        for (name, (skill, loc)) in &unique_skills {
+                            if *loc == "Taught" {
+                                println!("  ● [{}] {}", loc, name);
+                            } else {
+                                println!("  ● [{}] {} (Source: {})", loc, name, skill.source_path);
+                            }
+                        }
+                    }
                 } else if let Some(identifier) = delete {
                     println!("{}", memory.delete_learned_skill(&identifier)?);
                 } else if let Some(path) = path {
@@ -645,6 +803,7 @@ async fn main() -> Result<()> {
                             audio_data_uri: None,
                             document_attachment: None,
                             workspace_path: None,
+                            agent_id: None,
                         },
                     )
                     .await?;
@@ -1315,6 +1474,9 @@ impl CliStreamFormatter {
                     print_fn(ch);
                 }
                 print_fn('\n');
+                for ch in "  ".chars() {
+                    print_fn(ch);
+                }
             } else {
                 if is_table_line(&line) {
                     self.table_buffer.push(line);
@@ -1327,6 +1489,9 @@ impl CliStreamFormatter {
                         print_fn(ch);
                     }
                     print_fn('\n');
+                    for ch in "  ".chars() {
+                        print_fn(ch);
+                    }
                 }
             }
         }
@@ -1597,8 +1762,12 @@ async fn handle_slash_command(
                 ("/mcp list", "List configured MCP servers"),
                 ("/mcp allow <server> <tool>", "Allow an MCP tool"),
                 ("/stats", "Show session statistics"),
-                ("/exit | /quit", "Exit Mint"),
+                ("/exit", "Exit Mint"),
                 ("/code <task>", "Run in code-agent mode"),
+                (
+                    "/multi-agent [on|off]",
+                    "Show or toggle Multi-Agent Collaboration system",
+                ),
             ];
             for (cmd_name, desc) in &commands {
                 println!("  {MINT}{:<30}{RESET} {DIM}{}{RESET}", cmd_name, desc);
@@ -1639,13 +1808,77 @@ async fn handle_slash_command(
                 println!();
             } else {
                 session.config.ai_provider = rest.to_owned();
+                match mint_core::save_config(&session.config) {
+                    Ok(()) => {
+                        let active_model = active_model(&session.config.ai_provider, &session.config);
+                        let display_name = format!("Changed model to {} • {}", session.config.ai_provider, active_model);
+
+                        // Save system event interaction in memory
+                        if let Ok(memory) = MemoryStore::open_default() {
+                            let _ = memory.add_interaction_for_chat_with_fallback(
+                                CHAT_CLI_ID,
+                                &display_name,
+                                "",
+                                "system",
+                                "provider_change",
+                                None,
+                            );
+                        }
+
+                        println!(
+                            "\n{DIM}───{RESET} {MINT}{}{RESET} {DIM}───{RESET}\n",
+                            display_name
+                        );
+                    }
+                    Err(error) => println!("{ERROR}Config error:{RESET} {error}"),
+                }
+            }
+            Some(SlashResult::Handled)
+        }
+
+        "/multi-agent" => {
+            if rest == "on" || rest == "off" {
+                session.config.enable_agent_collaboration = rest == "on";
                 match mint_core::save_config(&session.config) {
                     Ok(()) => println!(
-                        "{DIM}Switched to provider: {}{RESET}\n",
-                        session.config.ai_provider
+                        "{DIM}Multi-Agent collaboration set to: {}{RESET}\n",
+                        if session.config.enable_agent_collaboration { "Enabled" } else { "Disabled" }
                     ),
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}"),
+                    Err(error) => println!("{ERROR}Config error:{RESET} {error}\n"),
                 }
+            } else if !rest.is_empty() {
+                println!("{WARN}Usage: /multi-agent [on|off]{RESET}\n");
+            } else {
+                println!("\n{BLUE}Multi-Agent System Settings:{RESET}");
+                let collab_status = if session.config.enable_agent_collaboration {
+                    format!("{MINT}Enabled (on){RESET}")
+                } else {
+                    format!("{DIM}Disabled (off){RESET}")
+                };
+                println!("  Global Collaboration: {collab_status}");
+                println!("\n{BLUE}Configured Agents:{RESET}");
+                if session.config.agents.is_empty() {
+                    println!("  No agents configured.");
+                } else {
+                    for agent in &session.config.agents {
+                        let status_label = if agent.enabled {
+                            format!("{MINT}[Enabled]{RESET}")
+                        } else {
+                            format!("{DIM}[Disabled]{RESET}")
+                        };
+                        println!(
+                            "  {:<15} {}  Provider: {:<12} Model: {}",
+                            agent.name, status_label, agent.provider, agent.model
+                        );
+                        let truncated_instruction = if agent.system_instruction.len() > 60 {
+                            format!("{}...", &agent.system_instruction[..60].replace('\n', " "))
+                        } else {
+                            agent.system_instruction.replace('\n', " ")
+                        };
+                        println!("    {DIM}Instruction: {truncated_instruction}{RESET}");
+                    }
+                }
+                println!();
             }
             Some(SlashResult::Handled)
         }
@@ -1792,7 +2025,56 @@ async fn handle_slash_command(
 
         "/learn" => {
             if rest.is_empty() {
-                println!("{WARN}/learn usage: /learn <path>{RESET}\n");
+                let mut skills = match MemoryStore::open_default() {
+                    Ok(m) => match m.learned_skills(100) {
+                        Ok(s) => s,
+                        Err(e) => {
+                            println!("{ERROR}Error loading custom skills: {e}{RESET}\n");
+                            return Some(SlashResult::Handled);
+                        }
+                    },
+                    Err(e) => {
+                        println!("{ERROR}Memory error: {e}{RESET}\n");
+                        return Some(SlashResult::Handled);
+                    }
+                };
+
+                if let Some(home) = dirs::home_dir() {
+                    let global_skills_path = home.join(".config").join("mint").join("mint-skills");
+                    mint_core::skills::load_skills_from_dir(&global_skills_path, &mut skills);
+                }
+                let workspace_skills_path1 = session.current_dir.join(".agents").join("skills");
+                mint_core::skills::load_skills_from_dir(&workspace_skills_path1, &mut skills);
+                let workspace_skills_path2 = session.current_dir.join("skills");
+                mint_core::skills::load_skills_from_dir(&workspace_skills_path2, &mut skills);
+
+                let mut unique_skills = std::collections::BTreeMap::new();
+                for skill in skills {
+                    let loc = if skill.source_path.contains("/.config/mint/mint-skills") {
+                        "Global"
+                    } else if skill.source_path.contains("/skills")
+                        || skill.source_path.contains("/.agents/skills")
+                    {
+                        "Workspace"
+                    } else {
+                        "Taught"
+                    };
+                    unique_skills.insert(skill.name.clone(), (skill, loc));
+                }
+
+                if unique_skills.is_empty() {
+                    println!("No learned skills found. Use '/learn <path>' to add one.\n");
+                } else {
+                    println!("Learned AI Skills:");
+                    for (name, (skill, loc)) in &unique_skills {
+                        if *loc == "Taught" {
+                            println!("  ● [{}] {}", loc, name);
+                        } else {
+                            println!("  ● [{}] {} (Source: {})", loc, name, skill.source_path);
+                        }
+                    }
+                    println!();
+                }
             } else {
                 let path = PathBuf::from(rest);
                 let path = if path.is_absolute() {
@@ -1834,8 +2116,10 @@ async fn handle_slash_command(
                                 println!(
                                     "  {DIM}[{}]{RESET} {BLUE}You:{RESET} {}",
                                     &item.created_at[..16.min(item.created_at.len())],
-                                    if item.user_text.len() > 80 {
-                                        format!("{}…", &item.user_text[..80])
+                                    if item.user_text.chars().count() > 80 {
+                                        let short: String =
+                                            item.user_text.chars().take(80).collect();
+                                        format!("{}…", short)
                                     } else {
                                         item.user_text.clone()
                                     }
@@ -1903,15 +2187,9 @@ async fn handle_slash_command(
                 .unwrap_or((rest, ""));
             match subcmd {
                 "list" | "" => match mcp::list() {
-                    Ok(servers) if servers.is_empty() => {
-                        println!("{DIM}No MCP servers configured.{RESET}\n");
-                    }
                     Ok(servers) => {
                         println!("\n{BLUE}MCP servers:{RESET}");
-                        match serde_json::to_string_pretty(&servers) {
-                            Ok(json) => println!("{json}\n"),
-                            Err(e) => println!("{ERROR}Error:{RESET} {e}\n"),
-                        }
+                        print_mcp_servers(&servers);
                     }
                     Err(e) => println!("{ERROR}MCP error:{RESET} {e}\n"),
                 },
@@ -2291,7 +2569,7 @@ async fn run_interactive_chat() -> Result<()> {
                 .to_owned();
 
             println!();
-            print!("{MINT}Mint:{RESET} {DIM}Thinking...{RESET}");
+            print!("  {MINT}Mint:{RESET} {DIM}Thinking...{RESET}");
             let _ = io::stdout().flush();
 
             let mut system_instruction = format!(
@@ -2333,11 +2611,12 @@ async fn run_interactive_chat() -> Result<()> {
                     audio_data_uri: None,
                     document_attachment: None,
                     workspace_path: None,
+                    agent_id: None,
                 },
                 |chunk| {
                     if first_chunk {
                         first_chunk = false;
-                        print!("\r\x1b[2K{MINT}Mint:{RESET} ");
+                        print!("\r\x1b[2K  {MINT}Mint:{RESET} ");
                     }
                     filter.process_chunk(&chunk, |text| {
                         for c in text.chars() {
@@ -2426,51 +2705,69 @@ fn print_exit_message(session: &InteractiveSession) {
 }
 
 const AUTOCOMPLETE_COMMANDS: &[(&str, &str)] = &[
-    ("/help", "Show help menu"),
+    ("/cd", "Change active workspace directory"),
+    ("/clear", "Clear conversation history"),
+    ("/code", "Run in code-agent mode"),
+    ("/exit", "Exit Mint CLI"),
     ("/fast", "Toggle fast mode (hide thinking traces)"),
-    ("/models", "List AI providers or switch active provider"),
+    ("/help", "Show help menu"),
+    ("/image", "Attach image from disk"),
     (
         "/image-provider",
         "List image gen providers or switch default provider",
     ),
-    ("/clear", "Clear conversation history"),
-    ("/cd", "Change active workspace directory"),
-    ("/image", "Attach image from disk"),
-    ("/paste", "Attach image from clipboard"),
     ("/learn", "Import persistent skill/instruction"),
-    ("/plugins", "List or generate plugins/skills"),
-    ("/memory", "Manage long-term memory store"),
     ("/mcp", "List configured MCP servers"),
+    ("/memory", "Manage long-term memory store"),
+    ("/models", "List AI providers or switch active provider"),
+    ("/multi-agent", "Show or toggle Multi-Agent Collaboration system"),
+    ("/paste", "Attach image from clipboard"),
+    ("/plugins", "List or generate plugins/skills"),
     ("/stats", "Show session statistics"),
-    ("/exit", "Exit Mint CLI"),
-    ("/quit", "Exit Mint CLI"),
-    ("/code", "Run in code-agent mode"),
 ];
 
 fn draw_input_box(
-    input: &str,
+    input_chars: &[char],
+    cursor_pos: usize,
     placeholder: &str,
     model: &str,
     path_str: &str,
     tab_base_input: Option<&str>,
     tab_index: Option<usize>,
-) -> usize {
+) -> (usize, usize) {
     let (term_width, _) = crossterm::terminal::size().unwrap_or((80, 24));
     let width = term_width as usize;
     let prefix = "› ";
     let input_width = width.saturating_sub(2);
     let content_max_len = input_width.saturating_sub(prefix.chars().count());
 
-    let display_str = if input.is_empty() {
+    let mut start_idx = 0;
+    if input_chars.len() > content_max_len {
+        if cursor_pos >= content_max_len {
+            start_idx = (cursor_pos + 5).saturating_sub(content_max_len);
+            if start_idx + content_max_len > input_chars.len() {
+                start_idx = input_chars.len() - content_max_len;
+            }
+        }
+    }
+
+    let slice_chars = if input_chars.len() > content_max_len {
+        &input_chars[start_idx..std::cmp::min(start_idx + content_max_len, input_chars.len())]
+    } else {
+        input_chars
+    };
+    let displayed_input: String = slice_chars.iter().collect();
+
+    let display_str = if displayed_input.is_empty() {
         format!("{DIM}{}\x1b[39m", placeholder)
     } else {
-        format_placeholders(input)
+        format_placeholders(&displayed_input)
     };
 
-    let visible_len = if input.is_empty() {
+    let visible_len = if displayed_input.is_empty() {
         placeholder.chars().count()
     } else {
-        string_visual_width(input)
+        string_visual_width(&displayed_input)
     };
 
     let pad_len = content_max_len.saturating_sub(visible_len);
@@ -2498,7 +2795,8 @@ fn draw_input_box(
     );
 
     // Compute and draw suggestions
-    let search_query = tab_base_input.unwrap_or(input);
+    let raw_input: String = input_chars.iter().collect();
+    let search_query = tab_base_input.unwrap_or(&raw_input);
     let mut match_count = 0;
     if search_query.starts_with('/') {
         let matches: Vec<_> = AUTOCOMPLETE_COMMANDS
@@ -2507,11 +2805,18 @@ fn draw_input_box(
             .collect();
 
         if !matches.is_empty() {
-            match_count = matches.len();
-            println!();
-            println!(" {BLUE}Suggestions{RESET}");
+            let total_pages = (matches.len() + 4) / 5;
             let highlight_idx = tab_index.map(|idx| idx % matches.len());
-            for (i, (cmd, desc)) in matches.iter().enumerate() {
+            let selected_idx = highlight_idx.unwrap_or(0);
+            let current_page = selected_idx / 5;
+            let start_idx = current_page * 5;
+            let end_idx = std::cmp::min(start_idx + 5, matches.len());
+            match_count = end_idx - start_idx;
+
+            println!();
+            println!(" {BLUE}Suggestions ({}/{}){RESET}", current_page + 1, total_pages);
+            for i in start_idx..end_idx {
+                let (cmd, desc) = matches[i];
                 if Some(i) == highlight_idx {
                     println!("  {BLUE}▶ {:<16}{RESET} {DIM}- {}{RESET}", cmd, desc);
                 } else {
@@ -2522,11 +2827,29 @@ fn draw_input_box(
     }
 
     let _ = io::stdout().flush();
-    match_count
+    (match_count, start_idx)
 }
 
 fn input_cursor_column(input_chars: &[char], cursor_pos: usize) -> usize {
-    let visual_cursor_pos: usize = input_chars[..cursor_pos]
+    let (term_width, _) = crossterm::terminal::size().unwrap_or((80, 24));
+    let width = term_width as usize;
+    let prefix = "› ";
+    let input_width = width.saturating_sub(2);
+    let content_max_len = input_width.saturating_sub(prefix.chars().count());
+
+    let mut start_idx = 0;
+    if input_chars.len() > content_max_len {
+        if cursor_pos >= content_max_len {
+            start_idx = (cursor_pos + 5).saturating_sub(content_max_len);
+            if start_idx + content_max_len > input_chars.len() {
+                start_idx = input_chars.len() - content_max_len;
+            }
+        }
+    }
+
+    let cursor_pos_clamped = std::cmp::min(cursor_pos, input_chars.len());
+    let start_idx_clamped = std::cmp::min(start_idx, cursor_pos_clamped);
+    let visual_cursor_pos: usize = input_chars[start_idx_clamped..cursor_pos_clamped]
         .iter()
         .copied()
         .map(char_visual_width)
@@ -2557,9 +2880,9 @@ fn redraw_input_box(
     tab_index: Option<usize>,
 ) {
     clear_input_box();
-    let input: String = input_chars.iter().collect();
-    let match_count = draw_input_box(
-        &input,
+    let (match_count, _) = draw_input_box(
+        input_chars,
+        cursor_pos,
         placeholder,
         model,
         path_str,
@@ -2590,7 +2913,7 @@ fn read_line_interactive(
     let mut tab_base_input: Option<String> = None;
     let mut tab_index: Option<usize> = None;
 
-    let match_count = draw_input_box("", placeholder, model, path_str, None, None);
+    let (match_count, _) = draw_input_box(&input_chars, cursor_pos, placeholder, model, path_str, None, None);
     position_input_cursor(&input_chars, cursor_pos, match_count);
     let _ = io::stdout().flush();
 
@@ -2709,12 +3032,7 @@ fn read_line_interactive(
                             }
                         }
                         KeyCode::Char(c) => {
-                            let (term_width, _) = crossterm::terminal::size().unwrap_or((80, 24));
-                            let max_width = (term_width as usize).saturating_sub(4);
-                            let current_visual_width: usize =
-                                input_chars.iter().copied().map(char_visual_width).sum();
-
-                            if current_visual_width < max_width {
+                            if input_chars.len() < 10000 {
                                 input_chars.insert(cursor_pos, c);
                                 cursor_pos += 1;
 
@@ -2883,13 +3201,15 @@ fn read_line_interactive(
                                 }
                             }
                             disable_raw_mode()?;
-                            let visual_cursor_pos: usize = input_chars[..cursor_pos]
-                                .iter()
-                                .copied()
-                                .map(char_visual_width)
-                                .sum();
-                            print!("\x1b[{}G", 4 + visual_cursor_pos);
-                            let _ = io::stdout().flush();
+                            redraw_input_box(
+                                &input_chars,
+                                cursor_pos,
+                                placeholder,
+                                model,
+                                path_str,
+                                None,
+                                None,
+                            );
                             enable_raw_mode()?;
                         }
                         KeyCode::Right => {
@@ -2902,13 +3222,15 @@ fn read_line_interactive(
                                 }
                             }
                             disable_raw_mode()?;
-                            let visual_cursor_pos: usize = input_chars[..cursor_pos]
-                                .iter()
-                                .copied()
-                                .map(char_visual_width)
-                                .sum();
-                            print!("\x1b[{}G", 4 + visual_cursor_pos);
-                            let _ = io::stdout().flush();
+                            redraw_input_box(
+                                &input_chars,
+                                cursor_pos,
+                                placeholder,
+                                model,
+                                path_str,
+                                None,
+                                None,
+                            );
                             enable_raw_mode()?;
                         }
                         KeyCode::Enter => {
@@ -2926,7 +3248,7 @@ fn read_line_interactive(
                                 expanded_str = expanded_str.replace(placeholder_str, content);
                             }
 
-                            println!("{BLUE}You ›{RESET} {}", expanded_str);
+                            println!("  {BLUE}You ›{RESET} {}", expanded_str);
                             let _ = io::stdout().flush();
 
                             break Some(InteractiveInput {
@@ -3157,7 +3479,7 @@ pub fn confirm(prompt: &str) -> Result<bool> {
         .to_string();
 
     if SESSION_APPROVED.load(std::sync::atomic::Ordering::Relaxed) {
-        println!("{} {MINT}Approve (session-wide){RESET}", clean_prompt);
+        println!("  {} {MINT}Approve (session-wide){RESET}", clean_prompt);
         return Ok(true);
     }
 
@@ -3166,7 +3488,7 @@ pub fn confirm(prompt: &str) -> Result<bool> {
     use crossterm::tty::IsTty;
 
     if !io::stdout().is_tty() || enable_raw_mode().is_err() {
-        print!("{} [y/N] ", clean_prompt);
+        print!("  {} [y/N] ", clean_prompt);
         let _ = io::stdout().flush();
         let mut answer = String::new();
         io::stdin().read_line(&mut answer)?;
@@ -3177,7 +3499,7 @@ pub fn confirm(prompt: &str) -> Result<bool> {
     }
 
     let _ = disable_raw_mode();
-    println!("{}", clean_prompt);
+    println!("  {}", clean_prompt);
 
     let options = ["Approve", "Approve this session", "No"];
     let mut selected = 0;
@@ -3284,7 +3606,7 @@ pub fn confirm(prompt: &str) -> Result<bool> {
         1 => format!("{MINT}Approve this session{RESET}"),
         _ => format!("{ERROR}No{RESET}"),
     };
-    println!("{} {}", clean_prompt, result_str);
+    println!("  {} {}", clean_prompt, result_str);
     let _ = io::stdout().flush();
 
     match choice {
@@ -3357,6 +3679,7 @@ async fn run_github_overview(repo: &str, config: &MintConfig) -> Result<()> {
             audio_data_uri: None,
             document_attachment: None,
             workspace_path: None,
+            agent_id: None,
         },
     )
     .await?;