@agent-native/core 0.98.16 → 0.99.0

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

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

@@ -14,6 +14,9 @@
 //!  * **Call-end heuristic** — best-effort: if a known video-conferencing
 //!    bundle id (Zoom, Google Meet wrapper, MS Teams) goes from frontmost
 //!    to background for >2 minutes, emit `meetings:call-ended`.
+//!  * **Calendar end** — when the scheduled meeting end has passed and both
+//!    audio sources have been quiet for the call-end window, emit the same
+//!    event even if the conferencing app remains frontmost.
 //!
 //! Renderer-side responsibility: subscribe via `silence-events.ts`, dispatch
 //! the `stop-meeting-recording` action when any of the events fire.
@@ -40,7 +43,7 @@
 //! trick is equivalent and uses constant memory.
 
 use std::sync::{Arc, Mutex, OnceLock};
-use std::time::{Duration, Instant};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 use serde::Deserialize;
 use tauri::{AppHandle, Emitter, Listener, Manager};
@@ -66,6 +69,10 @@ pub struct SilenceConfig {
     /// Whether to enable the call-ended heuristic.
     #[serde(default = "default_true")]
     pub watch_call_ended: bool,
+    /// Unix epoch milliseconds for the calendar event's scheduled end.
+    /// Calendar-end stopping still requires quiet audio as confirmation.
+    #[serde(default)]
+    pub scheduled_end_ms: Option<u64>,
 }
 
 fn default_threshold() -> f32 {
@@ -108,6 +115,8 @@ struct DetectorInner {
     system: Option<SourceState>,
     /// Already fired the silence-stop event in this session?
     silence_fired: bool,
+    /// Calendar event end for the active session, if one is known.
+    scheduled_end_ms: Option<u64>,
 }
 
 pub struct DetectorState {
@@ -142,6 +151,7 @@ pub fn silence_detector_start(app: AppHandle, config: Option<SilenceConfig>) ->
         call_ended_ms: default_call_ended_ms(),
         watch_sleep: true,
         watch_call_ended: true,
+        scheduled_end_ms: None,
     });
 
     // Install the audio-level listener exactly once for the process.
@@ -185,6 +195,7 @@ pub fn silence_detector_start(app: AppHandle, config: Option<SilenceConfig>) ->
         g.active = true;
         g.silence_fired = false;
         g.config = Some(cfg.clone());
+        g.scheduled_end_ms = cfg.scheduled_end_ms;
         // Seed both buckets with `now()` so we don't insta-fire on start
         // before any audio has streamed in yet.
         g.mic = Some(SourceState::fresh());
@@ -198,9 +209,10 @@ pub fn silence_detector_start(app: AppHandle, config: Option<SilenceConfig>) ->
     let inner_for_supervisor = state.inner.clone();
     let app_for_supervisor = app.clone();
     let silence_window = Duration::from_millis(cfg.silence_ms);
+    let calendar_end_quiet_window = Duration::from_millis(cfg.call_ended_ms);
     std::thread::spawn(move || loop {
         std::thread::sleep(Duration::from_secs(5));
-        let should_fire = {
+        let stop_reason = {
             let g = match inner_for_supervisor.lock() {
                 Ok(g) => g,
                 Err(_) => return,
@@ -209,7 +221,7 @@ pub fn silence_detector_start(app: AppHandle, config: Option<SilenceConfig>) ->
                 return; // session ended or replaced — exit
             }
             if g.silence_fired {
-                false
+                None
             } else {
                 let now = Instant::now();
                 let mic_silent = g
@@ -222,14 +234,39 @@ pub fn silence_detector_start(app: AppHandle, config: Option<SilenceConfig>) ->
                     .as_ref()
                     .map(|s| now.duration_since(s.last_loud_at) >= silence_window)
                     .unwrap_or(false);
-                mic_silent && system_silent
+                let mic_quiet_for_calendar_end = g
+                    .mic
+                    .as_ref()
+                    .map(|s| now.duration_since(s.last_loud_at) >= calendar_end_quiet_window)
+                    .unwrap_or(false);
+                let system_quiet_for_calendar_end = g
+                    .system
+                    .as_ref()
+                    .map(|s| now.duration_since(s.last_loud_at) >= calendar_end_quiet_window)
+                    .unwrap_or(false);
+                if calendar_end_stop_ready(
+                    g.scheduled_end_ms,
+                    unix_now_ms(),
+                    mic_quiet_for_calendar_end && system_quiet_for_calendar_end,
+                ) {
+                    Some("calendar")
+                } else if mic_silent && system_silent {
+                    Some("silence")
+                } else {
+                    None
+                }
             }
         };
-        if should_fire {
+        if let Some(reason) = stop_reason {
             if let Ok(mut g) = inner_for_supervisor.lock() {
                 g.silence_fired = true;
             }
-            let _ = app_for_supervisor.emit("meetings:silence-stop", ());
+            let event = if reason == "calendar" {
+                "meetings:call-ended"
+            } else {
+                "meetings:silence-stop"
+            };
+            let _ = app_for_supervisor.emit(event, ());
         }
     });
 
@@ -255,6 +292,7 @@ pub fn silence_detector_stop(app: AppHandle) -> Result<(), String> {
     g.silence_fired = false;
     g.mic = None;
     g.system = None;
+    g.scheduled_end_ms = None;
     Ok(())
 }
 
@@ -331,6 +369,7 @@ fn install_call_ended_watcher(app: &AppHandle, threshold_ms: u64) {
             let mut ever_seen_front = false;
             let mut last_front_at: Option<Instant> = None;
             let mut fired = false;
+            let mut last_front_was_generic_browser = false;
             loop {
                 std::thread::sleep(Duration::from_secs(10));
                 let state = app.state::<DetectorState>();
@@ -339,6 +378,7 @@ fn install_call_ended_watcher(app: &AppHandle, threshold_ms: u64) {
                     ever_seen_front = false;
                     last_front_at = None;
                     fired = false;
+                    last_front_was_generic_browser = false;
                     continue;
                 }
                 let front = crate::util::frontmost_bundle_id();
@@ -353,26 +393,28 @@ fn install_call_ended_watcher(app: &AppHandle, threshold_ms: u64) {
                 if is_strong_vc || is_generic_browser {
                     ever_seen_front = true;
                     last_front_at = Some(Instant::now());
+                    last_front_was_generic_browser = is_generic_browser;
                 }
-                if ever_seen_front && !fired {
-                    if let Some(t) = last_front_at {
-                        let backgrounded_ms = Instant::now().duration_since(t).as_millis() as u64;
-                        if backgrounded_ms >= threshold_ms {
-                            // Require audio corroboration before auto-stopping
-                            // for a generic browser: the frontmost-app signal
-                            // alone is too weak (backgrounding Chrome to check
-                            // email doesn't mean the Meet tab's call ended).
-                            // Native VC clients keep the fast, uncorroborated
-                            // path since a dedicated conferencing app losing
-                            // focus for minutes is a much stronger signal.
-                            let audio_corroborates =
-                                !is_generic_browser || audio_recently_silent(&state, threshold_ms);
-                            if audio_corroborates {
-                                let _ = app.emit("meetings:call-ended", ());
-                                fired = true;
-                            }
-                        }
-                    }
+                if fired {
+                    continue;
+                }
+
+                let frontmost_call_ended = ever_seen_front
+                    && last_front_at
+                        .map(|t| {
+                            Instant::now().duration_since(t).as_millis() as u64 >= threshold_ms
+                        })
+                        .unwrap_or(false)
+                    // Require audio corroboration for browser-hosted calls:
+                    // backgrounding Chrome/Arc alone does not prove that the
+                    // Meet tab ended. Use the last known conference app, not
+                    // the unrelated app now in front.
+                    && (!last_front_was_generic_browser
+                        || audio_recently_silent(&state, threshold_ms));
+
+                if frontmost_call_ended {
+                    let _ = app.emit("meetings:call-ended", ());
+                    fired = true;
                 }
             }
         });
@@ -382,6 +424,23 @@ fn install_call_ended_watcher(app: &AppHandle, threshold_ms: u64) {
 #[cfg(not(target_os = "macos"))]
 fn install_call_ended_watcher(_app: &AppHandle, _threshold_ms: u64) {}
 
+fn scheduled_end_reached(scheduled_end_ms: Option<u64>, now_ms: u64) -> bool {
+    scheduled_end_ms
+        .map(|end_ms| now_ms >= end_ms)
+        .unwrap_or(false)
+}
+
+fn calendar_end_stop_ready(scheduled_end_ms: Option<u64>, now_ms: u64, audio_quiet: bool) -> bool {
+    scheduled_end_reached(scheduled_end_ms, now_ms) && audio_quiet
+}
+
+fn unix_now_ms() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis() as u64
+}
+
 /// Corroboration check for the generic-browser call-ended signal: true only
 /// if BOTH mic and system audio have been quiet for at least `threshold_ms`.
 /// Reuses the same per-source `last_loud_at` tracking the silence-stop
@@ -408,3 +467,23 @@ fn audio_recently_silent(state: &tauri::State<'_, DetectorState>, threshold_ms:
         .unwrap_or(false);
     mic_silent && system_silent
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{calendar_end_stop_ready, scheduled_end_reached};
+
+    #[test]
+    fn calendar_end_requires_a_known_end_and_allows_the_exact_boundary() {
+        assert!(!scheduled_end_reached(None, 10_000));
+        assert!(!scheduled_end_reached(Some(10_001), 10_000));
+        assert!(scheduled_end_reached(Some(10_000), 10_000));
+        assert!(scheduled_end_reached(Some(9_999), 10_000));
+    }
+
+    #[test]
+    fn calendar_end_stop_also_requires_quiet_audio() {
+        assert!(!calendar_end_stop_ready(Some(9_999), 10_000, false));
+        assert!(calendar_end_stop_ready(Some(9_999), 10_000, true));
+        assert!(!calendar_end_stop_ready(Some(10_001), 10_000, true));
+    }
+}

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

@@ -115,6 +115,7 @@ pub async fn audio_transcription_start(
     mic_device_label: Option<String>,
     capture_system: Option<bool>,
     voice_processing: Option<bool>,
+    emit_partials: Option<bool>,
     owner: Option<String>,
 ) -> Result<(), String> {
     let _ = meeting_id;
@@ -128,6 +129,9 @@ pub async fn audio_transcription_start(
         // create a second VoiceProcessingIO stack beside a live call app.
         // Short dictation sessions opt in explicitly from the renderer.
         voice_processing.unwrap_or(false),
+        // Existing meeting callers depend on live partials. Recording capture
+        // explicitly opts out because it only persists final segments.
+        emit_partials.unwrap_or(true),
         owner,
     )
     .await