@agent-native/core 0.84.12 → 0.84.13

package/corpus/core/src/shared/streaming-text-smoothing.ts

@@ -1,6 +1,7 @@
 export const SMOOTH_STREAMING_COMMIT_INTERVAL_MS = 16;
 export const SMOOTH_STREAMING_LONG_TEXT_THRESHOLD_GRAPHEMES = 640;
 export const SMOOTH_STREAMING_LONG_TEXT_TAIL_GRAPHEMES = 180;
+const SMOOTH_STREAMING_SPEED_MULTIPLIER = 2;
 
 type SegmenterInstance = {
   segment(input: string): Iterable<{ segment: string }>;
@@ -137,7 +138,7 @@ export function smoothStreamingRevealCount({
     return 0;
   }
 
-  const charactersPerSecond = inputDone
+  const baseCharactersPerSecond = inputDone
     ? backlog > 800
       ? 900
       : 420
@@ -148,8 +149,12 @@ export function smoothStreamingRevealCount({
         : backlog > 180
           ? 190
           : 95;
+  const charactersPerSecond =
+    baseCharactersPerSecond * SMOOTH_STREAMING_SPEED_MULTIPLIER;
 
-  const maxBurst = inputDone ? 160 : backlog > 1400 ? 120 : 72;
+  const maxBurst =
+    (inputDone ? 160 : backlog > 1400 ? 120 : 72) *
+    SMOOTH_STREAMING_SPEED_MULTIPLIER;
   const count = Math.floor((elapsedMs / 1000) * charactersPerSecond);
 
   return Math.min(backlog, Math.max(1, count), maxBurst);
@@ -164,15 +169,15 @@ export function smoothStreamingPunctuationDelayMs(
   }
 
   if (grapheme === "\n") {
-    return 80;
+    return 80 / SMOOTH_STREAMING_SPEED_MULTIPLIER;
   }
 
   if (/[.!?)]/.test(grapheme)) {
-    return 70;
+    return 70 / SMOOTH_STREAMING_SPEED_MULTIPLIER;
   }
 
   if (/[,;:]/.test(grapheme)) {
-    return 35;
+    return 35 / SMOOTH_STREAMING_SPEED_MULTIPLIER;
   }
 
   return 0;

package/corpus/templates/clips/app/components/library/recording-card.tsx

@@ -28,6 +28,7 @@ import {
 } from "@/components/ui/dropdown-menu";
 import { isDefaultTitle } from "@/hooks/use-auto-title";
 import type { RecordingSummary } from "@/hooks/use-library";
+import { isStaleRecordingUpload } from "@/lib/recording-status";
 import { isStorageSetupFailureReason } from "@/lib/storage-failures";
 import { cn } from "@/lib/utils";
 
@@ -100,6 +101,12 @@ export function RecordingCard({
   const waitingForStorage = isStorageSetupFailureReason(
     recording.failureReason,
   );
+  const staleUpload = isStaleRecordingUpload(recording);
+  const displayFailed = recording.status === "failed" || staleUpload;
+  const failureReason = staleUpload
+    ? (recording.failureReason ??
+      t("recordingPage.processingStuck", { status: recording.status }))
+    : (recording.failureReason ?? t("clipsFinalRaw.removeFailedClip"));
   const nativeUploadPaused =
     recording.status === "failed" &&
     /native recording|native fullscreen|screencapture|avconvert/i.test(
@@ -221,11 +228,15 @@ export function RecordingCard({
         {/* Status pill for non-ready recordings */}
         {recording.status !== "ready" && (
           <div className="absolute top-2 end-2 rounded-full bg-black/80 px-2 py-0.5 text-[10px] font-medium text-white uppercase tracking-wide">
-            {waitingForStorage ? "storage" : recording.status}
+            {waitingForStorage
+              ? "storage"
+              : staleUpload
+                ? "failed"
+                : recording.status}
           </div>
         )}
 
-        {(recording.status === "failed" || waitingForStorage) && (
+        {(displayFailed || waitingForStorage) && (
           <div
             className={cn(
               "absolute inset-x-2 bottom-2 rounded-md border bg-background/95 p-2 text-start shadow-sm backdrop-blur",
@@ -252,8 +263,7 @@ export function RecordingCard({
                     ? t("clipsFinalRaw.connectStorageToFinish")
                     : nativeUploadPaused
                       ? t("clipsFinalRaw.retryFromClipsMenu")
-                      : (recording.failureReason ??
-                        t("clipsFinalRaw.removeFailedClip"))}
+                      : failureReason}
                 </div>
               </div>
               {!waitingForStorage && (

package/corpus/templates/clips/app/components/recorder/recorder-engine.ts

@@ -1145,6 +1145,9 @@ export class RecorderEngine {
       // mid-state — the UI spinner is wired to engine state and would
       // hang forever otherwise.
       const e = err instanceof Error ? err : new Error(String(err));
+      if (e.name !== "AbortError") {
+        this.rememberUploadFailure(e);
+      }
       this.transition("error", { message: e.message });
       throw e;
     } finally {
@@ -1183,6 +1186,9 @@ export class RecorderEngine {
       return this.toFinalizeResult(result, meta);
     } catch (err) {
       const e = err instanceof Error ? err : new Error(String(err));
+      if (e.name !== "AbortError") {
+        this.rememberUploadFailure(e);
+      }
       this.transition("error", { message: e.message });
       throw e;
     } finally {
@@ -1595,26 +1601,18 @@ export class RecorderEngine {
         const failure = err instanceof Error ? err : new Error(String(err));
         // User-initiated cancel — cancel() already runs the abortUrl path.
         if (failure.name === "AbortError") return;
-        await this.markUploadFailed(failure);
+        this.rememberUploadFailure(failure);
         this.emitError(failure);
       }
     });
   }
 
-  private async markUploadFailed(err: Error): Promise<void> {
+  private rememberUploadFailure(err: Error): void {
     if (!this.uploadFailure) {
       this.uploadFailure = err;
     }
-    if (!this.opts.abortUrl) return;
-    try {
-      await fetch(this.opts.abortUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ reason: err.message }),
-      });
-    } catch {
-      // ignore — the stop path will surface the original upload error.
-    }
+    // Do not call abortUrl for retryable upload failures. retryUpload() reuses
+    // this recording id; cancel() owns the terminal server-side abort path.
   }
 
   private async uploadBlobInSlices(

package/corpus/templates/clips/app/hooks/use-library.ts

@@ -1,5 +1,7 @@
 import { useActionQuery, useActionMutation } from "@agent-native/core/client";
 
+import { isLiveRecordingUpload } from "@/lib/recording-status";
+
 export interface RecordingSummary {
   id: string;
   title: string;
@@ -72,16 +74,17 @@ export function useRecordings(args: ListRecordingsArgs = {}) {
           recordings: Array.isArray(data?.recordings) ? data.recordings : [],
         };
       },
-      // If any recording is still on a replaceable seed title, keep a 3s
-      // refetch cadence so the skeleton in `recording-card` upgrades to
-      // the real title promptly even if the refresh-signal poll is missed.
+      // Keep a short poll while uploads/processors are active so the library
+      // card does not get stuck if the global refresh signal is missed.
+      // Also poll for replaceable seed titles so the card upgrades promptly.
       refetchInterval: (q) => {
         const recs = (q.state.data as any)?.recordings as
           | RecordingSummary[]
           | undefined;
         if (!recs || recs.length === 0) return false;
+        const pendingUpload = recs.some((rec) => isLiveRecordingUpload(rec));
         const pendingTitle = recs.some(isAwaitingAutoTitle);
-        return pendingTitle ? 3000 : false;
+        return pendingUpload || pendingTitle ? 3000 : false;
       },
     },
   );

package/corpus/templates/clips/app/lib/recording-status.ts

@@ -0,0 +1,32 @@
+export const STALE_RECORDING_UPLOAD_MS = 30 * 60 * 1000;
+
+type RecordingStatusLike = {
+  status?: string | null;
+  updatedAt?: string | null;
+};
+
+export function isActiveRecordingUploadStatus(
+  status: string | null | undefined,
+): boolean {
+  return status === "uploading" || status === "processing";
+}
+
+export function isStaleRecordingUpload(
+  recording: RecordingStatusLike,
+  nowMs = Date.now(),
+): boolean {
+  if (!isActiveRecordingUploadStatus(recording.status)) return false;
+  const updatedAtMs = Date.parse(recording.updatedAt ?? "");
+  if (!Number.isFinite(updatedAtMs)) return false;
+  return nowMs - updatedAtMs >= STALE_RECORDING_UPLOAD_MS;
+}
+
+export function isLiveRecordingUpload(
+  recording: RecordingStatusLike,
+  nowMs = Date.now(),
+): boolean {
+  if (!isActiveRecordingUploadStatus(recording.status)) return false;
+  const updatedAtMs = Date.parse(recording.updatedAt ?? "");
+  if (!Number.isFinite(updatedAtMs)) return true;
+  return nowMs - updatedAtMs < STALE_RECORDING_UPLOAD_MS;
+}

package/corpus/templates/clips/changelog/2026-07-01-dictation-keeps-listening-through-natural-pauses-and-gives-c.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-01
+---
+
+Dictation keeps listening through natural pauses and gives clearer start feedback.

package/corpus/templates/clips/changelog/2026-07-01-redoing-a-paused-desktop-recording-no-longer-leaves-the-recording-controls-disabled.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-01
+---
+
+Redoing a paused desktop recording no longer leaves the recording controls disabled.

package/corpus/templates/clips/changelog/2026-07-01-stalled-clip-uploads-now-update-in-the-library-and-surface-as-failed.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-01
+---
+
+Stalled clip uploads now update in the library and surface as failed instead of staying stuck as uploading.

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

@@ -1278,6 +1278,18 @@ async function trashRecording(
   }
 }
 
+async function cleanupCancelledRemoteRecording(
+  serverUrl: string,
+  recordingId: string,
+): Promise<void> {
+  await abortRecordingUpload(
+    serverUrl,
+    recordingId,
+    "Recording cancelled by user",
+  );
+  await trashRecording(serverUrl, recordingId);
+}
+
 class CountdownCancelledError extends Error {
   constructor() {
     super("Recording cancelled during countdown");
@@ -2029,7 +2041,12 @@ async function startNativeFullscreenRecording(
         }
         stateUnlistens.forEach((u) => u());
         stateUnlistens = [];
-        await transcriptionCapture?.cancel().catch(() => {});
+        void transcriptionCapture?.cancel().catch((err) => {
+          console.warn(
+            "[clips-recorder] native transcription cancel failed:",
+            err,
+          );
+        });
         await localCameraExport?.cancel().catch(() => {});
         await invoke("native_fullscreen_recording_cancel").catch((err) =>
           console.warn(
@@ -2049,12 +2066,14 @@ async function startNativeFullscreenRecording(
         streamCleanups.forEach((cleanup) => cleanup());
         await invoke("hide_overlays").catch(() => {});
         if (!localOnly && id) {
-          await abortRecordingUpload(
-            params.serverUrl,
-            id,
-            "Recording cancelled by user",
+          void cleanupCancelledRemoteRecording(params.serverUrl, id).catch(
+            (err) => {
+              console.warn(
+                "[clips-recorder] cancelled recording cleanup failed:",
+                err,
+              );
+            },
           );
-          await trashRecording(params.serverUrl, id);
         }
       })();
       return cancelPromise;
@@ -3244,7 +3263,9 @@ async function startRecordingInner(
       if (tickHandle) clearInterval(tickHandle);
       stateUnlistens.forEach((u) => u());
       stateUnlistens = [];
-      transcriptionCapture?.cancel().catch(() => {});
+      void transcriptionCapture?.cancel().catch((err) => {
+        console.warn("[clips-recorder] transcription cancel failed:", err);
+      });
       // Remove MediaRecorder's data handler so any final `ondataavailable`
       // from the stop() below doesn't push a new Blob into `inflight`
       // after we've decided to discard everything.
@@ -3282,18 +3303,15 @@ async function startRecordingInner(
       inflight.clear();
       await invoke("hide_recording_chrome").catch(() => {});
       // Tell the server to abort the partial recording (drops chunks from
-      // application_state, flips the recording row to 'failed'). Fire and
-      // forget with a short-circuit on failure — we don't want to keep the
-      // user waiting on a network call to a dev server that may be down.
-      try {
-        await abortRecordingUpload(
-          params.serverUrl,
-          id,
-          "Recording cancelled by user",
+      // application_state, flips the recording row to 'failed'), then trash
+      // it. This is best-effort background cleanup: redo/cancel must release
+      // the desktop chrome immediately even if the server is slow or offline.
+      if (id) {
+        void cleanupCancelledRemoteRecording(params.serverUrl, id).catch(
+          (err) => {
+            console.warn("[clips-recorder] abort failed (non-fatal):", err);
+          },
         );
-        await trashRecording(params.serverUrl, id);
-      } catch (err) {
-        console.warn("[clips-recorder] abort failed (non-fatal):", err);
       }
       await deleteBrowserRecordingBackup(id).catch((err) => {
         console.warn("[clips-recorder] local backup cleanup failed:", err);

package/corpus/templates/clips/desktop/src/lib/voice-dictation.ts

@@ -102,6 +102,11 @@ interface VoiceSession {
   // Accumulated final transcript from interim webkit results, in case
   // the recognition session ends before we ask it to stop.
   browserTranscript: string;
+  // Native / Whisper engines can emit one final segment per pause. Keep
+  // committed segments separate from the current partial so long dictations
+  // survive natural pauses.
+  finalTranscriptParts: string[];
+  interimTranscript: string;
   // browser-only: monotonic timestamp of the most recent
   // recognition.onresult event. stop() reads this to decide whether
   // the user was actively speaking up to Fn release (worth a tail-
@@ -229,6 +234,73 @@ function setFlowState(state: FlowState): void {
   emit("voice:state-change", { state }).catch(() => {});
 }
 
+let lastStartPingAt = 0;
+
+function playStartPing(): void {
+  const now = Date.now();
+  if (now - lastStartPingAt < 250) return;
+  lastStartPingAt = now;
+  try {
+    const AudioCtx = window.AudioContext || (window as any).webkitAudioContext;
+    if (!AudioCtx) return;
+    const ctx = new AudioCtx();
+    const osc = ctx.createOscillator();
+    const gain = ctx.createGain();
+    const start = ctx.currentTime;
+    osc.type = "sine";
+    osc.frequency.setValueAtTime(880, start);
+    osc.frequency.exponentialRampToValueAtTime(1174.66, start + 0.08);
+    gain.gain.setValueAtTime(0.0001, start);
+    gain.gain.exponentialRampToValueAtTime(0.08, start + 0.015);
+    gain.gain.exponentialRampToValueAtTime(0.0001, start + 0.13);
+    osc.connect(gain);
+    gain.connect(ctx.destination);
+    osc.start(start);
+    osc.stop(start + 0.14);
+    window.setTimeout(() => {
+      ctx.close().catch(() => {});
+    }, 250);
+  } catch {
+    // Sound feedback is best-effort; the moving bars remain the visual cue.
+  }
+}
+
+function enterRecordingState(): void {
+  setFlowState("recording");
+  playStartPing();
+}
+
+function joinedTranscript(parts: string[], interim: string): string {
+  return [...parts, interim].filter(Boolean).join(" ").trim();
+}
+
+function appendFinalTranscript(session: VoiceSession, text: string): void {
+  const clean = text.trim();
+  if (!clean) return;
+  const committed = joinedTranscript(session.finalTranscriptParts, "");
+  if (!committed) {
+    session.finalTranscriptParts = [clean];
+  } else if (clean === committed || clean.startsWith(`${committed} `)) {
+    // Some recognizers send the whole dictation as their final result.
+    session.finalTranscriptParts = [clean];
+  } else if (session.finalTranscriptParts.at(-1) !== clean) {
+    session.finalTranscriptParts.push(clean);
+  }
+  session.interimTranscript = "";
+  session.browserTranscript = joinedTranscript(
+    session.finalTranscriptParts,
+    "",
+  );
+}
+
+function setInterimTranscript(session: VoiceSession, text: string): void {
+  session.interimTranscript = text.trim();
+  session.browserTranscript = joinedTranscript(
+    session.finalTranscriptParts,
+    session.interimTranscript,
+  );
+}
+
 function stopMeter(session: VoiceSession): void {
   if (session.raf != null) {
     cancelAnimationFrame(session.raf);
@@ -698,7 +770,6 @@ export function installDesktopVoiceDictation(
     } catch (err) {
       console.warn("[voice-dictation] vocab learn-monitor failed:", err);
     }
-    emit("voice:partial-transcript", { text }).catch(() => {});
     if (target.cleanupProvider) setFlowState("idle");
     return text;
   };
@@ -808,7 +879,7 @@ export function installDesktopVoiceDictation(
         abortPendingStart();
         return;
       }
-      setFlowState("recording");
+      enterRecordingState();
       const mimeType = pickMimeType();
       const recorder = new MediaRecorder(stream, { mimeType });
       const next: VoiceSession = {
@@ -822,6 +893,8 @@ export function installDesktopVoiceDictation(
         mimeType: recorder.mimeType || mimeType,
         recognition: null,
         browserTranscript: "",
+        finalTranscriptParts: [],
+        interimTranscript: "",
         lastResultAt: 0,
         startedAt: Date.now(),
         stopping: false,
@@ -948,7 +1021,7 @@ export function installDesktopVoiceDictation(
         abortPendingStart();
         return;
       }
-      setFlowState("recording");
+      enterRecordingState();
       // Reset any prior partial transcript display in the flow-bar.
       emit("voice:partial-transcript", { text: "" }).catch(() => {});
       const next: VoiceSession = {
@@ -962,6 +1035,8 @@ export function installDesktopVoiceDictation(
         mimeType: "",
         recognition: null,
         browserTranscript: "",
+        finalTranscriptParts: [],
+        interimTranscript: "",
         lastResultAt: 0,
         startedAt: Date.now(),
         stopping: false,
@@ -1043,7 +1118,7 @@ export function installDesktopVoiceDictation(
         abortPendingStart();
         return;
       }
-      setFlowState("recording");
+      enterRecordingState();
       emit("voice:partial-transcript", { text: "" }).catch(() => {});
       const next: VoiceSession = {
         kind: "whisper",
@@ -1056,6 +1131,8 @@ export function installDesktopVoiceDictation(
         mimeType: "",
         recognition: null,
         browserTranscript: "",
+        finalTranscriptParts: [],
+        interimTranscript: "",
         lastResultAt: 0,
         startedAt: Date.now(),
         stopping: false,
@@ -1112,7 +1189,7 @@ export function installDesktopVoiceDictation(
         abortPendingStart();
         return;
       }
-      setFlowState("recording");
+      enterRecordingState();
       // Reset any prior partial transcript display in the flow-bar.
       emit("voice:partial-transcript", { text: "" }).catch(() => {});
       const recognition = new Ctor();
@@ -1131,6 +1208,8 @@ export function installDesktopVoiceDictation(
         mimeType: "",
         recognition,
         browserTranscript: "",
+        finalTranscriptParts: [],
+        interimTranscript: "",
         lastResultAt: 0,
         startedAt: Date.now(),
         stopping: false,
@@ -1203,10 +1282,6 @@ export function installDesktopVoiceDictation(
         // the tail because Web Speech only marks a segment as `isFinal`
         // after a confidence-threshold pass.
         next.browserTranscript = (finalSoFar + interim).trim();
-        // Stream the live transcript to the flow-bar.
-        emit("voice:partial-transcript", {
-          text: next.browserTranscript,
-        }).catch(() => {});
       };
       recognition.onerror = (ev) => {
         if (ev.error !== "no-speech" && ev.error !== "aborted") {
@@ -1732,31 +1807,28 @@ export function installDesktopVoiceDictation(
     if (!current || (current.kind !== "native" && current.kind !== "whisper"))
       return;
     if (current.cancelled || current.stopping) return;
-    current.browserTranscript = text.trim();
+    setInterimTranscript(current, text);
   })
     .then((u) => unlistens.push(u))
     .catch(() => {});
   onFinalTranscript(({ text }) => {
-    // Final transcripts are ONLY emitted by Rust after `endAudio()`,
-    // which we call in stop(). At that point the session has been
-    // moved from `session` to `lingeringSession`, so route there
-    // exclusively. Do NOT fall back to the active `session`: a
-    // late-arriving final from the previous session would otherwise
-    // overwrite the new session's transcript with stale text.
-    const current =
-      lingeringSession &&
-      (lingeringSession.kind === "native" ||
-        lingeringSession.kind === "whisper")
-        ? lingeringSession
+    // Whisper emits final segments throughout a long dictation whenever the
+    // speaker pauses. Native speech emits its final after stop, when the
+    // stopped session is parked in lingeringSession. Native final events do not
+    // carry a session id, so never fall back to an active native session here:
+    // a late final from the previous stop could otherwise be appended to a new
+    // dictation.
+    const current = lingeringSession
+      ? lingeringSession
+      : session && session.kind === "whisper" && !session.stopping
+        ? session
         : null;
     if (!current) return;
     if (current.cancelled) return;
-    // Final beats partial — overwrite so a `complete_voice_dictation`
-    // from a late stop() picks up the better text.
-    current.browserTranscript = text.trim();
-    // If stop() is waiting on this event before lingering, trigger the
-    // finalize sequence now (paste → 1s linger → dismiss).
-    current.onNativeFinalize?.();
+    appendFinalTranscript(current, text);
+    if (current === lingeringSession) {
+      current.onNativeFinalize?.();
+    }
   })
     .then((u) => unlistens.push(u))
     .catch(() => {});

package/corpus/templates/clips/desktop/src/overlays/flow-bar.tsx

@@ -3,11 +3,7 @@ import { invoke } from "@tauri-apps/api/core";
 import { emit, listen } from "@tauri-apps/api/event";
 import { useEffect, useRef, useState } from "react";
 
-import {
-  onAudioLevel,
-  onFinalTranscript,
-  onPartialTranscript,
-} from "../lib/transcription-engine";
+import { onAudioLevel } from "../lib/transcription-engine";
 
 type FlowState = "idle" | "recording" | "processing" | "complete" | "error";
 
@@ -28,7 +24,6 @@ export function FlowBar() {
   // "idle" caused the bar to flash an "EN" language pill that never went
   // away if the start event was missed.
   const [state, setState] = useState<FlowState>("recording");
-  const [partialTranscript, setPartialTranscript] = useState("");
   const canvasRef = useRef<HTMLCanvasElement | null>(null);
   const levelRef = useRef(0);
   const rafRef = useRef<number | null>(null);
@@ -63,23 +58,6 @@ export function FlowBar() {
       }),
     );
 
-    trackListen(
-      onPartialTranscript(({ text }) => {
-        // Live transcript as the user speaks — rendered above the pill.
-        // Empty payload clears the display (sent at session start/end).
-        setPartialTranscript(text);
-      }),
-    );
-
-    trackListen(
-      onFinalTranscript(({ text }) => {
-        // Final result from the recognizer (only fires after stop is
-        // requested). Show it on the bar — the last word lingers there
-        // for ~1s before voice-dictation.ts dismisses everything.
-        if (text) setPartialTranscript(text);
-      }),
-    );
-
     return () => {
       stopped = true;
       unlistens.forEach((u) => {
@@ -166,29 +144,12 @@ export function FlowBar() {
     }, 250);
   };
 
-  // The transcript chip is independent of the pill — it can linger on
-  // its own after Fn release while the pill dismisses snappily. Voice-
-  // dictation.ts emits an empty payload to clear it once the linger
-  // window expires.
-  const showTranscript = partialTranscript.length > 0;
-
   return (
     <div className="flow-bar-root">
-      {showTranscript && (
-        <div className="flow-bar-transcript">
-          {/* <bdi> + unicode-bidi: plaintext (in CSS) keeps Latin text
-              in its natural LTR order while the parent's direction:rtl
-              clips overflow from the visual left. Without this, the
-              last few characters of the newest words were being pushed
-              past the visible right edge by bidi reordering. */}
-          <bdi>{partialTranscript}</bdi>
-        </div>
-      )}
       {/* Pill is ALWAYS mounted — when state goes idle we fade the
-          opacity to 0 (see CSS) instead of removing it from the DOM,
-          so the transcript chip above doesn't reflow when the pill
-          "goes away". Inner content keeps its last frame rendered
-          during the fade so the canvas doesn't pop. */}
+          opacity to 0 (see CSS) instead of removing it from the DOM.
+          Inner content keeps its last frame rendered during the fade
+          so the canvas doesn't pop. */}
       <div className={`flow-bar flow-bar-${state}`}>
         {(state === "recording" || state === "idle") && (
           <div className="flow-bar-recording">

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

@@ -98,8 +98,11 @@ export function Toolbar() {
     trackListen(
       listen<boolean>("clips:toolbar-enabled", (ev) => {
         setEnabled(!!ev.payload);
+        setPendingAction(null);
         if (!ev.payload) {
           setDiskSpaceLevel("ok");
+          setPaused(false);
+          setElapsed(0);
         }
       }),
     );