@agent-native/core 0.114.16 → 0.115.3

package/corpus/templates/clips/.agents/skills/agent-native-docs/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: agent-native-docs
+description: >-
+  How to find version-matched Agent Native framework docs and source bundled in
+  node_modules. Use before implementing or answering questions about
+  @agent-native/core APIs, generated apps, workspaces, templates, or advanced
+  features.
+scope: dev
+metadata:
+  internal: true
+---
+
+# Agent Native Docs Lookup
+
+## Rule
+
+Before implementing or explaining non-trivial Agent Native behavior, read the
+version-matched docs installed with `@agent-native/core`. When examples,
+imports, or implementation details matter, inspect the packaged source corpus
+too.
+
+## Why
+
+Generated apps and workspaces may be on a different framework version than the
+public docs or model memory. The installed package is the source that matches
+the app in front of you. It also includes a source-only corpus of core and
+first-party templates so agents can replicate current best-practice patterns
+without needing the framework monorepo checkout.
+
+## How
+
+From a generated app directory:
+
+```bash
+pnpm action docs-search --query "<feature>"
+pnpm action docs-search --slug <slug>
+pnpm action docs-search --list
+pnpm action source-search --query "<pattern>"
+pnpm action source-search --path templates/plan/AGENTS.md
+pnpm action source-search --path toolkit/src/index.ts
+pnpm action source-search --list
+```
+
+The headless `pnpm agent` loop and built-in app agent also expose a read-only
+`docs-search` tool with the same `query`, `slug`, and `list` options, plus a
+read-only `source-search` tool with `query`, `path`, and `list`.
+
+If the action runner is unavailable, search the package directly:
+
+```bash
+rg -n "actions|automations|a2a|sharing" node_modules/@agent-native/core/docs
+rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
+```
+
+Then read `node_modules/@agent-native/core/docs/AGENTS.md` or the matching file
+under `node_modules/@agent-native/core/docs/content/`. For source examples,
+read files under `node_modules/@agent-native/core/corpus/core/` or
+`node_modules/@agent-native/core/corpus/templates/`.
+
+Toolkit source is searchable at `toolkit/` in the Core corpus and also ships as
+readable TypeScript under `node_modules/@agent-native/toolkit/src/`. Read
+`customizing-agent-native` before taking ownership of a shared component: inspect package
+source as a read-only reference, then configure, compose, or eject the smallest
+supported unit into app-owned source. Preserve public actions, application
+state, auth, and agent-chat runtime contracts. Never edit `node_modules` or
+deep-import its private source. Manual copying is only the fallback described by
+an unknown third-party package's add-style blueprint.
+
+## Reuse Proven Patterns (rg + cp)
+
+Version-matched installed source outranks web docs or memory: it is the exact
+code shipping with this app. `node_modules/@agent-native/core/corpus/templates/`
+holds source for every first-party template, not just the one this app started
+from, so a pattern from the mail template is fair game for a tasks app. Grep
+across it, then copy a whole file as a starting point instead of writing the
+pattern from scratch:
+
+```bash
+# Find how other templates solved a similar problem
+rg -n "drag.*drop|reorder" node_modules/@agent-native/core/corpus/templates
+
+# Grab a proven action file as a starting point, then adapt names/schema
+cp node_modules/@agent-native/core/corpus/templates/mail/actions/archive-email.ts \
+   actions/archive-item.ts
+
+# Read the full framework source behind an API, not just the corpus copy
+rg -n "defineAction" node_modules/@agent-native/core/src/action.ts
+```
+
+Copying template-level app code (actions, components, skill files) is the
+expected reuse path — templates exist to be forked. This is different from
+copying `core`/`toolkit` **runtime internals**: for those, follow
+`customizing-agent-native`'s configure/compose/eject ladder instead of
+hand-duplicating framework logic.
+
+## Useful Slugs
+
+| Need                           | Slugs                                                         |
+| ------------------------------ | ------------------------------------------------------------- |
+| Actions and typed client calls | `actions`, `client`                                           |
+| SQL, auth, access, sharing     | `database`, `authentication`, `security`, `sharing`           |
+| UI state visible to the agent  | `context-awareness`                                           |
+| Headless and chat-first apps   | `pure-agent-apps`, `agent-surfaces`, `using-your-agent`       |
+| Automations and schedules      | `automations`, `recurring-jobs`                               |
+| Cross-app and external agents  | `a2a-protocol`, `external-agents`, `mcp-protocol`, `mcp-apps` |
+| Skills and instructions        | `skills-guide`, `writing-agent-instructions`                  |
+
+## Don't
+
+- Do not rely on memory for framework APIs when package docs are present.
+- Do not add custom REST wrappers for app data before reading `actions`.
+- Do not add inline LLM calls before reading `using-your-agent` and
+  `agent-surfaces`.
+- Do not copy framework runtime internals when a public API or narrow UI copy
+  will do; read `customizing-agent-native` for the supported override ladder.

package/corpus/templates/clips/AGENTS.md

@@ -21,6 +21,13 @@ ladder.
 - Never hardcode API keys, tokens, webhook URLs, signing secrets, private Builder/internal data, customer data, or credential-looking literals. Use secrets/OAuth/runtime configuration and obvious placeholders in examples.
 - Use actions for recording metadata, transcripts, cleanup, summaries, chapters,
   comments, spaces/folders, meetings, and sharing. Do not bypass access helpers.
+- Use `prepare-crm-call-evidence` only for a viewer-accessible recording
+  explicitly identified by a user action or the exact approved CRM A2A recipe.
+  It returns an opaque clip ID, durable HTTPS `/r/<id>` page, and optional
+  capture time for CRM; it never returns the event media URL, a transcript,
+  temporary token, quote, or summary. A CRM recipe may install a Clips-owned
+  `clip.created` trigger only through an exact user-approved A2A automation
+  definition.
 - Organization admins can use `set-organization-branding` with
   `defaultVisibility=public|org|private` to choose the visibility applied when
   new recordings omit an explicit visibility. The default remains `public`, and

package/corpus/templates/clips/actions/prepare-crm-call-evidence.ts

@@ -0,0 +1,58 @@
+import { defineAction } from "@agent-native/core/action";
+import { getRequestContext } from "@agent-native/core/server";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import { getServerAppBasePath } from "../server/lib/public-agent-context.js";
+
+function clipsOrigin(): string {
+  const raw = getRequestContext()?.requestOrigin || process.env.APP_URL;
+  if (!raw) {
+    throw new Error(
+      "Clips needs an HTTPS APP_URL before it can prepare CRM evidence links.",
+    );
+  }
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(
+      "Clips needs a valid HTTPS APP_URL before it can prepare CRM evidence links.",
+    );
+  }
+  if (url.protocol !== "https:") {
+    throw new Error(
+      "Clips needs an HTTPS APP_URL before it can prepare CRM evidence links.",
+    );
+  }
+  return url.origin;
+}
+
+export default defineAction({
+  description:
+    "Prepare one access-gated Clips recording as bounded CRM call evidence. Returns only an opaque recording id, durable HTTPS recording page, and optional capture time; never media, a transcript, or a temporary access token.",
+  schema: z.object({
+    recordingId: z.string().trim().min(1).max(256),
+  }),
+  readOnly: true,
+  run: async ({ recordingId }) => {
+    const access = await assertAccess("recording", recordingId, "viewer");
+    const recording = access.resource as {
+      id: string;
+      createdAt?: string | null;
+      archivedAt?: string | null;
+      trashedAt?: string | null;
+    };
+    if (recording.archivedAt || recording.trashedAt) {
+      throw new Error("Archived or trashed Clips cannot be attached to CRM.");
+    }
+    const sourceUrl = `${clipsOrigin()}${getServerAppBasePath()}/r/${encodeURIComponent(recording.id)}`;
+    return {
+      sourceApp: "clips" as const,
+      artifactType: "call-evidence" as const,
+      artifactId: recording.id,
+      sourceUrl,
+      ...(recording.createdAt ? { capturedAt: recording.createdAt } : {}),
+    };
+  },
+});

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/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/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",