@agent-native/core 0.92.12 → 0.94.0

package/corpus/templates/clips/desktop/src/overlays/recording-pill.tsx

@@ -15,6 +15,7 @@ import { emit, listen } from "@tauri-apps/api/event";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import { useCallback, useEffect, useRef, useState } from "react";
 
+import { isDirectPillClick, type ScreenPoint } from "../lib/pill-interaction";
 import { speakerFor } from "../lib/transcription-engine";
 import { LiveTranscript, type FinalLine } from "./live-transcript";
 import { PillLogo } from "./pill-logo";
@@ -83,6 +84,7 @@ export function RecordingPill() {
   const sysCanvasRef = useRef<HTMLCanvasElement | null>(null);
   const rafRef = useRef<number | null>(null);
   const stopFallbackRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const dragStartScreenPointRef = useRef<ScreenPoint | null>(null);
 
   useEffect(() => {
     const unlistens: Array<() => void> = [];
@@ -111,6 +113,7 @@ export function RecordingPill() {
         // Reset timer on new context.
         startedAtRef.current = Date.now();
         setElapsed(0);
+        setPaused(false);
         // The Rust side reuses the pill window across recordings, so the
         // component never unmounts. Reset stop state explicitly when a
         // new recording session begins, otherwise the Stop button stays
@@ -138,6 +141,21 @@ export function RecordingPill() {
         }
       }),
     );
+    trackListen(
+      listen<{ paused: boolean; elapsedMs: number }>(
+        "clips:recorder-state",
+        (ev) => {
+          // Meeting capture has its own optimistic pause state. Ordinary clips
+          // follow the recorder's authoritative broadcast so this reused pill
+          // cannot drift or emit an inverted command.
+          if (ctxRef.current.mode !== "clip") return;
+          setPaused(!!ev.payload.paused);
+          setElapsed(
+            Math.max(0, Math.floor((ev.payload.elapsedMs ?? 0) / 1000)),
+          );
+        },
+      ),
+    );
     trackListen(
       listen<{ meetingId: string; initialNotes: string }>(
         "clips:meeting-notes-init",
@@ -240,7 +258,9 @@ export function RecordingPill() {
 
   // Elapsed timer.
   useEffect(() => {
-    if (paused) return;
+    // Clip recordings already broadcast their pause-aware elapsed time every
+    // 500ms. Keep the local wall clock only for meeting mode.
+    if (paused || ctx.mode === "clip") return;
     tickRef.current = setInterval(() => {
       setElapsed(Math.floor((Date.now() - startedAtRef.current) / 1000));
     }, 500);
@@ -248,7 +268,7 @@ export function RecordingPill() {
       if (tickRef.current) clearInterval(tickRef.current);
       tickRef.current = null;
     };
-  }, [paused]);
+  }, [ctx.mode, paused]);
 
   // Dual-stream "dancing bars" meter — one discrete vertical-bar group per
   // source (Granola/Wispr-style VU meter, not a continuous waveform line).
@@ -389,7 +409,7 @@ export function RecordingPill() {
 
   async function onPauseClick() {
     const nextPaused = !paused;
-    setPaused(nextPaused);
+    if (ctxRef.current.mode === "meeting") setPaused(nextPaused);
     emit(nextPaused ? "clips:recorder-pause" : "clips:recorder-resume").catch(
       () => {},
     );
@@ -460,6 +480,7 @@ export function RecordingPill() {
     if (e.button !== 0) return;
     const target = e.target as HTMLElement;
     if (target.closest("[data-no-drag]")) return;
+    dragStartScreenPointRef.current = { x: e.screenX, y: e.screenY };
     getCurrentWindow()
       .startDragging()
       .catch((err) => {
@@ -467,6 +488,13 @@ export function RecordingPill() {
       });
   };
 
+  const handlePillMediaClick = (e: React.MouseEvent) => {
+    const start = dragStartScreenPointRef.current;
+    dragStartScreenPointRef.current = null;
+    if (!isDirectPillClick(start, { x: e.screenX, y: e.screenY })) return;
+    void toggleExpanded();
+  };
+
   const mm = String(Math.floor(elapsed / 60)).padStart(2, "0");
   const ss = String(elapsed % 60).padStart(2, "0");
   const stopLabel =
@@ -491,9 +519,7 @@ export function RecordingPill() {
         >
           <div
             className="pill-media"
-            onClick={
-              !expanded && !detached ? () => void toggleExpanded() : undefined
-            }
+            onClick={!expanded && !detached ? handlePillMediaClick : undefined}
           >
             <PillLogo className="pill-logo" />
             {hasSystemAudio ? (

package/corpus/templates/clips/desktop/src/overlays/toolbar.tsx

@@ -63,6 +63,18 @@ export function Toolbar() {
   >("ok");
   const fallbackTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
   const expandedRef = useRef(false);
+  const pauseTransitionRef = useRef<"pause" | "resume" | null>(null);
+  const pauseTransitionTimerRef = useRef<ReturnType<typeof setTimeout> | null>(
+    null,
+  );
+
+  function clearPauseTransition() {
+    pauseTransitionRef.current = null;
+    if (pauseTransitionTimerRef.current) {
+      clearTimeout(pauseTransitionTimerRef.current);
+      pauseTransitionTimerRef.current = null;
+    }
+  }
 
   useEffect(() => {
     const unlistens: Array<() => void> = [];
@@ -90,7 +102,18 @@ export function Toolbar() {
       listen<{ paused: boolean; elapsedMs: number }>(
         "clips:recorder-state",
         (ev) => {
-          setPaused(!!ev.payload.paused);
+          const nextPaused = !!ev.payload.paused;
+          const pendingTransition = pauseTransitionRef.current;
+          const transitionReached =
+            (pendingTransition === "pause" && nextPaused) ||
+            (pendingTransition === "resume" && !nextPaused);
+          // Native pause/resume can take a beat. Keep the first click's
+          // optimistic state instead of letting an in-flight timer tick briefly
+          // flip the button back and invite duplicate clicks.
+          if (!pendingTransition || transitionReached) {
+            setPaused(nextPaused);
+          }
+          if (transitionReached) clearPauseTransition();
           setElapsed(ev.payload.elapsedMs ?? 0);
         },
       ),
@@ -137,6 +160,7 @@ export function Toolbar() {
         clearTimeout(fallbackTimer.current);
         fallbackTimer.current = null;
       }
+      clearPauseTransition();
     };
   }, []);
 
@@ -183,9 +207,27 @@ export function Toolbar() {
   }
   function togglePause() {
     if (!enabled || pendingAction) return;
-    emit(paused ? "clips:recorder-resume" : "clips:recorder-pause").catch(
-      () => {},
-    );
+    const transition = paused ? "resume" : "pause";
+    clearPauseTransition();
+    pauseTransitionRef.current = transition;
+    setPaused(transition === "pause");
+    pauseTransitionTimerRef.current = setTimeout(clearPauseTransition, 3_000);
+    emit(`clips:recorder-${transition}`).catch((err) => {
+      console.error(
+        `[clips-toolbar] emit clips:recorder-${transition} failed:`,
+        err,
+      );
+      clearPauseTransition();
+      setPaused(paused);
+    });
+  }
+  function activatePauseFromPointer(e: React.PointerEvent<HTMLButtonElement>) {
+    if (e.button !== 0) return;
+    // The native toolbar resizes as the pointer enters it. Dispatch on
+    // pointer-down so that resize/focus changes cannot cancel the subsequent
+    // click, while the click handler below remains available to keyboards.
+    e.preventDefault();
+    togglePause();
   }
   function restart() {
     if (pendingAction || !enabled) return;
@@ -299,7 +341,10 @@ export function Toolbar() {
         )}
         <button
           className="toolbar-v-pause"
-          onClick={togglePause}
+          onPointerDown={activatePauseFromPointer}
+          onClick={(e) => {
+            if (e.detail === 0) togglePause();
+          }}
           disabled={!enabled || !!pendingAction}
           aria-label={paused ? "Resume" : "Pause"}
           title={

package/corpus/templates/clips/desktop/src/styles.css

@@ -2040,21 +2040,19 @@ body[data-clips-route="recording-pill"] #root {
   padding: 0 8px;
 }
 
-.pending-upload-discard {
+.pending-upload-dismiss {
   width: 28px;
   height: 28px;
-  border: 1px solid #bfdbfe;
+  border: 0;
   border-radius: var(--radius-sm);
-  background: rgba(255, 255, 255, 0.76);
-  color: #2563eb;
+  background: transparent;
+  color: #3b5f9a;
   cursor: pointer;
   display: inline-flex;
   align-items: center;
   justify-content: center;
   padding: 0;
   transition:
-    background 120ms,
-    border-color 120ms,
     color 120ms,
     opacity 120ms;
 }
@@ -2093,16 +2091,14 @@ body[data-clips-route="recording-pill"] #root {
   border-color: #93c5fd;
 }
 
-.pending-upload-discard:hover {
-  background: #fee2e2;
-  border-color: #fecaca;
-  color: #b91c1c;
+.pending-upload-dismiss:hover {
+  color: #1e3a8a;
 }
 
 .pending-upload-retry:disabled,
 .pending-upload-connect:disabled,
 .pending-upload-folder:disabled,
-.pending-upload-discard:disabled {
+.pending-upload-dismiss:disabled {
   cursor: default;
   opacity: 0.6;
 }
@@ -2288,10 +2284,8 @@ body[data-clips-route="recording-pill"] #root {
     color: #dbeafe;
   }
 
-  .pending-upload-discard {
-    background: rgba(23, 23, 23, 0.58);
-    border-color: rgba(96, 165, 250, 0.38);
-    color: #bfdbfe;
+  .pending-upload-dismiss {
+    color: #93c5fd;
   }
 
   .pending-upload-folder {
@@ -2315,10 +2309,8 @@ body[data-clips-route="recording-pill"] #root {
     border-color: rgba(147, 197, 253, 0.62);
   }
 
-  .pending-upload-discard:hover {
-    background: rgba(127, 29, 29, 0.34);
-    border-color: rgba(248, 113, 113, 0.62);
-    color: #fecaca;
+  .pending-upload-dismiss:hover {
+    color: #dbeafe;
   }
 
   .error-banner {

package/corpus/templates/clips/desktop/src-tauri/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "clips-tray"
 version = "0.1.1"
-description = "Clips — menu-bar tray app (Tauri 2)"
+description = "Clips — cross-platform tray app (Tauri 2)"
 authors = ["Clips"]
 license = "MIT"
 edition = "2021"

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

@@ -498,8 +498,8 @@ pub async fn show_finalizing(app: AppHandle) -> Result<(), String> {
     Ok(())
 }
 
-/// Close the finalizing spinner overlay. Called from the recorder stop path
-/// right after `openExternal` opens the browser to the recording URL.
+/// Close the finalizing spinner overlay after the recorder's durable
+/// backup/upload boundary settles.
 #[tauri::command]
 pub async fn hide_finalizing(app: AppHandle) -> Result<(), String> {
     if let Some(w) = app.get_webview_window(FINALIZING_LABEL) {

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

@@ -136,7 +136,8 @@ pub fn run() {
             native_screen::native_fullscreen_recording_rotate_segment,
             native_screen::native_fullscreen_pending_uploads,
             native_screen::native_fullscreen_recording_retry_upload,
-            native_screen::native_fullscreen_recording_discard_upload,
+            native_screen::native_fullscreen_recording_dismiss_upload,
+            native_screen::native_fullscreen_open_drafts_folder,
             // local-only always-on screen memory compatibility helpers
             screen_memory::screen_memory_query,
             screen_memory::screen_memory_delete_all,

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

@@ -111,6 +111,7 @@ const FFMPEG_CANDIDATE_PATHS: &[&str] = &[
     "/opt/local/bin/ffmpeg",
 ];
 const PENDING_UPLOADS_DIR: &str = "pending-recording-uploads";
+const CLIP_DRAFTS_DIR: &str = "Drafts";
 const THUMBNAIL_MIME_TYPE: &str = "image/jpeg";
 const THUMBNAIL_MAX_BYTES: u64 = 2 * 1024 * 1024;
 const THUMBNAIL_WIDTH: &str = "1280";
@@ -2103,12 +2104,60 @@ pub async fn native_fullscreen_recording_retry_upload(
 }
 
 #[tauri::command]
-pub async fn native_fullscreen_recording_discard_upload(
+pub async fn native_fullscreen_recording_dismiss_upload(
     app: AppHandle,
     recording_id: String,
-) -> Result<(), String> {
-    let saved = read_saved_recording_metadata(&app, &recording_id)?;
-    clear_saved_recording(&app, &saved)
+) -> Result<String, String> {
+    let mut saved = read_saved_recording_metadata(&app, &recording_id)?;
+    let draft_dir = clip_drafts_dir(&app)?.join(sanitize_recording_id(&recording_id));
+    std::fs::create_dir_all(&draft_dir)
+        .map_err(|e| format!("clip draft directory unavailable: {e}"))?;
+
+    let mut sources = vec![saved.file_path.clone()];
+    for segment_path in &saved.segment_paths {
+        if !sources.contains(segment_path) {
+            sources.push(segment_path.clone());
+        }
+    }
+
+    let mut moved_any = false;
+    for source in sources {
+        if !source.exists() {
+            continue;
+        }
+        if source.parent() == Some(draft_dir.as_path()) {
+            moved_any = true;
+            continue;
+        }
+        let destination = available_draft_path(&draft_dir, &source);
+        move_or_copy_file(&source, &destination)?;
+        moved_any = true;
+
+        if saved.file_path == source {
+            saved.file_path = destination.clone();
+        }
+        for segment_path in &mut saved.segment_paths {
+            if *segment_path == source {
+                *segment_path = destination.clone();
+            }
+        }
+        // Keep metadata recoverable if a later segment move fails.
+        write_saved_recording_metadata(&app, &saved)?;
+    }
+
+    if !moved_any {
+        return Err("No saved clip file was available to move into Clip Drafts.".into());
+    }
+
+    let metadata_path = saved_recording_metadata_path(&app, &saved.recording_id)?;
+    remove_saved_file(&metadata_path, "pending recording metadata")?;
+    Ok(draft_dir.to_string_lossy().to_string())
+}
+
+#[tauri::command]
+pub fn native_fullscreen_open_drafts_folder(app: AppHandle) -> Result<(), String> {
+    let dir = clip_drafts_dir(&app)?;
+    crate::clips::open_local_recording_folder(dir.to_string_lossy().to_string())
 }
 
 fn sanitize_recording_id(value: &str) -> String {
@@ -2152,6 +2201,74 @@ fn pending_uploads_dir(app: &AppHandle) -> Result<PathBuf, String> {
     Ok(dir)
 }
 
+fn clip_drafts_dir(app: &AppHandle) -> Result<PathBuf, String> {
+    let dir = app
+        .path()
+        .video_dir()
+        .map_err(|e| format!("videos directory unavailable: {e}"))?
+        .join("Clips")
+        .join(CLIP_DRAFTS_DIR);
+    std::fs::create_dir_all(&dir).map_err(|e| format!("clip drafts directory unavailable: {e}"))?;
+    Ok(dir)
+}
+
+fn available_draft_path(draft_dir: &Path, source: &Path) -> PathBuf {
+    let file_name = source
+        .file_name()
+        .and_then(|value| value.to_str())
+        .unwrap_or("clip");
+    let preferred = draft_dir.join(file_name);
+    if !preferred.exists() {
+        return preferred;
+    }
+
+    let stem = source
+        .file_stem()
+        .and_then(|value| value.to_str())
+        .unwrap_or("clip");
+    let extension = source.extension().and_then(|value| value.to_str());
+    for suffix in 2.. {
+        let candidate_name = match extension {
+            Some(extension) => format!("{stem}-{suffix}.{extension}"),
+            None => format!("{stem}-{suffix}"),
+        };
+        let candidate = draft_dir.join(candidate_name);
+        if !candidate.exists() {
+            return candidate;
+        }
+    }
+    unreachable!()
+}
+
+#[cfg(test)]
+mod clip_draft_tests {
+    use super::available_draft_path;
+
+    #[test]
+    fn keeps_existing_drafts_when_file_names_collide() {
+        let root = std::env::temp_dir().join(format!(
+            "clips-draft-path-test-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        let drafts = root.join("Drafts");
+        std::fs::create_dir_all(&drafts).unwrap();
+        std::fs::write(drafts.join("clip.mp4"), b"first").unwrap();
+        std::fs::write(drafts.join("clip-2.mp4"), b"second").unwrap();
+
+        let source = root.join("clip.mp4");
+        assert_eq!(
+            available_draft_path(&drafts, &source),
+            drafts.join("clip-3.mp4")
+        );
+
+        let _ = std::fs::remove_dir_all(root);
+    }
+}
+
 fn pending_recording_path(
     app: &AppHandle,
     safe_id: &str,

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

@@ -177,6 +177,16 @@ pub(crate) mod macos {
         }
     }
 
+    fn native_speech_voice_processing_mode(owner: SessionOwner) -> MicVoiceProcessingMode {
+        match owner {
+            // Meeting-owned native speech is the last-resort path after local
+            // Whisper capture fails. It still needs a VPIO allocation to share
+            // the mic with call apps, but must not process their live uplink.
+            SessionOwner::Meeting => MicVoiceProcessingMode::Bypassed,
+            SessionOwner::Dictation => MicVoiceProcessingMode::Disabled,
+        }
+    }
+
     /// One in-flight dictation. Holds strong references to the AppKit objects
     /// so they don't drop while the recognition task is still emitting
     /// results.
@@ -625,15 +635,30 @@ pub(crate) mod macos {
         Ok(())
     }
 
-    fn enable_voice_processing(input_node: &AVAudioInputNode) {
-        if let Err(err) = unsafe { input_node.setVoiceProcessingEnabled_error(true) } {
-            eprintln!(
-                "[whisper-mic] voice processing enable failed: {} — continuing without AEC",
-                ns_error_message(&err)
-            );
+    fn enable_voice_processing(input_node: &AVAudioInputNode) -> Result<(), String> {
+        match unsafe { input_node.setVoiceProcessingEnabled_error(true) } {
+            Ok(()) => Ok(()),
+            Err(err) => {
+                let message = ns_error_message(&err);
+                eprintln!("[whisper-mic] voice processing enable failed: {message}");
+                Err(format!("VoiceProcessingIO enable failed: {message}"))
+            }
         }
     }
 
+    fn enable_bypassed_voice_processing(input_node: &AVAudioInputNode) -> Result<(), String> {
+        enable_voice_processing(input_node)?;
+        // VPIO owns a shareable voice input path, but Clips should receive and
+        // forward the unprocessed microphone signal. This also prevents AGC
+        // from changing the level seen by the live-call app.
+        unsafe {
+            input_node.setVoiceProcessingBypassed(true);
+            input_node.setVoiceProcessingAGCEnabled(false);
+        }
+        eprintln!("[whisper-mic] VoiceProcessingIO enabled in bypass mode for meeting fallback");
+        Ok(())
+    }
+
     fn disable_voice_processing_ducking(input_node: &AVAudioInputNode) {
         // Disable other-audio ducking so the separately-captured system audio
         // isn't dropped to near-silent while the mic VPIO runs.
@@ -793,7 +818,7 @@ pub(crate) mod macos {
         let engine: Retained<AVAudioEngine> = unsafe { AVAudioEngine::new() };
         configure_engine_input_device(&engine, mic_device_id, mic_device_label)?;
         let input_node: Retained<AVAudioInputNode> = unsafe { engine.inputNode() };
-        enable_voice_processing(&input_node);
+        let _ = enable_voice_processing(&input_node);
         // Finalize input format negotiation once. Dictation-owned Whisper starts
         // can then reuse this stopped VPIO engine instead of paying the
         // per-press VoiceProcessingIO setup cost.
@@ -995,6 +1020,15 @@ pub(crate) mod macos {
             mic_device_label.as_deref(),
         )?;
         let input_node = unsafe { engine.inputNode() };
+        let native_voice_processing = native_speech_voice_processing_mode(owner);
+        let voice_processing_enabled = match native_voice_processing {
+            MicVoiceProcessingMode::Bypassed => {
+                enable_bypassed_voice_processing(&input_node)?;
+                true
+            }
+            MicVoiceProcessingMode::Enabled => enable_voice_processing(&input_node).is_ok(),
+            MicVoiceProcessingMode::Disabled => false,
+        };
         // `prepare()` must run after pinning the device so the AUHAL adopts
         // the new hardware format before we install a tap. It can throw
         // NSException when a Bluetooth device (e.g. AirPods) is mid-SCO↔A2DP
@@ -1079,6 +1113,10 @@ pub(crate) mod macos {
             msg
         })?;
 
+        if voice_processing_enabled {
+            disable_voice_processing_ducking(&input_node);
+        }
+
         // Cancel + stop flags shared with the result handler.
         let cancelled = Arc::new(AtomicBool::new(false));
         let stopped = Arc::new(AtomicBool::new(false));
@@ -1338,18 +1376,29 @@ pub(crate) mod macos {
         })
     }
 
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    pub(crate) enum MicVoiceProcessingMode {
+        Disabled,
+        Enabled,
+        /// Allocate VoiceProcessingIO so a live-call app cannot starve this
+        /// parallel mic tap, but bypass its uplink processing so Clips does not
+        /// alter the microphone signal Zoom, Meet, or Teams receives.
+        Bypassed,
+    }
+
     /// Start mic capture and forward a mono mix of every available channel to
-    /// `on_samples`. Recording transcription can disable VPIO so the tap does
-    /// not precondition the shared mic before ScreenCaptureKit opens it.
+    /// `on_samples`. Recordings can keep VPIO disabled before ScreenCaptureKit
+    /// opens the microphone; legacy meeting capture uses bypassed VPIO so it
+    /// receives buffers without processing the live-call uplink.
     pub(crate) fn start_raw_mic_capture(
         app: AppHandle,
         mic_device_id: Option<String>,
         mic_device_label: Option<String>,
-        voice_processing: bool,
+        voice_processing: MicVoiceProcessingMode,
         reuse_voice_processing_engine: bool,
         on_samples: Arc<dyn Fn(&[f32]) + Send + Sync>,
     ) -> Result<RawMicCapture, String> {
-        if voice_processing && reuse_voice_processing_engine {
+        if voice_processing == MicVoiceProcessingMode::Enabled && reuse_voice_processing_engine {
             return start_warmed_raw_mic_capture(app, mic_device_id, mic_device_label, on_samples);
         }
         clear_warmed_raw_mic_engine();
@@ -1364,11 +1413,21 @@ pub(crate) mod macos {
         )?;
         let input_node: Retained<AVAudioInputNode> = unsafe { engine.inputNode() };
 
-        if voice_processing {
-            enable_voice_processing(&input_node);
-        } else {
-            eprintln!("[whisper-mic] voice processing disabled for shared mic capture");
-        }
+        let voice_processing_enabled = match voice_processing {
+            MicVoiceProcessingMode::Bypassed => {
+                // This mode exists specifically to close the shared-mic gap.
+                // If VPIO cannot be allocated, fail loudly so the caller can
+                // move to its next transcription fallback instead of silently
+                // running the known-unreliable raw meeting tap.
+                enable_bypassed_voice_processing(&input_node)?;
+                true
+            }
+            MicVoiceProcessingMode::Enabled => enable_voice_processing(&input_node).is_ok(),
+            MicVoiceProcessingMode::Disabled => {
+                eprintln!("[whisper-mic] voice processing disabled for shared mic capture");
+                false
+            }
+        };
         // Finalize input format negotiation.
         objc2::exception::catch(std::panic::AssertUnwindSafe(|| unsafe { engine.prepare() }))
             .map_err(|e| format!("AVAudioEngine prepare threw: {e:?}"))?;
@@ -1430,7 +1489,7 @@ pub(crate) mod macos {
             unsafe { format.channelCount() }
         );
 
-        if voice_processing {
+        if voice_processing_enabled {
             disable_voice_processing_ducking(&input_node);
         }
 
@@ -1488,4 +1547,25 @@ pub(crate) mod macos {
         unsafe { session.task.cancel() };
         Ok(())
     }
+
+    #[cfg(test)]
+    mod tests {
+        use super::{native_speech_voice_processing_mode, MicVoiceProcessingMode, SessionOwner};
+
+        #[test]
+        fn meeting_native_speech_fallback_uses_bypassed_voice_processing() {
+            assert_eq!(
+                native_speech_voice_processing_mode(SessionOwner::Meeting),
+                MicVoiceProcessingMode::Bypassed
+            );
+        }
+
+        #[test]
+        fn dictation_native_speech_keeps_raw_input() {
+            assert_eq!(
+                native_speech_voice_processing_mode(SessionOwner::Dictation),
+                MicVoiceProcessingMode::Disabled
+            );
+        }
+    }
 }

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

@@ -19,14 +19,18 @@ pub fn check_permission_statuses() -> PermissionStatuses {
     }
     #[cfg(not(target_os = "macos"))]
     {
-        // TODO: implement
+        // Windows and Linux permissions are granted through the WebView and,
+        // on Linux, the XDG desktop portal. There is no reliable synchronous
+        // preflight equivalent to macOS TCC here, so report unavailable rather
+        // than claiming permissions were granted. The non-macOS UI relies on
+        // the actual media prompt and does not render these values.
         PermissionStatuses {
-            screen: true,
-            camera: true,
-            microphone: true,
-            speech: true,
-            accessibility: true,
-            input_monitoring: true,
+            screen: false,
+            camera: false,
+            microphone: false,
+            speech: false,
+            accessibility: false,
+            input_monitoring: false,
         }
     }
 }