@agent-native/core 0.86.0 → 0.87.0

package/corpus/templates/clips/desktop/src/components/MediaDeviceRow.tsx

@@ -104,6 +104,7 @@ export function MediaDeviceRow({
   const { open, setOpen, rowRef } = useRowMenu();
 
   const disabled = !on;
+  const canOpenMenu = !disabled || (kind === "mic" && !!onSystemAudioToggle);
   const defaultLabel = kind === "camera" ? "Default camera" : "Default mic";
   const accessLabel =
     kind === "camera" ? "Allow camera access" : "Allow microphone access";
@@ -119,9 +120,9 @@ export function MediaDeviceRow({
         type="button"
         className="row-button"
         onClick={() => {
-          if (!disabled) setOpen((v) => !v);
+          if (canOpenMenu) setOpen((v) => !v);
         }}
-        disabled={disabled}
+        disabled={!canOpenMenu}
         title={label}
       >
         <span className="row-label">{label}</span>

package/corpus/templates/clips/desktop/src/lib/media-capture-constraints.ts

@@ -0,0 +1,121 @@
+export const VOICE_FOCUSED_AUDIO_CONSTRAINTS: MediaTrackConstraints = {
+  echoCancellation: { ideal: true },
+  noiseSuppression: { ideal: true },
+  autoGainControl: { ideal: true },
+  channelCount: { ideal: 1 },
+};
+
+export function voiceFocusedAudioConstraints(
+  deviceId?: string | null,
+): MediaTrackConstraints {
+  const id = deviceId?.trim();
+  return {
+    ...VOICE_FOCUSED_AUDIO_CONSTRAINTS,
+    ...(id ? { deviceId: { exact: id } } : {}),
+  };
+}
+
+export function buildDesktopDisplayMediaOptions({
+  audio,
+  frameRate,
+  maxWidth,
+  maxHeight,
+}: {
+  audio: boolean;
+  frameRate: number;
+  maxWidth: number;
+  maxHeight: number;
+}): DisplayMediaStreamOptions {
+  return {
+    video: {
+      frameRate: {
+        ideal: frameRate,
+        max: frameRate,
+      },
+      width: { ideal: maxWidth },
+      height: { ideal: maxHeight },
+    },
+    audio,
+  };
+}
+
+export function isMediaConstraintFailure(err: unknown): boolean {
+  const name =
+    err instanceof DOMException || err instanceof Error ? err.name : "";
+  const message = err instanceof Error ? err.message : String(err);
+  return (
+    name === "OverconstrainedError" ||
+    name === "ConstraintNotSatisfiedError" ||
+    name === "NotFoundError" ||
+    /invalid constraint|overconstrained|could not satisfy constraint|device not found|requested device not found/i.test(
+      message,
+    )
+  );
+}
+
+export async function getCameraStreamWithFallback(
+  deviceId?: string | null,
+): Promise<MediaStream> {
+  const id = deviceId?.trim();
+  const exactConstraints: MediaStreamConstraints = {
+    video: id ? { deviceId: { exact: id } } : true,
+    audio: false,
+  };
+
+  try {
+    return await navigator.mediaDevices.getUserMedia(exactConstraints);
+  } catch (err) {
+    if (!id || !isMediaConstraintFailure(err)) throw err;
+    console.warn(
+      "[clips-recorder] selected camera constraint failed; retrying default camera",
+      err,
+    );
+    return navigator.mediaDevices.getUserMedia({ video: true, audio: false });
+  }
+}
+
+export async function getAudioStreamWithFallback(
+  deviceId?: string | null,
+): Promise<MediaStream> {
+  const id = deviceId?.trim();
+
+  try {
+    return await navigator.mediaDevices.getUserMedia({
+      audio: voiceFocusedAudioConstraints(id),
+      video: false,
+    });
+  } catch (err) {
+    if (!isMediaConstraintFailure(err)) throw err;
+    if (id) {
+      console.warn(
+        "[clips-recorder] selected mic constraint failed; retrying default mic",
+        err,
+      );
+      try {
+        return await navigator.mediaDevices.getUserMedia({
+          audio: VOICE_FOCUSED_AUDIO_CONSTRAINTS,
+          video: false,
+        });
+      } catch (fallbackErr) {
+        if (!isMediaConstraintFailure(fallbackErr)) throw fallbackErr;
+        console.warn(
+          "[clips-recorder] voice-focused mic constraints failed; retrying basic audio",
+          fallbackErr,
+        );
+        return navigator.mediaDevices.getUserMedia({
+          audio: true,
+          video: false,
+        });
+      }
+    }
+
+    console.warn(
+      "[clips-recorder] voice-focused mic constraints failed; retrying basic audio",
+      err,
+    );
+    return navigator.mediaDevices.getUserMedia({
+      audio: true,
+      video: false,
+    });
+  }
+}

package/corpus/templates/clips/desktop/src/lib/recorder.ts

@@ -64,6 +64,11 @@ import {
   type LocalExportedFile,
   type LocalRecordingTarget,
 } from "./local-export";
+import {
+  buildDesktopDisplayMediaOptions,
+  getAudioStreamWithFallback,
+  getCameraStreamWithFallback,
+} from "./media-capture-constraints";
 import { buildCaptureTitle, type CaptureTitleResult } from "./recording-title";
 import {
   startTranscriptionCapture,
@@ -384,22 +389,6 @@ function createCloudMediaRecorder(
   throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
 
-const VOICE_FOCUSED_AUDIO_CONSTRAINTS: MediaTrackConstraints = {
-  echoCancellation: { ideal: true },
-  noiseSuppression: { ideal: true },
-  autoGainControl: { ideal: true },
-  channelCount: { ideal: 1 },
-};
-
-function voiceFocusedAudioConstraints(
-  deviceId?: string | null,
-): MediaTrackConstraints {
-  return {
-    ...VOICE_FOCUSED_AUDIO_CONSTRAINTS,
-    ...(deviceId ? { deviceId: { exact: deviceId } } : {}),
-  };
-}
-
 interface RecordingAudio {
   tracks: MediaStreamTrack[];
   cleanup: () => void;
@@ -444,13 +433,13 @@ function localRecordingTargetsForMode({
   localRecordingMode,
   displayStream,
   bubbleCameraStream,
-  audioStream,
+  recordingAudio,
   combined,
 }: {
   localRecordingMode: Exclude<LocalRecordingMode, "off">;
   displayStream: MediaStream | null;
   bubbleCameraStream: MediaStream | null;
-  audioStream: MediaStream | null;
+  recordingAudio: RecordingAudio;
   combined: MediaStream;
 }): LocalRecordingTarget[] {
   if (localRecordingMode === "composed") {
@@ -461,7 +450,7 @@ function localRecordingTargetsForMode({
   if (displayStream) {
     const desktopTracks = [
       ...displayStream.getVideoTracks(),
-      ...(audioStream?.getAudioTracks() ?? displayStream.getAudioTracks()),
+      ...recordingAudio.tracks,
     ];
     targets.push({
       role: "desktop",
@@ -1698,8 +1687,10 @@ async function startNativeFullscreenRecording(
   // clock and the toolbar-enable behind the real recording start.
   let startedAt = 0;
   let nativeTranscriptFailureSaved = false;
+  const wantsSystemAudio = params.systemAudioOn !== false;
+  const wantsRecordedAudio = wantsAudio || wantsSystemAudio;
   const saveTranscriptFailure = async (failureReason: string) => {
-    if (!wantsAudio || nativeTranscriptFailureSaved || !id) return;
+    if (!wantsRecordedAudio || nativeTranscriptFailureSaved || !id) return;
     nativeTranscriptFailureSaved = true;
     await saveRecordingTranscriptFailure(
       params.serverUrl,
@@ -1724,12 +1715,7 @@ async function startNativeFullscreenRecording(
     if (localOnly && localRecordingMode === "separate" && wantsCamera) {
       localCameraStream =
         params.preAcquiredCameraStream ??
-        (await navigator.mediaDevices.getUserMedia({
-          video: params.cameraId
-            ? { deviceId: { exact: params.cameraId } }
-            : true,
-          audio: false,
-        }));
+        (await getCameraStreamWithFallback(params.cameraId));
       localOwnsCameraStream =
         localCameraStream !== params.preAcquiredCameraStream;
       localCameraExport = await prepareLocalRecordingExport(
@@ -1757,16 +1743,12 @@ async function startNativeFullscreenRecording(
         ? "[clips-recorder] invoking show_countdown for native local recording"
         : "[clips-recorder] invoking show_countdown + createServerRecording",
     );
-    const wantsSystemAudio = wantsAudio && params.systemAudioOn !== false;
-    // Resolve the mic's REAL device name for the native recorder. WebKit's
-    // deviceId is a salted hash that never equals ScreenCaptureKit's CoreAudio
-    // device UID, so the Rust side can only pin the input by NAME. The stored
-    // label can be stale or empty (device list locked when picked, or a rotated
-    // deviceId salt after an app update) — that's what makes "only Default
-    // works": the hash matches nothing and there's no name to fall back to.
-    // A one-shot getUserMedia gives the exact current device name, the same
-    // string ScreenCaptureKit exposes, so name resolution succeeds. Done before
-    // warming so both phases pin the same input.
+    // Resolve the mic's REAL device name before native setup. WebKit's deviceId
+    // is a salted hash that never equals CoreAudio's device UID, so any native
+    // path that needs a mic can only pin the input by NAME. The stored label can
+    // be stale or empty (device list locked when picked, or a rotated deviceId
+    // salt after an app update), so a one-shot getUserMedia gives the exact
+    // current device name.
     let micDeviceLabel = params.micLabel || null;
     if (wantsAudio && params.micId) {
       try {
@@ -1797,11 +1779,10 @@ async function startNativeFullscreenRecording(
       micDeviceLabel,
       captureRegion,
     };
-    // Warm the mic DURING the countdown. ScreenCaptureKit delivers its first
-    // mic sample ~1s after capture starts; warming now lets `begin` attach the
-    // recording output to an already-live mic, so the clip no longer starts
-    // with a silent second. No-op when there's nothing to pre-warm (mic off /
-    // SCK unavailable) — `begin` then does a normal immediate start.
+    // Warm ScreenCaptureKit DURING the countdown without recording frames yet.
+    // This keeps the capture start off the critical path while letting `begin`
+    // attach the recording output at the exact start moment. No-op when SCK is
+    // unavailable — `begin` then does a normal immediate start.
     const warmMic = (recordingId: string) =>
       invoke("native_fullscreen_recording_warm", {
         recordingId,
@@ -1822,13 +1803,13 @@ async function startNativeFullscreenRecording(
       const recordingPromise = createServerRecording(
         params.serverUrl,
         wantsCamera,
-        wantsAudio,
+        wantsRecordedAudio,
         captureTitle,
       ).finally(() => {
         console.timeEnd("[clips-recorder] createServerRecording duration");
       });
       // The recording id usually lands well before the countdown ends — warm
-      // the mic as soon as it does so the warm-up overlaps the 3-2-1.
+      // native capture as soon as it does so setup overlaps the 3-2-1.
       const warmAndId = (async () => {
         const createRes = await recordingPromise;
         await warmMic(createRes.id);
@@ -2049,7 +2030,7 @@ async function startNativeFullscreenRecording(
             recordingId: id,
             authToken: params.authToken ?? "",
             cookie: params.cookie ?? "",
-            hasAudio: wantsAudio,
+            hasAudio: wantsRecordedAudio,
             hasCamera: wantsCamera,
           },
         );
@@ -2074,9 +2055,9 @@ async function startNativeFullscreenRecording(
               capturedTranscript,
               params.authToken,
             );
-          } else if (wantsAudio) {
+          } else if (wantsRecordedAudio) {
             await saveTranscriptFailure(
-              "No speech was captured during this recording. If you spoke, check Microphone input, Speech Recognition permission, and the selected mic, then retry transcription.",
+              "No speech was captured during this recording. If you spoke or played system audio, check System Audio, Microphone input, Speech Recognition permission, and the selected mic, then retry transcription.",
             );
           }
 
@@ -2265,8 +2246,7 @@ async function startNativeFullscreenRecording(
 
   if (!localOnly) {
     await showRegionGuidesForRecording(true);
-    const wantsSystemAudio = wantsAudio && params.systemAudioOn !== false;
-    transcriptionCapture = wantsAudio
+    transcriptionCapture = wantsRecordedAudio
       ? await startTranscriptionCapture(
           {
             deviceId: params.micId,
@@ -2288,12 +2268,12 @@ async function startNativeFullscreenRecording(
       );
       void transcriptionCapture.pause().catch(() => {});
     } else if (
-      wantsAudio &&
+      wantsRecordedAudio &&
       !transcriptionCapture &&
       shouldSaveLocalTranscriptionStartupFailure()
     ) {
       void saveTranscriptFailure(
-        "macOS Speech recognition could not start for this recording. Check Speech Recognition and Microphone permissions, then retry transcription.",
+        "macOS Speech recognition could not start for this recording. Check Speech Recognition, System Audio, and Microphone permissions, then retry transcription.",
       );
     }
   }
@@ -2409,7 +2389,8 @@ async function startRecordingInner(
   const wantsScreen = params.mode !== "camera";
   const wantsCamera = params.mode !== "screen" && params.cameraOn;
   const wantsAudio = params.micOn;
-  const wantsSystemAudio = wantsAudio && params.systemAudioOn !== false;
+  const wantsSystemAudio = wantsScreen && params.systemAudioOn !== false;
+  const wantsRecordedAudio = wantsAudio || wantsSystemAudio;
   const audioCue = createAudioCue();
   const captureSource = params.source ?? "window";
   const localRecordingMode = params.localRecordingMode ?? "off";
@@ -2421,6 +2402,7 @@ async function startRecordingInner(
     wantsScreen,
     wantsCamera,
     wantsAudio,
+    wantsSystemAudio,
   });
 
   if (wantsScreen && shouldUseNativeFullscreenRecording(captureSource)) {
@@ -2466,21 +2448,18 @@ async function startRecordingInner(
   const displayStreamPromise: Promise<MediaStream> | null = wantsScreen
     ? (() => {
         if (!devSyntheticCapture) {
-          const displaySurface =
-            captureSource === "window" ? "window" : "monitor";
-          return navigator.mediaDevices.getDisplayMedia({
-            video: {
-              frameRate: {
-                ideal: CLOUD_CAPTURE_FRAME_RATE,
-                max: CLOUD_CAPTURE_FRAME_RATE,
-              },
-              width: { ideal: CLOUD_CAPTURE_MAX_WIDTH },
-              height: { ideal: CLOUD_CAPTURE_MAX_HEIGHT },
-              displaySurface,
-            },
-            // System/desktop audio is gated by the system-audio toggle, not mic.
-            audio: wantsSystemAudio,
-          });
+          // Do not pass displaySurface as an input constraint. Modern runtimes
+          // can reject it with "Invalid constraint", and it cannot reliably
+          // pre-filter the OS picker anyway; the selected track reports its
+          // actual surface through getSettings() after capture starts.
+          return navigator.mediaDevices.getDisplayMedia(
+            buildDesktopDisplayMediaOptions({
+              audio: wantsSystemAudio,
+              frameRate: CLOUD_CAPTURE_FRAME_RATE,
+              maxWidth: CLOUD_CAPTURE_MAX_WIDTH,
+              maxHeight: CLOUD_CAPTURE_MAX_HEIGHT,
+            }),
+          );
         }
         console.warn(
           "[clips-recorder] using opt-in dev synthetic screen capture; remove localStorage clips:dev-synthetic-capture to use the native picker",
@@ -2506,18 +2485,10 @@ async function startRecordingInner(
   }
   const bubbleCameraStreamPromise: Promise<MediaStream> | null =
     wantsCamera && !reusedCameraStream
-      ? navigator.mediaDevices.getUserMedia({
-          video: params.cameraId
-            ? { deviceId: { exact: params.cameraId } }
-            : true,
-          audio: false,
-        })
+      ? getCameraStreamWithFallback(params.cameraId)
       : null;
   const audioStreamPromise: Promise<MediaStream> | null = wantsAudio
-    ? navigator.mediaDevices.getUserMedia({
-        audio: voiceFocusedAudioConstraints(params.micId),
-        video: false,
-      })
+    ? getAudioStreamWithFallback(params.micId)
     : null;
 
   // Use allSettled so a single rejection (e.g. user cancels the macOS screen
@@ -2700,7 +2671,7 @@ async function startRecordingInner(
       localRecordingMode,
       displayStream,
       bubbleCameraStream,
-      audioStream,
+      recordingAudio,
       combined,
     });
 
@@ -2896,7 +2867,7 @@ async function startRecordingInner(
   const recordingPromise = createServerRecording(
     params.serverUrl,
     wantsCamera,
-    wantsAudio,
+    recordingAudio.tracks.length > 0,
     captureTitle,
     { mimeType: mimeType || "video/webm", requestStreaming: true },
   ).finally(() => {
@@ -2922,7 +2893,7 @@ async function startRecordingInner(
   console.log("[clips-recorder] recording row created", { id, uploadMode });
   let nativeTranscriptFailureSaved = false;
   const saveTranscriptFailure = async (failureReason: string) => {
-    if (!wantsAudio || nativeTranscriptFailureSaved) return;
+    if (!wantsRecordedAudio || nativeTranscriptFailureSaved) return;
     nativeTranscriptFailureSaved = true;
     await saveRecordingTranscriptFailure(
       params.serverUrl,
@@ -3182,7 +3153,7 @@ async function startRecordingInner(
   // delaying capture, so the first ~1s the user expected to record was lost
   // (and the recording felt cut at the end). It's a separate capture from the
   // recorded audio tracks, so starting it slightly late is safe.
-  transcriptionCapture = wantsAudio
+  transcriptionCapture = wantsRecordedAudio
     ? await startTranscriptionCapture(
         {
           deviceId: params.micId,
@@ -3204,12 +3175,12 @@ async function startRecordingInner(
     );
     void transcriptionCapture.pause().catch(() => {});
   } else if (
-    wantsAudio &&
+    wantsRecordedAudio &&
     !transcriptionCapture &&
     shouldSaveLocalTranscriptionStartupFailure()
   ) {
     void saveTranscriptFailure(
-      "macOS Speech recognition could not start for this recording. Check Speech Recognition and Microphone permissions, then retry transcription.",
+      "macOS Speech recognition could not start for this recording. Check Speech Recognition, System Audio, and Microphone permissions, then retry transcription.",
     );
   }
 
@@ -3289,9 +3260,9 @@ async function startRecordingInner(
           capturedTranscript,
           params.authToken,
         );
-      } else if (wantsAudio) {
+      } else if (wantsRecordedAudio) {
         await saveTranscriptFailure(
-          "No speech was captured during this recording. If you spoke, check Microphone input, Speech Recognition permission, and the selected mic, then retry transcription.",
+          "No speech was captured during this recording. If you spoke or played system audio, check System Audio, Microphone input, Speech Recognition permission, and the selected mic, then retry transcription.",
         );
       }
       await thumbnailUploadPromise;

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

@@ -158,6 +158,10 @@ struct RestartInfo {
     safe_id: String,
     include_audio: bool,
     capture_system_audio: bool,
+    /// True only when the final media file itself contains microphone audio.
+    /// ScreenCaptureKit microphone muxing is intentionally disabled on macOS
+    /// 15 because SCRecordingOutput can hang finalization and leave no moov.
+    mic_captured_in_file: bool,
     mic_device_id: Option<String>,
     mic_device_label: Option<String>,
     /// Monotonic counter feeding the per-segment filename suffix.
@@ -523,41 +527,66 @@ fn start_native_session_locked(
         || mic_device_label
             .as_deref()
             .is_some_and(|v| !v.trim().is_empty());
-    let session = match start_screencapturekit_recording(
-        app,
-        &safe_id,
-        include_audio,
-        capture_system_audio,
-        mic_device_id.as_deref(),
-        mic_device_label.as_deref(),
-        capture_region,
-        defer_recording_output,
-    ) {
-        Ok(session) => session,
-        Err(sck_err) => {
-            if defer_recording_output {
-                return Err(sck_err);
-            }
-            if include_audio && has_specific_mic {
-                return Err(format!(
-                    "ScreenCaptureKit recording failed before it could use the selected microphone ({sck_err}). Clips did not fall back to macOS screencapture because that would ignore your selected input."
-                ));
-            }
+    let session = if include_audio && !capture_system_audio {
+        if defer_recording_output {
+            return Err(
+                "Skipping microphone-only ScreenCaptureKit warmup; begin will use screencapture."
+                    .to_string(),
+            );
+        }
+        if has_specific_mic {
             eprintln!(
-                "[clips-tray] ScreenCaptureKit recording unavailable; falling back to screencapture: {sck_err}"
+                "[clips-tray] using screencapture for microphone-only recording; selected mic cannot be pinned by this backend"
             );
-            start_screencapture_recording(
-                app,
-                &safe_id,
-                include_audio,
-                capture_system_audio,
-                capture_region,
-            )
-            .map_err(|fallback_err| {
-                format!(
-                    "ScreenCaptureKit recording failed ({sck_err}); screencapture fallback failed ({fallback_err})"
+        } else {
+            eprintln!(
+                "[clips-tray] using screencapture for microphone-only recording to avoid ScreenCaptureKit microphone finalization failures"
+            );
+        }
+        start_screencapture_recording(
+            app,
+            &safe_id,
+            include_audio,
+            capture_system_audio,
+            capture_region,
+        )?
+    } else {
+        match start_screencapturekit_recording(
+            app,
+            &safe_id,
+            include_audio,
+            capture_system_audio,
+            mic_device_id.as_deref(),
+            mic_device_label.as_deref(),
+            capture_region,
+            defer_recording_output,
+        ) {
+            Ok(session) => session,
+            Err(sck_err) => {
+                if defer_recording_output {
+                    return Err(sck_err);
+                }
+                if include_audio && !capture_system_audio && has_specific_mic {
+                    return Err(format!(
+                        "ScreenCaptureKit recording failed before it could use the selected microphone ({sck_err}). Clips did not fall back to macOS screencapture because that would ignore your selected input."
+                    ));
+                }
+                eprintln!(
+                    "[clips-tray] ScreenCaptureKit recording unavailable; falling back to screencapture: {sck_err}"
+                );
+                start_screencapture_recording(
+                    app,
+                    &safe_id,
+                    include_audio,
+                    capture_system_audio,
+                    capture_region,
                 )
-            })?
+                .map_err(|fallback_err| {
+                    format!(
+                        "ScreenCaptureKit recording failed ({sck_err}); screencapture fallback failed ({fallback_err})"
+                    )
+                })?
+            }
         }
     };
     let width = session.width;
@@ -1485,7 +1514,13 @@ pub(crate) fn start_screencapturekit_backend_at(
     } else {
         filter_builder.build()
     };
-    let selected_mic = if include_audio {
+    let capture_microphone_in_recording = false;
+    if include_audio {
+        eprintln!(
+            "[clips-tray] ScreenCaptureKit microphone recording disabled; microphone audio stays out of SCRecordingOutput to avoid macOS 15 finalize timeouts"
+        );
+    }
+    let selected_mic = if capture_microphone_in_recording {
         resolve_microphone_capture_device(mic_device_id, mic_device_label)?
     } else {
         None
@@ -1498,9 +1533,10 @@ pub(crate) fn start_screencapturekit_backend_at(
         .with_queue_depth(8)
         .with_shows_cursor(true)
         // Mic and system audio are independent toggles. SCK delivers them as
-        // separate inputs; SCRecordingOutput muxes them into the file.
+        // separate inputs. We intentionally do not hand microphone buffers to
+        // SCRecordingOutput because macOS 15 can fail to finalize those MP4s.
         .with_captures_audio(capture_system_audio)
-        .with_captures_microphone(include_audio)
+        .with_captures_microphone(capture_microphone_in_recording)
         .with_excludes_current_process_audio(true)
         .with_sample_rate(48000)
         .with_channel_count(2);
@@ -1533,7 +1569,7 @@ pub(crate) fn start_screencapturekit_backend_at(
     let mut stream = SCStream::new(&filter, &config);
     // Observe the microphone stream so `begin` can wait for the first sample
     // before attaching the recording output (avoids the silent-mic head).
-    let mic_ready = if include_audio {
+    let mic_ready = if capture_microphone_in_recording {
         let flag = Arc::new(AtomicBool::new(false));
         let flag_cb = Arc::clone(&flag);
         stream.add_output_handler(
@@ -1559,7 +1595,7 @@ pub(crate) fn start_screencapturekit_backend_at(
         return Err(format!("capture start failed: {err:?}"));
     }
     eprintln!(
-        "[clips-tray] ScreenCaptureKit recording started: {width}x{height} @ {NATIVE_CAPTURE_FPS}fps from {capture_width}x{capture_height} (display {source_width}x{source_height}), mic={include_audio} system_audio={capture_system_audio} deferred_output={defer_recording_output}"
+        "[clips-tray] ScreenCaptureKit recording started: {width}x{height} @ {NATIVE_CAPTURE_FPS}fps from {capture_width}x{capture_height} (display {source_width}x{source_height}), mic_requested={include_audio} mic_recorded={capture_microphone_in_recording} system_audio={capture_system_audio} deferred_output={defer_recording_output}"
     );
     Ok((
         NativeFullscreenBackend::ScreenCaptureKit {
@@ -2180,7 +2216,7 @@ fn saved_recording_from_session(
         height: session.height,
         bytes,
         has_audio,
-        mic_captured: session.restart.include_audio,
+        mic_captured: session.restart.mic_captured_in_file,
         has_camera,
         saved_at: now_iso(),
         last_attempt_at: None,
@@ -2355,6 +2391,7 @@ fn start_screencapturekit_recording(
             safe_id: safe_id.to_string(),
             include_audio,
             capture_system_audio,
+            mic_captured_in_file: false,
             mic_device_id: mic_device_id.map(str::to_string),
             mic_device_label: mic_device_label.map(str::to_string),
             segment_counter: 0,
@@ -2416,6 +2453,7 @@ fn start_screencapture_recording(
             // screencapture (fallback) can't capture system audio; tracked
             // for parity but only `-g` mic is honored by that backend.
             capture_system_audio,
+            mic_captured_in_file: include_audio,
             mic_device_id: None,
             mic_device_label: None,
             segment_counter: 0,
@@ -2717,7 +2755,7 @@ async fn upload_recording_file(
         session.height,
         Some(duration_ms),
         has_audio,
-        session.restart.include_audio,
+        session.restart.mic_captured_in_file,
     )?;
     let upload_result = upload_prepared_recording_file(
         app,