@agent-native/core 0.114.6 → 0.114.8

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

@@ -0,0 +1,408 @@
+//! Local post-segment audio transcription for Screen Memory.
+//!
+//! MP4 audio is decoded directly into bounded memory, transcribed through the
+//! process-wide Whisper context, and returned as typed rows. This module does
+//! not persist PCM and never logs transcript text; the capture worker owns the
+//! adjacent JSONL/status files.
+#![allow(dead_code)]
+
+use chrono::{DateTime, Duration, Utc};
+use serde::{Deserialize, Serialize};
+use std::io::Read;
+use std::path::Path;
+use std::process::{Command, Stdio};
+use tauri::AppHandle;
+
+pub const TRANSCRIPT_SCHEMA_VERSION: u32 = 1;
+pub const MAX_INPUT_BYTES: u64 = 2 * 1024 * 1024 * 1024;
+pub const MAX_DURATION_MS: u64 = 30 * 60 * 1_000;
+pub const MAX_TRANSCRIPT_ROWS: usize = 2_048;
+pub const MAX_ROW_TEXT_BYTES: usize = 8 * 1024;
+pub const MAX_TOTAL_TEXT_BYTES: usize = 1024 * 1024;
+const SAMPLE_RATE: usize = 16_000;
+const BYTES_PER_SAMPLE: usize = std::mem::size_of::<f32>();
+const FFMPEG_CANDIDATE_PATHS: &[&str] = &[
+    "ffmpeg",
+    "/opt/homebrew/bin/ffmpeg",
+    "/usr/local/bin/ffmpeg",
+    "/opt/local/bin/ffmpeg",
+];
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum ScreenMemoryTranscriptState {
+    Pending,
+    Transcribing,
+    Ready,
+    Failed,
+    Skipped,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScreenMemoryTranscriptStatus {
+    pub state: ScreenMemoryTranscriptState,
+    pub row_count: usize,
+    pub started_at: Option<String>,
+    pub finished_at: Option<String>,
+    pub error: Option<String>,
+}
+
+impl ScreenMemoryTranscriptStatus {
+    pub fn pending() -> Self {
+        Self::new(ScreenMemoryTranscriptState::Pending)
+    }
+
+    pub fn transcribing(started_at: impl Into<String>) -> Self {
+        Self {
+            started_at: Some(started_at.into()),
+            ..Self::new(ScreenMemoryTranscriptState::Transcribing)
+        }
+    }
+
+    pub fn ready(
+        row_count: usize,
+        started_at: impl Into<String>,
+        finished_at: impl Into<String>,
+    ) -> Self {
+        Self {
+            state: ScreenMemoryTranscriptState::Ready,
+            row_count: row_count.min(MAX_TRANSCRIPT_ROWS),
+            started_at: Some(started_at.into()),
+            finished_at: Some(finished_at.into()),
+            error: None,
+        }
+    }
+
+    pub fn failed(
+        started_at: impl Into<String>,
+        finished_at: impl Into<String>,
+        error: impl AsRef<str>,
+    ) -> Self {
+        Self {
+            state: ScreenMemoryTranscriptState::Failed,
+            row_count: 0,
+            started_at: Some(started_at.into()),
+            finished_at: Some(finished_at.into()),
+            error: Some(bounded_text(error.as_ref(), MAX_ROW_TEXT_BYTES)),
+        }
+    }
+
+    pub fn skipped(finished_at: impl Into<String>) -> Self {
+        Self {
+            finished_at: Some(finished_at.into()),
+            ..Self::new(ScreenMemoryTranscriptState::Skipped)
+        }
+    }
+
+    fn new(state: ScreenMemoryTranscriptState) -> Self {
+        Self {
+            state,
+            row_count: 0,
+            started_at: None,
+            finished_at: None,
+            error: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScreenMemoryTranscriptRow {
+    pub schema_version: u32,
+    pub segment_id: String,
+    pub source: String,
+    pub captured_at: String,
+    pub start_ms: u64,
+    pub end_ms: u64,
+    pub text: String,
+}
+
+/// The exact background-worker entry point intended for `screen_memory.rs`.
+/// `duration_ms` comes from finalized segment metadata and is checked before
+/// ffmpeg is started. `source` should describe the recorded audio track (for
+/// example `mixed-audio`); rows retain that source verbatim after validation.
+pub fn transcribe_segment(
+    app: &AppHandle,
+    segment_path: &Path,
+    segment_id: &str,
+    source: &str,
+    audio_stream_index: usize,
+    segment_started_at: DateTime<Utc>,
+    duration_ms: u64,
+    language: Option<&str>,
+) -> Result<Vec<ScreenMemoryTranscriptRow>, String> {
+    validate_request(segment_path, segment_id, source, duration_ms)?;
+    let samples = decode_audio(segment_path, audio_stream_index, duration_ms)?;
+    let raw = crate::whisper_speech::transcribe_offline_file_samples(app, &samples, language)?;
+    Ok(clean_rows(
+        segment_id,
+        source,
+        segment_started_at,
+        duration_ms,
+        raw,
+    ))
+}
+
+fn validate_request(
+    segment_path: &Path,
+    segment_id: &str,
+    source: &str,
+    duration_ms: u64,
+) -> Result<(), String> {
+    if segment_id.trim().is_empty() || segment_id.len() > 255 {
+        return Err("invalid transcript segment id".to_owned());
+    }
+    if source.trim().is_empty() || source.len() > 128 {
+        return Err("invalid transcript source".to_owned());
+    }
+    if duration_ms == 0 || duration_ms > MAX_DURATION_MS {
+        return Err(format!(
+            "transcript duration must be between 1 and {MAX_DURATION_MS} ms"
+        ));
+    }
+    let metadata = std::fs::metadata(segment_path)
+        .map_err(|e| format!("transcript input unavailable: {e}"))?;
+    if !metadata.is_file() || metadata.len() == 0 || metadata.len() > MAX_INPUT_BYTES {
+        return Err("transcript input size is outside the allowed bounds".to_owned());
+    }
+    Ok(())
+}
+
+fn decode_audio(
+    segment_path: &Path,
+    audio_stream_index: usize,
+    duration_ms: u64,
+) -> Result<Vec<f32>, String> {
+    let ffmpeg = resolve_ffmpeg_path()
+        .ok_or_else(|| "ffmpeg is required for local segment transcription".to_owned())?;
+    let max_samples = ((duration_ms as usize)
+        .saturating_mul(SAMPLE_RATE)
+        .saturating_add(999))
+        / 1_000;
+    let max_bytes = max_samples.saturating_mul(BYTES_PER_SAMPLE);
+    let duration_seconds = format!("{:.3}", duration_ms as f64 / 1_000.0);
+    let audio_map = format!("0:a:{audio_stream_index}?");
+    let mut child = Command::new(ffmpeg)
+        .args(["-v", "error", "-nostdin", "-i"])
+        .arg(segment_path)
+        .args(["-map", &audio_map, "-vn", "-t", &duration_seconds])
+        .args(["-ac", "1", "-ar", "16000", "-f", "f32le", "pipe:1"])
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .spawn()
+        .map_err(|e| format!("ffmpeg audio decode spawn failed: {e}"))?;
+    let mut bytes = Vec::with_capacity(max_bytes.min(8 * 1024 * 1024));
+    child
+        .stdout
+        .take()
+        .ok_or_else(|| "ffmpeg audio decode stdout unavailable".to_owned())?
+        .take((max_bytes as u64).saturating_add(1))
+        .read_to_end(&mut bytes)
+        .map_err(|e| format!("ffmpeg audio decode read failed: {e}"))?;
+    if bytes.len() > max_bytes {
+        let _ = child.kill();
+        let _ = child.wait();
+        return Err("decoded audio exceeded the declared segment duration".to_owned());
+    }
+    let status = child
+        .wait()
+        .map_err(|e| format!("ffmpeg audio decode wait failed: {e}"))?;
+    if !status.success() {
+        return Err("ffmpeg could not decode segment audio".to_owned());
+    }
+    if bytes.is_empty() {
+        return Err("segment has no decodable audio track".to_owned());
+    }
+    if bytes.len() % BYTES_PER_SAMPLE != 0 {
+        return Err("ffmpeg returned malformed PCM audio".to_owned());
+    }
+    let samples = bytes
+        .chunks_exact(BYTES_PER_SAMPLE)
+        .map(|chunk| f32::from_le_bytes(chunk.try_into().expect("four-byte PCM chunk")))
+        .collect::<Vec<_>>();
+    if samples.iter().any(|sample| !sample.is_finite()) {
+        return Err("ffmpeg returned invalid PCM audio".to_owned());
+    }
+    Ok(samples)
+}
+
+fn clean_rows(
+    segment_id: &str,
+    source: &str,
+    segment_started_at: DateTime<Utc>,
+    duration_ms: u64,
+    raw: impl IntoIterator<Item = crate::whisper_speech::OfflineTranscriptSegment>,
+) -> Vec<ScreenMemoryTranscriptRow> {
+    let mut total_text_bytes = 0usize;
+    raw.into_iter()
+        .filter_map(|segment| {
+            let text = clean_text(&segment.text)?;
+            let remaining = MAX_TOTAL_TEXT_BYTES.saturating_sub(total_text_bytes);
+            if remaining == 0 {
+                return None;
+            }
+            let text = bounded_text(&text, MAX_ROW_TEXT_BYTES.min(remaining));
+            if text.is_empty() {
+                return None;
+            }
+            total_text_bytes = total_text_bytes.saturating_add(text.len());
+            let start_ms = segment.start_ms.max(0) as u64;
+            let end_ms = segment.end_ms.max(segment.start_ms).max(0) as u64;
+            Some(ScreenMemoryTranscriptRow {
+                schema_version: TRANSCRIPT_SCHEMA_VERSION,
+                segment_id: segment_id.to_owned(),
+                source: source.to_owned(),
+                captured_at: (segment_started_at
+                    + Duration::milliseconds(start_ms.min(duration_ms) as i64))
+                .to_rfc3339(),
+                start_ms: start_ms.min(duration_ms),
+                end_ms: end_ms.min(duration_ms),
+                text,
+            })
+        })
+        .filter(|row| row.end_ms > row.start_ms)
+        .take(MAX_TRANSCRIPT_ROWS)
+        .collect()
+}
+
+fn clean_text(text: &str) -> Option<String> {
+    let trimmed = text.trim();
+    if trimmed.is_empty() || !trimmed.chars().any(char::is_alphanumeric) {
+        return None;
+    }
+    let normalized = trimmed
+        .trim_matches(|character: char| !character.is_alphanumeric() && character != '_')
+        .to_ascii_lowercase();
+    if matches!(
+        normalized.as_str(),
+        "blank_audio" | "silence" | "music" | "no speech"
+    ) {
+        return None;
+    }
+    if (trimmed.starts_with('[') && trimmed.ends_with(']'))
+        || (trimmed.starts_with('(') && trimmed.ends_with(')'))
+    {
+        return None;
+    }
+    Some(trimmed.to_owned())
+}
+
+fn bounded_text(text: &str, max_bytes: usize) -> String {
+    if text.len() <= max_bytes {
+        return text.to_owned();
+    }
+    let mut end = max_bytes;
+    while end > 0 && !text.is_char_boundary(end) {
+        end -= 1;
+    }
+    text[..end].to_owned()
+}
+
+fn resolve_ffmpeg_path() -> Option<String> {
+    if let Ok(path) = std::env::var("CLIPS_FFMPEG_PATH") {
+        let trimmed = path.trim();
+        if !trimmed.is_empty() && command_available(trimmed) {
+            return Some(trimmed.to_owned());
+        }
+    }
+    FFMPEG_CANDIDATE_PATHS
+        .iter()
+        .copied()
+        .find(|candidate| command_available(candidate))
+        .map(str::to_owned)
+}
+
+fn command_available(command: &str) -> bool {
+    Command::new(command)
+        .arg("-version")
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .map(|status| status.success())
+        .unwrap_or(false)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::whisper_speech::OfflineTranscriptSegment;
+
+    fn segment(start_ms: i64, end_ms: i64, text: impl Into<String>) -> OfflineTranscriptSegment {
+        OfflineTranscriptSegment {
+            start_ms,
+            end_ms,
+            text: text.into(),
+        }
+    }
+
+    #[test]
+    fn rejects_unbounded_requests_before_decode() {
+        let path = Path::new("does-not-matter.mp4");
+        assert!(validate_request(path, "segment", "mixed-audio", 0).is_err());
+        assert!(validate_request(path, "segment", "mixed-audio", MAX_DURATION_MS + 1).is_err());
+        assert!(validate_request(path, "", "mixed-audio", 1).is_err());
+        assert!(validate_request(path, "segment", "", 1).is_err());
+    }
+
+    #[test]
+    fn cleans_rows_and_rejects_silence_placeholders() {
+        let rows = clean_rows(
+            "segment-1",
+            "mixed-audio",
+            "2026-07-14T12:00:00Z".parse().unwrap(),
+            2_000,
+            [
+                segment(0, 250, " [BLANK_AUDIO]. "),
+                segment(250, 500, "(silence)"),
+                segment(-50, 750, " hello there "),
+                segment(1_900, 2_500, "last words"),
+            ],
+        );
+        assert_eq!(rows.len(), 2);
+        assert_eq!(rows[0].text, "hello there");
+        assert_eq!(rows[0].captured_at, "2026-07-14T12:00:00+00:00");
+        assert_eq!((rows[0].start_ms, rows[0].end_ms), (0, 750));
+        assert_eq!(rows[1].source, "mixed-audio");
+        assert_eq!((rows[1].start_ms, rows[1].end_ms), (1_900, 2_000));
+        assert_eq!(rows[1].captured_at, "2026-07-14T12:00:01.900+00:00");
+    }
+
+    #[test]
+    fn bounds_unicode_row_and_total_output() {
+        let text = "é".repeat(MAX_ROW_TEXT_BYTES);
+        let rows = clean_rows(
+            "segment-1",
+            "mixed-audio",
+            "2026-07-14T12:00:00Z".parse().unwrap(),
+            MAX_DURATION_MS,
+            (0..MAX_TRANSCRIPT_ROWS + 10)
+                .map(|index| segment(index as i64, index as i64 + 1, text.clone())),
+        );
+        assert!(rows.len() <= MAX_TRANSCRIPT_ROWS);
+        assert!(rows.iter().all(|row| row.text.len() <= MAX_ROW_TEXT_BYTES));
+        assert!(rows.iter().map(|row| row.text.len()).sum::<usize>() <= MAX_TOTAL_TEXT_BYTES);
+        assert!(rows
+            .iter()
+            .all(|row| row.text.is_char_boundary(row.text.len())));
+    }
+
+    #[test]
+    fn status_helpers_have_stable_lifecycle_fields() {
+        assert_eq!(
+            ScreenMemoryTranscriptStatus::pending().state,
+            ScreenMemoryTranscriptState::Pending
+        );
+        let active = ScreenMemoryTranscriptStatus::transcribing("start");
+        assert_eq!(active.started_at.as_deref(), Some("start"));
+        let ready = ScreenMemoryTranscriptStatus::ready(MAX_TRANSCRIPT_ROWS + 1, "start", "end");
+        assert_eq!(ready.row_count, MAX_TRANSCRIPT_ROWS);
+        assert_eq!(ready.finished_at.as_deref(), Some("end"));
+        let failed = ScreenMemoryTranscriptStatus::failed("start", "end", "x".repeat(20_000));
+        assert_eq!(failed.error.unwrap().len(), MAX_ROW_TEXT_BYTES);
+        assert_eq!(
+            ScreenMemoryTranscriptStatus::skipped("end").state,
+            ScreenMemoryTranscriptState::Skipped
+        );
+    }
+}

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

@@ -1,12 +1,12 @@
 use std::str::FromStr;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Mutex, OnceLock};
 use std::thread;
 use std::time::Duration;
 use tauri::{AppHandle, Emitter, Listener, Manager, PhysicalPosition, PhysicalSize};
 use tauri_plugin_global_shortcut::{Code, GlobalShortcutExt, Modifiers, Shortcut};
 
-use crate::clips::{remember_voice_target, toggle_popover};
+use crate::clips::{force_show_popover, remember_voice_target, toggle_popover};
 use crate::dlog;
 use crate::state::{DictationActive, VoiceWakePopover};
 use crate::util::{
@@ -33,6 +33,8 @@ 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);
+static COUNTDOWN_SHORTCUTS_GENERATION: AtomicU64 = AtomicU64::new(0);
+static COUNTDOWN_SHORTCUTS_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
 // 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
@@ -324,54 +326,130 @@ fn sync_dictation_escape_shortcut(app: AppHandle, active: bool) {
     });
 }
 
-pub fn install_countdown_shortcut_handler(app: &tauri::App) {
-    let handle = app.handle().clone();
-    app.listen("clips:countdown-shortcuts-active", move |event| {
-        let payload = event.payload().to_string();
-        let handle = handle.clone();
-        let active: bool = serde_json::from_str(&payload).unwrap_or(false);
-        set_countdown_shortcuts_active(handle, active);
-    });
-}
-
-fn set_countdown_shortcuts_active(app: AppHandle, active: bool) {
-    COUNTDOWN_SHORTCUTS_ACTIVE.store(active, Ordering::SeqCst);
-    thread::spawn(move || {
+/// Register the countdown shortcuts before its window becomes visible.
+///
+/// The event-driven synchronizer above intentionally hops off Carbon's hotkey
+/// callback stack, but that also means it cannot be used for the initial
+/// activation: a fast Return at the visible `3` can otherwise beat the worker
+/// thread and leave the recorder waiting for the full timer. The countdown
+/// command awaits this worker before showing the window, preserving the
+/// non-reentrant teardown path while making the first visible frame actionable.
+pub(crate) async fn prepare_countdown_shortcuts(app: AppHandle) -> Result<u64, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let _guard = COUNTDOWN_SHORTCUTS_LOCK
+            .get_or_init(|| Mutex::new(()))
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
+        let generation = COUNTDOWN_SHORTCUTS_GENERATION.fetch_add(1, Ordering::SeqCst) + 1;
+        COUNTDOWN_SHORTCUTS_ACTIVE.store(true, Ordering::SeqCst);
         let gs = app.global_shortcut();
-        let escape = escape_shortcut();
-        let enter = enter_shortcut();
-        let numpad_enter = numpad_enter_shortcut();
-        if active {
-            for shortcut in [escape, enter, numpad_enter] {
-                if !gs.is_registered(shortcut) {
-                    if let Err(err) = gs.register(shortcut) {
-                        eprintln!("[clips-tray] failed to register countdown shortcut: {err}");
+        let mut newly_registered = Vec::new();
+        for shortcut in [escape_shortcut(), enter_shortcut(), numpad_enter_shortcut()] {
+            if !gs.is_registered(shortcut) {
+                if let Err(error) = gs.register(shortcut) {
+                    for registered in newly_registered {
+                        let _ = gs.unregister(registered);
                     }
+                    COUNTDOWN_SHORTCUTS_ACTIVE.store(false, Ordering::SeqCst);
+                    return Err(format!("failed to register countdown shortcut: {error}"));
                 }
+                newly_registered.push(shortcut);
             }
-            return;
         }
+        Ok::<u64, String>(generation)
+    })
+    .await
+    .map_err(|error| format!("countdown shortcut worker stopped unexpectedly: {error}"))?
+}
 
-        for shortcut in [enter, numpad_enter] {
+/// Tear down only the countdown generation that the caller prepared. A late
+/// cleanup from an older overlay must not unregister Return beneath the next
+/// visible countdown.
+pub(crate) async fn finish_countdown_shortcuts(
+    app: AppHandle,
+    generation: u64,
+) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let _guard = COUNTDOWN_SHORTCUTS_LOCK
+            .get_or_init(|| Mutex::new(()))
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
+        if COUNTDOWN_SHORTCUTS_GENERATION.load(Ordering::SeqCst) != generation {
+            return;
+        }
+        COUNTDOWN_SHORTCUTS_ACTIVE.store(false, Ordering::SeqCst);
+        let gs = app.global_shortcut();
+        for shortcut in [enter_shortcut(), numpad_enter_shortcut()] {
             if gs.is_registered(shortcut) {
                 let _ = gs.unregister(shortcut);
             }
         }
+        let escape = escape_shortcut();
         if !POPOVER_DISMISS_SHORTCUT_ACTIVE.load(Ordering::SeqCst)
             && !DICTATION_ESCAPE_SHORTCUT_ACTIVE.load(Ordering::SeqCst)
             && gs.is_registered(escape)
         {
             let _ = gs.unregister(escape);
         }
+    })
+    .await
+    .map_err(|error| format!("countdown shortcut cleanup worker stopped unexpectedly: {error}"))
+}
+
+/// Observe key-down events only while Clips itself is the active application.
+/// AppKit local monitors need no Input Monitoring permission and never receive
+/// keystrokes destined for another app. The active-generation gate keeps this
+/// listener inert outside the three-second countdown.
+#[cfg(target_os = "macos")]
+pub fn install_countdown_local_key_monitor(app: &tauri::App) {
+    use std::ptr::NonNull;
+
+    use block2::RcBlock;
+    use objc2_app_kit::{NSEvent, NSEventMask};
+
+    let app = app.handle().clone();
+    let handler = RcBlock::new(move |event: NonNull<NSEvent>| -> *mut NSEvent {
+        if COUNTDOWN_SHORTCUTS_ACTIVE.load(Ordering::SeqCst) {
+            let key_code = unsafe { event.as_ref().keyCode() };
+            let countdown_event = match key_code {
+                36 | 76 => Some("clips:countdown-done"),
+                53 => Some("clips:countdown-cancel"),
+                _ => None,
+            };
+            if let Some(countdown_event) = countdown_event {
+                let app = app.clone();
+                thread::spawn(move || finish_countdown_from_shortcut(&app, countdown_event));
+            }
+        }
+        event.as_ptr()
     });
+    let monitor = unsafe {
+        NSEvent::addLocalMonitorForEventsMatchingMask_handler(NSEventMask::KeyDown, &handler)
+    };
+    if monitor.is_none() {
+        eprintln!("[clips-tray] failed to install app-local countdown key monitor");
+    }
 }
 
+#[cfg(not(target_os = "macos"))]
+pub fn install_countdown_local_key_monitor(_app: &tauri::App) {}
+
 fn finish_countdown_from_shortcut(app: &AppHandle, event: &'static str) {
-    let _ = app.emit(event, ());
+    dlog!("[clips-tray] countdown shortcut accepted: {event}");
+    let cause = if event == "clips:countdown-cancel" {
+        "escape"
+    } else {
+        "return"
+    };
+    let _ = app.emit(event, serde_json::json!({ "cause": cause }));
     if let Some(window) = app.get_webview_window("countdown") {
         let _ = window.close();
     }
-    set_countdown_shortcuts_active(app.clone(), false);
+    let app = app.clone();
+    let generation = COUNTDOWN_SHORTCUTS_GENERATION.load(Ordering::SeqCst);
+    tauri::async_runtime::spawn(async move {
+        let _ = finish_countdown_shortcuts(app, generation).await;
+    });
 }
 
 /// Build the global shortcut plugin with its handler. Called from `run()` to
@@ -411,7 +489,11 @@ pub fn build_shortcut_plugin() -> tauri_plugin_global_shortcut::Builder<tauri::W
                 finish_countdown_from_shortcut(app, event);
                 return;
             }
-            set_countdown_shortcuts_active(app.clone(), false);
+            let app = app.clone();
+            let generation = COUNTDOWN_SHORTCUTS_GENERATION.load(Ordering::SeqCst);
+            tauri::async_runtime::spawn(async move {
+                let _ = finish_countdown_shortcuts(app, generation).await;
+            });
         }
         if is_escape {
             if event.state() != tauri_plugin_global_shortcut::ShortcutState::Pressed {
@@ -509,12 +591,11 @@ pub fn build_shortcut_plugin() -> tauri_plugin_global_shortcut::Builder<tauri::W
             return;
         }
         if is_cmd || is_ctrl || is_custom_popover {
-            // Loom-style: if a recording is already active, the
-            // global shortcut stops it rather than re-opening the
-            // popover. Keeps parity with the tray-icon click
-            // behaviour in `on_tray_icon_event`.
+            // The dedicated record shortcut remains the fast start/stop
+            // gesture. The separate Open Clips shortcut follows the app-icon
+            // behavior: it opens the popover and never stops capture.
             if is_recording_active(app) && !is_meeting_active(app) {
-                let _ = app.emit("clips:recorder-stop", ());
+                force_show_popover(app);
             } else {
                 toggle_popover(app);
             }

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

@@ -23,8 +23,8 @@ pub struct TrayMeetings(pub Mutex<Vec<MeetingItem>>);
 pub struct PopoverShownAt(pub Mutex<Option<Instant>>);
 
 /// Whether a recording is currently in progress. Set from JS via
-/// `set_recording_state`. Used to re-purpose the tray icon click as a
-/// stop-recording shortcut while recording, matching Loom.
+/// `set_recording_state`. Keeps the parked popover reachable while recording
+/// and enables the explicit Stop item in the tray menu.
 #[derive(Default)]
 pub struct RecordingActive(pub Mutex<bool>);
 

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

@@ -119,7 +119,8 @@ pub async fn audio_transcription_start(
     owner: Option<String>,
 ) -> Result<(), String> {
     let _ = meeting_id;
-    crate::whisper_speech::whisper_transcription_start(
+    crate::logfile::diagnostic("[meeting-audio] transcription engine start requested");
+    let result = crate::whisper_speech::whisper_transcription_start(
         app,
         locale,
         mic_device_id,
@@ -134,7 +135,16 @@ pub async fn audio_transcription_start(
         emit_partials.unwrap_or(true),
         owner,
     )
-    .await
+    .await;
+    if let Err(error) = &result {
+        crate::logfile::diagnostic(&format!(
+            "[meeting-audio] transcription engine start failed: {error}"
+        ));
+        eprintln!("[clips-tray] meeting transcription engine start failed: {error}");
+    } else {
+        crate::logfile::diagnostic("[meeting-audio] transcription engine started");
+    }
+    result
 }
 
 #[tauri::command]
@@ -221,7 +231,7 @@ pub(crate) mod macos {
     /// open System Settings manually).
     pub fn open_screen_recording_settings() -> Result<(), String> {
         use std::process::Command;
-        let url = "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture";
+        let url = "x-apple.systempreferences:com.apple.settings.PrivacySecurity.extension?Privacy_ScreenCapture";
         Command::new("open")
             .arg(url)
             .status()

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

@@ -227,7 +227,10 @@ pub fn build_tray(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
                     meeting_active
                 );
                 if active && !meeting_active {
-                    let _ = app.emit("clips:recorder-stop", ());
+                    // Opening Clips must never double as an implicit Stop.
+                    // Keep the recording alive and restore the parked popover;
+                    // its active-recording view exposes an explicit Stop button.
+                    force_show_popover(app);
                 } else {
                     toggle_popover(app);
                 }