@agent-native/core 0.117.1 → 0.118.0

package/corpus/templates/clips/desktop/src/styles.css

@@ -888,20 +888,23 @@ body[data-clips-route="recording-pill"] #root {
 /* Readiness disclosure                                                       */
 /* ------------------------------------------------------------------------- */
 
+.recorder-disclosures {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+}
+
 .readiness {
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  background: var(--surface);
+  border: none;
+  border-radius: 0;
+  background: transparent;
   overflow: hidden;
   flex-shrink: 0;
-  transition:
-    border-color 120ms,
-    background 120ms;
 }
 
 .readiness-open {
-  border-color: var(--border-strong);
-  background: var(--bg);
+  border-color: transparent;
+  background: transparent;
 }
 
 .readiness-summary {
@@ -922,7 +925,7 @@ body[data-clips-route="recording-pill"] #root {
 }
 
 .readiness-summary:hover {
-  background: var(--surface-hover);
+  color: var(--fg-muted);
 }
 
 .readiness-summary:focus-visible {
@@ -932,10 +935,9 @@ body[data-clips-route="recording-pill"] #root {
 
 .readiness-open .readiness-summary {
   min-height: 42px;
-  border-radius: 0;
+  border-radius: var(--radius-sm);
   padding: 10px 12px;
-  background: var(--surface);
-  border-bottom: 1px solid var(--border);
+  background: transparent;
 }
 
 .readiness-title {
@@ -959,6 +961,12 @@ body[data-clips-route="recording-pill"] #root {
   line-height: 1;
 }
 
+.readiness-action svg,
+.rewind-home-state svg {
+  width: 11px;
+  height: 11px;
+}
+
 .readiness-open .readiness-action {
   color: var(--fg-muted);
 }
@@ -1332,37 +1340,111 @@ body[data-clips-route="recording-pill"] #root {
 /* Rewind is a calm everyday status first; configuration is a drill-in. */
 .rewind-home-card {
   display: grid;
-  gap: 8px;
-  padding: 10px 11px;
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  background: color-mix(in srgb, var(--surface) 72%, var(--bg));
+  gap: 0;
+  padding: 0;
+  border: none;
+  border-radius: 0;
+  background: transparent;
 }
 
-.rewind-home-status {
+.rewind-home-summary {
   display: grid;
-  grid-template-columns: auto minmax(0, 1fr) auto;
+  grid-template-columns: minmax(0, 1fr) auto;
   align-items: center;
-  gap: 9px;
+  gap: 8px;
+  width: 100%;
+  min-height: 42px;
+  padding: 10px 12px;
+  border: none;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--fg);
+  cursor: pointer;
+  text-align: left;
+  transition: color 120ms;
 }
 
-.rewind-settings-entry-main {
+.rewind-home-summary:hover {
+  color: var(--fg-muted);
+}
+
+.rewind-home-summary:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 3px var(--brand-ring);
+}
+
+.rewind-home-title {
+  font-size: 13px;
+  font-weight: 500;
+  line-height: 1;
+}
+
+.rewind-home-state {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  color: var(--fg-muted);
+  font-size: 11px;
+  font-weight: 600;
+  line-height: 1;
+}
+
+.rewind-home-details {
   display: grid;
-  grid-template-columns: auto minmax(0, 1fr);
-  align-items: start;
-  gap: 9px;
+  gap: 10px;
+  padding: 0 12px 10px;
 }
 
-.rewind-home-status p {
-  margin: 2px 0 0;
+.rewind-home-details p {
+  margin: 0;
   color: var(--fg-muted);
   font-size: 11px;
   line-height: 1.4;
 }
 
-.rewind-home-status strong {
-  font-size: 13px;
-  font-weight: 500;
+.rewind-home-detail-actions {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.rewind-home-controls {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  margin-left: auto;
+}
+
+.rewind-docs-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  padding: 0;
+  border: none;
+  background: transparent;
+  color: var(--fg-muted);
+  cursor: pointer;
+  font-size: 11px;
+  font-weight: 600;
+  white-space: nowrap;
+}
+
+.rewind-docs-link:hover {
+  color: var(--fg);
+}
+
+.rewind-docs-link:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 3px var(--brand-ring);
+  border-radius: 4px;
+}
+
+.rewind-settings-entry-main {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  align-items: start;
+  gap: 9px;
 }
 
 .rewind-home-lock-note,
@@ -1379,12 +1461,6 @@ body[data-clips-route="recording-pill"] #root {
   background: var(--surface);
 }
 
-.rewind-home-controls {
-  display: inline-flex;
-  align-items: center;
-  gap: 8px;
-}
-
 .rewind-agent-prompt-copy {
   width: 28px;
   height: 28px;
@@ -1399,7 +1475,6 @@ body[data-clips-route="recording-pill"] #root {
 }
 
 .rewind-agent-prompt-copy:hover {
-  background: var(--surface-hover);
   color: var(--fg);
 }
 

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

@@ -56,6 +56,38 @@ struct AdhocMeetingsWatcherInner {
     session_notified: HashMap<String, bool>,
 }
 
+impl AdhocMeetingsWatcherInner {
+    fn refresh_suppression(&mut self, platform: &str, now_ts: i64) {
+        self.session_notified.insert(platform.to_string(), true);
+        self.cooldown_until
+            .insert(platform.to_string(), now_ts + COOLDOWN_SECS);
+        self.dwell_platform = None;
+        self.dwell_since = None;
+    }
+
+    fn is_suppressed(&self, platform: &str, now_ts: i64) -> bool {
+        self.cooldown_until.get(platform).copied().unwrap_or(0) > now_ts
+            || self
+                .session_notified
+                .get(platform)
+                .copied()
+                .unwrap_or(false)
+    }
+}
+
+pub fn refresh_dismissal_suppression(app: &AppHandle, platform: &str) -> Result<(), String> {
+    let platform = platform.trim().to_lowercase();
+    if platform.is_empty() {
+        return Ok(());
+    }
+    let state = app
+        .try_state::<AdhocMeetingsWatcherState>()
+        .ok_or_else(|| "no AdhocMeetingsWatcherState".to_string())?;
+    let mut g = state.inner.lock().map_err(|e| e.to_string())?;
+    g.refresh_suppression(&platform, chrono::Utc::now().timestamp());
+    Ok(())
+}
+
 /// Spawn the long-running adhoc watcher. Idempotent — gated by OnceLock.
 pub fn spawn_watcher(app: AppHandle) {
     use std::sync::OnceLock;
@@ -170,10 +202,7 @@ async fn tick_macos(
         // Prune expired cooldowns.
         g.cooldown_until.retain(|_, until| *until > now_ts);
 
-        if g.cooldown_until.get(platform).copied().unwrap_or(0) > now_ts {
-            return Ok(());
-        }
-        if g.session_notified.get(platform).copied().unwrap_or(false) {
+        if g.is_suppressed(platform, now_ts) {
             return Ok(());
         }
 
@@ -263,6 +292,40 @@ async fn tick_macos(
     Ok(())
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn dismissal_refreshes_the_existing_cooldown_and_clears_dwell() {
+        let now_ts = 1_000;
+        let mut state = AdhocMeetingsWatcherInner {
+            dwell_platform: Some("zoom".to_string()),
+            dwell_since: Some(Instant::now()),
+            ..Default::default()
+        };
+
+        state.refresh_suppression("zoom", now_ts);
+        state.session_notified.remove("zoom");
+
+        assert!(state.is_suppressed("zoom", now_ts + COOLDOWN_SECS - 1));
+        assert!(!state.is_suppressed("zoom", now_ts + COOLDOWN_SECS));
+        assert_eq!(state.dwell_platform, None);
+        assert_eq!(state.dwell_since, None);
+    }
+
+    #[test]
+    fn dismissal_suppression_remains_platform_scoped() {
+        let now_ts = 1_000;
+        let mut state = AdhocMeetingsWatcherInner::default();
+
+        state.refresh_suppression("zoom", now_ts);
+
+        assert!(state.is_suppressed("zoom", now_ts));
+        assert!(!state.is_suppressed("teams", now_ts));
+    }
+}
+
 fn reset_dwell(app: &AppHandle) {
     if let Some(state) = app.try_state::<AdhocMeetingsWatcherState>() {
         if let Ok(mut g) = state.inner.lock() {

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

@@ -147,7 +147,6 @@ pub fn run() {
             native_screen::native_fullscreen_claim_upload_open,
             native_screen::native_fullscreen_recording_warm,
             native_screen::native_fullscreen_recording_begin,
-            native_screen::native_fullscreen_capture_thumbnail,
             native_screen::native_fullscreen_recording_stop_and_upload,
             native_screen::native_fullscreen_recording_stop_and_save,
             native_screen::native_fullscreen_recording_cancel,
@@ -204,6 +203,7 @@ pub fn run() {
             // notifications
             notifications::take_pending_meeting_notification,
             notifications::notify_meeting_starting,
+            notifications::dismiss_meeting_notification,
             // meetings watcher (background poller)
             meetings_watcher::meetings_watcher_set_server_url,
             meetings_watcher::meetings_watcher_set_session,
@@ -458,7 +458,16 @@ pub fn run() {
             // login (tagged with `--autostart`) so it doesn't pop up every boot.
             let launched_at_login = std::env::args().any(|arg| arg == "--autostart");
             if !launched_at_login {
-                toggle_popover(app.handle());
+                let app_handle = app.handle().clone();
+                tauri::async_runtime::spawn(async move {
+                    for _ in 0..8 {
+                        tokio::time::sleep(std::time::Duration::from_millis(25)).await;
+                        if tray::refresh_tray_anchor(&app_handle) {
+                            break;
+                        }
+                    }
+                    clips::force_show_popover(&app_handle);
+                });
             }
 
             Ok(())

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

@@ -145,6 +145,8 @@ struct MeetingItem {
     join_url: Option<String>,
     #[serde(default)]
     platform: Option<String>,
+    #[serde(default)]
+    source: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -345,6 +347,9 @@ async fn tick_once(app: &AppHandle, client: &reqwest::Client) -> Result<(), Stri
     let now = chrono::Utc::now();
     let now_ts = now.timestamp();
     for m in meetings {
+        if !is_calendar_reminder_candidate(&m) {
+            continue;
+        }
         let Some(start_str) = m.scheduled_start.as_deref() else {
             continue;
         };
@@ -445,6 +450,10 @@ async fn tick_once(app: &AppHandle, client: &reqwest::Client) -> Result<(), Stri
     Ok(())
 }
 
+fn is_calendar_reminder_candidate(meeting: &MeetingItem) -> bool {
+    meeting.source.as_deref() != Some("adhoc")
+}
+
 fn parse_meetings(body: &serde_json::Value) -> Vec<MeetingItem> {
     if let Ok(parsed) = serde_json::from_value::<ListMeetingsResponse>(body.clone()) {
         if let Some(v) = parsed.upcoming {
@@ -462,3 +471,45 @@ fn parse_meetings(body: &serde_json::Value) -> Vec<MeetingItem> {
     }
     Vec::new()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{is_calendar_reminder_candidate, parse_meetings};
+
+    #[test]
+    fn excludes_adhoc_meetings_from_calendar_reminders() {
+        let meetings = parse_meetings(&serde_json::json!({
+            "meetings": [
+                {
+                    "id": "adhoc-meeting",
+                    "scheduledStart": "2026-07-22T19:10:00Z",
+                    "source": "adhoc"
+                },
+                {
+                    "id": "calendar-meeting",
+                    "scheduledStart": "2026-07-22T19:10:00Z",
+                    "source": "calendar"
+                }
+            ]
+        }));
+
+        assert_eq!(meetings.len(), 2);
+        assert!(!is_calendar_reminder_candidate(&meetings[0]));
+        assert!(is_calendar_reminder_candidate(&meetings[1]));
+    }
+
+    #[test]
+    fn keeps_meetings_without_source_eligible_for_legacy_payloads() {
+        let meetings = parse_meetings(&serde_json::json!({
+            "meetings": [
+                {
+                    "id": "legacy-meeting",
+                    "scheduledStart": "2026-07-22T19:10:00Z"
+                }
+            ]
+        }));
+
+        assert_eq!(meetings.len(), 1);
+        assert!(is_calendar_reminder_candidate(&meetings[0]));
+    }
+}

package/corpus/templates/clips/desktop/src-tauri/src/native_screen/custom_capture.rs

@@ -2629,7 +2629,11 @@ fn decode_samples_to_f32(bytes: &[u8], is_float: bool, bits: u32) -> Vec<f32> {
             .map(|c| {
                 // Reconstruct a 24-bit little-endian signed integer and sign-extend to i32.
                 let raw = (c[0] as i32) | ((c[1] as i32) << 8) | ((c[2] as i32) << 16);
-                let signed = if raw & 0x800000 != 0 { raw | !0x00FF_FFFFi32 } else { raw };
+                let signed = if raw & 0x800000 != 0 {
+                    raw | !0x00FF_FFFFi32
+                } else {
+                    raw
+                };
                 signed as f32 / 8_388_608.0
             })
             .collect(),

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

@@ -155,10 +155,6 @@ const FFMPEG_CANDIDATE_PATHS: &[&str] = &[
 ];
 const PENDING_UPLOADS_DIR: &str = "pending-recording-uploads";
 const CLIP_DRAFTS_DIR: &str = "Drafts";
-const THUMBNAIL_MIME_TYPE: &str = "image/jpeg";
-const THUMBNAIL_MAX_BYTES: u64 = 2 * 1024 * 1024;
-const THUMBNAIL_WIDTH: &str = "1280";
-const SIPS_PATH: &str = "/usr/bin/sips";
 // Minimum free space required to start recording; below this we hard-block.
 pub(crate) const DISK_SPACE_BLOCK_BYTES: u64 = 500 * 1024 * 1024;
 // Free space below this at start time is logged as a warning but not blocked.
@@ -2018,31 +2014,6 @@ pub async fn native_fullscreen_recording_stop_and_save(
     save_finalized_native_artifact_to_local_export(&app, &artifact, &folder_name, &file_role)
 }
 
-#[tauri::command]
-pub async fn native_fullscreen_capture_thumbnail(
-    app: AppHandle,
-    server_url: String,
-    recording_id: String,
-    auth_token: Option<String>,
-    cookie: Option<String>,
-) -> Result<(), String> {
-    let bytes = capture_thumbnail_bytes(&app, &recording_id)?;
-    tauri::async_runtime::spawn(async move {
-        if let Err(err) = upload_thumbnail_bytes(
-            server_url,
-            recording_id.clone(),
-            auth_token.unwrap_or_default(),
-            cookie.unwrap_or_default(),
-            bytes,
-        )
-        .await
-        {
-            eprintln!("[clips-tray] native thumbnail upload failed for {recording_id}: {err}");
-        }
-    });
-    Ok(())
-}
-
 /// Called from the app's exit path (tray Quit / Cmd+Q) so a live `screencapture`
 /// fallback process doesn't survive the app quitting. `app.exit()` triggers
 /// `std::process::exit` under the hood, which does not run Rust destructors,
@@ -3455,117 +3426,6 @@ fn saved_recording_metadata_path(app: &AppHandle, recording_id: &str) -> Result<
     Ok(pending_uploads_dir(app)?.join(format!("{safe_id}.json")))
 }
 
-fn thumbnail_path(app: &AppHandle, recording_id: &str) -> Result<PathBuf, String> {
-    let safe_id = sanitize_recording_id(recording_id);
-    pending_recording_path(app, &format!("{safe_id}-thumb"), "jpg")
-}
-
-fn resized_thumbnail_path(path: &Path) -> PathBuf {
-    let stem = path
-        .file_stem()
-        .and_then(|value| value.to_str())
-        .unwrap_or("thumbnail");
-    path.with_file_name(format!("{stem}-1280.jpg"))
-}
-
-fn thumbnail_file_for_upload(path: &Path) -> Result<PathBuf, String> {
-    let original_bytes = std::fs::metadata(path)
-        .map_err(|e| format!("thumbnail metadata unavailable: {e}"))?
-        .len();
-    if original_bytes <= THUMBNAIL_MAX_BYTES || !std::path::Path::new(SIPS_PATH).exists() {
-        return Ok(path.to_path_buf());
-    }
-
-    let resized_path = resized_thumbnail_path(path);
-    let _ = std::fs::remove_file(&resized_path);
-    let status = Command::new(SIPS_PATH)
-        .arg("--resampleWidth")
-        .arg(THUMBNAIL_WIDTH)
-        .arg("--setProperty")
-        .arg("format")
-        .arg("jpeg")
-        .arg("--setProperty")
-        .arg("formatOptions")
-        .arg("85")
-        .arg(path)
-        .arg("--out")
-        .arg(&resized_path)
-        .stdin(Stdio::null())
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .status()
-        .map_err(|e| format!("thumbnail resize failed: {e}"))?;
-
-    if !status.success() {
-        let _ = std::fs::remove_file(&resized_path);
-        return Ok(path.to_path_buf());
-    }
-
-    let resized_bytes = std::fs::metadata(&resized_path)
-        .map_err(|e| format!("resized thumbnail metadata unavailable: {e}"))?
-        .len();
-    if resized_bytes == 0 || resized_bytes > original_bytes {
-        let _ = std::fs::remove_file(&resized_path);
-        return Ok(path.to_path_buf());
-    }
-
-    Ok(resized_path)
-}
-
-fn capture_thumbnail_bytes(app: &AppHandle, recording_id: &str) -> Result<Vec<u8>, String> {
-    #[cfg(not(target_os = "macos"))]
-    {
-        let _ = (app, recording_id);
-        Err("Native full-screen thumbnails are currently macOS-only.".into())
-    }
-
-    #[cfg(target_os = "macos")]
-    {
-        if !std::path::Path::new("/usr/sbin/screencapture").exists() {
-            return Err("macOS screencapture is unavailable on this machine.".into());
-        }
-
-        let path = thumbnail_path(app, recording_id)?;
-        let _ = std::fs::remove_file(&path);
-        let thumb_display_flag = tray_display_id(app)
-            .and_then(|id| {
-                CGDisplay::active_displays().ok().and_then(|ids| {
-                    ids.iter()
-                        .position(|&aid| aid == id)
-                        .map(|p| format!("-D{}", p + 1))
-                })
-            })
-            .unwrap_or_else(|| "-D1".to_string());
-        let status = Command::new("/usr/sbin/screencapture")
-            .arg("-x")
-            .arg("-t")
-            .arg("jpg")
-            .arg(thumb_display_flag)
-            .arg(&path)
-            .stdin(Stdio::null())
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .status()
-            .map_err(|e| format!("thumbnail capture failed: {e}"))?;
-        if !status.success() {
-            let _ = std::fs::remove_file(&path);
-            return Err(format!("thumbnail capture exited with {status}"));
-        }
-
-        let upload_path = thumbnail_file_for_upload(&path)?;
-        let bytes =
-            std::fs::read(&upload_path).map_err(|e| format!("thumbnail read failed: {e}"))?;
-        if upload_path != path {
-            let _ = std::fs::remove_file(&upload_path);
-        }
-        let _ = std::fs::remove_file(&path);
-        if bytes.is_empty() {
-            return Err("Thumbnail capture produced an empty file.".into());
-        }
-        Ok(bytes)
-    }
-}
-
 fn saved_recording_from_session(
     session: &NativeFullscreenSession,
     server_url: &str,
@@ -4767,55 +4627,6 @@ async fn reset_upload_chunks(
     Ok(NativeUploadMode::from_reset_response(&body))
 }
 
-async fn upload_thumbnail_bytes(
-    server_url: String,
-    recording_id: String,
-    auth_token: String,
-    cookie: String,
-    bytes: Vec<u8>,
-) -> Result<(), String> {
-    let url = thumbnail_upload_url(&server_url, &recording_id)?;
-    let client = reqwest::Client::builder()
-        .timeout(Duration::from_secs(30))
-        .build()
-        .map_err(|e| format!("thumbnail upload client failed: {e}"))?;
-    let mut request = client
-        .post(url)
-        .header("Content-Type", THUMBNAIL_MIME_TYPE)
-        .header("X-Request-Source", "clips-desktop")
-        .body(bytes);
-    let trimmed_token = auth_token.trim();
-    if !trimmed_token.is_empty() {
-        request = request.bearer_auth(trimmed_token);
-    }
-    let trimmed_cookie = cookie.trim();
-    if !trimmed_cookie.is_empty() {
-        request = request.header("Cookie", trimmed_cookie);
-    }
-
-    let response = request
-        .send()
-        .await
-        .map_err(|e| format!("native thumbnail upload failed: {e}"))?;
-    let status = response.status();
-    let body = response.text().await.unwrap_or_default();
-    if !status.is_success() {
-        return Err(format!(
-            "native thumbnail upload returned {status}: {}",
-            body.chars().take(400).collect::<String>()
-        ));
-    }
-    Ok(())
-}
-
-fn thumbnail_upload_url(server_url: &str, recording_id: &str) -> Result<url::Url, String> {
-    let base = server_url.trim_end_matches('/');
-    url::Url::parse(&format!(
-        "{base}/api/recordings/{recording_id}/thumbnail?replace=auto"
-    ))
-    .map_err(|e| format!("invalid thumbnail upload URL: {e}"))
-}
-
 async fn send_upload_post(
     client: &reqwest::Client,
     server_url: &str,