@agent-native/core 0.98.17 → 0.99.1

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"}`}

package/corpus/templates/clips/desktop/src/overlays/recording-pill.tsx

@@ -352,9 +352,18 @@ export function RecordingPill() {
     );
 
     const startMs = Date.now();
+    let lastDrawMs = 0;
+    // A bar meter reads the same to the eye 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 pill is hidden.
+    const FRAME_INTERVAL_MS = 1000 / 20;
     const tick = () => {
+      rafRef.current = requestAnimationFrame(tick);
+      const nowMs = Date.now();
+      if (nowMs - lastDrawMs < FRAME_INTERVAL_MS) return;
+      lastDrawMs = nowMs;
       // Modulo prevents float precision loss on long recordings.
-      const t = (Date.now() - startMs) % 1_000_000;
+      const t = (nowMs - startMs) % 1_000_000;
       for (const s of setups) {
         const target = Math.min(1, s.levelRef.current * s.gain);
 
@@ -385,7 +394,6 @@ export function RecordingPill() {
         }
         s.ctx2d.shadowBlur = 0;
       }
-      rafRef.current = requestAnimationFrame(tick);
     };
     tick();
     return () => {

package/corpus/templates/clips/desktop/src-tauri/Cargo.toml

@@ -124,7 +124,12 @@ screencapturekit = { version = "2.0.0", features = ["macos_15_0"] }
 # AudioBufferList type so we can hand SCK's CMSampleBuffer audio bytes to
 # AVAudioPCMBuffer for the speech recognizer.
 objc2-core-audio-types = "0.3"
-whisper-rs = { version = "0.16.0" }
+# `metal` builds whisper.cpp's ggml-metal backend and links it in (the sys
+# crate's build script embeds the compiled metallib, so no app-bundle/runtime
+# asset changes are needed). Without it, whisper.cpp decode runs CPU-only.
+# `use_gpu` is still set explicitly per-arch in whisper_speech.rs so Intel
+# Macs don't exercise Metal even though the feature is compiled in.
+whisper-rs = { version = "0.16.0", features = ["metal"] }
 # NOTE: We hand-roll the few EventKit selectors we need via raw `objc2`
 # msg_send! in `eventkit.rs` rather than depending on the `objc2-event-kit`
 # crate. Its API surface drifts between minor 0.3.x releases (and not

package/corpus/templates/clips/desktop/src-tauri/src/notifications.rs

@@ -6,8 +6,13 @@
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Mutex;
-use tauri::{AppHandle, Emitter, Manager, PhysicalPosition, PhysicalSize, WebviewWindowBuilder};
+use std::time::Duration;
+use tauri::{
+    AppHandle, Emitter, Manager, PhysicalPosition, PhysicalSize, WebviewWindow,
+    WebviewWindowBuilder,
+};
 
 use crate::dlog;
 use crate::util::{
@@ -54,6 +59,75 @@ fn notification_rect(app: &AppHandle) -> (u32, u32, i32, i32) {
     (w, h, x, top.max(0))
 }
 
+static MEETING_NOTIF_HOVER_TRACKING: AtomicBool = AtomicBool::new(false);
+
+/// True when the global cursor sits inside the notification window's frame.
+/// Mirrors `cursor_inside_pill_frame` in `recording_indicator.rs`: cursor and
+/// frame both come from Tauri (physical px, desktop top-left origin), so the
+/// test is a plain point-in-rect with no AppKit hop.
+fn cursor_inside_notification_frame(window: &WebviewWindow) -> bool {
+    let (Ok(c), Ok(p), Ok(s)) = (
+        window.cursor_position(),
+        window.outer_position(),
+        window.outer_size(),
+    ) else {
+        return false;
+    };
+    c.x >= p.x as f64
+        && c.x <= (p.x + s.width as i32) as f64
+        && c.y >= p.y as f64
+        && c.y <= (p.y + s.height as i32) as f64
+}
+
+/// Poll the cursor against the notification frame and emit
+/// `meetings:notification-hover` on transitions. The window never becomes key
+/// (`show_without_activation` uses `orderFrontRegardless`, not
+/// `makeKeyAndOrderFront:`), so CSS `:hover`/`onMouseEnter` only fires once
+/// the user's first click makes it key — this poll is the fallback that
+/// reveals the close button on real hover before that click, same pattern as
+/// `start_pill_hover_tracking`. Idempotent — a second call is a no-op while a
+/// loop is already running.
+fn start_meeting_notification_hover_tracking(app: &AppHandle) {
+    if MEETING_NOTIF_HOVER_TRACKING.swap(true, Ordering::SeqCst) {
+        return;
+    }
+    let app = app.clone();
+    tauri::async_runtime::spawn(async move {
+        let mut prev = false;
+        while MEETING_NOTIF_HOVER_TRACKING.load(Ordering::Relaxed) {
+            let Some(win) = app.get_webview_window(MEETING_NOTIFICATION_LABEL) else {
+                break;
+            };
+            // The window is reused across notifications (hidden/shown from
+            // the frontend, never destroyed), so this loop runs for the rest
+            // of the app session. Skip the cursor/frame queries entirely
+            // while hidden — no notification is on screen to hover — and
+            // back off to a slower idle tick until it's shown again.
+            if !win.is_visible().unwrap_or(false) {
+                if prev {
+                    prev = false;
+                    let _ = win.emit(
+                        "meetings:notification-hover",
+                        serde_json::json!({ "hovered": false }),
+                    );
+                }
+                tokio::time::sleep(Duration::from_millis(250)).await;
+                continue;
+            }
+            let inside = cursor_inside_notification_frame(&win);
+            if inside != prev {
+                prev = inside;
+                let _ = win.emit(
+                    "meetings:notification-hover",
+                    serde_json::json!({ "hovered": inside }),
+                );
+            }
+            tokio::time::sleep(Duration::from_millis(80)).await;
+        }
+        MEETING_NOTIF_HOVER_TRACKING.store(false, Ordering::SeqCst);
+    });
+}
+
 pub fn show_meeting_notification_window(app: &AppHandle) -> Result<(), String> {
     let (w, h, x, y) = notification_rect(app);
     if let Some(existing) = app.get_webview_window(MEETING_NOTIFICATION_LABEL) {
@@ -61,6 +135,7 @@ pub fn show_meeting_notification_window(app: &AppHandle) -> Result<(), String> {
         let _ = existing.set_position(PhysicalPosition::new(x, y));
         configure_overlay_behavior(&existing);
         show_without_activation(&existing);
+        start_meeting_notification_hover_tracking(&app);
         return Ok(());
     }
 
@@ -97,6 +172,7 @@ pub fn show_meeting_notification_window(app: &AppHandle) -> Result<(), String> {
     // own recording chrome is still excluded elsewhere so it won't leak.)
     configure_overlay_behavior(&win);
     show_without_activation(&win);
+    start_meeting_notification_hover_tracking(&app);
     Ok(())
 }