@pheem49/mint 1.14.0 → 1.16.0

package/crates/mint-core/src/slash/mod.rs

@@ -1,7 +1,7 @@
 //! UI-agnostic slash-command engine, shared by the CLI
 //! (`crates/mint-cli/src/interactive/slash_commands.rs`), the web API server
 //! (`crate::api_server::routes::slash`), and the desktop Tauri host
-//! (`src-tauri/src/lib.rs::run_slash_command`).
+//! (`src-tauri/src/commands/conversation.rs::run_slash_command`).
 //!
 //! `execute` is a pure function of its `input` string plus the `MintConfig` it
 //! is handed: it mutates the config in place for config commands and reports
@@ -17,6 +17,7 @@
 
 use crate::MintConfig;
 use std::path::{Path, PathBuf};
+mod mods;
 
 /// The instruction `/init` hands to the code agent (via
 /// [`SlashResponse::ForwardToAgent`]). Mirrors Claude Code's `/init`, but
@@ -48,6 +49,8 @@ use render::{local_time, md_heading, md_list, md_table};
 #[derive(serde::Deserialize)]
 pub struct SlashRequest {
     pub input: String,
+    #[serde(default)]
+    pub chat_id: Option<String>,
     /// Active workspace directory; defaults to the process cwd.
     #[serde(default)]
     pub cwd: Option<String>,
@@ -128,6 +131,7 @@ pub enum SlashEffect {
     WorkspaceChanged {
         path: String,
     },
+    WorkspaceFilesChanged,
     /// `/clear` — caller wipes the current conversation.
     HistoryCleared,
     FastModeChanged {
@@ -139,6 +143,10 @@ pub enum SlashEffect {
     PlanModeChanged {
         enabled: bool,
     },
+    ThinkingChanged {
+        enabled: bool,
+        effort: String,
+    },
 }
 
 #[derive(serde::Serialize)]
@@ -189,29 +197,50 @@ pub fn execute(req: &SlashRequest, config: &mut MintConfig) -> SlashResponse {
         return SlashResponse::NotHandled;
     };
 
+    if token == "/mods" || token.starts_with("/mods:") {
+        let Some(chat) = req.chat_id.as_deref().filter(|s| !s.is_empty()) else {
+            return error("Mods require an explicit chat ID");
+        };
+        let root = req.workspace();
+        if let Err(e) = crate::assert_path_capability(&root, crate::Capability::Read, config) {
+            return error(e.to_string());
+        }
+        if token == "/mods" {
+            if let Some(response) = mods::picker(&root, chat, rest) {
+                return response.unwrap_or_else(error);
+            }
+        }
+        return match crate::mods::slash(&root, chat, &req.input) {
+            Ok(text) => message(text),
+            Err(e) => error(e),
+        };
+    }
     match token.as_str() {
+        "/mint-web" => match crate::system::mint_web::command(&req.workspace(), rest, None, config) { Ok(text) => message(text), Err(err) => error(err) },
+        "/shells" if !req.is_cli() => match crate::bg_shell::shells_command(rest, &req.workspace(), &None, config) {
+            Ok(text) => message(text), Err(err) => error(err.to_string()),
+        },
+        "/preview" => match crate::system::html_preview::command(&req.workspace(), rest, None, config) { Ok(text) => message(text), Err(err) => error(err) },
         "/help" => cmd_help(req.is_cli()),
         "/init" => SlashResponse::ForwardToAgent {
             prompt: INIT_AGENTS_MD_PROMPT.to_string(),
             agent_mode: true,
             plan_mode: false,
         },
-        "/release-notes" => message(
-            include_str!(concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/../../Release_Note.md"
-            ))
-            .trim(),
-        ),
+        "/release-notes" => message(crate::release_notes::text()),
         "/clear" => SlashResponse::Applied {
             markdown: "🧹 Conversation history cleared.".into(),
             effects: vec![SlashEffect::HistoryCleared],
         },
+        "/thought" => SlashResponse::Applied {
+            markdown: "Thought process can be viewed in the collapsible **Thinking** accordion on Desktop & Web, or by pressing `Ctrl+T` / running `/thought` in the CLI.".into(),
+            effects: vec![],
+        },
 
         "/autoskill" => cmd_bool_toggle(
             rest,
             "/autoskill",
-            "Auto Skill Writing",
+            "Skill Suggestions (approval required to save)",
             config.auto_skill_writing,
             |cfg, v| cfg.auto_skill_writing = v,
             config,
@@ -262,6 +291,10 @@ pub fn execute(req: &SlashRequest, config: &mut MintConfig) -> SlashResponse {
             }
         }
         "/rewind" => cmd_rewind(req, rest),
+        "/history" | "/undo" => {
+            if !rest.trim().is_empty() { error(format!("Usage: {token}")) }
+            else { cmd_workspace_history(req, token == "/undo", config) }
+        }
         "/fast" => match parse_on_off(rest) {
             None if rest.is_empty() => needs_on_off("/fast", "Fast Mode (hide thinking)"),
             None => error("Usage: /fast [on|off]"),
@@ -280,6 +313,7 @@ pub fn execute(req: &SlashRequest, config: &mut MintConfig) -> SlashResponse {
         },
 
         "/models" => cmd_models(rest, config),
+        "/thinking" | "/think" => cmd_thinking(rest, config),
         "/temperature" | "/temp" => cmd_temperature(rest, config),
         // `/searchProvider` is a documented camelCase alias (see UNDOCUMENTED_ALIASES).
         "/search-provider" | "/searchprovider" => cmd_extra_provider(
@@ -567,6 +601,44 @@ fn cmd_bool_toggle(
     }
 }
 
+fn cmd_workspace_history(req: &SlashRequest, undo: bool, config: &MintConfig) -> SlashResponse {
+    let capability = if undo {
+        crate::Capability::Write
+    } else {
+        crate::Capability::Read
+    };
+    let root = match crate::assert_path_capability(&req.workspace(), capability, config) {
+        Ok(root) => root,
+        Err(reason) => return error(reason),
+    };
+    if undo {
+        match crate::system::workspace_history::undo(&root, None) {
+            Ok(Some(entry)) => SlashResponse::Applied {
+                markdown: format!("✅ {}", entry.label),
+                effects: vec![SlashEffect::WorkspaceFilesChanged],
+            },
+            Ok(None) => message("There is no workspace action to undo."),
+            Err(reason) => error(reason),
+        }
+    } else {
+        match crate::system::workspace_history::list(&root) {
+            Ok(entries) if entries.is_empty() => message(
+                "No workspace file history yet. File edits are backed up before changes, including projects without Git.",
+            ),
+            Ok(entries) => message(format!(
+                "Recent workspace file actions (newest first):\n\n{}\n\nUse `/undo` to undo the latest action. Changed files and occupied restore paths are protected.",
+                entries
+                    .iter()
+                    .take(20)
+                    .map(|entry| format!("- {}", entry.label.trim_start_matches("Undo ")))
+                    .collect::<Vec<_>>()
+                    .join("\n")
+            )),
+            Err(reason) => error(reason),
+        }
+    }
+}
+
 fn cmd_rewind(req: &SlashRequest, rest: &str) -> SlashResponse {
     let chat_id = crate::CHAT_CLI_ID;
     let root = req.workspace();
@@ -641,16 +713,25 @@ fn cmd_models(rest: &str, config: &mut MintConfig) -> SlashResponse {
     if model.is_none() {
         let options = models::model_options_for_provider(config, provider);
         if !options.is_empty() {
+            let mut choices: Vec<SlashChoice> = options
+                .into_iter()
+                .map(|m| {
+                    let label = if models::is_free_model(&m) {
+                        format!("{m} [FREE]")
+                    } else {
+                        m.clone()
+                    };
+                    SlashChoice { label, value: m }
+                })
+                .collect();
+            choices.push(SlashChoice {
+                label: "[Custom] Enter custom model ID...".into(),
+                value: "__action:custom".into(),
+            });
             return SlashResponse::NeedsChoice {
                 command: format!("/models {provider}"),
                 title: format!("Select {provider} model"),
-                options: options
-                    .into_iter()
-                    .map(|m| SlashChoice {
-                        label: m.clone(),
-                        value: m,
-                    })
-                    .collect(),
+                options: choices,
             };
         }
     }
@@ -822,6 +903,139 @@ fn cmd_temperature_status(config: &MintConfig) -> SlashResponse {
     message(md)
 }
 
+fn capitalize_effort(s: &str) -> String {
+    if s == "extra_high" {
+        return "Extra High".into();
+    }
+    let mut c = s.chars();
+    match c.next() {
+        None => String::new(),
+        Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
+    }
+}
+
+fn cmd_thinking(rest: &str, config: &mut MintConfig) -> SlashResponse {
+    let model = config.active_model().to_string();
+    let supported = config.is_thinking_supported();
+    let (current_enabled, current_effort) = config.resolved_thinking();
+    let raw = rest.trim().to_ascii_lowercase();
+
+    if raw.is_empty() {
+        let status_label = if !supported {
+            "Not supported by active model".to_string()
+        } else if current_enabled {
+            format!("ON (Effort: {})", capitalize_effort(current_effort))
+        } else {
+            "OFF".to_string()
+        };
+
+        let mut choices = Vec::new();
+        if current_enabled {
+            choices.push(SlashChoice {
+                label: "Turn Thinking OFF".into(),
+                value: "off".into(),
+            });
+        } else {
+            choices.push(SlashChoice {
+                label: "Turn Thinking ON".into(),
+                value: "on".into(),
+            });
+        }
+        for eff in &["Low", "Medium", "High", "Extra High"] {
+            let val = eff.to_ascii_lowercase().replace(' ', "_");
+            let is_sel = current_enabled && current_effort.to_ascii_lowercase() == val;
+            choices.push(SlashChoice {
+                label: if is_sel {
+                    format!("Effort: {eff} ✓")
+                } else {
+                    format!("Effort: {eff}")
+                },
+                value: val,
+            });
+        }
+
+        return SlashResponse::NeedsChoice {
+            command: "/thinking".into(),
+            title: format!("🧠 Thinking Configuration ({model}): {status_label}"),
+            options: choices,
+        };
+    }
+
+    if raw == "status" {
+        let status_label = if !supported {
+            "⚠️ Thinking is **not supported** by the current active model.".to_string()
+        } else if current_enabled {
+            format!(
+                "✅ Thinking is **ON** (Effort: **{}**)",
+                capitalize_effort(current_effort)
+            )
+        } else {
+            "⏸️ Thinking is **OFF**".to_string()
+        };
+        return message(format!(
+            "🧠 **Thinking Status**\n\n- Active Model: `{model}`\n- Supported: **{supported}**\n- State: {status_label}\n\nUsage: `/thinking [on|off|low|medium|high|extra_high]`"
+        ));
+    }
+
+    let parts: Vec<&str> = raw.split_whitespace().collect();
+    let mut new_enabled = current_enabled;
+    let mut new_effort = current_effort.to_string();
+
+    for p in parts {
+        match p {
+            "on" | "enable" | "true" => new_enabled = true,
+            "off" | "disable" | "false" => new_enabled = false,
+            "low" => {
+                new_effort = "low".into();
+                new_enabled = true;
+            }
+            "medium" | "med" => {
+                new_effort = "medium".into();
+                new_enabled = true;
+            }
+            "high" => {
+                new_effort = "high".into();
+                new_enabled = true;
+            }
+            "extra_high" | "extra" | "extra-high" | "max" => {
+                new_effort = "extra_high".into();
+                new_enabled = true;
+            }
+            _ => {}
+        }
+    }
+
+    config.set_model_thinking(&model, new_enabled, &new_effort);
+    config.thinking_enabled = new_enabled;
+    config.thinking_effort = new_effort.clone();
+
+    let text = if !supported {
+        format!(
+            "🧠 Updated thinking preference for `{model}` to **{}** (Effort: **{}**).\n*Note: `{model}` may not natively emit reasoning tokens.*",
+            if new_enabled { "ON" } else { "OFF" },
+            capitalize_effort(&new_effort)
+        )
+    } else if new_enabled {
+        format!(
+            "🧠 Thinking **ON** for `{model}` (Effort: **{}**).",
+            capitalize_effort(&new_effort)
+        )
+    } else {
+        format!("🧠 Thinking **OFF** for `{model}`.")
+    };
+
+    SlashResponse::Applied {
+        markdown: text,
+        effects: vec![
+            SlashEffect::ConfigChanged,
+            SlashEffect::ThinkingChanged {
+                enabled: new_enabled,
+                effort: new_effort,
+            },
+        ],
+    }
+}
+
 fn cmd_temperature(rest: &str, config: &mut MintConfig) -> SlashResponse {
     let raw = rest.trim();
     if raw.is_empty() {
@@ -1069,21 +1283,175 @@ async fn cmd_models_async(rest: &str, config: &mut MintConfig) -> SlashResponse
         None => (rest.trim(), None),
     };
 
-    // Provider given but no model yet — offer the model picker using live fetch first.
-    if model.is_none() {
-        let options = models::model_options_for_provider_async(config, provider).await;
-        if !options.is_empty() {
-            return SlashResponse::NeedsChoice {
-                command: format!("/models {provider}"),
-                title: format!("Select {provider} model"),
-                options: options
+    let is_action_all = model == Some("__action:all");
+    let is_action_free = model == Some("__action:free");
+    let search_query = model.and_then(|m| m.strip_prefix("__action:search:"));
+
+    // Provider given but no model yet, or an action requested — offer model picker.
+    if model.is_none() || is_action_all || is_action_free || search_query.is_some() {
+        let all_options = models::model_options_for_provider_async(config, provider).await;
+        if !all_options.is_empty() {
+            if let Some(query) = search_query {
+                let q_lower = query.trim().to_lowercase();
+                let matched: Vec<String> = all_options
                     .into_iter()
-                    .map(|m| SlashChoice {
-                        label: m.clone(),
-                        value: m,
-                    })
-                    .collect(),
-            };
+                    .filter(|m| m.to_lowercase().contains(&q_lower))
+                    .collect();
+                if matched.is_empty() {
+                    return message(format!(
+                        "No models found matching \"{query}\" for provider {provider}."
+                    ));
+                }
+                return SlashResponse::NeedsChoice {
+                    command: format!("/models {provider}"),
+                    title: format!(
+                        "Search results for \"{query}\" in {provider} ({})",
+                        matched.len()
+                    ),
+                    options: matched
+                        .into_iter()
+                        .map(|m| {
+                            let label = if models::is_free_model(&m) {
+                                format!("{m} [FREE]")
+                            } else {
+                                m.clone()
+                            };
+                            SlashChoice { label, value: m }
+                        })
+                        .collect(),
+                };
+            }
+
+            if is_action_free {
+                let free_models: Vec<String> = all_options
+                    .into_iter()
+                    .filter(|m| models::is_free_model(m))
+                    .collect();
+                if free_models.is_empty() {
+                    return message(format!("No free models found for provider {provider}."));
+                }
+                return SlashResponse::NeedsChoice {
+                    command: format!("/models {provider}"),
+                    title: format!("Free {provider} models ({})", free_models.len()),
+                    options: free_models
+                        .into_iter()
+                        .map(|m| SlashChoice {
+                            label: format!("{m} [FREE]"),
+                            value: m,
+                        })
+                        .collect(),
+                };
+            }
+
+            if is_action_all {
+                return SlashResponse::NeedsChoice {
+                    command: format!("/models {provider}"),
+                    title: format!("All {provider} models ({})", all_options.len()),
+                    options: all_options
+                        .into_iter()
+                        .map(|m| {
+                            let label = if models::is_free_model(&m) {
+                                format!("{m} [FREE]")
+                            } else {
+                                m.clone()
+                            };
+                            SlashChoice { label, value: m }
+                        })
+                        .collect(),
+                };
+            }
+
+            // Normal provider selection menu
+            let has_free = all_options.iter().any(|m| models::is_free_model(m));
+            let total_count = all_options.len();
+
+            let mut choices: Vec<SlashChoice> = Vec::new();
+
+            if total_count > 8 || provider == "openrouter" {
+                let popular_presets = models::popular_models_for_provider(provider);
+                let mut added_popular = 0;
+                for pop in popular_presets {
+                    if all_options.iter().any(|m| m == pop) {
+                        let label = if models::is_free_model(pop) {
+                            format!("{pop} [FREE]")
+                        } else {
+                            pop.to_string()
+                        };
+                        choices.push(SlashChoice {
+                            label,
+                            value: pop.to_string(),
+                        });
+                        added_popular += 1;
+                    }
+                }
+
+                if added_popular == 0 {
+                    for m in all_options.iter().take(6) {
+                        let label = if models::is_free_model(m) {
+                            format!("{m} [FREE]")
+                        } else {
+                            m.clone()
+                        };
+                        choices.push(SlashChoice {
+                            label,
+                            value: m.clone(),
+                        });
+                    }
+                }
+
+                choices.push(SlashChoice {
+                    label: "[Search] Filter models by keyword...".into(),
+                    value: "__action:search".into(),
+                });
+                if has_free {
+                    choices.push(SlashChoice {
+                        label: "[Free] Browse free models only (:free)".into(),
+                        value: "__action:free".into(),
+                    });
+                }
+                choices.push(SlashChoice {
+                    label: format!("[All] Browse all {total_count} models..."),
+                    value: "__action:all".into(),
+                });
+                choices.push(SlashChoice {
+                    label: "[Custom] Enter custom model ID...".into(),
+                    value: "__action:custom".into(),
+                });
+
+                return SlashResponse::NeedsChoice {
+                    command: format!("/models {provider}"),
+                    title: format!("Select {provider} model"),
+                    options: choices,
+                };
+            } else {
+                for m in &all_options {
+                    let label = if models::is_free_model(m) {
+                        format!("{m} [FREE]")
+                    } else {
+                        m.clone()
+                    };
+                    choices.push(SlashChoice {
+                        label,
+                        value: m.clone(),
+                    });
+                }
+                choices.push(SlashChoice {
+                    label: "[Custom] Enter custom model ID...".into(),
+                    value: "__action:custom".into(),
+                });
+
+                return SlashResponse::NeedsChoice {
+                    command: format!("/models {provider}"),
+                    title: format!("Select {provider} model"),
+                    options: choices,
+                };
+            }
+        }
+    }
+
+    if let Some(m) = model {
+        if m.starts_with("__action:") {
+            return SlashResponse::NotHandled;
         }
     }
 
@@ -1809,7 +2177,38 @@ fn cmd_link(rest: &str) -> SlashResponse {
             Ok(false) => error(format!("No linked folder named `{args}`.")),
             Err(e) => error(e),
         },
-        _ => error("Usage: /link [list] | add <name> | <path> | <desc> | remove <name>"),
+        "refresh" if !args.is_empty() => match crate::refresh_linked_folder(args) {
+            Ok(status) => message(format!(
+                "Indexed {} files in `{args}`.",
+                status.indexed_files
+            )),
+            Err(e) => error(e),
+        },
+        "notes" if !args.is_empty() => match crate::list_linked_folder_notes(args) {
+            Ok(notes) if notes.is_empty() => message(format!("No saved notes in `{args}`.")),
+            Ok(notes) => message(md_list(
+                &notes
+                    .iter()
+                    .map(|n| format!("`{}` — {} — {}", n.created_at, n.status, n.path))
+                    .collect::<Vec<_>>(),
+            )),
+            Err(e) => error(e),
+        },
+        "save" => {
+            let Some((name, content)) = args.split_once('|') else {
+                return error("Usage: /link save <name> | <text>");
+            };
+            match crate::save_linked_folder_note(name.trim(), content.trim()) {
+                Ok(note) if note.status == "saved" => {
+                    message(format!("Saved note to `{}`: `{}`", name.trim(), note.path))
+                }
+                Ok(note) => error(note.error.unwrap_or_else(|| "note was not saved".into())),
+                Err(e) => error(e),
+            }
+        }
+        _ => error(
+            "Usage: /link [list] | add <name> | <path> | <desc> | remove <name> | refresh <name> | notes <name> | save <name> | <text>",
+        ),
     }
 }
 
@@ -1901,6 +2300,7 @@ fn cmd_mcp(rest: &str, config: &mut MintConfig) -> SlashResponse {
                             url: Some(target.to_string()),
                             headers: None,
                             transport: Some("sse".to_string()),
+                            timeout_secs: None,
                         }
                     } else {
                         crate::McpServer {
@@ -1912,6 +2312,7 @@ fn cmd_mcp(rest: &str, config: &mut MintConfig) -> SlashResponse {
                             url: None,
                             headers: None,
                             transport: None,
+                            timeout_secs: None,
                         }
                     };
                     match crate::upsert_server_in(config, name, server) {
@@ -1961,9 +2362,21 @@ fn cmd_mcp(rest: &str, config: &mut MintConfig) -> SlashResponse {
         "edit" => {
             let mut parts = args.splitn(3, char::is_whitespace);
             let (Some(name), Some(field)) = (parts.next(), parts.next()) else {
-                return error("Usage: /mcp edit <name> command|args|icon <value>");
+                return error("Usage: /mcp edit <name> command|args|icon|timeout <value>");
             };
             let value = parts.next().unwrap_or("").trim();
+            if matches!(
+                field.to_ascii_lowercase().as_str(),
+                "timeout" | "timeoutsecs" | "timeout-secs"
+            ) {
+                return match crate::mcp::parse_mcp_timeout(value)
+                    .and_then(|seconds| crate::mcp::set_server_timeout_in(config, name, seconds))
+                {
+                    Ok(true) => applied(format!("🔌 Updated `{name}` tool timeout.")),
+                    Ok(false) => error(format!("No MCP server named `{name}`.")),
+                    Err(e) => error(e),
+                };
+            }
             let edit = match field.to_ascii_lowercase().as_str() {
                 "command" if !value.is_empty() => (Some(value.to_string()), None, None),
                 "command" => return error("`/mcp edit <name> command <value>` needs a value"),
@@ -1977,7 +2390,7 @@ fn cmd_mcp(rest: &str, config: &mut MintConfig) -> SlashResponse {
                     None,
                     Some((!value.is_empty()).then(|| value.to_string())),
                 ),
-                _ => return error("Editable fields: command | args | icon"),
+                _ => return error("Editable fields: command | args | icon | timeout"),
             };
             match crate::update_server_in(config, name, edit.0, edit.1, None, edit.2) {
                 Ok(true) => applied(format!("🔌 Updated `{name}`.")),
@@ -2093,6 +2506,7 @@ mod tests {
             input: input.to_string(),
             cwd: None,
             surface: None,
+            chat_id: None,
         }
     }
 
@@ -2101,6 +2515,43 @@ mod tests {
             input: input.to_string(),
             cwd: None,
             surface: Some(surface.to_string()),
+            chat_id: None,
+        }
+    }
+
+    #[test]
+    fn mint_web_command_is_registered_and_validates_usage_on_all_surfaces() {
+        for surface in ["cli", "desktop", "web"] {
+            assert!(catalog::SLASH_COMMANDS.iter().any(
+                |spec| spec.token == "/mint-web" && spec.surfaces.iter().any(|s| s == surface)
+            ));
+            match execute(
+                &req_surface("/mint-web unexpected", surface),
+                &mut MintConfig::default(),
+            ) {
+                SlashResponse::Message { markdown } => {
+                    assert!(markdown.contains("Usage: /mint-web"))
+                }
+                _ => panic!("Mint Web command was not routed on {surface}"),
+            }
+        }
+    }
+
+    #[test]
+    fn release_notes_are_available_on_every_surface() {
+        for surface in ["cli", "desktop", "web"] {
+            match execute(
+                &req_surface("/release-notes", surface),
+                &mut MintConfig::default(),
+            ) {
+                SlashResponse::Message { markdown } => {
+                    assert!(markdown.starts_with("# Release Notes - Mint Agent"));
+                }
+                other => panic!(
+                    "expected release notes on {surface}, got {}",
+                    serde_json::to_value(other).unwrap()
+                ),
+            }
         }
     }
 
@@ -2321,6 +2772,44 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn review_timeout_slash_validates_without_corrupting_config_on_every_surface() {
+        for surface in ["cli", "desktop", "web"] {
+            let mut cfg = MintConfig::default();
+            execute(&req_surface("/mcp add timer sh -c cat", surface), &mut cfg);
+            for (field, value) in [("timeout", 1), ("timeoutSecs", 300), ("timeout-secs", 3600)] {
+                let response = execute(
+                    &req_surface(&format!("/mcp edit timer {field} {value}"), surface),
+                    &mut cfg,
+                );
+                assert!(
+                    matches!(response, SlashResponse::Applied { .. }),
+                    "timeout edit was not applied on {surface}"
+                );
+                assert_eq!(cfg.extra["mcpServers"]["timer"]["timeoutSecs"], value);
+            }
+            let saved = cfg.extra.clone();
+            for invalid in ["0", "3601", "1.5", "banana", ""] {
+                assert!(matches!(
+                    execute(
+                        &req_surface(&format!("/mcp edit timer timeout {invalid}"), surface),
+                        &mut cfg
+                    ),
+                    SlashResponse::Message { .. }
+                ));
+                assert_eq!(cfg.extra, saved, "invalid input modified config");
+            }
+            assert!(matches!(
+                execute(
+                    &req_surface("/mcp edit ghost timeout 600", surface),
+                    &mut cfg
+                ),
+                SlashResponse::Message { .. }
+            ));
+            assert_eq!(cfg.extra, saved);
+        }
+    }
+
     #[test]
     fn mcp_registry_lists_the_catalog() {
         let mut cfg = MintConfig::default();
@@ -2407,6 +2896,16 @@ mod tests {
         }
     }
 
+    #[test]
+    fn mods_are_discoverable_in_help_on_every_surface() {
+        for surface in ["cli", "desktop", "web"] {
+            match execute(&req_surface("/help", surface), &mut MintConfig::default()) {
+                SlashResponse::Message { markdown } => assert!(markdown.contains("`/mods`")),
+                _ => panic!("expected help Message"),
+            }
+        }
+    }
+
     #[test]
     fn plan_toggles_and_forwards_task() {
         let mut cfg = MintConfig::default();
@@ -2562,4 +3061,116 @@ mod tests {
             other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
         }
     }
+
+    #[test]
+    fn thinking_slash_command_inspection_override_and_reset() {
+        let mut cfg = MintConfig::default();
+        cfg.ai_provider = "anthropic".into();
+        cfg.anthropic_model = "claude-3-7-sonnet".into();
+
+        // 1. Without args: interactive menu
+        match execute(&req("/thinking"), &mut cfg) {
+            SlashResponse::NeedsChoice { options, .. } => {
+                assert!(!options.is_empty());
+            }
+            other => panic!(
+                "expected NeedsChoice, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+
+        // 2. Set effort to High
+        match execute(&req("/thinking high"), &mut cfg) {
+            SlashResponse::Applied { effects, markdown } => {
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+                assert!(effects.contains(&SlashEffect::ThinkingChanged {
+                    enabled: true,
+                    effort: "high".into()
+                }));
+                assert!(markdown.contains("High"));
+                let (enabled, effort) = cfg.resolved_thinking();
+                assert!(enabled);
+                assert_eq!(effort, "high");
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 3. Turn thinking off
+        match execute(&req("/thinking off"), &mut cfg) {
+            SlashResponse::Applied { effects, .. } => {
+                assert!(effects.contains(&SlashEffect::ThinkingChanged {
+                    enabled: false,
+                    effort: "high".into()
+                }));
+                let (enabled, _) = cfg.resolved_thinking();
+                assert!(!enabled);
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 4. Status inspection
+        match execute(&req("/thinking status"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.to_ascii_uppercase().contains("OFF"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 5. Non-reasoning model accepts preference with advisory note
+        cfg.ai_provider = "openai".into();
+        cfg.openai_model = "gpt-4o".into();
+        match execute(&req("/thinking on"), &mut cfg) {
+            SlashResponse::Applied { markdown, .. } => {
+                assert!(markdown.contains("may not natively emit reasoning tokens"));
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+    }
+
+    #[tokio::test]
+    async fn models_slash_command_actions_and_options() {
+        let mut cfg = MintConfig::default();
+        // 1. /models openrouter offers popular models and action shortcuts
+        match execute_async(&req("/models openrouter"), &mut cfg).await {
+            SlashResponse::NeedsChoice {
+                command, options, ..
+            } => {
+                assert_eq!(command, "/models openrouter");
+                assert!(options.iter().any(|o| o.value == "__action:search"));
+                assert!(options.iter().any(|o| o.value == "__action:all"));
+                assert!(options.iter().any(|o| o.value == "__action:custom"));
+            }
+            other => panic!(
+                "expected NeedsChoice, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+
+        // 2. /models openrouter __action:all returns all models
+        match execute_async(&req("/models openrouter __action:all"), &mut cfg).await {
+            SlashResponse::NeedsChoice { title, options, .. } => {
+                assert!(title.contains("All openrouter models"));
+                assert!(!options.is_empty());
+            }
+            other => panic!(
+                "expected NeedsChoice, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+
+        // 3. /models openrouter __action:search:gpt filters models
+        match execute_async(&req("/models openrouter __action:search:gpt"), &mut cfg).await {
+            SlashResponse::NeedsChoice { options, .. } => {
+                assert!(
+                    options
+                        .iter()
+                        .all(|o| o.value.to_lowercase().contains("gpt"))
+                );
+            }
+            other => panic!(
+                "expected NeedsChoice, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+    }
 }