@agent-native/core 0.77.11 → 0.77.12

package/corpus/templates/clips/desktop/src/overlays/toolbar.tsx

@@ -1,4 +1,5 @@
 import {
+  IconAlertTriangle,
   IconLoader2,
   IconPlayerPauseFilled,
   IconPlayerPlayFilled,
@@ -57,6 +58,9 @@ export function Toolbar() {
   // Stop / Pause are disabled until the recorder actually begins, at which
   // point `clips:toolbar-enabled` fires with `true` from the recorder.
   const [enabled, setEnabled] = useState(false);
+  const [diskSpaceLevel, setDiskSpaceLevel] = useState<
+    "ok" | "warning" | "critical"
+  >("ok");
   const fallbackTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
   const expandedRef = useRef(false);
 
@@ -94,6 +98,26 @@ export function Toolbar() {
     trackListen(
       listen<boolean>("clips:toolbar-enabled", (ev) => {
         setEnabled(!!ev.payload);
+        if (!ev.payload) {
+          setDiskSpaceLevel("ok");
+        }
+      }),
+    );
+    trackListen(
+      listen<{ freeMb: number }>("clips:disk-space-warning", () => {
+        setDiskSpaceLevel((prev) =>
+          prev === "critical" ? "critical" : "warning",
+        );
+      }),
+    );
+    trackListen(
+      listen<{ freeMb: number }>("clips:disk-space-critical", () => {
+        setDiskSpaceLevel("critical");
+      }),
+    );
+    trackListen(
+      listen<{ freeMb: number }>("clips:disk-space-ok", () => {
+        setDiskSpaceLevel("ok");
       }),
     );
     return () => {
@@ -221,7 +245,7 @@ export function Toolbar() {
 
   return (
     <div
-      className={`toolbar-v ${paused ? "toolbar-v-paused" : ""} ${enabled ? "" : "toolbar-v-disabled"}`}
+      className={`toolbar-v ${paused ? "toolbar-v-paused" : ""} ${enabled ? "" : "toolbar-v-disabled"} ${diskSpaceLevel !== "ok" ? `toolbar-v-disk-${diskSpaceLevel}` : ""}`}
       onMouseDown={handleToolbarMouseDown}
       onMouseEnter={() => resizeToolbarWindow(true)}
       onMouseLeave={() => resizeToolbarWindow(false)}
@@ -257,6 +281,19 @@ export function Toolbar() {
           )}
         </button>
         <div className="toolbar-v-time">{formatTime(elapsed)}</div>
+        {diskSpaceLevel !== "ok" && (
+          <div
+            className={`toolbar-v-disk-indicator toolbar-v-disk-indicator-${diskSpaceLevel}`}
+            title={
+              diskSpaceLevel === "critical"
+                ? "Disk almost full — stop recording now to avoid losing your clip"
+                : "Low disk space — save your recording soon"
+            }
+            data-no-drag
+          >
+            <IconAlertTriangle size={12} />
+          </div>
+        )}
         <button
           className="toolbar-v-pause"
           onClick={togglePause}

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

@@ -2676,12 +2676,47 @@ body[data-clips-route="recording-pill"] #root {
   cursor: not-allowed;
 }
 
+.toolbar-v-disk-indicator {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #f59e0b;
+  opacity: 0.9;
+  flex-shrink: 0;
+}
+
+.toolbar-v-disk-indicator-critical {
+  color: #ef4444;
+  animation: toolbar-v-disk-pulse 1.4s ease-in-out infinite;
+}
+
+@keyframes toolbar-v-disk-pulse {
+  0%,
+  100% {
+    opacity: 0.7;
+  }
+  50% {
+    opacity: 1;
+  }
+}
+
+.toolbar-v-disk-warning {
+  border-color: rgba(245, 158, 11, 0.45);
+}
+
+.toolbar-v-disk-critical {
+  border-color: rgba(239, 68, 68, 0.5);
+}
+
 @media (prefers-reduced-motion: reduce) {
   .toolbar-v,
   .toolbar-v-hover-actions,
   .toolbar-v-action {
     transition: none;
   }
+  .toolbar-v-disk-indicator-critical {
+    animation: none;
+  }
 }
 
 /* ------------------------------------------------------------------------- */

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

@@ -26,7 +26,6 @@ use screencapturekit::stream::{
     configuration::SCStreamConfiguration, content_filter::SCContentFilter,
     output_type::SCStreamOutputType, sc_stream::SCStream,
 };
-#[cfg(target_os = "macos")]
 use std::sync::atomic::{AtomicBool, Ordering};
 
 const QUICKTIME_RECORDING_MIME_TYPE: &str = "video/quicktime";
@@ -85,6 +84,16 @@ 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.
+const DISK_SPACE_BLOCK_BYTES: u64 = 500 * 1024 * 1024;
+// Free space below this at start time is logged as a warning but not blocked.
+const DISK_SPACE_WARN_BYTES: u64 = 2 * 1024 * 1024 * 1024;
+// Mid-recording warning threshold (emits clips:disk-space-warning).
+const DISK_MONITOR_WARN_BYTES: u64 = 1024 * 1024 * 1024;
+// Mid-recording critical threshold (emits clips:disk-space-critical).
+const DISK_MONITOR_CRITICAL_BYTES: u64 = 250 * 1024 * 1024;
+// How often the background monitor checks free space.
+const DISK_MONITOR_INTERVAL_SECS: u64 = 30;
 
 #[derive(Default)]
 pub struct NativeFullscreenRecordingState {
@@ -131,6 +140,9 @@ struct NativeFullscreenSession {
     /// warming up) but the recording output hasn't been attached yet, so
     /// nothing is written to disk. `begin` attaches it and flips this false.
     pending_recording_output: bool,
+    /// Stop flag for the background disk-space monitor thread. Set to true
+    /// when the session is finalized or discarded so the thread exits cleanly.
+    disk_monitor_stop: Option<Arc<AtomicBool>>,
 }
 
 #[derive(Clone)]
@@ -245,6 +257,89 @@ fn format_mb(bytes: u64) -> String {
     format!("{:.1} MB", bytes as f64 / (1024.0 * 1024.0))
 }
 
+/// Returns free bytes on the volume containing `path`, or `None` on error.
+#[cfg(target_os = "macos")]
+fn free_disk_bytes(path: &Path) -> Option<u64> {
+    use std::ffi::CString;
+    let c_path = CString::new(path.to_str()?).ok()?;
+    let mut stat: libc::statvfs = unsafe { std::mem::zeroed() };
+    if unsafe { libc::statvfs(c_path.as_ptr(), &mut stat) } == 0 {
+        Some(stat.f_bavail as u64 * stat.f_frsize as u64)
+    } else {
+        None
+    }
+}
+
+/// Spawns a background thread that checks free disk space every
+/// [`DISK_MONITOR_INTERVAL_SECS`] seconds and emits warning/critical events
+/// to the frontend. Returns a stop flag the caller sets to shut the thread down.
+#[cfg(target_os = "macos")]
+fn spawn_disk_monitor(app: AppHandle, recording_path: PathBuf) -> Arc<AtomicBool> {
+    // Use the parent directory for the statvfs call. The recording file itself
+    // may not exist yet (warm/begin path defers writing until after countdown),
+    // and statvfs returns ENOENT on non-existent paths. The parent dir is the
+    // pending-uploads folder, which always exists.
+    let check_path = recording_path
+        .parent()
+        .map(|p| p.to_path_buf())
+        .unwrap_or(recording_path);
+    let stop = Arc::new(AtomicBool::new(false));
+    let stop_clone = Arc::clone(&stop);
+    std::thread::spawn(move || {
+        let tick_ms = 500u64;
+        let ticks_per_check = (DISK_MONITOR_INTERVAL_SECS * 1000) / tick_ms;
+        // Start at ticks_per_check so the first iteration runs an immediate check
+        // rather than waiting the full 30s interval. Subsequent checks are every 30s.
+        let mut ticks = ticks_per_check;
+        // True once a warning/critical event has been emitted; used to gate the
+        // recovery ok event so we only emit it on actual state transitions.
+        let mut was_elevated = false;
+        loop {
+            std::thread::sleep(Duration::from_millis(tick_ms));
+            if stop_clone.load(Ordering::Relaxed) {
+                return;
+            }
+            ticks += 1;
+            if ticks < ticks_per_check {
+                continue;
+            }
+            ticks = 0;
+            if let Some(free) = free_disk_bytes(&check_path) {
+                let free_mb = free / (1024 * 1024);
+                if free < DISK_MONITOR_CRITICAL_BYTES {
+                    eprintln!(
+                        "[clips-tray] disk space critical during recording: {} free",
+                        format_mb(free)
+                    );
+                    let _ = app.emit(
+                        "clips:disk-space-critical",
+                        serde_json::json!({ "freeMb": free_mb }),
+                    );
+                    was_elevated = true;
+                } else if free < DISK_MONITOR_WARN_BYTES {
+                    eprintln!(
+                        "[clips-tray] disk space low during recording: {} free",
+                        format_mb(free)
+                    );
+                    let _ = app.emit(
+                        "clips:disk-space-warning",
+                        serde_json::json!({ "freeMb": free_mb }),
+                    );
+                    was_elevated = true;
+                } else if was_elevated {
+                    // Space recovered — notify the UI to clear its warning.
+                    let _ = app.emit(
+                        "clips:disk-space-ok",
+                        serde_json::json!({ "freeMb": free_mb }),
+                    );
+                    was_elevated = false;
+                }
+            }
+        }
+    });
+    stop
+}
+
 fn emit_native_upload_progress(
     app: &AppHandle,
     stage: &str,
@@ -285,6 +380,10 @@ struct SavedNativeRecording {
     last_attempt_at: Option<String>,
     last_error: Option<String>,
     retry_count: u32,
+    /// True when the SCK finalization callback reported an error, meaning the
+    /// MP4 is missing its moov atom and cannot be recovered by retrying.
+    #[serde(default)]
+    corrupt: bool,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -303,6 +402,7 @@ pub struct PendingNativeRecording {
     last_attempt_at: Option<String>,
     last_error: Option<String>,
     retry_count: u32,
+    corrupt: bool,
 }
 
 #[derive(Serialize)]
@@ -364,6 +464,7 @@ impl From<&SavedNativeRecording> for PendingNativeRecording {
             last_attempt_at: saved.last_attempt_at.clone(),
             last_error: saved.last_error.clone(),
             retry_count: saved.retry_count,
+            corrupt: saved.corrupt,
         }
     }
 }
@@ -671,6 +772,35 @@ pub async fn native_fullscreen_recording_stop_and_upload(
     )?;
     if let Err(stop_err) = &stop_outcome {
         saved.last_error = Some(stop_err.clone());
+        // Only mark corrupt when the SCK delegate explicitly called recording_did_fail
+        // (error contains "finalize failed"). Transient stop_capture /
+        // remove_recording_output errors also return Err but don't prove the moov
+        // was never written — they should remain retryable.
+        // "finalization callback failed" is unique to the delegate path;
+        // "recording finalize failed" also appears on remove_recording_output errors.
+        let is_definitive = stop_err.contains("finalization callback failed");
+        if is_definitive && mp4_has_moov(&saved.file_path) == Some(false) {
+            saved.corrupt = true;
+            eprintln!(
+                "[clips-tray] recording marked corrupt: definitive finalize error + missing moov atom"
+            );
+        }
+    } else if mp4_has_moov(&saved.file_path) == Some(false) {
+        // stop_outcome was Ok but the finalize callback timed out — SCK may still be
+        // flushing the moov atom. Persist metadata so the clip appears as retryable
+        // in the UI, then bail out before upload_recording_file re-checks moov and
+        // permanently marks it corrupt.
+        saved.last_error = Some(
+            "Recorded MP4 is missing playback metadata. Please retry the recording."
+                .to_string(),
+        );
+        eprintln!("[clips-tray] recording missing moov after Ok stop outcome (likely finalize timeout) — saving as retryable, skipping upload");
+        write_saved_recording_metadata(&app, &saved)?;
+        emit_native_upload_progress(&app, "failed", "Upload paused", None, None);
+        return Err(
+            "Recorded MP4 is missing playback metadata. Please retry the recording."
+                .to_string(),
+        );
     } else if let Err(merge_err) = &consolidate_outcome {
         saved.last_error = Some(merge_err.clone());
     }
@@ -711,6 +841,9 @@ pub async fn native_fullscreen_recording_stop_and_upload(
             saved.last_attempt_at = Some(now_iso());
             saved.last_error = Some(err.clone());
             saved.retry_count = saved.retry_count.saturating_add(1);
+            if is_moov_corrupt_error(&err) {
+                saved.corrupt = true;
+            }
             let _ = write_saved_recording_metadata(&app, &saved);
             emit_native_upload_progress(&app, "failed", "Upload paused", None, None);
             Err(format!(
@@ -749,6 +882,37 @@ pub async fn native_fullscreen_recording_stop_and_save(
             ));
         }
     }
+    // Only treat the file as permanently unrecoverable when the SCK delegate
+    // explicitly called recording_did_fail (error contains "finalization callback failed",
+    // the unique prefix used by the delegate path). Transient stop_capture /
+    // remove_recording_output errors use "recording finalize failed" and should
+    // remain retryable — deleting on those would risk silent data loss.
+    let is_definitive_finalize_error = stop_outcome
+        .as_ref()
+        .err()
+        .map(|e| e.contains("finalization callback failed"))
+        .unwrap_or(false);
+    if is_definitive_finalize_error {
+        if mp4_has_moov(&session.path) == Some(false) {
+            eprintln!(
+                "[clips-tray] native local recording corrupt (finalize error + missing moov) — not exporting"
+            );
+            let _ = std::fs::remove_file(&session.path);
+            return Err(
+                "Recorded file is corrupted — the video is incomplete and cannot be saved. \
+                 Please record again."
+                    .into(),
+            );
+        }
+    } else if mp4_has_moov(&session.path) == Some(false) {
+        // Non-definitive case (transient error or finalize timeout): the moov may
+        // still be flushing. Proceed with the export so the file lands in the
+        // user-requested folder and is accessible — stranding it in an internal
+        // pending folder with no metadata would leave it unrecoverable.
+        eprintln!(
+            "[clips-tray] native local recording has no moov after finalize; exporting anyway so user can access the file"
+        );
+    }
 
     save_native_recording_to_local_export(&app, &session, &folder_name, &file_role, duration_ms)
 }
@@ -842,6 +1006,20 @@ pub async fn native_fullscreen_recording_resume(
     let segment_path = segment_path_for(&app, &restart.safe_id, extension, next_counter)?;
     let _ = std::fs::remove_file(&segment_path);
 
+    // Re-check disk space before starting the new segment. The mid-recording
+    // monitor warns but does not block, so space can drop below the hard limit
+    // between the initial start and a resume without being caught here.
+    #[cfg(target_os = "macos")]
+    if let Some(free) = free_disk_bytes(segment_path.parent().unwrap_or(&segment_path)) {
+        if free < DISK_SPACE_BLOCK_BYTES {
+            return Err(format!(
+                "Not enough disk space to resume recording. Free up at least {} and try again (currently {} free).",
+                format_mb(DISK_SPACE_BLOCK_BYTES),
+                format_mb(free)
+            ));
+        }
+    }
+
     // Start the new segment backend FIRST. Only clear paused state if it
     // succeeds — otherwise the session would be left with no backend but
     // appear running, which silently drops everything after the resume.
@@ -896,6 +1074,10 @@ fn take_and_finalize_active_session(
     }
     .ok_or_else(|| "No native full-screen recording is active.".to_string())?;
 
+    // Signal the disk monitor to stop before tearing down the backend.
+    if let Some(stop) = &session.disk_monitor_stop {
+        stop.store(true, Ordering::Relaxed);
+    }
     // Try to finalize capture, but don't early-return on failure: the
     // underlying MP4 file is already on disk after stop_capture(), and
     // ScreenCaptureKit's StreamError("invalid parameter") on
@@ -952,6 +1134,9 @@ fn finalize_active_backend(
 /// session displaced by a new start). Finalizes any active backend and
 /// deletes every on-disk artifact — segment files and the final path.
 fn discard_session(session: &mut NativeFullscreenSession) {
+    if let Some(stop) = &session.disk_monitor_stop {
+        stop.store(true, Ordering::Relaxed);
+    }
     let _ = finalize_active_backend(session, false);
     for segment in &session.segments {
         let _ = std::fs::remove_file(segment);
@@ -1371,11 +1556,17 @@ pub async fn native_fullscreen_recording_retry_upload(
             Ok(result)
         }
         Err(err) => {
+            if is_moov_corrupt_error(&err) {
+                saved.corrupt = true;
+            }
             persist_saved_recording_error(&app, &mut saved, &err);
             emit_native_upload_progress(&app, "failed", "Retry paused", None, None);
-            Err(format!(
-                "{err}. The local copy is still saved, so you can retry again."
-            ))
+            let suffix = if saved.corrupt {
+                "The file is corrupted and cannot be recovered."
+            } else {
+                "The local copy is still saved, so you can retry again."
+            };
+            Err(format!("{err}. {suffix}"))
         }
     }
 }
@@ -1780,6 +1971,7 @@ fn saved_recording_from_session(
         last_attempt_at: None,
         last_error: None,
         retry_count: 0,
+        corrupt: false,
     })
 }
 
@@ -1912,6 +2104,21 @@ fn start_screencapturekit_recording(
         "[clips-tray] starting ScreenCaptureKit recording -> {}",
         path.display()
     );
+    let check_path = path.parent().unwrap_or(&path);
+    if let Some(free) = free_disk_bytes(check_path) {
+        if free < DISK_SPACE_BLOCK_BYTES {
+            return Err(format!(
+                "Not enough disk space to record. Free up at least {} and try again (currently {} free).",
+                format_mb(DISK_SPACE_BLOCK_BYTES),
+                format_mb(free)
+            ));
+        } else if free < DISK_SPACE_WARN_BYTES {
+            eprintln!(
+                "[clips-tray] low disk space at recording start: {} free — recording may fail if space runs out",
+                format_mb(free)
+            );
+        }
+    }
     let (backend, width, height) = start_screencapturekit_backend_at(
         &path,
         include_audio,
@@ -1941,6 +2148,7 @@ fn start_screencapturekit_recording(
         },
     );
     session.pending_recording_output = defer_recording_output;
+    session.disk_monitor_stop = Some(spawn_disk_monitor(app.clone(), session.path.clone()));
     Ok(session)
 }
 
@@ -1959,6 +2167,20 @@ fn start_screencapture_recording(
         "[clips-tray] starting screencapture (fallback) recording -> {}",
         path.display()
     );
+    if let Some(free) = free_disk_bytes(path.parent().unwrap_or(&path)) {
+        if free < DISK_SPACE_BLOCK_BYTES {
+            return Err(format!(
+                "Not enough disk space to record. Free up at least {} and try again (currently {} free).",
+                format_mb(DISK_SPACE_BLOCK_BYTES),
+                format_mb(free)
+            ));
+        } else if free < DISK_SPACE_WARN_BYTES {
+            eprintln!(
+                "[clips-tray] low disk space at recording start: {} free — recording may fail if space runs out",
+                format_mb(free)
+            );
+        }
+    }
     let (backend, w, h) = start_screencapture_backend_at(
         app,
         &path,
@@ -1967,7 +2189,7 @@ fn start_screencapture_recording(
         capture_region,
     )?;
     let (fallback_width, fallback_height) = primary_monitor_size(app);
-    Ok(new_fullscreen_session(
+    let mut session = new_fullscreen_session(
         backend,
         path,
         QUICKTIME_RECORDING_MIME_TYPE,
@@ -1985,7 +2207,9 @@ fn start_screencapture_recording(
             target_display_id,
             capture_region,
         },
-    ))
+    );
+    session.disk_monitor_stop = Some(spawn_disk_monitor(app.clone(), session.path.clone()));
+    Ok(session)
 }
 
 /// Build a fresh `NativeFullscreenSession` around a freshly-started
@@ -2011,6 +2235,7 @@ fn new_fullscreen_session(
         paused_at: None,
         restart,
         pending_recording_output: false,
+        disk_monitor_stop: None,
     }
 }
 
@@ -2118,17 +2343,17 @@ fn stop_native_recording(
                 .map_err(|e| format!("ScreenCaptureKit stop failed: {e:?}"));
             // remove_recording_output() occasionally fails with
             // StreamError("Failed due to an invalid parameter") when the audio
-            // tap or stream state hasn't fully drained yet. Retry once after a
-            // short pause before giving up — the underlying MP4 file is
-            // already on disk by this point, so the recovery path can still
-            // pick it up via write_saved_recording_metadata().
+            // tap or stream state hasn't fully drained yet. We retry once after
+            // a 200ms drain delay; the sleep is in the error branch only so
+            // healthy clips pay no extra stop latency.
             let remove_result = stream
                 .remove_recording_output(recording)
                 .map_err(|e| format!("ScreenCaptureKit recording finalize failed: {e:?}"));
             let remove_result = match remove_result {
                 Ok(v) => Ok(v),
                 Err(first_err) => {
-                    std::thread::sleep(Duration::from_millis(150));
+                    eprintln!("[clips-tray] waiting 200ms for SCK frame buffer to drain before remove_recording_output retry");
+                    std::thread::sleep(Duration::from_millis(200));
                     stream.remove_recording_output(recording).map_err(|e| {
                         format!(
                             "ScreenCaptureKit recording finalize failed (retry): {e:?}; first attempt: {first_err}"
@@ -2158,12 +2383,25 @@ fn stop_native_recording(
                 None
             };
 
+            // Check the delegate outcome BEFORE returning on stop_result. When
+            // stop_capture() fails AND recording_did_fail fires, callers must see
+            // the "finalization callback failed" prefix to correctly identify
+            // permanent corruption — the stop_capture error string would mask it.
+            if let Some(Err(err)) = &finalize_outcome {
+                eprintln!("[clips-tray] SCK finalize failed: {err}");
+                // Use a unique prefix so callers can distinguish the SCK delegate
+                // reporting failure (recording_did_fail) from teardown API errors.
+                return Err(format!("ScreenCaptureKit finalization callback failed: {err}"));
+            }
+
             if let Err(err) = stop_result {
                 return Err(err);
             }
-
-            if let Some(Err(err)) = &finalize_outcome {
-                return Err(format!("ScreenCaptureKit recording finalize failed: {err}"));
+            if waited_for_finalize && finalize_outcome.is_none() {
+                eprintln!(
+                    "[clips-tray] SCK finalize timed out after {}s — moov atom may be missing",
+                    SCK_FINALIZE_TIMEOUT.as_secs()
+                );
             }
 
             match remove_result {
@@ -2583,6 +2821,81 @@ fn upload_url(
     Ok(url.to_string())
 }
 
+/// Returns true when an upload error string indicates the file is permanently
+/// corrupt (missing moov atom) and cannot be recovered by retrying.
+fn is_moov_corrupt_error(err: &str) -> bool {
+    // Matches both the native prepare_recording_file error and the server-side
+    // finalize-recording.ts error so the corrupt flag is set regardless of
+    // which layer first detected the missing moov atom.
+    err.contains("video is missing required metadata")
+        || err.contains("corrupted or incomplete")
+}
+
+/// Walk the top-level ISO BMFF boxes of a file and return `Some(true)` when a
+/// `moov` box is present, `Some(false)` when the scan reached EOF without
+/// finding one (file is unplayable), or `None` when the file could not be
+/// read (transient I/O error — callers must not treat this as permanent
+/// corruption).
+fn mp4_has_moov(path: &Path) -> Option<bool> {
+    use std::io::{ErrorKind, Read, Seek, SeekFrom};
+    let mut f = match std::fs::File::open(path) {
+        Ok(f) => f,
+        Err(e) => {
+            eprintln!("[clips-tray] mp4_has_moov: could not open file for moov scan: {e}");
+            return None;
+        }
+    };
+    let mut buf = [0u8; 8];
+    loop {
+        match f.read_exact(&mut buf) {
+            Ok(()) => {}
+            Err(e) if e.kind() == ErrorKind::UnexpectedEof => {
+                // Clean EOF — moov was never found; file is missing the atom.
+                return Some(false);
+            }
+            Err(_) => return None, // Transient read error; don't mark as corrupt.
+        }
+        let box_size_raw = u32::from_be_bytes([buf[0], buf[1], buf[2], buf[3]]);
+        let box_type = &buf[4..8];
+        if box_type == b"moov" {
+            return Some(true);
+        }
+        let skip: u64 = match box_size_raw {
+            0 => return Some(false), // box extends to EOF — moov not before it
+            1 => {
+                // 64-bit extended-size: next 8 bytes hold the real size.
+                let mut ext = [0u8; 8];
+                match f.read_exact(&mut ext) {
+                    Ok(()) => {}
+                    Err(e) if e.kind() == ErrorKind::UnexpectedEof => return Some(false),
+                    Err(_) => return None,
+                }
+                let full = u64::from_be_bytes(ext);
+                // full includes the 8-byte header + 8-byte ext field (16 total).
+                full.saturating_sub(16)
+            }
+            // Sizes 2-7 are below the minimum valid box size (8 bytes).
+            // saturating_sub would produce 0, causing skip=0 and an infinite
+            // loop since the file position would never advance.
+            n if n < 8 => return Some(false),
+            n => (n as u64).saturating_sub(8),
+        };
+        if skip > 0 {
+            // Use SeekFrom::Current with a checked i64 cast; a valid box
+            // whose payload exceeds i64::MAX (~9 EiB) is treated as
+            // malformed — return Some(false) so callers can surface the
+            // error without wrapping or seeking backwards.
+            let offset = match i64::try_from(skip) {
+                Ok(v) => v,
+                Err(_) => return Some(false),
+            };
+            if f.seek(SeekFrom::Current(offset)).is_err() {
+                return None; // seek I/O error — don't assume corruption
+            }
+        }
+    }
+}
+
 fn prepare_recording_file(
     app: &AppHandle,
     path: &Path,
@@ -2606,6 +2919,22 @@ fn prepare_recording_file(
         );
         return Err("Native recording produced an empty file.".into());
     }
+    // For MP4/QuickTime files check that a top-level moov atom exists. SCK
+    // finalization errors (-5814) produce a file with ftyp + mdat but no
+    // moov, making it permanently unplayable. Catching this here avoids a
+    // full chunked upload that the server will reject anyway.
+    if mime_type == "video/mp4" || mime_type == "video/quicktime" {
+        if mp4_has_moov(path) == Some(false) {
+            eprintln!(
+                "[clips-tray] native recording corrupt moov check failed — skipping upload"
+            );
+            return Err(
+                "Recorded file is corrupted or incomplete — the video is missing required \
+                 metadata. Please record again."
+                    .into(),
+            );
+        }
+    }
     emit_native_upload_progress(app, "preparing", "Optimizing clip", None, None);
 
     let original = PreparedRecordingFile {

package/dist/cli/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/cli/create.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/cli/create.ts"],"names":[],"mappings":"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"}