@agent-native/core 0.91.1 → 0.91.2

package/corpus/templates/clips/desktop/src/app.tsx

@@ -1286,6 +1286,9 @@ export function App() {
       if (e.key === "Escape") {
         // Don't close mid-recording — user would lose the recorder handle.
         if (isRecording) return;
+        // Reset nested views before hide so the next tray open lands on the
+        // main recorder UI instead of resuming scrolled settings/meetings.
+        setPopoverView("recorder");
         hidePopover();
       }
     }
@@ -1328,7 +1331,11 @@ export function App() {
     track(
       listen<boolean>("clips:popover-visible", (ev) => {
         console.log("[clips-popover] popover-visible =", ev.payload);
-        setPopoverVisible(!!ev.payload);
+        const visible = !!ev.payload;
+        setPopoverVisible(visible);
+        // Leaving settings/meetings/dictation mid-scroll should not resume on
+        // the next open — always return to the main recorder surface.
+        if (!visible) setPopoverView("recorder");
       }),
     );
     // The bubble window emits `clips:bubble-closed` when the user clicks
@@ -1415,6 +1422,10 @@ export function App() {
   // tracks (which causes the laggy / black / silently-failing recording
   // symptoms). Reset to false once the recording is fully torn down.
   const bubbleStreamTransferredToRecorder = useRef(false);
+  // Bumped when the native stop path releases the camera mid-session so the
+  // bubble effect re-acquires even if bubbleActive/cameraId are unchanged
+  // (post-stop reopen with a blank "Default Camera" preview).
+  const [bubbleSessionEpoch, setBubbleSessionEpoch] = useState(0);
   const wantsCamera = mode !== "screen" && cameraOn;
   const nativeFullscreenRecordingActive =
     mode !== "camera" && shouldUseNativeFullscreenRecording(source);
@@ -1623,14 +1634,21 @@ export function App() {
         invoke("hide_overlays").catch(() => {});
       }
     };
-  }, [bubbleActive, cameraId]);
+  }, [bubbleActive, cameraId, bubbleSessionEpoch]);
 
   useEffect(() => {
     let unlisten: (() => void) | null = null;
     let cancelled = false;
     listen("clips:release-camera", () => {
       console.log(`[popover] releasing camera`);
+      // Native stop closes the bubble and kills tracks while React may still
+      // hold a live RecorderHandle during finalize/upload. Clear ownership so
+      // the bubble session can re-acquire a fresh preview, and so Start is not
+      // stuck on an ended stream.
+      bubbleStreamTransferredToRecorder.current = false;
       bubbleStreamRef.current?.getTracks().forEach((t) => t.stop());
+      bubbleStreamRef.current = null;
+      setBubbleSessionEpoch((epoch) => epoch + 1);
     })
       .then((u) => {
         if (cancelled) u();
@@ -1643,6 +1661,24 @@ export function App() {
     };
   }, []);
 
+  // If the popover reopens while camera is still wanted, and the previous
+  // bubble stream is gone or all tracks have ended (common after native stop
+  // + mid-upload reopen), bump the session epoch so the bubble effect
+  // re-acquires getUserMedia + WebRTC instead of showing a blank "Default
+  // Camera" label with a silent Start.
+  useEffect(() => {
+    if (!popoverVisible || !wantsCamera) return;
+    if (recordingFlowGateRef.current || recordingFlowActive) return;
+    const tracks = bubbleStreamRef.current?.getTracks() ?? [];
+    const needsFreshBubble =
+      tracks.length === 0 ||
+      tracks.every((track) => track.readyState === "ended");
+    if (!needsFreshBubble) return;
+    bubbleStreamTransferredToRecorder.current = false;
+    bubbleStreamRef.current = null;
+    setBubbleSessionEpoch((epoch) => epoch + 1);
+  }, [popoverVisible, wantsCamera, recordingFlowActive]);
+
   // ---- auto-size popover to content --------------------------------------
   // The Tauri window is fixed-size via tauri.conf.json, but our content
   // height varies (more rows when a camera is on, Recent list toggle, etc.).
@@ -1859,7 +1895,25 @@ export function App() {
   async function handleStartRecording(options?: {
     ignoreActiveRecorder?: boolean;
   }) {
-    if (recorder && !options?.ignoreActiveRecorder) return;
+    if (recorder && !options?.ignoreActiveRecorder) {
+      console.warn(
+        "[clips-popover] handleStartRecording ignored — recorder already active",
+      );
+      setRecError(
+        "Still finishing the last recording. Wait a moment, then try again.",
+      );
+      return;
+    }
+    const bubbleTracks = bubbleStreamRef.current?.getTracks() ?? [];
+    const bubbleStreamDead =
+      bubbleTracks.length > 0 &&
+      bubbleTracks.every((track) => track.readyState === "ended");
+    if (bubbleStreamDead) {
+      console.warn("[clips-popover] clearing ended bubble stream before start");
+      bubbleStreamTransferredToRecorder.current = false;
+      bubbleStreamRef.current = null;
+      setBubbleSessionEpoch((epoch) => epoch + 1);
+    }
     if (localRecordingMode === "off") {
       if (videoStorageStatus === "checking") {
         setRecError("Checking video storage. Try again in a moment.");
@@ -2202,11 +2256,28 @@ export function App() {
     };
     track(
       listen("clips:recorder-stop", async () => {
+        // Detach the React Start/bubble gate immediately. Native stop already
+        // released the camera and cleared Rust `is_recording_active` mid-
+        // finalize; keeping `recorder` set through the whole upload made
+        // reopen show a blank preview and made Start a silent no-op.
+        const handle = recorder;
+        bubbleStreamTransferredToRecorder.current = false;
+        bubbleStreamRef.current = null;
+        recordingFlowGateRef.current = false;
+        (window as unknown as { clipsForceAlive?: boolean }).clipsForceAlive =
+          false;
+        setRecordingFlowActive(false);
+        setRecorder(null);
+        // Force a fresh bubble session even when bubbleActive stays true
+        // (popover still open / camera still on). Without this epoch bump the
+        // effect does not re-run and reopen shows ended tracks until Start
+        // discovers them.
+        setBubbleSessionEpoch((epoch) => epoch + 1);
+
         let stopFailed = false;
         let stopResult: RecorderStopResult | null = null;
         try {
-          stopResult = await recorder.stop();
-          if (cancelled) return;
+          stopResult = await handle.stop();
           if (stopResult.localOnly) {
             setLocalRecordingNotice({
               folderPath: stopResult.localFolder,
@@ -2217,36 +2288,20 @@ export function App() {
           }
         } catch (err) {
           stopFailed = true;
-          if (!cancelled) {
-            setRecError(err instanceof Error ? err.message : String(err));
-            await loadPendingUploads();
-          }
+          setRecError(err instanceof Error ? err.message : String(err));
+          await loadPendingUploads();
         } finally {
-          if (!cancelled) {
-            // Clear the force-alive flag — recording is done, the pump
-            // can honor document.hidden normally again.
-            (
-              window as unknown as { clipsForceAlive?: boolean }
-            ).clipsForceAlive = false;
-            // Recorder has stopped its tracks; next popover session can
-            // acquire the camera cleanly again.
-            bubbleStreamTransferredToRecorder.current = false;
-            bubbleStreamRef.current = null;
-            recordingFlowGateRef.current = false;
-            setRecorder(null);
-            setRecordingFlowActive(false);
-            invoke("set_recording_state", { active: false }).catch(() => {});
-            if (stopFailed || stopResult?.localOnly) {
-              invoke("show_popover").catch(() => {});
-            } else {
-              // Close the popover — recorder.stop() already opened the
-              // recording's page in the default browser. The popover doesn't
-              // need to hang around.
-              getCurrentWindow()
-                .hide()
-                .catch(() => {});
-              emit("clips:popover-visible", false).catch(() => {});
-            }
+          invoke("set_recording_state", { active: false }).catch(() => {});
+          if (stopFailed || stopResult?.localOnly) {
+            invoke("show_popover").catch(() => {});
+          } else {
+            // Close the popover — recorder.stop() already opened the
+            // recording's page in the default browser. The popover doesn't
+            // need to hang around.
+            getCurrentWindow()
+              .hide()
+              .catch(() => {});
+            emit("clips:popover-visible", false).catch(() => {});
           }
         }
       }),
@@ -2265,6 +2320,7 @@ export function App() {
             recordingFlowGateRef.current = false;
             setRecorder(null);
             setRecordingFlowActive(false);
+            setBubbleSessionEpoch((epoch) => epoch + 1);
             invoke("set_recording_state", { active: false }).catch(() => {});
             invoke("show_popover").catch(() => {});
           }
@@ -2285,6 +2341,7 @@ export function App() {
             recordingFlowGateRef.current = false;
             setRecorder(null);
             setRecordingFlowActive(false);
+            setBubbleSessionEpoch((epoch) => epoch + 1);
             invoke("set_recording_state", { active: false }).catch(() => {});
             // Starting a new browser capture must come from a fresh click in
             // this webview. The toolbar click arrives here through async Tauri

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

@@ -363,12 +363,19 @@ export function useMeetingTranscription({
         };
 
         // Resume the engine that initial start settled on (no fallback here —
-        // the engine choice was already made below).
+        // the engine choice was already made below). Keep voice processing
+        // off: AEC/ducking on the shared mic can make Zoom/Meet callers hear
+        // the local user at a whisper while Clips is transcribed.
         const startAudio = async () => {
-          await restartTranscriptionEngine(session.engine, {
-            deviceId: selectedMicId,
-            label: selectedMicLabel,
-          });
+          await restartTranscriptionEngine(
+            session.engine,
+            {
+              deviceId: selectedMicId,
+              label: selectedMicLabel,
+            },
+            true,
+            false,
+          );
         };
 
         // Pause/resume state machine — see app.tsx for full explanation.
@@ -538,6 +545,9 @@ export function useMeetingTranscription({
 
         session.engine = await startTranscriptionEngine({
           mic: { deviceId: selectedMicId, label: selectedMicLabel },
+          // Match clip recordings: VoiceProcessingIO AEC/ducking on the shared
+          // mic can tank live meeting volume for remote participants.
+          voiceProcessing: false,
         });
 
         await invoke("silence_detector_start", {

package/corpus/templates/clips/desktop/src/lib/meeting-notification-timing.ts

@@ -0,0 +1,83 @@
+/**
+ * Meeting reminder visibility policy (Granola-aligned).
+ *
+ * Show the overlay from 1 minute before start through 5 minutes after start,
+ * unless the user dismisses it or takes an action.
+ */
+
+export const MEETING_NOTIFY_LEAD_MS = 60_000;
+export const MEETING_NOTIFY_HOLD_AFTER_START_MS = 5 * 60_000;
+
+/** True when `now` is inside the show window for a meeting that starts at `startMs`. */
+export function isMeetingNotificationWindowOpen(
+  startMs: number,
+  nowMs: number = Date.now(),
+): boolean {
+  if (!Number.isFinite(startMs)) return false;
+  const earliest = startMs - MEETING_NOTIFY_LEAD_MS;
+  const latest = startMs + MEETING_NOTIFY_HOLD_AFTER_START_MS;
+  return nowMs >= earliest && nowMs <= latest;
+}
+
+/**
+ * Milliseconds until the overlay should auto-hide, assuming it is currently
+ * visible. Returns 0 when the window has already closed.
+ */
+export function meetingNotificationAutoHideMs(
+  startMs: number,
+  nowMs: number = Date.now(),
+): number {
+  if (!Number.isFinite(startMs)) return 0;
+  const latest = startMs + MEETING_NOTIFY_HOLD_AFTER_START_MS;
+  return Math.max(0, latest - nowMs);
+}
+
+export type MeetingJoinProvider = "zoom" | "meet" | "teams" | "webex" | "other";
+
+export function detectMeetingJoinProvider(
+  joinUrl: string | null | undefined,
+  platform?: string | null,
+): MeetingJoinProvider {
+  const haystack = `${platform ?? ""} ${joinUrl ?? ""}`.toLowerCase();
+  if (haystack.includes("zoom")) return "zoom";
+  if (haystack.includes("meet.google") || /\bmeet\b/.test(haystack))
+    return "meet";
+  if (haystack.includes("teams.microsoft") || haystack.includes("teams"))
+    return "teams";
+  if (haystack.includes("webex")) return "webex";
+  return "other";
+}
+
+export function joinProviderLabel(provider: MeetingJoinProvider): string {
+  switch (provider) {
+    case "zoom":
+      return "Zoom";
+    case "meet":
+      return "Meet";
+    case "teams":
+      return "Teams";
+    case "webex":
+      return "Webex";
+    default:
+      return "meeting";
+  }
+}
+
+/** Format a local time range like "9:00 AM - 9:30 AM". */
+export function formatMeetingTimeRange(
+  startIso: string | null | undefined,
+  endIso: string | null | undefined,
+  locale?: string,
+): string | null {
+  if (!startIso) return null;
+  const start = Date.parse(startIso);
+  if (!Number.isFinite(start)) return null;
+  const end = endIso ? Date.parse(endIso) : NaN;
+  const fmt = new Intl.DateTimeFormat(locale, {
+    hour: "numeric",
+    minute: "2-digit",
+  });
+  const startLabel = fmt.format(new Date(start));
+  if (!Number.isFinite(end)) return startLabel;
+  return `${startLabel} - ${fmt.format(new Date(end))}`;
+}

package/corpus/templates/clips/desktop/src/lib/native-recording-warm.ts

@@ -0,0 +1,21 @@
+/**
+ * Hosted native start sequencing: overlap Whisper start, create-recording, and
+ * deferred SCK warm so Skip no longer waits serially on Whisper then warm.
+ * Begin/attach must still wait for this promise (transcription settled).
+ */
+export function planNativeFullscreenWarmOverlap<
+  TRecording extends { id: string },
+>(input: {
+  createRecording: () => Promise<TRecording>;
+  startTranscription: () => Promise<unknown>;
+  warmMic: (recordingId: string) => Promise<unknown>;
+}): Promise<TRecording> {
+  const transcriptionPromise = input.startTranscription();
+  return (async () => {
+    const created = await input.createRecording();
+    // Deferred-output warm may overlap remaining Whisper startup; frames are
+    // not written until begin attaches the recording output.
+    await Promise.all([transcriptionPromise, input.warmMic(created.id)]);
+    return created;
+  })();
+}

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

@@ -69,6 +69,7 @@ import {
   getAudioStreamWithFallback,
   getCameraStreamWithFallback,
 } from "./media-capture-constraints";
+import { planNativeFullscreenWarmOverlap } from "./native-recording-warm";
 import { buildCaptureTitle, type CaptureTitleResult } from "./recording-title";
 import {
   startTranscriptionCapture,
@@ -77,6 +78,7 @@ import {
 } from "./transcription-capture";
 
 export type { LocalExportedFile } from "./local-export";
+export { planNativeFullscreenWarmOverlap } from "./native-recording-warm";
 
 export type CaptureMode = "screen" | "screen-camera" | "camera";
 export type CaptureSource = "full-screen" | "window" | "region";
@@ -1677,6 +1679,11 @@ async function openNativeUploadUrl(
   }
 }
 
+/**
+ * Hosted native start sequencing helper: overlap Whisper start, create-recording,
+ * and deferred SCK warm so Skip no longer waits serially on Whisper then warm.
+ * `begin` / attach still waits for transcription to settle first.
+ */
 function abortCreatedRecordingOnCountdownCancel(
   err: unknown,
   recordingPromise: Promise<{ id: string }>,
@@ -1847,19 +1854,42 @@ async function startNativeFullscreenRecording(
       }).catch((err) => {
         console.warn("[clips-recorder] mic warm failed:", err);
       });
+    const clickStartedAt = Date.now();
     if (localOnly) {
+      // Local recordings have no create-recording round-trip; still overlap
+      // Whisper startup with countdown + deferred SCK warm.
       const countdownPromise = runRecordingCountdown(true);
       id = localFolderName;
-      await Promise.all([countdownPromise, warmMic(id)]);
+      const transcriptionPromise = startNativeTranscriptionBeforeRecording();
+      const warmPromise = (async () => {
+        const warmStartedAt = Date.now();
+        await warmMic(id);
+        console.log(
+          `[clips-recorder] native warm durations: warmMs=${Date.now() - warmStartedAt}`,
+        );
+      })();
+      try {
+        await Promise.all([
+          countdownPromise,
+          transcriptionPromise,
+          warmPromise,
+        ]);
+      } catch (err) {
+        await transcriptionPromise.catch(() => {});
+        throw err;
+      }
     } else {
       const captureTitlePromise = captureTitleForRecording({
         mode: params.mode,
         source: params.source,
       });
       const countdownPromise = runRecordingCountdown(true);
+      // Kick Whisper off immediately (no recording id needed) so Skip no longer
+      // serializes create → Whisper → SCK warm on the critical path.
+      const transcriptionPromise = startNativeTranscriptionBeforeRecording();
       const recordingPromise = (async () => {
         const captureTitle = await captureTitlePromise;
-        console.time("[clips-recorder] createServerRecording duration");
+        const createStartedAt = Date.now();
         try {
           return await createServerRecording(
             params.serverUrl,
@@ -1873,26 +1903,47 @@ async function startNativeFullscreenRecording(
             },
           );
         } finally {
-          console.timeEnd("[clips-recorder] createServerRecording duration");
+          console.log(
+            `[clips-recorder] createServerRecording durationMs=${Date.now() - createStartedAt}`,
+          );
         }
       })();
-      // The recording id usually lands well before the countdown ends — warm
-      // native capture as soon as it does so setup overlaps the 3-2-1.
-      const warmAndId = (async () => {
-        const createRes = await recordingPromise;
-        uploadMode = createRes.uploadMode;
-        id = createRes.id;
-        // Start the live transcription mic tap before SCK attaches its
-        // recording output. On macOS, opening AVAudioEngine after SCK has
-        // started writing can reconfigure the shared input device and leave
-        // SCK's microphone leg near-silent while Whisper still hears audio.
-        await startNativeTranscriptionBeforeRecording();
-        await warmMic(createRes.id);
-        return createRes.id;
-      })();
+      // Once create returns an id, warm SCK with deferred_output in parallel
+      // with any remaining Whisper startup. Begin/attach still waits on
+      // transcription settling first (AVAudioEngine after SCK writing can mute
+      // the SCK mic leg).
+      const warmAndId = planNativeFullscreenWarmOverlap({
+        createRecording: async () => {
+          const createRes = await recordingPromise;
+          uploadMode = createRes.uploadMode;
+          id = createRes.id;
+          return createRes;
+        },
+        startTranscription: async () => {
+          const transcriptionStartedAt = Date.now();
+          try {
+            await transcriptionPromise;
+          } finally {
+            console.log(
+              `[clips-recorder] transcription warm durationMs=${Date.now() - transcriptionStartedAt}`,
+            );
+          }
+        },
+        warmMic: async (recordingId) => {
+          const warmStartedAt = Date.now();
+          try {
+            await warmMic(recordingId);
+          } finally {
+            console.log(
+              `[clips-recorder] native warm durationMs=${Date.now() - warmStartedAt}`,
+            );
+          }
+        },
+      });
       try {
-        const [, warmedId] = await Promise.all([countdownPromise, warmAndId]);
-        id = warmedId;
+        const [, createRes] = await Promise.all([countdownPromise, warmAndId]);
+        id = createRes.id;
+        uploadMode = createRes.uploadMode ?? uploadMode;
       } catch (err) {
         abortCreatedRecordingOnCountdownCancel(
           err,
@@ -1905,11 +1956,16 @@ async function startNativeFullscreenRecording(
 
     await audioCue.playBeforeCapture();
     // Phase 2: attach the recording output now that the mic is warm (or do a
-    // normal immediate start if warming was skipped/failed).
+    // normal immediate start if warming was skipped/failed). Transcription has
+    // already been awaited above so AVAudioEngine won't reconfigure mid-write.
+    const beginStartedAt = Date.now();
     await invoke("native_fullscreen_recording_begin", {
       recordingId: id,
       ...captureAudioParams,
     });
+    console.log(
+      `[clips-recorder] native begin durationMs=${Date.now() - beginStartedAt} clickToLiveMs=${Date.now() - clickStartedAt}`,
+    );
     await transcriptionCapture?.resetTimeline().catch((err) => {
       console.warn(
         "[clips-recorder] transcription timeline reset failed:",
@@ -2021,7 +2077,26 @@ async function startNativeFullscreenRecording(
       stopPromise = (async () => {
         stopped = true;
         console.log("[clips-recorder] native full-screen stop requested");
+        // Tear chrome down immediately with finalizing so the live camera bubble /
+        // toolbar don't linger while ScreencaptureKit finalize + upload run.
+        // hide_recording_chrome leaves the bubble; close_bubble destroys it.
+        // Order matters: show finalizing first, and never call hide_overlays here
+        // because that also closes the finalizing window.
         if (!localOnly) showFinalizingFeedback();
+        await invoke("hide_recording_chrome").catch((err) =>
+          console.error(
+            "[clips-recorder] immediate hide_recording_chrome after stop failed:",
+            err,
+          ),
+        );
+        if (wantsCamera) {
+          await invoke("close_bubble").catch((err) =>
+            console.error(
+              "[clips-recorder] immediate close_bubble after stop failed:",
+              err,
+            ),
+          );
+        }
         clearSegmentRotator();
         if (tickHandle) {
           clearInterval(tickHandle);
@@ -3226,6 +3301,9 @@ async function startRecordingInner(
           label: params.micLabel,
         },
         wantsSystemAudio,
+        // Match native path: VoiceProcessingIO AEC/ducking on a shared mic
+        // can tank live call volume and attenuate the recorded mic leg.
+        { voiceProcessing: false },
       )
     : null;
   // Stop/Cancel can fire during the await above — at that point stop()/cancel()