@agent-native/core 0.93.0 → 0.94.1

package/corpus/templates/clips/desktop/src/hooks/useMeetingTranscription.ts

@@ -197,15 +197,9 @@ export function useMeetingTranscription({
           // never lands.
           if (reason !== "app-quit") await finalizePromise;
         }
-        // Skip opening the meeting in the browser on app-quit — the app is
-        // exiting, there's nothing to hand off to.
-        if (reason !== "app-quit") {
-          openExternal(
-            `${normalizedServerUrl}/meetings/${session.meetingId}`,
-          ).catch((err) => {
-            console.warn("[clips-popover] open meeting in web failed:", err);
-          });
-        }
+        // Keep completed notes in Clips instead of interrupting the user by
+        // opening a browser tab. The pill's explicit Open notes action remains
+        // available through the clips:open-meeting listener below.
         // Guard the shared Rust-side state writes and sessionRef null-out by
         // identity. App quit and other callers can still race a stop against a
         // new start that slips in between awaits, and stale teardown must not
@@ -377,9 +371,9 @@ export function useMeetingTranscription({
         };
 
         // Resume the engine that initial start settled on (no fallback here —
-        // the engine choice was already made below). Never add a second
-        // VoiceProcessingIO stack beside the meeting app: it can alter the
-        // microphone level that remote participants receive.
+        // the engine choice was already made below). Rust prefers one combined
+        // SCK stream and uses bypassed VoiceProcessingIO only for legacy/failure
+        // fallback, so the transcript stays live without changing call volume.
         const startAudio = async () => {
           await restartTranscriptionEngine(
             session.engine,
@@ -560,8 +554,8 @@ export function useMeetingTranscription({
         session.engine = await startTranscriptionEngine({
           mic: { deviceId: selectedMicId, label: selectedMicLabel },
           // macOS 15+ uses ScreenCaptureKit's independent microphone output.
-          // The legacy fallback must also remain a raw tap so Zoom/Meet/Teams
-          // stay in sole control of their live-call voice processing.
+          // Rust upgrades only the legacy/failure fallback to bypassed VPIO so
+          // call apps cannot starve Clips of mic buffers or lose call volume.
           voiceProcessing: false,
         });
 

package/corpus/templates/clips/desktop/src/lib/meeting-join-url.ts

@@ -0,0 +1,33 @@
+const ZOOM_JOIN_PATH = /^\/j\/(\d+)\/?$/;
+
+function isZoomMeetingHost(hostname: string): boolean {
+  return hostname === "zoom.us" || hostname.endsWith(".zoom.us");
+}
+
+/**
+ * Resolve a calendar join URL to the native desktop-app URI when the provider
+ * supports one. Unknown providers and unsupported Zoom URL shapes stay on
+ * their original HTTPS URL.
+ */
+export function resolveDesktopMeetingJoinUrl(joinUrl: string): string {
+  try {
+    const url = new URL(joinUrl);
+    if (url.protocol !== "https:" || !isZoomMeetingHost(url.hostname)) {
+      return joinUrl;
+    }
+
+    const meetingNumber = ZOOM_JOIN_PATH.exec(url.pathname)?.[1];
+    if (!meetingNumber) return joinUrl;
+
+    const params = new URLSearchParams({
+      action: "join",
+      confno: meetingNumber,
+    });
+    const passcode = url.searchParams.get("pwd");
+    if (passcode) params.set("pwd", passcode);
+
+    return `zoommtg://${url.hostname}/join?${params.toString()}`;
+  } catch {
+    return joinUrl;
+  }
+}

package/corpus/templates/clips/desktop/src/lib/pause-transition.ts

@@ -0,0 +1,79 @@
+export interface PauseTransitionQueue {
+  request(paused: boolean): void;
+  getAppliedPaused(): boolean;
+  getDesiredPaused(): boolean;
+  isTransitioning(): boolean;
+  synchronize(paused: boolean): void;
+  dispose(): void;
+}
+
+interface PauseTransitionOptions {
+  initialPaused?: boolean;
+  apply(paused: boolean): Promise<void> | void;
+  onRequested?(paused: boolean): void;
+  onApplied?(paused: boolean): void;
+  onError?(error: unknown, attemptedPaused: boolean): void;
+}
+
+/**
+ * Serializes slow pause/resume work while preserving the user's latest intent.
+ * If Resume arrives while Pause is still in flight, Pause finishes once and the
+ * queue immediately applies Resume instead of silently dropping that click.
+ */
+export function createPauseTransitionQueue(
+  options: PauseTransitionOptions,
+): PauseTransitionQueue {
+  let appliedPaused = options.initialPaused ?? false;
+  let desiredPaused = appliedPaused;
+  let transitioning = false;
+  let disposed = false;
+
+  const applyDesiredState = async (): Promise<void> => {
+    if (disposed || transitioning || desiredPaused === appliedPaused) return;
+
+    transitioning = true;
+    const targetPaused = desiredPaused;
+    let applied = false;
+    try {
+      await options.apply(targetPaused);
+      applied = true;
+    } catch (error) {
+      if (!disposed) {
+        // Reflect reality after a failed transition. A fresh request can retry.
+        desiredPaused = appliedPaused;
+        options.onError?.(error, targetPaused);
+      }
+    } finally {
+      transitioning = false;
+    }
+
+    if (disposed) return;
+    if (applied) {
+      appliedPaused = targetPaused;
+      options.onApplied?.(targetPaused);
+    }
+
+    // The desired state may have changed while the operation was awaiting.
+    void applyDesiredState();
+  };
+
+  return {
+    request(paused) {
+      if (disposed || paused === desiredPaused) return;
+      desiredPaused = paused;
+      options.onRequested?.(paused);
+      void applyDesiredState();
+    },
+    getAppliedPaused: () => appliedPaused,
+    getDesiredPaused: () => desiredPaused,
+    isTransitioning: () => transitioning,
+    synchronize(paused) {
+      if (disposed || transitioning) return;
+      appliedPaused = paused;
+      desiredPaused = paused;
+    },
+    dispose() {
+      disposed = true;
+    },
+  };
+}

package/corpus/templates/clips/desktop/src/lib/pill-interaction.ts

@@ -0,0 +1,19 @@
+export interface ScreenPoint {
+  x: number;
+  y: number;
+}
+
+const DIRECT_CLICK_MAX_TRAVEL_PX = 5;
+
+export function isDirectPillClick(
+  start: ScreenPoint | null,
+  end: ScreenPoint,
+): boolean {
+  if (!start) return false;
+  const deltaX = end.x - start.x;
+  const deltaY = end.y - start.y;
+  return (
+    deltaX * deltaX + deltaY * deltaY <=
+    DIRECT_CLICK_MAX_TRAVEL_PX * DIRECT_CLICK_MAX_TRAVEL_PX
+  );
+}

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

@@ -71,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,
@@ -684,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) {
@@ -704,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,
@@ -2034,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) {
@@ -2046,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) => {
@@ -2054,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();
           }
         })
@@ -2067,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(() => {});
   }
@@ -2108,6 +2138,7 @@ async function startNativeFullscreenRecording(
           );
         }
         clearSegmentRotator();
+        pauseQueue?.dispose();
         if (tickHandle) {
           clearInterval(tickHandle);
           tickHandle = null;
@@ -2305,6 +2336,7 @@ async function startNativeFullscreenRecording(
       cancelPromise = (async () => {
         stopped = true;
         clearSegmentRotator();
+        pauseQueue?.dispose();
         if (tickHandle) {
           clearInterval(tickHandle);
           tickHandle = null;
@@ -2350,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");

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/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);
   }

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={