@agent-native/core 0.152.1 → 0.153.0

package/corpus/templates/clips/app/lib/thumbnail-picker-state.ts

@@ -0,0 +1,93 @@
+import type { ThumbnailSpec } from "./timestamp-mapping";
+
+export type ThumbnailPickerTab = "upload" | "frame" | "gif";
+
+export interface ThumbnailPickerState {
+  tab: ThumbnailPickerTab;
+  frameTime: number;
+  gifStart: number;
+  gifDuration: number;
+}
+
+const DEFAULT_GIF_DURATION_MS = 3_000;
+const MIN_GIF_DURATION_MS = 500;
+const MAX_GIF_DURATION_MS = 10_000;
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+function finiteNumber(value: unknown, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return value;
+}
+
+function parseGifValue(value: string): {
+  startMs?: unknown;
+  durationMs?: unknown;
+} {
+  try {
+    const parsed: unknown = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object") return {};
+    return parsed as { startMs?: unknown; durationMs?: unknown };
+  } catch {
+    // coercion-ok: malformed saved GIF metadata falls back to safe picker defaults.
+    return {};
+  }
+}
+
+export function resolveThumbnailPickerState(
+  thumbnail: ThumbnailSpec | null | undefined,
+  options: {
+    durationMs: number;
+    hasAnimatedThumbnail?: boolean;
+  },
+): ThumbnailPickerState {
+  const durationMs = Math.max(0, finiteNumber(options.durationMs, 0));
+  const frameMax = Math.max(1_000, durationMs);
+  const defaultGifDuration = clamp(
+    DEFAULT_GIF_DURATION_MS,
+    MIN_GIF_DURATION_MS,
+    MAX_GIF_DURATION_MS,
+  );
+
+  if (thumbnail?.kind === "frame") {
+    return {
+      tab: "frame",
+      frameTime: clamp(finiteNumber(Number(thumbnail.value), 0), 0, frameMax),
+      gifStart: 0,
+      gifDuration: defaultGifDuration,
+    };
+  }
+
+  if (thumbnail?.kind === "gif") {
+    const gif = parseGifValue(thumbnail.value);
+    const gifDuration = clamp(
+      finiteNumber(gif.durationMs, defaultGifDuration),
+      MIN_GIF_DURATION_MS,
+      MAX_GIF_DURATION_MS,
+    );
+    return {
+      tab: "gif",
+      frameTime: 0,
+      gifStart: clamp(
+        finiteNumber(gif.startMs, 0),
+        0,
+        Math.max(0, durationMs - gifDuration),
+      ),
+      gifDuration,
+    };
+  }
+
+  return {
+    tab:
+      thumbnail?.kind === "url"
+        ? "upload"
+        : options.hasAnimatedThumbnail
+          ? "gif"
+          : "frame",
+    frameTime: 0,
+    gifStart: 0,
+    gifDuration: defaultGifDuration,
+  };
+}

package/corpus/templates/clips/app/routes/_app.meetings.$meetingId.tsx

@@ -322,7 +322,7 @@ export default function MeetingDetailRoute() {
       segmentsJson?: TranscriptSegment[] | null;
     } | null;
     recording?: { id: string; durationMs?: number | null } | null;
-    role?: "owner" | "admin" | "editor" | "viewer";
+    role?: "owner" | "admin" | "editor" | "commenter" | "viewer";
   };
 
   const { data, isLoading, isError } = useActionQuery<GetMeetingResp>(

package/corpus/templates/clips/app/routes/r.$recordingId.tsx

@@ -379,6 +379,7 @@ export default function RecordingPage() {
     | "owner"
     | "admin"
     | "editor"
+    | "commenter"
     | "viewer"
     | undefined;
   const comments = playerDataQ.data?.comments ?? [];
@@ -391,6 +392,11 @@ export default function RecordingPage() {
   const transcriptCleanup = playerDataQ.data?.transcript?.cleanup ?? null;
   const ctas = playerDataQ.data?.ctas ?? [];
   const canEdit = role === "owner" || role === "admin" || role === "editor";
+  const canComment =
+    role === "owner" ||
+    role === "admin" ||
+    role === "editor" ||
+    role === "commenter";
   useEffect(() => {
     if (!canEdit && (panel === "insights" || panel === "settings")) {
       setPanel("comments");
@@ -1051,11 +1057,7 @@ export default function RecordingPage() {
         <p className="text-sm text-muted-foreground mb-4 max-w-md text-center">
           {failureReason}
         </p>
-        {isFailure &&
-        !storageSetupFailure &&
-        detail &&
-        role &&
-        role !== "viewer" ? (
+        {isFailure && !storageSetupFailure && detail && role && canEdit ? (
           <div className="mb-4 w-full max-w-xl rounded-md border border-border bg-card p-4 text-start shadow-sm">
             <div className="mb-2 text-xs font-medium uppercase tracking-wide text-muted-foreground">
               {t("recordingPage.details")}
@@ -1254,6 +1256,7 @@ export default function RecordingPage() {
             currentMs={currentMs}
             currentUserEmail={session?.email}
             enableComments={recording.enableComments}
+            canComment={canComment}
             onSeek={(ms) => playerRef.current?.seek(ms)}
             queryKey={[
               "action",
@@ -1615,7 +1618,7 @@ export default function RecordingPage() {
                   onCommentClick={openCommentsPanel}
                   className="h-full w-full rounded-none sm:rounded-xl"
                 />
-                {commentOpen ? (
+                {commentOpen && canComment ? (
                   <TimestampedCommentBar
                     recordingId={recording.id}
                     atMs={commentAtMs}
@@ -1667,21 +1670,24 @@ export default function RecordingPage() {
                     </NavLink>
                   ) : null}
                   <div className="flex flex-wrap items-center gap-2">
-                    <TimestampedCommentButton
-                      enableComments={recording.enableComments}
-                      className="shrink-0"
-                      onOpen={() => {
-                        if (isCompactLayout) {
-                          openCommentsPanel();
-                          return;
-                        }
-                        setCommentAtMs(resolvePlaybackMs());
-                        setCommentOpen(true);
-                      }}
-                    />
+                    {canComment ? (
+                      <TimestampedCommentButton
+                        enableComments={recording.enableComments}
+                        canComment={canComment}
+                        className="shrink-0"
+                        onOpen={() => {
+                          if (isCompactLayout) {
+                            openCommentsPanel();
+                            return;
+                          }
+                          setCommentAtMs(resolvePlaybackMs());
+                          setCommentOpen(true);
+                        }}
+                      />
+                    ) : null}
                     {recording.enableReactions ? (
                       <ReactionsTray
-                        disabled={!recording.enableReactions}
+                        disabled={!recording.enableReactions || !canComment}
                         onReact={(emoji) => {
                           tracking.reportReaction(emoji);
                           const liveMs = resolvePlaybackMs();

package/corpus/templates/clips/app/routes/share.$shareId.tsx

@@ -518,6 +518,7 @@ export default function ShareRoute() {
     | "owner"
     | "admin"
     | "editor"
+    | "commenter"
     | "viewer"
     | undefined;
   const viewerCanEdit =
@@ -525,6 +526,11 @@ export default function ShareRoute() {
     viewerRole === "owner" ||
     viewerRole === "admin" ||
     viewerRole === "editor";
+  const viewerCanComment =
+    viewerRole === "owner" ||
+    viewerRole === "admin" ||
+    viewerRole === "editor" ||
+    viewerRole === "commenter";
   const viewerIsOwner = Boolean(dataQ.data?.data?.viewer?.isOwner);
   const viewerCanOpenDashboard = Boolean(
     dataQ.data?.data?.viewer?.canOpenDashboard,
@@ -1048,6 +1054,7 @@ export default function ShareRoute() {
             <div className="flex max-w-full flex-col items-stretch gap-2 sm:items-end">
               {recording.enableReactions ? (
                 <ReactionsTray
+                  disabled={!viewerCanComment}
                   onReact={(emoji) => {
                     if (!session) {
                       requireSignIn("react");
@@ -1182,6 +1189,7 @@ export default function ShareRoute() {
               currentMs={currentMs}
               currentUserEmail={session?.email}
               enableComments={recording.enableComments}
+              canComment={viewerCanComment}
               onSeek={(ms) => playerRef.current?.seek(ms)}
               onUnauthenticated={requireSignIn}
               queryKey={[

package/corpus/templates/clips/changelog/2026-07-23-meeting-recording-meters-and-dismissed-prompts.md

@@ -3,4 +3,4 @@ type: fixed
 date: 2026-07-23
 ---
 
-Meeting recording meters now use thin, responsive audio bars, while dismissed reminders stay dismissed and frontmost Zoom detection stays quiet unless Auto mode is enabled.
+Meeting recording meters now use thin, responsive audio bars, and dismissed reminders stay dismissed.

package/corpus/templates/clips/changelog/2026-08-11-clips-asks-to-take-notes-again-when-you-join-an-adhoc-zoom-o.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-11
+---
+
+Clips asks to take notes again when you join an adhoc Zoom or Teams call, and now waits until the call is actually live before offering.

package/corpus/templates/clips/changelog/2026-08-12-viewers-are-read-only-and-commenters-can-comment.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-12
+---
+
+Shared recordings now distinguish read-only viewers from commenters who can comment and react without editing the recording.

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

@@ -1,10 +1,10 @@
 //! Granola-style adhoc Zoom / Teams detection.
 //!
 //! Polls the frontmost macOS app every few seconds. When Zoom or Teams stays
-//! frontmost for a short dwell window, creates a meeting row via
-//! `create-meeting`, and silently starts transcription when the user has
-//! explicitly selected Auto mode. Ask/manual mode stays quiet because a
-//! frontmost Zoom window is not reliable evidence of an active call.
+//! frontmost for a short dwell window *and* that app is holding a live audio
+//! input, creates a meeting row via `create-meeting` and shows the same
+//! meeting-notification overlay used for calendar reminders — with
+//! `type: "adhoc"`.
 //!
 //! Reuses `MeetingsWatcherState` session (server URL + cookie + auth token)
 //! so the popover only needs to push credentials once.
@@ -130,6 +130,50 @@ fn match_vc_bundle(bundle: &str) -> Option<(&'static str, &'static str)> {
         .map(|(_, platform, title)| (*platform, *title))
 }
 
+/// Bundle ids belonging to one platform, lowercased for CoreAudio comparison.
+///
+/// Scoped to the frontmost platform rather than every call app: Teams sitting
+/// in a call must not vouch for a Zoom window that is merely open.
+fn bundles_for_platform(platform: &str) -> Vec<String> {
+    STRONG_VC_BUNDLES
+        .iter()
+        .filter(|(_, candidate, _)| *candidate == platform)
+        .map(|(bundle_id, _, _)| bundle_id.to_lowercase())
+        .collect()
+}
+
+/// Whether a live-input reading should veto a dwell-confirmed detection.
+///
+/// Only an explicit `Some(false)` blocks. `None` means the OS declined to
+/// answer — `kAudioProcessPropertyIsRunningInput` is macOS 14+ — and treating
+/// that as "no call" would leave every older machine detecting nothing at all,
+/// which is the failure mode this whole branch exists to undo.
+fn mic_vetoes_detection(mic_running: Option<bool>) -> bool {
+    mic_running == Some(false)
+}
+
+/// What a dwell-confirmed detection is allowed to do under the current mode.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct AdhocNotificationPlan {
+    /// Surface the meeting-notification overlay so the user can accept.
+    show_widget: bool,
+    /// Begin transcription without waiting for a click.
+    auto_start: bool,
+}
+
+/// Ask must surface the overlay. Collapsing this gate to `mode == Auto` is the
+/// regression that shipped in b00c38db4: Ask is the shipped default, so ad-hoc
+/// detection produced neither a prompt nor a capture and went silently dead.
+fn adhoc_notification_plan(config: &crate::config::FeatureConfig) -> AdhocNotificationPlan {
+    let auto_start = config.meeting_transcription_mode == MeetingTranscriptionMode::Auto;
+    AdhocNotificationPlan {
+        show_widget: config.show_meeting_widget_enabled
+            || config.meeting_transcription_mode == MeetingTranscriptionMode::Ask
+            || auto_start,
+        auto_start,
+    }
+}
+
 async fn tick_once(app: &AppHandle, client: &reqwest::Client) -> Result<(), String> {
     let config = feature_config(app);
     if !config.meetings_enabled {
@@ -158,7 +202,7 @@ async fn tick_macos(
     let front = crate::util::frontmost_bundle_id();
     let matched = front.as_deref().and_then(match_vc_bundle);
 
-    let Some((platform, _title)) = matched else {
+    let Some((platform, title)) = matched else {
         // VC app left front — clear session dedupe so a later re-focus can
         // fire again (cooldown still applies).
         clear_session_if_left(app, None);
@@ -174,7 +218,22 @@ async fn tick_macos(
         return Ok(());
     }
 
-    if config.meeting_transcription_mode != MeetingTranscriptionMode::Auto {
+    if config.meeting_transcription_mode == MeetingTranscriptionMode::Manual
+        && !config.show_meeting_widget_enabled
+    {
+        reset_dwell(app);
+        return Ok(());
+    }
+
+    // Frontmost dwell alone also matches Zoom parked on a second monitor or
+    // opened to check a schedule — the reason prompting was muted in the first
+    // place. A live input stream is what separates an app being open from a
+    // call being underway. `None` means the OS could not answer (the property
+    // is macOS 14+), so fall back to dwell-only rather than going silently
+    // dead on older systems.
+    let call_bundles = bundles_for_platform(platform);
+    let mic_running = crate::call_activity::call_app_uses_microphone(&call_bundles);
+    if mic_vetoes_detection(mic_running) {
         reset_dwell(app);
         return Ok(());
     }
@@ -249,14 +308,44 @@ async fn tick_macos(
         }
     };
 
-    let _ = app.emit(
-        "meetings:start-transcription",
-        serde_json::json!({
-            "meetingId": meeting_id,
-            "joinUrl": null,
-            "reason": "adhoc-auto",
-        }),
-    );
+    let AdhocNotificationPlan {
+        show_widget,
+        auto_start,
+    } = adhoc_notification_plan(config);
+
+    if show_widget {
+        let app_clone = app.clone();
+        let id_clone = meeting_id.clone();
+        let title_clone = title.to_string();
+        let platform_clone = platform.to_string();
+        let scheduled_start = chrono::Utc::now().to_rfc3339();
+        tauri::async_runtime::spawn(async move {
+            let _ = crate::notifications::notify_meeting_starting(
+                app_clone,
+                id_clone,
+                title_clone,
+                0,
+                None,
+                Some(scheduled_start),
+                None,
+                Some(platform_clone),
+                Some(auto_start),
+                Some("adhoc".to_string()),
+            )
+            .await;
+        });
+    }
+
+    if auto_start {
+        let _ = app.emit(
+            "meetings:start-transcription",
+            serde_json::json!({
+                "meetingId": meeting_id,
+                "joinUrl": null,
+                "reason": "adhoc-auto",
+            }),
+        );
+    }
 
     Ok(())
 }
@@ -265,6 +354,69 @@ async fn tick_macos(
 mod tests {
     use super::*;
 
+    fn config_with(
+        mode: MeetingTranscriptionMode,
+        show_meeting_widget_enabled: bool,
+    ) -> crate::config::FeatureConfig {
+        crate::config::FeatureConfig {
+            meeting_transcription_mode: mode,
+            show_meeting_widget_enabled,
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn platform_bundles_do_not_vouch_for_each_other() {
+        let zoom = bundles_for_platform("zoom");
+        assert!(zoom.contains(&"us.zoom.xos".to_string()));
+        assert!(zoom.contains(&"us.zoom.zoomclips".to_string()));
+        assert!(!zoom.iter().any(|id| id.contains("teams")));
+
+        let teams = bundles_for_platform("teams");
+        assert!(teams.contains(&"com.microsoft.teams2".to_string()));
+        assert!(!teams.iter().any(|id| id.contains("zoom")));
+
+        assert!(bundles_for_platform("webex").is_empty());
+    }
+
+    #[test]
+    fn an_unreadable_microphone_does_not_veto_detection() {
+        // Only a definite "not in a call" blocks. Collapsing None into false
+        // would make ad-hoc detection dead on macOS 13, where the CoreAudio
+        // property does not exist — the exact silent-death this branch undoes.
+        assert!(mic_vetoes_detection(Some(false)));
+        assert!(!mic_vetoes_detection(Some(true)));
+        assert!(!mic_vetoes_detection(None));
+    }
+
+    #[test]
+    fn ask_mode_prompts_without_auto_starting() {
+        // The b00c38db4 regression: Ask is the shipped default, so if this
+        // stops surfacing the overlay, ad-hoc detection is dead for everyone
+        // who never opened Settings.
+        let plan = adhoc_notification_plan(&config_with(MeetingTranscriptionMode::Ask, false));
+        assert!(plan.show_widget);
+        assert!(!plan.auto_start);
+    }
+
+    #[test]
+    fn auto_mode_prompts_and_starts() {
+        let plan = adhoc_notification_plan(&config_with(MeetingTranscriptionMode::Auto, false));
+        assert!(plan.show_widget);
+        assert!(plan.auto_start);
+    }
+
+    #[test]
+    fn manual_mode_stays_silent_only_when_the_widget_is_disabled() {
+        let hidden = adhoc_notification_plan(&config_with(MeetingTranscriptionMode::Manual, false));
+        assert!(!hidden.show_widget);
+        assert!(!hidden.auto_start);
+
+        let shown = adhoc_notification_plan(&config_with(MeetingTranscriptionMode::Manual, true));
+        assert!(shown.show_widget);
+        assert!(!shown.auto_start);
+    }
+
     #[test]
     fn dismissal_refreshes_the_existing_cooldown_and_clears_dwell() {
         let now_ts = 1_000;

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

@@ -0,0 +1,146 @@
+//! Whether a conferencing app is holding a live audio input right now.
+//!
+//! Both meeting watchers read this, from opposite ends of a call: the ad-hoc
+//! detector treats a running input as corroboration that a call actually
+//! started, and the silence detector treats its release as evidence one ended.
+
+#[cfg(target_os = "macos")]
+pub(crate) fn default_call_app_bundle_ids() -> Vec<String> {
+    [
+        "us.zoom.xos",
+        "us.zoom.ZoomClips",
+        "com.microsoft.teams2",
+        "com.microsoft.teams",
+    ]
+    .into_iter()
+    .map(|bundle_id| bundle_id.to_lowercase())
+    .collect()
+}
+
+/// Returns whether one of the target conferencing apps currently has a live
+/// CoreAudio input stream. `None` means the OS could not provide a reliable
+/// answer, so callers must keep the existing conservative fallbacks.
+///
+/// `kAudioProcessPropertyIsRunningInput` is macOS 14+, so an older system is a
+/// `None` and never a `Some(false)`. Callers that collapse the two make the
+/// feature silently dead on Sonoma-minus rather than degraded.
+///
+/// Observation only: this enumerates process objects and never opens an input
+/// unit. A detector that grabbed one while idle would fight `whisper_speech`,
+/// which holds VPIO with uplink processing bypassed precisely so a call app
+/// cannot starve Clips of mic buffers.
+#[cfg(target_os = "macos")]
+pub(crate) fn call_app_uses_microphone(bundle_ids: &[String]) -> Option<bool> {
+    use core_foundation::base::TCFType;
+    use core_foundation::string::CFString;
+    use objc2_core_audio::{
+        kAudioHardwareNoError, kAudioHardwarePropertyProcessObjectList,
+        kAudioObjectPropertyElementMain, kAudioObjectPropertyScopeGlobal, kAudioObjectSystemObject,
+        kAudioProcessPropertyBundleID, kAudioProcessPropertyIsRunningInput,
+        AudioObjectGetPropertyData, AudioObjectGetPropertyDataSize, AudioObjectID,
+        AudioObjectPropertyAddress,
+    };
+    use std::ffi::c_void;
+    use std::mem::size_of;
+    use std::ptr::NonNull;
+
+    let mut list_address = AudioObjectPropertyAddress {
+        mSelector: kAudioHardwarePropertyProcessObjectList,
+        mScope: kAudioObjectPropertyScopeGlobal,
+        mElement: kAudioObjectPropertyElementMain,
+    };
+    let mut data_size = 0;
+    let list_status = unsafe {
+        AudioObjectGetPropertyDataSize(
+            kAudioObjectSystemObject as AudioObjectID,
+            NonNull::from(&mut list_address),
+            0,
+            std::ptr::null(),
+            NonNull::from(&mut data_size),
+        )
+    };
+    if list_status != kAudioHardwareNoError || data_size == 0 {
+        return None;
+    }
+
+    let mut processes = vec![0 as AudioObjectID; data_size as usize / size_of::<AudioObjectID>()];
+    let list_status = unsafe {
+        AudioObjectGetPropertyData(
+            kAudioObjectSystemObject as AudioObjectID,
+            NonNull::from(&mut list_address),
+            0,
+            std::ptr::null(),
+            NonNull::from(&mut data_size),
+            NonNull::new(processes.as_mut_ptr().cast::<c_void>())?,
+        )
+    };
+    if list_status != kAudioHardwareNoError {
+        return None;
+    }
+
+    // Set when a target bundle is found but its running-input state can't be
+    // read. Distinct from "no target bundle is running at all" — the caller's
+    // None/Some(false) contract depends on not conflating the two.
+    let mut matched_bundle_with_unreadable_input = false;
+
+    for process in processes {
+        let mut bundle_address = AudioObjectPropertyAddress {
+            mSelector: kAudioProcessPropertyBundleID,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain,
+        };
+        let mut bundle_ref: *const c_void = std::ptr::null();
+        let mut bundle_size = size_of::<*const c_void>() as u32;
+        let bundle_status = unsafe {
+            AudioObjectGetPropertyData(
+                process,
+                NonNull::from(&mut bundle_address),
+                0,
+                std::ptr::null(),
+                NonNull::from(&mut bundle_size),
+                NonNull::new((&mut bundle_ref as *mut *const c_void).cast::<c_void>())?,
+            )
+        };
+        if bundle_status != kAudioHardwareNoError || bundle_ref.is_null() {
+            continue;
+        }
+        let bundle_id = unsafe {
+            CFString::wrap_under_get_rule(bundle_ref as core_foundation::string::CFStringRef)
+        }
+        .to_string()
+        .to_lowercase();
+        if !bundle_ids.iter().any(|candidate| candidate == &bundle_id) {
+            continue;
+        }
+
+        let mut input_address = AudioObjectPropertyAddress {
+            mSelector: kAudioProcessPropertyIsRunningInput,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain,
+        };
+        let mut input_running: u32 = 0;
+        let mut input_size = size_of::<u32>() as u32;
+        let input_status = unsafe {
+            AudioObjectGetPropertyData(
+                process,
+                NonNull::from(&mut input_address),
+                0,
+                std::ptr::null(),
+                NonNull::from(&mut input_size),
+                NonNull::new((&mut input_running as *mut u32).cast::<c_void>())?,
+            )
+        };
+        if input_status != kAudioHardwareNoError {
+            matched_bundle_with_unreadable_input = true;
+            continue;
+        }
+        if input_running != 0 {
+            return Some(true);
+        }
+    }
+
+    if matched_bundle_with_unreadable_input {
+        return None;
+    }
+    Some(false)
+}

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

@@ -6,6 +6,7 @@
 
 mod accessibility;
 mod adhoc_meetings_watcher;
+mod call_activity;
 mod capture_audio_bus;
 mod capture_graph;
 mod clips;