@pheem49/mint 1.14.0 → 1.16.0

package/src-tauri/src/app/lifecycle.rs

@@ -0,0 +1,277 @@
+use crate::app::shortcuts::install_shortcuts;
+use crate::app::tray::install_tray;
+use crate::background::events::start_system_events;
+use crate::background::headless::start_headless_queue;
+use crate::background::proactive::start_loop as start_proactive_loop;
+use crate::commands::approvals::ApprovalsState;
+use crate::commands::voice::{GeminiLiveState, MicRecordingState};
+use crate::native::terminal::TerminalSessions;
+use crate::native::windows::{open_desktop_window, position_widget};
+use crate::{app, background, commands, native};
+use mint_core::{load_config, start_channels, start_cron_scheduler};
+use tauri::{AppHandle, Manager};
+
+#[tauri::command]
+pub(crate) fn exit_app(app: AppHandle) {
+    app.exit(0);
+}
+
+/// WebKitGTK denies every `permission-request` (microphone, camera, geolocation, ...) by
+/// default unless something handles the signal — Tauri/wry doesn't wire this up on Linux,
+/// which is why `getUserMedia()` rejects with `NotAllowedError` even though the user never
+/// saw (or could act on) a prompt. Auto-allow only mic/camera requests here; everything
+/// else falls through to WebKit's default (deny).
+#[cfg(any(
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+fn allow_media_permission_requests(window: &tauri::WebviewWindow) {
+    use webkit2gtk::{PermissionRequestExt, WebViewExt, glib::prelude::ObjectExt};
+    let _ = window.with_webview(|platform_webview| {
+        let webview = platform_webview.inner();
+        webview.connect_permission_request(|_webview, request| {
+            if request.is::<webkit2gtk::UserMediaPermissionRequest>() {
+                request.allow();
+                true
+            } else {
+                false
+            }
+        });
+    });
+}
+
+#[cfg(not(any(
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+)))]
+fn allow_media_permission_requests(_window: &tauri::WebviewWindow) {}
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    if std::env::args().nth(1).as_deref() == Some("--mint-mod-host") {
+        if let Err(error) = mint_core::mods::worker_main() {
+            eprintln!("{error}");
+        }
+        return;
+    }
+    tauri::Builder::default()
+        .plugin(tauri_plugin_dialog::init())
+        .plugin(tauri_plugin_notification::init())
+        .plugin(tauri_plugin_updater::Builder::new().build())
+        .manage(ApprovalsState::default())
+        .manage(GeminiLiveState::default())
+        .manage(MicRecordingState::default())
+        .manage(TerminalSessions::default())
+        .manage(mint_core::avatar_bridge::AvatarBridge::new(
+            load_config()
+                .map(|c| mint_core::avatar_bridge::AvatarBridgeConfig::from_mint_config(&c))
+                .unwrap_or_else(|_| mint_core::avatar_bridge::AvatarBridgeConfig::from_env()),
+        ))
+        .setup(|app| {
+            // The embedded API also observes these signals, but its completion
+            // does not stop Tauri's event loop. Keep the host watcher independent
+            // so Ctrl+C still exits when the API port could not be bound.
+            let shutdown_app = app.handle().clone();
+            tauri::async_runtime::spawn(mint_core::api_server::shutdown_on_signal(move || {
+                shutdown_app.exit(0);
+            }));
+            if let Some(main_window) = app.get_webview_window("main") {
+                allow_media_permission_requests(&main_window);
+            }
+            std::thread::spawn(|| {
+                if let Err(error) = mint_core::library::LibraryStore::open_default() {
+                    eprintln!("[mint] Library startup: {error}")
+                }
+            });
+            install_tray(app.handle())?;
+            install_shortcuts(app.handle())?;
+            start_system_events(app.handle().clone());
+            start_headless_queue(app.handle().clone());
+            start_proactive_loop(app.handle().clone());
+            tauri::async_runtime::spawn(async {
+                mint_core::companion::start();
+                if let Err(error) = mint_core::start_api_server(3000).await {
+                    eprintln!("[mint] embedded API unavailable: {error}");
+                    start_channels();
+                    start_cron_scheduler();
+                }
+            });
+            if load_config()
+                .map(|config| config.show_desktop_widget)
+                .unwrap_or(false)
+            {
+                let _ = open_desktop_window(app.handle(), "widget");
+                position_widget(app.handle());
+            }
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![
+            commands::mods::mods_operation,
+            native::notifications::send_mint_notification,
+            native::terminal::start_interactive_terminal,
+            native::terminal::write_interactive_terminal,
+            native::terminal::resize_interactive_terminal,
+            native::terminal::stop_interactive_terminal,
+            native::browser::open_mint_browser,
+            native::browser::close_mint_browser,
+            native::browser::show_mint_browser_suggestions,
+            native::browser::hide_mint_browser_suggestions,
+            native::browser::get_mint_browser_suggestion_query,
+            native::browser::navigate_mint_browser,
+            native::browser::browser_go_back,
+            native::browser::browser_go_forward,
+            native::browser::browser_reload,
+            commands::settings::get_runtime_status,
+            commands::settings::detect_system_tools,
+            commands::integrations::reauth_mcp_server,
+            commands::integrations::list_mcp_server_tools,
+            commands::integrations::test_mcp_connection,
+            commands::integrations::read_mcp_artifact,
+            commands::settings::fetch_provider_models,
+            commands::media::fetch_image_provider_models,
+            commands::media::fetch_video_provider_models,
+            commands::media::fetch_gemini_live_models,
+            commands::workspace::get_workspace_snapshot,
+            commands::workspace::get_git_branch_info,
+            commands::workspace::switch_git_branch,
+            commands::workspace::create_git_branch,
+            commands::workspace::checkout_remote_git_branch,
+            commands::workspace::get_git_graph,
+            commands::workspace::get_workspace_git_diff,
+            commands::workspace::create_workspace_file,
+            commands::workspace::create_workspace_folder,
+            commands::workspace::delete_workspace_item,
+            commands::workspace::move_workspace_item,
+            commands::workspace::list_workspace_history,
+            commands::workspace::undo_workspace_action,
+            commands::media::generate_images,
+            commands::media::generate_video,
+            commands::workspace::select_workspace_directory,
+            commands::settings::get_config,
+            commands::settings::get_updater_status,
+            commands::settings::check_for_updates,
+            commands::settings::install_available_update,
+            commands::settings::update_config,
+            commands::settings::set_active_model,
+            commands::settings::inspect_shell_command,
+            commands::conversation::send_chat_message,
+            commands::conversation::stream_chat_message,
+            commands::conversation::cancel_chat_message,
+            commands::voice::start_gemini_live_session,
+            commands::voice::send_gemini_live_audio_chunk,
+            commands::voice::stop_gemini_live_session,
+            commands::voice::start_mic_recording,
+            commands::voice::stop_mic_recording_and_transcribe,
+            commands::voice::cancel_mic_recording,
+            commands::conversation::submit_tool_approval,
+            commands::conversation::get_recent_interactions,
+            commands::conversation::get_conversation_snapshot,
+            commands::conversation::get_conversation_sources,
+            commands::conversation::save_source_attachments,
+            commands::conversation::get_conversation_changes,
+            commands::conversation::save_interaction_agent_activity,
+            commands::conversation::list_chat_sessions,
+            commands::conversation::delete_chat_session,
+            commands::conversation::rename_chat_session,
+            commands::auth::get_profile_value,
+            commands::auth::set_profile_value,
+            commands::auth::auth_register,
+            commands::auth::auth_login,
+            commands::auth::auth_logout,
+            commands::auth::auth_current_user,
+            commands::auth::auth_update_profile,
+            commands::auth::auth_upload_avatar,
+            commands::conversation::clear_chat_history,
+            commands::integrations::list_learned_skills,
+            commands::integrations::add_learned_skill,
+            commands::integrations::delete_learned_skill,
+            commands::integrations::list_subagents,
+            commands::integrations::save_subagent,
+            commands::integrations::delete_subagent,
+            commands::conversation::run_slash_command,
+            commands::workspace::list_background_jobs,
+            commands::workspace::start_html_preview,
+            commands::workspace::get_background_job,
+            commands::workspace::stop_background_job,
+            commands::workspace::remove_background_job,
+            commands::integrations::list_cron_jobs,
+            commands::integrations::add_cron_job,
+            commands::integrations::remove_cron_job,
+            commands::integrations::set_cron_job_enabled,
+            commands::workspace::list_linked_folders,
+            commands::workspace::add_linked_folder,
+            commands::workspace::remove_linked_folder,
+            commands::workspace::linked_folder_status,
+            commands::workspace::refresh_linked_folder,
+            commands::workspace::list_linked_folder_notes,
+            commands::workspace::read_linked_folder_note,
+            commands::workspace::save_linked_folder_note,
+            commands::workspace::open_linked_folder_note,
+            commands::media::list_library,
+            commands::media::get_library_item,
+            commands::media::set_library_trashed,
+            commands::media::remove_library_item,
+            commands::media::read_library_file,
+            commands::media::list_pictures,
+            commands::media::delete_picture,
+            commands::media::save_pictures,
+            commands::media::upload_file,
+            commands::workspace::open_folder,
+            commands::media::get_tts_urls,
+            commands::media::get_weather,
+            commands::workspace::propose_desktop_code_edits,
+            commands::workspace::apply_desktop_code_edits,
+            commands::workspace::list_git_checkpoints,
+            commands::workspace::rollback_git_checkpoint,
+            commands::workspace::undo_git_checkpoint,
+            commands::workspace::read_workspace_file,
+            native::windows::open_window,
+            native::windows::hide_desktop_window,
+            native::windows::close_desktop_window,
+            native::windows::resize_desktop_window,
+            native::actions::run_desktop_action,
+            commands::integrations::get_integration_inventory,
+            commands::integrations::run_native_plugin,
+            native::capture::capture_chat_screen,
+            native::capture::read_clipboard_image,
+            native::capture::capture_translation_frame,
+            native::capture::translate_captured_frame,
+            native::actions::get_smart_context,
+            native::browser::get_browser_tabs,
+            native::browser::navigate_browser,
+            native::browser::read_browser_page,
+            native::browser::click_browser_selector,
+            native::browser::type_in_browser,
+            native::capture::start_live_translate,
+            native::capture::open_live_translate_controls,
+            native::capture::live_translate_geometry,
+            native::capture::set_live_translate_passthrough,
+            native::windows::submit_spotlight,
+            native::windows::set_ai_state,
+            background::proactive::toggle_proactive,
+            background::proactive::save_behavior_context,
+            background::headless::run_next_queued_task,
+            app::lifecycle::exit_app,
+            commands::conversation::save_system_interaction,
+            commands::conversation::update_chat_session_workspace
+        ])
+        .build(tauri::generate_context!())
+        .expect("error while running Mint desktop")
+        .run(|_app_handle, event| {
+            // Kill any stdio MCP child processes we spawned before the process
+            // goes away — `SESSIONS` is a `static`, so `McpSession::Drop` never
+            // runs at exit on its own. Fires for tray "Quit", `exit_app`, and
+            // the last window closing.
+            if let tauri::RunEvent::Exit = event {
+                mint_core::companion::shutdown();
+                mint_core::close_all_mcp_sessions();
+                mint_core::bg_shell::shutdown();
+            }
+        });
+}

package/src-tauri/src/app/mod.rs

@@ -0,0 +1,4 @@
+//! Desktop composition, startup/shutdown, tray and global shortcuts.
+pub(crate) mod lifecycle;
+pub(crate) mod shortcuts;
+pub(crate) mod tray;

package/src-tauri/src/app/shortcuts.rs

@@ -0,0 +1,40 @@
+use crate::native::capture::toggle_live_translate_interaction;
+use crate::native::windows::open_desktop_window;
+use tauri::{AppHandle, Manager};
+use tauri_plugin_global_shortcut::{Code, GlobalShortcutExt, Modifiers, Shortcut, ShortcutState};
+
+pub(crate) fn install_shortcuts(app: &AppHandle) -> tauri::Result<()> {
+    let main_shortcut = Shortcut::new(Some(Modifiers::CONTROL | Modifiers::SHIFT), Code::Space);
+    let spotlight_shortcut = Shortcut::new(Some(Modifiers::ALT), Code::Space);
+    let live_translate_shortcut =
+        Shortcut::new(Some(Modifiers::ALT | Modifiers::SHIFT), Code::KeyL);
+    let main_handler = main_shortcut;
+    let spotlight_handler = spotlight_shortcut;
+    let live_translate_handler = live_translate_shortcut;
+    app.plugin(
+        tauri_plugin_global_shortcut::Builder::new()
+            .with_handler(move |app, shortcut, event| {
+                if event.state() != ShortcutState::Pressed {
+                    return;
+                }
+                if shortcut == &main_handler {
+                    if let Some(window) = app.get_webview_window("main") {
+                        let _ = if window.is_visible().unwrap_or(false) {
+                            window.hide()
+                        } else {
+                            window.show()
+                        };
+                    }
+                } else if shortcut == &spotlight_handler {
+                    let _ = open_desktop_window(app, "spotlight");
+                } else if shortcut == &live_translate_handler {
+                    toggle_live_translate_interaction(app);
+                }
+            })
+            .build(),
+    )?;
+    let _ = app.global_shortcut().register(main_shortcut);
+    let _ = app.global_shortcut().register(spotlight_shortcut);
+    let _ = app.global_shortcut().register(live_translate_shortcut);
+    Ok(())
+}

package/src-tauri/src/app/tray.rs

@@ -0,0 +1,52 @@
+use crate::native::windows::{emit_to_main, open_desktop_window};
+use tauri::menu::{Menu, MenuItem};
+use tauri::tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent};
+use tauri::{AppHandle, Manager};
+
+pub(crate) fn install_tray(app: &AppHandle) -> tauri::Result<()> {
+    let show = MenuItem::with_id(app, "show", "Show Mint", true, None::<&str>)?;
+    let settings = MenuItem::with_id(app, "settings", "Settings", true, None::<&str>)?;
+    let spotlight = MenuItem::with_id(app, "spotlight", "Spotlight", true, None::<&str>)?;
+    let quit = MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)?;
+    let menu = Menu::with_items(app, &[&show, &settings, &spotlight, &quit])?;
+    let mut builder = TrayIconBuilder::new()
+        .tooltip("Mint AI Assistant")
+        .menu(&menu)
+        .on_menu_event(|app, event| match event.id().as_ref() {
+            "show" => {
+                let _ = app.get_webview_window("main").map(|window| window.show());
+            }
+            "settings" => {
+                emit_to_main(app, "open-settings", ());
+            }
+            "spotlight" => {
+                let _ = open_desktop_window(app, "spotlight");
+            }
+            "quit" => app.exit(0),
+            _ => {}
+        })
+        .on_tray_icon_event(|tray, event| {
+            if matches!(
+                event,
+                TrayIconEvent::Click {
+                    button: MouseButton::Left,
+                    button_state: MouseButtonState::Up,
+                    ..
+                }
+            ) {
+                let app = tray.app_handle();
+                if let Some(window) = app.get_webview_window("main") {
+                    let _ = if window.is_visible().unwrap_or(false) {
+                        window.hide()
+                    } else {
+                        window.show()
+                    };
+                }
+            }
+        });
+    if let Some(icon) = app.default_window_icon() {
+        builder = builder.icon(icon.clone());
+    }
+    builder.build(app)?;
+    Ok(())
+}

package/src-tauri/src/background/events.rs

@@ -0,0 +1,70 @@
+use serde_json::json;
+use std::{
+    fs,
+    net::{SocketAddr, TcpStream},
+    path::Path,
+    thread,
+    time::Duration,
+};
+
+use tauri::{AppHandle, Emitter, Manager};
+
+pub fn start_system_events(app: AppHandle) {
+    thread::spawn(move || {
+        let mut last_battery = None;
+        let mut last_online = None;
+        loop {
+            let battery = battery_level(Path::new("/sys/class/power_supply"));
+            if let Some(level) = battery
+                .filter(|level| *level <= 20 && last_battery.is_none_or(|previous| previous > 20))
+            {
+                emit_notification(
+                    &app,
+                    json!({ "message": format!("Battery is low ({level}%). Please plug in your charger."), "type": "warning" }),
+                );
+            }
+            last_battery = battery;
+
+            let online = network_online();
+            if last_online.is_some_and(|previous| previous != online) {
+                emit_notification(
+                    &app,
+                    json!({
+                        "message": if online { "Internet connection restored." } else { "Internet connection lost." },
+                        "type": "info"
+                    }),
+                );
+            }
+            last_online = Some(online);
+            thread::sleep(Duration::from_secs(60));
+        }
+    });
+}
+
+fn emit_notification(app: &AppHandle, payload: serde_json::Value) {
+    if let Some(main) = app.get_webview_window("main") {
+        let _ = main.emit("proactive-notification", payload);
+    }
+}
+
+fn battery_level(root: &Path) -> Option<u8> {
+    fs::read_dir(root).ok()?.flatten().find_map(|entry| {
+        let name = entry.file_name().to_string_lossy().to_ascii_uppercase();
+        if !name.starts_with("BAT") {
+            return None;
+        }
+        fs::read_to_string(entry.path().join("capacity"))
+            .ok()?
+            .trim()
+            .parse()
+            .ok()
+    })
+}
+
+fn network_online() -> bool {
+    "1.1.1.1:53"
+        .parse::<SocketAddr>()
+        .ok()
+        .and_then(|address| TcpStream::connect_timeout(&address, Duration::from_secs(2)).ok())
+        .is_some()
+}

package/src-tauri/src/background/headless.rs

@@ -0,0 +1,230 @@
+use serde::Deserialize;
+use std::{path::Path, time::Duration};
+
+use mint_core::{
+    CodeEdit, KnowledgeStore, MintConfig, Task, TaskStore, load_config, parse_agent_json,
+    propose_code_edits, run_agent_loop,
+};
+use serde_json::{Value, json};
+use tauri::{AppHandle, Emitter, Manager};
+
+use mint_core::browser::{click, navigate, read_page_text, type_text};
+
+const MAX_STEPS: usize = 20;
+const SYSTEM_PROMPT: &str = r#"You are Mint's native background task agent. Return only JSON:
+{"thought":"short progress note","action":"done|propose_folder|propose_write_file|open_url|browser_read|browser_click|browser_type|knowledge_search|propose_bash","target":"path, URL, selector, query, command, or final result","data":"optional file content"}
+Use only one action per response. Background tasks never mutate the filesystem or execute shell commands. Use propose_folder, propose_write_file, and propose_bash so Mint can record a proposal for explicit user approval."#;
+
+#[derive(Debug, Deserialize)]
+struct AgentAction {
+    #[serde(default)]
+    thought: String,
+    action: String,
+    #[serde(default)]
+    target: String,
+    #[serde(default)]
+    data: String,
+}
+
+pub fn start_headless_queue(app: AppHandle) {
+    tauri::async_runtime::spawn(async move {
+        if let Ok(store) = TaskStore::open_default() {
+            let _ = store.resume_running();
+        }
+        loop {
+            tokio::time::sleep(Duration::from_secs(15)).await;
+            let Ok(config) = load_config() else {
+                continue;
+            };
+            if config
+                .extra
+                .get("enableHeadlessTaskQueue")
+                .and_then(Value::as_bool)
+                != Some(true)
+            {
+                continue;
+            }
+            let _ = run_next_task(&app).await;
+        }
+    });
+}
+
+pub async fn run_next_task(app: &AppHandle) -> Result<Option<Task>, String> {
+    let store = TaskStore::open_default().map_err(|error| error.to_string())?;
+    let Some(task) = store.pending().map_err(|error| error.to_string())? else {
+        return Ok(None);
+    };
+    store
+        .update_status(&task.id, "running", None)
+        .map_err(|error| error.to_string())?;
+    checkpoint(&store, &task.id, "started", &task.description)?;
+    emit(
+        app,
+        &format!("Started queued task: {}", task.description),
+        "info",
+    );
+
+    match execute_task(&store, &task).await {
+        Ok(result) => {
+            store
+                .add_artifact(
+                    &task.id,
+                    json!({ "type": "final_result", "content": result }),
+                )
+                .map_err(|error| error.to_string())?;
+            let completed = store
+                .update_status(&task.id, "completed", Some(Value::String(result.clone())))
+                .map_err(|error| error.to_string())?;
+            emit(app, &format!("Queued task completed: {result}"), "info");
+            Ok(completed)
+        }
+        Err(error) => {
+            let failed = store
+                .fail_with_retry(&task.id, &error)
+                .map_err(|store_error| store_error.to_string())?;
+            emit(app, &format!("Queued task failed: {error}"), "warning");
+            Ok(failed)
+        }
+    }
+}
+
+async fn execute_task(store: &TaskStore, task: &Task) -> Result<String, String> {
+    let config = load_config().map_err(|error| error.to_string())?;
+    let observer_store = store.clone();
+    let observer_task = task.clone();
+    let executor_store = store.clone();
+    let executor_task = task.clone();
+    let executor_config = config.clone();
+    run_agent_loop(
+        &config,
+        SYSTEM_PROMPT,
+        format!("Task: {}\nChoose the first action.", task.description),
+        MAX_STEPS,
+        |raw| parse_agent_json(raw).map_err(|error| error.to_string()),
+        |action: &AgentAction| (action.action == "done").then(|| action.target.clone()),
+        move |step, action| {
+            let store = executor_store.clone();
+            let task = executor_task.clone();
+            let config = executor_config.clone();
+            Box::pin(async move {
+                let observation = execute_action(&config, &store, &task, step, &action).await?;
+                checkpoint(&store, &task.id, "observation", &observation)?;
+                Ok(observation)
+            })
+        },
+        move |step, action| {
+            observer_store
+                .add_checkpoint(
+                    &observer_task.id,
+                    json!({
+                        "phase": "native_agent_step",
+                        "step": step,
+                        "thought": action.thought,
+                        "action": action.action,
+                        "target": action.target,
+                    }),
+                )
+                .map(|_| ())
+                .map_err(|error| error.to_string())
+        },
+    )
+    .await
+    .map_err(|error| error.to_string())
+}
+
+async fn execute_action(
+    config: &MintConfig,
+    store: &TaskStore,
+    task: &Task,
+    step: usize,
+    action: &AgentAction,
+) -> Result<String, String> {
+    match action.action.as_str() {
+        "propose_folder" => {
+            store
+                .add_artifact(
+                    &task.id,
+                    json!({ "type": "folder_proposal", "path": action.target, "description": format!("Proposed by native task step {step}; explicit approval required") }),
+                )
+                .map_err(|error| error.to_string())?;
+            Ok(format!(
+                "folder proposal recorded but not applied: {}",
+                action.target
+            ))
+        }
+        "propose_write_file" => {
+            let root = std::env::current_dir().map_err(|error| error.to_string())?;
+            let proposal = propose_code_edits(
+                &root,
+                &[CodeEdit {
+                    path: Path::new(&action.target).to_path_buf(),
+                    content: action.data.clone(),
+                }],
+                config,
+            )
+            .map_err(|error| error.to_string())?;
+            store
+                .add_artifact(
+                    &task.id,
+                    json!({ "type": "file_edit_proposal", "proposal": proposal, "description": format!("Proposed by native task step {step}; explicit approval required") }),
+                )
+                .map_err(|error| error.to_string())?;
+            Ok(format!(
+                "file edit proposal recorded but not applied: {}",
+                action.target
+            ))
+        }
+        "open_url" => navigate(config, &action.target).await,
+        "browser_read" => read_page_text(config).await,
+        "browser_click" => click(config, &action.target).await,
+        "browser_type" => type_text(config, &action.target, &action.data).await,
+        "knowledge_search" => {
+            let hits = KnowledgeStore::open_default()
+                .map_err(|error| error.to_string())?
+                .search(&action.target, 5)
+                .map_err(|error| error.to_string())?;
+            serde_json::to_string(&hits).map_err(|error| error.to_string())
+        }
+        "propose_bash" => Ok(format!(
+            "command proposal recorded but not executed: {}",
+            action.target
+        )),
+        other => Err(format!("unsupported native background action '{other}'")),
+    }
+}
+
+fn checkpoint(store: &TaskStore, id: &str, phase: &str, message: &str) -> Result<(), String> {
+    store
+        .add_checkpoint(id, json!({ "phase": phase, "message": message }))
+        .map(|_| ())
+        .map_err(|error| error.to_string())
+}
+
+fn emit(app: &AppHandle, message: &str, kind: &str) {
+    if let Some(main) = app.get_webview_window("main") {
+        let _ = main.emit(
+            "proactive-notification",
+            json!({ "message": message, "type": kind }),
+        );
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_json_wrapped_in_provider_text() {
+        let action: AgentAction =
+            parse_agent_json("```json\n{\"action\":\"done\",\"target\":\"ok\"}\n```").unwrap();
+        assert_eq!(action.action, "done");
+        assert_eq!(action.target, "ok");
+    }
+}
+
+#[tauri::command]
+pub(crate) async fn run_next_queued_task(
+    app: AppHandle,
+) -> Result<Option<mint_core::Task>, String> {
+    run_next_task(&app).await
+}

package/src-tauri/src/background/mod.rs

@@ -0,0 +1,4 @@
+//! Desktop-owned background loops and their notification adapters.
+pub(crate) mod events;
+pub(crate) mod headless;
+pub(crate) mod proactive;