@pheem49/mint 1.16.0 → 1.18.0

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

@@ -159,14 +159,46 @@ fn first_line_preview(path: &Path) -> String {
         .map(str::trim)
         .find(|l| !l.is_empty())
         .unwrap_or("");
-    if first.chars().count() > 80 {
-        let short: String = first.chars().take(80).collect();
+    let clean = first.trim_start_matches('#').trim();
+    if clean.chars().count() > 80 {
+        let short: String = clean.chars().take(80).collect();
         format!("{short}…")
     } else {
-        first.to_string()
+        clean.to_string()
     }
 }
 
+fn format_plan_meta(path: &Path) -> String {
+    let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("");
+    if stem.len() >= 15 && stem.as_bytes().get(8) == Some(&b'-') {
+        let y = &stem[0..4];
+        let m = &stem[4..6];
+        let d = &stem[6..8];
+        let hh = &stem[9..11];
+        let mm = &stem[11..13];
+        let ss = &stem[13..15];
+        if y.chars().all(|c| c.is_ascii_digit())
+            && m.chars().all(|c| c.is_ascii_digit())
+            && d.chars().all(|c| c.is_ascii_digit())
+            && hh.chars().all(|c| c.is_ascii_digit())
+            && mm.chars().all(|c| c.is_ascii_digit())
+            && ss.chars().all(|c| c.is_ascii_digit())
+        {
+            let date_str = format!("{y}-{m}-{d} {hh}:{mm}:{ss}");
+            if stem.len() > 16 {
+                let slug = &stem[16..];
+                return format!("{date_str} · {slug}");
+            } else {
+                return date_str;
+            }
+        }
+    }
+    path.file_name()
+        .and_then(|n| n.to_str())
+        .unwrap_or("")
+        .to_string()
+}
+
 async fn execute_core_slash(
     session: &mut InteractiveSession,
     ui: &mut dyn CommandUi,
@@ -205,7 +237,19 @@ async fn execute_core_slash(
     match response {
         SlashResponse::Message { markdown } => {
             if !markdown.is_empty() {
-                ui.push_command_output(markdown);
+                if matches!(
+                    cmd,
+                    "/release-notes"
+                        | "/release_notes"
+                        | "/release-note"
+                        | "/release_note"
+                        | "/releasenotes"
+                        | "/releasenote"
+                ) {
+                    ui.push_release_notes(&markdown);
+                } else {
+                    ui.push_command_output(markdown);
+                }
             }
             Some(SlashResult::Handled)
         }
@@ -381,6 +425,7 @@ pub async fn handle_slash_command(
             | "/shells"
             | "/palette"
             | "/theme"
+            | "/onboard"
             | "/image"
             | "/paste"
             | "/avatar"
@@ -426,6 +471,34 @@ pub async fn handle_slash_command(
             mint_core::slash::INIT_AGENTS_MD_PROMPT.to_string(),
         )),
 
+        "/edit" | "/retry" => {
+            let scoped = mint_core::scoped_chat_id(
+                &session.chat_id,
+                Some(&session.current_dir.to_string_lossy()),
+            );
+            if let Ok(memory) = MemoryStore::open_default() {
+                if let Ok(rows) = memory.interactions_for_chat(&scoped) {
+                    if let Some(last) = rows.last() {
+                        let turn_id = last.id;
+                        let prompt_to_run = if rest.is_empty() {
+                            last.user_text.clone()
+                        } else {
+                            rest.to_string()
+                        };
+                        let _ = memory.truncate_interactions_from(&scoped, turn_id);
+                        ui.push_notice(format!(
+                            "Truncated turn #{} from history. Resending with prompt:\n{}",
+                            rows.len(),
+                            prompt_to_run
+                        ));
+                        return Some(SlashResult::ForwardToAgent(prompt_to_run));
+                    }
+                }
+            }
+            ui.push_notice("No previous turn found to edit or retry.");
+            Some(SlashResult::Handled)
+        }
+
         "/fast" => {
             let choice = if rest.is_empty() {
                 let options = vec![
@@ -487,6 +560,7 @@ pub async fn handle_slash_command(
                     ui.push_notice(format!("Already in session '{target_id}'."));
                 } else {
                     session.chat_id = target_id.clone();
+                    crate::companion_navigation::set_chat(&session.chat_id);
                     mint_core::live_sync::update_live_sync_chat_id(&session.chat_id);
                     ui.reload_transcript(&session.chat_id, &session.current_dir);
                     if let Ok(memory) = MemoryStore::open_default() {
@@ -529,14 +603,15 @@ pub async fn handle_slash_command(
             };
             if rest.is_empty() {
                 if checkpoints.is_empty() {
-                    println!("\n{DIM}No git checkpoints recorded for this CLI session yet.{RESET}");
-                    println!(
-                        "{DIM}Checkpoints are created automatically before mutating file actions (write_file, apply_patch).{RESET}\n"
+                    ui.push_notice(
+                        "No git checkpoints recorded for this CLI session yet.\nCheckpoints are created automatically before mutating file actions (write_file, apply_patch).",
                     );
                 } else {
-                    println!("\n{BLUE}────────────────────────────────────────────{RESET}");
-                    println!("{MINT}  ↺ Available Git Checkpoints (Time Machine){RESET}");
-                    println!("{BLUE}────────────────────────────────────────────{RESET}");
+                    let mut lines = vec![
+                        format!("{BLUE}────────────────────────────────────────────{RESET}"),
+                        format!("{MINT}  ↺ Available Git Checkpoints (Time Machine){RESET}"),
+                        format!("{BLUE}────────────────────────────────────────────{RESET}"),
+                    ];
                     for cp in checkpoints.iter().rev() {
                         let hash_short = if cp.commit_hash.len() >= 7 {
                             &cp.commit_hash[..7]
@@ -544,24 +619,21 @@ pub async fn handle_slash_command(
                             &cp.commit_hash
                         };
                         let target = cp.target_path.as_deref().unwrap_or("-");
-                        println!(
+                        lines.push(format!(
                             "  {MINT}Step {:<3}{RESET} {DIM}[{}]{RESET} {:<20} {DIM}({}){RESET}",
                             cp.step, hash_short, cp.action, target
-                        );
+                        ));
                     }
-                    println!(
-                        "\n{DIM}Use {RESET}{MINT}/rewind <step>{RESET}{DIM} to restore workspace to before that step, or {RESET}{MINT}/rewind undo{RESET}{DIM} to recover from rescue snapshot.{RESET}\n"
-                    );
+                    lines.push(format!(
+                        "\n{DIM}Use {RESET}{MINT}/rewind <step>{RESET}{DIM} to restore workspace to before that step, or {RESET}{MINT}/rewind undo{RESET}{DIM} to recover from rescue snapshot.{RESET}"
+                    ));
+                    ui.push_command_output(lines.join("\n"));
                 }
                 Some(SlashResult::Handled)
             } else if rest.trim().eq_ignore_ascii_case("undo") {
                 match mint_core::git::undo_rollback(&session.current_dir) {
-                    Ok(msg) => {
-                        println!("\n{MINT}{msg}{RESET}\n");
-                    }
-                    Err(err) => {
-                        println!("\n{ERROR}Failed to undo rewind:{RESET} {err}\n");
-                    }
+                    Ok(msg) => ui.push_notice(msg),
+                    Err(err) => ui.push_notice(format!("Failed to undo rewind: {err}")),
                 }
                 Some(SlashResult::Handled)
             } else {
@@ -572,18 +644,14 @@ pub async fn handle_slash_command(
                             &target_rewind_chat_id,
                             step,
                         ) {
-                            Ok(msg) => {
-                                println!("\n{MINT}{msg}{RESET}\n");
-                            }
-                            Err(err) => {
-                                println!("\n{ERROR}Failed to rollback:{RESET} {err}\n");
-                            }
+                            Ok(msg) => ui.push_notice(msg),
+                            Err(err) => ui.push_notice(format!("Failed to rollback: {err}")),
                         }
                     }
                     Err(_) => {
-                        println!(
-                            "\n{ERROR}Invalid step number:{RESET} \"{rest}\". Usage: /rewind <step> or /rewind undo\n"
-                        );
+                        ui.push_notice(format!(
+                            "Invalid step number: \"{rest}\". Usage: /rewind <step> or /rewind undo"
+                        ));
                     }
                 }
                 Some(SlashResult::Handled)
@@ -613,6 +681,19 @@ pub async fn handle_slash_command(
             Some(SlashResult::Handled)
         }
 
+        "/onboard" => {
+            match ui.prompt_onboard(&mut session.config) {
+                Ok(true) => {
+                    ui.push_notice("✔ Configuration updated successfully.");
+                }
+                Ok(false) => {
+                    ui.push_notice("Onboarding cancelled.");
+                }
+                Err(error) => ui.report_error(&error),
+            }
+            Some(SlashResult::Handled)
+        }
+
         "/palette" => {
             let options = vec![
                 ChoiceItem::with_description(
@@ -687,28 +768,75 @@ pub async fn handle_slash_command(
         }
 
         "/thought" | "/think" => {
-            if let Some(record) = get_last_thought() {
-                let _ = show_thought_viewer(&record.thought, &record.elapsed_str);
-            } else {
-                ui.push_notice("No recent thought process recorded for this turn.");
+            if let Err(err) = ui.open_thought_viewer() {
+                ui.push_notice(format!("Could not open thought viewer: {err}"));
             }
             Some(SlashResult::Handled)
         }
 
-        "/plan" if rest == "list" => {
+        "/plan" if rest == "list" || rest.starts_with("list ") => {
+            let arg = rest.trim_start_matches("list").trim();
             let files = list_plan_files(&session.current_dir);
             if files.is_empty() {
-                ui.push_notice("No saved plans yet.");
+                ui.push_notice("No saved plans yet under .agents/plans/");
+            } else if !arg.is_empty() {
+                let found = if let Ok(idx) = arg.parse::<usize>() {
+                    idx.checked_sub(1).and_then(|i| files.get(i))
+                } else {
+                    files.iter().find(|p| {
+                        p.file_name()
+                            .and_then(|n| n.to_str())
+                            .is_some_and(|n| n.contains(arg))
+                    })
+                };
+                match found {
+                    Some(path) => match std::fs::read_to_string(path) {
+                        Ok(content) => ui.push_plan(&content),
+                        Err(e) => ui.push_notice(format!("Could not read plan file: {e}")),
+                    },
+                    None => ui.push_notice(format!(
+                        "No saved plan matching \"{arg}\" — run /plan list to see saved plans."
+                    )),
+                }
             } else {
-                let mut lines = vec![format!("{BLUE}Saved plans:{RESET}")];
-                for (idx, path) in files.iter().enumerate() {
-                    lines.push(format!(
-                        "  {DIM}[{}]{RESET} {BLUE}{}{RESET}",
-                        idx + 1,
-                        first_line_preview(path)
-                    ));
+                let options = files
+                    .iter()
+                    .enumerate()
+                    .map(|(idx, path)| {
+                        let preview = first_line_preview(path);
+                        let display_title = if preview.is_empty() {
+                            path.file_name()
+                                .and_then(|n| n.to_str())
+                                .unwrap_or("Untitled Plan")
+                        } else {
+                            &preview
+                        };
+                        let meta = format_plan_meta(path);
+                        ChoiceItem::with_description(
+                            format!("[{}] {}", idx + 1, display_title),
+                            meta,
+                            path.to_string_lossy().to_string(),
+                        )
+                    })
+                    .collect::<Vec<_>>();
+
+                match ui.prompt_choice(
+                    "Select Saved Plan",
+                    "Choose a plan to view its content (Press Enter to view, Esc to cancel)",
+                    &options,
+                ) {
+                    Ok(Some(idx)) => {
+                        if let Some(path) = files.get(idx) {
+                            match std::fs::read_to_string(path) {
+                                Ok(content) => {
+                                    ui.push_plan(&content);
+                                }
+                                Err(e) => ui.push_notice(format!("Could not read plan file: {e}")),
+                            }
+                        }
+                    }
+                    _ => {}
                 }
-                ui.push_command_output(lines.join("\n"));
             }
             Some(SlashResult::Handled)
         }
@@ -727,7 +855,7 @@ pub async fn handle_slash_command(
             };
             match found {
                 Some(path) => match std::fs::read_to_string(path) {
-                    Ok(content) => ui.push_command_output(content),
+                    Ok(content) => ui.push_plan(&content),
                     Err(e) => ui.push_notice(format!("Could not read plan file: {e}")),
                 },
                 None => ui.push_notice(format!(
@@ -774,18 +902,18 @@ pub async fn handle_slash_command(
         "/models" => {
             let selected_provider = if rest.is_empty() {
                 let providers = session.config.available_providers();
-                match prompt_interactive_select(
-                    "Select AI provider",
-                    &providers,
-                    &session.config.ai_provider,
-                ) {
-                    Ok(Some(p)) => Some(p),
+                let choices: Vec<ChoiceItem> = providers
+                    .iter()
+                    .map(|p| ChoiceItem::new(p.clone(), p.clone()))
+                    .collect();
+                match ui.prompt_choice("Select AI provider", "", &choices) {
+                    Ok(Some(idx)) => providers.get(idx).cloned(),
                     Ok(None) => {
-                        println!("Cancelled provider selection.\n");
+                        ui.push_notice("Cancelled provider selection.");
                         None
                     }
                     Err(e) => {
-                        println!("{ERROR}Error selecting provider:{RESET} {e}\n");
+                        ui.push_notice(format!("Error selecting provider: {e}"));
                         None
                     }
                 }
@@ -794,25 +922,16 @@ pub async fn handle_slash_command(
             };
 
             if let Some(provider) = selected_provider {
-                // Switch provider first so `active_model()` reflects that
-                // provider's own default/last-used model, then offer a
-                // second picker (when a model list is known for it) so the
-                // user isn't stuck with the default after choosing a provider.
                 match session.config.set_active_model(&provider, None) {
                     Ok(mut display_name) => {
-                        // Try live fetch from the provider API; fall back to
-                        // static presets if the network is unavailable or the
-                        // user hasn't entered an API key yet.
-                        print!("{DIM}Fetching available models for {provider}...{RESET}\r");
-                        let _ = std::io::Write::flush(&mut std::io::stdout());
+                        ui.set_status(vec![format!("Fetching available models for {provider}...")]);
                         let mut model_options =
                             mint_core::slash::models::model_options_for_provider_async(
                                 &session.config,
                                 &provider,
                             )
                             .await;
-                        print!("\r\x1b[2K");
-                        let _ = std::io::Write::flush(&mut std::io::stdout());
+                        ui.clear_status();
                         let current_model = session.config.active_model().to_string();
                         if !current_model.is_empty()
                             && !model_options.iter().any(|m| m == &current_model)
@@ -821,32 +940,40 @@ pub async fn handle_slash_command(
                         }
 
                         if !model_options.is_empty() {
-                            match prompt_interactive_select(
+                            let choices: Vec<ChoiceItem> = model_options
+                                .iter()
+                                .map(|m| ChoiceItem::new(m.clone(), m.clone()))
+                                .collect();
+                            match ui.prompt_choice(
                                 &format!("Select {provider} model"),
-                                &model_options,
-                                &current_model,
+                                "",
+                                &choices,
                             ) {
-                                Ok(Some(model)) if model != current_model => {
-                                    match session.config.set_active_model(&provider, Some(&model)) {
-                                        Ok(name) => display_name = name,
-                                        Err(error) => {
-                                            println!("{ERROR}Config error:{RESET} {error}")
+                                Ok(Some(idx)) => {
+                                    if let Some(model) = model_options.get(idx)
+                                        && model != &current_model
+                                    {
+                                        match session
+                                            .config
+                                            .set_active_model(&provider, Some(model))
+                                        {
+                                            Ok(name) => display_name = name,
+                                            Err(error) => {
+                                                ui.push_notice(format!("Config error: {error}"));
+                                            }
                                         }
                                     }
                                 }
-                                Ok(_) => {}
+                                Ok(None) => {}
                                 Err(e) => {
-                                    println!("{ERROR}Error selecting model:{RESET} {e}\n")
+                                    ui.push_notice(format!("Error selecting model: {e}"));
                                 }
                             }
                         }
 
-                        println!(
-                            "\n{DIM}───{RESET} {MINT}{}{RESET} {DIM}───{RESET}\n",
-                            display_name
-                        );
+                        ui.push_notice(format!("Active model: {display_name}"));
                     }
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}"),
+                    Err(error) => ui.push_notice(format!("Config error: {error}")),
                 }
             }
             Some(SlashResult::Handled)
@@ -856,29 +983,31 @@ pub async fn handle_slash_command(
             if rest == "on" || rest == "off" {
                 session.config.enable_agent_collaboration = rest == "on";
                 match mint_core::save_config(&session.config) {
-                    Ok(()) => println!(
-                        "{DIM}Multi-Agent collaboration set to: {}{RESET}\n",
+                    Ok(()) => ui.push_notice(format!(
+                        "Multi-Agent collaboration set to: {}",
                         if session.config.enable_agent_collaboration {
                             "Enabled"
                         } else {
                             "Disabled"
                         }
-                    ),
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}\n"),
+                    )),
+                    Err(error) => ui.push_notice(format!("Config error: {error}")),
                 }
             } else if !rest.is_empty() {
-                println!("{WARN}Usage: /multi-agent [on|off]{RESET}\n");
+                ui.push_notice("Usage: /multi-agent [on|off]");
             } 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}");
+                let mut lines = vec![
+                    format!("{BLUE}Multi-Agent System Settings:{RESET}"),
+                    format!("  Global Collaboration: {collab_status}"),
+                    format!("\n{BLUE}Configured Agents:{RESET}"),
+                ];
                 if session.config.agents.is_empty() {
-                    println!("  No agents configured.");
+                    lines.push("  No agents configured.".to_string());
                 } else {
                     for agent in &session.config.agents {
                         let status_label = if agent.enabled {
@@ -886,10 +1015,10 @@ pub async fn handle_slash_command(
                         } else {
                             format!("{DIM}[Disabled]{RESET}")
                         };
-                        println!(
+                        lines.push(format!(
                             "  {:<15} {}  Provider: {:<12} Model: {}",
                             agent.name, status_label, agent.provider, agent.model
-                        );
+                        ));
                         let truncated_instruction = if agent.system_instruction.chars().count() > 60
                         {
                             let head: String = agent.system_instruction.chars().take(60).collect();
@@ -897,38 +1026,34 @@ pub async fn handle_slash_command(
                         } else {
                             agent.system_instruction.replace('\n', " ")
                         };
-                        println!("    {DIM}Instruction: {truncated_instruction}{RESET}");
+                        lines.push(format!(
+                            "    {DIM}Instruction: {truncated_instruction}{RESET}"
+                        ));
                     }
                 }
-                println!();
+                ui.push_command_output(lines.join("\n"));
 
-                let options = vec![
-                    "Keep current status".to_string(),
-                    "on (enable collaboration)".to_string(),
-                    "off (disable collaboration)".to_string(),
+                let choices = vec![
+                    ChoiceItem::new("Keep current status", "keep"),
+                    ChoiceItem::new("on (enable collaboration)", "on"),
+                    ChoiceItem::new("off (disable collaboration)", "off"),
                 ];
-                let current = &options[0];
-                match prompt_interactive_select("Toggle Collaboration Status?", &options, current) {
-                    Ok(Some(sel)) => {
-                        if sel.starts_with("on") {
-                            session.config.enable_agent_collaboration = true;
-                            match mint_core::save_config(&session.config) {
-                                Ok(()) => println!(
-                                    "{DIM}Multi-Agent collaboration set to: Enabled{RESET}\n"
-                                ),
-                                Err(error) => println!("{ERROR}Config error:{RESET} {error}\n"),
-                            }
-                        } else if sel.starts_with("off") {
-                            session.config.enable_agent_collaboration = false;
-                            match mint_core::save_config(&session.config) {
-                                Ok(()) => println!(
-                                    "{DIM}Multi-Agent collaboration set to: Disabled{RESET}\n"
-                                ),
-                                Err(error) => println!("{ERROR}Config error:{RESET} {error}\n"),
-                            }
+                if let Ok(Some(idx)) =
+                    ui.prompt_choice("Toggle Collaboration Status?", "", &choices)
+                {
+                    if idx == 1 {
+                        session.config.enable_agent_collaboration = true;
+                        match mint_core::save_config(&session.config) {
+                            Ok(()) => ui.push_notice("Multi-Agent collaboration set to: Enabled"),
+                            Err(error) => ui.push_notice(format!("Config error: {error}")),
+                        }
+                    } else if idx == 2 {
+                        session.config.enable_agent_collaboration = false;
+                        match mint_core::save_config(&session.config) {
+                            Ok(()) => ui.push_notice("Multi-Agent collaboration set to: Disabled"),
+                            Err(error) => ui.push_notice(format!("Config error: {error}")),
                         }
                     }
-                    _ => {}
                 }
             }
             Some(SlashResult::Handled)
@@ -939,19 +1064,21 @@ pub async fn handle_slash_command(
 
             // Soft toggle: `avatar_signal_disabled` hides the tool while keeping
             // the token so the paired viewer never needs re-linking.
-            let set_signal_disabled = |session: &mut InteractiveSession, disabled: bool| {
+            let set_signal_disabled = |session: &mut InteractiveSession,
+                                       ui: &mut dyn CommandUi,
+                                       disabled: bool| {
                 session.config.avatar_signal_disabled = disabled;
                 match mint_core::save_config(&session.config) {
                     Ok(()) => {
                         if disabled {
-                            println!(
-                                "{DIM}[Avatar] avatar_signal disabled (token kept — run /avatar to re-enable).{RESET}\n"
-                            );
+                            ui.push_notice(
+                                    "[Avatar] avatar_signal disabled (token kept — run /avatar to re-enable).",
+                                );
                         } else {
-                            println!("{DIM}[Avatar] avatar_signal enabled.{RESET}\n");
+                            ui.push_notice("[Avatar] avatar_signal enabled.");
                         }
                     }
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}\n"),
+                    Err(error) => ui.push_notice(format!("Config error: {error}")),
                 }
             };
 
@@ -961,33 +1088,33 @@ pub async fn handle_slash_command(
                 "web" | "link web" => "web",
                 "desktop" | "link desktop" => "desktop",
                 "on" | "enable" => {
-                    set_signal_disabled(session, false);
+                    set_signal_disabled(session, ui, false);
                     return Some(SlashResult::Handled);
                 }
                 "off" | "disable" => {
-                    set_signal_disabled(session, true);
+                    set_signal_disabled(session, ui, true);
                     return Some(SlashResult::Handled);
                 }
                 "" | "link" => {
                     let options = vec![
-                        "No".to_string(),
-                        "Off (disable avatar_signal)".to_string(),
-                        "Web browser".to_string(),
-                        "Desktop app".to_string(),
+                        ChoiceItem::new("Web browser", "web"),
+                        ChoiceItem::new("Desktop app", "desktop"),
+                        ChoiceItem::new("Off (disable avatar_signal)", "off"),
+                        ChoiceItem::new("No", "no"),
                     ];
-                    match prompt_interactive_select("Avatar output", &options, &options[2]) {
-                        Ok(Some(sel)) if sel == "No" => return Some(SlashResult::Handled),
-                        Ok(Some(sel)) if sel.starts_with("Off") => {
-                            set_signal_disabled(session, true);
-                            return Some(SlashResult::Handled);
-                        }
-                        Ok(Some(sel)) if sel.starts_with("Desktop") => "desktop",
-                        Ok(Some(_)) => "web",
-                        // Cancelled / no TTY — the picker has an explicit "No",
-                        // so treat a cancel as "do nothing".
+                    match ui.prompt_choice("Avatar output", "", &options) {
+                        Ok(Some(idx)) => match options[idx].value.as_str() {
+                            "no" => return Some(SlashResult::Handled),
+                            "off" => {
+                                set_signal_disabled(session, ui, true);
+                                return Some(SlashResult::Handled);
+                            }
+                            "desktop" => "desktop",
+                            _ => "web",
+                        },
                         Ok(None) => return Some(SlashResult::Handled),
                         Err(e) => {
-                            println!("{ERROR}Error selecting target:{RESET} {e}\n");
+                            ui.push_notice(format!("Error selecting target: {e}"));
                             return Some(SlashResult::Handled);
                         }
                     }
@@ -995,44 +1122,41 @@ pub async fn handle_slash_command(
                 "status" => {
                     let cfg = AvatarBridgeConfig::from_mint_config(&session.config);
                     if !cfg.enabled {
-                        println!("{WARN}[Avatar] No token yet — run /avatar link first.{RESET}\n");
+                        ui.push_notice("[Avatar] No token yet — run /avatar link first.");
                     } else {
-                        println!(
-                            "{DIM}[Avatar] avatar_signal tool: {}{RESET}",
-                            if session.config.avatar_signal_disabled {
-                                "disabled"
-                            } else {
-                                "enabled"
-                            }
-                        );
+                        let tool_state = if session.config.avatar_signal_disabled {
+                            "disabled"
+                        } else {
+                            "enabled"
+                        };
                         match fetch_channel_state(&cfg).await {
                             Ok(state) => {
                                 let now_ms = std::time::SystemTime::now()
                                     .duration_since(std::time::UNIX_EPOCH)
                                     .map(|d| d.as_millis() as i64)
                                     .unwrap_or(0);
-                                println!("\n{BLUE}[Avatar] Channel status:{RESET}");
-                                println!(
-                                    "  Model:       {}",
-                                    state.model.unwrap_or_else(|| "not selected".into())
-                                );
-                                println!("  Viewers:     {}", state.connected_clients);
-                                println!(
-                                    "  Last event:  {}\n",
-                                    state
-                                        .last_agent_event_at
-                                        .map(|t| format!("{}s ago", (now_ms - t).max(0) / 1000))
-                                        .unwrap_or_else(|| "never".into())
-                                );
+                                let last_ev = state
+                                    .last_agent_event_at
+                                    .map(|t| format!("{}s ago", (now_ms - t).max(0) / 1000))
+                                    .unwrap_or_else(|| "never".into());
+                                ui.push_command_output(format!(
+                                    "{DIM}[Avatar] avatar_signal tool: {tool_state}{RESET}\n\
+                                     {BLUE}[Avatar] Channel status:{RESET}\n  \
+                                     Model:       {}\n  \
+                                     Viewers:     {}\n  \
+                                     Last event:  {last_ev}",
+                                    state.model.unwrap_or_else(|| "not selected".into()),
+                                    state.connected_clients
+                                ));
                             }
-                            Err(error) => println!("{ERROR}[Avatar] {error}{RESET}\n"),
+                            Err(error) => ui.push_notice(format!("[Avatar] {error}")),
                         }
                     }
                     return Some(SlashResult::Handled);
                 }
                 _ => {
-                    println!(
-                        "{WARN}Usage: /avatar [web|desktop|on|off|status] — connects agent activity to Project Avatar{RESET}\n"
+                    ui.push_notice(
+                        "Usage: /avatar [web|desktop|on|off|status] — connects agent activity to Project Avatar",
                     );
                     return Some(SlashResult::Handled);
                 }
@@ -1045,175 +1169,185 @@ pub async fn handle_slash_command(
                 session.config.avatar_token = AvatarBridgeConfig::generate_token();
             }
             if let Err(error) = mint_core::save_config(&session.config) {
-                println!("{ERROR}Config error:{RESET} {error}\n");
+                ui.push_notice(format!("Config error: {error}"));
                 return Some(SlashResult::Handled);
             }
             let cfg = AvatarBridgeConfig::from_mint_config(&session.config);
             let token = session.config.avatar_token.clone();
             if target == "desktop" {
-                println!(
-                    "\n{MINT}[Avatar] Desktop app:{RESET}\n\
+                ui.push_command_output(format!(
+                    "{MINT}[Avatar] Desktop app:{RESET}\n\
                      1. Open the Project Avatar desktop app.\n\
                      2. It has no address bar, so on first launch it generates its \
                      own token — paste this one into its \"Paste existing token...\" \
                      field instead so it connects to the same channel Mint pushes to:\n\
                      {DIM}{token}{RESET}\n\
-                     It remembers the token after that; you won't need to paste it again.\n"
-                );
+                     It remembers the token after that; you won't need to paste it again."
+                ));
             } else {
-                println!(
-                    "\n{MINT}[Avatar] Share link:{RESET}\n{}\n",
+                ui.push_command_output(format!(
+                    "{MINT}[Avatar] Share link:{RESET}\n{}",
                     cfg.share_link().expect("token was just ensured non-empty")
-                );
+                ));
             }
             Some(SlashResult::Handled)
         }
 
         "/autoskill" => {
-            if rest == "on" || rest == "off" {
-                session.config.auto_skill_writing = rest == "on";
+            let apply = |session: &mut InteractiveSession, ui: &mut dyn CommandUi, on: bool| {
+                session.config.auto_skill_writing = on;
                 match mint_core::save_config(&session.config) {
-                    Ok(()) => println!(
-                        "{DIM}Skill suggestions (approval required to save) set to: {}{RESET}\n",
-                        if session.config.auto_skill_writing {
-                            "Enabled"
-                        } else {
-                            "Disabled"
-                        }
-                    ),
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}\n"),
+                    Ok(()) => ui.push_notice(format!(
+                        "Skill suggestions (approval required to save) set to: {}",
+                        if on { "Enabled" } else { "Disabled" }
+                    )),
+                    Err(error) => ui.push_notice(format!("Config error: {error}")),
                 }
+            };
+            if rest == "on" || rest == "off" {
+                apply(session, ui, rest == "on");
             } else if !rest.is_empty() {
-                println!("{WARN}Usage: /autoskill [on|off]{RESET}\n");
+                ui.push_notice("Usage: /autoskill [on|off]");
             } else {
-                println!(
-                    "{DIM}When enabled, the agent proposes a skill after a reusable task. Each proposed diff needs your approval before saving.{RESET}"
-                );
-                let options = vec!["on (enable)".to_string(), "off (disable)".to_string()];
-                let current = if session.config.auto_skill_writing {
-                    &options[0]
+                let options = if session.config.auto_skill_writing {
+                    vec![
+                        ChoiceItem::new("on (current)", "on"),
+                        ChoiceItem::new("off", "off"),
+                    ]
                 } else {
-                    &options[1]
+                    vec![
+                        ChoiceItem::new("off (current)", "off"),
+                        ChoiceItem::new("on", "on"),
+                    ]
                 };
-                match prompt_interactive_select("Skill Suggestions", &options, current) {
-                    Ok(Some(sel)) => {
-                        session.config.auto_skill_writing = sel.starts_with("on");
-                        match mint_core::save_config(&session.config) {
-                            Ok(()) => println!(
-                                "{DIM}Skill suggestions (approval required to save) set to: {}{RESET}\n",
-                                if session.config.auto_skill_writing {
-                                    "Enabled"
-                                } else {
-                                    "Disabled"
-                                }
-                            ),
-                            Err(error) => println!("{ERROR}Config error:{RESET} {error}\n"),
-                        }
-                    }
-                    Ok(None) => println!("{DIM}Cancelled.{RESET}\n"),
-                    Err(e) => println!("{ERROR}Error selecting option:{RESET} {e}\n"),
+                match ui.prompt_choice(
+                    "Skill Suggestions",
+                    "When enabled, the agent proposes a skill after a reusable task. Each proposed diff needs your approval before saving.",
+                    &options,
+                ) {
+                    Ok(Some(idx)) => apply(session, ui, options[idx].value == "on"),
+                    Ok(None) => ui.push_notice("Cancelled."),
+                    Err(e) => ui.push_notice(format!("Error selecting option: {e}")),
                 }
             }
             Some(SlashResult::Handled)
         }
 
         "/autorecall" => {
-            let apply = |session: &mut InteractiveSession, on: bool| {
+            let apply = |session: &mut InteractiveSession, ui: &mut dyn CommandUi, on: bool| {
                 session.config.memory_recall = on;
                 match mint_core::save_config(&session.config) {
-                    Ok(()) => println!(
-                        "{DIM}Memory recall set to: {}{RESET}\n",
+                    Ok(()) => ui.push_notice(format!(
+                        "Memory recall set to: {}",
                         if on { "Enabled" } else { "Disabled" }
-                    ),
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}\n"),
+                    )),
+                    Err(error) => ui.push_notice(format!("Config error: {error}")),
                 }
             };
             if rest == "on" || rest == "off" {
-                apply(session, rest == "on");
+                apply(session, ui, rest == "on");
             } else if !rest.is_empty() {
-                println!("{WARN}Usage: /autorecall [on|off]{RESET}\n");
+                ui.push_notice("Usage: /autorecall [on|off]");
             } else {
-                println!(
-                    "{DIM}When enabled, each turn full-text-searches this conversation's older messages and injects the few most relevant to what you just said.{RESET}"
-                );
-                let options = vec!["on (enable)".to_string(), "off (disable)".to_string()];
-                let current = if session.config.memory_recall {
-                    &options[0]
+                let options = if session.config.memory_recall {
+                    vec![
+                        ChoiceItem::new("on (enable)", "on"),
+                        ChoiceItem::new("off (disable)", "off"),
+                    ]
                 } else {
-                    &options[1]
+                    vec![
+                        ChoiceItem::new("off (disable)", "off"),
+                        ChoiceItem::new("on (enable)", "on"),
+                    ]
                 };
-                match prompt_interactive_select("Memory Recall", &options, current) {
-                    Ok(Some(sel)) => apply(session, sel.starts_with("on")),
-                    Ok(None) => println!("{DIM}Cancelled.{RESET}\n"),
-                    Err(e) => println!("{ERROR}Error selecting option:{RESET} {e}\n"),
+                match ui.prompt_choice(
+                    "Memory Recall",
+                    "When enabled, each turn full-text-searches this conversation's older messages and injects the few most relevant to what you just said.",
+                    &options,
+                ) {
+                    Ok(Some(idx)) => apply(session, ui, options[idx].value == "on"),
+                    Ok(None) => ui.push_notice("Cancelled."),
+                    Err(e) => ui.push_notice(format!("Error selecting option: {e}")),
                 }
             }
             Some(SlashResult::Handled)
         }
 
         "/autofacts" => {
-            let apply = |session: &mut InteractiveSession, on: bool| {
+            let apply = |session: &mut InteractiveSession, ui: &mut dyn CommandUi, on: bool| {
                 session.config.auto_fact_extraction = on;
                 match mint_core::save_config(&session.config) {
-                    Ok(()) => println!(
-                        "{DIM}Auto fact extraction set to: {}{RESET}\n",
+                    Ok(()) => ui.push_notice(format!(
+                        "Auto fact extraction set to: {}",
                         if on { "Enabled" } else { "Disabled" }
-                    ),
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}\n"),
+                    )),
+                    Err(error) => ui.push_notice(format!("Config error: {error}")),
                 }
             };
             if rest == "on" || rest == "off" {
-                apply(session, rest == "on");
+                apply(session, ui, rest == "on");
             } else if !rest.is_empty() {
-                println!("{WARN}Usage: /autofacts [on|off]{RESET}\n");
+                ui.push_notice("Usage: /autofacts [on|off]");
             } else {
-                println!(
-                    "{DIM}When enabled, a turn that states a durable preference, naming, or standing instruction triggers a background pass that saves it to long-term memory.{RESET}"
-                );
-                let options = vec!["on (enable)".to_string(), "off (disable)".to_string()];
-                let current = if session.config.auto_fact_extraction {
-                    &options[0]
+                let options = if session.config.auto_fact_extraction {
+                    vec![
+                        ChoiceItem::new("on (enable)", "on"),
+                        ChoiceItem::new("off (disable)", "off"),
+                    ]
                 } else {
-                    &options[1]
+                    vec![
+                        ChoiceItem::new("off (disable)", "off"),
+                        ChoiceItem::new("on (enable)", "on"),
+                    ]
                 };
-                match prompt_interactive_select("Auto Fact Extraction", &options, current) {
-                    Ok(Some(sel)) => apply(session, sel.starts_with("on")),
-                    Ok(None) => println!("{DIM}Cancelled.{RESET}\n"),
-                    Err(e) => println!("{ERROR}Error selecting option:{RESET} {e}\n"),
+                match ui.prompt_choice(
+                    "Auto Fact Extraction",
+                    "When enabled, a turn that states a durable preference, naming, or standing instruction triggers a background pass that saves it to long-term memory.",
+                    &options,
+                ) {
+                    Ok(Some(idx)) => apply(session, ui, options[idx].value == "on"),
+                    Ok(None) => ui.push_notice("Cancelled."),
+                    Err(e) => ui.push_notice(format!("Error selecting option: {e}")),
                 }
             }
             Some(SlashResult::Handled)
         }
 
         "/factrecall" => {
-            let apply = |session: &mut InteractiveSession, on: bool| {
+            let apply = |session: &mut InteractiveSession, ui: &mut dyn CommandUi, on: bool| {
                 session.config.semantic_fact_recall = on;
                 match mint_core::save_config(&session.config) {
-                    Ok(()) => println!(
-                        "{DIM}Semantic fact recall set to: {}{RESET}\n",
+                    Ok(()) => ui.push_notice(format!(
+                        "Semantic fact recall set to: {}",
                         if on { "Enabled" } else { "Disabled" }
-                    ),
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}\n"),
+                    )),
+                    Err(error) => ui.push_notice(format!("Config error: {error}")),
                 }
             };
             if rest == "on" || rest == "off" {
-                apply(session, rest == "on");
+                apply(session, ui, rest == "on");
             } else if !rest.is_empty() {
-                println!("{WARN}Usage: /factrecall [on|off]{RESET}\n");
+                ui.push_notice("Usage: /factrecall [on|off]");
             } else {
-                println!(
-                    "{DIM}When your stored facts overflow their per-turn budget, this fills the overflow with the facts most relevant to your message instead of just the newest ones (the newest few are always kept).{RESET}"
-                );
-                let options = vec!["on (enable)".to_string(), "off (disable)".to_string()];
-                let current = if session.config.semantic_fact_recall {
-                    &options[0]
+                let options = if session.config.semantic_fact_recall {
+                    vec![
+                        ChoiceItem::new("on (enable)", "on"),
+                        ChoiceItem::new("off (disable)", "off"),
+                    ]
                 } else {
-                    &options[1]
+                    vec![
+                        ChoiceItem::new("off (disable)", "off"),
+                        ChoiceItem::new("on (enable)", "on"),
+                    ]
                 };
-                match prompt_interactive_select("Semantic Fact Recall", &options, current) {
-                    Ok(Some(sel)) => apply(session, sel.starts_with("on")),
-                    Ok(None) => println!("{DIM}Cancelled.{RESET}\n"),
-                    Err(e) => println!("{ERROR}Error selecting option:{RESET} {e}\n"),
+                match ui.prompt_choice(
+                    "Semantic Fact Recall",
+                    "When your stored facts overflow their per-turn budget, this fills the overflow with the facts most relevant to your message instead of just the newest ones (the newest few are always kept).",
+                    &options,
+                ) {
+                    Ok(Some(idx)) => apply(session, ui, options[idx].value == "on"),
+                    Ok(None) => ui.push_notice("Cancelled."),
+                    Err(e) => ui.push_notice(format!("Error selecting option: {e}")),
                 }
             }
             Some(SlashResult::Handled)
@@ -1234,25 +1368,25 @@ pub async fn handle_slash_command(
                 ("user", None, rest)
             };
             if body.is_empty() {
-                println!("{WARN}Usage: /remember [here] <text>{RESET}\n");
+                ui.push_notice("Usage: /remember [here] <text>");
                 return Some(SlashResult::Handled);
             }
             match MemoryStore::open_default() {
                 Ok(memory) => {
                     match memory.add_fact(scope, project_path.as_deref(), body, None, None) {
-                        Ok(Some(_)) => println!(
-                            "{DIM}Remembered{}.{RESET}\n",
+                        Ok(Some(_)) => ui.push_notice(format!(
+                            "Remembered{}.",
                             if scope == "project" {
                                 " (this project)"
                             } else {
                                 ""
                             }
-                        ),
-                        Ok(None) => println!("{DIM}Already remembered.{RESET}\n"),
-                        Err(e) => println!("{ERROR}Error:{RESET} {e}\n"),
+                        )),
+                        Ok(None) => ui.push_notice("Already remembered."),
+                        Err(e) => ui.push_notice(format!("Error: {e}")),
                     }
                 }
-                Err(e) => println!("{ERROR}Memory error:{RESET} {e}\n"),
+                Err(e) => ui.push_notice(format!("Memory error: {e}")),
             }
             Some(SlashResult::Handled)
         }
@@ -1282,42 +1416,45 @@ pub async fn handle_slash_command(
             }
 
             let selected_provider = if rest.is_empty() {
-                let options: Vec<String> = available.iter().map(|s| s.to_string()).collect();
-                match prompt_interactive_select(
-                    "Select Image Generation provider",
-                    &options,
-                    &session.config.image_gen_provider,
-                ) {
-                    Ok(Some(p)) => Some(p),
+                let mut options: Vec<ChoiceItem> =
+                    available.iter().map(|s| ChoiceItem::new(*s, *s)).collect();
+                if let Some(pos) = options
+                    .iter()
+                    .position(|o| o.value == session.config.image_gen_provider)
+                    && pos > 0
+                {
+                    let item = options.remove(pos);
+                    options.insert(0, item);
+                }
+                match ui.prompt_choice("Select Image Generation provider", "", &options) {
+                    Ok(Some(idx)) => Some(options[idx].value.clone()),
                     Ok(None) => {
-                        println!("Cancelled image provider selection.\n");
+                        ui.push_notice("Cancelled image provider selection.");
                         None
                     }
                     Err(e) => {
-                        println!("{ERROR}Error selecting provider:{RESET} {e}\n");
+                        ui.push_notice(format!("Error selecting provider: {e}"));
                         None
                     }
                 }
+            } else if available.contains(&rest) {
+                Some(rest.to_owned())
             } else {
-                if available.contains(&rest) {
-                    Some(rest.to_owned())
-                } else {
-                    println!("{ERROR}Provider '{rest}' is not configured or invalid.{RESET}\n");
-                    None
-                }
+                ui.push_notice(format!("Provider '{rest}' is not configured or invalid."));
+                None
             };
 
             if let Some(provider) = selected_provider {
-                print!("{DIM}Fetching available image models for {provider}...{RESET}\r");
-                let _ = std::io::Write::flush(&mut std::io::stdout());
+                ui.set_status(vec![format!(
+                    "Fetching available image models for {provider}..."
+                )]);
                 let mut model_options =
                     mint_core::media::image_models::image_model_options_for_provider_async(
                         &session.config,
                         &provider,
                     )
                     .await;
-                print!("\r\x1b[2K");
-                let _ = std::io::Write::flush(&mut std::io::stdout());
+                ui.clear_status();
 
                 let current_model =
                     mint_core::media::image_models::active_image_model_for_provider(
@@ -1330,19 +1467,29 @@ pub async fn handle_slash_command(
                 }
 
                 if !model_options.is_empty() {
-                    match prompt_interactive_select(
+                    let mut choices: Vec<ChoiceItem> = model_options
+                        .iter()
+                        .map(|m| ChoiceItem::new(m.clone(), m.clone()))
+                        .collect();
+                    if let Some(pos) = choices.iter().position(|c| c.value == current_model)
+                        && pos > 0
+                    {
+                        let item = choices.remove(pos);
+                        choices.insert(0, item);
+                    }
+                    match ui.prompt_choice(
                         &format!(
                             "Select {} model",
                             mint_core::media::image_models::image_provider_display_name(&provider)
                         ),
-                        &model_options,
-                        &current_model,
+                        "",
+                        &choices,
                     ) {
-                        Ok(Some(model)) => {
+                        Ok(Some(idx)) => {
                             mint_core::media::image_models::set_active_image_provider_model(
                                 &mut session.config,
                                 &provider,
-                                Some(&model),
+                                Some(&choices[idx].value),
                             );
                         }
                         Ok(None) => {
@@ -1353,7 +1500,7 @@ pub async fn handle_slash_command(
                             );
                         }
                         Err(e) => {
-                            println!("{ERROR}Error selecting image model:{RESET} {e}\n");
+                            ui.push_notice(format!("Error selecting image model: {e}"));
                         }
                     }
                 } else {
@@ -1371,13 +1518,13 @@ pub async fn handle_slash_command(
                                 &session.config,
                                 &provider,
                             );
-                        println!(
-                            "{DIM}Switched default image provider to: {} • {}{RESET}\n",
+                        ui.push_notice(format!(
+                            "Switched default image provider to: {} • {}",
                             mint_core::media::image_models::image_provider_display_name(&provider),
                             active
-                        );
+                        ));
                     }
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}"),
+                    Err(error) => ui.push_notice(format!("Config error: {error}")),
                 }
             }
             Some(SlashResult::Handled)
@@ -1393,49 +1540,24 @@ pub async fn handle_slash_command(
                 available.push("veo");
             }
 
-            let current_provider = session
-                .config
-                .extra
-                .get("videoGenProvider")
-                .and_then(|v| v.as_str())
-                .unwrap_or("veo")
-                .to_string();
-
             let selected_provider = if rest.is_empty() {
-                let options = vec!["Google Veo (Gemini Videos)".to_string()];
-                let current_display = if current_provider == "veo" {
-                    "Google Veo (Gemini Videos)"
-                } else {
-                    &current_provider
-                };
-                match prompt_interactive_select(
-                    "Select Video Generation provider",
-                    &options,
-                    current_display,
-                ) {
-                    Ok(Some(p)) => {
-                        if p == "Google Veo (Gemini Videos)" {
-                            Some("veo".to_string())
-                        } else {
-                            Some(p)
-                        }
-                    }
+                let options = vec![ChoiceItem::new("Google Veo (Gemini Videos)", "veo")];
+                match ui.prompt_choice("Select Video Generation provider", "", &options) {
+                    Ok(Some(idx)) => Some(options[idx].value.clone()),
                     Ok(None) => {
-                        println!("Cancelled video provider selection.\n");
+                        ui.push_notice("Cancelled video provider selection.");
                         None
                     }
                     Err(e) => {
-                        println!("{ERROR}Error selecting provider:{RESET} {e}\n");
+                        ui.push_notice(format!("Error selecting provider: {e}"));
                         None
                     }
                 }
+            } else if rest == "veo" || rest == "Google Veo (Gemini Videos)" {
+                Some("veo".to_string())
             } else {
-                if rest == "veo" || rest == "Google Veo (Gemini Videos)" {
-                    Some("veo".to_string())
-                } else {
-                    println!("{ERROR}Provider '{rest}' is not configured or invalid.{RESET}\n");
-                    None
-                }
+                ui.push_notice(format!("Provider '{rest}' is not configured or invalid."));
+                None
             };
 
             if let Some(provider) = selected_provider {
@@ -1450,12 +1572,11 @@ pub async fn handle_slash_command(
                         } else {
                             &provider
                         };
-                        println!(
-                            "{DIM}Switched default video provider to: {}{RESET}\n",
-                            display_name
-                        );
+                        ui.push_notice(format!(
+                            "Switched default video provider to: {display_name}"
+                        ));
                     }
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}"),
+                    Err(error) => ui.push_notice(format!("Config error: {error}")),
                 }
             }
             Some(SlashResult::Handled)
@@ -1498,8 +1619,8 @@ pub async fn handle_slash_command(
             }
 
             if available.is_empty() {
-                println!(
-                    "{ERROR}No search provider is configured yet.{RESET} Run onboarding or set a Google/Brave key or SearXNG URL in Settings first.\n"
+                ui.push_notice(
+                    "No search provider is configured yet. Run onboarding or set a Google/Brave key or SearXNG URL in Settings first.",
                 );
                 return Some(SlashResult::Handled);
             }
@@ -1513,30 +1634,24 @@ pub async fn handle_slash_command(
                 .to_string();
 
             let selected_provider = if rest.is_empty() {
-                let options: Vec<String> = available
+                let mut options: Vec<ChoiceItem> = available
                     .iter()
-                    .map(|(_, label)| label.to_string())
+                    .map(|(key, label)| ChoiceItem::new(*label, *key))
                     .collect();
-                let current_display = available
-                    .iter()
-                    .find(|(key, _)| *key == current_provider)
-                    .map(|(_, label)| *label)
-                    .unwrap_or(available[0].1);
-                match prompt_interactive_select(
-                    "Select Web Search provider",
-                    &options,
-                    current_display,
-                ) {
-                    Ok(Some(label)) => available
-                        .iter()
-                        .find(|(_, l)| *l == label)
-                        .map(|(key, _)| key.to_string()),
+                if let Some(pos) = options.iter().position(|o| o.value == current_provider)
+                    && pos > 0
+                {
+                    let item = options.remove(pos);
+                    options.insert(0, item);
+                }
+                match ui.prompt_choice("Select Web Search provider", "", &options) {
+                    Ok(Some(idx)) => Some(options[idx].value.clone()),
                     Ok(None) => {
-                        println!("Cancelled search provider selection.\n");
+                        ui.push_notice("Cancelled search provider selection.");
                         None
                     }
                     Err(e) => {
-                        println!("{ERROR}Error selecting provider:{RESET} {e}\n");
+                        ui.push_notice(format!("Error selecting provider: {e}"));
                         None
                     }
                 }
@@ -1546,7 +1661,7 @@ pub async fn handle_slash_command(
             {
                 Some(key.to_string())
             } else {
-                println!("{ERROR}Provider '{rest}' is not configured or invalid.{RESET}\n");
+                ui.push_notice(format!("Provider '{rest}' is not configured or invalid."));
                 None
             };
 
@@ -1562,12 +1677,11 @@ pub async fn handle_slash_command(
                             .find(|(key, _)| *key == provider)
                             .map(|(_, label)| *label)
                             .unwrap_or(&provider);
-                        println!(
-                            "{DIM}Switched default web search provider to: {}{RESET}\n",
-                            display_name
-                        );
+                        ui.push_notice(format!(
+                            "Switched default web search provider to: {display_name}"
+                        ));
                     }
-                    Err(error) => println!("{ERROR}Config error:{RESET} {error}"),
+                    Err(error) => ui.push_notice(format!("Config error: {error}")),
                 }
             }
             Some(SlashResult::Handled)
@@ -1710,6 +1824,17 @@ pub async fn handle_slash_command(
                 .unwrap_or((rest, ""));
 
             match sub {
+                "stop" if arg.is_empty() => {
+                    match mint_core::bg_shell::shells_command(
+                        "stop",
+                        &session.current_dir,
+                        &None,
+                        &session.config,
+                    ) {
+                        Ok(message) => ui.push_notice(message),
+                        Err(error) => ui.push_notice(error.to_string()),
+                    }
+                }
                 "show" if !arg.is_empty() => match mint_core::bg_shell::snapshot(arg) {
                     Ok(job) => {
                         let mut lines =
@@ -1737,7 +1862,7 @@ pub async fn handle_slash_command(
                     Ok(msg) => ui.push_notice(msg),
                     Err(_) => ui.push_notice("No such job."),
                 },
-                _ => ui.push_notice("Usage: /shells [all|show <id>|stop <id>|kill <id>]"),
+                _ => ui.push_notice("Usage: /shells [all|show <id>|stop [<id>]|kill <id>]"),
             }
             Some(SlashResult::Handled)
         }
@@ -1988,9 +2113,15 @@ pub async fn handle_slash_command(
                     }
                 };
                 if unique_skills.is_empty() {
-                    println!("No learned skills found. Use '/learn <path>' to add one.\n");
+                    println!(
+                        "No learned skills found in workspace: {}. Use '/learn <path>' to add one.\n",
+                        session.current_dir.display()
+                    );
                 } else {
-                    println!("Learned AI Skills:");
+                    println!(
+                        "Learned AI Skills (Workspace: {}):",
+                        session.current_dir.display()
+                    );
                     for entry in &unique_skills {
                         let skill = &entry.skill;
                         let name = &skill.name;
@@ -2036,10 +2167,11 @@ pub async fn handle_slash_command(
                     let skills = load_all_available_skills(&session.current_dir);
                     if skills.is_empty() {
                         println!(
-                            "No skills found. Use `/skill add <path|github-repo|url>` to add one.\n"
+                            "No skills found in workspace: {}. Use `/skill add <path|github-repo|url>` to add one.\n",
+                            session.current_dir.display()
                         );
                     } else {
-                        println!("Skills:");
+                        println!("Skills (Workspace: {}):", session.current_dir.display());
                         for skill in &skills {
                             let loc = if skill.source_path.contains("/.config/mint/mint-skills") {
                                 "Global"
@@ -2234,6 +2366,77 @@ pub async fn handle_slash_command(
             Some(SlashResult::Handled)
         }
 
+        "/trajectory" => {
+            let memory = match MemoryStore::open_default() {
+                Ok(m) => m,
+                Err(e) => {
+                    println!("{ERROR}Memory error:{RESET} {e}\n");
+                    return Some(SlashResult::Handled);
+                }
+            };
+            let chat_id = mint_core::scoped_chat_id(
+                CHAT_CLI_ID,
+                Some(&session.current_dir.to_string_lossy()),
+            );
+            let (subcmd, args) = rest
+                .split_once(char::is_whitespace)
+                .map(|(c, a)| (c, a.trim()))
+                .unwrap_or((rest, ""));
+
+            match subcmd {
+                "export" => {
+                    let (run_id_opt, path_opt) = if args.is_empty() {
+                        (None, None)
+                    } else if args.starts_with("run-") {
+                        let mut parts = args.split_whitespace();
+                        let r = parts.next();
+                        let p = parts.next();
+                        (r, p)
+                    } else {
+                        (None, Some(args))
+                    };
+
+                    match memory.export_trajectory_json(&chat_id, run_id_opt) {
+                        Ok(json) => {
+                            let default_path = format!("trajectory-{}.json", chrono::Local::now().format("%Y%m%d%H%M%S"));
+                            let dest_path = path_opt.unwrap_or(&default_path);
+                            match std::fs::write(dest_path, &json) {
+                                Ok(_) => println!("{MINT}Exported SWE-bench trajectory to {dest_path}{RESET}\n"),
+                                Err(err) => println!("{ERROR}Failed to write trajectory to {dest_path}:{RESET} {err}\n"),
+                            }
+                        }
+                        Err(e) => println!("{ERROR}Failed to export trajectory:{RESET} {e}\n"),
+                    }
+                }
+                _ => {
+                    match memory.export_trajectory_json(&chat_id, None) {
+                        Ok(json) => {
+                            if let Ok(run) = mint_core::orchestration::trajectory_schema::StandardTrajectoryRun::from_json(&json) {
+                                println!("\n{BLUE}Execution Trajectory (v{}){RESET}", run.schema_version);
+                                println!("  {DIM}Run ID:{RESET} {}", run.run_id);
+                                println!("  {DIM}Task:{RESET} {}", run.task);
+                                println!("  {DIM}Model:{RESET} {} ({})", run.model, run.provider);
+                                println!("  {DIM}Outcome:{RESET} {}", run.outcome);
+                                println!("  {DIM}Metrics:{RESET} {} steps | {} tokens | {:.1}s", run.total_steps, run.total_tokens, run.duration_secs);
+                                if !run.trajectory.is_empty() {
+                                    println!("\n  {BLUE}Step Timeline:{RESET}");
+                                    for s in &run.trajectory {
+                                        let status_color = if s.status == "success" { MINT } else { ERROR };
+                                        println!("    {DIM}Step {:>2}:{RESET} {:<15} {status_color}{:<10}{RESET} ({}ms)", s.step, s.action, s.status, s.duration_ms);
+                                    }
+                                }
+                                println!("\n{DIM}Use '/trajectory export [path.json]' to save SWE-bench JSON.{RESET}\n");
+                            } else {
+                                println!("{DIM}Trajectory JSON ({} bytes). Use '/trajectory export' to save.{RESET}\n", json.len());
+                            }
+                        }
+                        Err(e) => println!("{DIM}No recorded trajectory for this session:{RESET} {e}\n"),
+                    }
+                }
+            }
+            Some(SlashResult::Handled)
+        }
+
         "/cron" => {
             let cron_jobs = match mint_core::CronStore::open_default() {
                 Ok(store) => store,
@@ -2557,11 +2760,9 @@ pub async fn handle_slash_command(
             Some(SlashResult::Handled)
         }
 
-        "/release-notes" => {
-            ui.push_command_output(format!(
-                "\n{BLUE}────────────────────────────────────────────{RESET}\n{}\n{BLUE}────────────────────────────────────────────{RESET}",
-                mint_core::release_notes::text()
-            ));
+        "/release-notes" | "/release_notes" | "/release-note" | "/release_note"
+        | "/releasenotes" | "/releasenote" => {
+            ui.push_release_notes(&mint_core::release_notes::text());
             Some(SlashResult::Handled)
         }
 
@@ -2993,6 +3194,74 @@ pub async fn handle_slash_command(
             }
         }
 
+        "/voice" => {
+            let sub = rest.trim().to_ascii_lowercase();
+            if sub == "stop" || sub == "cancel" {
+                let _ = super::stop_cli_voice_recording();
+                ui.push_notice("Voice recording stopped.");
+                return Some(SlashResult::Handled);
+            }
+            if !super::is_cli_voice_recording()
+                && let Err(err) = super::start_cli_voice_recording()
+            {
+                ui.push_notice(format!("Microphone error: {err}"));
+                return Some(SlashResult::Handled);
+            }
+            let choices = vec![
+                ChoiceItem::with_description(
+                    "Transcribe & Send",
+                    "Stop recording, transcribe speech, and send prompt to Mint",
+                    "send",
+                ),
+                ChoiceItem::with_description("Cancel", "Discard current voice recording", "cancel"),
+            ];
+            match ui.prompt_choice(
+                "🎙 Recording Voice",
+                "Speak into your microphone, then select an action:",
+                &choices,
+            ) {
+                Ok(Some(0)) => {
+                    let wav_bytes = match super::stop_cli_voice_recording() {
+                        Ok(Some(bytes)) => bytes,
+                        Ok(None) => {
+                            ui.push_notice("No active voice recording found.");
+                            return Some(SlashResult::Handled);
+                        }
+                        Err(err) => {
+                            ui.push_notice(format!("Voice recording error: {err}"));
+                            return Some(SlashResult::Handled);
+                        }
+                    };
+                    ui.push_notice("Transcribing voice recording…");
+                    match mint_core::mic_transcribe::transcribe_recording(
+                        &session.config,
+                        wav_bytes,
+                    )
+                    .await
+                    {
+                        Ok(text) if !text.trim().is_empty() => {
+                            let cleaned = text.trim().to_string();
+                            ui.push_notice(format!("🎙 Heard: {cleaned}"));
+                            Some(SlashResult::ForwardToAgent(cleaned))
+                        }
+                        Ok(_) => {
+                            ui.push_notice("No speech detected in voice recording.");
+                            Some(SlashResult::Handled)
+                        }
+                        Err(err) => {
+                            ui.push_notice(format!("Voice transcription failed: {err}"));
+                            Some(SlashResult::Handled)
+                        }
+                    }
+                }
+                _ => {
+                    let _ = super::stop_cli_voice_recording();
+                    ui.push_notice("Voice recording cancelled.");
+                    Some(SlashResult::Handled)
+                }
+            }
+        }
+
         _ => {
             // Unknown slash command — treat as normal message to the agent
             None
@@ -4155,4 +4424,120 @@ mod tests {
         assert!(matches!(res, Some(SlashResult::Handled)));
         assert!(session.fast_mode);
     }
+
+    #[tokio::test]
+    async fn slash_release_notes_routes_to_push_release_notes() {
+        let mut session = InteractiveSession {
+            chat_id: mint_core::CHAT_CLI_ID.to_string(),
+            config: MintConfig::default(),
+            current_dir: std::env::current_dir().unwrap(),
+            fast_mode: false,
+            plan_mode: false,
+            pending_image: None,
+            history: Vec::new(),
+            jobs: BackgroundJobs::new(),
+        };
+
+        for cmd in [
+            "/release-notes",
+            "/release_notes",
+            "/release-note",
+            "/release_note",
+        ] {
+            let mut ui = MockCommandUi::new();
+            let res = handle_slash_command(&mut session, &mut ui, cmd).await;
+            assert!(matches!(res, Some(SlashResult::Handled)));
+            assert!(
+                ui.command_outputs.is_empty(),
+                "must not route {cmd} to push_command_output"
+            );
+            assert_eq!(
+                ui.release_notes.len(),
+                1,
+                "must route {cmd} to push_release_notes"
+            );
+            assert!(ui.release_notes[0].contains("Release Notes"));
+        }
+    }
+
+    #[test]
+    fn format_plan_meta_parses_timestamp() {
+        let p1 = Path::new("/tmp/plans/20261102-182231-my-plan.md");
+        assert_eq!(format_plan_meta(p1), "2026-11-02 18:22:31 · my-plan");
+
+        let p2 = Path::new("/tmp/plans/20261102-180001.md");
+        assert_eq!(format_plan_meta(p2), "2026-11-02 18:00:01");
+
+        let p3 = Path::new("/tmp/plans/custom-plan.md");
+        assert_eq!(format_plan_meta(p3), "custom-plan.md");
+    }
+
+    #[tokio::test]
+    async fn slash_plan_list_interactive_selection_and_show() {
+        let temp = std::env::temp_dir().join(format!("mint-plan-test-{}", std::process::id()));
+        let plans_dir = temp.join(".agents").join("plans");
+        std::fs::create_dir_all(&plans_dir).unwrap();
+
+        let plan1_content = "# First Plan\n- [ ] Task 1";
+        let plan2_content = "# Second Plan\n- [x] Done";
+        std::fs::write(plans_dir.join("20261102-180000-plan-one.md"), plan1_content).unwrap();
+        std::fs::write(plans_dir.join("20261102-183000-plan-two.md"), plan2_content).unwrap();
+
+        let mut session = InteractiveSession {
+            chat_id: mint_core::CHAT_CLI_ID.to_string(),
+            config: MintConfig::default(),
+            current_dir: temp.clone(),
+            fast_mode: false,
+            plan_mode: false,
+            pending_image: None,
+            history: Vec::new(),
+            jobs: BackgroundJobs::new(),
+        };
+
+        // 1. /plan list with interactive selection (pick index 0, which is the newest plan2)
+        let mut ui = MockCommandUi::new();
+        ui.choice_answers.push(Some(0));
+        let res = handle_slash_command(&mut session, &mut ui, "/plan list").await;
+        assert!(matches!(res, Some(SlashResult::Handled)));
+        assert_eq!(ui.plans.len(), 1);
+        assert_eq!(ui.plans[0], plan2_content);
+
+        // 2. /plan list 1 directly views the first plan
+        let mut ui = MockCommandUi::new();
+        let res = handle_slash_command(&mut session, &mut ui, "/plan list 1").await;
+        assert!(matches!(res, Some(SlashResult::Handled)));
+        assert_eq!(ui.plans.len(), 1);
+        assert_eq!(ui.plans[0], plan2_content);
+
+        // 3. /plan show 2 views the second plan
+        let mut ui = MockCommandUi::new();
+        let res = handle_slash_command(&mut session, &mut ui, "/plan show 2").await;
+        assert!(matches!(res, Some(SlashResult::Handled)));
+        assert_eq!(ui.plans.len(), 1);
+        assert_eq!(ui.plans[0], plan1_content);
+
+        let _ = std::fs::remove_dir_all(temp);
+    }
+
+    #[tokio::test]
+    async fn slash_voice_stop_is_handled_cleanly() {
+        let mut session = InteractiveSession {
+            chat_id: mint_core::CHAT_CLI_ID.to_string(),
+            config: MintConfig::default(),
+            current_dir: std::env::current_dir().unwrap(),
+            fast_mode: false,
+            plan_mode: false,
+            pending_image: None,
+            history: Vec::new(),
+            jobs: BackgroundJobs::new(),
+        };
+        let mut ui = MockCommandUi::new();
+        let res = handle_slash_command(&mut session, &mut ui, "/voice stop").await;
+        assert!(matches!(res, Some(SlashResult::Handled)));
+        assert!(
+            ui.notices.iter().any(|n| n.contains("Voice recording")),
+            "expected voice notice, got: {:?}",
+            ui.notices
+        );
+    }
 }