@agent-native/core 0.91.1 → 0.92.0

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()

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

@@ -1,16 +1,33 @@
-import { IconAlertCircle, IconClock, IconX } from "@tabler/icons-react";
+import {
+  IconAlertCircle,
+  IconChevronDown,
+  IconNotes,
+  IconVideo,
+  IconX,
+} from "@tabler/icons-react";
 import { invoke } from "@tauri-apps/api/core";
+import { LogicalSize } from "@tauri-apps/api/dpi";
 import { emit, listen } from "@tauri-apps/api/event";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import { open as openExternal } from "@tauri-apps/plugin-shell";
 import { useEffect, useRef, useState } from "react";
 
+import {
+  detectMeetingJoinProvider,
+  joinProviderLabel,
+  meetingNotificationAutoHideMs,
+  type MeetingJoinProvider,
+} from "../lib/meeting-notification-timing";
+
 interface NotificationData {
   type: "calendar" | "adhoc";
   title: string;
   subtitle: string;
   meetingId: string;
   joinUrl?: string | null;
+  platform?: string | null;
+  scheduledStart?: string | null;
+  scheduledEnd?: string | null;
   autoStart?: boolean;
 }
 
@@ -19,12 +36,14 @@ interface TranscriptionStatusPayload {
   error?: string;
 }
 
-const DEFAULT_AUTO_HIDE_MS = 30_000;
 const SNOOZE_MS = 5 * 60_000;
+const FALLBACK_AUTO_HIDE_MS = 6 * 60_000;
+const NOTIFICATION_WINDOW_WIDTH = 440;
+const NOTIFICATION_COLLAPSED_HEIGHT = 120;
+const NOTIFICATION_MENU_HEIGHT = 224;
 
 /**
- * Open a meeting join URL via the Tauri shell plugin. Used by the
- * notification's dedicated Join CTA (notes start is a separate action).
+ * Open a meeting join URL via the Tauri shell plugin.
  */
 async function openJoinUrl(url: string | null | undefined): Promise<void> {
   if (!url) return;
@@ -35,40 +54,90 @@ async function openJoinUrl(url: string | null | undefined): Promise<void> {
   }
 }
 
+function resizeNotificationWindow(expanded: boolean) {
+  const height = expanded
+    ? NOTIFICATION_MENU_HEIGHT
+    : NOTIFICATION_COLLAPSED_HEIGHT;
+  getCurrentWindow()
+    .setSize(new LogicalSize(NOTIFICATION_WINDOW_WIDTH, height))
+    .catch((err) => {
+      console.warn("[clips-meeting-notif] resize failed", err);
+    });
+}
+
+function ProviderGlyph({ provider }: { provider: MeetingJoinProvider }) {
+  // Lightweight glyphs — keep the overlay free of extra assets. Zoom blue
+  // camera / Meet green / Teams purple, otherwise a generic video icon.
+  if (provider === "zoom") {
+    return (
+      <span
+        className="meeting-notification-provider meeting-notification-provider-zoom"
+        aria-hidden
+      >
+        <IconVideo size={14} stroke={2.2} />
+      </span>
+    );
+  }
+  if (provider === "meet") {
+    return (
+      <span
+        className="meeting-notification-provider meeting-notification-provider-meet"
+        aria-hidden
+      >
+        <IconVideo size={14} stroke={2.2} />
+      </span>
+    );
+  }
+  if (provider === "teams") {
+    return (
+      <span
+        className="meeting-notification-provider meeting-notification-provider-teams"
+        aria-hidden
+      >
+        <IconVideo size={14} stroke={2.2} />
+      </span>
+    );
+  }
+  return (
+    <span
+      className="meeting-notification-provider meeting-notification-provider-other"
+      aria-hidden
+    >
+      <IconNotes size={14} stroke={2.2} />
+    </span>
+  );
+}
+
 /**
  * Granola-style meeting notification — small card in the top-right corner.
- * Variants:
  *
- *   - Calendar event: solid left bar (green), meeting title, time,
- *     "Start notes" + optional "Join" + "Snooze 5 min" buttons.
- *   - Ad-hoc call: dashed left bar (slate), "Call detected", app name,
- *     same controls.
+ * Primary split button: join the call and open Clips notes in one click.
+ * Chevron exposes secondary actions (join only / notes only / snooze).
  *
- * Data arrives via Tauri event `meetings:show-notification`. Auto-hides
- * after 30s by default. Hover pauses the auto-hide timer. Errors from the
- * persistent popover transcription session surface inline beneath the title
- * so the user isn't left wondering why nothing happened.
+ * Data arrives via Tauri event `meetings:show-notification`. Visibility holds
+ * from 1 minute before start until 5 minutes after, unless dismissed.
  */
 export function MeetingNotification() {
   const [data, setData] = useState<NotificationData | null>(null);
   const [showClose, setShowClose] = useState(false);
+  const [menuOpen, setMenuOpen] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [pending, setPending] = useState(false);
   const autoHideTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const dataRef = useRef<NotificationData | null>(null);
 
-  // Keep a ref to the latest data so the transcription-status listeners can
-  // match incoming events against the meeting currently on screen without
-  // re-subscribing on every render.
   useEffect(() => {
     dataRef.current = data;
   }, [data]);
 
-  // The notification window is a single persistent overlay (created once at
-  // startup so it can receive `meetings:show-notification` events). Drive its
-  // OS-level visibility from React state: a shown-but-empty transparent window
-  // would otherwise sit at the top of the screen swallowing clicks. Visible
-  // only while there's a notification on screen.
+  useEffect(() => {
+    resizeNotificationWindow(Boolean(data && menuOpen));
+  }, [data, menuOpen]);
+
+  useEffect(() => {
+    return () => resizeNotificationWindow(false);
+  }, []);
+
   useEffect(() => {
     const win = getCurrentWindow();
     if (data) {
@@ -84,8 +153,15 @@ export function MeetingNotification() {
   ) {
     setData(payload);
     setError(null);
+    setMenuOpen(false);
     setPending(!!payload.autoStart && !options?.hydrated);
-    scheduleAutoHide(DEFAULT_AUTO_HIDE_MS);
+    const startMs = payload.scheduledStart
+      ? Date.parse(payload.scheduledStart)
+      : NaN;
+    const hideMs = Number.isFinite(startMs)
+      ? meetingNotificationAutoHideMs(startMs)
+      : FALLBACK_AUTO_HIDE_MS;
+    scheduleAutoHide(hideMs);
   }
 
   useEffect(() => {
@@ -112,6 +188,15 @@ export function MeetingNotification() {
       }),
     );
 
+    // Cold overlay boot: hydrate any payload stored before this webview
+    // mounted (calendar or adhoc).
+    invoke<NotificationData | null>("take_pending_meeting_notification")
+      .then((pending) => {
+        if (stopped || !pending) return;
+        showNotification(pending, { hydrated: true });
+      })
+      .catch(() => {});
+
     trackListen(
       listen<TranscriptionStatusPayload>("meetings:hide-notification", (ev) => {
         if (ev.payload.meetingId !== dataRef.current?.meetingId) return;
@@ -154,14 +239,30 @@ export function MeetingNotification() {
 
   function scheduleAutoHide(ms: number) {
     clearAutoHide();
+    if (ms <= 0) {
+      hideNotification();
+      return;
+    }
     autoHideTimerRef.current = setTimeout(() => hideNotification(), ms);
   }
 
+  function resumeAutoHide() {
+    const current = dataRef.current;
+    const startMs = current?.scheduledStart
+      ? Date.parse(current.scheduledStart)
+      : NaN;
+    const hideMs = Number.isFinite(startMs)
+      ? meetingNotificationAutoHideMs(startMs)
+      : FALLBACK_AUTO_HIDE_MS;
+    scheduleAutoHide(hideMs);
+  }
+
   function hideNotification() {
     clearAutoHide();
     setData(null);
     setError(null);
     setPending(false);
+    setMenuOpen(false);
     dataRef.current = null;
   }
 
@@ -169,6 +270,7 @@ export function MeetingNotification() {
     if (!data || pending) return;
     setPending(true);
     setError(null);
+    setMenuOpen(false);
     emit("meetings:start-transcription", {
       meetingId: data.meetingId,
       joinUrl: data.joinUrl,
@@ -181,14 +283,23 @@ export function MeetingNotification() {
 
   async function joinMeeting() {
     if (!data?.joinUrl) return;
+    setMenuOpen(false);
     await openJoinUrl(data.joinUrl);
   }
 
+  /** Granola primary: join the call and start Clips notes together. */
+  async function joinAndOpenClips() {
+    if (!data || pending) return;
+    setMenuOpen(false);
+    if (data.joinUrl) {
+      await openJoinUrl(data.joinUrl);
+    }
+    await takeNotes();
+  }
+
   function snooze() {
     if (!data) return;
-    // Hand the snooze to the Rust watcher so the reminder re-fires after the
-    // delay even though this overlay window closes right away. A setTimeout
-    // here would be torn down with the window and never fire.
+    setMenuOpen(false);
     invoke("meetings_snooze", {
       meetingId: data.meetingId,
       minutes: Math.round(SNOOZE_MS / 60_000),
@@ -202,6 +313,14 @@ export function MeetingNotification() {
 
   const isCalendar = data.type === "calendar";
   const hasJoin = Boolean(data.joinUrl);
+  const provider = detectMeetingJoinProvider(data.joinUrl, data.platform);
+  const providerName = joinProviderLabel(provider);
+  const primaryLabel = hasJoin
+    ? provider === "other"
+      ? "Join meeting"
+      : `Join ${providerName}`
+    : "Start notes";
+  const secondaryLabel = hasJoin ? "& open Clips" : null;
 
   return (
     <div
@@ -212,14 +331,11 @@ export function MeetingNotification() {
       }}
       onMouseLeave={() => {
         setShowClose(false);
-        // Resume the auto-hide timer with the remaining-ish budget.
-        // Cheap approximation: just restart the full timer on leave.
-        scheduleAutoHide(DEFAULT_AUTO_HIDE_MS);
+        setMenuOpen(false);
+        resumeAutoHide();
       }}
     >
-      <div
-        className={`meeting-notification${hasJoin ? " meeting-notification-with-join" : ""}`}
-      >
+      <div className="meeting-notification">
         <div
           className={`meeting-notification-bar ${isCalendar ? "meeting-notification-bar-calendar" : "meeting-notification-bar-adhoc"}`}
         />
@@ -233,34 +349,65 @@ export function MeetingNotification() {
             </div>
           ) : null}
         </div>
-        <div className="meeting-notification-actions">
+        <div className="meeting-notification-split">
           <button
-            className="meeting-notification-btn meeting-notification-btn-primary"
-            onClick={takeNotes}
+            className="meeting-notification-split-main"
+            onClick={hasJoin ? joinAndOpenClips : takeNotes}
             disabled={pending}
             data-no-drag
           >
-            {pending ? "Starting…" : "Start notes"}
+            <ProviderGlyph provider={provider} />
+            <span className="meeting-notification-split-copy">
+              <span className="meeting-notification-split-primary">
+                {pending ? "Starting…" : primaryLabel}
+              </span>
+              {secondaryLabel && !pending ? (
+                <span className="meeting-notification-split-secondary">
+                  {secondaryLabel}
+                </span>
+              ) : null}
+            </span>
           </button>
-          {hasJoin ? (
-            <button
-              className="meeting-notification-btn meeting-notification-btn-secondary"
-              onClick={joinMeeting}
-              data-no-drag
-            >
-              Join
-            </button>
-          ) : null}
           <button
-            className="meeting-notification-btn meeting-notification-btn-secondary"
-            onClick={snooze}
+            className="meeting-notification-split-chevron"
+            onClick={() => setMenuOpen((open) => !open)}
+            aria-label="More actions"
+            aria-expanded={menuOpen}
             data-no-drag
-            aria-label="Snooze 5 minutes"
-            title="Snooze 5 min"
           >
-            <IconClock size={12} aria-hidden="true" />
-            <span>5m</span>
+            <IconChevronDown size={14} aria-hidden="true" />
           </button>
+          {menuOpen ? (
+            <div className="meeting-notification-menu" role="menu">
+              {hasJoin ? (
+                <button
+                  role="menuitem"
+                  className="meeting-notification-menu-item"
+                  onClick={joinMeeting}
+                  data-no-drag
+                >
+                  Join only
+                </button>
+              ) : null}
+              <button
+                role="menuitem"
+                className="meeting-notification-menu-item"
+                onClick={takeNotes}
+                disabled={pending}
+                data-no-drag
+              >
+                Start notes only
+              </button>
+              <button
+                role="menuitem"
+                className="meeting-notification-menu-item"
+                onClick={snooze}
+                data-no-drag
+              >
+                Snooze 5 min
+              </button>
+            </div>
+          ) : null}
         </div>
         {showClose ? (
           <button