@agent-native/core 0.103.1 → 0.105.0

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

@@ -1318,13 +1318,68 @@ pub async fn native_fullscreen_recording_stop_and_upload(
     // final post instead of re-uploading the whole file.
     #[cfg(target_os = "macos")]
     if let Some(live) = session.live_upload.take() {
+        let verified_duration_ms = match probe_local_media_duration_ms(&saved.file_path) {
+            Ok(media_duration_ms)
+                if media_durations_materially_match(duration_ms, media_duration_ms) =>
+            {
+                media_duration_ms
+            }
+            Ok(media_duration_ms) => {
+                let error = format!(
+                    "Clip may be incomplete. The local media duration ({media_duration_ms} ms) did not match the recorded duration ({duration_ms} ms)."
+                );
+                live.ctrl.cancelled.store(true, Ordering::SeqCst);
+                let _ = live.result_rx.await;
+                saved.last_attempt_at = Some(now_iso());
+                saved.last_error = Some(error.clone());
+                saved.retry_count = saved.retry_count.saturating_add(1);
+                let _ = write_saved_recording_metadata(&app, &saved);
+                emit_native_upload_progress(&app, "failed", "Upload paused", None, None);
+                let error = format!(
+                    "{error} The clip was saved locally and can be retried from the Clips menu."
+                );
+                emit_native_upload_finished(
+                    &app,
+                    &server_url,
+                    &recording_id,
+                    false,
+                    Some(error.clone()),
+                    Some(&saved.file_path),
+                );
+                return Err(error);
+            }
+            Err(probe_error) => {
+                let error = format!(
+                    "Clip may be incomplete. The local media duration could not be verified ({probe_error})."
+                );
+                live.ctrl.cancelled.store(true, Ordering::SeqCst);
+                let _ = live.result_rx.await;
+                saved.last_attempt_at = Some(now_iso());
+                saved.last_error = Some(error.clone());
+                saved.retry_count = saved.retry_count.saturating_add(1);
+                let _ = write_saved_recording_metadata(&app, &saved);
+                emit_native_upload_progress(&app, "failed", "Upload paused", None, None);
+                let error = format!(
+                    "{error} The clip was saved locally and can be retried from the Clips menu."
+                );
+                emit_native_upload_finished(
+                    &app,
+                    &server_url,
+                    &recording_id,
+                    false,
+                    Some(error.clone()),
+                    Some(&saved.file_path),
+                );
+                return Err(error);
+            }
+        };
         eprintln!(
-            "[live-upload] stop: signalling finalize for {recording_id} (duration_ms={duration_ms})"
+            "[live-upload] stop: signalling finalize for {recording_id} (measured_duration_ms={verified_duration_ms})"
         );
         emit_native_upload_progress(&app, "uploading", "Uploading clip", None, None);
         live.ctrl
             .duration_ms
-            .store(duration_ms as u64, Ordering::SeqCst);
+            .store(verified_duration_ms as u64, Ordering::SeqCst);
         live.ctrl.finalize.store(true, Ordering::SeqCst);
         let result = match live.result_rx.await {
             Ok(inner) => inner,
@@ -1343,7 +1398,7 @@ pub async fn native_fullscreen_recording_stop_and_upload(
                 emit_native_upload_finished(&app, &server_url, &recording_id, true, None, None);
                 Ok(NativeFullscreenUploadResult {
                     recording_id,
-                    duration_ms,
+                    duration_ms: verified_duration_ms,
                     width: session.width,
                     height: session.height,
                     bytes,
@@ -3830,6 +3885,75 @@ fn concat_saved_recording_segments(_segments: &[PathBuf], _output: &Path) -> Res
     Err("Segment concat is only available on macOS.".into())
 }
 
+#[cfg(target_os = "macos")]
+fn probe_local_media_duration_ms(path: &Path) -> Result<u128, String> {
+    use std::ffi::CString;
+
+    use objc2::encode::{Encode, Encoding, RefEncode};
+    use objc2::rc::Retained;
+    use objc2::runtime::{AnyClass, AnyObject};
+    use objc2::{class, msg_send};
+
+    #[repr(C)]
+    #[derive(Copy, Clone)]
+    struct CMTime {
+        value: i64,
+        timescale: i32,
+        flags: u32,
+        epoch: i64,
+    }
+
+    unsafe impl RefEncode for CMTime {
+        const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
+    }
+    unsafe impl Encode for CMTime {
+        const ENCODING: Encoding = Encoding::Struct(
+            "CMTime",
+            &[i64::ENCODING, i32::ENCODING, u32::ENCODING, i64::ENCODING],
+        );
+    }
+
+    let path_str = path
+        .to_str()
+        .ok_or_else(|| format!("recording path is not valid UTF-8: {}", path.display()))?;
+    let path_cstr = CString::new(path_str)
+        .map_err(|_| format!("recording path contains a null byte: {}", path.display()))?;
+    let asset_class_name = CString::new("AVURLAsset").expect("static class name");
+    let asset_class =
+        AnyClass::get(&asset_class_name).ok_or_else(|| "AVURLAsset is unavailable".to_string())?;
+
+    unsafe {
+        let string_allocated: *mut AnyObject = msg_send![class!(NSString), alloc];
+        let string_raw: *mut AnyObject =
+            msg_send![string_allocated, initWithUTF8String: path_cstr.as_ptr()];
+        let path_string = Retained::<AnyObject>::from_raw(string_raw)
+            .ok_or_else(|| format!("could not represent recording path: {}", path.display()))?;
+        let url_raw: *mut AnyObject = msg_send![class!(NSURL), fileURLWithPath: &*path_string];
+        let url = Retained::<AnyObject>::retain(url_raw)
+            .ok_or_else(|| format!("could not open recording path: {}", path.display()))?;
+        let asset_raw: *mut AnyObject =
+            msg_send![asset_class, URLAssetWithURL: &*url, options: std::ptr::null::<AnyObject>()];
+        let asset = Retained::<AnyObject>::retain(asset_raw)
+            .ok_or_else(|| format!("could not inspect local recording: {}", path.display()))?;
+        let duration: CMTime = msg_send![&*asset, duration];
+        if duration.flags & 1 == 0 || duration.timescale <= 0 || duration.value <= 0 {
+            return Err(format!(
+                "Clip may be incomplete. The local media duration could not be verified; the local backup was kept ({})",
+                path.display()
+            ));
+        }
+        let duration_ms = (i128::from(duration.value) * 1_000)
+            .checked_div(i128::from(duration.timescale))
+            .and_then(|value| u128::try_from(value).ok())
+            .filter(|value| *value > 0)
+            .ok_or_else(|| {
+                "Clip may be incomplete. The local media duration was invalid; the local backup was kept."
+                    .to_string()
+            })?;
+        Ok(duration_ms)
+    }
+}
+
 async fn upload_prepared_recording_file(
     app: &AppHandle,
     prepared: &PreparedRecordingFile,
@@ -3844,6 +3968,19 @@ async fn upload_prepared_recording_file(
     has_audio: bool,
     has_camera: bool,
 ) -> Result<NativeFullscreenUploadResult, String> {
+    #[cfg(target_os = "macos")]
+    let verified_local_duration_ms = {
+        let media_duration_ms = probe_local_media_duration_ms(&prepared.path)?;
+        if !media_durations_materially_match(duration_ms, media_duration_ms) {
+            return Err(format!(
+                "Clip may be incomplete. The local media duration ({media_duration_ms} ms) did not match the recorded duration ({duration_ms} ms); the local backup was kept."
+            ));
+        }
+        media_duration_ms
+    };
+    #[cfg(not(target_os = "macos"))]
+    let verified_local_duration_ms = duration_ms;
+
     let total_bytes = prepared.bytes;
     let total_bytes_usize = usize::try_from(total_bytes)
         .map_err(|_| "Native recording is too large to upload on this system.".to_string())?;
@@ -3892,6 +4029,7 @@ async fn upload_prepared_recording_file(
                 has_camera,
                 upload_mode,
                 false,
+                None,
                 buffer,
             )
             .await?;
@@ -3926,7 +4064,7 @@ async fn upload_prepared_recording_file(
             streaming_full_chunks,
             total_posts,
             true,
-            Some(duration_ms),
+            Some(verified_local_duration_ms),
             &prepared.mime_type,
             width,
             height,
@@ -3934,6 +4072,7 @@ async fn upload_prepared_recording_file(
             has_camera,
             upload_mode,
             prepared.locally_transcoded,
+            Some(total_bytes),
             final_body,
         )
         .await?;
@@ -3964,6 +4103,7 @@ async fn upload_prepared_recording_file(
                 has_camera,
                 upload_mode,
                 false,
+                None,
                 buffer,
             )
             .await?;
@@ -3992,7 +4132,7 @@ async fn upload_prepared_recording_file(
             total_chunks,
             total_posts,
             true,
-            Some(duration_ms),
+            Some(verified_local_duration_ms),
             &prepared.mime_type,
             width,
             height,
@@ -4000,6 +4140,7 @@ async fn upload_prepared_recording_file(
             has_camera,
             upload_mode,
             prepared.locally_transcoded,
+            Some(total_bytes),
             Vec::new(),
         )
         .await?;
@@ -4008,7 +4149,7 @@ async fn upload_prepared_recording_file(
     emit_native_upload_progress(app, "opening", "Uploading clip", None, Some(1.0));
     Ok(NativeFullscreenUploadResult {
         recording_id,
-        duration_ms,
+        duration_ms: verified_local_duration_ms,
         width,
         height,
         bytes: total_bytes,
@@ -4127,6 +4268,7 @@ async fn send_upload_post(
     has_camera: bool,
     upload_mode: NativeUploadMode,
     locally_transcoded: bool,
+    expected_source_bytes: Option<u64>,
     body: Vec<u8>,
 ) -> Result<(), String> {
     let body_len = body.len();
@@ -4177,6 +4319,17 @@ async fn send_upload_post(
             body.chars().take(400).collect::<String>()
         ));
     }
+    if is_final {
+        verify_native_finalize_receipt(
+            &body,
+            expected_source_bytes.ok_or_else(|| {
+                "Clip may be incomplete: final upload had no local byte count".to_string()
+            })?,
+            duration_ms.ok_or_else(|| {
+                "Clip may be incomplete: final upload had no local duration".to_string()
+            })?,
+        )?;
+    }
     eprintln!(
         "[clips-tray] native upload post ok recording={recording_id} mode={} index={index}/{total} final={is_final}",
         upload_mode.label()
@@ -4184,6 +4337,88 @@ async fn send_upload_post(
     Ok(())
 }
 
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct NativeFinalizeReceipt {
+    ok: bool,
+    finalized: bool,
+    status: Option<String>,
+    source_size_bytes: Option<u64>,
+    duration_ms: Option<u128>,
+}
+
+fn verify_native_finalize_receipt(
+    body: &str,
+    expected_source_bytes: u64,
+    expected_duration_ms: u128,
+) -> Result<(), String> {
+    let receipt: NativeFinalizeReceipt = serde_json::from_str(body).map_err(|_| {
+        "Clip may be incomplete. The final upload receipt was unreadable; the local backup was kept."
+            .to_string()
+    })?;
+    if !receipt.ok || !receipt.finalized || receipt.status.as_deref() != Some("ready") {
+        return Err(
+            "Clip may be incomplete. Finalization was not confirmed; the local backup was kept."
+                .to_string(),
+        );
+    }
+    if receipt.source_size_bytes != Some(expected_source_bytes) {
+        return Err(format!(
+            "Clip may be incomplete. The server did not confirm all {expected_source_bytes} source bytes; the local backup was kept."
+        ));
+    }
+    let actual_duration_ms = receipt.duration_ms.unwrap_or(0);
+    if !media_durations_materially_match(expected_duration_ms, actual_duration_ms) {
+        return Err(
+            "Clip may be incomplete. The uploaded duration did not match the local recording; the local backup was kept."
+                .to_string(),
+        );
+    }
+    Ok(())
+}
+
+fn media_durations_materially_match(expected_ms: u128, actual_ms: u128) -> bool {
+    if expected_ms == 0 || actual_ms == 0 {
+        return false;
+    }
+    let tolerance_ms = 5_000_u128.max(expected_ms / 50);
+    actual_ms.abs_diff(expected_ms) <= tolerance_ms
+}
+
+#[cfg(test)]
+mod native_finalize_receipt_tests {
+    use super::{media_durations_materially_match, verify_native_finalize_receipt};
+
+    #[test]
+    fn compares_measured_media_duration_with_a_bounded_tolerance() {
+        assert!(media_durations_materially_match(1_592_773, 1_593_259));
+        assert!(media_durations_materially_match(10_000, 15_000));
+        assert!(!media_durations_materially_match(10_000, 15_001));
+        assert!(!media_durations_materially_match(0, 10_000));
+        assert!(!media_durations_materially_match(10_000, 0));
+    }
+
+    #[test]
+    fn accepts_only_matching_ready_receipts() {
+        let ready = r#"{"ok":true,"finalized":true,"status":"ready","sourceSizeBytes":581614005,"durationMs":1593259}"#;
+        assert!(verify_native_finalize_receipt(ready, 581_614_005, 1_592_773).is_ok());
+
+        let short = r#"{"ok":true,"finalized":true,"status":"ready","sourceSizeBytes":581614005,"durationMs":483000}"#;
+        assert!(
+            verify_native_finalize_receipt(short, 581_614_005, 1_592_773)
+                .unwrap_err()
+                .contains("duration")
+        );
+
+        let partial = r#"{"ok":true,"finalized":true,"status":"ready","sourceSizeBytes":183000000,"durationMs":1592773}"#;
+        assert!(
+            verify_native_finalize_receipt(partial, 581_614_005, 1_592_773)
+                .unwrap_err()
+                .contains("581614005")
+        );
+    }
+}
+
 fn upload_url(
     server_url: &str,
     recording_id: &str,

package/corpus/templates/clips/server/db/schema.ts

@@ -37,7 +37,7 @@ export const organizationSettings = table("organization_settings", {
     enum: ["private", "org", "public"],
   })
     .notNull()
-    .default("private"),
+    .default("public"),
   createdAt: text("created_at").notNull().default(now()),
   updatedAt: text("updated_at").notNull().default(now()),
 });
@@ -52,7 +52,7 @@ export const workspaces = table("workspaces", {
     enum: ["private", "org", "public"],
   })
     .notNull()
-    .default("private"),
+    .default("public"),
   createdAt: text("created_at").notNull().default(now()),
   updatedAt: text("updated_at").notNull().default(now()),
   ...ownableColumns(),

package/corpus/templates/clips/server/lib/builder-media-compression.ts

@@ -25,7 +25,6 @@ import { ownerEmailMatches } from "./recordings.js";
 
 const BUILDER_CDN_HOST_RE = /^cdn(?:-qa)?\.builder\.io$/i;
 const DEFAULT_TRIGGER_TIMEOUT_MS = 45_000;
-const DEFAULT_PROBE_TIMEOUT_MS = 10_000;
 const DEFAULT_MAX_SOURCE_BYTES = 512 * 1024 * 1024;
 const MAX_TRIGGER_ATTEMPTS = 5;
 const TRIGGERED_POLL_DELAY_MS = 5 * 60 * 1000;
@@ -102,13 +101,6 @@ function triggerTimeoutMs(): number {
   );
 }
 
-function probeTimeoutMs(): number {
-  return envNumber(
-    "CLIPS_BUILDER_COMPRESSION_PROBE_TIMEOUT_MS",
-    DEFAULT_PROBE_TIMEOUT_MS,
-  );
-}
-
 function maxSourceBytes(): number {
   return envNumber(
     "CLIPS_BUILDER_BACKGROUND_COMPRESSION_MAX_BYTES",
@@ -162,14 +154,6 @@ function parsePositiveNumber(value: unknown): number | undefined {
   return undefined;
 }
 
-function headerByteLength(headers: Headers): number | undefined {
-  const length = parsePositiveNumber(headers.get("content-length"));
-  if (length) return length;
-  const range = headers.get("content-range") ?? "";
-  const total = range.match(/\/(\d+)$/)?.[1];
-  return parsePositiveNumber(total);
-}
-
 function timeoutError(label: string, timeoutMs: number): Error {
   const err = new Error(`${label} timed out after ${timeoutMs}ms`);
   err.name = "AbortError";
@@ -358,38 +342,13 @@ export function builderCompressedMediaUrl(sourceUrl: string): string | null {
   return extractBuilderMediaTarget(sourceUrl)?.compressedUrl ?? null;
 }
 
-async function probeCompressedMedia(
-  compressedUrl: string,
-): Promise<{ exists: boolean; sizeBytes?: number }> {
-  const timeoutMs = probeTimeoutMs();
-  let res = await fetchWithTimeout(
-    compressedUrl,
-    { method: "HEAD" },
-    timeoutMs,
-    "Builder compressed-media probe",
-  );
-  if (res.status === 405) {
-    res = await fetchWithTimeout(
-      compressedUrl,
-      { method: "GET", headers: { Range: "bytes=0-0" } },
-      timeoutMs,
-      "Builder compressed-media probe",
-    );
-  }
-  if (
-    (res.status >= 200 && res.status < 300) ||
-    res.status === 304 ||
-    res.status === 206
-  ) {
-    return { exists: true, sizeBytes: headerByteLength(res.headers) };
-  }
-  if ([403, 404, 416].includes(res.status)) return { exists: false };
-  throw new Error(`Compressed media probe failed (${res.status})`);
-}
-
 async function triggerBuilderCompression(
   state: BuilderMediaCompressionState,
-): Promise<string | null> {
+): Promise<{
+  url: string;
+  durationMs?: number;
+  sizeBytes?: number;
+} | null> {
   const privateKey = await resolveBuilderPrivateKey();
   if (!privateKey) {
     throw new Error("Builder private key is not configured");
@@ -414,8 +373,18 @@ async function triggerBuilderCompression(
       `Builder media compression trigger failed (${res.status}): ${body || res.statusText}`,
     );
   }
-  const json = (await res.json().catch(() => null)) as { url?: string } | null;
-  return typeof json?.url === "string" ? json.url : null;
+  const json = (await res.json().catch(() => null)) as {
+    url?: string;
+    durationMs?: unknown;
+    sizeBytes?: unknown;
+  } | null;
+  return typeof json?.url === "string"
+    ? {
+        url: json.url,
+        durationMs: parsePositiveNumber(json.durationMs),
+        sizeBytes: parsePositiveNumber(json.sizeBytes),
+      }
+    : null;
 }
 
 async function enqueueWorkerCompression(
@@ -499,10 +468,14 @@ async function swapRecordingToCompressed(
   state: BuilderMediaCompressionState,
   compressedUrl: string,
   sizeBytes?: number,
+  durationMs?: number,
 ): Promise<BuilderMediaCompressionState> {
   const db = getDb();
   const [row] = await db
-    .select({ videoUrl: schema.recordings.videoUrl })
+    .select({
+      videoUrl: schema.recordings.videoUrl,
+      durationMs: schema.recordings.durationMs,
+    })
     .from(schema.recordings)
     .where(
       and(
@@ -516,6 +489,18 @@ async function swapRecordingToCompressed(
     return markCompressionFailed(state, "Recording row no longer exists");
   }
 
+  if (
+    !durationMs ||
+    !mediaDurationsMateriallyMatch(row.durationMs, durationMs)
+  ) {
+    return markCompressionFailed(
+      state,
+      durationMs
+        ? `Compressed media duration mismatch (${durationMs}ms output vs ${row.durationMs}ms source)`
+        : "Compressed media completion did not include a verified duration",
+    );
+  }
+
   if (row.videoUrl === compressedUrl) {
     return writeCompressionState(state, {
       status: "ready",
@@ -587,11 +572,6 @@ async function processMediaWorkerState(
   if (!worker) return state;
   if (!isDue(state)) return state;
 
-  const probe = await probeCompressedMedia(worker.outputUrl).catch(() => null);
-  if (probe?.exists) {
-    return swapRecordingToCompressed(state, worker.outputUrl, probe.sizeBytes);
-  }
-
   if (worker.attempts >= MEDIA_WORKER_MAX_ENQUEUE_ATTEMPTS) {
     return markCompressionFailed(
       state,
@@ -652,15 +632,6 @@ async function processCompressionState(
     });
   }
 
-  const probe = await probeCompressedMedia(state.compressedUrl);
-  if (probe.exists) {
-    return swapRecordingToCompressed(
-      state,
-      state.compressedUrl,
-      probe.sizeBytes,
-    );
-  }
-
   if (state.status === "triggered" && state.lastTriggeredAt) {
     const lastTriggeredAt = new Date(state.lastTriggeredAt).getTime();
     if (
@@ -675,9 +646,14 @@ async function processCompressionState(
 
   const attempts = state.attempts + 1;
   try {
-    const compressedUrl = await triggerBuilderCompression(state);
-    if (compressedUrl) {
-      return swapRecordingToCompressed(state, compressedUrl);
+    const compressed = await triggerBuilderCompression(state);
+    if (compressed) {
+      return swapRecordingToCompressed(
+        state,
+        compressed.url,
+        compressed.sizeBytes,
+        compressed.durationMs,
+      );
     }
     return writeCompressionState(state, {
       status: "triggered",
@@ -920,7 +896,12 @@ export async function applyMediaWorkerCallback(
         };
       }
 
-      const next = await swapRecordingToCompressed(state, outputUrl);
+      const next = await swapRecordingToCompressed(
+        state,
+        outputUrl,
+        undefined,
+        callback.durationMs,
+      );
       if (next.status !== "ready") {
         return {
           ok: false,
@@ -934,6 +915,22 @@ export async function applyMediaWorkerCallback(
   );
 }
 
+export function mediaDurationsMateriallyMatch(
+  expectedDurationMs: number,
+  actualDurationMs: number,
+): boolean {
+  if (
+    !Number.isFinite(expectedDurationMs) ||
+    !Number.isFinite(actualDurationMs) ||
+    expectedDurationMs <= 0 ||
+    actualDurationMs <= 0
+  ) {
+    return false;
+  }
+  const toleranceMs = Math.max(5_000, expectedDurationMs * 0.02);
+  return Math.abs(expectedDurationMs - actualDurationMs) <= toleranceMs;
+}
+
 export async function runBuilderMediaCompressionSweepOnce(): Promise<void> {
   const exec = getDbExec();
   const { rows } = await exec.execute({

package/corpus/templates/clips/server/lib/calendar-event-classification.ts

@@ -55,6 +55,25 @@ function normalizeEmail(email: string | null | undefined): string | null {
   return trimmed || null;
 }
 
+export function isDeclinedCalendarEvent(args: {
+  account: CalendarAccountForEventClassification;
+  event: CalendarEvent;
+  currentUserEmail?: string | null;
+}): boolean {
+  const selfEmails = new Set(
+    [args.currentUserEmail, args.account.email, args.account.ownerEmail]
+      .map(normalizeEmail)
+      .filter((email): email is string => Boolean(email)),
+  );
+
+  return (args.event.attendees ?? []).some((attendee) => {
+    if (attendee.responseStatus !== "declined") return false;
+    if (attendee.self === true) return true;
+    const email = normalizeEmail(attendee.email);
+    return Boolean(email && selfEmails.has(email));
+  });
+}
+
 export function isPersonalSoloCalendarEvent(args: {
   account: CalendarAccountForEventClassification;
   event: CalendarEvent;

package/corpus/templates/clips/server/lib/google-calendar-client.ts

@@ -63,6 +63,7 @@ export interface CalendarEvent {
     email?: string;
     displayName?: string;
     responseStatus?: string;
+    self?: boolean;
   }>;
   conferenceData?: {
     entryPoints?: Array<{

package/corpus/templates/clips/server/lib/recordings.ts

@@ -60,6 +60,45 @@ export async function getEventOwnerEmail(event: H3Event): Promise<string> {
 
 export type OrganizationAccessRole = "owner" | "admin" | "member";
 
+export type RecordingVisibility = "private" | "org" | "public";
+
+export const DEFAULT_RECORDING_VISIBILITY: RecordingVisibility = "public";
+
+export function isRecordingVisibility(
+  value: unknown,
+): value is RecordingVisibility {
+  return value === "private" || value === "org" || value === "public";
+}
+
+export function resolveRecordingVisibility(
+  explicit: RecordingVisibility | null | undefined,
+  configured: unknown,
+): RecordingVisibility {
+  if (explicit) return explicit;
+  return isRecordingVisibility(configured)
+    ? configured
+    : DEFAULT_RECORDING_VISIBILITY;
+}
+
+export async function getOrganizationDefaultVisibility(
+  organizationId: string | null | undefined,
+): Promise<RecordingVisibility> {
+  if (!organizationId) return DEFAULT_RECORDING_VISIBILITY;
+
+  try {
+    const [row] = await getDb()
+      .select({
+        defaultVisibility: schema.organizationSettings.defaultVisibility,
+      })
+      .from(schema.organizationSettings)
+      .where(eq(schema.organizationSettings.organizationId, organizationId))
+      .limit(1);
+    return resolveRecordingVisibility(undefined, row?.defaultVisibility);
+  } catch {
+    return DEFAULT_RECORDING_VISIBILITY;
+  }
+}
+
 const ORG_ROLE_RANK: Record<OrganizationAccessRole, number> = {
   member: 1,
   admin: 2,
@@ -231,7 +270,7 @@ export interface RecordingRow {
   durationMs: number;
   videoUrl: string | null;
   status: "uploading" | "processing" | "ready" | "failed";
-  visibility: "private" | "org" | "public";
+  visibility: RecordingVisibility;
   ownerEmail: string;
   folderId: string | null;
   spaceIds: string[];

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

@@ -29,6 +29,7 @@ const INITIAL_TOOL_NAMES = [
   "regenerate-chapters",
   "trim-recording",
   "remove-silences",
+  "update-ai-request-status",
   "remove-filler-words",
   "export-to-brain",
   "navigate",