@agent-native/core 0.114.15 → 0.115.1

package/corpus/templates/clips/app/components/recorder/recorder-engine.ts

@@ -1524,25 +1524,32 @@ export class RecorderEngine {
       return this.compressAndReupload(meta);
     }
 
-    await this.resetUploadedChunks(null, signal);
+    const uploadMode = await this.resetUploadedChunks(null, signal);
     this.transition("uploading", { progress: 0 });
     const assembled = new Blob(this.localChunks, { type: this.mimeType });
-    return this.uploadBlobInSlices(assembled, this.mimeType, meta, signal);
+    return uploadMode === "streaming"
+      ? this.uploadBlobInStreamingChunks(assembled, this.mimeType, meta, signal)
+      : this.uploadBlobInSlices(assembled, this.mimeType, meta, signal);
   }
 
   private async resetUploadedChunks(
     compression: CompressionUploadMeta | null,
     signal?: AbortSignal,
-  ): Promise<void> {
+  ): Promise<UploadMode> {
     const resetUrl = `${appBasePath()}/api/uploads/${
       this.opts.recordingId
     }/reset-chunks`;
+    const uploadMimeType = compression?.outputMimeType || this.mimeType;
     let resetRes: Response;
     try {
       resetRes = await fetch(resetUrl, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ compression }),
+        body: JSON.stringify({
+          compression,
+          requestStreaming: this.uploadMode === "streaming",
+          mimeType: uploadMimeType,
+        }),
         signal,
       });
     } catch (err) {
@@ -1566,6 +1573,17 @@ export class RecorderEngine {
         }). ${text || resetRes.statusText}`,
       );
     }
+    const reset = (await resetRes.json().catch(() => null)) as {
+      uploadMode?: unknown;
+    } | null;
+    if (reset?.uploadMode !== "streaming" && reset?.uploadMode !== "buffered") {
+      throw new Error(
+        "Couldn't prepare the recording for re-upload (reset-chunks returned no upload mode).",
+      );
+    }
+    const uploadMode = reset.uploadMode;
+    this.uploadMode = uploadMode;
+    return uploadMode;
   }
 
   // -------------------------------------------------------------------------
@@ -1653,7 +1671,10 @@ export class RecorderEngine {
             outputMimeType: compression.outputMimeType,
           }
         : null;
-      await this.resetUploadedChunks(compressionPayload, abort.signal);
+      const uploadMode = await this.resetUploadedChunks(
+        compressionPayload,
+        abort.signal,
+      );
 
       if (compressionError) {
         // Compression itself failed — we still hold the original assembled
@@ -1680,12 +1701,19 @@ export class RecorderEngine {
       }
 
       this.transition("uploading", { progress: 0 });
-      return this.uploadBlobInSlices(
-        finalBlob,
-        compression.outputMimeType,
-        meta,
-        abort.signal,
-      );
+      return uploadMode === "streaming"
+        ? this.uploadBlobInStreamingChunks(
+            finalBlob,
+            compression.outputMimeType,
+            meta,
+            abort.signal,
+          )
+        : this.uploadBlobInSlices(
+            finalBlob,
+            compression.outputMimeType,
+            meta,
+            abort.signal,
+          );
     } finally {
       // Always release the controller reference even on throw — otherwise
       // a subsequent cancel() would abort a freshly-started compression.
@@ -2025,6 +2053,55 @@ export class RecorderEngine {
     return results[finalSlice.index];
   }
 
+  private async uploadBlobInStreamingChunks(
+    blob: Blob,
+    mimeType: string,
+    meta: {
+      durationMs: number;
+      dimensions: { width: number; height: number };
+      hasAudio: boolean;
+      hasCamera: boolean;
+    },
+    signal?: AbortSignal,
+  ): Promise<Record<string, unknown> | undefined> {
+    if (blob.size === 0) {
+      throw new Error("Cannot retry an empty recording upload.");
+    }
+
+    this.chunkIndex = 0;
+    const totalChunks = Math.ceil(blob.size / STREAM_CHUNK_BYTES);
+    let result: Record<string, unknown> | undefined;
+
+    for (let index = 0; index < totalChunks; index++) {
+      const start = index * STREAM_CHUNK_BYTES;
+      const end = Math.min(start + STREAM_CHUNK_BYTES, blob.size);
+      const isFinal = index === totalChunks - 1;
+      const chunk = blob.slice(start, end, mimeType);
+      result = await this.uploadChunk(chunk, this.chunkIndex++, {
+        isFinal,
+        total: totalChunks,
+        mimeType,
+        ...(isFinal
+          ? {
+              durationMs: meta.durationMs,
+              width: meta.dimensions.width,
+              height: meta.dimensions.height,
+              hasAudio: meta.hasAudio,
+              hasCamera: meta.hasCamera,
+            }
+          : {}),
+        signal,
+      });
+      this.opts.onChunk?.({
+        index,
+        bytes: chunk.size,
+        total: totalChunks,
+      });
+    }
+
+    return result;
+  }
+
   private async uploadChunk(
     blob: Blob,
     index: number,

package/corpus/templates/clips/app/i18n/en-US.ts

@@ -833,6 +833,10 @@ All notable user-facing changes to Clips are documented here. Open it any time f
     loadFailedBody:
       "Something went wrong while loading this list. Your recordings are safe — try again.",
     retry: "Retry",
+    paginationRange: "{{start}}–{{end}} of {{total}}",
+    paginationPrevious: "Previous",
+    paginationNext: "Next",
+    paginationPage: "Page {{page}} of {{totalPages}}",
   },
   notificationsRoute: {
     pageTitle: "Notifications · Clips",
@@ -1370,6 +1374,8 @@ All notable user-facing changes to Clips are documented here. Open it any time f
   clipsFinalRaw: {
     splitAtPlayhead: "Split at playhead (S)",
     selectedCount: "{{count}} selected",
+    selectAll: "Select all",
+    deselectAll: "Deselect all",
     move: "Move",
     moveSelected: "Move {{count}} selected",
     current: "Current",

package/corpus/templates/clips/app/routes/_app.trash.tsx

@@ -46,6 +46,7 @@ export default function TrashRoute() {
   const t = useT();
   const [sort, setSort] = useState<SortKey>("recent");
   const [selected, setSelected] = useState<Set<string>>(new Set());
+  const [lastSelectedId, setLastSelectedId] = useState<string | null>(null);
   const [confirmPurge, setConfirmPurge] = useState(false);
   const [singlePurgeId, setSinglePurgeId] = useState<string | null>(null);
   const [isBulkPending, setIsBulkPending] = useState(false);
@@ -60,13 +61,26 @@ export default function TrashRoute() {
     "delete-recording-permanent",
   );
 
-  const toggleSelect = (id: string) => {
+  const toggleSelect = (id: string, shiftKey = false) => {
     setSelected((prev) => {
+      if (shiftKey && lastSelectedId && lastSelectedId !== id) {
+        const ids = recordings.map((r) => r.id);
+        const fromIndex = ids.indexOf(lastSelectedId);
+        const toIndex = ids.indexOf(id);
+        if (fromIndex !== -1 && toIndex !== -1) {
+          const [start, end] =
+            fromIndex < toIndex ? [fromIndex, toIndex] : [toIndex, fromIndex];
+          const next = new Set(prev);
+          for (let i = start; i <= end; i++) next.add(ids[i]);
+          return next;
+        }
+      }
       const next = new Set(prev);
       if (next.has(id)) next.delete(id);
       else next.add(id);
       return next;
     });
+    setLastSelectedId(id);
   };
 
   const restoreAll = async (ids: string[]) => {
@@ -170,6 +184,7 @@ export default function TrashRoute() {
         ? new Set()
         : new Set(recordings.map((r) => r.id)),
     );
+    setLastSelectedId(null);
   };
 
   return (

package/corpus/templates/clips/changelog/2026-07-21-crm-call-evidence-handoff.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-21
+---
+
+Clips can now prepare an access-checked recording link for bounded CRM call evidence without exposing media or transcripts.

package/corpus/templates/clips/changelog/2026-07-21-recording-retries-and-restarts-keep-their-upload-session-so-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-21
+---
+
+Recording retries and restarts keep their upload session so they can finish saving.

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

@@ -1,4 +1,6 @@
 import {
+  restartUploadModeFromResponse,
+  restartUploadResetBody,
   shouldReconcilePersistedRecording,
   type OffscreenRecordingState,
 } from "./native-recording-state";
@@ -166,6 +168,7 @@ type NativeRecording = {
   // fallback so it is never lost; these describe that saved file.
   savedToDisk?: boolean;
   savedFilename?: string;
+  mimeType?: string;
 };
 
 type OffscreenStatusMessage = {
@@ -179,6 +182,7 @@ type OffscreenStatusMessage = {
   savedToDisk?: boolean;
   savedFilename?: string;
   recordingStep?: string;
+  mimeType?: string;
 };
 
 type ExtensionErrorMessage = {
@@ -1512,8 +1516,8 @@ async function handleOverlayRestart() {
   // so we must not leave the overlay stuck mid-recording/paused with no
   // recorder behind it — tear the overlay back down and release those streams,
   // matching the re-arm failure handling just below.
-  const chunksReset = await resetRecordingChunks(recording);
-  if (!chunksReset) {
+  const uploadMode = await resetRecordingChunks(recording);
+  if (!uploadMode) {
     recording.status = "error";
     recording.error =
       "Could not clear the previous take before restarting. Stop and start a new recording.";
@@ -1530,6 +1534,7 @@ async function handleOverlayRestart() {
       error: recording.error,
     };
   }
+  recording.uploadMode = uploadMode;
   overlayPhase = "countdown";
   overlayBaseElapsedMs = 0;
   overlayBaseEpochMs = nowMs();
@@ -1579,18 +1584,25 @@ async function handleOverlayRestart() {
 
 async function resetRecordingChunks(
   recording: NativeRecording,
-): Promise<boolean> {
+): Promise<UploadMode | null> {
   const url = `${recording.clipsBaseUrl}/api/uploads/${encodeURIComponent(
     recording.recordingId,
   )}/reset-chunks`;
-  const headers = await authHeaders(settingsFromRecording(recording));
+  const headers = {
+    ...(await authHeaders(settingsFromRecording(recording))),
+    "Content-Type": "application/json",
+  };
   const response = await fetch(url, {
     method: "POST",
     headers,
     credentials: "include",
     cache: "no-store",
+    body: JSON.stringify(
+      restartUploadResetBody(recording.mimeType ?? "video/webm"),
+    ),
   }).catch(() => undefined);
-  return Boolean(response?.ok);
+  if (!response?.ok) return null;
+  return restartUploadModeFromResponse(await response.json().catch(() => null));
 }
 
 // Finalize a successful save: open the clip and tear down the "Saving…" overlay.
@@ -2399,6 +2411,9 @@ async function dispatchRuntimeMessage(message: unknown): Promise<unknown> {
           activeNativeRecording,
         );
       }
+      if (typeof status.mimeType === "string") {
+        activeNativeRecording.mimeType = status.mimeType;
+      }
       if (status.status === "error") {
         activeNativeRecording.savedToDisk = status.savedToDisk === true;
         activeNativeRecording.savedFilename =

package/corpus/templates/clips/chrome-extension/src/native-recording-state.ts

@@ -6,6 +6,8 @@ export type NativeRecordingStateStatus =
   | "complete"
   | "error";
 
+export type RestartUploadMode = "streaming" | "buffered";
+
 export type OffscreenRecordingState = {
   activeSessionId?: string;
   preparedSessionId?: string;
@@ -30,3 +32,20 @@ export function shouldReconcilePersistedRecording(
   if (status === "error" || status === "complete") return false;
   return !hasLiveOffscreenSession(sessionId, state);
 }
+
+export function restartUploadResetBody(mimeType: string): {
+  requestStreaming: true;
+  mimeType: string;
+} {
+  return { requestStreaming: true, mimeType };
+}
+
+export function restartUploadModeFromResponse(
+  value: unknown,
+): RestartUploadMode | null {
+  if (!value || typeof value !== "object") return null;
+  const uploadMode = (value as { uploadMode?: unknown }).uploadMode;
+  return uploadMode === "streaming" || uploadMode === "buffered"
+    ? uploadMode
+    : null;
+}

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

@@ -56,6 +56,8 @@ const STORAGE_SETUP_REQUIRED_MESSAGE =
 const STORAGE_SETUP_FAILURE_RE =
   /video storage is not connected|no video storage configured|file upload provider|storage provider|connect builder|s3-compatible/i;
 const CHUNK_UPLOAD_MAX_ATTEMPTS = 3;
+const CHUNK_UPLOAD_TIMEOUT_MS = 60_000;
+const FINAL_CHUNK_UPLOAD_TIMEOUT_MS = 180_000;
 const RETRYABLE_CHUNK_UPLOAD_STATUSES = new Set([
   408, 425, 429, 500, 502, 503, 504,
 ]);
@@ -860,6 +862,11 @@ async function uploadChunk(
         headers,
         credentials: "include",
         body,
+        signal: AbortSignal.timeout(
+          extra.isFinal
+            ? FINAL_CHUNK_UPLOAD_TIMEOUT_MS
+            : CHUNK_UPLOAD_TIMEOUT_MS,
+        ),
       });
     } catch (err) {
       if (attempt >= CHUNK_UPLOAD_MAX_ATTEMPTS) throw err;
@@ -1387,6 +1394,7 @@ function startRecorderNow(recording: ActiveRecording): void {
       height: recording.dimensions.height,
       hasAudio: recording.hasAudio,
       hasCamera: recording.hasCamera,
+      mimeType: recording.mimeType,
     });
   } catch (err) {
     captureExtensionError(err, {

package/corpus/templates/clips/desktop/src/app.tsx

@@ -572,6 +572,21 @@ function openPrivacySettings(pane: MacosPrivacyPane): void {
   }
 }
 
+// Same explicit-drag pattern the toolbar/bubble overlays use —
+// `data-tauri-drag-region` has been unreliable, so we call `startDragging()`
+// directly on mousedown. Clicks on buttons/inputs still reach their handlers
+// since we only start a drag when the mousedown target isn't inside one.
+function handlePopoverHeaderMouseDown(event: React.MouseEvent) {
+  if (event.button !== 0) return;
+  const target = event.target as HTMLElement;
+  if (target.closest("button, a, input, select, textarea")) return;
+  getCurrentWindow()
+    .startDragging()
+    .catch((err) => {
+      console.warn("[clips-popover] startDragging failed:", err);
+    });
+}
+
 function nativeVoiceProvider(): VoiceProvider {
   return isMacPlatform() ? "macos-native" : "browser";
 }
@@ -4248,7 +4263,10 @@ function Header({
   // close button lives top-right as an absolute-positioned sibling, so the
   // tabs aren't offset by the close button's width.
   return (
-    <div className="header header-centered">
+    <div
+      className="header header-centered"
+      onMouseDown={handlePopoverHeaderMouseDown}
+    >
       <FeedbackButton submitterEmail={submitterEmail} />
       <div
         className="mode-toggle"
@@ -4444,7 +4462,10 @@ function PopoverSubViewHeader({
   action?: ReactNode;
 }) {
   return (
-    <div className="setup-header popover-view-header">
+    <div
+      className="setup-header popover-view-header"
+      onMouseDown={handlePopoverHeaderMouseDown}
+    >
       <button
         type="button"
         className="setup-back"
@@ -6376,7 +6397,7 @@ function Setup({
 
   return (
     <div className="setup">
-      <div className="setup-header">
+      <div className="setup-header" onMouseDown={handlePopoverHeaderMouseDown}>
         {onCancel ? (
           <button
             type="button"

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

@@ -344,6 +344,14 @@ export function RecordingPill() {
     void toggleExpanded();
   };
 
+  const handlePillMouseUp = (e: React.MouseEvent) => {
+    const start = dragStartScreenPointRef.current;
+    if (isDirectPillClick(start, { x: e.screenX, y: e.screenY })) return;
+    void invoke("recording_pill_save_position").catch((err) => {
+      console.warn("[clips-pill] save position failed", err);
+    });
+  };
+
   const mm = String(Math.floor(elapsed / 60)).padStart(2, "0");
   const ss = String(elapsed % 60).padStart(2, "0");
   const stopLabel =
@@ -356,6 +364,7 @@ export function RecordingPill() {
           hovered ? " pill-hovered" : ""
         }`}
         onMouseDown={handlePillMouseDown}
+        onMouseUp={handlePillMouseUp}
       >
         <div
           className={`pill-header${

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

@@ -130,20 +130,32 @@ fn pill_detached_position_path(app: &AppHandle) -> Option<PathBuf> {
     Some(dir.join("pill-position-detached.json"))
 }
 
-fn load_meeting_position(app: &AppHandle) -> Option<(i32, i32)> {
+#[derive(Deserialize)]
+struct MeetingPillPosition {
+    x: i32,
+    y: i32,
+    #[serde(default)]
+    anchor: Option<String>,
+    #[serde(default)]
+    width: Option<u32>,
+}
+
+fn load_meeting_position(app: &AppHandle) -> Option<MeetingPillPosition> {
     let path = pill_meeting_position_path(app)?;
     let bytes = std::fs::read(&path).ok()?;
-    let value: serde_json::Value = serde_json::from_slice(&bytes).ok()?;
-    let x = value.get("x")?.as_i64()? as i32;
-    let y = value.get("y")?.as_i64()? as i32;
-    Some((x, y))
+    serde_json::from_slice(&bytes).ok()
 }
 
-fn save_meeting_position_to_disk(app: &AppHandle, x: i32, y: i32) {
+fn save_meeting_position_to_disk(app: &AppHandle, x: i32, y: i32, width: u32) {
     let Some(path) = pill_meeting_position_path(app) else {
         return;
     };
-    let body = match serde_json::to_vec(&serde_json::json!({ "x": x, "y": y })) {
+    let body = match serde_json::to_vec(&serde_json::json!({
+        "x": x + width as i32,
+        "y": y,
+        "anchor": "right",
+        "width": width,
+    })) {
         Ok(b) => b,
         Err(_) => return,
     };
@@ -313,7 +325,28 @@ fn anchored_rect(
         let (_, h_exp) = pill_size_physical(app, true);
         let max_y_exp = (my + mh as i32 - h_exp as i32).max(my);
         let (x, y) = match load_meeting_position(app) {
-            Some((sx, sy)) => (sx.clamp(mx, max_x), sy.clamp(my, max_y_exp)),
+            Some(position) if position.anchor.as_deref() == Some("right") => {
+                let saved_width = position.width.unwrap_or(w);
+                (
+                    (position.x - saved_width as i32).clamp(mx, max_x),
+                    position.y.clamp(my, max_y_exp),
+                )
+            }
+            Some(position) => {
+                let (expanded_w, _) = pill_size_physical(app, true);
+                let right_margin = (PILL_RIGHT_MARGIN_LOGICAL as f64 * scale_factor(app)) as i32;
+                let legacy_right_edge = position.x + expanded_w as i32;
+                let monitor_right = mx + mw as i32;
+                if (legacy_right_edge - (monitor_right - right_margin)).abs() <= 4 {
+                    save_meeting_position_to_disk(app, position.x, position.y, expanded_w);
+                    (
+                        (legacy_right_edge - w as i32).clamp(mx, max_x),
+                        position.y.clamp(my, max_y_exp),
+                    )
+                } else {
+                    (position.x.clamp(mx, max_x), position.y.clamp(my, max_y_exp))
+                }
+            }
             None => default_center_right(app, w, h),
         };
         return (w, h, x, y);
@@ -492,35 +525,28 @@ pub async fn recording_pill_expand(app: AppHandle, expanded: bool) -> Result<(),
 pub async fn recording_pill_hide(app: AppHandle) -> Result<(), String> {
     stop_pill_hover_tracking();
     if let Some(w) = app.get_webview_window(PILL_LABEL) {
-        // Snapshot current position before close so the next show re-opens
-        // at the user's chosen spot.
-        if let Ok(pos) = w.outer_position() {
-            if PILL_DETACHED.load(Ordering::Relaxed) {
-                save_detached_position_to_disk(&app, pos.x, pos.y);
-            } else if PILL_RIGHT_SIDE.load(Ordering::Relaxed) {
-                save_meeting_position_to_disk(&app, pos.x, pos.y);
-            } else {
-                save_pill_position_to_disk(&app, pos.x, pos.y);
-            }
-        }
         let _ = w.close();
     }
     Ok(())
 }
 
-/// Persist the pill's current position. Called by the React side after the
-/// user drag-moves it (mouseup) so the next `show` reopens at the chosen
-/// spot.
 #[tauri::command]
-pub async fn recording_pill_save_position(app: AppHandle, x: i32, y: i32) -> Result<(), String> {
-    // Persist to the right slot — detached drags shouldn't overwrite the
-    // user's preferred bottom-center position and vice versa.
+pub async fn recording_pill_save_position(app: AppHandle) -> Result<(), String> {
+    let Some(window) = app.get_webview_window(PILL_LABEL) else {
+        return Ok(());
+    };
+    let Ok(position) = window.outer_position() else {
+        return Ok(());
+    };
+
     if PILL_DETACHED.load(Ordering::Relaxed) {
-        save_detached_position_to_disk(&app, x, y);
+        save_detached_position_to_disk(&app, position.x, position.y);
     } else if PILL_RIGHT_SIDE.load(Ordering::Relaxed) {
-        save_meeting_position_to_disk(&app, x, y);
+        if let Ok(size) = window.outer_size() {
+            save_meeting_position_to_disk(&app, position.x, position.y, size.width);
+        }
     } else {
-        save_pill_position_to_disk(&app, x, y);
+        save_pill_position_to_disk(&app, position.x, position.y);
     }
     Ok(())
 }

package/corpus/templates/clips/server/plugins/agent-chat.ts

@@ -18,6 +18,7 @@ const INITIAL_TOOL_NAMES = [
   "list-recordings",
   "search-recordings",
   "get-recording-player-data",
+  "prepare-crm-call-evidence",
   "request-transcript",
   "create-recording",
   "import-loom-recording",