@agent-native/core 0.88.0 → 0.90.1

package/corpus/templates/clips/desktop/src-tauri/src/shortcuts.rs

@@ -33,6 +33,12 @@ static FN_TAP_ENABLED: AtomicBool = AtomicBool::new(false);
 static FN_TAP_INSTALL_STARTED: AtomicBool = AtomicBool::new(false);
 static POPOVER_DISMISS_SHORTCUT_ACTIVE: AtomicBool = AtomicBool::new(false);
 static COUNTDOWN_SHORTCUTS_ACTIVE: AtomicBool = AtomicBool::new(false);
+// P1: tracks whether Escape is currently registered *for dictation-cancel*
+// specifically (independent of POPOVER_DISMISS_SHORTCUT_ACTIVE, which tracks
+// the popover's own reason to want Escape registered). Escape should stay
+// registered globally if EITHER reason wants it, and only unregister once
+// BOTH are false — see `sync_dictation_escape_shortcut`.
+static DICTATION_ESCAPE_SHORTCUT_ACTIVE: AtomicBool = AtomicBool::new(false);
 
 fn custom_voice_shortcut() -> &'static Mutex<Option<Shortcut>> {
     CUSTOM_VOICE_SHORTCUT.get_or_init(|| Mutex::new(None))
@@ -162,7 +168,7 @@ pub async fn set_custom_shortcuts(
 pub async fn set_fn_shortcut_enabled(app: AppHandle, enabled: bool) -> Result<(), String> {
     FN_TAP_ENABLED.store(enabled, Ordering::SeqCst);
     if !enabled {
-        set_dictation_active(&app, false);
+        set_dictation_active_and_sync_escape(&app, false);
         return Ok(());
     }
 
@@ -177,6 +183,22 @@ pub async fn set_fn_shortcut_enabled(app: AppHandle, enabled: bool) -> Result<()
     Ok(())
 }
 
+/// Wispr parity (P5): re-paste the last dictation on demand. Cmd+Ctrl+V on
+/// macOS; Ctrl+Alt+V elsewhere (Ctrl+Shift+V collides with several
+/// terminals' native paste override, and Shift+Alt+Z per wispr-ux.md's
+/// Windows row isn't a natural fit for our existing modifier conventions
+/// here, so we mirror our own Ctrl+Shift+L-style dual-binding instead).
+fn paste_last_dictation_shortcut() -> Shortcut {
+    #[cfg(target_os = "macos")]
+    {
+        Shortcut::new(Some(Modifiers::SUPER | Modifiers::CONTROL), Code::KeyV)
+    }
+    #[cfg(not(target_os = "macos"))]
+    {
+        Shortcut::new(Some(Modifiers::CONTROL | Modifiers::ALT), Code::KeyV)
+    }
+}
+
 pub fn register_shortcuts(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
     // Register the global shortcut. On macOS we use Cmd+Shift+L;
     // on Windows/Linux we use Ctrl+Shift+L. Registering both is safe
@@ -198,6 +220,12 @@ pub fn register_shortcuts(app: &tauri::App) -> Result<(), Box<dyn std::error::Er
     if let Err(err) = gs.register(voice_ctrl_space) {
         eprintln!("[clips-tray] failed to register Ctrl+Shift+Space voice shortcut: {err}");
     }
+    // Non-fatal: a collision here should never block the rest of startup —
+    // paste-last-dictation is a convenience shortcut, always reachable via
+    // the tray menu regardless of whether the hotkey registered.
+    if let Err(err) = gs.register(paste_last_dictation_shortcut()) {
+        eprintln!("[clips-tray] failed to register paste-last-dictation shortcut: {err}");
+    }
 
     Ok(())
 }
@@ -230,6 +258,7 @@ pub fn install_popover_dismiss_handler(app: &tauri::App) {
                     }
                 }
             } else if !COUNTDOWN_SHORTCUTS_ACTIVE.load(Ordering::SeqCst)
+                && !DICTATION_ESCAPE_SHORTCUT_ACTIVE.load(Ordering::SeqCst)
                 && gs.is_registered(shortcut)
             {
                 let _ = gs.unregister(shortcut);
@@ -238,6 +267,63 @@ pub fn install_popover_dismiss_handler(app: &tauri::App) {
     });
 }
 
+/// P1 (Esc cancels dictation): set `DictationActive` and keep the global
+/// Escape registration in lockstep, from a single chokepoint. Every call
+/// site that flips `DictationActive` in this file should go through this
+/// function (or the cmd/ctrl-shift-space branch's own direct mutex flip,
+/// which calls `sync_dictation_escape_shortcut` immediately after) instead of
+/// calling `set_dictation_active` directly, so Escape can never be left
+/// dangling registered after a session ends. Idempotent: registering an
+/// already-registered shortcut or unregistering an absent one is a no-op via
+/// the `is_registered` guards in `sync_dictation_escape_shortcut`.
+pub fn set_dictation_active_and_sync_escape(app: &AppHandle, active: bool) {
+    set_dictation_active(app, active);
+    sync_dictation_escape_shortcut(app.clone(), active);
+}
+
+/// Hands-free dictation outlives the physical key press that started it, while
+/// the physical key-edge handlers disarm Escape as soon as the triggering key
+/// is released. The webview calls this command when hands-free mode starts or
+/// ends so Escape stays armed for the whole hands-free session. `hide_flow_bar`
+/// remains the final safety net and unconditionally disarms on teardown.
+#[tauri::command]
+pub fn set_dictation_escape_active(app: AppHandle, active: bool) -> Result<(), String> {
+    set_dictation_active_and_sync_escape(&app, active);
+    Ok(())
+}
+
+/// Register/unregister the global Escape shortcut so it only intercepts Esc
+/// while a dictation session is actually active — mirrors
+/// `install_popover_dismiss_handler`'s register-on-demand pattern (same
+/// Carbon-reentrancy hazard: never call global_shortcut::{register,
+/// unregister,is_registered} synchronously from inside a hotkey callback, so
+/// this always hops to a worker thread). Registration failure is logged and
+/// swallowed — never breaks dictation start over a hotkey conflict.
+fn sync_dictation_escape_shortcut(app: AppHandle, active: bool) {
+    DICTATION_ESCAPE_SHORTCUT_ACTIVE.store(active, Ordering::SeqCst);
+    thread::spawn(move || {
+        let gs = app.global_shortcut();
+        let shortcut = escape_shortcut();
+        if active {
+            if !gs.is_registered(shortcut) {
+                if let Err(err) = gs.register(shortcut) {
+                    eprintln!("[clips-tray] failed to register dictation-cancel Escape: {err}");
+                }
+            }
+            return;
+        }
+        // Only unregister once none of the popover, countdown, or a
+        // dictation session still wants Escape — otherwise we'd steal the
+        // registration out from under whichever of those is still using it.
+        if !POPOVER_DISMISS_SHORTCUT_ACTIVE.load(Ordering::SeqCst)
+            && !COUNTDOWN_SHORTCUTS_ACTIVE.load(Ordering::SeqCst)
+            && gs.is_registered(shortcut)
+        {
+            let _ = gs.unregister(shortcut);
+        }
+    });
+}
+
 pub fn install_countdown_shortcut_handler(app: &tauri::App) {
     let handle = app.handle().clone();
     app.listen("clips:countdown-shortcuts-active", move |event| {
@@ -271,7 +357,10 @@ fn set_countdown_shortcuts_active(app: AppHandle, active: bool) {
                 let _ = gs.unregister(shortcut);
             }
         }
-        if !POPOVER_DISMISS_SHORTCUT_ACTIVE.load(Ordering::SeqCst) && gs.is_registered(escape) {
+        if !POPOVER_DISMISS_SHORTCUT_ACTIVE.load(Ordering::SeqCst)
+            && !DICTATION_ESCAPE_SHORTCUT_ACTIVE.load(Ordering::SeqCst)
+            && gs.is_registered(escape)
+        {
             let _ = gs.unregister(escape);
         }
     });
@@ -306,6 +395,7 @@ pub fn build_shortcut_plugin() -> tauri_plugin_global_shortcut::Builder<tauri::W
         let is_escape = shortcut.matches(Modifiers::empty(), Code::Escape);
         let is_enter = shortcut.matches(Modifiers::empty(), Code::Enter);
         let is_numpad_enter = shortcut.matches(Modifiers::empty(), Code::NumpadEnter);
+        let is_paste_last_dictation = *shortcut == paste_last_dictation_shortcut();
         if (is_escape || is_enter || is_numpad_enter)
             && COUNTDOWN_SHORTCUTS_ACTIVE.load(Ordering::SeqCst)
         {
@@ -327,6 +417,20 @@ pub fn build_shortcut_plugin() -> tauri_plugin_global_shortcut::Builder<tauri::W
             if event.state() != tauri_plugin_global_shortcut::ShortcutState::Pressed {
                 return;
             }
+            // P1: Esc cancels an active dictation (wispr-ux.md §1) —
+            // checked before the popover-dismiss fallthrough below, and
+            // BEFORE the recording-active guard, since dictation and
+            // screen-recording are independent flags and a live dictation
+            // should always win Esc regardless of what else is going on.
+            // This Escape registration is itself gated on dictation being
+            // active (see `install_dictation_escape_handler`), but the
+            // check is cheap and kept here too as defence-in-depth in case
+            // Escape is independently registered for the popover at the
+            // same moment.
+            if is_dictation_active(app) {
+                let _ = app.emit("voice:cancel", ());
+                return;
+            }
             // Don't dismiss mid-recording — same guard as the React-side Esc
             // handler. The user would lose the recorder handle.
             if is_recording_active(app) {
@@ -338,6 +442,18 @@ pub fn build_shortcut_plugin() -> tauri_plugin_global_shortcut::Builder<tauri::W
             let _ = app.emit("clips:popover-visible", false);
             return;
         }
+        if is_paste_last_dictation {
+            if event.state() != tauri_plugin_global_shortcut::ShortcutState::Pressed {
+                return;
+            }
+            let app = app.clone();
+            tauri::async_runtime::spawn(async move {
+                if let Err(err) = crate::clips::paste_last_dictation(app).await {
+                    eprintln!("[clips-tray] paste_last_dictation failed: {err}");
+                }
+            });
+            return;
+        }
         if is_voice_cmd_space || is_voice_ctrl_space || is_custom_voice {
             let source = if is_custom_voice {
                 "custom"
@@ -358,6 +474,11 @@ pub fn build_shortcut_plugin() -> tauri_plugin_global_shortcut::Builder<tauri::W
                     }
                     if !already_active {
                         eprintln!("[clips-tray] {source} down — starting voice dictation");
+                        // P1: keep Escape's registration in lockstep with
+                        // DictationActive even though this branch flips the
+                        // mutex directly instead of through
+                        // set_dictation_active_and_sync_escape.
+                        sync_dictation_escape_shortcut(app.clone(), true);
                         emit_voice_shortcut(app, "voice:shortcut-start", source, true);
                     }
                 }
@@ -368,6 +489,7 @@ pub fn build_shortcut_plugin() -> tauri_plugin_global_shortcut::Builder<tauri::W
                         }
                     }
                     eprintln!("[clips-tray] {source} up — stopping voice dictation");
+                    sync_dictation_escape_shortcut(app.clone(), false);
                     emit_voice_shortcut(app, "voice:shortcut-stop", source, false);
                 }
             }
@@ -518,12 +640,18 @@ fn install_fn_event_tap(app: tauri::AppHandle) {
     let prev_down = Arc::new(AtomicBool::new(false));
     let needs_reenable = Arc::new(AtomicBool::new(false));
     let event_count = Arc::new(AtomicU64::new(0));
+    // Millis (via Instant-relative counter) at the last Fn-down edge, 0 if
+    // not currently down. Lets the up-edge detect a fast tap (< 80ms) even
+    // though `prev_down` itself is flipped synchronously on both edges —
+    // see the fast-tap handling below.
+    let fn_down_at = Arc::new(AtomicU64::new(0));
+    let tap_epoch = std::time::Instant::now();
 
     let app_for_cancel = app.clone();
     let prev_for_cancel = prev_down.clone();
     app.listen("voice:cancel", move |_event| {
         prev_for_cancel.store(false, Ordering::SeqCst);
-        set_dictation_active(&app_for_cancel, false);
+        set_dictation_active_and_sync_escape(&app_for_cancel, false);
     });
 
     dlog!("[clips-tray][fn-tap] install_fn_event_tap called — spawning listener thread");
@@ -535,6 +663,7 @@ fn install_fn_event_tap(app: tauri::AppHandle) {
             let prev_for_cb = prev_down.clone();
             let needs_reenable_for_cb = needs_reenable.clone();
             let event_count_for_cb = event_count.clone();
+            let fn_down_at_for_cb = fn_down_at.clone();
 
             dlog!("[clips-tray][fn-tap] thread started; about to call CGEventTap::new");
             let tap_result = CGEventTap::new(
@@ -599,9 +728,23 @@ fn install_fn_event_tap(app: tauri::AppHandle) {
                     if fn_down == was_down {
                         return CallbackResult::Keep;
                     }
-                    set_dictation_active(&app_for_cb, fn_down);
+                    // Safe to call from inside the tap callback: the actual
+                    // register/unregister work is deferred to a spawned
+                    // thread inside `sync_dictation_escape_shortcut` — same
+                    // reentrancy avoidance as `emit_voice_shortcut` below.
+                    set_dictation_active_and_sync_escape(&app_for_cb, fn_down);
                     if fn_down {
                         dlog!("[clips-tray] Fn down — starting voice dictation");
+                        // Snapshot the frontmost app now, at press time, so a
+                        // focus change during the (possibly sub-80ms)
+                        // dictation still reactivates the app the user meant
+                        // to dictate into — mirrors emit_voice_shortcut's
+                        // remember_voice_target call for the other sources.
+                        remember_voice_target(&app_for_cb);
+                        fn_down_at_for_cb.store(
+                            tap_epoch.elapsed().as_millis() as u64,
+                            Ordering::SeqCst,
+                        );
                         // Wake the popover (parked at 2x2, no focus) so its
                         // JS runtime is live to receive the event. Without
                         // this, if the popover was hidden, macOS may have
@@ -616,15 +759,49 @@ fn install_fn_event_tap(app: tauri::AppHandle) {
                         // show happens slightly later than this line.
                         let app_for_emit = app_for_cb.clone();
                         let prev_for_emit = prev_for_cb.clone();
+                        let fn_down_at_for_emit = fn_down_at_for_cb.clone();
                         thread::spawn(move || {
                             thread::sleep(Duration::from_millis(80));
-                            if prev_for_emit.load(Ordering::SeqCst)
-                                && should_emit_delayed_voice_start(&app_for_emit, "fn")
-                            {
+                            let still_down = prev_for_emit.load(Ordering::SeqCst);
+                            // A tap shorter than 80ms flips `prev_for_emit`
+                            // back to false via the up-edge's synchronous
+                            // swap before we wake up here, so gating on
+                            // `still_down` alone silently drops fast taps
+                            // (start never fires, so the up-edge's earlier
+                            // voice:shortcut-stop is a no-op). Detect that
+                            // case via the down-edge timestamp — if nothing
+                            // re-armed it (no newer press), treat it as a
+                            // completed fast tap and still emit start,
+                            // immediately followed by stop, so the existing
+                            // <500ms accidental-tap discard in the TS layer
+                            // handles it uniformly instead of the event
+                            // vanishing.
+                            let fast_tap = !still_down
+                                && fn_down_at_for_emit.load(Ordering::SeqCst) != 0;
+                            // For a fast tap, both `current_fn_flag_down()`
+                            // and `is_dictation_active` (inside
+                            // should_emit_delayed_voice_start) read false by
+                            // now — the up-edge already released the key and
+                            // flipped DictationActive off as part of this
+                            // same tap — so that gate only applies to the
+                            // still-held case. A completed fast tap is only
+                            // gated on the tap still being enabled.
+                            let should_emit = if fast_tap {
+                                FN_TAP_ENABLED.load(Ordering::SeqCst)
+                            } else {
+                                should_emit_delayed_voice_start(&app_for_emit, "fn")
+                            };
+                            if (still_down || fast_tap) && should_emit {
                                 let _ = app_for_emit.emit(
                                     "voice:shortcut-start",
                                     serde_json::json!({ "source": "fn" }),
                                 );
+                                if fast_tap {
+                                    let _ = app_for_emit.emit(
+                                        "voice:shortcut-stop",
+                                        serde_json::json!({ "source": "fn" }),
+                                    );
+                                }
                             } else {
                                 hide_voice_wake_popover(&app_for_emit);
                             }
@@ -632,6 +809,18 @@ fn install_fn_event_tap(app: tauri::AppHandle) {
                         install_fn_release_watchdog(app_for_cb.clone(), prev_for_cb.clone());
                     } else {
                         dlog!("[clips-tray] Fn up — stopping voice dictation");
+                        let elapsed_since_down =
+                            tap_epoch.elapsed().as_millis() as u64
+                                - fn_down_at_for_cb.load(Ordering::SeqCst);
+                        fn_down_at_for_cb.store(0, Ordering::SeqCst);
+                        if elapsed_since_down < 80 {
+                            // Fast tap: the delayed-start thread (still
+                            // pending) will emit start+stop together once it
+                            // wakes — see the fast_tap branch above. Emitting
+                            // our own stop now would race ahead of a start
+                            // that hasn't happened yet.
+                            return CallbackResult::Keep;
+                        }
                         let _ = app_for_cb.emit(
                             "voice:shortcut-stop",
                             serde_json::json!({ "source": "fn" }),
@@ -727,7 +916,7 @@ fn install_fn_release_watchdog(
             if !current_fn_flag_down() {
                 if prev_down.swap(false, Ordering::SeqCst) {
                     dlog!("[clips-tray] Fn up missed — synthesizing voice stop");
-                    set_dictation_active(&app, false);
+                    set_dictation_active_and_sync_escape(&app, false);
                     let _ = app.emit(
                         "voice:shortcut-stop",
                         serde_json::json!({ "source": "fn", "synthetic": true }),

package/corpus/templates/clips/desktop/src-tauri/src/silence_detector.rs

@@ -307,12 +307,25 @@ fn install_call_ended_watcher(app: &AppHandle, threshold_ms: u64) {
             // If it was front during this session and has been background for
             // > threshold_ms, fire `meetings:call-ended`. On the first session
             // tick we just record state and wait.
-            let known_vc_bundles: &[&str] = &[
+            // Native VC clients are a strong signal on their own: a Zoom/Teams
+            // window backgrounding for a while means the user almost
+            // certainly left the call. Generic browsers are NOT included
+            // here — Meet/Zoom-web/Teams-web all run inside Chrome/Arc, so
+            // "Chrome was frontmost" just means the user was in some tab, not
+            // that any call ended. Browser-hosted calls fall back to
+            // `strong_vc_bundles` below only when corroborated by the
+            // mic+system silence tracking this same detector already keeps
+            // (DetectorInner.mic/system), never on the frontmost-app poll
+            // alone — matching the granola-ux.md "transcript length +
+            // calendar times" model instead of raw frontmost tracking.
+            let strong_vc_bundles: &[&str] = &[
                 "us.zoom.xos",
                 "us.zoom.ZoomClips",
                 "com.microsoft.teams2",
                 "com.microsoft.teams",
-                "com.google.Chrome", // meet runs inside Chrome; weak signal
+            ];
+            let generic_browser_bundles: &[&str] = &[
+                "com.google.Chrome",
                 "company.thebrowser.Browser", // Arc
             ];
             let mut ever_seen_front = false;
@@ -329,19 +342,35 @@ fn install_call_ended_watcher(app: &AppHandle, threshold_ms: u64) {
                     continue;
                 }
                 let front = frontmost_bundle_id();
-                let is_vc = front
+                let is_strong_vc = front
+                    .as_ref()
+                    .map(|b| strong_vc_bundles.iter().any(|k| k == b))
+                    .unwrap_or(false);
+                let is_generic_browser = front
                     .as_ref()
-                    .map(|b| known_vc_bundles.iter().any(|k| k == b))
+                    .map(|b| generic_browser_bundles.iter().any(|k| k == b))
                     .unwrap_or(false);
-                if is_vc {
+                if is_strong_vc || is_generic_browser {
                     ever_seen_front = true;
                     last_front_at = Some(Instant::now());
                 }
                 if ever_seen_front && !fired {
                     if let Some(t) = last_front_at {
-                        if Instant::now().duration_since(t).as_millis() as u64 >= threshold_ms {
-                            let _ = app.emit("meetings:call-ended", ());
-                            fired = true;
+                        let backgrounded_ms = Instant::now().duration_since(t).as_millis() as u64;
+                        if backgrounded_ms >= threshold_ms {
+                            // Require audio corroboration before auto-stopping
+                            // for a generic browser: the frontmost-app signal
+                            // alone is too weak (backgrounding Chrome to check
+                            // email doesn't mean the Meet tab's call ended).
+                            // Native VC clients keep the fast, uncorroborated
+                            // path since a dedicated conferencing app losing
+                            // focus for minutes is a much stronger signal.
+                            let audio_corroborates =
+                                !is_generic_browser || audio_recently_silent(&state, threshold_ms);
+                            if audio_corroborates {
+                                let _ = app.emit("meetings:call-ended", ());
+                                fired = true;
+                            }
                         }
                     }
                 }
@@ -353,6 +382,33 @@ fn install_call_ended_watcher(app: &AppHandle, threshold_ms: u64) {
 #[cfg(not(target_os = "macos"))]
 fn install_call_ended_watcher(_app: &AppHandle, _threshold_ms: u64) {}
 
+/// Corroboration check for the generic-browser call-ended signal: true only
+/// if BOTH mic and system audio have been quiet for at least `threshold_ms`.
+/// Reuses the same per-source `last_loud_at` tracking the silence-stop
+/// supervisor already maintains — no new subsystem, no new lock ordering
+/// beyond the existing `DetectorState.inner` mutex. Missing/never-seen
+/// sources count as "not corroborating" (conservative — when in doubt, keep
+/// recording rather than auto-stop).
+#[cfg(target_os = "macos")]
+fn audio_recently_silent(state: &tauri::State<'_, DetectorState>, threshold_ms: u64) -> bool {
+    let Ok(g) = state.inner.lock() else {
+        return false;
+    };
+    let window = Duration::from_millis(threshold_ms);
+    let now = Instant::now();
+    let mic_silent = g
+        .mic
+        .as_ref()
+        .map(|s| now.duration_since(s.last_loud_at) >= window)
+        .unwrap_or(false);
+    let system_silent = g
+        .system
+        .as_ref()
+        .map(|s| now.duration_since(s.last_loud_at) >= window)
+        .unwrap_or(false);
+    mic_silent && system_silent
+}
+
 #[cfg(target_os = "macos")]
 fn frontmost_bundle_id() -> Option<String> {
     // Lightweight shell-out to avoid extra crates: AppleScript via `osascript`

package/corpus/templates/clips/desktop/src-tauri/src/state.rs

@@ -28,8 +28,9 @@ pub struct PopoverShownAt(pub Mutex<Option<Instant>>);
 #[derive(Default)]
 pub struct RecordingActive(pub Mutex<bool>);
 
-#[allow(dead_code)]
-/// Whether a meeting recording is in progress.
+/// Whether a meeting recording is in progress. Set from JS via
+/// `set_meeting_active`. Gates the `ExitRequested` quit-teardown handler in
+/// `lib.rs` so quitting stays instant when no meeting is active.
 #[derive(Default)]
 pub struct MeetingActive(pub Mutex<bool>);
 

package/corpus/templates/clips/desktop/src-tauri/src/system_audio.rs

@@ -22,6 +22,7 @@
 //! | `system_audio_version_status`      | Report macOS SCK-audio support.          |
 //! | `system_audio_open_privacy_settings`| Open the Screen Recording privacy pane.  |
 //! | `audio_transcription_start`        | Start the Whisper mic + system capture.  |
+//! | `audio_transcription_reset_timeline`| Rebase transcript timestamps to now.     |
 //! | `audio_transcription_stop`         | Stop the capture.                         |
 //!
 //! `start_raw_system_capture` (in the `macos` submodule) is the capture entry
@@ -113,6 +114,8 @@ pub async fn audio_transcription_start(
     mic_device_id: Option<String>,
     mic_device_label: Option<String>,
     capture_system: Option<bool>,
+    voice_processing: Option<bool>,
+    owner: Option<String>,
 ) -> Result<(), String> {
     let _ = meeting_id;
     crate::whisper_speech::whisper_transcription_start(
@@ -121,6 +124,8 @@ pub async fn audio_transcription_start(
         mic_device_id,
         mic_device_label,
         capture_system.unwrap_or(true),
+        voice_processing.unwrap_or(true),
+        owner,
     )
     .await
 }
@@ -130,6 +135,11 @@ pub async fn audio_transcription_stop(app: AppHandle) -> Result<(), String> {
     crate::whisper_speech::whisper_transcription_stop(app).await
 }
 
+#[tauri::command]
+pub async fn audio_transcription_reset_timeline() -> Result<(), String> {
+    crate::whisper_speech::whisper_transcription_reset_timeline().await
+}
+
 #[cfg(target_os = "macos")]
 pub(crate) mod macos {
     use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};

package/corpus/templates/clips/desktop/src-tauri/src/tray.rs

@@ -33,6 +33,21 @@ fn build_menu_with_meetings(
         recording_active,
         None::<&str>,
     )?;
+    let has_last_dictation = app
+        .try_state::<crate::state::LastTranscript>()
+        .and_then(|s| {
+            s.0.lock()
+                .ok()
+                .map(|g| g.as_deref().is_some_and(|t| !t.trim().is_empty()))
+        })
+        .unwrap_or(false);
+    let paste_last_dictation_item = MenuItem::with_id(
+        app,
+        "paste-last-dictation",
+        "Paste Last Dictation",
+        has_last_dictation,
+        Some("Cmd+Ctrl+V"),
+    )?;
     let guides = crate::config::feature_config(app).region_guides;
     let region_guides_item = CheckMenuItem::with_id(
         app,
@@ -53,6 +68,7 @@ fn build_menu_with_meetings(
             &separator,
             &show_item,
             &stop_item,
+            &paste_last_dictation_item,
             &region_guides_item,
             &devtools_item,
             &quit_item,
@@ -118,6 +134,14 @@ pub fn build_tray(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
                 "stop" => {
                     let _ = app.emit("clips:recorder-stop", ());
                 }
+                "paste-last-dictation" => {
+                    let app = app.clone();
+                    tauri::async_runtime::spawn(async move {
+                        if let Err(err) = crate::clips::paste_last_dictation(app).await {
+                            eprintln!("[clips-tray] paste_last_dictation (tray) failed: {err}");
+                        }
+                    });
+                }
                 "toggle-region-guides" => {
                     let mut new_config = crate::config::feature_config(app);
                     let next_visible = !new_config.region_guides.always_visible;
@@ -148,14 +172,11 @@ pub fn build_tray(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
                     rebuild_tray_menu(app);
                 }
                 "devtools" => {
-                    #[cfg(debug_assertions)]
-                    {
-                        if let Some(w) = app.get_webview_window("popover") {
-                            if w.is_devtools_open() {
-                                w.close_devtools();
-                            } else {
-                                w.open_devtools();
-                            }
+                    if let Some(w) = app.get_webview_window("popover") {
+                        if w.is_devtools_open() {
+                            w.close_devtools();
+                        } else {
+                            w.open_devtools();
                         }
                     }
                 }