@pheem49/mint 1.15.0 → 1.17.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 {
@@ -193,20 +197,37 @@ 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],
@@ -219,7 +240,7 @@ pub fn execute(req: &SlashRequest, config: &mut MintConfig) -> SlashResponse {
         "/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,
@@ -270,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]"),
@@ -290,6 +315,8 @@ 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),
+        "/steps" | "/max-steps" => cmd_steps(rest, config),
+        "/browser" => cmd_browser(rest, config),
         // `/searchProvider` is a documented camelCase alias (see UNDOCUMENTED_ALIASES).
         "/search-provider" | "/searchprovider" => cmd_extra_provider(
             "/search-provider",
@@ -560,7 +587,15 @@ fn cmd_bool_toggle(
     config: &mut MintConfig,
 ) -> SlashResponse {
     match parse_on_off(rest) {
-        None if rest.is_empty() => needs_on_off(command, label),
+        None if rest.is_empty() => {
+            let mut response = needs_on_off(command, label);
+            if command == "/autoskill"
+                && let SlashResponse::NeedsChoice { options, .. } = &mut response
+            {
+                options[usize::from(!current)].label.push_str(" (current)");
+            }
+            response
+        }
         None => error(format!("Usage: {command} [on|off]")),
         Some(v) => {
             set(config, v);
@@ -576,6 +611,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();
@@ -1173,6 +1246,299 @@ fn cmd_temperature(rest: &str, config: &mut MintConfig) -> SlashResponse {
     }
 }
 
+fn cmd_steps(rest: &str, config: &mut MintConfig) -> SlashResponse {
+    let raw = rest.trim();
+    let current_steps = config.resolved_agent_max_steps();
+    if raw.is_empty() {
+        return SlashResponse::NeedsChoice {
+            command: "/steps".into(),
+            title: format!(
+                "⏱️ Agent Step Limit: {} steps per turn\nSelect a preset or run `/steps <10-200>`",
+                current_steps
+            ),
+            options: vec![
+                SlashChoice {
+                    label: format!(
+                        "25 steps — Fast & frugal{}",
+                        if current_steps == 25 {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "25".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "40 steps — Default standard{}",
+                        if current_steps == 40 {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "40".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "60 steps — Extended workflows{}",
+                        if current_steps == 60 {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "60".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "80 steps — Heavy deep coding{}",
+                        if current_steps == 80 {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "80".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "100 steps — Long-running autonomous{}",
+                        if current_steps == 100 {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "100".into(),
+                },
+                SlashChoice {
+                    label: "Reset to default (40 steps)".into(),
+                    value: "reset".into(),
+                },
+            ],
+        };
+    }
+
+    if raw.eq_ignore_ascii_case("status") {
+        return message(format!(
+            "⏱️ **Agent Step Budget Status**\n\n\
+             - **Current Limit**: `{}` steps per turn\n\
+             - **Step Warning**: Injected into prompt & observations at step `{}`\n\
+             - **Wrap-up Synthesis**: Enforced on final step `{}` (synthesizes findings without tools)\n\
+             - **Allowed Range**: 10 – 200 steps\n\
+             - **Default**: {} steps\n\n\
+             To adjust: `/steps <number>` or `/steps reset`",
+            current_steps,
+            current_steps.saturating_sub(5),
+            current_steps,
+            crate::system::config::DEFAULT_AGENT_MAX_STEPS
+        ));
+    }
+
+    if raw.eq_ignore_ascii_case("reset") || raw.eq_ignore_ascii_case("default") {
+        config.agent_max_steps = crate::system::config::DEFAULT_AGENT_MAX_STEPS;
+        return SlashResponse::Applied {
+            markdown: format!(
+                "🔄 Agent step limit reset to default (**{}** steps per turn).",
+                crate::system::config::DEFAULT_AGENT_MAX_STEPS
+            ),
+            effects: vec![SlashEffect::ConfigChanged],
+        };
+    }
+
+    match raw.parse::<usize>() {
+        Ok(val) => {
+            if !(10..=200).contains(&val) {
+                return error(format!(
+                    "Step limit must be between 10 and 200 steps (received `{val}`)."
+                ));
+            }
+            config.agent_max_steps = val;
+            SlashResponse::Applied {
+                markdown: format!(
+                    "⏱️ Agent step limit set to **{}** steps per turn (Warning at step {}, Wrap-up at step {}).",
+                    val,
+                    val.saturating_sub(5),
+                    val
+                ),
+                effects: vec![SlashEffect::ConfigChanged],
+            }
+        }
+        Err(_) => error(format!(
+            "Invalid step limit `{raw}`. Please specify a number between 10 and 200, or `reset`."
+        )),
+    }
+}
+
+fn cmd_browser(rest: &str, config: &mut MintConfig) -> SlashResponse {
+    let raw = rest.trim();
+    let current_enabled = config
+        .extra
+        .get("browserAutomationEnabled")
+        .and_then(serde_json::Value::as_bool)
+        != Some(false);
+    let current_mode = config
+        .extra
+        .get("browserAgentMode")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("headless");
+    let custom_exe = config
+        .extra
+        .get("browserExecutable")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("");
+    let exe_display = if !custom_exe.trim().is_empty() {
+        custom_exe.trim()
+    } else {
+        "Auto-detect (Chrome / Chromium / Edge)"
+    };
+    let width = config
+        .extra
+        .get("browserViewportWidth")
+        .and_then(serde_json::Value::as_u64)
+        .unwrap_or(1440);
+    let height = config
+        .extra
+        .get("browserViewportHeight")
+        .and_then(serde_json::Value::as_u64)
+        .unwrap_or(900);
+    let debug_url = config
+        .extra
+        .get("browserDebugUrl")
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("http://127.0.0.1:9222/json/list");
+
+    if raw.is_empty() {
+        return SlashResponse::NeedsChoice {
+            command: "/browser".into(),
+            title: format!(
+                "🌐 Browser Automation Configuration\n• Tools: {}\n• Mode: {}\nSelect an option to configure or run `/browser [on|off|headless|headed|status]`",
+                if current_enabled {
+                    "Enabled (on)"
+                } else {
+                    "Disabled (off)"
+                },
+                if current_mode == "headless" {
+                    "headless Browser"
+                } else {
+                    "headed Automation"
+                }
+            ),
+            options: vec![
+                SlashChoice {
+                    label: format!(
+                        "on — Enable browser automation tools{}",
+                        if current_enabled { " (current)" } else { "" }
+                    ),
+                    value: "on".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "off — Disable browser automation tools{}",
+                        if !current_enabled { " (current)" } else { "" }
+                    ),
+                    value: "off".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "headless Browser — Run silently in background without window{}",
+                        if current_mode == "headless" {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "headless".into(),
+                },
+                SlashChoice {
+                    label: format!(
+                        "headed Automation — Show browser window on screen{}",
+                        if current_mode == "headed" {
+                            " (current)"
+                        } else {
+                            ""
+                        }
+                    ),
+                    value: "headed".into(),
+                },
+                SlashChoice {
+                    label: "status — View current configuration & detected Chrome".into(),
+                    value: "status".into(),
+                },
+            ],
+        };
+    }
+
+    let normalized = raw.to_ascii_lowercase();
+    match normalized.as_str() {
+        "status" => SlashResponse::Message {
+            markdown: format!(
+                "### 🌐 Browser Automation Status\n\n\
+                 - **Tools Enabled**: {}\n\
+                 - **Browser Mode**: {}\n\
+                 - **Viewport Size**: `{}` × `{}`\n\
+                 - **Executable**: `{}`\n\
+                 - **Debugging Endpoint**: `{}`\n\n\
+                 *Use `/browser on` or `/browser off` to toggle tools, and `/browser headless` or `/browser headed` to change display mode.*",
+                if current_enabled {
+                    "🟢 **Enabled** (`on`)"
+                } else {
+                    "🔴 **Disabled** (`off`)"
+                },
+                if current_mode == "headless" {
+                    "🕶️ `headless Browser` (runs in background)"
+                } else {
+                    "🖥️ `headed Automation` (shows window)"
+                },
+                width,
+                height,
+                exe_display,
+                debug_url
+            ),
+        },
+        "on" | "enable" => {
+            config
+                .extra
+                .insert("browserAutomationEnabled".into(), serde_json::json!(true));
+            SlashResponse::Applied {
+                markdown: "🟢 **Browser automation tools enabled (`on`)**.\nAgent can inspect web pages and capture screenshots using Headless Chromium.".into(),
+                effects: vec![SlashEffect::ConfigChanged],
+            }
+        }
+        "off" | "disable" => {
+            config
+                .extra
+                .insert("browserAutomationEnabled".into(), serde_json::json!(false));
+            SlashResponse::Applied {
+                markdown: "🔴 **Browser automation tools disabled (`off`)**.".into(),
+                effects: vec![SlashEffect::ConfigChanged],
+            }
+        }
+        "headless" | "headless browser" => {
+            config
+                .extra
+                .insert("browserAgentMode".into(), serde_json::json!("headless"));
+            SlashResponse::Applied {
+                markdown: "🕶️ **Browser mode set to `headless Browser`**.\nAutomation will run silently in the background without opening a window.".into(),
+                effects: vec![SlashEffect::ConfigChanged],
+            }
+        }
+        "headed" | "headed automation" => {
+            config
+                .extra
+                .insert("browserAgentMode".into(), serde_json::json!("headed"));
+            SlashResponse::Applied {
+                markdown: "🖥️ **Browser mode set to `headed Automation`**.\nAutomation will display the browser window on screen in real time.".into(),
+                effects: vec![SlashEffect::ConfigChanged],
+            }
+        }
+        _ => SlashResponse::Message {
+            markdown: "Usage: `/browser [on|off|headless|headed|status]`".into(),
+        },
+    }
+}
+
 async fn cmd_temperature_async(rest: &str, config: &mut MintConfig) -> SlashResponse {
     let tokens: Vec<&str> = rest.split_whitespace().collect();
     if tokens.len() == 1 {
@@ -2237,6 +2603,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 {
@@ -2248,6 +2615,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) {
@@ -2297,9 +2665,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"),
@@ -2313,7 +2693,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}`.")),
@@ -2429,6 +2809,7 @@ mod tests {
             input: input.to_string(),
             cwd: None,
             surface: None,
+            chat_id: None,
         }
     }
 
@@ -2437,6 +2818,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()
+                ),
+            }
         }
     }
 
@@ -2657,6 +3075,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();
@@ -2743,6 +3199,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();
@@ -3010,4 +3476,164 @@ mod tests {
             ),
         }
     }
+
+    #[test]
+    fn steps_slash_command_behavior() {
+        let mut cfg = MintConfig::default();
+        assert_eq!(cfg.resolved_agent_max_steps(), 40);
+
+        // 1. Bare /steps returns NeedsChoice with presets
+        match execute(&req("/steps"), &mut cfg) {
+            SlashResponse::NeedsChoice {
+                command, options, ..
+            } => {
+                assert_eq!(command, "/steps");
+                assert!(options.iter().any(|o| o.value == "25"));
+                assert!(
+                    options
+                        .iter()
+                        .any(|o| o.value == "40" && o.label.contains("(current)"))
+                );
+                assert!(options.iter().any(|o| o.value == "60"));
+                assert!(options.iter().any(|o| o.value == "reset"));
+            }
+            other => panic!(
+                "expected NeedsChoice, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+
+        // 2. /steps status returns informative message
+        match execute(&req("/steps status"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("Agent Step Budget Status"));
+                assert!(markdown.contains("40"));
+                assert!(markdown.contains("35"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 3. /steps 60 sets agent_max_steps to 60 with ConfigChanged effect
+        match execute(&req("/steps 60"), &mut cfg) {
+            SlashResponse::Applied { markdown, effects } => {
+                assert!(markdown.contains("60"));
+                assert_eq!(cfg.agent_max_steps, 60);
+                assert_eq!(cfg.resolved_agent_max_steps(), 60);
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 4. Out-of-bounds rejected
+        match execute(&req("/steps 5"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("between 10 and 200"));
+            }
+            other => panic!(
+                "expected Error Message, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+
+        match execute(&req("/steps 250"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("between 10 and 200"));
+            }
+            other => panic!(
+                "expected Error Message, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+
+        // 5. /steps reset reverts back to default 40
+        match execute(&req("/steps reset"), &mut cfg) {
+            SlashResponse::Applied { markdown, effects } => {
+                assert!(markdown.contains("40"));
+                assert_eq!(cfg.agent_max_steps, 40);
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+    }
+
+    #[test]
+    fn browser_slash_command_behavior() {
+        let mut cfg = MintConfig::default();
+
+        // 1. Bare /browser returns NeedsChoice with options
+        match execute(&req("/browser"), &mut cfg) {
+            SlashResponse::NeedsChoice {
+                command, options, ..
+            } => {
+                assert_eq!(command, "/browser");
+                assert!(options.iter().any(|o| o.value == "on"));
+                assert!(options.iter().any(|o| o.value == "off"));
+                assert!(options.iter().any(|o| o.value == "headless"));
+                assert!(options.iter().any(|o| o.value == "headed"));
+                assert!(options.iter().any(|o| o.value == "status"));
+            }
+            other => panic!(
+                "expected NeedsChoice, got {:?}",
+                serde_json::to_value(other)
+            ),
+        }
+
+        // 2. /browser status returns informative message
+        match execute(&req("/browser status"), &mut cfg) {
+            SlashResponse::Message { markdown } => {
+                assert!(markdown.contains("Browser Automation Status"));
+                assert!(markdown.contains("Enabled"));
+                assert!(markdown.contains("headless Browser"));
+            }
+            other => panic!("expected Message, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 3. /browser off disables tools
+        match execute(&req("/browser off"), &mut cfg) {
+            SlashResponse::Applied { effects, .. } => {
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+                assert_eq!(
+                    cfg.extra.get("browserAutomationEnabled"),
+                    Some(&serde_json::json!(false))
+                );
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 4. /browser on re-enables tools
+        match execute(&req("/browser on"), &mut cfg) {
+            SlashResponse::Applied { effects, .. } => {
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+                assert_eq!(
+                    cfg.extra.get("browserAutomationEnabled"),
+                    Some(&serde_json::json!(true))
+                );
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 5. /browser headed switches mode
+        match execute(&req("/browser headed"), &mut cfg) {
+            SlashResponse::Applied { effects, .. } => {
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+                assert_eq!(
+                    cfg.extra.get("browserAgentMode"),
+                    Some(&serde_json::json!("headed"))
+                );
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+
+        // 6. /browser headless switches mode back
+        match execute(&req("/browser headless"), &mut cfg) {
+            SlashResponse::Applied { effects, .. } => {
+                assert!(effects.contains(&SlashEffect::ConfigChanged));
+                assert_eq!(
+                    cfg.extra.get("browserAgentMode"),
+                    Some(&serde_json::json!("headless"))
+                );
+            }
+            other => panic!("expected Applied, got {:?}", serde_json::to_value(other)),
+        }
+    }
 }