@agent-native/core 0.92.11 → 0.93.0

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

@@ -55,6 +55,7 @@ import {
   isMediaConstraintFailure,
 } from "./lib/media-capture-constraints";
 import {
+  DESKTOP_CAPTURE_PERMISSION_MESSAGE,
   isHardCapturePermissionError,
   MACOS_CAPTURE_PERMISSION_MESSAGE,
   MACOS_SCREEN_PERMISSION_MESSAGE,
@@ -1667,7 +1668,11 @@ export function App() {
           msg.includes("sandbox") ||
           err?.name === "NotAllowedError"
         ) {
-          setCameraError(MACOS_CAPTURE_PERMISSION_MESSAGE);
+          setCameraError(
+            isMacPlatform()
+              ? MACOS_CAPTURE_PERMISSION_MESSAGE
+              : DESKTOP_CAPTURE_PERMISSION_MESSAGE,
+          );
         } else if (isMediaConstraintFailure(err)) {
           // Even the default-camera retry inside getCameraStreamWithFallback
           // failed, so no camera is usable right now. Say that plainly
@@ -2237,7 +2242,9 @@ export function App() {
       setRecError(
         isUpdatePendingRestart()
           ? MACOS_UPDATE_RESTART_MESSAGE
-          : MACOS_CAPTURE_PERMISSION_MESSAGE,
+          : isMacPlatform()
+            ? MACOS_CAPTURE_PERMISSION_MESSAGE
+            : DESKTOP_CAPTURE_PERMISSION_MESSAGE,
       );
       return;
     }
@@ -2354,10 +2361,11 @@ export function App() {
     };
     track(
       listen("clips:recorder-stop", async () => {
-        // Detach the React Start/bubble gate immediately. Native stop already
-        // released the camera and cleared Rust `is_recording_active` mid-
-        // finalize; keeping `recorder` set through the whole upload made
-        // reopen show a blank preview and made Start a silent no-op.
+        // Detach the React Start/bubble gate immediately. The recorder keeps
+        // Rust `is_recording_active` and the finalizing overlay guarded until
+        // its durable backup/finalize boundary; keeping this React handle set
+        // through the whole upload made reopen show a blank preview and made
+        // Start a silent no-op.
         const handle = recorder;
         recordingStopFinalizingRef.current = true;
         bubbleStreamTransferredToRecorder.current = false;
@@ -2723,7 +2731,8 @@ export function App() {
         recError === MACOS_UPDATE_RESTART_MESSAGE ? (
           <UpdateRestartBanner message={recError} />
         ) : recError === MACOS_CAPTURE_PERMISSION_MESSAGE ||
-          recError === MACOS_SCREEN_PERMISSION_MESSAGE ? (
+          recError === MACOS_SCREEN_PERMISSION_MESSAGE ||
+          recError === DESKTOP_CAPTURE_PERMISSION_MESSAGE ? (
           <PermissionRecoveryBanner
             kind="recording"
             message={recError}
@@ -2748,7 +2757,8 @@ export function App() {
         )
       ) : null}
       {cameraError && !recError ? (
-        cameraError === MACOS_CAPTURE_PERMISSION_MESSAGE ? (
+        cameraError === MACOS_CAPTURE_PERMISSION_MESSAGE ||
+        cameraError === DESKTOP_CAPTURE_PERMISSION_MESSAGE ? (
           <PermissionRecoveryBanner
             kind="camera"
             message={cameraError}
@@ -2839,6 +2849,7 @@ function PermissionRecoveryBanner({
         ? "Camera setup blocked"
         : "Recording setup blocked";
   const uniquePanes = Array.from(new Set(panes));
+  const canOpenPrivacySettings = isMacPlatform() || isWindowsPlatform();
 
   return (
     <div className="error-banner permission-banner">
@@ -2846,16 +2857,18 @@ function PermissionRecoveryBanner({
         <div className="permission-title">{title}</div>
         <div>{message}</div>
       </div>
-      <div className="permission-actions" aria-label="Open privacy settings">
-        {uniquePanes.map((pane) => (
-          <button
-            type="button"
-            key={pane}
-            onClick={() => openPrivacySettings(pane)}
-          >
-            {permissionPaneLabel(pane)}
-          </button>
-        ))}
+      <div className="permission-actions" aria-label="Permission recovery">
+        {canOpenPrivacySettings
+          ? uniquePanes.map((pane) => (
+              <button
+                type="button"
+                key={pane}
+                onClick={() => openPrivacySettings(pane)}
+              >
+                {permissionPaneLabel(pane)}
+              </button>
+            ))
+          : null}
         <button type="button" className="permission-retry" onClick={onRetry}>
           Try again
         </button>
@@ -3718,7 +3731,7 @@ function formatStorageBytes(bytes: number): string {
 function desktopUpdateStatusText(status: UpdateStatus): string {
   switch (status.state) {
     case "idle":
-      return "Clips checks automatically after launch and every 4 hours.";
+      return "Clips checks automatically after launch, every hour, and when you return.";
     case "checking":
       return "Checking for updates...";
     case "not-available":

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

@@ -8,7 +8,7 @@ import {
 import { invoke } from "@tauri-apps/api/core";
 import { useState, useCallback, useEffect } from "react";
 
-import { isMacPlatform } from "../lib/platform";
+import { isMacPlatform, isWindowsPlatform } from "../lib/platform";
 
 type CaptureMode = "screen" | "screen-camera" | "camera";
 type MacosPrivacyPane =
@@ -56,7 +56,6 @@ function readinessItems({
       detail: "Needed for screen or window capture.",
       pane: "screen",
       active: mode !== "camera",
-      macosOnly: true,
     },
     {
       label: "Microphone",
@@ -132,6 +131,7 @@ export function ReadinessPanel({
   onOpenPermission: (pane: MacosPrivacyPane) => void;
 }) {
   const mac = isMacPlatform();
+  const canOpenPrivacySettings = mac || isWindowsPlatform();
   const items = readinessItems({
     mode,
     cameraOn,
@@ -215,13 +215,19 @@ export function ReadinessPanel({
                         )}
                       </span>
                     ) : null}
-                    <button
-                      type="button"
-                      className="readiness-open-button"
-                      onClick={() => onOpenPermission(item.pane)}
-                    >
-                      Open
-                    </button>
+                    {canOpenPrivacySettings ? (
+                      <button
+                        type="button"
+                        className="readiness-open-button"
+                        onClick={() => onOpenPermission(item.pane)}
+                      >
+                        Open
+                      </button>
+                    ) : (
+                      <span className="readiness-item-detail">
+                        System prompt
+                      </span>
+                    )}
                   </div>
                 </div>
               );

package/corpus/templates/clips/desktop/src/lib/finalization-guard.ts

@@ -0,0 +1,22 @@
+interface FinalizationGuardOptions<T> {
+  ensureBackupDurable: () => Promise<void>;
+  attemptFinalize: () => Promise<T>;
+  releaseGuard: () => Promise<void> | void;
+}
+
+/**
+ * Keep the desktop's post-stop guard visible until recovery metadata is
+ * durable and the finalize request has settled at least once.
+ */
+export async function finalizeAfterDurableBackup<T>({
+  ensureBackupDurable,
+  attemptFinalize,
+  releaseGuard,
+}: FinalizationGuardOptions<T>): Promise<T> {
+  try {
+    await ensureBackupDurable();
+    return await attemptFinalize();
+  } finally {
+    await releaseGuard();
+  }
+}

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

@@ -1,4 +1,4 @@
-// macOS capture/permission messaging shared between the device pickers and the
+// Capture/permission messaging shared between the device pickers and the
 // recording flow. Centralized so the "is this a hard system block?" heuristic
 // and the user-facing copy stay in sync wherever a getUserMedia call can fail.
 
@@ -6,6 +6,8 @@ export const MACOS_CAPTURE_PERMISSION_MESSAGE =
   "Grant the required macOS permissions below, then try again. If you just changed access, restart Clips before retrying.";
 export const MACOS_SCREEN_PERMISSION_MESSAGE =
   "Grant Screen Recording permission in macOS Settings, then restart Clips and try again.";
+export const DESKTOP_CAPTURE_PERMISSION_MESSAGE =
+  "Allow the requested screen, camera, or microphone access in your desktop permission prompt, then try again.";
 export const MACOS_SPEECH_PERMISSION_MESSAGE =
   "Grant Speech Recognition and Microphone access, then try again. If you just changed access, restart Clips before retrying.";
 export const MACOS_UPDATE_RESTART_MESSAGE =

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

@@ -55,6 +55,7 @@ import { waitForReadyRecordingAfterFinalizeError } from "../../../shared/finaliz
 import type { LocalRecordingMode } from "../shared/config";
 import { createAudioCue, type AudioCue } from "./audio-cue";
 import { createCameraCompositeStream } from "./camera-composite";
+import { finalizeAfterDurableBackup } from "./finalization-guard";
 import {
   createLocalRecordingFolderName,
   exportBlobChunksToLocalRecordingFile,
@@ -1661,6 +1662,15 @@ function showFinalizingFeedback() {
   );
 }
 
+async function releaseFinalizingFeedback() {
+  await invoke("set_recording_state", { active: false }).catch((err) =>
+    console.error("[clips-recorder] clear recording state failed:", err),
+  );
+  await invoke("hide_finalizing").catch((err) =>
+    console.error("[clips-recorder] hide_finalizing failed:", err),
+  );
+}
+
 async function claimNativeUploadOpen(recordingId: string): Promise<boolean> {
   return invoke<boolean>("native_fullscreen_claim_upload_open", {
     recordingId,
@@ -2203,15 +2213,19 @@ async function startNativeFullscreenRecording(
           },
         );
         uploadPromise.catch(() => {});
+        // The recording row already exists, so open its page as soon as the
+        // native stop command has started. Upload/finalize continues in this
+        // webview while the page polls from `uploading` to `ready`.
+        await openNativeUploadUrl(
+          id,
+          `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
+        );
         try {
           await Promise.race([
             recorderFinalized,
             new Promise<void>((resolve) => window.setTimeout(resolve, 15000)),
           ]);
           unlistenFinalized();
-          await invoke("set_recording_state", { active: false }).catch(
-            () => {},
-          );
 
           const capturedTranscript = await transcriptionCapture
             ?.stop()
@@ -2263,10 +2277,6 @@ async function startNativeFullscreenRecording(
                 authToken: params.authToken,
               })
             ) {
-              await openNativeUploadUrl(
-                id,
-                `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
-              );
               return { recordingId: id, viewUrl };
             }
             await abortRecordingUpload(
@@ -2274,36 +2284,16 @@ async function startNativeFullscreenRecording(
               id,
               err instanceof Error ? err.message : String(err),
             );
-            // Still take the user to the clip status page. If the server
-            // marked the upload failed, that page shows the failure state; if
-            // the abort request could not land, it keeps polling instead of
-            // leaving the user on an empty desktop.
-            try {
-              await openExternal(
-                `${params.serverUrl.replace(
-                  /\/+$/,
-                  "",
-                )}${viewUrl}?saveFailed=1`,
-              );
-            } catch (openErr) {
-              console.error("[clips-recorder] openExternal failed:", openErr);
-            }
             throw err;
           }
 
-          await openNativeUploadUrl(
-            uploadResult.recordingId,
-            `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
-          );
           return {
             recordingId: uploadResult.recordingId,
             viewUrl,
           };
         } finally {
           streamCleanups.forEach((cleanup) => cleanup());
-          invoke("hide_finalizing").catch((err) =>
-            console.error("[clips-recorder] hide_finalizing failed:", err),
-          );
+          await releaseFinalizingFeedback();
         }
       })();
       return stopPromise;
@@ -3223,15 +3213,6 @@ async function startRecordingInner(
     }).catch(() => {});
   }
 
-  async function openFailedRecordingPage() {
-    const viewUrl = `/r/${id}?saveFailed=1`;
-    try {
-      await openExternal(`${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`);
-    } catch (err) {
-      console.error("[clips-recorder] openExternal failed:", err);
-    }
-  }
-
   // 5. Wire toolbar events.
   const toolbarUnlistens = await Promise.all([
     listen("clips:recorder-pause", () => {
@@ -3346,6 +3327,7 @@ async function startRecordingInner(
       // chunk — but NOT the transcript-finalize + thumbnail + upload awaits that
       // follow, which add ~seconds and would overstate the saved duration.
       let stoppedAt = 0;
+      const viewUrl = `/r/${id}`;
       console.log("[clips-recorder] stop requested");
       showFinalizingFeedback();
       if (tickHandle) clearInterval(tickHandle);
@@ -3354,12 +3336,20 @@ async function startRecordingInner(
 
       // Flush the in-flight recorder buffer, then wait for it to fully stop
       // so we get the trailing dataavailable event.
-      await new Promise<void>((resolve) => {
+      const recorderStopped = new Promise<void>((resolve) => {
         if (recorder.state === "inactive") {
+          stoppedAt = Date.now();
           resolve();
           return;
         }
-        recorder.addEventListener("stop", () => resolve(), { once: true });
+        recorder.addEventListener(
+          "stop",
+          () => {
+            stoppedAt = Date.now();
+            resolve();
+          },
+          { once: true },
+        );
         try {
           if (recorder.state === "paused") {
             recorder.resume();
@@ -3380,10 +3370,18 @@ async function startRecordingInner(
           // ignore
         }
       });
+      // `recorder.stop()` has already been requested, so recorded duration is
+      // fixed even if launching the browser takes a moment. Open the existing
+      // recording row now and let its page poll while upload/finalize continues.
+      try {
+        await openExternal(`${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`);
+      } catch (err) {
+        console.error("[clips-recorder] openExternal failed:", err);
+      }
+      await recorderStopped;
       // Recorder has fully stopped and flushed its trailing chunk — this is the
       // true end of recorded content. Everything after (transcript, thumbnail,
       // upload) is post-processing and must not count toward duration.
-      stoppedAt = Date.now();
 
       const thumbnailUploadPromise = captureAndUploadRecordingThumbnail({
         serverUrl: params.serverUrl,
@@ -3497,7 +3495,6 @@ async function startRecordingInner(
       await invoke("hide_recording_chrome").catch((err) =>
         console.error(`[clips-recorder] hide_recording_chrome failed:`, err),
       );
-      await invoke("set_recording_state", { active: false }).catch(() => {});
 
       // Wait for any in-flight chunk uploads to settle before sending the
       // final chunk. Otherwise the server could finalize before the last
@@ -3511,19 +3508,19 @@ async function startRecordingInner(
         await Promise.allSettled(pending);
       }
       inflight.clear();
-      // Ensure the local backup is fully written before we either delete it
-      // (on success) or leave it in place for recovery (on failure).
-      await Promise.allSettled([...backupWrites]);
       if (failed) {
-        console.error("[clips-recorder] chunk upload failed:", failed);
-        await markBrowserRecordingBackupError(id, failed.message).catch(
-          () => {},
-        );
-        await abortRecordingUpload(params.serverUrl, id, failed.message);
-        invoke("hide_finalizing").catch((err) =>
-          console.error("[clips-recorder] hide_finalizing failed:", err),
-        );
-        await openFailedRecordingPage();
+        try {
+          // Keep the guard until the final metadata and every trailing chunk
+          // backup are durable, even though this upload cannot be finalized.
+          await Promise.allSettled([...backupWrites]);
+          console.error("[clips-recorder] chunk upload failed:", failed);
+          await markBrowserRecordingBackupError(id, failed.message).catch(
+            () => {},
+          );
+          await abortRecordingUpload(params.serverUrl, id, failed.message);
+        } finally {
+          await releaseFinalizingFeedback();
+        }
         throw failed;
       }
 
@@ -3553,78 +3550,58 @@ async function startRecordingInner(
         uploadMode,
         anyFailed: !!failed,
       });
-      try {
-        const finalRes = await fetch(finalizeUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/octet-stream" },
-          credentials: "include",
-          body: finalBody,
-          signal: AbortSignal.timeout(FINALIZE_UPLOAD_TIMEOUT_MS),
-        });
-        const bodyText = await finalRes.text().catch(() => "");
-        console.log(
-          "[clips-recorder] finalize response:",
-          finalRes.status,
-          bodyText.slice(0, 500),
-        );
-        if (!finalRes.ok) {
-          throw new Error(
-            `Finalize failed (${finalRes.status}): ${bodyText.slice(0, 200)}`,
-          );
-        }
-      } catch (err) {
-        console.error("[clips-recorder] finalize fetch failed:", err);
-        const error = err instanceof Error ? err : new Error(String(err));
-        if (
-          await recoverReadyRecordingAfterFinalizeError({
-            serverUrl: params.serverUrl,
-            recordingId: id,
-            authToken: params.authToken,
-          })
-        ) {
-          const viewUrl = `/r/${id}`;
+      return finalizeAfterDurableBackup({
+        // Opening the browser must not make the desktop look idle until every
+        // trailing backup write and the final metadata are durable.
+        ensureBackupDurable: async () => {
+          await Promise.allSettled([...backupWrites]);
+        },
+        attemptFinalize: async () => {
           try {
-            await openExternal(
-              `${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`,
+            const finalRes = await fetch(finalizeUrl, {
+              method: "POST",
+              headers: { "Content-Type": "application/octet-stream" },
+              credentials: "include",
+              body: finalBody,
+              signal: AbortSignal.timeout(FINALIZE_UPLOAD_TIMEOUT_MS),
+            });
+            const bodyText = await finalRes.text().catch(() => "");
+            console.log(
+              "[clips-recorder] finalize response:",
+              finalRes.status,
+              bodyText.slice(0, 500),
+            );
+            if (!finalRes.ok) {
+              throw new Error(
+                `Finalize failed (${finalRes.status}): ${bodyText.slice(0, 200)}`,
+              );
+            }
+          } catch (err) {
+            console.error("[clips-recorder] finalize fetch failed:", err);
+            const error = err instanceof Error ? err : new Error(String(err));
+            if (
+              await recoverReadyRecordingAfterFinalizeError({
+                serverUrl: params.serverUrl,
+                recordingId: id,
+                authToken: params.authToken,
+              })
+            ) {
+              return { recordingId: id, viewUrl };
+            }
+            await markBrowserRecordingBackupError(id, error.message).catch(
+              () => {},
             );
-          } catch (openErr) {
-            console.error("[clips-recorder] openExternal failed:", openErr);
+            await abortRecordingUpload(params.serverUrl, id, error.message);
+            throw error;
           }
-          invoke("hide_finalizing").catch((hideErr) =>
-            console.error("[clips-recorder] hide_finalizing failed:", hideErr),
-          );
+          await deleteBrowserRecordingBackup(id).catch((err) => {
+            console.warn("[clips-recorder] local backup cleanup failed:", err);
+          });
+
           return { recordingId: id, viewUrl };
-        }
-        await markBrowserRecordingBackupError(id, error.message).catch(
-          () => {},
-        );
-        await abortRecordingUpload(params.serverUrl, id, error.message);
-        invoke("hide_finalizing").catch((hideErr) =>
-          console.error("[clips-recorder] hide_finalizing failed:", hideErr),
-        );
-        await openFailedRecordingPage();
-        throw error;
-      }
-      await deleteBrowserRecordingBackup(id).catch((err) => {
-        console.warn("[clips-recorder] local backup cleanup failed:", err);
+        },
+        releaseGuard: releaseFinalizingFeedback,
       });
-
-      // Finalize done (or tried and failed — the player page shows a clear
-      // error state in either case). Open the browser to the playback URL
-      // and THEN close the finalizing spinner. Closing before the browser
-      // opens would leave the user staring at an empty desktop for the
-      // brief moment while the OS launches / focuses the default browser.
-      const viewUrl = `/r/${id}`;
-      try {
-        await openExternal(`${params.serverUrl.replace(/\/+$/, "")}${viewUrl}`);
-      } catch (err) {
-        console.error("[clips-recorder] openExternal failed:", err);
-      }
-      invoke("hide_finalizing").catch((err) =>
-        console.error("[clips-recorder] hide_finalizing failed:", err),
-      );
-
-      return { recordingId: id, viewUrl };
     },
 
     async cancel() {

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

@@ -27,6 +27,10 @@ let pendingUpdate: Update | null = null;
 const listeners = new Set<StatusListener>();
 let started = false;
 let checkInFlight: Promise<void> | null = null;
+let lastCheckStartedAt = 0;
+
+const UPDATE_CHECK_INTERVAL_MS = 60 * 60 * 1000;
+const UPDATE_FOCUS_CHECK_MIN_INTERVAL_MS = 15 * 60 * 1000;
 
 function canRunUpdateChecks() {
   // Dev and local release builds are for testing the current checkout. Do not
@@ -40,8 +44,10 @@ function setStatus(next: UpdateStatus) {
 }
 
 async function runCheck() {
+  if (cachedStatus.state === "downloaded") return;
   if (checkInFlight) return checkInFlight;
 
+  lastCheckStartedAt = Date.now();
   checkInFlight = (async () => {
     try {
       setStatus({ state: "checking" });
@@ -90,14 +96,30 @@ async function runCheck() {
   return checkInFlight;
 }
 
+function maybeCheckForUpdate() {
+  if (!canRunUpdateChecks()) return;
+  if (cachedStatus.state === "downloaded") return;
+  if (
+    checkInFlight ||
+    Date.now() - lastCheckStartedAt < UPDATE_FOCUS_CHECK_MIN_INTERVAL_MS
+  ) {
+    return;
+  }
+  void runCheck();
+}
+
 function startUpdateLoop() {
   if (started) return;
   started = true;
   if (!canRunUpdateChecks()) return;
-  // Check 3s after launch (let the popover finish first paint), then every
-  // 4 hours. Matches the cadence used by the Electron app.
-  setTimeout(runCheck, 3000);
-  setInterval(runCheck, 4 * 60 * 60 * 1000);
+  // Check 3s after launch (let the popover finish first paint), hourly while
+  // Clips stays open, and when the user returns after at least 15 minutes.
+  setTimeout(() => void runCheck(), 3000);
+  setInterval(() => void runCheck(), UPDATE_CHECK_INTERVAL_MS);
+  window.addEventListener("focus", maybeCheckForUpdate);
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "visible") maybeCheckForUpdate();
+  });
 }
 
 export function useUpdateStatus(): UpdateStatus {

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

@@ -25,17 +25,13 @@ type NativeUploadFinished = {
 
 /**
  * Full-screen transparent feedback overlay. Rendered the moment the user
- * clicks Stop on the recording toolbar and kept visible until the browser
- * opens at `/r/:id`. This fills the gap between `hide_recording_chrome`
- * tearing down the toolbar + bubble and `openExternal` actually opening
- * the browser — a gap that can stretch for several seconds while
- * MediaRecorder flushes trailing chunks and the server finalize POST
- * completes.
+ * clicks Stop on the recording toolbar and kept visible while the desktop
+ * finishes its durable backup and first upload/finalize attempt. The browser
+ * can open `/r/:id` earlier so the page shows live progress.
  *
  * The window ignores cursor events on the Rust side, so the compact
  * bottom-left card does not block the user's screen while compression or
- * upload continues. The recorder.ts stop path invokes `hide_finalizing`
- * right after `openExternal` to close this window.
+ * upload runs.
  */
 export function Finalizing() {
   const [progress, setProgress] = useState<ProcessingProgress>({

package/corpus/templates/clips/desktop/src-tauri/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "clips-tray"
 version = "0.1.1"
-description = "Clips — menu-bar tray app (Tauri 2)"
+description = "Clips — cross-platform tray app (Tauri 2)"
 authors = ["Clips"]
 license = "MIT"
 edition = "2021"

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

@@ -498,8 +498,8 @@ pub async fn show_finalizing(app: AppHandle) -> Result<(), String> {
     Ok(())
 }
 
-/// Close the finalizing spinner overlay. Called from the recorder stop path
-/// right after `openExternal` opens the browser to the recording URL.
+/// Close the finalizing spinner overlay after the recorder's durable
+/// backup/upload boundary settles.
 #[tauri::command]
 pub async fn hide_finalizing(app: AppHandle) -> Result<(), String> {
     if let Some(w) = app.get_webview_window(FINALIZING_LABEL) {

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

@@ -19,14 +19,18 @@ pub fn check_permission_statuses() -> PermissionStatuses {
     }
     #[cfg(not(target_os = "macos"))]
     {
-        // TODO: implement
+        // Windows and Linux permissions are granted through the WebView and,
+        // on Linux, the XDG desktop portal. There is no reliable synchronous
+        // preflight equivalent to macOS TCC here, so report unavailable rather
+        // than claiming permissions were granted. The non-macOS UI relies on
+        // the actual media prompt and does not render these values.
         PermissionStatuses {
-            screen: true,
-            camera: true,
-            microphone: true,
-            speech: true,
-            accessibility: true,
-            input_monitoring: true,
+            screen: false,
+            camera: false,
+            microphone: false,
+            speech: false,
+            accessibility: false,
+            input_monitoring: false,
         }
     }
 }