@agent-native/core 0.176.1 → 0.176.2-nightly-20260831184159

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

@@ -2998,46 +2998,6 @@ body[data-clips-route]:not([data-clips-route="popover"]) #root {
   line-height: 1;
 }
 
-.countdown-hint {
-  position: fixed;
-  left: 50%;
-  bottom: 34px;
-  display: inline-flex;
-  align-items: center;
-  gap: 14px;
-  padding: 7px 10px;
-  border: 1px solid rgba(255, 255, 255, 0.1);
-  border-radius: var(--radius-pill);
-  background: rgba(10, 12, 16, 0.28);
-  color: rgba(255, 255, 255, 0.58);
-  font-size: 11px;
-  font-weight: 500;
-  line-height: 1;
-  transform: translateX(-50%);
-  backdrop-filter: blur(8px);
-}
-
-.countdown-hint span {
-  display: inline-flex;
-  align-items: center;
-  gap: 5px;
-  white-space: nowrap;
-}
-
-.countdown-hint kbd {
-  min-width: 24px;
-  padding: 3px 5px;
-  border: 1px solid rgba(255, 255, 255, 0.14);
-  border-radius: 5px;
-  background: rgba(255, 255, 255, 0.08);
-  color: rgba(255, 255, 255, 0.74);
-  font-family: inherit;
-  font-size: 10px;
-  font-weight: 700;
-  line-height: 1;
-  text-align: center;
-}
-
 @keyframes cd-pop {
   0% {
     transform: scale(0.6);

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

@@ -23,6 +23,34 @@
 
 @source "./**/*.{ts,tsx}";
 
+.skeleton-shimmer {
+  background-image: linear-gradient(
+    100deg,
+    transparent 30%,
+    hsl(var(--ui-foreground) / 0.043) 50%,
+    transparent 70%
+  );
+  background-position: 150% 0;
+  background-repeat: repeat;
+  background-size: 200% 100%;
+  animation: skeleton-shimmer 1.6s linear infinite;
+}
+
+@keyframes skeleton-shimmer {
+  from {
+    background-position: 150% 0;
+  }
+  to {
+    background-position: -50% 0;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .skeleton-shimmer {
+    animation: none;
+  }
+}
+
 /**
  * The parts of preflight a Tailwind-era surface cannot live without, scoped to
  * subtrees marked `data-tw-surface` so the hand-written tray surfaces keep the
@@ -352,20 +380,6 @@
   font-family: ui-monospace, "SF Mono", Menlo, monospace;
 }
 
-/* Collapsible pill segment: measured at natural width and animated between 0
-   and exact pixels (never max-width — a guessed value wastes the easing tail
-   and lands segments out of sync). Content is right-anchored so it slides as
-   a solid block instead of being wiped by the clip edge. */
-.record-pill-seg {
-  display: flex;
-  align-items: center;
-  justify-content: flex-end;
-  overflow: hidden;
-  flex: none;
-  width: 0;
-  opacity: 0;
-}
-
 .record-pill-card-in {
   animation: record-pill-card-in 220ms var(--pill-ease);
 }

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

@@ -5,7 +5,7 @@ use std::path::PathBuf;
 use std::process::Command;
 #[cfg(target_os = "macos")]
 use std::process::Stdio;
-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;
@@ -22,13 +22,16 @@ use crate::state::{
 use crate::util::{
     build_overlay_url, configure_overlay_behavior, hide_voice_wake_popover, is_recording_active,
     mark_popover_shown, present_interactive_window, raise_to_status_level, set_capture_excluded,
-    set_capture_excluded_always, set_capture_included, tray_monitor_physical_rect,
+    set_capture_excluded_always, set_capture_included, start_topmost_reassert_loop,
+    tray_monitor_physical_rect,
 };
 
 /// Native overlay windows for the recording experience. These render the same
 /// React bundle with a hash route that `main.tsx` uses to pick the component.
 const COUNTDOWN_LABEL: &str = "countdown";
 const TOOLBAR_LABEL: &str = "toolbar";
+/// Supersedes stale toolbar topmost loops after window recreation.
+static TOOLBAR_TOPMOST_GENERATION: AtomicU64 = AtomicU64::new(0);
 // Geometry of the two circular cancel/skip buttons that flank the countdown
 // number. These MUST stay in sync with the CSS in
 // `templates/clips/desktop/src/styles.css` (`.countdown-control` is 64px and
@@ -1029,7 +1032,7 @@ pub async fn show_toolbar(app: AppHandle) -> Result<(), String> {
     // lands on the tray monitor (clamped so a monitor change can't strand
     // the pill off-screen).
     let default_x: i32 = mx + (mw as i32 - w as i32) / 2;
-    let default_y: i32 = my + mh as i32 - h as i32 - (48.0 * scale).round() as i32;
+    let default_y: i32 = my + mh as i32 - h as i32 - (20.0 * scale).round() as i32;
     let (x, y) = match load_toolbar_position(&app) {
         Some((sx, sy)) => (
             sx.clamp(mx, mx + mw as i32 - w as i32),
@@ -1044,6 +1047,7 @@ pub async fn show_toolbar(app: AppHandle) -> Result<(), String> {
         set_capture_excluded(&existing);
         configure_overlay_behavior(&existing);
         raise_to_status_level(&existing);
+        start_topmost_reassert_loop(&app, TOOLBAR_LABEL, &TOOLBAR_TOPMOST_GENERATION);
         return Ok(());
     }
     #[allow(unused_mut)]
@@ -1080,19 +1084,18 @@ pub async fn show_toolbar(app: AppHandle) -> Result<(), String> {
     set_capture_excluded(&win);
     configure_overlay_behavior(&win);
     raise_to_status_level(&win);
-    // Deliberately NOT shown here. The pill owns its visibility through
-    // `toolbar_set_visible`: it stays hidden through pre-record and the
-    // countdown and appears only once the recorder reports capture live —
-    // recording controls before recording exists read as a broken state.
-    dlog!("[clips-tray] toolbar created (hidden until capture is live)");
+    // Deliberately NOT shown here. The renderer owns visibility through
+    // `toolbar_set_visible` so the window can mount in its disabled state
+    // before capture is live.
+    dlog!("[clips-tray] toolbar created (hidden until renderer is ready)");
 
     Ok(())
 }
 
 /// Show or hide the recording pill without activating it. Visibility is
-/// driven entirely by the pill renderer: hidden while the recorder is
-/// preparing or counting down, visible while capture is live or the
-/// completion card is up.
+/// driven entirely by the pill renderer: visible while the recorder is
+/// preparing, counting down, or capturing, and while the completion card is
+/// up.
 #[tauri::command]
 pub async fn toolbar_set_visible(app: AppHandle, visible: bool) -> Result<(), String> {
     let Some(win) = app.get_webview_window(TOOLBAR_LABEL) else {
@@ -1100,6 +1103,7 @@ pub async fn toolbar_set_visible(app: AppHandle, visible: bool) -> Result<(), St
     };
     if visible {
         raise_to_status_level(&win);
+        start_topmost_reassert_loop(&app, TOOLBAR_LABEL, &TOOLBAR_TOPMOST_GENERATION);
         crate::util::show_without_activation(&win);
     } else {
         let _ = win.hide();

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

@@ -325,6 +325,15 @@ pub fn run() {
                 err
             })?;
 
+            // Warm the native capture snapshot while the hidden popover
+            // webview is starting so the first recording skips that lookup.
+            tauri::async_runtime::spawn(async {
+                if let Err(err) = native_screen::native_fullscreen_prefetch_capture_content().await
+                {
+                    eprintln!("[clips-tray] startup capture prefetch failed: {err}");
+                }
+            });
+
             // clips:// deep-link handler — a web "Open desktop app" click
             // launches or focuses the running tray popover (same as a second
             // launch). macOS registers the scheme via Info.plist at build time;

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

@@ -27,7 +27,7 @@ use screencapturekit::stream::{
     configuration::SCStreamConfiguration, content_filter::SCContentFilter,
     output_trait::SCStreamOutputTrait, output_type::SCStreamOutputType, sc_stream::SCStream,
 };
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};
 
 pub(crate) const QUICKTIME_RECORDING_MIME_TYPE: &str = "video/quicktime";
 pub(crate) const MP4_RECORDING_MIME_TYPE: &str = "video/mp4";
@@ -37,6 +37,14 @@ pub(crate) const MP4_RECORDING_MIME_TYPE: &str = "video/mp4";
 /// is incomplete even when its init-segment `moov` is present, so uploading
 /// would silently publish a truncated clip.
 const CAPTURE_FINALIZE_INCOMPLETE_PREFIX: &str = "capture finalize incomplete: ";
+/// Prefix tagging `refuse_if_capture_stop_pending`'s error: a previous
+/// ScreenCaptureKit stop timed out and its detached worker is still running.
+/// Callers that otherwise treat an SCK start failure as "unavailable, fall
+/// back to `screencapture`" must check for this prefix first — falling back
+/// would start a second capture mechanism while the OS may still consider the
+/// old ScreenCaptureKit session live, the exact contention this guard exists
+/// to prevent.
+const CAPTURE_STOP_PENDING_PREFIX: &str = "capture stop pending: ";
 // Keep native chunks comfortably under serverless request/event limits.
 const GCS_CHUNK_ALIGN_BYTES: usize = 256 * 1024;
 const UPLOAD_CHUNK_BYTES: usize = 15 * GCS_CHUNK_ALIGN_BYTES; // 3.75 MiB
@@ -399,7 +407,11 @@ pub(crate) enum NativeFullscreenBackend {
     },
     #[cfg(target_os = "macos")]
     ScreenCaptureKit {
-        stream: SCStream,
+        /// Behind `Arc<Mutex>` so the stop path can bound `stop_capture()` on
+        /// a detached thread instead of blocking the caller when the SCStream
+        /// connection is interrupted and the synchronous call never returns.
+        /// See `CustomScreenCaptureKit::stream` for the same reasoning.
+        stream: Arc<Mutex<SCStream>>,
         recording: SCRecordingOutput,
         finish: Arc<RecordingFinish>,
         /// Set true once the first microphone sample buffer is delivered.
@@ -1416,7 +1428,12 @@ fn start_native_session_locked(
     ) {
         Ok(session) => session,
         Err(sck_err) => {
-            if defer_recording_output {
+            if defer_recording_output || sck_err.starts_with(CAPTURE_STOP_PENDING_PREFIX) {
+                // A pending-stop refusal means a previous ScreenCaptureKit
+                // session may still be live at the OS level. `screencapture`
+                // is not guaranteed independent of ScreenCaptureKit on every
+                // macOS version, so falling back to it here could race the
+                // same still-tearing-down session this guard exists to avoid.
                 return Err(sck_err);
             }
             if include_audio {
@@ -1750,6 +1767,8 @@ pub async fn native_fullscreen_recording_begin(
                 stream, recording, ..
             }) => {
                 stream
+                    .lock()
+                    .map_err(|e| format!("ScreenCaptureKit stream lock poisoned: {e}"))?
                     .add_recording_output(recording)
                     .map_err(|e| format!("add recording output failed: {e:?}"))?;
             }
@@ -2690,17 +2709,19 @@ fn rotate_screencapturekit_segment(
     }
     recover_from_unusable_current_segment(session, "segment rotation", true);
 
-    let start_result = start_screencapturekit_backend_at(
-        &segment_path,
-        restart.include_audio,
-        restart.capture_system_audio,
-        restart.mic_device_id.as_deref(),
-        restart.mic_device_label.as_deref(),
-        restart.target_display_id,
-        restart.capture_region,
-        false,
-        None,
-    );
+    let start_result = refuse_if_capture_stop_pending().and_then(|()| {
+        start_screencapturekit_backend_at(
+            &segment_path,
+            restart.include_audio,
+            restart.capture_system_audio,
+            restart.mic_device_id.as_deref(),
+            restart.mic_device_label.as_deref(),
+            restart.target_display_id,
+            restart.capture_region,
+            false,
+            None,
+        )
+    });
 
     let (backend, _, _) = match start_result {
         Ok(result) => result,
@@ -3047,36 +3068,46 @@ fn start_segment_backend(
         // safe_id isn't needed on macOS — the segment path is pre-computed by
         // the caller. Consume to silence the unused-variable warning.
         let _ = safe_id;
-        let sck_result = if crate::remote_flags::current().use_custom_sck_pipeline {
-            start_custom_screencapturekit_backend_at(
-                app,
-                segment_path,
-                include_audio,
-                capture_system_audio,
-                mic_device_id,
-                mic_device_label,
-                target_display_id,
-                capture_region,
-                false,
-                false,
-                None,
-            )
-        } else {
-            start_screencapturekit_backend_at(
-                segment_path,
-                include_audio,
-                capture_system_audio,
-                mic_device_id,
-                mic_device_label,
-                target_display_id,
-                capture_region,
-                false,
-                None,
-            )
-        };
+        let sck_result = refuse_if_capture_stop_pending().and_then(|()| {
+            if crate::remote_flags::current().use_custom_sck_pipeline {
+                start_custom_screencapturekit_backend_at(
+                    app,
+                    segment_path,
+                    include_audio,
+                    capture_system_audio,
+                    mic_device_id,
+                    mic_device_label,
+                    target_display_id,
+                    capture_region,
+                    false,
+                    false,
+                    None,
+                )
+            } else {
+                start_screencapturekit_backend_at(
+                    segment_path,
+                    include_audio,
+                    capture_system_audio,
+                    mic_device_id,
+                    mic_device_label,
+                    target_display_id,
+                    capture_region,
+                    false,
+                    None,
+                )
+            }
+        });
         match sck_result {
             Ok((backend, w, h)) => return Ok((backend, w, h)),
             Err(sck_err) => {
+                if sck_err.starts_with(CAPTURE_STOP_PENDING_PREFIX) {
+                    // A previous ScreenCaptureKit session may still be live at
+                    // the OS level. `screencapture` is not guaranteed
+                    // independent of ScreenCaptureKit on every macOS version,
+                    // so falling back here could race the same
+                    // still-tearing-down session this guard exists to avoid.
+                    return Err(sck_err);
+                }
                 if include_audio {
                     let mic_description = if mic_device_id
                         .is_some_and(|value| !value.trim().is_empty())
@@ -3175,10 +3206,10 @@ fn take_prefetched_shareable_content(target_display_id: Option<u32>) -> Option<S
     Some(content)
 }
 
-/// Fire-and-forget warm-up called when the recorder popover opens: fetch the
-/// multi-second `SCShareableContent` snapshot now so a recording start within
-/// the TTL skips it. Best-effort — failures are logged and the start paths
-/// fall back to their own fetch, so this can never fail a recording.
+/// Fire-and-forget warm-up called during app startup: fetch the multi-second
+/// `SCShareableContent` snapshot now so a recording start within the TTL skips
+/// it. Best-effort — failures are logged and the start paths fall back to their
+/// own fetch, so this can never fail a recording.
 #[tauri::command]
 pub async fn native_fullscreen_prefetch_capture_content() -> Result<(), String> {
     #[cfg(target_os = "macos")]
@@ -3356,7 +3387,7 @@ pub(crate) fn start_screencapturekit_backend_at(
     );
     Ok((
         NativeFullscreenBackend::ScreenCaptureKit {
-            stream,
+            stream: Arc::new(Mutex::new(stream)),
             recording,
             finish,
             mic_ready,
@@ -5182,6 +5213,7 @@ fn start_screencapturekit_recording(
     capture_region: Option<NativeCaptureRegion>,
     defer_recording_output: bool,
 ) -> Result<NativeFullscreenSession, String> {
+    refuse_if_capture_stop_pending()?;
     let target_display_id = tray_display_id(app);
     let path = pending_recording_path(app, safe_id, "mp4")?;
     let _ = std::fs::remove_file(&path);
@@ -5448,10 +5480,41 @@ const SCK_FINALIZE_TIMEOUT: Duration = Duration::from_secs(10);
 
 /// `SCStream::stop_capture()` occasionally stops the underlying capture but
 /// never returns from ScreenCaptureKit's synchronous completion wait. Keep
-/// teardown bounded so the writer can still close its inputs, flush the final
-/// fragment, and let the upload path validate the playable file on disk.
+/// teardown bounded — for the custom backend so the writer can still close
+/// its inputs, flush the final fragment, and let the upload path validate the
+/// playable file on disk; for the plain backend so a stuck `stop_capture()`
+/// can't leave the OS-level capture session half-torn-down and stall the
+/// *next* recording's `start_capture()` for the rest of its own hang.
 #[cfg(target_os = "macos")]
-const CUSTOM_SCK_STOP_TIMEOUT: Duration = Duration::from_secs(3);
+const SCK_STOP_TIMEOUT: Duration = Duration::from_secs(3);
+
+#[cfg(target_os = "macos")]
+static PENDING_CAPTURE_STOP_WORKERS: AtomicUsize = AtomicUsize::new(0);
+
+#[cfg(target_os = "macos")]
+pub(crate) fn pending_capture_stop_workers() -> usize {
+    PENDING_CAPTURE_STOP_WORKERS.load(Ordering::SeqCst)
+}
+
+/// Every entry point that constructs a brand-new ScreenCaptureKit `SCStream`
+/// (initial start, resume, and automatic segment rotation) must call this
+/// first. A prior stop that hit `SCK_STOP_TIMEOUT` leaves its `stop_capture()`
+/// running on a detached thread, still holding that stream's lock, with no
+/// signal of when (or whether) it finishes; starting a new capture while one
+/// is outstanding risks the exact OS-level contention this bounding exists to
+/// avoid. Errors carry `CAPTURE_STOP_PENDING_PREFIX` — callers that treat an
+/// SCK failure as "unavailable, fall back to `screencapture`" must check for
+/// it and refuse to fall back instead, since `screencapture` is not
+/// guaranteed independent of ScreenCaptureKit on every macOS version.
+#[cfg(target_os = "macos")]
+pub(crate) fn refuse_if_capture_stop_pending() -> Result<(), String> {
+    if pending_capture_stop_workers() > 0 {
+        return Err(format!(
+            "{CAPTURE_STOP_PENDING_PREFIX}A previous recording is still shutting down. Wait a moment and try again."
+        ));
+    }
+    Ok(())
+}
 
 #[cfg(target_os = "macos")]
 pub(crate) fn run_bounded_capture_stop<F>(stop: F, timeout: Duration) -> Result<(), String>
@@ -5459,8 +5522,11 @@ where
     F: FnOnce() -> Result<(), String> + Send + 'static,
 {
     let (tx, rx) = std::sync::mpsc::sync_channel(1);
+    PENDING_CAPTURE_STOP_WORKERS.fetch_add(1, Ordering::SeqCst);
     std::thread::spawn(move || {
-        let _ = tx.send(stop());
+        let result = stop();
+        PENDING_CAPTURE_STOP_WORKERS.fetch_sub(1, Ordering::SeqCst);
+        let _ = tx.send(result);
     });
     match rx.recv_timeout(timeout) {
         Ok(result) => result,
@@ -5477,10 +5543,27 @@ where
 #[cfg(all(test, target_os = "macos"))]
 mod bounded_capture_stop_tests {
     use super::run_bounded_capture_stop;
+    use std::sync::{Mutex, MutexGuard, OnceLock};
     use std::time::{Duration, Instant};
 
+    // All three tests below drive `run_bounded_capture_stop`, which touches
+    // the shared `PENDING_CAPTURE_STOP_WORKERS` static. Cargo runs tests in
+    // parallel by default, so without this a slow worker spawned by one test
+    // (e.g. the 1s sleep below) can still be decrementing the counter while
+    // another test is asserting against it, making the "back to baseline"
+    // check spuriously fail. Mirrors the `test_guard` pattern already used in
+    // `capture_audio_bus.rs` for the same class of shared-static tests.
+    fn test_guard() -> MutexGuard<'static, ()> {
+        static TEST_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+        TEST_LOCK
+            .get_or_init(|| Mutex::new(()))
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+    }
+
     #[test]
     fn returns_the_capture_stop_result() {
+        let _guard = test_guard();
         assert_eq!(
             run_bounded_capture_stop(|| Ok(()), Duration::from_millis(50)),
             Ok(())
@@ -5493,6 +5576,7 @@ mod bounded_capture_stop_tests {
 
     #[test]
     fn releases_the_caller_when_capture_stop_hangs() {
+        let _guard = test_guard();
         let started = Instant::now();
         let result = run_bounded_capture_stop(
             || {
@@ -5503,6 +5587,41 @@ mod bounded_capture_stop_tests {
         );
         assert!(result.unwrap_err().contains("timed out"));
         assert!(started.elapsed() < Duration::from_millis(250));
+        // This test's own worker is still sleeping (up to ~1s) when it
+        // returns. Wait it out under the same lock so it can't bleed its
+        // decrement into whichever test acquires the guard next.
+        while super::pending_capture_stop_workers() > 0 {
+            std::thread::sleep(Duration::from_millis(10));
+        }
+    }
+
+    #[test]
+    fn tracks_a_timed_out_worker_until_it_actually_finishes() {
+        let _guard = test_guard();
+        use super::pending_capture_stop_workers;
+        let baseline = pending_capture_stop_workers();
+        let result = run_bounded_capture_stop(
+            || {
+                std::thread::sleep(Duration::from_millis(200));
+                Ok(())
+            },
+            Duration::from_millis(20),
+        );
+        assert!(result.unwrap_err().contains("timed out"));
+        assert!(
+            pending_capture_stop_workers() > baseline,
+            "a timed-out stop must stay counted as outstanding — the caller \
+             gave up waiting, but the worker (and the lock it holds) is still alive"
+        );
+        let deadline = Instant::now() + Duration::from_millis(1000);
+        while pending_capture_stop_workers() > baseline && Instant::now() < deadline {
+            std::thread::sleep(Duration::from_millis(10));
+        }
+        assert_eq!(
+            pending_capture_stop_workers(),
+            baseline,
+            "the counter must drop back once the worker's stop() call actually returns"
+        );
     }
 }
 
@@ -5544,7 +5663,7 @@ pub(crate) fn stop_native_recording(
                                 .map_err(|e| format!("custom ScreenCaptureKit stop failed: {e:?}"))
                         })
                 },
-                CUSTOM_SCK_STOP_TIMEOUT,
+                SCK_STOP_TIMEOUT,
             );
             if let Err(err) = &stop_result {
                 eprintln!("[clips-tray] custom capture stop_capture error: {err}");
@@ -5564,12 +5683,28 @@ pub(crate) fn stop_native_recording(
             // `remove_recording_output()` looks like the clean stop path, but
             // on real machines it can block synchronously forever when the
             // underlying SCStream connection is interrupted. `stop_capture()`
-            // returns control to us, then the delegate callback is bounded by
-            // `SCK_FINALIZE_TIMEOUT`; the moov/audio guards below decide
-            // whether the resulting file is uploadable or recoverable.
-            let stop_result = stream
-                .stop_capture()
-                .map_err(|e| format!("ScreenCaptureKit stop failed: {e:?}"));
+            // itself is not guaranteed to return either, so it runs on a
+            // detached thread bounded by `SCK_STOP_TIMEOUT`: an unbounded
+            // hang here doesn't just delay this stop, it leaves the OS-level
+            // capture session half-torn-down and stalls the *next*
+            // recording's `start_capture()`. The delegate callback below is
+            // separately bounded by `SCK_FINALIZE_TIMEOUT`; the moov/audio
+            // guards then decide whether the resulting file is uploadable or
+            // recoverable.
+            let stream_for_stop = Arc::clone(stream);
+            let stop_result = run_bounded_capture_stop(
+                move || {
+                    stream_for_stop
+                        .lock()
+                        .map_err(|e| format!("ScreenCaptureKit stop lock poisoned: {e}"))
+                        .and_then(|guard| {
+                            guard
+                                .stop_capture()
+                                .map_err(|e| format!("ScreenCaptureKit stop failed: {e:?}"))
+                        })
+                },
+                SCK_STOP_TIMEOUT,
+            );
             let mut waited_for_finalize = false;
             let finalize_outcome = if wait_for_finalize {
                 waited_for_finalize = true;

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

@@ -26,7 +26,7 @@
 //!     position so the next show reopens at the same spot.
 
 use std::path::PathBuf;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::time::Duration;
 
 use serde::{Deserialize, Serialize};
@@ -36,11 +36,13 @@ use tauri::{
 
 use crate::dlog;
 use crate::util::{
-    build_overlay_url, configure_overlay_behavior, set_capture_excluded, show_without_activation,
-    tray_monitor_physical_rect,
+    build_overlay_url, configure_overlay_behavior, raise_to_status_level, set_capture_excluded,
+    show_without_activation, start_topmost_reassert_loop, tray_monitor_physical_rect,
 };
 
 const PILL_LABEL: &str = "recording-pill";
+/// Supersedes stale pill topmost loops after window recreation.
+static PILL_TOPMOST_GENERATION: AtomicU64 = AtomicU64::new(0);
 
 /// Detached-mode flag. Toggled from JS via `recording_pill_set_detached` —
 /// the renderer flips it when the main app loses focus. We store it as a
@@ -519,7 +521,9 @@ pub async fn recording_pill_show(
         );
         configure_overlay_behavior(&existing);
         show_without_activation(&existing);
+        raise_to_status_level(&existing);
         start_pill_hover_tracking(&app);
+        start_topmost_reassert_loop(&app, PILL_LABEL, &PILL_TOPMOST_GENERATION);
         return Ok(());
     }
 
@@ -527,7 +531,9 @@ pub async fn recording_pill_show(
     let win = build_pill_window(&app, false)?;
     configure_overlay_behavior(&win);
     show_without_activation(&win);
+    raise_to_status_level(&win);
     start_pill_hover_tracking(&app);
+    start_topmost_reassert_loop(&app, PILL_LABEL, &PILL_TOPMOST_GENERATION);
 
     // Tell the freshly-mounted React side which mode + meeting_id to render.
     use tauri::Emitter;

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

@@ -142,6 +142,18 @@ fn apply_tray_mode(app: &tauri::AppHandle, active: bool, title: Option<String>)
     }));
     #[cfg(not(target_os = "macos"))]
     let _ = title;
+    // The stop-square icon swap above is easy to miss at tray-icon size, and
+    // Windows has no menu-bar title text to reinforce it — the tooltip is the
+    // one place left to spell out that this icon is now the stop button. Gated
+    // on the same mode flip as the icon so the 4x/sec timer tick from the pill
+    // doesn't touch the tooltip on every call.
+    if tray_icon_needs_write(applied_icon_mode, active) {
+        let _ = tray.set_tooltip(Some(if active {
+            "Clips — Recording (click to stop)"
+        } else {
+            "Clips"
+        }));
+    }
 }
 
 /// Single writer for the status item's recording mode: the pill invokes this