@pheem49/mint 1.8.1 → 1.9.0

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

@@ -494,8 +494,8 @@ async fn main() -> Result<()> {
                     println!("{}", serde_json::to_string_pretty(&load_config()?)?)
                 }
                 ConfigCommand::Set { key, value } => {
-                    let value = serde_json::from_str(&value)
-                        .unwrap_or_else(|_| serde_json::Value::String(value));
+                    let value =
+                        serde_json::from_str(&value).unwrap_or(serde_json::Value::String(value));
                     println!(
                         "{}",
                         serde_json::to_string_pretty(&set_config_value(&key, value)?)?
@@ -579,7 +579,7 @@ async fn main() -> Result<()> {
 
                 // Start tailing the log file in a background task
                 let log_dir = dirs::config_dir()
-                    .unwrap_or_else(|| std::env::temp_dir())
+                    .unwrap_or_else(std::env::temp_dir)
                     .join("mint");
                 let log_file = log_dir.join("browser-automation.log");
 
@@ -591,40 +591,37 @@ async fn main() -> Result<()> {
                     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;
-                                    }
+                        if log_file_clone.exists()
+                            && let Ok(mut file) = std::fs::File::open(&log_file_clone)
+                            && file.seek(SeekFrom::Start(file_pos)).is_ok()
+                        {
+                            let reader = BufReader::new(file);
+                            for line_str in reader.lines().flatten() {
+                                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;
                     }
@@ -705,20 +702,20 @@ async fn main() -> Result<()> {
                             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,
-                            );
+                    if let Ok(root) = std::env::current_dir()
+                        && 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 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();
@@ -803,6 +800,7 @@ async fn main() -> Result<()> {
                             audio_data_uri: None,
                             document_attachment: None,
                             workspace_path: None,
+                            agent_id: None,
                         },
                     )
                     .await?;
@@ -1152,10 +1150,10 @@ async fn main() -> Result<()> {
                                         ),
                                     }
                                 }
-                                if let Some(desc) = &result.description {
-                                    if !desc.is_empty() {
-                                        println!("\n{DIM}{desc}{RESET}");
-                                    }
+                                if let Some(desc) = &result.description
+                                    && !desc.is_empty()
+                                {
+                                    println!("\n{DIM}{desc}{RESET}");
                                 }
                             }
                             Err(e) => eprintln!("{ERROR}Failed to save images: {e}{RESET}"),
@@ -1200,16 +1198,16 @@ async fn launch_mint_target(target: String) -> Result<()> {
                         path = p.parent();
                     }
                 }
-                if found.is_none() {
-                    if let Ok(cwd) = std::env::current_dir() {
-                        let mut path = Some(cwd.as_path());
-                        while let Some(p) = path {
-                            if p.join("package.json").exists() {
-                                found = Some(p.to_path_buf());
-                                break;
-                            }
-                            path = p.parent();
+                if found.is_none()
+                    && let Ok(cwd) = std::env::current_dir()
+                {
+                    let mut path = Some(cwd.as_path());
+                    while let Some(p) = path {
+                        if p.join("package.json").exists() {
+                            found = Some(p.to_path_buf());
+                            break;
                         }
+                        path = p.parent();
                     }
                 }
                 found.ok_or_else(|| {
@@ -1218,7 +1216,7 @@ async fn launch_mint_target(target: String) -> Result<()> {
             };
             std::process::Command::new("npm")
                 .current_dir(&project_root)
-                .args(&["run", "dev:web"])
+                .args(["run", "dev:web"])
                 .stdout(std::process::Stdio::null())
                 .stderr(std::process::Stdio::null())
                 .spawn()
@@ -1401,7 +1399,7 @@ fn render_markdown_table(table_lines: &[String]) -> String {
     rendered.push_str(&draw_border("┌", "┬", "┐", "─", &col_widths));
 
     if let Some(ref header) = header_row {
-        rendered.push_str("│");
+        rendered.push('│');
         for (i, col) in header.iter().enumerate() {
             let width = unicode_width(col);
             let padding = col_widths[i] - width;
@@ -1410,20 +1408,20 @@ fn render_markdown_table(table_lines: &[String]) -> String {
                 col,
                 " ".repeat(padding + 1)
             ));
-            rendered.push_str("│");
+            rendered.push('│');
         }
         rendered.push('\n');
         rendered.push_str(&draw_border("├", "┼", "┤", "─", &col_widths));
     }
 
     for (r_idx, row) in data_rows.iter().enumerate() {
-        rendered.push_str("│");
+        rendered.push('│');
         for i in 0..num_cols {
             let col_val = row.get(i).cloned().unwrap_or_default();
             let width = unicode_width(&col_val);
             let padding = col_widths[i] - width;
             rendered.push_str(&format!(" {}{}", col_val, " ".repeat(padding + 1)));
-            rendered.push_str("│");
+            rendered.push('│');
         }
         rendered.push('\n');
 
@@ -1432,7 +1430,7 @@ fn render_markdown_table(table_lines: &[String]) -> String {
         }
     }
 
-    rendered.push_str(&draw_border("└", "┴", "┘", "─", &col_widths).trim_end());
+    rendered.push_str(draw_border("└", "┴", "┘", "─", &col_widths).trim_end());
     rendered
 }
 
@@ -1746,6 +1744,10 @@ async fn handle_slash_command(
                 ("/paste [prompt]", "Attach image from clipboard"),
                 ("Ctrl+V", "Paste clipboard image as [Image #1]"),
                 ("/learn <path>", "Import a persistent .md or .txt skill"),
+                (
+                    "/skill add <path>",
+                    "Copy/install skill file or folder to global config",
+                ),
                 (
                     "/plugins <name> [prompt]",
                     "Generate a skill.md file for a plugin/skill",
@@ -1761,8 +1763,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);
@@ -1803,13 +1809,85 @@ 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)
         }
@@ -2024,6 +2102,73 @@ async fn handle_slash_command(
             Some(SlashResult::Handled)
         }
 
+        "/skill" => {
+            let (subcmd, args) = rest
+                .split_once(char::is_whitespace)
+                .map(|(c, a)| (c, a.trim()))
+                .unwrap_or((rest, ""));
+
+            match subcmd {
+                "add" | "install" => {
+                    if args.is_empty() {
+                        println!(
+                            "{WARN}/skill add <path> requires a path to a skill file or folder{RESET}\n"
+                        );
+                    } else {
+                        let source_path = PathBuf::from(args);
+                        let source_path = if source_path.is_absolute() {
+                            source_path
+                        } else {
+                            session.current_dir.join(source_path)
+                        };
+
+                        if !source_path.exists() {
+                            println!("{ERROR}Source skill path not found: {}{RESET}\n", args);
+                        } else if let Some(home) = dirs::home_dir() {
+                            let global_skills_path =
+                                home.join(".config").join("mint").join("mint-skills");
+                            if !global_skills_path.exists() {
+                                let _ = std::fs::create_dir_all(&global_skills_path);
+                            }
+
+                            let name = source_path
+                                .file_name()
+                                .and_then(|n| n.to_str())
+                                .unwrap_or("skill");
+
+                            let dest_path = global_skills_path.join(name);
+                            let copy_res = if source_path.is_dir() {
+                                copy_dir_all(&source_path, &dest_path)
+                            } else {
+                                std::fs::copy(&source_path, &dest_path)
+                                    .map(|_| ())
+                                    .map_err(|e| e)
+                            };
+
+                            match copy_res {
+                                Ok(()) => println!(
+                                    "{DIM}Skill successfully copied to Global config: {}{RESET}\n",
+                                    dest_path.display()
+                                ),
+                                Err(e) => println!(
+                                    "{ERROR}Failed to copy skill to Global: {}{RESET}\n",
+                                    e
+                                ),
+                            }
+                        } else {
+                            println!(
+                                "{ERROR}Unable to resolve home directory for Global config.{RESET}\n"
+                            );
+                        }
+                    }
+                }
+                _ => {
+                    println!("{WARN}Usage: /skill add <path>  (or /skill install <path>){RESET}\n");
+                }
+            }
+            Some(SlashResult::Handled)
+        }
+
         "/memory" => {
             let memory = match MemoryStore::open_default() {
                 Ok(m) => m,
@@ -2222,44 +2367,40 @@ async fn handle_slash_command(
 
                 // Scan local workspace skills directory
                 let local_skills_dir = session.current_dir.join("skills");
-                if local_skills_dir.is_dir() {
-                    if let Ok(entries) = fs::read_dir(&local_skills_dir) {
-                        let mut local_files = Vec::new();
-                        for entry in entries.flatten() {
-                            let path = entry.path();
-                            if path.is_file() {
-                                if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
-                                    if matches!(ext.to_ascii_lowercase().as_str(), "md" | "txt") {
-                                        if let Some(name) =
-                                            path.file_name().and_then(|n| n.to_str())
-                                        {
-                                            if let Ok(canon_path) = path.canonicalize() {
-                                                local_files.push((name.to_owned(), canon_path));
-                                            } else {
-                                                local_files.push((name.to_owned(), path));
-                                            }
-                                        }
-                                    }
-                                }
+                if local_skills_dir.is_dir()
+                    && let Ok(entries) = fs::read_dir(&local_skills_dir)
+                {
+                    let mut local_files = Vec::new();
+                    for entry in entries.flatten() {
+                        let path = entry.path();
+                        if path.is_file()
+                            && let Some(ext) = path.extension().and_then(|e| e.to_str())
+                            && matches!(ext.to_ascii_lowercase().as_str(), "md" | "txt")
+                            && let Some(name) = path.file_name().and_then(|n| n.to_str())
+                        {
+                            if let Ok(canon_path) = path.canonicalize() {
+                                local_files.push((name.to_owned(), canon_path));
+                            } else {
+                                local_files.push((name.to_owned(), path));
                             }
                         }
+                    }
 
-                        let inactive_files: Vec<_> = local_files
-                            .into_iter()
-                            .filter(|(_, full_path)| !active_skills.contains(full_path))
-                            .map(|(name, _)| name)
-                            .collect();
+                    let inactive_files: Vec<_> = local_files
+                        .into_iter()
+                        .filter(|(_, full_path)| !active_skills.contains(full_path))
+                        .map(|(name, _)| name)
+                        .collect();
 
-                        if !inactive_files.is_empty() {
+                    if !inactive_files.is_empty() {
+                        println!(
+                            "\n{MINT}Local Skill Files (Found but not learned/active yet):{RESET}"
+                        );
+                        for file in inactive_files {
                             println!(
-                                "\n{MINT}Local Skill Files (Found but not learned/active yet):{RESET}"
+                                "  - {WARN}{:<20}{RESET} skills/{} {DIM}(Type '/learn skills/{}' to activate){RESET}",
+                                file, file, file
                             );
-                            for file in inactive_files {
-                                println!(
-                                    "  - {WARN}{:<20}{RESET} skills/{} {DIM}(Type '/learn skills/{}' to activate){RESET}",
-                                    file, file, file
-                                );
-                            }
                         }
                     }
                 }
@@ -2318,7 +2459,8 @@ async fn run_interactive_chat() -> Result<()> {
         now.format("%M")
     );
     let version = env!("CARGO_PKG_VERSION");
-    let line1_text = format!("[Mint] v{} | Active AI: {}", version, provider);
+    let clean_provider_name = format_provider_display_name(provider, &config);
+    let line1_text = format!("[Mint] v{} | Active AI: {}", version, clean_provider_name);
     let line2_text = format!("{} • {}", date_time, model);
 
     let len1 = line1_text.chars().count();
@@ -2340,7 +2482,7 @@ async fn run_interactive_chat() -> Result<()> {
         println!(
             "{MINT}|  \\/  (_)_ __ | |_ / __| |  |_ _|{RESET}   {DIM}│{RESET} {MINT}[Mint]{RESET} v{} | Active AI: {}{} {DIM}│{RESET}",
             version,
-            provider,
+            clean_provider_name,
             " ".repeat(content_width - len1)
         );
         println!(
@@ -2357,7 +2499,7 @@ async fn run_interactive_chat() -> Result<()> {
         println!(
             "{DIM}│{RESET} {MINT}[Mint]{RESET} v{} | Active AI: {}{} {DIM}│{RESET}",
             version,
-            provider,
+            clean_provider_name,
             " ".repeat(content_width - len1)
         );
         println!(
@@ -2397,11 +2539,11 @@ async fn run_interactive_chat() -> Result<()> {
     loop {
         if let Some(handle) = update_handle.take() {
             if handle.is_finished() {
-                if let Ok(Some((current, latest))) = handle.await {
-                    if !printed_update {
-                        updater::print_update_notice(&current, &latest);
-                        printed_update = true;
-                    }
+                if let Ok(Some((current, latest))) = handle.await
+                    && !printed_update
+                {
+                    updater::print_update_notice(&current, &latest);
+                    printed_update = true;
                 }
             } else {
                 update_handle = Some(handle);
@@ -2411,9 +2553,12 @@ async fn run_interactive_chat() -> Result<()> {
         let path_str = format_path_with_tilde(&session.current_dir);
         let model_str = active_model(&session.config.ai_provider, &session.config).to_owned();
 
-        if let Some(input) =
-            read_line_interactive(&session.config.ai_provider, &model_str, &path_str)?
-        {
+        if let Some(input) = read_line_interactive(
+            &session.config.ai_provider,
+            &model_str,
+            &path_str,
+            &session.current_dir,
+        )? {
             if let Some(uri) = input.pasted_image {
                 if let Some(ref mut current) = session.pending_image {
                     current.push(' ');
@@ -2427,6 +2572,72 @@ async fn run_interactive_chat() -> Result<()> {
                 continue;
             }
 
+            if query_str.starts_with('$') {
+                let (skill_word, task_part) = query_str
+                    .split_once(char::is_whitespace)
+                    .map(|(s, t)| (s, t.trim()))
+                    .unwrap_or((&query_str, ""));
+
+                let skill_name = skill_word.trim_start_matches('$').to_lowercase();
+                let skills = load_all_available_skills(&session.current_dir);
+                let skill_opt = skills.iter().find(|s| s.name.to_lowercase() == skill_name);
+
+                if let Some(skill) = skill_opt {
+                    println!("\n{BLUE}Skill: {}{RESET}", skill.name);
+                    if let Some(ref desc) = skill.description {
+                        println!("{DIM}{}{RESET}", desc);
+                    }
+                    println!("{DIM}────────────────────────────────────────────{RESET}");
+                    println!("{}", skill.content);
+                    println!("{DIM}────────────────────────────────────────────{RESET}\n");
+
+                    if confirm("ต้องการ activate skill นี้ไหม? [y/N] ")? {
+                        let final_task = if task_part.is_empty() {
+                            print!("พิมพ์ Task ที่ต้องการให้ทำงานด้วย Skill นี้: ");
+                            let _ = io::stdout().flush();
+                            let mut input = String::new();
+                            io::stdin().read_line(&mut input)?;
+                            let input = input.trim().to_owned();
+                            if input.is_empty() {
+                                println!("{WARN}Cancelled: Task cannot be empty.{RESET}\n");
+                                continue;
+                            }
+                            input
+                        } else {
+                            task_part.to_owned()
+                        };
+
+                        let task_with_skill = format!(
+                            "=== ACTIVATED SKILL: {} ===\n\
+                             {}\n\
+                             ===========================\n\n\
+                             Task: {}",
+                            skill.name, skill.content, final_task
+                        );
+
+                        println!();
+                        if let Err(error) = run_code_agent_with_saved_image(
+                            &task_with_skill,
+                            &session.current_dir,
+                            &session.config,
+                            session.pending_image.take(),
+                            agent::AgentOptions {
+                                fast_mode: session.fast_mode,
+                            },
+                        )
+                        .await
+                        {
+                            println!("{ERROR}Error:{RESET} {error}\n");
+                        }
+                    } else {
+                        println!("{DIM}Cancelled.{RESET}\n");
+                    }
+                } else {
+                    println!("{ERROR}Skill '{}' not found.{RESET}\n", skill_name);
+                }
+                continue;
+            }
+
             // Run slash-command router
             match handle_slash_command(&mut session, &query_str).await {
                 Some(SlashResult::Handled) => continue,
@@ -2503,8 +2714,7 @@ async fn run_interactive_chat() -> Result<()> {
             print!("  {MINT}Mint:{RESET} {DIM}Thinking...{RESET}");
             let _ = io::stdout().flush();
 
-            let mut system_instruction = format!(
-                "You are Mint, a cute and helpful AI assistant. You speak in a polite, friendly, and sweet Thai tone (using \"คุณ\", \"ค่ะ\", \"นะคะ\"). \
+            let mut system_instruction = "You are Mint, a cute and helpful AI assistant. You speak in a polite, friendly, and sweet Thai tone (using \"คุณ\", \"ค่ะ\", \"นะคะ\"). \
                 You are running inside the Mint CLI interactive chat. \
                 You have access to native system actions to help the user! If the user asks you to open a website, launch an app, read a file, list a folder, run code, run tests, or execute a local shell command, you can execute these actions by writing a special block at the very end of your response: \
                 `[ACTION: <command> <arguments>]` \
@@ -2515,15 +2725,14 @@ async fn run_interactive_chat() -> Result<()> {
                 - `[ACTION: read-folder <path>]` to list files/folders in a directory. \
                 - `[ACTION: run-shell <command>]` to run a non-destructive local shell command after approval. \
                 You may discuss mature personal topics at a non-explicit level, including adult relationships, sex education, intimacy, emotions, and feelings. Keep the tone respectful and supportive, avoid graphic sexual detail, and do not engage with sexual content involving minors, coercion, exploitation, or sexual violence. \
-                Write the action block on a single line at the very end of your response."
-            );
-            if let Ok(memory) = MemoryStore::open_default() {
-                if let Ok(Some(name)) = memory.get_profile("name") {
-                    system_instruction.push_str(&format!(
-                        "\nThe user's name is {}. Refer to them by their name when appropriate.",
-                        name
-                    ));
-                }
+                Write the action block on a single line at the very end of your response.".to_string();
+            if let Ok(memory) = MemoryStore::open_default()
+                && let Ok(Some(name)) = memory.get_profile("name")
+            {
+                system_instruction.push_str(&format!(
+                    "\nThe user's name is {}. Refer to them by their name when appropriate.",
+                    name
+                ));
             }
 
             let image_uri = session.pending_image.take();
@@ -2542,6 +2751,7 @@ async fn run_interactive_chat() -> Result<()> {
                     audio_data_uri: None,
                     document_attachment: None,
                     workspace_path: None,
+                    agent_id: None,
                 },
                 |chunk| {
                     if first_chunk {
@@ -2621,9 +2831,10 @@ async fn run_interactive_chat() -> Result<()> {
 
 fn print_exit_message(session: &InteractiveSession) {
     println!("\n{MINT}──────────────── Mint session closed ────────────────{RESET}");
+    let clean_provider = format_provider_display_name(&session.config.ai_provider, &session.config);
     println!(
         "{DIM}Provider:{RESET} {} {DIM}• Model:{RESET} {}",
-        session.config.ai_provider,
+        clean_provider,
         active_model(&session.config.ai_provider, &session.config)
     );
     println!(
@@ -2634,52 +2845,140 @@ fn print_exit_message(session: &InteractiveSession) {
     println!("{MINT}See you next time.{RESET}\n");
 }
 
+fn format_provider_display_name(provider: &str, config: &mint_core::MintConfig) -> String {
+    if provider.starts_with("custom:") {
+        let id = provider.strip_prefix("custom:").unwrap_or(provider);
+        let cp = config.custom_providers.iter().find(|p| p.id == id);
+        match cp {
+            Some(p) if !p.display_name.is_empty() => format!("{} (Custom)", p.display_name),
+            Some(p) => format!("{} (Custom)", p.id),
+            None => format!("{} (Custom)", id),
+        }
+    } else {
+        match provider {
+            "gemini" => "Gemini".to_string(),
+            "openai" => "OpenAI".to_string(),
+            "openrouter" => "OpenRouter".to_string(),
+            "deepseek" => "DeepSeek".to_string(),
+            "anthropic" => "Claude".to_string(),
+            "huggingface" => "HF".to_string(),
+            "local_openai" => "Local".to_string(),
+            "ollama" => "Ollama".to_string(),
+            _ => {
+                let mut chars = provider.chars();
+                match chars.next() {
+                    None => String::new(),
+                    Some(f) => f.to_uppercase().collect::<String>() + chars.as_str(),
+                }
+            }
+        }
+    }
+}
+
 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"),
+    ("/skill add", "Add or install global skill file or folder"),
     ("/stats", "Show session statistics"),
-    ("/exit", "Exit Mint CLI"),
-    ("/quit", "Exit Mint CLI"),
-    ("/code", "Run in code-agent mode"),
 ];
 
+fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> std::io::Result<()> {
+    std::fs::create_dir_all(&dst)?;
+    for entry in std::fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        if ty.is_dir() {
+            copy_dir_all(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        } else {
+            std::fs::copy(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        }
+    }
+    Ok(())
+}
+
+fn load_all_available_skills(current_dir: &Path) -> Vec<mint_core::LearnedSkill> {
+    let mut skills = Vec::new();
+    if let Ok(memory) = MemoryStore::open_default() {
+        if let Ok(s) = memory.learned_skills(100) {
+            skills = s;
+        }
+    }
+    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 = current_dir.join(".agents").join("skills");
+    mint_core::skills::load_skills_from_dir(&workspace_skills_path1, &mut skills);
+    let workspace_skills_path2 = 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 {
+        unique_skills.insert(skill.name.clone(), skill);
+    }
+    unique_skills.into_values().collect()
+}
+
 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 {
+    current_dir: &Path,
+) -> (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 && 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);
@@ -2707,7 +3006,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
@@ -2716,11 +3016,22 @@ fn draw_input_box(
             .collect();
 
         if !matches.is_empty() {
-            match_count = matches.len();
-            println!();
-            println!(" {BLUE}Suggestions{RESET}");
+            let total_pages = matches.len().div_ceil(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 s_start_idx = current_page * 5;
+            let s_end_idx = std::cmp::min(s_start_idx + 5, matches.len());
+            match_count = s_end_idx - s_start_idx;
+
+            println!();
+            println!(
+                " {BLUE}Suggestions ({}/{}){RESET}",
+                current_page + 1,
+                total_pages
+            );
+            for i in s_start_idx..s_end_idx {
+                let (cmd, desc) = matches[i];
                 if Some(i) == highlight_idx {
                     println!("  {BLUE}▶ {:<16}{RESET} {DIM}- {}{RESET}", cmd, desc);
                 } else {
@@ -2728,14 +3039,86 @@ fn draw_input_box(
                 }
             }
         }
+    } else if search_query.starts_with('$') {
+        // Parse skill name (excluding arguments)
+        let skill_query = search_query
+            .split_whitespace()
+            .next()
+            .unwrap_or(search_query);
+        let prefix = &skill_query[1..].to_lowercase();
+        let skills = load_all_available_skills(current_dir);
+        let matches: Vec<_> = skills
+            .iter()
+            .filter(|skill| skill.name.to_lowercase().starts_with(prefix))
+            .collect();
+
+        if !matches.is_empty() {
+            let total_pages = matches.len().div_ceil(5);
+            let highlight_idx = tab_index.map(|idx| idx % matches.len());
+            let selected_idx = highlight_idx.unwrap_or(0);
+            let current_page = selected_idx / 5;
+            let s_start_idx = current_page * 5;
+            let s_end_idx = std::cmp::min(s_start_idx + 5, matches.len());
+            match_count = s_end_idx - s_start_idx;
+
+            println!();
+            println!(
+                " {BLUE}Suggestions ({}/{}){RESET}",
+                current_page + 1,
+                total_pages
+            );
+            for i in s_start_idx..s_end_idx {
+                let skill = matches[i];
+                let desc = skill
+                    .description
+                    .as_deref()
+                    .unwrap_or("No description provided");
+                let max_desc_len = width.saturating_sub(35);
+                let truncated_desc = if desc.chars().count() > max_desc_len {
+                    let mut s: String = desc.chars().take(max_desc_len.saturating_sub(3)).collect();
+                    s.push_str("...");
+                    s
+                } else {
+                    desc.to_string()
+                };
+
+                if Some(i) == highlight_idx {
+                    println!(
+                        "  {BLUE}▶ ${:<20}{RESET} {MINT}[Skill]{RESET} {DIM}{}{RESET}",
+                        skill.name, truncated_desc
+                    );
+                } else {
+                    println!(
+                        "    {DIM}${:<20} [Skill] {}{RESET}",
+                        skill.name, truncated_desc
+                    );
+                }
+            }
+        }
     }
 
     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 && 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)
@@ -2764,16 +3147,18 @@ fn redraw_input_box(
     path_str: &str,
     tab_base_input: Option<&str>,
     tab_index: Option<usize>,
+    current_dir: &Path,
 ) {
     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,
         tab_base_input,
         tab_index,
+        current_dir,
     );
     position_input_cursor(input_chars, cursor_pos, match_count);
     let _ = io::stdout().flush();
@@ -2783,6 +3168,7 @@ fn read_line_interactive(
     _provider: &str,
     model: &str,
     path_str: &str,
+    current_dir: &Path,
 ) -> io::Result<Option<InteractiveInput>> {
     use crossterm::event::{self, Event, KeyCode};
     use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
@@ -2799,7 +3185,16 @@ 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,
+        current_dir,
+    );
     position_input_cursor(&input_chars, cursor_pos, match_count);
     let _ = io::stdout().flush();
 
@@ -2839,70 +3234,177 @@ fn read_line_interactive(
                     path_str,
                     None,
                     None,
+                    current_dir,
                 );
                 enable_raw_mode()?;
                 last_paste_time = Some(std::time::Instant::now());
                 continue;
             }
-            if let Event::Key(key_event) = ev {
-                if key_event.kind == event::KeyEventKind::Press {
-                    let is_ctrl_d = matches!(key_event.code, KeyCode::Char('d'))
-                        && key_event
+            if let Event::Key(key_event) = ev
+                && key_event.kind == event::KeyEventKind::Press
+            {
+                let is_ctrl_d = matches!(key_event.code, KeyCode::Char('d'))
+                    && key_event
+                        .modifiers
+                        .contains(crossterm::event::KeyModifiers::CONTROL);
+                if ctrl_d_pressed && !is_ctrl_d {
+                    ctrl_d_pressed = false;
+                    disable_raw_mode()?;
+                    print!("\r\x1b[3B\r\x1b[2K\x1b[3A");
+                    print!("\x1b[{}G", input_cursor_column(&input_chars, cursor_pos));
+                    let _ = io::stdout().flush();
+                    enable_raw_mode()?;
+                }
+
+                // Reset tab autocomplete state if any key other than Tab, Up, or Down is pressed
+                if key_event.code != KeyCode::Tab
+                    && key_event.code != KeyCode::Up
+                    && key_event.code != KeyCode::Down
+                {
+                    tab_base_input = None;
+                    tab_index = None;
+                }
+
+                match key_event.code {
+                    KeyCode::Char('d')
+                        if key_event
+                            .modifiers
+                            .contains(crossterm::event::KeyModifiers::CONTROL) =>
+                    {
+                        if ctrl_d_pressed {
+                            disable_raw_mode()?;
+                            clear_input_box();
+                            let _ = io::stdout().flush();
+                            break None;
+                        } else {
+                            ctrl_d_pressed = true;
+                            disable_raw_mode()?;
+                            print!(
+                                "\r\x1b[3B\r\x1b[2K{WARN}Press Ctrl+D again to exit{RESET}\x1b[3A"
+                            );
+                            print!("\x1b[{}G", input_cursor_column(&input_chars, cursor_pos));
+                            let _ = io::stdout().flush();
+                            enable_raw_mode()?;
+                        }
+                    }
+                    KeyCode::Char('v')
+                        if key_event
                             .modifiers
-                            .contains(crossterm::event::KeyModifiers::CONTROL);
-                    if ctrl_d_pressed && !is_ctrl_d {
-                        ctrl_d_pressed = false;
+                            .contains(crossterm::event::KeyModifiers::CONTROL) =>
+                    {
+                        if let Ok(Some(uri)) = image::read_clipboard_image() {
+                            if let Some(ref mut current) = pasted_image {
+                                current.push(' ');
+                                current.push_str(&uri);
+                            } else {
+                                pasted_image = Some(uri);
+                            }
+                            insert_image_placeholder(&mut input_chars, &mut cursor_pos);
+
+                            disable_raw_mode()?;
+                            redraw_input_box(
+                                &input_chars,
+                                cursor_pos,
+                                placeholder,
+                                model,
+                                path_str,
+                                None,
+                                None,
+                                current_dir,
+                            );
+                            enable_raw_mode()?;
+                        }
+                    }
+                    KeyCode::Char(c) if input_chars.len() < 10000 => {
+                        input_chars.insert(cursor_pos, c);
+                        cursor_pos += 1;
+
                         disable_raw_mode()?;
-                        print!("\r\x1b[3B\r\x1b[2K\x1b[3A");
-                        print!("\x1b[{}G", input_cursor_column(&input_chars, cursor_pos));
-                        let _ = io::stdout().flush();
+                        redraw_input_box(
+                            &input_chars,
+                            cursor_pos,
+                            placeholder,
+                            model,
+                            path_str,
+                            None,
+                            None,
+                            current_dir,
+                        );
                         enable_raw_mode()?;
                     }
+                    KeyCode::Backspace if cursor_pos > 0 => {
+                        cursor_pos -= 1;
+                        input_chars.remove(cursor_pos);
 
-                    // Reset tab autocomplete state if any key other than Tab, Up, or Down is pressed
-                    if key_event.code != KeyCode::Tab
-                        && key_event.code != KeyCode::Up
-                        && key_event.code != KeyCode::Down
-                    {
-                        tab_base_input = None;
-                        tab_index = None;
+                        disable_raw_mode()?;
+                        redraw_input_box(
+                            &input_chars,
+                            cursor_pos,
+                            placeholder,
+                            model,
+                            path_str,
+                            None,
+                            None,
+                            current_dir,
+                        );
+                        enable_raw_mode()?;
                     }
+                    KeyCode::Tab => {
+                        let base = match &tab_base_input {
+                            Some(b) => b.clone(),
+                            None => {
+                                let current_str: String = input_chars.iter().collect();
+                                tab_base_input = Some(current_str.clone());
+                                current_str
+                            }
+                        };
+
+                        if base.starts_with('/') {
+                            let matches: Vec<_> = AUTOCOMPLETE_COMMANDS
+                                .iter()
+                                .filter(|(cmd, _)| cmd.starts_with(&base))
+                                .collect();
+
+                            if !matches.is_empty() {
+                                let idx = tab_index.unwrap_or(0) % matches.len();
+                                let completed = format!("{} ", matches[idx].0);
+                                input_chars = completed.chars().collect();
+                                cursor_pos = input_chars.len();
+
+                                // Highlight currently completed item in suggestions
+                                let current_highlight = Some(idx);
+                                tab_index = Some(idx + 1);
 
-                    match key_event.code {
-                        KeyCode::Char('d')
-                            if key_event
-                                .modifiers
-                                .contains(crossterm::event::KeyModifiers::CONTROL) =>
-                        {
-                            if ctrl_d_pressed {
-                                disable_raw_mode()?;
-                                clear_input_box();
-                                let _ = io::stdout().flush();
-                                break None;
-                            } else {
-                                ctrl_d_pressed = true;
                                 disable_raw_mode()?;
-                                print!(
-                                    "\r\x1b[3B\r\x1b[2K{WARN}Press Ctrl+D again to exit{RESET}\x1b[3A"
+                                redraw_input_box(
+                                    &input_chars,
+                                    cursor_pos,
+                                    placeholder,
+                                    model,
+                                    path_str,
+                                    Some(&base),
+                                    current_highlight,
+                                    current_dir,
                                 );
-                                print!("\x1b[{}G", input_cursor_column(&input_chars, cursor_pos));
-                                let _ = io::stdout().flush();
                                 enable_raw_mode()?;
                             }
-                        }
-                        KeyCode::Char('v')
-                            if key_event
-                                .modifiers
-                                .contains(crossterm::event::KeyModifiers::CONTROL) =>
-                        {
-                            if let Ok(Some(uri)) = image::read_clipboard_image() {
-                                if let Some(ref mut current) = pasted_image {
-                                    current.push(' ');
-                                    current.push_str(&uri);
-                                } else {
-                                    pasted_image = Some(uri);
-                                }
-                                insert_image_placeholder(&mut input_chars, &mut cursor_pos);
+                        } else if base.starts_with('$') {
+                            let skill_query = base.split_whitespace().next().unwrap_or(&base);
+                            let prefix = &skill_query[1..].to_lowercase();
+                            let skills = load_all_available_skills(current_dir);
+                            let matches: Vec<_> = skills
+                                .iter()
+                                .filter(|s| s.name.to_lowercase().starts_with(prefix))
+                                .collect();
+
+                            if !matches.is_empty() {
+                                let idx = tab_index.unwrap_or(0) % matches.len();
+                                let completed = format!("${} ", matches[idx].name);
+                                input_chars = completed.chars().collect();
+                                cursor_pos = input_chars.len();
+
+                                let current_highlight = Some(idx);
+                                tab_index = Some(idx + 1);
 
                                 disable_raw_mode()?;
                                 redraw_input_box(
@@ -2911,21 +3413,39 @@ fn read_line_interactive(
                                     placeholder,
                                     model,
                                     path_str,
-                                    None,
-                                    None,
+                                    Some(&base),
+                                    current_highlight,
+                                    current_dir,
                                 );
                                 enable_raw_mode()?;
                             }
                         }
-                        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();
+                    }
+                    KeyCode::Down => {
+                        let base = match &tab_base_input {
+                            Some(b) => b.clone(),
+                            None => {
+                                let current_str: String = input_chars.iter().collect();
+                                tab_base_input = Some(current_str.clone());
+                                current_str
+                            }
+                        };
 
-                            if current_visual_width < max_width {
-                                input_chars.insert(cursor_pos, c);
-                                cursor_pos += 1;
+                        if base.starts_with('/') {
+                            let matches: Vec<_> = AUTOCOMPLETE_COMMANDS
+                                .iter()
+                                .filter(|(cmd, _)| cmd.starts_with(&base))
+                                .collect();
+
+                            if !matches.is_empty() {
+                                let new_idx = match tab_index {
+                                    Some(idx) => (idx + 1) % matches.len(),
+                                    None => 0,
+                                };
+                                tab_index = Some(new_idx);
+                                let completed = format!("{} ", matches[new_idx].0);
+                                input_chars = completed.chars().collect();
+                                cursor_pos = input_chars.len();
 
                                 disable_raw_mode()?;
                                 redraw_input_box(
@@ -2934,16 +3454,30 @@ fn read_line_interactive(
                                     placeholder,
                                     model,
                                     path_str,
-                                    None,
-                                    None,
+                                    Some(&base),
+                                    Some(new_idx),
+                                    current_dir,
                                 );
                                 enable_raw_mode()?;
                             }
-                        }
-                        KeyCode::Backspace => {
-                            if cursor_pos > 0 {
-                                cursor_pos -= 1;
-                                input_chars.remove(cursor_pos);
+                        } else if base.starts_with('$') {
+                            let skill_query = base.split_whitespace().next().unwrap_or(&base);
+                            let prefix = &skill_query[1..].to_lowercase();
+                            let skills = load_all_available_skills(current_dir);
+                            let matches: Vec<_> = skills
+                                .iter()
+                                .filter(|s| s.name.to_lowercase().starts_with(prefix))
+                                .collect();
+
+                            if !matches.is_empty() {
+                                let new_idx = match tab_index {
+                                    Some(idx) => (idx + 1) % matches.len(),
+                                    None => 0,
+                                };
+                                tab_index = Some(new_idx);
+                                let completed = format!("${} ", matches[new_idx].name);
+                                input_chars = completed.chars().collect();
+                                cursor_pos = input_chars.len();
 
                                 disable_raw_mode()?;
                                 redraw_input_box(
@@ -2952,205 +3486,171 @@ fn read_line_interactive(
                                     placeholder,
                                     model,
                                     path_str,
-                                    None,
-                                    None,
+                                    Some(&base),
+                                    Some(new_idx),
+                                    current_dir,
                                 );
                                 enable_raw_mode()?;
                             }
                         }
-                        KeyCode::Tab => {
-                            let base = match &tab_base_input {
-                                Some(b) => b.clone(),
-                                None => {
-                                    let current_str: String = input_chars.iter().collect();
-                                    tab_base_input = Some(current_str.clone());
-                                    current_str
-                                }
-                            };
-
-                            if base.starts_with('/') {
-                                let matches: Vec<_> = AUTOCOMPLETE_COMMANDS
-                                    .iter()
-                                    .filter(|(cmd, _)| cmd.starts_with(&base))
-                                    .collect();
-
-                                if !matches.is_empty() {
-                                    let idx = tab_index.unwrap_or(0) % matches.len();
-                                    let completed = format!("{} ", matches[idx].0);
-                                    input_chars = completed.chars().collect();
-                                    cursor_pos = input_chars.len();
-
-                                    // Highlight currently completed item in suggestions
-                                    let current_highlight = Some(idx);
-                                    tab_index = Some(idx + 1);
-
-                                    disable_raw_mode()?;
-                                    redraw_input_box(
-                                        &input_chars,
-                                        cursor_pos,
-                                        placeholder,
-                                        model,
-                                        path_str,
-                                        Some(&base),
-                                        current_highlight,
-                                    );
-                                    enable_raw_mode()?;
-                                }
+                    }
+                    KeyCode::Up => {
+                        let base = match &tab_base_input {
+                            Some(b) => b.clone(),
+                            None => {
+                                let current_str: String = input_chars.iter().collect();
+                                tab_base_input = Some(current_str.clone());
+                                current_str
                             }
-                        }
-                        KeyCode::Down => {
-                            let base = match &tab_base_input {
-                                Some(b) => b.clone(),
-                                None => {
-                                    let current_str: String = input_chars.iter().collect();
-                                    tab_base_input = Some(current_str.clone());
-                                    current_str
-                                }
-                            };
+                        };
 
-                            if base.starts_with('/') {
-                                let matches: Vec<_> = AUTOCOMPLETE_COMMANDS
-                                    .iter()
-                                    .filter(|(cmd, _)| cmd.starts_with(&base))
-                                    .collect();
-
-                                if !matches.is_empty() {
-                                    let new_idx = match tab_index {
-                                        Some(idx) => (idx + 1) % matches.len(),
-                                        None => 0,
-                                    };
-                                    tab_index = Some(new_idx);
-                                    let completed = format!("{} ", matches[new_idx].0);
-                                    input_chars = completed.chars().collect();
-                                    cursor_pos = input_chars.len();
-
-                                    disable_raw_mode()?;
-                                    redraw_input_box(
-                                        &input_chars,
-                                        cursor_pos,
-                                        placeholder,
-                                        model,
-                                        path_str,
-                                        Some(&base),
-                                        Some(new_idx),
-                                    );
-                                    enable_raw_mode()?;
-                                }
-                            }
-                        }
-                        KeyCode::Up => {
-                            let base = match &tab_base_input {
-                                Some(b) => b.clone(),
-                                None => {
-                                    let current_str: String = input_chars.iter().collect();
-                                    tab_base_input = Some(current_str.clone());
-                                    current_str
-                                }
-                            };
+                        if base.starts_with('/') {
+                            let matches: Vec<_> = AUTOCOMPLETE_COMMANDS
+                                .iter()
+                                .filter(|(cmd, _)| cmd.starts_with(&base))
+                                .collect();
+
+                            if !matches.is_empty() {
+                                let new_idx = match tab_index {
+                                    Some(idx) => {
+                                        if idx == 0 {
+                                            matches.len() - 1
+                                        } else {
+                                            idx - 1
+                                        }
+                                    }
+                                    None => matches.len() - 1,
+                                };
+                                tab_index = Some(new_idx);
+                                let completed = format!("{} ", matches[new_idx].0);
+                                input_chars = completed.chars().collect();
+                                cursor_pos = input_chars.len();
 
-                            if base.starts_with('/') {
-                                let matches: Vec<_> = AUTOCOMPLETE_COMMANDS
-                                    .iter()
-                                    .filter(|(cmd, _)| cmd.starts_with(&base))
-                                    .collect();
-
-                                if !matches.is_empty() {
-                                    let new_idx = match tab_index {
-                                        Some(idx) => {
-                                            if idx == 0 {
-                                                matches.len() - 1
-                                            } else {
-                                                idx - 1
-                                            }
+                                disable_raw_mode()?;
+                                redraw_input_box(
+                                    &input_chars,
+                                    cursor_pos,
+                                    placeholder,
+                                    model,
+                                    path_str,
+                                    Some(&base),
+                                    Some(new_idx),
+                                    current_dir,
+                                );
+                                enable_raw_mode()?;
+                            }
+                        } else if base.starts_with('$') {
+                            let skill_query = base.split_whitespace().next().unwrap_or(&base);
+                            let prefix = &skill_query[1..].to_lowercase();
+                            let skills = load_all_available_skills(current_dir);
+                            let matches: Vec<_> = skills
+                                .iter()
+                                .filter(|s| s.name.to_lowercase().starts_with(prefix))
+                                .collect();
+
+                            if !matches.is_empty() {
+                                let new_idx = match tab_index {
+                                    Some(idx) => {
+                                        if idx == 0 {
+                                            matches.len() - 1
+                                        } else {
+                                            idx - 1
                                         }
-                                        None => matches.len() - 1,
-                                    };
-                                    tab_index = Some(new_idx);
-                                    let completed = format!("{} ", matches[new_idx].0);
-                                    input_chars = completed.chars().collect();
-                                    cursor_pos = input_chars.len();
-
-                                    disable_raw_mode()?;
-                                    redraw_input_box(
-                                        &input_chars,
-                                        cursor_pos,
-                                        placeholder,
-                                        model,
-                                        path_str,
-                                        Some(&base),
-                                        Some(new_idx),
-                                    );
-                                    enable_raw_mode()?;
-                                }
+                                    }
+                                    None => matches.len() - 1,
+                                };
+                                tab_index = Some(new_idx);
+                                let completed = format!("${} ", matches[new_idx].name);
+                                input_chars = completed.chars().collect();
+                                cursor_pos = input_chars.len();
+
+                                disable_raw_mode()?;
+                                redraw_input_box(
+                                    &input_chars,
+                                    cursor_pos,
+                                    placeholder,
+                                    model,
+                                    path_str,
+                                    Some(&base),
+                                    Some(new_idx),
+                                    current_dir,
+                                );
+                                enable_raw_mode()?;
                             }
                         }
-                        KeyCode::Left => {
-                            while cursor_pos > 0 {
-                                cursor_pos -= 1;
-                                if cursor_pos == 0 || !is_thai_zero_width(input_chars[cursor_pos]) {
-                                    break;
-                                }
+                    }
+                    KeyCode::Left => {
+                        while cursor_pos > 0 {
+                            cursor_pos -= 1;
+                            if cursor_pos == 0 || !is_thai_zero_width(input_chars[cursor_pos]) {
+                                break;
                             }
-                            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();
-                            enable_raw_mode()?;
                         }
-                        KeyCode::Right => {
-                            while cursor_pos < input_chars.len() {
-                                cursor_pos += 1;
-                                if cursor_pos == input_chars.len()
-                                    || !is_thai_zero_width(input_chars[cursor_pos])
-                                {
-                                    break;
-                                }
+                        disable_raw_mode()?;
+                        redraw_input_box(
+                            &input_chars,
+                            cursor_pos,
+                            placeholder,
+                            model,
+                            path_str,
+                            None,
+                            None,
+                            current_dir,
+                        );
+                        enable_raw_mode()?;
+                    }
+                    KeyCode::Right => {
+                        while cursor_pos < input_chars.len() {
+                            cursor_pos += 1;
+                            if cursor_pos == input_chars.len()
+                                || !is_thai_zero_width(input_chars[cursor_pos])
+                            {
+                                break;
                             }
-                            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();
-                            enable_raw_mode()?;
                         }
-                        KeyCode::Enter => {
-                            if let Some(time) = last_paste_time {
-                                if time.elapsed() < std::time::Duration::from_millis(100) {
-                                    continue;
-                                }
-                            }
-                            disable_raw_mode()?;
-                            clear_input_box();
-                            let input_str: String = input_chars.iter().collect();
+                        disable_raw_mode()?;
+                        redraw_input_box(
+                            &input_chars,
+                            cursor_pos,
+                            placeholder,
+                            model,
+                            path_str,
+                            None,
+                            None,
+                            current_dir,
+                        );
+                        enable_raw_mode()?;
+                    }
+                    KeyCode::Enter => {
+                        if let Some(time) = last_paste_time
+                            && time.elapsed() < std::time::Duration::from_millis(100)
+                        {
+                            continue;
+                        }
+                        disable_raw_mode()?;
+                        clear_input_box();
+                        let input_str: String = input_chars.iter().collect();
 
-                            let mut expanded_str = input_str.clone();
-                            for (placeholder_str, content) in &paste_contents {
-                                expanded_str = expanded_str.replace(placeholder_str, content);
-                            }
+                        let mut expanded_str = input_str.clone();
+                        for (placeholder_str, content) in &paste_contents {
+                            expanded_str = expanded_str.replace(placeholder_str, content);
+                        }
 
-                            println!("  {BLUE}You ›{RESET} {}", expanded_str);
-                            let _ = io::stdout().flush();
+                        println!("  {BLUE}You ›{RESET} {}", expanded_str);
+                        let _ = io::stdout().flush();
 
-                            break Some(InteractiveInput {
-                                text: expanded_str,
-                                pasted_image,
-                            });
-                        }
-                        KeyCode::Esc => {
-                            disable_raw_mode()?;
-                            clear_input_box();
-                            let _ = io::stdout().flush();
-                            break None;
-                        }
-                        _ => {}
+                        break Some(InteractiveInput {
+                            text: expanded_str,
+                            pasted_image,
+                        });
+                    }
+                    KeyCode::Esc => {
+                        disable_raw_mode()?;
+                        clear_input_box();
+                        let _ = io::stdout().flush();
+                        break None;
                     }
+                    _ => {}
                 }
             }
         }
@@ -3190,18 +3690,18 @@ fn format_placeholders(s: &str) -> String {
     while i < chars.len() {
         if chars[i] == '[' && i + 12 < chars.len() {
             let slice: String = chars[i..i + 13].iter().collect();
-            if slice == "[Pasted text #" {
-                if let Some(end_offset) = chars[i..].iter().position(|&c| c == ']') {
-                    let end_idx = i + end_offset;
-                    let inside: String = chars[i + 1..end_idx].iter().collect();
-                    result.push('[');
-                    result.push_str(BLUE);
-                    result.push_str(&inside);
-                    result.push_str("\x1b[39m");
-                    result.push(']');
-                    i = end_idx + 1;
-                    continue;
-                }
+            if slice == "[Pasted text #"
+                && let Some(end_offset) = chars[i..].iter().position(|&c| c == ']')
+            {
+                let end_idx = i + end_offset;
+                let inside: String = chars[i + 1..end_idx].iter().collect();
+                result.push('[');
+                result.push_str(BLUE);
+                result.push_str(&inside);
+                result.push_str("\x1b[39m");
+                result.push(']');
+                i = end_idx + 1;
+                continue;
             }
         }
         result.push(chars[i]);
@@ -3232,6 +3732,22 @@ fn active_model<'a>(provider: &str, config: &'a mint_core::MintConfig) -> &'a st
         "huggingface" => &config.hf_model,
         "local_openai" => &config.local_model_name,
         "ollama" => &config.ollama_model,
+        p if p.starts_with("custom:") => {
+            if let Some(id) = p.strip_prefix("custom:")
+                && let Some(selections) = config
+                    .extra
+                    .get("customModelSelections")
+                    .and_then(|v| v.as_object())
+                && let Some(m) = selections.get(id).and_then(|v| v.as_str())
+            {
+                return m;
+            }
+            config
+                .resolve_custom_provider(p)
+                .and_then(|cp| cp.models.first())
+                .map(|m| m.model_id.as_str())
+                .unwrap_or("")
+        }
         _ => &config.gemini_model,
     }
 }
@@ -3566,6 +4082,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?;