@agent-native/core 0.92.12 → 0.94.0

package/corpus/templates/clips/desktop/src/lib/recorder.ts

@@ -55,6 +55,7 @@ import { waitForReadyRecordingAfterFinalizeError } from "../../../shared/finaliz
 import type { LocalRecordingMode } from "../shared/config";
 import { createAudioCue, type AudioCue } from "./audio-cue";
 import { createCameraCompositeStream } from "./camera-composite";
+import { finalizeAfterDurableBackup } from "./finalization-guard";
 import {
   createLocalRecordingFolderName,
   exportBlobChunksToLocalRecordingFile,
@@ -70,6 +71,10 @@ import {
   getCameraStreamWithFallback,
 } from "./media-capture-constraints";
 import { planNativeFullscreenWarmOverlap } from "./native-recording-warm";
+import {
+  createPauseTransitionQueue,
+  type PauseTransitionQueue,
+} from "./pause-transition";
 import { buildCaptureTitle, type CaptureTitleResult } from "./recording-title";
 import {
   startTranscriptionCapture,
@@ -683,14 +688,9 @@ async function deleteBrowserRecordingBackup(
   }
 }
 
-export async function discardBrowserRecordingBackup(
-  recordingId: string,
-): Promise<void> {
-  await deleteBrowserRecordingBackup(recordingId);
-}
-
 export async function exportBrowserRecordingBackup(
   recordingId: string,
+  folderName?: string,
 ): Promise<LocalBlobExportResult> {
   const meta = await getBrowserRecordingBackupMeta(recordingId);
   if (!meta) {
@@ -703,12 +703,26 @@ export async function exportBrowserRecordingBackup(
     chunks: validatedChunks.map((chunk) => chunk.blob),
     role: "composed",
     mimeType: meta.mimeType || validatedChunks[0]?.mimeType || "video/webm",
+    folderName,
     durationMs: meta.durationMs,
     width: meta.width,
     height: meta.height,
   });
 }
 
+export async function dismissBrowserRecordingBackup(
+  recordingId: string,
+): Promise<LocalBlobExportResult> {
+  const safeRecordingId =
+    recordingId.replace(/[^a-zA-Z0-9_-]/g, "") || `clip-${Date.now()}`;
+  const exported = await exportBrowserRecordingBackup(
+    recordingId,
+    `Drafts/${safeRecordingId}`,
+  );
+  await deleteBrowserRecordingBackup(recordingId);
+  return exported;
+}
+
 async function markBrowserRecordingBackupError(
   recordingId: string,
   error: string,
@@ -1661,6 +1675,15 @@ function showFinalizingFeedback() {
   );
 }
 
+async function releaseFinalizingFeedback() {
+  await invoke("set_recording_state", { active: false }).catch((err) =>
+    console.error("[clips-recorder] clear recording state failed:", err),
+  );
+  await invoke("hide_finalizing").catch((err) =>
+    console.error("[clips-recorder] hide_finalizing failed:", err),
+  );
+}
+
 async function claimNativeUploadOpen(recordingId: string): Promise<boolean> {
   return invoke<boolean>("native_fullscreen_claim_upload_open", {
     recordingId,
@@ -2024,7 +2047,9 @@ async function startNativeFullscreenRecording(
   // segments via AVFoundation. We keep the JS-side timer in sync so the
   // toolbar / pill show the right paused state and elapsed time.
   let pausedAt: number | null = null;
+  let pauseRequestedAt: number | null = null;
   let accumulatedPauseMs = 0;
+  let pauseQueue: PauseTransitionQueue | null = null;
 
   function clearSegmentRotator() {
     if (segmentRotateHandle) {
@@ -2036,7 +2061,14 @@ async function startNativeFullscreenRecording(
   function startSegmentRotator() {
     clearSegmentRotator();
     segmentRotateHandle = setInterval(() => {
-      if (stopped || pausedAt != null || segmentRotateInFlight) return;
+      if (
+        stopped ||
+        pauseQueue?.getDesiredPaused() ||
+        pausedAt !== null ||
+        segmentRotateInFlight
+      ) {
+        return;
+      }
       segmentRotateInFlight = true;
       invoke("native_fullscreen_recording_rotate_segment")
         .catch((err) => {
@@ -2044,10 +2076,11 @@ async function startNativeFullscreenRecording(
           console.warn("[clips-recorder] native segment rotation failed:", err);
           if (
             !stopped &&
-            pausedAt == null &&
+            pausedAt === null &&
             message.includes("paused recording")
           ) {
             pausedAt = Date.now();
+            pauseQueue?.synchronize(true);
             emitState();
           }
         })
@@ -2057,15 +2090,22 @@ async function startNativeFullscreenRecording(
     }, NATIVE_FULLSCREEN_SEGMENT_MS);
   }
 
-  function emitState() {
+  function emitState(
+    paused = pauseQueue?.getDesiredPaused() ?? pausedAt !== null,
+  ) {
     const now = Date.now();
-    const pausedNowMs = pausedAt != null ? now - pausedAt : 0;
+    const displayedPauseStartedAt =
+      pausedAt ?? (paused ? pauseRequestedAt : null);
+    const pausedNowMs =
+      paused && displayedPauseStartedAt !== null
+        ? now - displayedPauseStartedAt
+        : 0;
     const elapsedMs = Math.max(
       0,
       now - startedAt - accumulatedPauseMs - pausedNowMs,
     );
     emit("clips:recorder-state", {
-      paused: pausedAt != null,
+      paused,
       elapsedMs,
     }).catch(() => {});
   }
@@ -2098,6 +2138,7 @@ async function startNativeFullscreenRecording(
           );
         }
         clearSegmentRotator();
+        pauseQueue?.dispose();
         if (tickHandle) {
           clearInterval(tickHandle);
           tickHandle = null;
@@ -2203,15 +2244,19 @@ async function startNativeFullscreenRecording(
           },
         );
         uploadPromise.catch(() => {});
+        // The recording row already exists, so open its page as soon as the
+        // native stop command has started. Upload/finalize continues in this
+        // webview while the page polls from `uploading` to `ready`.
+        await openNativeUploadUrl(
+          id,
+          `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
+        );
         try {
           await Promise.race([
             recorderFinalized,
             new Promise<void>((resolve) => window.setTimeout(resolve, 15000)),
           ]);
           unlistenFinalized();
-          await invoke("set_recording_state", { active: false }).catch(
-            () => {},
-          );
 
           const capturedTranscript = await transcriptionCapture
             ?.stop()
@@ -2263,10 +2308,6 @@ async function startNativeFullscreenRecording(
                 authToken: params.authToken,
               })
             ) {
-              await openNativeUploadUrl(
-                id,
-                `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
-              );
               return { recordingId: id, viewUrl };
             }
             await abortRecordingUpload(
@@ -2274,36 +2315,16 @@ async function startNativeFullscreenRecording(
               id,
               err instanceof Error ? err.message : String(err),
             );
-            // Still take the user to the clip status page. If the server
-            // marked the upload failed, that page shows the failure state; if
-            // the abort request could not land, it keeps polling instead of
-            // leaving the user on an empty desktop.
-            try {
-              await openExternal(
-                `${params.serverUrl.replace(
-                  /\/+$/,
-                  "",
-                )}${viewUrl}?saveFailed=1`,
-              );
-            } catch (openErr) {
-              console.error("[clips-recorder] openExternal failed:", openErr);
-            }
             throw err;
           }
 
-          await openNativeUploadUrl(
-            uploadResult.recordingId,
-            `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
-          );
           return {
             recordingId: uploadResult.recordingId,
             viewUrl,
           };
         } finally {
           streamCleanups.forEach((cleanup) => cleanup());
-          invoke("hide_finalizing").catch((err) =>
-            console.error("[clips-recorder] hide_finalizing failed:", err),
-          );
+          await releaseFinalizingFeedback();
         }
       })();
       return stopPromise;
@@ -2315,6 +2336,7 @@ async function startNativeFullscreenRecording(
       cancelPromise = (async () => {
         stopped = true;
         clearSegmentRotator();
+        pauseQueue?.dispose();
         if (tickHandle) {
           clearInterval(tickHandle);
           tickHandle = null;
@@ -2360,38 +2382,57 @@ async function startNativeFullscreenRecording(
     },
   };
 
+  pauseQueue = createPauseTransitionQueue({
+    apply: (paused) =>
+      invoke(
+        paused
+          ? "native_fullscreen_recording_pause"
+          : "native_fullscreen_recording_resume",
+      ),
+    onRequested(paused) {
+      if (paused && pausedAt === null && pauseRequestedAt === null) {
+        pauseRequestedAt = Date.now();
+      }
+      // Broadcast the desired state immediately. Native ScreenCaptureKit pause
+      // can spend seconds finalizing its current segment, but one click should
+      // still freeze the clock and flip every control right away.
+      emitState(paused);
+    },
+    onApplied(paused) {
+      if (paused) {
+        pausedAt = pauseRequestedAt ?? Date.now();
+        pauseRequestedAt = null;
+        console.log("[clips-recorder] native pause: pausing transcription");
+        void transcriptionCapture?.pause().catch(() => {});
+      } else {
+        if (pausedAt !== null) {
+          accumulatedPauseMs += Date.now() - pausedAt;
+        }
+        pausedAt = null;
+        pauseRequestedAt = null;
+        console.log("[clips-recorder] native resume: resuming transcription");
+        void transcriptionCapture?.resume().catch(() => {});
+      }
+      // If the desired state changed while IPC was in flight, keep rendering
+      // that latest intent while the queue applies the follow-up transition.
+      emitState(pauseQueue?.getDesiredPaused() ?? paused);
+    },
+    onError(err, attemptedPaused) {
+      pauseRequestedAt = null;
+      emitState(pauseQueue?.getAppliedPaused() ?? pausedAt !== null);
+      console.warn(
+        `[clips-recorder] native ${attemptedPaused ? "pause" : "resume"} failed:`,
+        err,
+      );
+    },
+  });
+
   const toolbarUnlistens = await Promise.all([
     listen("clips:recorder-pause", () => {
-      if (pausedAt != null) return;
-      const at = Date.now();
-      invoke("native_fullscreen_recording_pause")
-        .then(() => {
-          pausedAt = at;
-          emitState();
-          console.log("[clips-recorder] native pause: pausing transcription");
-          void transcriptionCapture?.pause().catch(() => {});
-        })
-        .catch((err) => {
-          console.warn("[clips-recorder] native pause failed:", err);
-        });
+      pauseQueue?.request(true);
     }),
     listen("clips:recorder-resume", () => {
-      if (pausedAt == null) return;
-      // Only resume transcription once the recorder actually resumed, so a
-      // rejected IPC can't leave transcription running over a paused recording.
-      invoke("native_fullscreen_recording_resume")
-        .then(() => {
-          if (pausedAt != null) {
-            accumulatedPauseMs += Date.now() - pausedAt;
-            pausedAt = null;
-          }
-          emitState();
-          console.log("[clips-recorder] native resume: resuming transcription");
-          void transcriptionCapture?.resume().catch(() => {});
-        })
-        .catch((err) => {
-          console.warn("[clips-recorder] native resume failed:", err);
-        });
+      pauseQueue?.request(false);
     }),
     listen("clips:recorder-stop", () => {
       console.log("[clips-recorder] native stop event received");
@@ -3223,15 +3264,6 @@ async function startRecordingInner(
     }).catch(() => {});
   }
 
-  async function openFailedRecordingPage() {
-    const viewUrl = `/r/${id}?saveFailed=1`;
-    try {
-      await openExternal(`${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`);
-    } catch (err) {
-      console.error("[clips-recorder] openExternal failed:", err);
-    }
-  }
-
   // 5. Wire toolbar events.
   const toolbarUnlistens = await Promise.all([
     listen("clips:recorder-pause", () => {
@@ -3346,6 +3378,7 @@ async function startRecordingInner(
       // chunk — but NOT the transcript-finalize + thumbnail + upload awaits that
       // follow, which add ~seconds and would overstate the saved duration.
       let stoppedAt = 0;
+      const viewUrl = `/r/${id}`;
       console.log("[clips-recorder] stop requested");
       showFinalizingFeedback();
       if (tickHandle) clearInterval(tickHandle);
@@ -3354,12 +3387,20 @@ async function startRecordingInner(
 
       // Flush the in-flight recorder buffer, then wait for it to fully stop
       // so we get the trailing dataavailable event.
-      await new Promise<void>((resolve) => {
+      const recorderStopped = new Promise<void>((resolve) => {
         if (recorder.state === "inactive") {
+          stoppedAt = Date.now();
           resolve();
           return;
         }
-        recorder.addEventListener("stop", () => resolve(), { once: true });
+        recorder.addEventListener(
+          "stop",
+          () => {
+            stoppedAt = Date.now();
+            resolve();
+          },
+          { once: true },
+        );
         try {
           if (recorder.state === "paused") {
             recorder.resume();
@@ -3380,10 +3421,18 @@ async function startRecordingInner(
           // ignore
         }
       });
+      // `recorder.stop()` has already been requested, so recorded duration is
+      // fixed even if launching the browser takes a moment. Open the existing
+      // recording row now and let its page poll while upload/finalize continues.
+      try {
+        await openExternal(`${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`);
+      } catch (err) {
+        console.error("[clips-recorder] openExternal failed:", err);
+      }
+      await recorderStopped;
       // Recorder has fully stopped and flushed its trailing chunk — this is the
       // true end of recorded content. Everything after (transcript, thumbnail,
       // upload) is post-processing and must not count toward duration.
-      stoppedAt = Date.now();
 
       const thumbnailUploadPromise = captureAndUploadRecordingThumbnail({
         serverUrl: params.serverUrl,
@@ -3497,7 +3546,6 @@ async function startRecordingInner(
       await invoke("hide_recording_chrome").catch((err) =>
         console.error(`[clips-recorder] hide_recording_chrome failed:`, err),
       );
-      await invoke("set_recording_state", { active: false }).catch(() => {});
 
       // Wait for any in-flight chunk uploads to settle before sending the
       // final chunk. Otherwise the server could finalize before the last
@@ -3511,19 +3559,19 @@ async function startRecordingInner(
         await Promise.allSettled(pending);
       }
       inflight.clear();
-      // Ensure the local backup is fully written before we either delete it
-      // (on success) or leave it in place for recovery (on failure).
-      await Promise.allSettled([...backupWrites]);
       if (failed) {
-        console.error("[clips-recorder] chunk upload failed:", failed);
-        await markBrowserRecordingBackupError(id, failed.message).catch(
-          () => {},
-        );
-        await abortRecordingUpload(params.serverUrl, id, failed.message);
-        invoke("hide_finalizing").catch((err) =>
-          console.error("[clips-recorder] hide_finalizing failed:", err),
-        );
-        await openFailedRecordingPage();
+        try {
+          // Keep the guard until the final metadata and every trailing chunk
+          // backup are durable, even though this upload cannot be finalized.
+          await Promise.allSettled([...backupWrites]);
+          console.error("[clips-recorder] chunk upload failed:", failed);
+          await markBrowserRecordingBackupError(id, failed.message).catch(
+            () => {},
+          );
+          await abortRecordingUpload(params.serverUrl, id, failed.message);
+        } finally {
+          await releaseFinalizingFeedback();
+        }
         throw failed;
       }
 
@@ -3553,78 +3601,58 @@ async function startRecordingInner(
         uploadMode,
         anyFailed: !!failed,
       });
-      try {
-        const finalRes = await fetch(finalizeUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/octet-stream" },
-          credentials: "include",
-          body: finalBody,
-          signal: AbortSignal.timeout(FINALIZE_UPLOAD_TIMEOUT_MS),
-        });
-        const bodyText = await finalRes.text().catch(() => "");
-        console.log(
-          "[clips-recorder] finalize response:",
-          finalRes.status,
-          bodyText.slice(0, 500),
-        );
-        if (!finalRes.ok) {
-          throw new Error(
-            `Finalize failed (${finalRes.status}): ${bodyText.slice(0, 200)}`,
-          );
-        }
-      } catch (err) {
-        console.error("[clips-recorder] finalize fetch failed:", err);
-        const error = err instanceof Error ? err : new Error(String(err));
-        if (
-          await recoverReadyRecordingAfterFinalizeError({
-            serverUrl: params.serverUrl,
-            recordingId: id,
-            authToken: params.authToken,
-          })
-        ) {
-          const viewUrl = `/r/${id}`;
+      return finalizeAfterDurableBackup({
+        // Opening the browser must not make the desktop look idle until every
+        // trailing backup write and the final metadata are durable.
+        ensureBackupDurable: async () => {
+          await Promise.allSettled([...backupWrites]);
+        },
+        attemptFinalize: async () => {
           try {
-            await openExternal(
-              `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
+            const finalRes = await fetch(finalizeUrl, {
+              method: "POST",
+              headers: { "Content-Type": "application/octet-stream" },
+              credentials: "include",
+              body: finalBody,
+              signal: AbortSignal.timeout(FINALIZE_UPLOAD_TIMEOUT_MS),
+            });
+            const bodyText = await finalRes.text().catch(() => "");
+            console.log(
+              "[clips-recorder] finalize response:",
+              finalRes.status,
+              bodyText.slice(0, 500),
             );
-          } catch (openErr) {
-            console.error("[clips-recorder] openExternal failed:", openErr);
+            if (!finalRes.ok) {
+              throw new Error(
+                `Finalize failed (${finalRes.status}): ${bodyText.slice(0, 200)}`,
+              );
+            }
+          } catch (err) {
+            console.error("[clips-recorder] finalize fetch failed:", err);
+            const error = err instanceof Error ? err : new Error(String(err));
+            if (
+              await recoverReadyRecordingAfterFinalizeError({
+                serverUrl: params.serverUrl,
+                recordingId: id,
+                authToken: params.authToken,
+              })
+            ) {
+              return { recordingId: id, viewUrl };
+            }
+            await markBrowserRecordingBackupError(id, error.message).catch(
+              () => {},
+            );
+            await abortRecordingUpload(params.serverUrl, id, error.message);
+            throw error;
           }
-          invoke("hide_finalizing").catch((hideErr) =>
-            console.error("[clips-recorder] hide_finalizing failed:", hideErr),
-          );
+          await deleteBrowserRecordingBackup(id).catch((err) => {
+            console.warn("[clips-recorder] local backup cleanup failed:", err);
+          });
+
           return { recordingId: id, viewUrl };
-        }
-        await markBrowserRecordingBackupError(id, error.message).catch(
-          () => {},
-        );
-        await abortRecordingUpload(params.serverUrl, id, error.message);
-        invoke("hide_finalizing").catch((hideErr) =>
-          console.error("[clips-recorder] hide_finalizing failed:", hideErr),
-        );
-        await openFailedRecordingPage();
-        throw error;
-      }
-      await deleteBrowserRecordingBackup(id).catch((err) => {
-        console.warn("[clips-recorder] local backup cleanup failed:", err);
+        },
+        releaseGuard: releaseFinalizingFeedback,
       });
-
-      // Finalize done (or tried and failed — the player page shows a clear
-      // error state in either case). Open the browser to the playback URL
-      // and THEN close the finalizing spinner. Closing before the browser
-      // opens would leave the user staring at an empty desktop for the
-      // brief moment while the OS launches / focuses the default browser.
-      const viewUrl = `/r/${id}`;
-      try {
-        await openExternal(`${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`);
-      } catch (err) {
-        console.error("[clips-recorder] openExternal failed:", err);
-      }
-      invoke("hide_finalizing").catch((err) =>
-        console.error("[clips-recorder] hide_finalizing failed:", err),
-      );
-
-      return { recordingId: id, viewUrl };
     },
 
     async cancel() {

package/corpus/templates/clips/desktop/src/lib/transcription-engine.ts

@@ -152,8 +152,9 @@ export async function startTranscriptionEngine(opts: {
   captureSystem?: boolean;
   /**
    * Enable Apple's voice-processing input mode for the Whisper mic tap.
-   * Meeting and recording capture leave this off so Clips never adds a second
-   * VoIP processor beside Zoom, Meet, or Teams and changes their mic uplink.
+   * Meeting and recording capture leave this off at the renderer boundary.
+   * The native meeting runtime may allocate VoiceProcessingIO in bypass mode
+   * only when combined ScreenCaptureKit capture is unavailable or fails.
    */
   voiceProcessing?: boolean;
 }): Promise<TranscriptionEngine> {

package/corpus/templates/clips/desktop/src/lib/updater.ts

@@ -27,6 +27,10 @@ let pendingUpdate: Update | null = null;
 const listeners = new Set<StatusListener>();
 let started = false;
 let checkInFlight: Promise<void> | null = null;
+let lastCheckStartedAt = 0;
+
+const UPDATE_CHECK_INTERVAL_MS = 60 * 60 * 1000;
+const UPDATE_FOCUS_CHECK_MIN_INTERVAL_MS = 15 * 60 * 1000;
 
 function canRunUpdateChecks() {
   // Dev and local release builds are for testing the current checkout. Do not
@@ -40,8 +44,10 @@ function setStatus(next: UpdateStatus) {
 }
 
 async function runCheck() {
+  if (cachedStatus.state === "downloaded") return;
   if (checkInFlight) return checkInFlight;
 
+  lastCheckStartedAt = Date.now();
   checkInFlight = (async () => {
     try {
       setStatus({ state: "checking" });
@@ -90,14 +96,30 @@ async function runCheck() {
   return checkInFlight;
 }
 
+function maybeCheckForUpdate() {
+  if (!canRunUpdateChecks()) return;
+  if (cachedStatus.state === "downloaded") return;
+  if (
+    checkInFlight ||
+    Date.now() - lastCheckStartedAt < UPDATE_FOCUS_CHECK_MIN_INTERVAL_MS
+  ) {
+    return;
+  }
+  void runCheck();
+}
+
 function startUpdateLoop() {
   if (started) return;
   started = true;
   if (!canRunUpdateChecks()) return;
-  // Check 3s after launch (let the popover finish first paint), then every
-  // 4 hours. Matches the cadence used by the Electron app.
-  setTimeout(runCheck, 3000);
-  setInterval(runCheck, 4 * 60 * 60 * 1000);
+  // Check 3s after launch (let the popover finish first paint), hourly while
+  // Clips stays open, and when the user returns after at least 15 minutes.
+  setTimeout(() => void runCheck(), 3000);
+  setInterval(() => void runCheck(), UPDATE_CHECK_INTERVAL_MS);
+  window.addEventListener("focus", maybeCheckForUpdate);
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "visible") maybeCheckForUpdate();
+  });
 }
 
 export function useUpdateStatus(): UpdateStatus {

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

@@ -25,17 +25,13 @@ type NativeUploadFinished = {
 
 /**
  * Full-screen transparent feedback overlay. Rendered the moment the user
- * clicks Stop on the recording toolbar and kept visible until the browser
- * opens at `/r/:id`. This fills the gap between `hide_recording_chrome`
- * tearing down the toolbar + bubble and `openExternal` actually opening
- * the browser — a gap that can stretch for several seconds while
- * MediaRecorder flushes trailing chunks and the server finalize POST
- * completes.
+ * clicks Stop on the recording toolbar and kept visible while the desktop
+ * finishes its durable backup and first upload/finalize attempt. The browser
+ * can open `/r/:id` earlier so the page shows live progress.
  *
  * The window ignores cursor events on the Rust side, so the compact
  * bottom-left card does not block the user's screen while compression or
- * upload continues. The recorder.ts stop path invokes `hide_finalizing`
- * right after `openExternal` to close this window.
+ * upload runs.
  */
 export function Finalizing() {
   const [progress, setProgress] = useState<ProcessingProgress>({

package/corpus/templates/clips/desktop/src/overlays/meeting-notification.tsx

@@ -12,6 +12,7 @@ import { getCurrentWindow } from "@tauri-apps/api/window";
 import { open as openExternal } from "@tauri-apps/plugin-shell";
 import { useEffect, useRef, useState } from "react";
 
+import { resolveDesktopMeetingJoinUrl } from "../lib/meeting-join-url";
 import {
   detectMeetingJoinProvider,
   joinProviderLabel,
@@ -45,12 +46,12 @@ const NOTIFICATION_COLLAPSED_HEIGHT = 120;
 const NOTIFICATION_MENU_HEIGHT = 224;
 
 /**
- * Open a meeting join URL via the Tauri shell plugin.
+ * Open a meeting join URL via its native desktop app when supported.
  */
 async function openJoinUrl(url: string | null | undefined): Promise<void> {
   if (!url) return;
   try {
-    await openExternal(url);
+    await openExternal(resolveDesktopMeetingJoinUrl(url));
   } catch (err) {
     console.error("[clips-tray] openJoinUrl failed:", err);
   }