@agent-native/core-corpus 0.210.2 → 0.211.0

package/corpus/templates/clips/changelog/2026-10-19-chapter-list-times-now-match-the-player-s-clock-and-each-cha.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-19
+---
+
+Chapter list times now match the player's clock, and each chapter shows a focus ring when you tab to it.

package/corpus/templates/clips/changelog/2026-10-19-editing-a-comment-puts-the-cursor-after-its-text-and-reply-o.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-19
+---
+
+Editing a comment puts the cursor after its text, and Reply on another notification moves the cursor to its reply box.

package/corpus/templates/clips/changelog/2026-10-19-youtube-import-followups.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-19
+---
+
+Video imports use clearer labels, YouTube links work without connected storage, and embedded players stay clear of timeline hover previews.

package/corpus/templates/clips/changelog/2026-10-20-locally-saved-desktop-recordings-now-appear-in-the-recovery-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-20
+---
+
+Locally saved desktop recordings now appear in the recovery list with upload and storage setup actions.

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

@@ -165,8 +165,7 @@ import {
   loadRecordFirstFiles,
   RecordFirstFileMissingError,
   recordFirstFilesKey,
-  recordFirstFilesToQueue,
-  recordFirstMediaFlags,
+  shouldPollVideoStorageStatus,
   stagedIdAfterFailure,
   transferRecordFirstFiles,
   type RecordFirstFile,
@@ -209,11 +208,13 @@ import {
   ScreenRecordingPermissionError,
 } from "./lib/recording-preflight";
 import {
+  mapRecordFirstFilesForRecovery,
   reconcileRecordingRecovery,
   recordingRecoveryKey,
   shouldShowRecordingRecoveryBanner,
   type PendingDesktopUpload,
   type PendingNativeUpload,
+  type RecordFirstFileUploadError,
   type RecoverySnapshot,
 } from "./lib/recording-recovery";
 import {
@@ -1391,7 +1392,7 @@ export function App({
   }, [videoStorageIdentity, serverUrl, signedInAs]);
 
   const refreshVideoStorageStatus = useCallback(async () => {
-    if (authStatus !== "authed" || localRecordingMode !== "off") {
+    if (authStatus !== "authed") {
       hostedClipLimitMsRef.current = null;
       setVideoStorageStatus("configured");
       return true;
@@ -1410,13 +1411,7 @@ export function App({
     hostedClipLimitMsRef.current = maxClipDurationMs;
     setVideoStorageStatus(probe);
     return probe === "configured";
-  }, [
-    authStatus,
-    localRecordingMode,
-    serverUrl,
-    signedInAs,
-    videoStorageIdentity,
-  ]);
+  }, [authStatus, serverUrl, signedInAs, videoStorageIdentity]);
 
   useEffect(() => {
     void refreshVideoStorageStatus();
@@ -1424,14 +1419,9 @@ export function App({
 
   useEffect(() => {
     if (
-      authStatus !== "authed" ||
-      localRecordingMode !== "off" ||
-      (videoStorageStatus !== "missing" &&
-        videoStorageStatus !== "checking" &&
-        videoStorageStatus !== "unavailable")
-    ) {
+      !shouldPollVideoStorageStatus(authStatus === "authed", videoStorageStatus)
+    )
       return;
-    }
 
     let inFlight = false;
     const tick = () => {
@@ -1450,12 +1440,7 @@ export function App({
       window.clearInterval(interval);
       document.removeEventListener("visibilitychange", onVisibilityChange);
     };
-  }, [
-    authStatus,
-    localRecordingMode,
-    refreshVideoStorageStatus,
-    videoStorageStatus,
-  ]);
+  }, [authStatus, refreshVideoStorageStatus, videoStorageStatus]);
 
   // Mirrors the web recorder: a hosted take stops itself at the clip cap
   // instead of failing the upload past the server's size limit. The cap the
@@ -3201,9 +3186,6 @@ export function App({
   const recorderStopListenerPromiseRef = useRef<Promise<() => void> | null>(
     null,
   );
-  const recordedWithoutStorageRef = useRef(false);
-  // The record-first list a capture belongs to, fixed when capture starts.
-  const recordFirstKeyAtStartRef = useRef<string | null>(null);
   const finishRecordingStopRef = useRef<
     (handle: RecorderHandle, recordingId?: string | null) => Promise<void>
   >(async () => {});
@@ -3597,7 +3579,7 @@ export function App({
   >([]);
   const [recordFirstError, setRecordFirstError] = useState<string | null>(null);
   const [recordFirstFileErrors, setRecordFirstFileErrors] = useState<
-    Record<string, { message: string; missing: boolean }>
+    Record<string, RecordFirstFileUploadError>
   >({});
   const [recordFirstUploading, setRecordFirstUploading] = useState(false);
   useEffect(() => {
@@ -3636,17 +3618,6 @@ export function App({
     },
     [recordFirstKey, unclaimedRecordFirstKey],
   );
-  const rememberRecordFirstFile = useCallback(
-    (file: RecordFirstFile, key: string) => {
-      // `key` is the account signed in when capture started, never whoever
-      // is signed in at Stop, so a switch mid-recording cannot reassign it.
-      changeQueuedFiles(key, (files) => [
-        ...files.filter((f) => f.path !== file.path),
-        file,
-      ]);
-    },
-    [changeQueuedFiles],
-  );
   const forgetRecordFirstFile = useCallback(
     (path: string) => {
       // Removes the list entry only; the file on disk is never touched.
@@ -3828,24 +3799,6 @@ export function App({
           folderPath: stopResult.localFolder,
           files: stopResult.localFiles ?? [],
         });
-        const queueKey = recordFirstKeyAtStartRef.current;
-        if (recordedWithoutStorageRef.current && queueKey) {
-          for (const file of recordFirstFilesToQueue(
-            stopResult.localFiles ?? [],
-          )) {
-            rememberRecordFirstFile(
-              {
-                ...file,
-                ...recordFirstMediaFlags(file.role, {
-                  hasAudio: micOn || systemAudioOn,
-                  hasCamera: mode !== "screen",
-                }),
-                savedAt: new Date().toISOString(),
-              },
-              queueKey,
-            );
-          }
-        }
         emit("clips:native-upload-finished", {
           recordingId: stopResult.recordingId,
           ok: true,
@@ -3867,7 +3820,7 @@ export function App({
             ok: false,
             error: err instanceof Error ? err.message : String(err),
           },
-          localRecordingMode !== "off" || recordedWithoutStorageRef.current,
+          localRecordingMode !== "off",
         );
         emit("clips:native-upload-finished", {
           recordingId: stoppingRecordingId ?? undefined,
@@ -4242,19 +4195,7 @@ export function App({
       bubbleStreamRef.current = null;
       setBubbleSessionEpoch((epoch) => epoch + 1);
     }
-    // Recording never waits on storage: until storage reads as connected the
-    // clip is written to Movies/Clips as it records, then uploads once
-    // storage connects.
-    const recordingLocalMode = effectiveLocalRecordingMode(
-      localRecordingMode,
-      videoStorageStatus,
-    );
-    const recordLocallyUntilStorage = recordingLocalMode !== localRecordingMode;
-    recordedWithoutStorageRef.current = recordLocallyUntilStorage;
-    recordFirstKeyAtStartRef.current = recordFirstFilesKey(
-      originForServer(serverUrl),
-      signedInAs,
-    );
+    const recordingLocalMode = effectiveLocalRecordingMode(localRecordingMode);
     setRecError(null);
     setLocalRecordingNotice(null);
     setShareLinkNotice(null);
@@ -4264,6 +4205,7 @@ export function App({
       mode,
       source,
       localRecordingMode,
+      videoStorageStatus,
       cameraOn,
       micOn,
     });
@@ -4875,8 +4817,16 @@ export function App({
         ? "Start recording"
         : "Start local recording";
 
+  const localRecoveryFiles = mapRecordFirstFilesForRecovery(
+    [...recordFirstFiles, ...unclaimedRecordFirstFiles],
+    recordFirstFileErrors,
+  );
   const recoveryProps: RecordingRecoveryProps = {
     uploads: pendingUploads,
+    localFiles: localRecoveryFiles,
+    localFilesError: recordFirstError,
+    localFilesUploading: recordFirstUploading,
+    localFilesStorageStatus: videoStorageStatus,
     lookupErrors: recoverySnapshot.errors,
     actionErrors: recoveryActionErrors,
     refreshing: recoveryRefreshing,
@@ -4897,6 +4847,11 @@ export function App({
     onRetry: retryPendingUpload,
     onCancelRetry: cancelPendingUploadRetry,
     onOpenFolder: openPendingUploadFolder,
+    onRetryLocalFiles: () =>
+      void uploadRecordFirstFilesRef.current({ includeUnclaimed: true }),
+    onRefreshStorage: () => void refreshVideoStorageStatus(),
+    onConnectLocalStorage: () => openVideoStorageSetup(serverUrl),
+    onForgetLocalFile: forgetRecordFirstFile,
     onReviewFiles: (key) => {
       void invoke("native_fullscreen_open_drafts_folder").catch((error) => {
         setRecoveryActionErrors((errors) => ({
@@ -4921,7 +4876,9 @@ export function App({
         delete next[key];
         return next;
       });
-      void openExternal(`${targetServerUrl}/record`).catch((error) => {
+      void openExternal(
+        `${targetServerUrl.replace(/\/+$/, "")}/record?connectStorage=1`,
+      ).catch((error) => {
         setRecoveryActionErrors((errors) => ({
           ...errors,
           [key]: error instanceof Error ? error.message : String(error),
@@ -4932,6 +4889,7 @@ export function App({
   const pendingUploadBanner = shouldShowRecordingRecoveryBanner(
     popoverView,
     authStatus === "authed",
+    localRecoveryFiles.length > 0 || !!recordFirstError,
   ) ? (
     <RecordingRecovery
       {...recoveryProps}
@@ -5492,31 +5450,6 @@ export function App({
           </button>
         ) : null}
 
-        {recordFirstFiles.length + unclaimedRecordFirstFiles.length > 0 ||
-        recordFirstError ? (
-          <RecordFirstUploadsBanner
-            count={recordFirstFiles.length + unclaimedRecordFirstFiles.length}
-            storageStatus={videoStorageStatus}
-            signedIn={!!signedInAs}
-            uploading={recordFirstUploading}
-            error={recordFirstError}
-            failedFiles={[
-              ...recordFirstFiles,
-              ...unclaimedRecordFirstFiles,
-            ].flatMap((file) =>
-              recordFirstFileErrors[file.path]
-                ? [{ file, ...recordFirstFileErrors[file.path]! }]
-                : [],
-            )}
-            onUpload={() =>
-              void uploadRecordFirstFilesRef.current({
-                includeUnclaimed: true,
-              })
-            }
-            onCheckStorage={() => void refreshVideoStorageStatus()}
-            onForget={forgetRecordFirstFile}
-          />
-        ) : null}
         {recError ? (
           recError === MACOS_UPDATE_RESTART_MESSAGE ? (
             <UpdateRestartBanner message={recError} />
@@ -5719,96 +5652,6 @@ function UpdateRestartBanner({ message }: { message: string }) {
 const RECORD_FIRST_LIST_UNREADABLE =
   "Clips couldn't read its list of recordings waiting to upload. They are still in Movies/Clips.";
 
-function RecordFirstUploadsBanner({
-  count,
-  storageStatus,
-  signedIn,
-  uploading,
-  error,
-  failedFiles,
-  onUpload,
-  onCheckStorage,
-  onForget,
-}: {
-  count: number;
-  storageStatus: VideoStorageStatus;
-  signedIn: boolean;
-  uploading: boolean;
-  error: string | null;
-  failedFiles: Array<{
-    file: RecordFirstFile;
-    message: string;
-    missing: boolean;
-  }>;
-  onUpload: () => void;
-  onCheckStorage: () => void;
-  onForget: (path: string) => void;
-}) {
-  const recordings = count === 1 ? "1 recording" : `${count} recordings`;
-  const storageCopy =
-    storageStatus === "configured"
-      ? "Saved in Movies/Clips. Upload them to get share links."
-      : storageStatus === "missing"
-        ? "Saved in Movies/Clips. Connect storage and they upload."
-        : storageStatus === "unavailable"
-          ? "Storage authorization could not be checked. Retry to check again; recordings remain in Movies/Clips."
-          : "Checking whether storage can upload clips.";
-  const checkingStorage =
-    storageStatus === "checking" || storageStatus === "unavailable";
-  return (
-    <>
-      <div className="storage-flow-banner" role="status">
-        <div className="storage-flow-icon" aria-hidden>
-          <IconUpload size={17} stroke={1.8} />
-        </div>
-        <div className="storage-flow-copy">
-          <div className="storage-flow-title">
-            {uploading
-              ? `Uploading ${recordings}…`
-              : `${recordings} saved on this Mac, not uploaded`}
-          </div>
-          <div className="storage-flow-sub">
-            {error ? <div>{error}</div> : null}
-            <div>{storageCopy}</div>
-          </div>
-        </div>
-        {count > 0 ? (
-          <button
-            type="button"
-            className="storage-flow-connect"
-            disabled={uploading || !signedIn}
-            title={signedIn ? undefined : "Sign in to upload"}
-            onClick={checkingStorage ? onCheckStorage : onUpload}
-          >
-            <IconUpload size={14} stroke={2} />
-            {storageStatus === "configured"
-              ? "Upload now"
-              : storageStatus === "missing"
-                ? "Connect"
-                : storageStatus === "unavailable"
-                  ? "Retry"
-                  : "Check storage"}
-          </button>
-        ) : null}
-      </div>
-      {failedFiles.map(({ file, message, missing }) => (
-        <div key={file.path} className="error-banner" role="alert">
-          {file.fileName}: {message}
-          {missing ? (
-            <button
-              type="button"
-              className="storage-flow-connect"
-              onClick={() => onForget(file.path)}
-            >
-              Remove from list
-            </button>
-          ) : null}
-        </div>
-      ))}
-    </>
-  );
-}
-
 function StorageConnectionBanner({ onConnect }: { onConnect: () => void }) {
   return (
     <div className="storage-flow-banner">

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

@@ -3,11 +3,13 @@ import {
   IconChevronRight,
   IconDots,
   IconRefresh,
+  IconUpload,
   IconX,
 } from "@tabler/icons-react";
 import { useLayoutEffect, useRef, type RefObject, type ReactNode } from "react";
 
 import { desktopRecoveryCopy as copy } from "../i18n/en-US";
+import type { VideoStorageStatus } from "../lib/record-first";
 import {
   classifyRecordingRecoveryError,
   recordingRecoveryKey,
@@ -39,6 +41,16 @@ import { Spinner } from "./ui/spinner";
 
 export interface RecordingRecoveryState {
   uploads: PendingDesktopUpload[];
+  localFiles: Array<{
+    path: string;
+    fileName: string;
+    savedAt: string;
+    error?: string;
+    missing?: boolean;
+  }>;
+  localFilesError: string | null;
+  localFilesUploading: boolean;
+  localFilesStorageStatus: VideoStorageStatus;
   lookupErrors: RecoveryLookupError[];
   actionErrors: Record<string, string>;
   refreshing: boolean;
@@ -64,6 +76,10 @@ export interface RecordingRecoveryProps extends RecordingRecoveryState {
   onExport: (upload: PendingDesktopUpload) => void;
   onOpenFolder: (upload: PendingDesktopUpload) => void;
   onConnectStorage: (upload: PendingDesktopUpload) => void;
+  onRetryLocalFiles: () => void;
+  onRefreshStorage: () => void;
+  onConnectLocalStorage: () => void;
+  onForgetLocalFile: (path: string) => void;
   onReviewFiles: (key: string) => void;
   onOpenLogs: (key: string) => void;
 }
@@ -117,19 +133,28 @@ function recoveryPresentation(props: RecordingRecoveryState) {
         messages: [...(orphanErrors.get(id)?.messages || []), message],
       });
   }
-  const attentionCount = uploads.filter(
-    (upload) => uploadSeverity(upload, props) !== "neutral",
-  ).length;
+  const attentionCount =
+    uploads.filter((upload) => uploadSeverity(upload, props) !== "neutral")
+      .length + (props.localFilesUploading ? 0 : props.localFiles.length);
   const unknownFailures =
-    props.lookupErrors.length > 0 || orphanErrors.size > 0;
+    props.lookupErrors.length > 0 ||
+    orphanErrors.size > 0 ||
+    !!props.localFilesError;
+  const localFileSeverities = props.localFiles.map((file) =>
+    props.localFilesUploading ? "neutral" : file.missing ? "error" : "warning",
+  );
   const severities = [
     ...uploads.map((upload) => uploadSeverity(upload, props)),
+    ...localFileSeverities,
     ...[...orphanErrors.values()].map((error) =>
       recordingRecoverySeverity(error.messages),
     ),
     ...(props.lookupErrors.length
       ? [recordingRecoverySeverity([lookupDiagnostic(props.lookupErrors)])]
       : []),
+    ...(props.localFilesError
+      ? [recordingRecoverySeverity([props.localFilesError])]
+      : []),
   ];
   const severity = severities.includes("error")
     ? "error"
@@ -138,6 +163,7 @@ function recoveryPresentation(props: RecordingRecoveryState) {
       : "neutral";
   return {
     uploads,
+    localFiles: props.localFiles,
     orphanErrors: [...orphanErrors.values()],
     attentionCount,
     unknownFailures,
@@ -151,21 +177,29 @@ export function RecordingRecovery(
     triggerRef?: RefObject<HTMLButtonElement | null>;
   },
 ) {
-  const { uploads, attentionCount, unknownFailures, severity } =
+  const { uploads, localFiles, attentionCount, unknownFailures, severity } =
     recoveryPresentation(props);
   const showFinalizing = props.finalizing && props.showFinalizing !== false;
-  if (uploads.length === 0 && !unknownFailures && !showFinalizing) return null;
+  if (
+    uploads.length === 0 &&
+    localFiles.length === 0 &&
+    !unknownFailures &&
+    !showFinalizing
+  )
+    return null;
   const label = unknownFailures
     ? copy.recordingsNeedAttention
-    : attentionCount === 1
-      ? copy.attentionOne
-      : attentionCount > 1
-        ? copy.attentionMany.replace("{count}", String(attentionCount))
-        : showFinalizing
-          ? copy.finishing
-          : props.exportingUploadId
-            ? copy.exporting
-            : copy.retrying;
+    : props.localFilesUploading
+      ? copy.retrying
+      : attentionCount === 1
+        ? copy.attentionOne
+        : attentionCount > 1
+          ? copy.attentionMany.replace("{count}", String(attentionCount))
+          : showFinalizing
+            ? copy.finishing
+            : props.exportingUploadId
+              ? copy.exporting
+              : copy.retrying;
   return (
     <div data-tw-surface className="recording-recovery-entry">
       <Button
@@ -293,7 +327,7 @@ export function RecordingRecoveryPage(
   useLayoutEffect(() => {
     backRef.current?.focus();
   }, []);
-  const { uploads, orphanErrors } = recoveryPresentation(props);
+  const { uploads, localFiles, orphanErrors } = recoveryPresentation(props);
   const busy = !!props.retryingUploadId || !!props.exportingUploadId;
   return (
     <section
@@ -344,6 +378,125 @@ export function RecordingRecoveryPage(
             </ItemActions>
           </Item>
         ) : null}
+        {props.localFilesError ? (
+          <Item size="recovery" role="listitem">
+            <ItemMedia data-recovery-tone="warning">
+              <IconAlertTriangle size={20} stroke={1.75} aria-hidden />
+            </ItemMedia>
+            <ItemContent>
+              <ItemTitle>{copy.localFiles}</ItemTitle>
+              <RecoveryDescription
+                text={copy.lookupFailed}
+                diagnostic={props.localFilesError}
+              />
+            </ItemContent>
+            <ItemActions>
+              <RecoveryMore
+                onOpenLogs={() => props.onOpenLogs("record-first-list")}
+              />
+            </ItemActions>
+          </Item>
+        ) : null}
+        {localFiles.map((file) => {
+          const failureKind = file.error
+            ? classifyRecordingRecoveryError(file.error, {
+                storageRequired: props.needsStorage(file.error),
+                incomplete: file.missing,
+                actionError: true,
+              })
+            : null;
+          const status = props.localFilesUploading
+            ? copy.retrying
+            : !props.authenticated
+              ? copy.signInToRetry
+              : file.error
+                ? copy[failureKind!]
+                : file.missing
+                  ? copy.localSaveFailed
+                  : props.localFilesStorageStatus === "missing"
+                    ? copy.storageRequired
+                    : props.localFilesStorageStatus === "unavailable"
+                      ? copy.storageStatusUnavailable
+                      : copy.uploadPending;
+          const severity = props.localFilesUploading
+            ? "neutral"
+            : file.missing
+              ? "error"
+              : "warning";
+          return (
+            <Item
+              key={`local:${file.path}`}
+              size="recovery"
+              role="listitem"
+              aria-label={file.fileName}
+            >
+              <ItemMedia data-recovery-tone={severity}>
+                {props.localFilesUploading ? (
+                  <Spinner />
+                ) : (
+                  <IconAlertTriangle size={16} stroke={1.75} aria-hidden />
+                )}
+              </ItemMedia>
+              <ItemContent>
+                <ItemTitle title={file.path}>{file.fileName}</ItemTitle>
+                <RecoveryDescription text={status} diagnostic={file.error} />
+              </ItemContent>
+              <ItemActions>
+                {!file.missing ? (
+                  <RecoveryAction
+                    label={
+                      !props.authenticated
+                        ? copy.signInToRetry
+                        : props.localFilesStorageStatus === "configured"
+                          ? copy.retry
+                          : props.localFilesStorageStatus === "missing"
+                            ? copy.connectStorage
+                            : copy.refresh
+                    }
+                    disabled={
+                      !props.authenticated ||
+                      props.localFilesUploading ||
+                      props.finalizing ||
+                      props.localFilesStorageStatus === "checking"
+                    }
+                    busy={
+                      props.localFilesUploading ||
+                      props.localFilesStorageStatus === "checking"
+                    }
+                    onClick={() => {
+                      if (props.localFilesStorageStatus === "configured") {
+                        props.onRetryLocalFiles();
+                      } else if (props.localFilesStorageStatus === "missing") {
+                        props.onConnectLocalStorage();
+                      } else {
+                        props.onRefreshStorage();
+                      }
+                    }}
+                  >
+                    {props.localFilesStorageStatus === "missing" ? (
+                      <IconUpload aria-hidden />
+                    ) : (
+                      <IconRefresh aria-hidden />
+                    )}
+                  </RecoveryAction>
+                ) : null}
+                <RecoveryMore
+                  localAction={
+                    file.missing
+                      ? {
+                          label: "Remove from list",
+                          onSelect: () => props.onForgetLocalFile(file.path),
+                        }
+                      : undefined
+                  }
+                  onOpenLogs={() =>
+                    props.onOpenLogs(`record-first:${file.path}`)
+                  }
+                />
+              </ItemActions>
+            </Item>
+          );
+        })}
         {uploads.map((upload) => {
           const key = recordingRecoveryKey(upload);
           const retrying = props.retryingUploadId === key;
@@ -486,6 +639,8 @@ export function RecordingRecoveryPage(
         })}
       </ItemGroup>
       {!uploads.length &&
+      !localFiles.length &&
+      !props.localFilesError &&
       !orphanErrors.length &&
       !props.lookupErrors.length &&
       !props.finalizing ? (