@pheem49/mint 1.15.0 → 1.16.0

package/crates/mint-core/src/search/knowledge.rs

@@ -225,6 +225,12 @@ impl KnowledgeStore {
 
 pub fn extract_document_text(path: &Path, config: &MintConfig) -> Result<String, KnowledgeError> {
     let path = assert_path_capability(path, Capability::Read, config)?;
+    extract_managed_document_text(&path)
+}
+
+// Only Library may bypass workspace policy after validating a managed original.
+pub(crate) fn extract_managed_document_text(path: &Path) -> Result<String, KnowledgeError> {
+    let path = path.to_path_buf();
     let metadata = fs::metadata(&path).map_err(|source| KnowledgeError::Read {
         path: path.clone(),
         source,
@@ -245,7 +251,7 @@ pub fn extract_document_text(path: &Path, config: &MintConfig) -> Result<String,
     Ok(content)
 }
 
-fn supported(path: &Path) -> bool {
+pub(crate) fn supported(path: &Path) -> bool {
     path.extension()
         .and_then(|extension| extension.to_str())
         .is_some_and(|extension| {

package/crates/mint-core/src/search/linked_folders/index.rs

@@ -7,7 +7,7 @@ use std::time::UNIX_EPOCH;
 
 use chrono::Local;
 use ignore::WalkBuilder;
-use rusqlite::{Connection, OptionalExtension, params};
+use rusqlite::{Connection, OptionalExtension, TransactionBehavior, params};
 use uuid::Uuid;
 
 use super::{LinkedFolder, LinkedFolderNote, LinkedFolderStatus};
@@ -21,13 +21,37 @@ const CHUNK_CHARS: usize = 1000;
 const CHUNK_OVERLAP: usize = 200;
 
 fn db() -> Result<Connection, String> {
-    let path = memory_path().map_err(|e| e.to_string())?;
+    open_db().map_err(|error| error.to_string())
+}
+
+pub(super) type ClaimedJob = (String, String, String, i64);
+
+#[derive(Debug, thiserror::Error)]
+pub(super) enum ClaimError {
+    #[error(transparent)]
+    Database(#[from] rusqlite::Error),
+    #[error("{0}")]
+    Setup(String),
+}
+
+impl ClaimError {
+    pub(super) fn is_busy(&self) -> bool {
+        matches!(self, Self::Database(rusqlite::Error::SqliteFailure(error, _))
+            if matches!(error.code, rusqlite::ErrorCode::DatabaseBusy | rusqlite::ErrorCode::DatabaseLocked))
+    }
+}
+
+fn open_db() -> Result<Connection, ClaimError> {
+    let path = memory_path().map_err(|e| ClaimError::Setup(e.to_string()))?;
+    open_db_at(&path)
+}
+
+fn open_db_at(path: &Path) -> Result<Connection, ClaimError> {
     if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+        fs::create_dir_all(parent).map_err(|e| ClaimError::Setup(e.to_string()))?;
     }
-    let conn = Connection::open(path).map_err(|e| e.to_string())?;
-    conn.busy_timeout(std::time::Duration::from_secs(5))
-        .map_err(|e| e.to_string())?;
+    let conn = Connection::open(path)?;
+    conn.busy_timeout(std::time::Duration::from_secs(5))?;
     conn.execute_batch(
         "CREATE TABLE IF NOT EXISTS linked_folder_files (
            folder TEXT NOT NULL, root TEXT NOT NULL, path TEXT NOT NULL,
@@ -50,7 +74,7 @@ fn db() -> Result<Connection, String> {
            id TEXT PRIMARY KEY, user_text TEXT NOT NULL, ai_text TEXT NOT NULL,
            status TEXT NOT NULL, attempts INTEGER NOT NULL DEFAULT 0,
            error TEXT, created_at TEXT NOT NULL, claimed_at INTEGER);"
-    ).map_err(|e| e.to_string())?;
+    )?;
     Ok(conn)
 }
 
@@ -654,15 +678,20 @@ pub(super) fn queue_job(id: &str, user_text: &str, ai_text: &str) -> Result<(),
     Ok(())
 }
 
-pub(super) fn claim_job() -> Result<Option<(String, String, String, i64)>, String> {
-    let mut conn = db()?;
-    let tx = conn.transaction().map_err(|e| e.to_string())?;
+pub(super) fn claim_job() -> Result<Option<ClaimedJob>, ClaimError> {
+    claim_job_on(&mut open_db()?)
+}
+
+fn claim_job_on(conn: &mut Connection) -> Result<Option<ClaimedJob>, ClaimError> {
+    // Acquire the writer slot before reading: a deferred transaction can read
+    // an outdated WAL snapshot and fail immediately when upgrading to a writer.
+    let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
     let job = tx.query_row("SELECT id,user_text,ai_text,attempts FROM linked_folder_jobs WHERE (status='pending' AND (claimed_at IS NULL OR claimed_at <= unixepoch())) OR (status='running' AND claimed_at < unixepoch()-600) ORDER BY created_at LIMIT 1", [],
-        |r| Ok((r.get::<_,String>(0)?,r.get::<_,String>(1)?,r.get::<_,String>(2)?,r.get::<_,i64>(3)?))).optional().map_err(|e| e.to_string())?;
+        |r| Ok((r.get::<_,String>(0)?,r.get::<_,String>(1)?,r.get::<_,String>(2)?,r.get::<_,i64>(3)?))).optional()?;
     if let Some((ref id, _, _, _)) = job {
-        tx.execute("UPDATE linked_folder_jobs SET status='running',attempts=attempts+1,claimed_at=unixepoch() WHERE id=?1",[id]).map_err(|e| e.to_string())?;
+        tx.execute("UPDATE linked_folder_jobs SET status='running',attempts=attempts+1,claimed_at=unixepoch() WHERE id=?1",[id])?;
     }
-    tx.commit().map_err(|e| e.to_string())?;
+    tx.commit()?;
     Ok(job)
 }
 
@@ -686,6 +715,141 @@ pub(super) fn retry_job(id: &str, error: &str, delay_seconds: i64) -> Result<(),
 mod tests {
     use super::*;
 
+    fn claim_test_db() -> (std::path::PathBuf, Connection) {
+        let dir = std::env::temp_dir().join(format!("mint-linked-claim-{}", Uuid::new_v4()));
+        let path = dir.join("jobs.sqlite");
+        let conn = open_db_at(&path).unwrap();
+        conn.execute_batch("PRAGMA journal_mode=WAL;").unwrap();
+        (path, conn)
+    }
+
+    fn insert_test_job(conn: &Connection, id: &str) {
+        conn.execute("INSERT INTO linked_folder_jobs(id,user_text,ai_text,status,created_at) VALUES(?1,'user','ai','pending','2026-10-02')", [id]).unwrap();
+    }
+
+    #[test]
+    fn concurrent_claims_take_each_job_once() {
+        let (path, conn) = claim_test_db();
+        for i in 0..8 {
+            insert_test_job(&conn, &format!("job-{i}"));
+        }
+        let barrier = std::sync::Arc::new(std::sync::Barrier::new(8));
+        let mut workers = Vec::new();
+        for _ in 0..8 {
+            let mut worker_conn = open_db_at(&path).unwrap();
+            let barrier = barrier.clone();
+            workers.push(std::thread::spawn(move || {
+                barrier.wait();
+                claim_job_on(&mut worker_conn).unwrap().unwrap()
+            }));
+        }
+        let jobs: Vec<_> = workers
+            .into_iter()
+            .map(|worker| worker.join().unwrap())
+            .collect();
+        assert_eq!(
+            jobs.iter().map(|job| &job.0).collect::<HashSet<_>>().len(),
+            8
+        );
+        assert!(jobs.iter().all(|job| job.3 == 0));
+        let running: i64 = conn
+            .query_row(
+                "SELECT count(*) FROM linked_folder_jobs WHERE status='running' AND attempts=1",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(running, 8);
+        drop(conn);
+        fs::remove_dir_all(path.parent().unwrap()).unwrap();
+    }
+
+    #[test]
+    fn claim_waits_for_writer_and_failed_lock_does_not_consume_job_attempt() {
+        let (path, mut writer) = claim_test_db();
+        insert_test_job(&writer, "job");
+        let mut claimant = open_db_at(&path).unwrap();
+        claimant.busy_timeout(std::time::Duration::ZERO).unwrap();
+        let tx = writer
+            .transaction_with_behavior(TransactionBehavior::Immediate)
+            .unwrap();
+        let error = claim_job_on(&mut claimant).unwrap_err();
+        assert!(error.is_busy());
+        let attempts: i64 = tx
+            .query_row(
+                "SELECT attempts FROM linked_folder_jobs WHERE id='job'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(attempts, 0);
+        claimant
+            .busy_timeout(std::time::Duration::from_secs(5))
+            .unwrap();
+        let (started_tx, started_rx) = std::sync::mpsc::channel();
+        let (result_tx, result_rx) = std::sync::mpsc::channel();
+        let worker = std::thread::spawn(move || {
+            started_tx.send(()).unwrap();
+            result_tx.send(claim_job_on(&mut claimant)).unwrap();
+        });
+        started_rx.recv().unwrap();
+        assert!(matches!(
+            result_rx.recv_timeout(std::time::Duration::from_millis(50)),
+            Err(std::sync::mpsc::RecvTimeoutError::Timeout)
+        ));
+        tx.commit().unwrap();
+        let job = result_rx
+            .recv_timeout(std::time::Duration::from_secs(5))
+            .unwrap()
+            .unwrap()
+            .unwrap();
+        assert_eq!(job.0, "job");
+        assert_eq!(job.3, 0);
+        worker.join().unwrap();
+        assert!(claim_job_on(&mut writer).unwrap().is_none());
+        drop(writer);
+        fs::remove_dir_all(path.parent().unwrap()).unwrap();
+    }
+
+    #[tokio::test]
+    async fn claim_retry_recovers_after_real_database_lock_is_released() {
+        let (path, mut writer) = claim_test_db();
+        insert_test_job(&writer, "job");
+        let mut claimant = open_db_at(&path).unwrap();
+        claimant.busy_timeout(std::time::Duration::ZERO).unwrap();
+        let mut lock = Some(
+            writer
+                .transaction_with_behavior(TransactionBehavior::Immediate)
+                .unwrap(),
+        );
+        let mut calls = 0;
+        let job = super::super::claim_job_with_retry(|| {
+            calls += 1;
+            if calls == 2 {
+                lock.take().unwrap().commit().unwrap();
+            }
+            std::future::ready(claim_job_on(&mut claimant))
+        })
+        .await
+        .unwrap()
+        .unwrap();
+        assert_eq!(calls, 2);
+        assert_eq!(job.0, "job");
+        assert_eq!(job.3, 0);
+        let attempts: i64 = claimant
+            .query_row(
+                "SELECT attempts FROM linked_folder_jobs WHERE id='job'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(attempts, 1);
+        drop(lock);
+        drop(claimant);
+        drop(writer);
+        fs::remove_dir_all(path.parent().unwrap()).unwrap();
+    }
+
     #[test]
     fn concurrent_appends_keep_each_note_once() {
         let dir = std::env::temp_dir().join(format!("mint-linked-write-{}", Uuid::new_v4()));

package/crates/mint-core/src/search/linked_folders.rs

@@ -447,7 +447,7 @@ fn parse_model_notes(
 /// Fire-and-forget: after a chat turn, ask the model (in a second, separate
 /// call) whether it touched on a linked folder's topic closely enough to be
 /// worth a note, and if so append one to `<folder>/mint-notes/<date>.md`.
-/// Mirrors [`crate::orchestration::spawn_auto_skill_write`] — never blocks or
+/// Like background memory extraction, this never blocks or
 /// fails the turn that triggered it.
 pub fn spawn_linked_folder_note(
     config: MintConfig,
@@ -465,13 +465,41 @@ pub fn spawn_linked_folder_note(
     resume_linked_folder_jobs(config);
 }
 
+const CLAIM_LOCK_RETRIES: usize = 3;
+
+async fn claim_job_with_retry<Claim, Fut>(
+    mut claim: Claim,
+) -> Result<Option<index::ClaimedJob>, index::ClaimError>
+where
+    Claim: FnMut() -> Fut,
+    Fut: std::future::Future<Output = Result<Option<index::ClaimedJob>, index::ClaimError>>,
+{
+    for retry in 0..=CLAIM_LOCK_RETRIES {
+        match claim().await {
+            Err(error) if error.is_busy() && retry < CLAIM_LOCK_RETRIES => {
+                tokio::time::sleep(std::time::Duration::from_millis(100 << retry)).await;
+            }
+            result => return result,
+        }
+    }
+    unreachable!("last attempt always returns")
+}
+
 fn resume_linked_folder_jobs(config: MintConfig) {
     let Ok(runtime) = tokio::runtime::Handle::try_current() else {
         return;
     };
     runtime.spawn(async move {
         loop {
-            let job = match index::claim_job() {
+            let job = match claim_job_with_retry(|| async {
+                // SQLite may wait up to five seconds for a writer. Keep that
+                // blocking wait off the async runtime's worker threads.
+                tokio::task::spawn_blocking(index::claim_job)
+                    .await
+                    .map_err(|error| index::ClaimError::Setup(error.to_string()))?
+            })
+            .await
+            {
                 Ok(Some(job)) => job,
                 Ok(None) => break,
                 Err(error) => {
@@ -675,6 +703,59 @@ Use an empty notes array when nothing is worth saving."#
 mod tests {
     use super::*;
 
+    fn database_error(code: i32) -> index::ClaimError {
+        rusqlite::Error::SqliteFailure(rusqlite::ffi::Error::new(code), None).into()
+    }
+
+    #[tokio::test]
+    async fn claim_retries_busy_errors_then_returns_recovered_job() {
+        let mut calls = 0;
+        let job = claim_job_with_retry(|| {
+            calls += 1;
+            std::future::ready(if calls <= 2 {
+                Err(database_error(rusqlite::ffi::SQLITE_BUSY))
+            } else {
+                Ok(Some(("job".into(), "user".into(), "ai".into(), 0)))
+            })
+        })
+        .await
+        .unwrap()
+        .unwrap();
+        assert_eq!(calls, 3);
+        assert_eq!(job.0, "job");
+        assert_eq!(job.3, 0);
+    }
+
+    #[tokio::test]
+    async fn claim_stops_retrying_after_budget_and_does_not_retry_other_errors() {
+        for code in [rusqlite::ffi::SQLITE_BUSY, rusqlite::ffi::SQLITE_LOCKED] {
+            let mut calls = 0;
+            let error = claim_job_with_retry(|| {
+                calls += 1;
+                std::future::ready(Err(database_error(code)))
+            })
+            .await
+            .unwrap_err();
+            assert!(error.is_busy());
+            assert_eq!(calls, CLAIM_LOCK_RETRIES + 1);
+        }
+        let mut calls = 0;
+        let error = claim_job_with_retry(|| {
+            calls += 1;
+            std::future::ready(Err(database_error(rusqlite::ffi::SQLITE_CORRUPT)))
+        })
+        .await
+        .unwrap_err();
+        assert!(!error.is_busy());
+        assert_eq!(calls, 1);
+        assert!(
+            claim_job_with_retry(|| std::future::ready(Ok(None)))
+                .await
+                .unwrap()
+                .is_none()
+        );
+    }
+
     #[test]
     fn model_response_can_save_distinct_notes_in_multiple_candidate_folders() {
         let candidates = ["Food".to_string(), "Travel".to_string()].into();

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

@@ -4,7 +4,7 @@
 //! surface: the Rust CLI (`crates/mint-cli/src/interactive/`), this engine, and
 //! the Web/Desktop renderer (`src/renderer/shared/constants/slashCommands.ts`,
 //! which imports the same JSON). Each entry's `surfaces` array says which UIs
-//! list it — CLI-only commands (`/bg`, `/jobs`, `/shells`, `/exit`, `/plan`, and
+//! list it — CLI-only commands (`/bg`, `/jobs`, `/exit`, `/plan`, and
 //! the `Ctrl+V` / `↑ / ↓` help rows) carry just `["cli"]`.
 
 #[derive(serde::Deserialize)]

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]"),
@@ -576,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();
@@ -2237,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 {
@@ -2248,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) {
@@ -2297,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"),
@@ -2313,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}`.")),
@@ -2429,6 +2506,7 @@ mod tests {
             input: input.to_string(),
             cwd: None,
             surface: None,
+            chat_id: None,
         }
     }
 
@@ -2437,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()
+                ),
+            }
         }
     }
 
@@ -2657,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();
@@ -2743,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();