@pheem49/mint 1.14.0 → 1.16.0

package/crates/mint-core/src/api_server/routes/sessions.rs

@@ -15,6 +15,50 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
         auth_label: _auth_label,
     } = ctx;
     match (method, route) {
+        ("GET", "/api/conversation-snapshot") => {
+            let chat_id =
+                query_param(query, "chatId").unwrap_or_else(|| DEFAULT_CONVERSATION_ID.to_owned());
+            let before_id = query_param(query, "beforeId").and_then(|s| s.parse::<i64>().ok());
+            let limit = query_param(query, "limit")
+                .and_then(|s| s.parse::<usize>().ok())
+                .unwrap_or(50);
+            match MemoryStore::open_default()
+                .and_then(|m| m.conversation_snapshot(&chat_id, before_id, limit))
+            {
+                Ok(snapshot) => {
+                    send_json_response(
+                        socket,
+                        "200 OK",
+                        &serde_json::to_string(&snapshot).unwrap_or_default(),
+                    )
+                    .await
+                }
+                Err(_) => send_json_response(socket, "500 Internal Server Error", "{}").await,
+            }
+        }
+        ("GET", "/api/conversation-changes") => {
+            let chat_id =
+                query_param(query, "chatId").unwrap_or_else(|| DEFAULT_CONVERSATION_ID.to_owned());
+            let after = query_param(query, "after")
+                .and_then(|s| s.parse::<i64>().ok())
+                .unwrap_or(0);
+            let limit = query_param(query, "limit")
+                .and_then(|s| s.parse::<usize>().ok())
+                .unwrap_or(100);
+            match MemoryStore::open_default()
+                .and_then(|m| m.conversation_changes(&chat_id, after, limit))
+            {
+                Ok(changes) => {
+                    send_json_response(
+                        socket,
+                        "200 OK",
+                        &serde_json::to_string(&changes).unwrap_or_default(),
+                    )
+                    .await
+                }
+                Err(_) => send_json_response(socket, "500 Internal Server Error", "{}").await,
+            }
+        }
         ("GET", "/api/interactions") => {
             let limit = query_param(query, "limit")
                 .and_then(|value| value.parse::<usize>().ok())
@@ -48,8 +92,49 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
             send_json_response(socket, "500 Internal Server Error", "[]").await;
         }
 
+        ("POST", "/api/chat-sessions/workspace") => {
+            let value = serde_json::from_str::<Value>(body).unwrap_or(Value::Null);
+            let chat_id = value
+                .get("chatId")
+                .and_then(Value::as_str)
+                .map(str::trim)
+                .filter(|id| !id.is_empty());
+            let workspace = match value.get("workspacePath") {
+                Some(Value::Null) => Some(None),
+                Some(Value::String(path)) => Some(if path.trim().is_empty() {
+                    None
+                } else {
+                    Some(path.trim())
+                }),
+                _ => None,
+            };
+            let (Some(chat_id), Some(workspace)) = (chat_id, workspace) else {
+                send_json_response(
+                    socket,
+                    "400 Bad Request",
+                    "{\"error\":\"chatId and a string or null workspacePath are required\"}",
+                )
+                .await;
+                return;
+            };
+            match MemoryStore::open_default()
+                .and_then(|memory| memory.set_chat_session_workspace(chat_id, workspace))
+            {
+                Ok(()) => send_json_response(socket, "200 OK", "{\"status\":\"ok\"}").await,
+                Err(error) => {
+                    send_json_response(
+                        socket,
+                        "500 Internal Server Error",
+                        &json!({"error": error.to_string()}).to_string(),
+                    )
+                    .await
+                }
+            }
+        }
+
         ("POST", "/api/chat-sessions/delete") => {
             let chat_id = query_param(query, "chatId").unwrap_or_default();
+            crate::cancel_agent(&chat_id);
             if let Ok(memory) = MemoryStore::open_default() {
                 let deleted = memory.delete_chat_session(&chat_id).unwrap_or(0);
                 let response = serde_json::json!({ "status": "ok", "deleted": deleted });

package/crates/mint-core/src/api_server/routes/skills_subagents.rs

@@ -7,7 +7,7 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
     let RequestCtx {
         method,
         route,
-        query: _query,
+        query,
         body,
         request_str: _request_str,
         request_bytes: _request_bytes,
@@ -16,47 +16,17 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
     } = ctx;
     match (method, route) {
         ("GET", "/api/learned-skills") => {
-            let mut skills = match MemoryStore::open_default() {
-                Ok(m) => m.learned_skills(100).unwrap_or_default(),
-                Err(_) => Vec::new(),
-            };
-
-            if let Some(home) = dirs::home_dir() {
-                let global_agents_path = home.join(".gemini").join("config").join("AGENTS.md");
-                crate::skills::load_agent_rules_file(&global_agents_path, &mut skills);
-
-                let global_skills_path = home.join(".config").join("mint").join("mint-skills");
-                crate::skills::load_skills_from_dir(&global_skills_path, &mut skills);
-            }
-
-            if let Ok(current_dir) = std::env::current_dir() {
-                let workspace_agents_path1 = current_dir.join(".agents").join("AGENTS.md");
-                crate::skills::load_agent_rules_file(&workspace_agents_path1, &mut skills);
-                let workspace_agents_path2 = current_dir.join("AGENTS.md");
-                crate::skills::load_agent_rules_file(&workspace_agents_path2, &mut skills);
-
-                let workspace_skills_path1 = current_dir.join(".agents").join("skills");
-                crate::skills::load_skills_from_dir(&workspace_skills_path1, &mut skills);
-                let workspace_skills_path2 = current_dir.join("skills");
-                crate::skills::load_skills_from_dir(&workspace_skills_path2, &mut skills);
-
-                if let Ok(canonical_cwd) = current_dir.canonicalize() {
-                    for s in &mut skills {
-                        if let Ok(p) = std::path::Path::new(&s.source_path).canonicalize() {
-                            if p.starts_with(&canonical_cwd) {
-                                s.is_workspace = true;
-                            }
-                        }
-                    }
-                }
-            }
-
-            let mut unique_skills = std::collections::BTreeMap::new();
-            for s in skills {
-                unique_skills.insert(s.name.clone(), s);
-            }
-
-            let list: Vec<_> = unique_skills.into_values().collect();
+            let workspace = query_param(query, "workspacePath")
+                .filter(|path| !path.trim().is_empty())
+                .map(std::path::PathBuf::from)
+                .or_else(|| std::env::current_dir().ok());
+            let list = MemoryStore::open_default()
+                .ok()
+                .and_then(|memory| {
+                    crate::skill_inventory::list_available_skills(&memory, workspace.as_deref())
+                        .ok()
+                })
+                .unwrap_or_default();
             send_json_response(
                 socket,
                 "200 OK",

package/crates/mint-core/src/api_server/routes/slash.rs

@@ -6,6 +6,18 @@ use super::super::*;
 /// `POST /api/slash` — run a slash command through the shared engine
 /// (`crate::slash`). Body: `{ "input": "/cron", "cwd": "/path" }`.
 pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStream) {
+    let owner = match background_request_owner(ctx.request_str) {
+        Ok(owner) => owner,
+        Err(message) => {
+            send_json_response(
+                socket,
+                "401 Unauthorized",
+                &json!({"message": message}).to_string(),
+            )
+            .await;
+            return;
+        }
+    };
     let RequestCtx {
         method,
         route,
@@ -41,7 +53,44 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
                     return;
                 }
             };
-            let response = crate::slash::execute_async(&req, &mut config).await;
+            let trimmed = req.input.trim();
+            let (token, rest) = trimmed
+                .split_once(char::is_whitespace)
+                .unwrap_or((trimmed, ""));
+            let response = if token == "/shells" {
+                let cwd = req
+                    .cwd
+                    .as_deref()
+                    .map(std::path::PathBuf::from)
+                    .unwrap_or_else(|| std::env::current_dir().unwrap_or_default());
+                match crate::bg_shell::shells_command(rest.trim(), &cwd, &owner, &config) {
+                    Ok(markdown) => crate::slash::SlashResponse::Message { markdown },
+                    Err(error) => crate::slash::SlashResponse::Message {
+                        markdown: error.to_string(),
+                    },
+                }
+            } else if token == "/mint-web" {
+                let cwd = req
+                    .cwd
+                    .as_deref()
+                    .map(std::path::PathBuf::from)
+                    .unwrap_or_else(|| std::env::current_dir().unwrap_or_default());
+                let markdown = crate::system::mint_web::command(&cwd, rest, owner, &config)
+                    .unwrap_or_else(|e| e);
+                crate::slash::SlashResponse::Message { markdown }
+            } else if token == "/preview" {
+                let cwd = req
+                    .cwd
+                    .as_deref()
+                    .map(std::path::PathBuf::from)
+                    .unwrap_or_else(|| std::env::current_dir().unwrap_or_default());
+                match crate::system::html_preview::command(&cwd, rest, owner, &config) {
+                    Ok(markdown) => crate::slash::SlashResponse::Message { markdown },
+                    Err(markdown) => crate::slash::SlashResponse::Message { markdown },
+                }
+            } else {
+                crate::slash::execute_async(&req, &mut config).await
+            };
             if slash_persists_config(&response) {
                 let _ = save_config(&config);
             }

package/crates/mint-core/src/api_server/routes/sources.rs

@@ -0,0 +1,101 @@
+use super::super::*;
+use super::RequestCtx;
+use crate::agent::memory::SourceAttachment;
+use tokio::net::TcpStream;
+
+pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStream) {
+    #[derive(Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct SaveRequest {
+        chat_id: String,
+        interaction_id: i64,
+        attachments: Vec<SourceAttachment>,
+    }
+    let request = if ctx.method == "POST" {
+        serde_json::from_str::<SaveRequest>(ctx.body).ok()
+    } else {
+        None
+    };
+    if ctx.method == "POST" && request.is_none() {
+        send_json_response(
+            socket,
+            "400 Bad Request",
+            "{\"error\":\"Invalid source metadata\"}",
+        )
+        .await;
+        return;
+    }
+    let chat_id = request
+        .as_ref()
+        .map(|r| r.chat_id.clone())
+        .or_else(|| query_param(ctx.query, "chatId"))
+        .unwrap_or_default();
+    let owner = match background_request_owner(ctx.request_str) {
+        Ok(owner) => owner,
+        Err(message) => {
+            send_json_response(
+                socket,
+                "401 Unauthorized",
+                &json!({"error": message}).to_string(),
+            )
+            .await;
+            return;
+        }
+    };
+    if chat_id.trim().is_empty() {
+        send_json_response(
+            socket,
+            "400 Bad Request",
+            "{\"error\":\"chatId is required\"}",
+        )
+        .await;
+        return;
+    }
+    if !crate::bg_shell::bind_chat_owner(&chat_id, owner) {
+        send_json_response(
+            socket,
+            "403 Forbidden",
+            "{\"error\":\"Conversation belongs to another user\"}",
+        )
+        .await;
+        return;
+    }
+    let result = tokio::task::spawn_blocking(move || -> Result<Value, String> {
+        let store = MemoryStore::open_default().map_err(|e| e.to_string())?;
+        if let Some(request) = request {
+            store.save_source_attachments(
+                &chat_id,
+                request.interaction_id,
+                &request.attachments,
+            )?;
+            Ok(json!({"status":"ok"}))
+        } else {
+            serde_json::to_value(
+                store
+                    .conversation_sources(&chat_id)
+                    .map_err(|e| e.to_string())?,
+            )
+            .map_err(|e| e.to_string())
+        }
+    })
+    .await;
+    match result {
+        Ok(Ok(value)) => send_json_response(socket, "200 OK", &value.to_string()).await,
+        Ok(Err(error)) => {
+            send_json_response(
+                socket,
+                "400 Bad Request",
+                &json!({"error": error}).to_string(),
+            )
+            .await
+        }
+        Err(_) => {
+            send_json_response(
+                socket,
+                "500 Internal Server Error",
+                "{\"error\":\"Could not load session sources\"}",
+            )
+            .await
+        }
+    }
+}

package/crates/mint-core/src/api_server.rs

@@ -52,7 +52,6 @@ use crate::{
     destroy_session,
     detect_silence,
     find_paths,
-    generate_images,
     generate_srt,
     generate_video,
     get_user,
@@ -124,9 +123,42 @@ pub(crate) fn log_api_err(context: &str, error: &dyn std::fmt::Display) {
 /// duplicate Discord gateway connections, duplicate replies to the owner).
 mod routes;
 
+/// Observe terminal shutdown without taking ownership of the host's lifetime.
+/// Embedded hosts must also request their own exit: stopping this HTTP server
+/// alone leaves a GUI event loop alive after Tokio intercepts the OS signal.
+pub async fn shutdown_on_signal(on_shutdown: impl FnOnce()) {
+    let shutdown = async {
+        #[cfg(unix)]
+        {
+            if let Ok(mut signal) =
+                tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
+            {
+                tokio::select! { _ = tokio::signal::ctrl_c() => {}, _ = signal.recv() => {} }
+                return;
+            }
+        }
+        let _ = tokio::signal::ctrl_c().await;
+    };
+    shutdown.await;
+    on_shutdown();
+}
+
 pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
-    let addr = SocketAddr::from(([0, 0, 0, 0], port));
+    start_api_server_on(SocketAddr::from(([0, 0, 0, 0], port))).await
+}
+
+/// Serve the API on a caller-selected interface. Tailnet web mode uses
+/// loopback so only its local web proxy can reach the API directly.
+pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error> {
     let listener = TcpListener::bind(addr).await?;
+    let listener_addr = listener.local_addr()?;
+    let _webhook_lease = crate::webhooks::claim_api_listener(listener_addr);
+    tokio::task::spawn_blocking(|| {
+        if let Err(error) = crate::library::LibraryStore::open_default() {
+            eprintln!("[mint] Library startup: {error}")
+        }
+    });
+    crate::companion::start();
     // API server banner removed to prevent duplicate output
 
     // Start background messaging bridges (Telegram, Discord, Slack)
@@ -134,8 +166,17 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
     // Start the cron scheduler so scheduled agent tasks fire while this server is up
     crate::start_cron_scheduler();
 
+    let shutdown = shutdown_on_signal(|| {});
+    tokio::pin!(shutdown);
     loop {
-        let (mut socket, peer_addr) = match listener.accept().await {
+        let accepted = tokio::select! {
+            accepted = listener.accept() => accepted,
+            _ = &mut shutdown => {
+                let _ = tokio::task::spawn_blocking(crate::bg_shell::shutdown).await;
+                return Ok(());
+            }
+        };
+        let (mut socket, peer_addr) = match accepted {
             Ok(val) => val,
             Err(_) => continue,
         };
@@ -143,6 +184,11 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
         // only safe for, a browser on this same machine — capture that now
         // while we still have the peer address.
         let from_loopback = peer_addr.ip().is_loopback();
+        // A wildcard API listener can cover more interfaces than a webhook is
+        // configured to accept. Classify callbacks by this connection's destination.
+        let Ok(connection_addr) = socket.local_addr() else {
+            continue;
+        };
 
         tokio::spawn(async move {
             // Isolates a panic anywhere in this connection's handling (a malformed
@@ -237,6 +283,20 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
 
             let (route, query) = path.split_once('?').unwrap_or((path, ""));
 
+            // Provider-authenticated callbacks share this listener when their configured
+            // interface and port match it. Ordinary API routes still use the API token.
+            if let Ok(config) = crate::load_config()
+                && let Some(service) = crate::webhooks::api_service(&config, connection_addr, method, path)
+            {
+                let request = crate::webhooks::Request {
+                    method: method.into(), path: path.into(),
+                    headers: request_str[..header_end].into(),
+                    body: request_bytes[header_end + 4..].to_vec(),
+                };
+                crate::webhooks::handle(socket, service, config, request).await;
+                return;
+            }
+
             if !api_auth_ok(&request_str) {
                 send_json_response(
                     socket,
@@ -288,11 +348,47 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                 && route != "/api/action"
                 && route != "/api/config"
                 && route != "/api/gemini-live"
+                && route != "/api/interactions"
+                && route != "/api/conversation-snapshot"
+                && route != "/api/conversation-changes"
+                && route != "/api/status"
+                && route != "/api/chat-sessions"
             {
                 log_api_req(method, route, "200 OK", Some(&auth_label));
             }
 
             match (method, route) {
+                ("GET" | "POST" | "DELETE", route) if route == "/api/library" || route.starts_with("/api/library/") => {
+                    routes::library::execute(routes::RequestCtx { method, route, query, body, request_str: &request_str, request_bytes: &request_bytes, header_end, auth_label: auth_label.clone() }, socket).await;
+                }
+                ("GET" | "POST", "/api/conversation-sources") => {
+                    routes::sources::execute(routes::RequestCtx { method, route, query, body, request_str: &request_str, request_bytes: &request_bytes, header_end, auth_label: auth_label.clone() }, socket).await;
+                }
+                ("GET", route) if route.starts_with("/api/mcp-artifacts/") => {
+                    let id = route.trim_start_matches("/api/mcp-artifacts/").to_owned();
+                    let artifact = tokio::task::spawn_blocking(move || crate::integrations::mcp_result::read_artifact(&id)).await;
+                    match artifact {
+                        Ok(Ok((entry, bytes))) => {
+                            let mime = if entry.kind == "image" { entry.mime_type.as_str() } else { "application/octet-stream" };
+                            let disposition = if entry.kind == "image" {"inline"} else {"attachment"};
+                            let header = format!("HTTP/1.1 200 OK\r\nContent-Type: {mime}\r\nContent-Length: {}\r\nContent-Disposition: {disposition}; filename=\"{}\"\r\nX-Content-Type-Options: nosniff\r\nAccess-Control-Allow-Origin: *\r\nConnection: close\r\n\r\n", bytes.len(), entry.id);
+                            let mut socket = socket;
+                            let _ = socket.write_all(header.as_bytes()).await;
+                            let _ = socket.write_all(&bytes).await;
+                        }
+                        _ => send_json_response(socket, "404 Not Found", "{\"error\":\"Artifact unavailable\"}").await,
+                    }
+                }
+                ("POST", "/api/html-preview") => {
+                    routes::html_preview::execute(routes::RequestCtx { method, route, query, body, request_str: &request_str, request_bytes: &request_bytes, header_end, auth_label: auth_label.clone() }, socket).await;
+                }
+                ("GET" | "POST" | "DELETE", route) if route == "/api/background-jobs" || route.starts_with("/api/background-jobs/") => {
+                    routes::background_jobs::execute(routes::RequestCtx { method, route, query, body, request_str: &request_str, request_bytes: &request_bytes, header_end, auth_label: auth_label.clone() }, socket).await;
+                }
+
+                ("POST", "/api/mods") => {
+                    routes::mods::execute(routes::RequestCtx { method, route, query, body, request_str: &request_str, request_bytes: &request_bytes, header_end, auth_label: auth_label.clone() }, socket).await;
+                }
                                 ("GET", "/api/status") => {
                     routes::status_health::execute(
                         routes::RequestCtx {
@@ -485,7 +581,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                     )
                     .await;
                 }
-                                ("GET", "/api/interactions") => {
+                                ("GET", "/api/interactions" | "/api/conversation-snapshot" | "/api/conversation-changes") => {
                     routes::sessions::execute(
                         routes::RequestCtx {
                             method,
@@ -533,7 +629,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                     )
                     .await;
                 }
-                                ("POST", "/api/chat-sessions/rename") => {
+                                ("POST", "/api/chat-sessions/rename" | "/api/chat-sessions/workspace") => {
                     routes::sessions::execute(
                         routes::RequestCtx {
                             method,
@@ -742,6 +838,15 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         socket,
                     )
                     .await;
+                }
+                                ("GET" | "POST", route) if route.starts_with("/api/linked-folders/") => {
+                    routes::linked_folders::execute(
+                        routes::RequestCtx {
+                            method, route, query, body,
+                            request_str: &request_str, request_bytes: &request_bytes,
+                            header_end, auth_label: auth_label.clone(),
+                        }, socket,
+                    ).await;
                 }
                                 ("POST", "/api/linked-folders") => {
                     routes::linked_folders::execute(
@@ -1112,11 +1217,14 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                     .await;
                 }
                 ("GET", "/api/models")
+                | ("GET", "/api/live-models")
                 | ("GET", "/api/image-models")
                 | ("GET", "/api/video-models")
                 | ("GET", "/api/checkpoints")
                 | ("POST", "/api/checkpoints/rollback")
                 | ("POST", "/api/checkpoints/undo")
+                | ("GET", "/api/workspace-history")
+                | ("POST", "/api/workspace-history/undo")
                 | ("GET", "/api/file/read") => {
                     routes::misc::execute(
                         routes::RequestCtx {
@@ -1295,7 +1403,7 @@ async fn run_web_agent_loop(
         None,
         request.pinned_mcp_server.as_deref(),
         fast_mode,
-        false,
+        request.plan_mode,
         |_| Ok(ApprovalOutcome::Denied),
         |_| {},
         |_| {},
@@ -1308,7 +1416,7 @@ async fn run_web_agent_loop(
         model: result.model,
         text: result.summary,
         fallback_provider: result.fallback,
-        fallback_reason: None,
+        fallback_reason: result.fallback_reason,
         tool_calls: None,
         stop_reason: None,
         total_tokens: None,
@@ -1470,7 +1578,9 @@ fn picture_bytes(filename: &str) -> Result<(String, Vec<u8>), String> {
         .into_iter()
         .find(|entry| entry.filename == filename)
         .ok_or_else(|| "picture not found".to_string())?;
-    let bytes = std::fs::read(&picture.path).map_err(|error| error.to_string())?;
+    let (_, bytes) = crate::library::LibraryStore::open_default()
+        .and_then(|store| store.read(&picture.id, false))
+        .map_err(|error| error.to_string())?;
     Ok((picture.mime_type, bytes))
 }
 
@@ -1486,10 +1596,9 @@ fn thumbnail_bytes(filename: &str) -> Result<(String, Vec<u8>), String> {
         .into_iter()
         .find(|entry| entry.id == id)
         .ok_or_else(|| "picture not found".to_string())?;
-    let thumb_path = picture
-        .thumbnail_path
-        .ok_or_else(|| "thumbnail not found".to_string())?;
-    let bytes = std::fs::read(&thumb_path).map_err(|error| error.to_string())?;
+    let (_, bytes) = crate::library::LibraryStore::open_default()
+        .and_then(|store| store.read(&picture.id, true))
+        .map_err(|error| error.to_string())?;
     Ok(("image/png".to_string(), bytes))
 }
 
@@ -1572,6 +1681,25 @@ fn authorized_user_id(request_str: &str) -> Option<String> {
     session_user_id(token.trim())
 }
 
+fn background_request_owner(request: &str) -> Result<Option<String>, &'static str> {
+    let owner = authorized_user_id(request);
+    if get_header(request, "Authorization").is_some() && owner.is_none() {
+        let configured = load_config().ok().and_then(|c| {
+            c.extra
+                .get("apiAuthToken")
+                .and_then(Value::as_str)
+                .map(str::to_owned)
+        });
+        if !configured
+            .filter(|t| !t.is_empty())
+            .is_some_and(|token| token_matches(request, &token))
+        {
+            return Err("Session expired or invalid");
+        }
+    }
+    Ok(owner)
+}
+
 fn percent_decode(raw: &str) -> String {
     let bytes = raw.as_bytes();
     let mut output = Vec::with_capacity(bytes.len());

package/crates/mint-core/src/avatar_bridge.rs

@@ -506,7 +506,7 @@ impl AvatarBridge {
     }
 
     /// Hook this into whatever emits `AgentProgress` for a turn (currently
-    /// wired at the `progress_cb` closure in `src-tauri/src/lib.rs` around
+    /// wired at the `progress_cb` closure in `src-tauri/src/commands/conversation.rs` around
     /// the `orchestrate_agent_loop` call).
     pub fn on_agent_progress(&self, progress: &AgentProgress) {
         if !self.is_active() {
@@ -517,6 +517,7 @@ impl AvatarBridge {
                 action,
                 input,
                 subagent,
+                ..
             } => {
                 let session = SessionMeta::for_subagent(subagent.as_deref());
                 // The model's own explicit signal is the primary source of
@@ -556,9 +557,16 @@ impl AvatarBridge {
                 self.transition(AvatarSignal::emotions(&[("interest", "medium")]), None);
             }
             AgentProgress::Thought { .. } => {}
+            AgentProgress::ThinkingDelta { .. } => {}
+            AgentProgress::ExtendedThinking { .. } => {}
             AgentProgress::WaitingForNetwork { .. } => {}
+            AgentProgress::ContextCompaction { .. } => {}
             AgentProgress::PlanUpdated { .. } => {}
-            AgentProgress::RunCompleted { .. } => {}
+            AgentProgress::RunCompleted { .. }
+            | AgentProgress::ToolProgress { .. }
+            | AgentProgress::ToolArtifacts { .. }
+            | AgentProgress::ToolDiscovery { .. }
+            | AgentProgress::DeviceState { .. } => {}
         }
     }
 
@@ -793,6 +801,7 @@ mod tests {
     async fn tool_start_without_subagent_uses_main_session_at_priority_zero() {
         let bridge = AvatarBridge::new(test_cfg());
         bridge.on_agent_progress(&AgentProgress::ToolStart {
+            call_id: None,
             action: "run_shell".into(),
             input: serde_json::Value::Null,
             subagent: None,
@@ -811,6 +820,7 @@ mod tests {
     async fn tool_start_inside_a_subagent_gets_its_own_lower_priority_session() {
         let bridge = AvatarBridge::new(test_cfg());
         bridge.on_agent_progress(&AgentProgress::ToolStart {
+            call_id: None,
             action: "run_shell".into(),
             input: serde_json::Value::Null,
             subagent: Some("researcher".into()),
@@ -829,6 +839,7 @@ mod tests {
     async fn thinking_falls_back_to_the_last_known_session() {
         let bridge = AvatarBridge::new(test_cfg());
         bridge.on_agent_progress(&AgentProgress::ToolStart {
+            call_id: None,
             action: "run_shell".into(),
             input: serde_json::Value::Null,
             subagent: Some("researcher".into()),