@agent-native/core 0.136.3 → 0.136.5

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 7515
+- template files: 7516

package/corpus/templates/clips/.agents/skills/recording/SKILL.md

@@ -189,6 +189,59 @@ When mode is `screen+camera`, "the bubble" is two different things:
 
 Because that draw loop runs continuously for the whole recording, keep its CPU/GPU cost bounded: a Worker-based timer drives the draw loop at the capture frame rate (`SCREEN_CAPTURE_FRAME_RATE`, 24fps — falling back to `requestAnimationFrame` only if Worker creation fails, e.g. under a strict CSP), the canvas is hard-capped to 1080p-class dimensions (1920px on its longest edge) even if the source display track is Retina/4K, and the bubble's drop shadow is pre-rendered into a small cached sprite (keyed by bubble size) instead of re-blurring with `shadowBlur` every frame.
 
+## Restart (desktop)
+
+Restart throws the current take away and immediately starts another one. It
+must never re-acquire the screen: the toolbar click reaches the popover through
+async Tauri IPC, which carries no user activation, so a second `getDisplayMedia`
+would throw. Instead the dying session hands its live display and mic streams to
+the replacement — `RecorderHandle.discardForRestart()` returns a `RestartHandoff`
+that `startRecording` accepts as `preAcquiredDisplayStream` /
+`preAcquiredAudioStream`.
+
+Ownership is the opposite of the camera's. The popover owns the camera stream for
+the whole session and re-hands it unchanged, so restart must not bump
+`bubbleSessionEpoch` or clear `bubbleStreamTransferredToRecorder`. The handed-off
+display and mic streams belong to the **recorder**, so the new session stops them
+on its own stop/cancel, and whoever asked for the restart must stop them if the
+new session never comes up.
+
+`cancel()` and `discardForRestart()` share one `discardTake(forRestart)` per
+backend, and the difference is which teardown they run. Cancel ends the
+*session*: `hide_overlays` (which destroys the camera bubble window too) and
+`clearRecordingState()`. A restart ends only the *take*, so it uses
+`hide_recording_chrome`, which spares the bubble, and leaves the recording state
+active.
+
+Stop, cancel and restart are mutually exclusive terminal transitions, so each
+gets its own promise slot — never reuse `cancelPromise` for a discard, or a
+cancel arriving mid-restart returns the take-level teardown and the session
+never ends. A cancel that lands after a discard still owes the session half,
+plus stopping the capture the retake never took ownership of. On the app side
+`restartInFlightRef` latches synchronously so stop and cancel events cannot act
+on the recorder a restart is already tearing down.
+
+Native full-screen backends re-acquire capture in Rust and hand off nothing.
+`resolveRestartHandoff` vets the inherited streams before anything is acquired,
+and it treats the two kinds of capture differently: an ended display share is
+fatal and fails with `RESTART_CAPTURE_ENDED_MESSAGE`, because re-acquiring it
+would surface an activation error that names the wrong cause, while an ended
+microphone is just dropped and re-acquired normally. A restart also has to wait
+for the old take's `transcriptionCapture.cancel()` — the engine is process-global
+(`audio_transcription_stop` / `native_speech_stop`), so a late cancel would stop
+the replacement's engine. And `stop()` after a discard must throw rather than
+answer with the discarded take's id, or an aborted recording gets published as a
+finished one. The
+recording-flow latches (`recordingFlowGateRef`, `recordingFlowActive`,
+`clipsForceAlive`, `set_recording_state`) stay held across the restart; releasing
+them the way cancel does lets the popover blur auto-hide fire mid-restart.
+
+Holding those latches has a catch. The `show_toolbar` effect is keyed on
+`isRecording || recordingFlowActive`, so it does not re-run when the flow never
+leaves — but the discard already closed the toolbar window. Restart therefore
+bumps `recordingChromeEpoch` to rebuild it. The countdown needs no such nudge;
+the recorder recreates it on every start.
+
 ## Error recovery
 
 | Failure                       | Handling                                                                  |

package/corpus/templates/clips/actions/import-loom-recording.ts

@@ -387,11 +387,18 @@ export default defineAction({
       await writeAppState("navigate", { view: "recording", recordingId: id });
 
       try {
+        console.log("[import-loom-recording] dispatching loom-import job", {
+          recordingId: id,
+          provider: providerId,
+        });
         await dispatchPostFinalizeJob({
           recordingId: id,
           kind: "loom-import",
           requireAccepted: true,
         });
+        console.log("[import-loom-recording] loom-import job accepted", {
+          recordingId: id,
+        });
       } catch (err) {
         const failureReason = `Could not start the Loom import: ${
           err instanceof Error ? err.message : String(err)

package/corpus/templates/clips/actions/lib/loom-import-job.ts

@@ -55,6 +55,11 @@ export async function failLoomImport(
   failureReason: string,
   claimId?: string,
 ): Promise<LoomImportJobResult> {
+  console.error("[loom-import] failed", {
+    recordingId,
+    claimId,
+    failureReason,
+  });
   const now = new Date().toISOString();
   const [updated] = await getDb()
     .update(schema.recordings)
@@ -140,9 +145,16 @@ export async function runLoomImportJob({
     );
   }
 
+  console.log("[loom-import] job started", { recordingId, claimId });
+
   let media: Awaited<ReturnType<typeof downloadLoomVideo>>;
   try {
     media = await downloadLoomVideo({ loomId, shareUrl });
+    console.log("[loom-import] download complete", {
+      recordingId,
+      bytes: media.sizeBytes,
+      mimeType: media.mimeType,
+    });
   } catch (err) {
     return failLoomImport(
       recordingId,
@@ -167,6 +179,10 @@ export async function runLoomImportJob({
         claimId,
       );
     }
+    console.log("[loom-import] reupload complete", {
+      recordingId,
+      videoUrl: upload.url,
+    });
 
     const now = new Date().toISOString();
     const [mediaReady] = await db
@@ -187,11 +203,15 @@ export async function runLoomImportJob({
       )
       .returning({ id: schema.recordings.id });
     if (!mediaReady) {
-      return {
-        status: "failed",
-        failureReason: "The Loom import lease was lost before media was saved.",
-      };
+      const failureReason =
+        "The Loom import lease was lost before media was saved.";
+      console.warn("[loom-import] lease lost before ready", {
+        recordingId,
+        claimId,
+      });
+      return { status: "failed", failureReason };
     }
+    console.log("[loom-import] recording ready", { recordingId });
 
     void queueBuilderMediaCompression({
       recordingId,

package/corpus/templates/clips/changelog/2026-08-03-restart-during-a-recording-now-immediately-starts-a-fresh-ta.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-03
+---
+
+Restart during a recording now immediately starts a fresh take instead of cancelling.

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

@@ -90,6 +90,7 @@ import {
   type PendingBrowserRecordingUpload,
   type RecorderHandle,
   type RecorderStopResult,
+  type RestartHandoff,
 } from "./lib/recorder";
 import {
   copyRecordingShareLink,
@@ -377,6 +378,12 @@ function normalizeCaptureSource(value: string): CaptureSource {
   return value === "window" ? "window" : "full-screen";
 }
 
+function stopRestartHandoff(handoff: RestartHandoff): void {
+  [handoff.displayStream, handoff.audioStream].forEach((stream) =>
+    stream?.getTracks().forEach((track) => track.stop()),
+  );
+}
+
 type FetchInput = Parameters<typeof fetch>[0];
 type FetchInit = Parameters<typeof fetch>[1];
 
@@ -1039,6 +1046,12 @@ export function App() {
     refreshHomeScreenMemoryStatus,
   ]);
   const recordShortcutHandlerRef = useRef<() => void>(() => {});
+  const handleStartRecordingRef = useRef<
+    (options?: {
+      ignoreActiveRecorder?: boolean;
+      resumeCapture?: RestartHandoff;
+    }) => Promise<RecorderHandle | null>
+  >(async () => null);
   // Mirrors `bubbleActive` (assigned below once it is computed) so device
   // probes can synchronously tell whether the camera bubble owns the grant.
   const bubbleActiveRef = useRef(false);
@@ -2197,6 +2210,11 @@ export function App() {
   // bubble effect re-acquires even if bubbleActive/cameraId are unchanged
   // (post-stop reopen with a blank "Default Camera" preview).
   const [bubbleSessionEpoch, setBubbleSessionEpoch] = useState(0);
+  // Bumped when a session tears the recording chrome down without leaving the
+  // recording flow, which only a restart does. `toolbarActive` stays true
+  // across that handoff, so without an epoch the toolbar effect never re-runs
+  // and the closed toolbar window is never rebuilt.
+  const [recordingChromeEpoch, setRecordingChromeEpoch] = useState(0);
   const wantsCamera = mode !== "screen" && cameraOn;
   const nativeFullscreenRecordingActive =
     mode !== "camera" && shouldUseNativeFullscreenRecording(source);
@@ -2209,6 +2227,10 @@ export function App() {
   // fresh camera session can recover immediately. Keep that post-stop phase
   // separate so React cleanup does not close the finalizing progress window.
   const recordingStopFinalizingRef = useRef(false);
+  // Held from the restart click until the replacement recorder is up (or has
+  // failed). Stop and cancel are terminal transitions on the recorder a
+  // restart is already tearing down, so they must not run against it.
+  const restartInFlightRef = useRef(false);
   const recordingInFlight = isRecording || recordingFlowActive;
   useLayoutEffect(() => {
     recordingFlowGateRef.current = recordingInFlight;
@@ -2252,7 +2274,7 @@ export function App() {
         }).catch(() => {});
       }
     };
-  }, [toolbarActive]);
+  }, [toolbarActive, recordingChromeEpoch]);
 
   useEffect(() => {
     if (!bubbleActive) return;
@@ -2759,7 +2781,9 @@ export function App() {
 
   async function handleStartRecording(options?: {
     ignoreActiveRecorder?: boolean;
-  }) {
+    /** Live capture inherited from the take a restart is replacing. */
+    resumeCapture?: RestartHandoff;
+  }): Promise<RecorderHandle | null> {
     if (recorder && !options?.ignoreActiveRecorder) {
       console.warn(
         "[clips-popover] handleStartRecording ignored — recorder already active",
@@ -2767,7 +2791,7 @@ export function App() {
       setRecError(
         "Still finishing the last recording. Wait a moment, then try again.",
       );
-      return;
+      return null;
     }
     const bubbleTracks = bubbleStreamRef.current?.getTracks() ?? [];
     const bubbleStreamDead =
@@ -2782,11 +2806,11 @@ export function App() {
     if (localRecordingMode === "off") {
       if (videoStorageStatus === "checking") {
         setRecError("Checking video storage. Try again in a moment.");
-        return;
+        return null;
       }
       if (videoStorageStatus === "missing") {
         openVideoStorageSetup();
-        return;
+        return null;
       }
     }
     setRecError(null);
@@ -2810,12 +2834,12 @@ export function App() {
           setReadinessOpen(true);
           setRecError(MACOS_SCREEN_PERMISSION_MESSAGE);
           openPrivacySettings("screen");
-          return;
+          return null;
         }
       } catch (err) {
         setReadinessOpen(true);
         setRecError(err instanceof Error ? err.message : String(err));
-        return;
+        return null;
       }
     }
 
@@ -2901,6 +2925,8 @@ export function App() {
         systemAudioOn,
         localRecordingMode,
         preAcquiredCameraStream,
+        preAcquiredDisplayStream: options?.resumeCapture?.displayStream ?? null,
+        preAcquiredAudioStream: options?.resumeCapture?.audioStream ?? null,
       });
       // macOS: park the popover to its 2×2 pinhole IMMEDIATELY so it
       // doesn't appear in the screen picker window list. The native
@@ -2967,7 +2993,7 @@ export function App() {
 
     if (handle) {
       setRecorder(handle);
-      return;
+      return handle;
     }
 
     // Failure path — the recorder never came up. Side-effects (recording
@@ -2988,13 +3014,13 @@ export function App() {
       errName === "AbortError" ||
       /was cancelled|dismissed|region selection cancelled/i.test(message)
     ) {
-      return;
+      return null;
     }
     if (
       errName === "NotAllowedError" &&
       !isHardCapturePermissionError(message)
     ) {
-      return;
+      return null;
     }
     if (isHardCapturePermissionError(message)) {
       // If an update has finished downloading and is waiting to install, the
@@ -3009,16 +3035,22 @@ export function App() {
             ? MACOS_CAPTURE_PERMISSION_MESSAGE
             : DESKTOP_CAPTURE_PERMISSION_MESSAGE,
       );
-      return;
+      return null;
     }
     if (isStorageSetupFailureMessage(message)) {
       setRecError(STORAGE_SETUP_HELP_TEXT);
       openVideoStorageSetup();
-      return;
+      return null;
     }
     setRecError(message);
+    return null;
   }
 
+  // The restart listener lives in an effect keyed on `recorder`; calling the
+  // start flow through this ref keeps that dependency list from having to
+  // include a function that is recreated every render.
+  handleStartRecordingRef.current = handleStartRecording;
+
   recordShortcutHandlerRef.current = () => {
     if (recorder) {
       emit("clips:recorder-stop").catch(() => {});
@@ -3124,6 +3156,7 @@ export function App() {
     };
     track(
       listen("clips:recorder-stop", async () => {
+        if (restartInFlightRef.current) return;
         // 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
@@ -3185,6 +3218,7 @@ export function App() {
     );
     track(
       listen("clips:recorder-cancel", async () => {
+        if (restartInFlightRef.current) return;
         try {
           await recorder.cancel();
         } finally {
@@ -3206,26 +3240,43 @@ export function App() {
     );
     track(
       listen("clips:recorder-restart", async () => {
+        if (recordingStopFinalizingRef.current) return;
+        // Latched synchronously: a restart is a terminal transition on this
+        // recorder, and stop/cancel must not act on it while the replacement
+        // is being brought up.
+        if (restartInFlightRef.current) return;
+        restartInFlightRef.current = true;
+        let handoff: RestartHandoff | null = null;
         try {
-          await recorder.cancel();
+          handoff = await recorder.discardForRestart();
+          if (cancelled) return;
+          // The recording flow stays latched across the restart. Releasing
+          // `clipsForceAlive` / `recordingFlowGateRef` / `recordingFlowActive`
+          // / `set_recording_state` the way cancel does would let the popover's
+          // blur auto-hide fire and flicker the pill between the two takes. The
+          // camera also stays owned by the popover, so the bubble session epoch
+          // is deliberately not bumped and the stream is re-handed unchanged.
+          //
+          // The discard did close the countdown and toolbar windows. The
+          // recorder rebuilds the countdown on every start, but the toolbar is
+          // owned by an effect keyed on the flow latches we just kept held — so
+          // it has to be told the chrome is gone.
+          setRecordingChromeEpoch((epoch) => epoch + 1);
+          setRecorder(null);
+          const restarted = await handleStartRecordingRef.current({
+            ignoreActiveRecorder: true,
+            resumeCapture: handoff,
+          });
+          // The new session owns the handed-off capture only once it exists.
+          if (restarted) handoff = null;
+        } catch (err) {
+          console.error("[clips-popover] restart failed:", err);
+          setRecError(err instanceof Error ? err.message : String(err));
         } finally {
-          if (!cancelled) {
-            (
-              window as unknown as { clipsForceAlive?: boolean }
-            ).clipsForceAlive = false;
-            bubbleStreamTransferredToRecorder.current = false;
-            bubbleStreamRef.current = null;
-            recordingFlowGateRef.current = false;
-            setRecorder(null);
-            setRecordingFlowActive(false);
-            setBubbleSessionEpoch((epoch) => epoch + 1);
-            invoke("set_recording_state", { active: false }).catch(() => {});
-            // Starting a new browser capture must come from a fresh click in
-            // this webview. The toolbar click arrives here through async Tauri
-            // IPC, so reopen the popover and let the next Start click provide
-            // the required user activation.
-            invoke("show_popover").catch(() => {});
-          }
+          // Anything still held here belongs to a retake that never came up.
+          // Leaving it would keep the screen captured with nothing recording.
+          if (handoff) stopRestartHandoff(handoff);
+          restartInFlightRef.current = false;
         }
       }),
     );