@agent-native/core 0.98.16 → 0.99.0

package/corpus/templates/clips/app/routes/record.tsx

@@ -843,7 +843,6 @@ export default function RecordRoute() {
   const [error, setError] = useState<string | null>(null);
   const [isPaused, setIsPaused] = useState(false);
   const visibilityAutoPausedRef = useRef(false);
-  const [elapsedMs, setElapsedMs] = useState(0);
   const [cameraStream, setCameraStream] = useState<MediaStream | null>(null);
   const [cameraSize, setCameraSize] = useState<CameraBubbleSize>(
     () => loadRecorderPreferences().cameraSize ?? "md",
@@ -985,35 +984,15 @@ export default function RecordRoute() {
     micDeviceLabel?: string | null;
     cameraDeviceId: string | null;
   } | null>(null);
-  const tickRef = useRef<number | null>(null);
   const previewVideoRef = useRef<HTMLVideoElement>(null);
   const fileUploadAbortRef = useRef<AbortController | null>(null);
   const browserDiagnosticsRef = useRef<BrowserDiagnosticsCapture | null>(null);
   // Bumped by doCancel() to invalidate any in-flight startFlow().
   const startSessionRef = useRef(0);
 
-  // -------------------------------------------------------------------------
-  // Timer
-  // -------------------------------------------------------------------------
-  useEffect(() => {
-    if (uiState !== "recording") {
-      if (tickRef.current !== null) {
-        window.clearInterval(tickRef.current);
-        tickRef.current = null;
-      }
-      return;
-    }
-    tickRef.current = window.setInterval(() => {
-      const e = engineRef.current?.getElapsedMs() ?? 0;
-      setElapsedMs(e);
-    }, 250);
-    return () => {
-      if (tickRef.current !== null) {
-        window.clearInterval(tickRef.current);
-        tickRef.current = null;
-      }
-    };
-  }, [uiState]);
+  // Elapsed-time display now ticks inside RecordingToolbar itself (via
+  // `active` + `getElapsedMs`) so the ~4x/sec poll doesn't re-render this
+  // whole route — see the `active`/`getElapsedMs` props passed below.
 
   // -------------------------------------------------------------------------
   // Wire preview stream into its video element.
@@ -2671,7 +2650,8 @@ export default function RecordRoute() {
       {/* Floating toolbar */}
       {showRecordingUi && (
         <RecordingToolbar
-          elapsedMs={elapsedMs}
+          active={uiState === "recording"}
+          getElapsedMs={() => engineRef.current?.getElapsedMs() ?? 0}
           isPaused={isPaused}
           onTogglePause={togglePause}
           onStop={() => void doStop()}

package/corpus/templates/clips/changelog/2026-07-13-clips-desktop-now-requires-macos-13-for-native-capture.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-13
+---
+
+Clips Desktop now declares its macOS 13 minimum consistently with the native ScreenCaptureKit and Metal capture stack.

package/corpus/templates/clips/changelog/2026-07-13-clips-hide-solo-meeting-reminders.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-13
+---
+
+Clips no longer shows meeting-notes reminders for calendar events attended only by you.

package/corpus/templates/clips/changelog/2026-07-13-clips-now-removes-duplicate-mic-and-system-transcript-turns-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-13
+---
+
+Clips now removes duplicate mic and system transcript turns and filters more silent-audio hallucinations.

package/corpus/templates/clips/changelog/2026-07-13-desktop-recordings-run-cooler-and-quieter-live-transcription.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-13
+---
+
+Desktop recordings run cooler and quieter: live transcription now uses the GPU on Apple Silicon

package/corpus/templates/clips/changelog/2026-07-13-meeting-recordings-now-stop-after-a-calendar-meeting-ends-an.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-13
+---
+
+Meeting recordings now stop after a calendar meeting ends and goes quiet

package/corpus/templates/clips/changelog/2026-07-13-meeting-transcripts-now-use-a-clean-agent-chat-style-reading.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-13
+---
+
+Meeting transcripts now use a clean, agent-chat-style reading layout instead of chat bubbles.

package/corpus/templates/clips/changelog/2026-07-13-screen-recordings-use-less-processing-power-during-longer-ca.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-13
+---
+
+Screen recordings use less processing power during longer captures

package/corpus/templates/clips/chrome-extension/src/background.ts

@@ -258,9 +258,11 @@ type OverlayPart = "bubble" | "countdown" | "toolbar" | "saving";
 let overlayPhase: OverlayPhase = "idle";
 let overlayBaseElapsedMs = 0;
 let overlayBaseEpochMs = 0;
-// Bubble during the countdown preview (any camera). During recording, the face
-// is composited into the video by the offscreen for screen+camera, so we only
-// show the on-page bubble for camera-only mode (recordingShowsBubble).
+// Bubble during the countdown preview (any camera). The offscreen document does
+// NOT composite the camera into screen recordings — that compositor code path is
+// unreachable because screen mode never acquires a camera stream (see
+// offscreen.ts acquire()). So the on-page bubble is the only place the face shows
+// up, for both camera-only AND screen+camera recording (recordingShowsBubble).
 let overlayShowsBubble = false;
 let recordingShowsBubble = false;
 // Cross-tab follow: when true, the overlay is pushed to whatever tab the user

package/corpus/templates/clips/chrome-extension/src/offscreen.ts

@@ -23,6 +23,11 @@ import {
   type AudioInputFallback,
 } from "@shared/media-device-selection";
 import { scheduleReadyChime } from "@shared/recording-audio";
+import {
+  SCREEN_CAPTURE_FRAME_RATE,
+  screenCaptureVideoConstraints,
+  type ScreenCaptureSurface,
+} from "@shared/recording-capture";
 import {
   chunkUploadUrl,
   pickMimeType,
@@ -300,19 +305,10 @@ async function streamDimensions(
 }
 
 function displayConstraints(
-  surface: "browser" | "window" | "monitor",
+  surface: ScreenCaptureSurface,
 ): MediaStreamConstraints {
-  const displaySurface =
-    surface === "browser"
-      ? "browser"
-      : surface === "window"
-        ? "window"
-        : "monitor";
   return {
-    video: {
-      frameRate: { ideal: 30, max: 30 },
-      ...({ displaySurface } as object),
-    },
+    video: screenCaptureVideoConstraints(surface),
     audio: {
       echoCancellation: false,
       noiseSuppression: false,
@@ -373,6 +369,10 @@ function cameraConstraints(deviceId: string): MediaTrackConstraints {
   const base: MediaTrackConstraints = {
     width: { ideal: 1280 },
     height: { ideal: 720 },
+    frameRate: {
+      ideal: SCREEN_CAPTURE_FRAME_RATE,
+      max: SCREEN_CAPTURE_FRAME_RATE,
+    },
   };
   if (deviceId) base.deviceId = { exact: deviceId };
   else base.facingMode = "user";
@@ -750,7 +750,7 @@ async function buildCompositor(
   };
   raf = requestAnimationFrame(draw);
 
-  const canvasStream = canvas.captureStream(30);
+  const canvasStream = canvas.captureStream(SCREEN_CAPTURE_FRAME_RATE);
   return {
     videoTrack: canvasStream.getVideoTracks()[0],
     canvasStream,
@@ -1194,8 +1194,11 @@ async function begin(message: BeginMessage): Promise<{
   const mimeType = pickMimeType() || "video/webm";
   const recorder = new MediaRecorder(outputStream, {
     mimeType,
-    // Crisp 1080p capture — matches the web/desktop recorders. Files upload
-    // directly (no client-side shrink), so we favor sharpness over a budget.
+    // Crisp 1080p capture — matches the web/desktop recorders. displayConstraints()
+    // (see screenCaptureVideoConstraints in @shared/recording-capture) caps retina/5K
+    // surfaces down to 1920x1080 before this point, so the software VP8 encoder is
+    // never fed native-resolution frames. Files upload directly (no client-side
+    // shrink), so within that cap we favor sharpness over a bitrate budget.
     videoBitsPerSecond: 8_000_000,
     audioBitsPerSecond: 128_000,
   });

package/corpus/templates/clips/chrome-extension/src/overlay.ts

@@ -1,4 +1,6 @@
 import "./overlay.css";
+import { SCREEN_CAPTURE_FRAME_RATE } from "@shared/recording-capture";
+
 import { captureExtensionError, initExtensionSentry } from "./sentry";
 
 initExtensionSentry("overlay");
@@ -31,8 +33,12 @@ function isDeviceUnavailableError(error: unknown): boolean {
 
 function cameraConstraint(deviceId: string): MediaTrackConstraints {
   const video: MediaTrackConstraints = {
-    width: { ideal: 640 },
-    height: { ideal: 640 },
+    width: { ideal: 480 },
+    height: { ideal: 480 },
+    frameRate: {
+      ideal: SCREEN_CAPTURE_FRAME_RATE,
+      max: SCREEN_CAPTURE_FRAME_RATE,
+    },
   };
   if (deviceId) video.deviceId = { exact: deviceId };
   else video.facingMode = "user";

package/corpus/templates/clips/desktop/README.md

@@ -2,6 +2,9 @@
 
 A small Tauri 2.x tray app for macOS, Windows, and Linux. Click the icon — or press the global shortcut `Cmd/Ctrl+Shift+L` — to open a popover with:
 
+The macOS desktop build requires macOS 13 or newer because its native
+ScreenCaptureKit and Metal transcription dependencies target that SDK.
+
 - **New recording** button (opens `/record` on your configured Clips server)
 - **Recent** — your three most recent recordings
 - Quick links to **Open library** and **Settings**

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

@@ -260,6 +260,7 @@ export function useMeetingTranscription({
       try {
         const result = await callClipsAction<{
           meetingId?: string;
+          scheduledEnd?: string | null;
           recording?: { id?: string | null } | null;
         }>("start-meeting-recording", { meetingId });
         const resolvedMeetingId = result.meetingId ?? meetingId;
@@ -268,6 +269,13 @@ export function useMeetingTranscription({
           throw new Error("Could not create a transcript session.");
         }
 
+        const parsedScheduledEndMs = result.scheduledEnd
+          ? Date.parse(result.scheduledEnd)
+          : Number.NaN;
+        const scheduledEndMs = Number.isFinite(parsedScheduledEndMs)
+          ? parsedScheduledEndMs
+          : null;
+
         const session: MeetingTranscriptionSession = {
           meetingId: resolvedMeetingId,
           recordingId,
@@ -366,6 +374,7 @@ export function useMeetingTranscription({
           silenceThreshold: 0.05,
           silenceMs: 15 * 60 * 1000,
           callEndedMs: 2 * 60 * 1000,
+          scheduledEndMs,
           watchSleep: true,
           watchCallEnded: true,
         };

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

@@ -81,6 +81,7 @@ import {
   type CapturedTranscript,
   type TranscriptionCapture,
 } from "./transcription-capture";
+import { shouldResampleVideoForUpload } from "./upload-video-stream";
 
 export type { LocalExportedFile } from "./local-export";
 export { planNativeFullscreenWarmOverlap } from "./native-recording-warm";
@@ -98,7 +99,7 @@ export interface RegionCaptureRect {
 const NATIVE_FULLSCREEN_RECORDING_FLAG = "clips:native-fullscreen-recording";
 const DEV_SYNTHETIC_CAPTURE_FLAG = "clips:dev-synthetic-capture";
 const LEGACY_DEV_REAL_CAPTURE_FLAG = "clips:dev-real-capture";
-const LIVE_UPLOAD_CHUNK_MS = 1_000;
+const LIVE_UPLOAD_CHUNK_MS = 2_000;
 const NATIVE_FULLSCREEN_SEGMENT_MS = 5 * 60_000;
 const NATIVE_FULLSCREEN_MIME_TYPE = "video/mp4";
 // GCS resumable uploads require every non-final chunk to be a multiple of
@@ -302,6 +303,11 @@ function createUploadOptimizedVideoStream(
   }
 
   const sourceSize = videoTrackDimensions(source);
+  if (
+    !shouldResampleVideoForUpload(sourceSize, CLOUD_RECORDING_MAX_LONG_EDGE)
+  ) {
+    return { stream: source, cleanup() {} };
+  }
   const initial = scaledVideoDimensions(
     sourceSize.width ?? 1280,
     sourceSize.height ?? 720,
@@ -3216,8 +3222,8 @@ async function startRecordingInner(
   // resumable session with the correct content type when the server supports
   // streaming uploads.
   const mimeCandidates = [
-    "video/webm;codecs=vp9,opus",
     "video/webm;codecs=vp8,opus",
+    "video/webm;codecs=vp9,opus",
     "video/webm",
   ];
   const mimeType =

package/corpus/templates/clips/desktop/src/lib/silence-events.ts

@@ -23,6 +23,7 @@ export interface SilenceConfig {
   silenceThreshold?: number;
   silenceMs?: number;
   callEndedMs?: number;
+  scheduledEndMs?: number | null;
   watchSleep?: boolean;
   watchCallEnded?: boolean;
 }

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

@@ -337,6 +337,10 @@ export async function startTranscriptionCapture(
       mic,
       captureSystem,
       voiceProcessing: opts?.voiceProcessing,
+      // Recordings only persist final segments. Meetings use the same engine
+      // directly and retain live partials, but repeatedly inferring partials
+      // here burns CPU without any recording UI consuming them.
+      emitPartials: false,
     });
     console.log(
       `[clips-recorder] transcription started (${engine} mic${captureSystem ? "+system" : ""})`,
@@ -367,6 +371,7 @@ export async function startTranscriptionCapture(
           mic,
           captureSystem,
           voiceProcessing: opts?.voiceProcessing,
+          emitPartials: false,
         });
         // stop()/cancel() can run during the await above; if it did, the new
         // engine would leak (mic/system capture stays live). Tear it down.

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

@@ -30,6 +30,9 @@ export interface SourcedTranscriptSegment extends TranscriptSegment {
   source: TranscriptSource;
 }
 
+const DUPLICATE_TOKEN_OVERLAP = 0.72;
+const DUPLICATE_TIME_OVERLAP = 0.35;
+
 export interface FinalTranscriptEvent {
   /** Raw text (not trimmed); callers decide whether to skip empties. */
   text: string;
@@ -70,6 +73,97 @@ export function speakerFor(
   return source === "system" ? "Them" : "Me";
 }
 
+function normalizedTranscriptText(text: string): string {
+  return text
+    .normalize("NFKC")
+    .toLocaleLowerCase()
+    .replace(/[^\p{L}\p{N}]+/gu, " ")
+    .trim();
+}
+
+function transcriptWords(text: string): string[] {
+  const normalized = normalizedTranscriptText(text);
+  return normalized ? normalized.split(/\s+/) : [];
+}
+
+function tokenOverlap(left: string[], right: string[]): number {
+  if (left.length === 0 || right.length === 0) return 0;
+
+  const rightWords = new Set(right);
+  const sharedWords = new Set(left.filter((word) => rightWords.has(word)));
+  return sharedWords.size / Math.min(new Set(left).size, new Set(right).size);
+}
+
+function timeOverlapRatio(
+  left: SourcedTranscriptSegment,
+  right: SourcedTranscriptSegment,
+): number {
+  const overlapStart = Math.max(left.startMs, right.startMs);
+  const overlapEnd = Math.min(left.endMs, right.endMs);
+  const overlapMs = Math.max(0, overlapEnd - overlapStart);
+  const shorterDuration = Math.max(
+    1,
+    Math.min(left.endMs - left.startMs, right.endMs - right.startMs),
+  );
+
+  return overlapMs / shorterDuration;
+}
+
+function isDuplicateTranscriptSegment(
+  existing: SourcedTranscriptSegment,
+  incoming: SourcedTranscriptSegment,
+): boolean {
+  if (existing.source === incoming.source) return false;
+
+  const existingText = normalizedTranscriptText(existing.text);
+  const incomingText = normalizedTranscriptText(incoming.text);
+  const existingWords = transcriptWords(existing.text);
+  const incomingWords = transcriptWords(incoming.text);
+
+  if (
+    !existingText ||
+    !incomingText ||
+    existingWords.length < 3 ||
+    incomingWords.length < 3
+  ) {
+    return false;
+  }
+
+  if (timeOverlapRatio(existing, incoming) < DUPLICATE_TIME_OVERLAP) {
+    return false;
+  }
+
+  return (
+    existingText === incomingText ||
+    tokenOverlap(existingWords, incomingWords) >= DUPLICATE_TOKEN_OVERLAP
+  );
+}
+
+function isDuplicateTranscriptLine(
+  lines: string[],
+  source: TranscriptSource,
+  text: string,
+): boolean {
+  const words = transcriptWords(text);
+  if (words.length < 4) return false;
+
+  const speaker = speakerFor(source);
+  return lines.some((line) => {
+    const separatorIndex = line.indexOf(":");
+    if (separatorIndex === -1 || line.slice(0, separatorIndex) === speaker) {
+      return false;
+    }
+
+    const existingText = line.slice(separatorIndex + 1);
+    const existingWords = transcriptWords(existingText);
+    return (
+      normalizedTranscriptText(existingText) ===
+        normalizedTranscriptText(text) ||
+      tokenOverlap(existingWords, words) >= DUPLICATE_TOKEN_OVERLAP
+    );
+  });
+}
+
 /**
  * Fold a final-transcript event into a running transcript: appends a
  * speaker-labelled line and the event's (non-empty) segments tagged with the
@@ -83,14 +177,39 @@ export function appendFinalTranscript(
 ): boolean {
   const text = event.text.trim();
   if (!text) return false;
-  lines.push(`${speakerFor(event.source)}: ${text}`);
-  for (const seg of event.segments) {
-    const segText = seg.text?.trim();
-    if (!segText) continue;
+
+  if (event.segments.length === 0) {
+    if (isDuplicateTranscriptLine(lines, event.source, text)) return false;
+
+    lines.push(`${speakerFor(event.source)}: ${text}`);
+    return true;
+  }
+
+  const uniqueSegments = event.segments.filter((segment) => {
+    const segText = segment.text?.trim();
+    if (!segText) return false;
+
+    return !segments.some((existing) =>
+      isDuplicateTranscriptSegment(existing, {
+        ...segment,
+        text: segText,
+        source: event.source,
+      }),
+    );
+  });
+
+  if (uniqueSegments.length === 0) return false;
+
+  lines.push(
+    `${speakerFor(event.source)}: ${uniqueSegments
+      .map((segment) => segment.text.trim())
+      .join(" ")}`,
+  );
+  for (const seg of uniqueSegments) {
     segments.push({
       startMs: seg.startMs,
       endMs: seg.endMs,
-      text: segText,
+      text: seg.text.trim(),
       source: event.source,
     });
   }
@@ -120,6 +239,7 @@ export async function restartTranscriptionEngine(
   mic?: MicSelection,
   captureSystem: boolean = true,
   voiceProcessing: boolean = false,
+  emitPartials: boolean = true,
 ): Promise<void> {
   if (engine === "whisper") {
     await invoke("audio_transcription_start", {
@@ -129,6 +249,7 @@ export async function restartTranscriptionEngine(
       micDeviceLabel: mic?.label || null,
       captureSystem,
       voiceProcessing,
+      emitPartials,
       owner: "meeting",
     });
   } else {
@@ -157,15 +278,23 @@ export async function startTranscriptionEngine(opts: {
    * only when combined ScreenCaptureKit capture is unavailable or fails.
    */
   voiceProcessing?: boolean;
+  /**
+   * Emit recurring live partial transcripts while speech is in progress.
+   * Meetings render these updates; recordings only persist final segments and
+   * disable them to avoid repeatedly transcribing the same growing buffer.
+   */
+  emitPartials?: boolean;
 }): Promise<TranscriptionEngine> {
   const captureSystem = opts.captureSystem ?? true;
   const voiceProcessing = opts.voiceProcessing ?? false;
+  const emitPartials = opts.emitPartials ?? true;
   try {
     await restartTranscriptionEngine(
       "whisper",
       opts.mic,
       captureSystem,
       voiceProcessing,
+      emitPartials,
     );
     return "whisper";
   } catch (err) {

package/corpus/templates/clips/desktop/src/lib/upload-video-stream.ts

@@ -0,0 +1,28 @@
+export interface VideoDimensions {
+  width: number | null;
+  height: number | null;
+}
+
+function isPositiveNumber(value: number | null): value is number {
+  return value !== null && Number.isFinite(value) && value > 0;
+}
+
+/**
+ * Whether upload capture needs a canvas-backed resize pass.
+ *
+ * Unknown dimensions stay on the defensive resize path. A source that is
+ * already within the upload budget can go straight to MediaRecorder, avoiding
+ * a full-frame draw on the renderer thread for every captured frame.
+ */
+export function shouldResampleVideoForUpload(
+  dimensions: VideoDimensions,
+  maxLongEdge: number,
+): boolean {
+  if (
+    !isPositiveNumber(dimensions.width) ||
+    !isPositiveNumber(dimensions.height)
+  ) {
+    return true;
+  }
+  return Math.max(dimensions.width, dimensions.height) > maxLongEdge;
+}

package/corpus/templates/clips/desktop/src/overlays/flow-bar.tsx

@@ -83,8 +83,17 @@ export function FlowBar() {
     const BAR_COUNT = 14;
     const BAR_WIDTH = 2;
     const BAR_GAP = 3;
+    // A bar waveform reads the same well below display refresh rate
+    // (60-120Hz); cap the actual draw work to ~20fps while still scheduling
+    // via rAF every frame so the loop still pauses when the bar is hidden.
+    const FRAME_INTERVAL_MS = 1000 / 20;
+    let lastDrawMs = 0;
+
+    function draw(timestamp: number) {
+      rafRef.current = requestAnimationFrame(draw);
+      if (timestamp - lastDrawMs < FRAME_INTERVAL_MS) return;
+      lastDrawMs = timestamp;
 
-    function draw() {
       const canvas = canvasRef.current;
       if (!canvas) return;
       const ctx = canvas.getContext("2d");
@@ -119,8 +128,6 @@ export function FlowBar() {
         ctx.roundRect(x, y, BAR_WIDTH, h, 1);
         ctx.fill();
       }
-
-      rafRef.current = requestAnimationFrame(draw);
     }
 
     rafRef.current = requestAnimationFrame(draw);

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

@@ -128,6 +128,16 @@ export function MeetingNotification() {
   const [pending, setPending] = useState(false);
   const autoHideTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const dataRef = useRef<NotificationData | null>(null);
+  // Real DOM hover only fires while this overlay window is key, which macOS
+  // won't grant it without a click (`show_without_activation` never
+  // activates). `polledHovered` mirrors the Rust-side global cursor poll
+  // (`meetings:notification-hover`, see `start_meeting_notification_hover_tracking`
+  // in notifications.rs) so the X still reveals on hover while another app is
+  // focused — same fallback pattern as the recording pill's `clips:pill-hover`.
+  const [domHovered, setDomHovered] = useState(false);
+  const [polledHovered, setPolledHovered] = useState(false);
+  const hovered = domHovered || polledHovered;
+  const prevHoveredRef = useRef(false);
 
   useEffect(() => {
     dataRef.current = data;
@@ -150,6 +160,30 @@ export function MeetingNotification() {
     }
   }, [data]);
 
+  useEffect(() => {
+    if (!data) {
+      // Dismissing doesn't guarantee mouseleave/hovered:false fires first
+      // (e.g. dismissed while the cursor is still over the card), so clear
+      // every hover source here — otherwise the next notification can
+      // inherit hovered === true and open with its close button already
+      // showing and auto-hide already cancelled.
+      prevHoveredRef.current = false;
+      setDomHovered(false);
+      setPolledHovered(false);
+      setShowClose(false);
+      return;
+    }
+    if (hovered === prevHoveredRef.current) return;
+    prevHoveredRef.current = hovered;
+    setShowClose(hovered);
+    if (hovered) {
+      clearAutoHide();
+    } else {
+      setMenuOpen(false);
+      resumeAutoHide();
+    }
+  }, [data, hovered]);
+
   function showNotification(
     payload: NotificationData,
     options?: { hydrated?: boolean },
@@ -191,6 +225,12 @@ export function MeetingNotification() {
       }),
     );
 
+    trackListen(
+      listen<{ hovered: boolean }>("meetings:notification-hover", (ev) => {
+        setPolledHovered(ev.payload.hovered);
+      }),
+    );
+
     // Cold overlay boot: hydrate any payload stored before this webview
     // mounted (calendar or adhoc).
     invoke<NotificationData | null>("take_pending_meeting_notification")
@@ -329,15 +369,8 @@ export function MeetingNotification() {
     <div className="meeting-notification-root">
       <div
         className="meeting-notification"
-        onMouseEnter={() => {
-          setShowClose(true);
-          clearAutoHide();
-        }}
-        onMouseLeave={() => {
-          setShowClose(false);
-          setMenuOpen(false);
-          resumeAutoHide();
-        }}
+        onMouseEnter={() => setDomHovered(true)}
+        onMouseLeave={() => setDomHovered(false)}
       >
         <div
           className={`meeting-notification-bar ${isCalendar ? "meeting-notification-bar-calendar" : "meeting-notification-bar-adhoc"}`}