@agent-native/core 0.109.0 → 0.109.2

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

@@ -51,7 +51,10 @@ import { invoke } from "@tauri-apps/api/core";
 import { emit, listen, type UnlistenFn } from "@tauri-apps/api/event";
 import { open as openExternal } from "@tauri-apps/plugin-shell";
 
-import { waitForReadyRecordingAfterFinalizeError } from "../../../shared/finalize-recovery";
+import {
+  waitForAcceptedRecordingAfterFinalizeError,
+  waitForReadyRecordingAfterFinalizeError,
+} from "../../../shared/finalize-recovery";
 import type { LocalRecordingMode } from "../shared/config";
 import { createAudioCue, type AudioCue } from "./audio-cue";
 import { createCameraCompositeStream } from "./camera-composite";
@@ -75,6 +78,7 @@ import {
   createPauseTransitionQueue,
   type PauseTransitionQueue,
 } from "./pause-transition";
+import { reconcileProcessingBackup } from "./processing-backup-recovery";
 import { buildCaptureTitle, type CaptureTitleResult } from "./recording-title";
 import { singleFlight } from "./single-flight";
 import {
@@ -83,6 +87,7 @@ import {
   type TranscriptionCapture,
 } from "./transcription-capture";
 import {
+  parseFinalizeReceipt,
   verifyFinalizeReceipt,
   type FinalizeReceipt,
 } from "./upload-verification";
@@ -741,6 +746,7 @@ export async function dismissBrowserRecordingBackup(
 async function markBrowserRecordingBackupError(
   recordingId: string,
   error: string,
+  incrementRetryCount = true,
 ): Promise<void> {
   const meta = await getBrowserRecordingBackupMeta(recordingId);
   if (!meta) return;
@@ -748,11 +754,84 @@ async function markBrowserRecordingBackupError(
     ...meta,
     lastAttemptAt: new Date().toISOString(),
     lastError: error,
-    retryCount: meta.retryCount + 1,
+    retryCount: incrementRetryCount ? meta.retryCount + 1 : meta.retryCount,
+  });
+}
+
+const MEDIA_VERIFICATION_BACKUP_ERROR =
+  "The server could not finish verifying this upload. The local copy is still saved; retry to continue.";
+
+async function flagBrowserBackupAfterProcessing(recordingId: string) {
+  await markBrowserRecordingBackupError(
+    recordingId,
+    MEDIA_VERIFICATION_BACKUP_ERROR,
+    false,
+  );
+  await emit("clips:pending-uploads-changed").catch(() => {});
+}
+
+async function flagNativeBackupAfterProcessing(recordingId: string) {
+  await invoke("native_fullscreen_recording_mark_upload_error", {
+    recordingId,
+    error: MEDIA_VERIFICATION_BACKUP_ERROR,
+  });
+}
+
+function scheduleBrowserBackupCleanupAfterProcessing(args: {
+  serverUrl: string;
+  recordingId: string;
+  authToken?: string;
+}): void {
+  void reconcileProcessingBackup({
+    waitForReady: () =>
+      waitForReadyRecordingAfterFinalizeError({
+        uploadUrl: chunkUrl(args.serverUrl, args.recordingId, 0, false),
+        recordingId: args.recordingId,
+        authToken: args.authToken,
+        preferAuthenticated: true,
+        timeoutMs: 12 * 60 * 1000,
+      }),
+    onReady: () => deleteBrowserRecordingBackup(args.recordingId),
+    onUnresolved: () => flagBrowserBackupAfterProcessing(args.recordingId),
+    onPollError: (err) => {
+      console.warn(
+        "[clips-recorder] background backup cleanup check failed:",
+        err,
+      );
+    },
+  }).catch((err) => {
+    console.warn("[clips-recorder] background backup flag failed:", err);
+  });
+}
+
+export function scheduleNativeBackupCleanupAfterProcessing(args: {
+  serverUrl: string;
+  recordingId: string;
+  authToken?: string;
+}): void {
+  void reconcileProcessingBackup({
+    waitForReady: () =>
+      waitForReadyRecordingAfterFinalizeError({
+        uploadUrl: chunkUrl(args.serverUrl, args.recordingId, 0, false),
+        recordingId: args.recordingId,
+        authToken: args.authToken,
+        preferAuthenticated: true,
+        timeoutMs: 12 * 60 * 1000,
+      }),
+    onReady: () =>
+      invoke("native_fullscreen_recording_dismiss_upload", {
+        recordingId: args.recordingId,
+      }),
+    onUnresolved: () => flagNativeBackupAfterProcessing(args.recordingId),
+    onPollError: (err) => {
+      console.warn("[clips-recorder] native backup cleanup check failed:", err);
+    },
+  }).catch((err) => {
+    console.warn("[clips-recorder] native backup flag failed:", err);
   });
 }
 
-async function recoverReadyRecordingAfterFinalizeError({
+async function recoverAcceptedRecordingAfterFinalizeError({
   serverUrl,
   recordingId,
   authToken,
@@ -760,19 +839,27 @@ async function recoverReadyRecordingAfterFinalizeError({
   serverUrl: string;
   recordingId: string;
   authToken?: string;
-}): Promise<boolean> {
-  const recovered = await waitForReadyRecordingAfterFinalizeError({
+}): Promise<"processing" | "ready" | null> {
+  const recovered = await waitForAcceptedRecordingAfterFinalizeError({
     uploadUrl: chunkUrl(serverUrl, recordingId, 0, false),
     recordingId,
     authToken,
     preferAuthenticated: true,
   });
-  if (!recovered) return false;
+  if (!recovered) return null;
+  if (recovered.status === "processing") {
+    scheduleBrowserBackupCleanupAfterProcessing({
+      serverUrl,
+      recordingId,
+      authToken,
+    });
+    return "processing";
+  }
   await markBrowserRecordingBackupError(
     recordingId,
     "Upload completed, but its final receipt could not be verified. The local backup was kept.",
   ).catch(() => {});
-  return true;
+  return "ready";
 }
 
 export async function listBrowserRecordingBackups(): Promise<
@@ -824,7 +911,7 @@ async function postBackupChunk(
       `Upload retry failed (${res.status}): ${body.slice(0, 200)}`,
     );
   }
-  return body ? (JSON.parse(body) as FinalizeReceipt) : null;
+  return parseFinalizeReceipt(body);
 }
 
 async function resetBrowserRecordingBackupUpload(
@@ -951,10 +1038,21 @@ export async function retryBrowserRecordingBackup(input: {
           validatedChunks,
           input.authToken,
         );
-        verifyFinalizeReceipt(receipt, meta);
+        const receiptStatus = verifyFinalizeReceipt(receipt, meta);
+        if (receiptStatus === "processing") {
+          scheduleBrowserBackupCleanupAfterProcessing({
+            serverUrl: meta.serverUrl,
+            recordingId: meta.recordingId,
+            authToken: input.authToken,
+          });
+          return {
+            recordingId: meta.recordingId,
+            viewUrl: `/r/${meta.recordingId}`,
+          };
+        }
       } catch (err) {
         if (
-          await recoverReadyRecordingAfterFinalizeError({
+          await recoverAcceptedRecordingAfterFinalizeError({
             serverUrl: meta.serverUrl,
             recordingId: meta.recordingId,
             authToken: input.authToken,
@@ -1007,10 +1105,21 @@ export async function retryBrowserRecordingBackup(input: {
         new Blob([], { type: meta.mimeType }),
         input.authToken,
       );
-      verifyFinalizeReceipt(receipt, meta);
+      const receiptStatus = verifyFinalizeReceipt(receipt, meta);
+      if (receiptStatus === "processing") {
+        scheduleBrowserBackupCleanupAfterProcessing({
+          serverUrl: meta.serverUrl,
+          recordingId: meta.recordingId,
+          authToken: input.authToken,
+        });
+        return {
+          recordingId: meta.recordingId,
+          viewUrl: `/r/${meta.recordingId}`,
+        };
+      }
     } catch (err) {
       if (
-        await recoverReadyRecordingAfterFinalizeError({
+        await recoverAcceptedRecordingAfterFinalizeError({
           serverUrl: meta.serverUrl,
           recordingId: meta.recordingId,
           authToken: input.authToken,
@@ -1143,6 +1252,7 @@ interface NativeFullscreenUploadResult {
   durationMs: number;
   width?: number;
   height?: number;
+  verificationPending?: boolean;
 }
 
 interface NativeFullscreenSaveResult {
@@ -2490,7 +2600,7 @@ async function startNativeFullscreenRecording(
             uploadResult = await uploadPromise;
           } catch (err) {
             if (
-              await recoverReadyRecordingAfterFinalizeError({
+              await recoverAcceptedRecordingAfterFinalizeError({
                 serverUrl: params.serverUrl,
                 recordingId: id,
                 authToken: params.authToken,
@@ -2505,6 +2615,13 @@ async function startNativeFullscreenRecording(
             );
             throw err;
           }
+          if (uploadResult.verificationPending) {
+            scheduleNativeBackupCleanupAfterProcessing({
+              serverUrl: params.serverUrl,
+              recordingId: id,
+              authToken: params.authToken,
+            });
+          }
           const transcriptSaved = await transcriptSavePromise;
           if (!transcriptSaved && capturedTranscript?.text.trim()) {
             // The first write runs in parallel with native upload. Retry once
@@ -3875,18 +3992,24 @@ async function startRecordingInner(
                 `Finalize failed (${finalRes.status}): ${bodyText.slice(0, 200)}`,
               );
             }
-            const receipt = bodyText
-              ? (JSON.parse(bodyText) as FinalizeReceipt)
-              : null;
-            verifyFinalizeReceipt(receipt, {
+            const receipt = parseFinalizeReceipt(bodyText);
+            const receiptStatus = verifyFinalizeReceipt(receipt, {
               bytes: backupBytes,
               durationMs,
             });
+            if (receiptStatus === "processing") {
+              scheduleBrowserBackupCleanupAfterProcessing({
+                serverUrl: params.serverUrl,
+                recordingId: id,
+                authToken: params.authToken,
+              });
+              return { recordingId: id, viewUrl };
+            }
           } catch (err) {
             console.error("[clips-recorder] finalize fetch failed:", err);
             const error = err instanceof Error ? err : new Error(String(err));
             if (
-              await recoverReadyRecordingAfterFinalizeError({
+              await recoverAcceptedRecordingAfterFinalizeError({
                 serverUrl: params.serverUrl,
                 recordingId: id,
                 authToken: params.authToken,

package/corpus/templates/clips/desktop/src/lib/upload-verification.ts

@@ -2,6 +2,7 @@ export interface FinalizeReceipt {
   ok?: unknown;
   finalized?: unknown;
   status?: unknown;
+  verificationPending?: unknown;
   sourceSizeBytes?: unknown;
   durationMs?: unknown;
 }
@@ -11,16 +12,34 @@ export interface LocalRecordingProof {
   durationMs: number;
 }
 
+export type FinalizeReceiptStatus = "processing" | "ready";
+
+export function parseFinalizeReceipt(body: string): FinalizeReceipt | null {
+  if (!body) return null;
+  try {
+    const parsed: unknown = JSON.parse(body);
+    return parsed && typeof parsed === "object"
+      ? (parsed as FinalizeReceipt)
+      : null;
+  } catch {
+    throw new Error("Upload returned an invalid finalization response");
+  }
+}
+
 export function verifyFinalizeReceipt(
   receipt: FinalizeReceipt | null,
   local: LocalRecordingProof,
-): void {
-  if (
-    !receipt ||
-    receipt.ok !== true ||
-    receipt.finalized !== true ||
-    receipt.status !== "ready"
-  ) {
+): FinalizeReceiptStatus {
+  const ready =
+    receipt?.ok === true &&
+    receipt.finalized === true &&
+    receipt.status === "ready";
+  const processing =
+    receipt?.ok === true &&
+    receipt.finalized === false &&
+    receipt.status === "processing" &&
+    receipt.verificationPending === true;
+  if (!ready && !processing) {
     throw new Error(
       "Clip may be incomplete. Finalization was not confirmed; the local backup was kept.",
     );
@@ -48,4 +67,6 @@ export function verifyFinalizeReceipt(
       "Clip may be incomplete. The uploaded duration did not match the local recording; the local backup was kept.",
     );
   }
+
+  return ready ? "ready" : "processing";
 }

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

@@ -141,6 +141,7 @@ pub fn run() {
             native_screen::native_fullscreen_recording_rotate_segment,
             native_screen::native_fullscreen_pending_uploads,
             native_screen::native_fullscreen_recording_retry_upload,
+            native_screen::native_fullscreen_recording_mark_upload_error,
             native_screen::native_fullscreen_recording_dismiss_upload,
             native_screen::native_fullscreen_open_drafts_folder,
             // local-only always-on screen memory compatibility helpers
@@ -249,8 +250,7 @@ pub fn run() {
                 use tauri_plugin_deep_link::DeepLinkExt;
                 let dl_handle = app.handle().clone();
                 app.deep_link().on_open_url(move |event| {
-                    let urls: Vec<String> =
-                        event.urls().iter().map(|u| u.to_string()).collect();
+                    let urls: Vec<String> = event.urls().iter().map(|u| u.to_string()).collect();
                     dlog!("[clips-tray] deep link opened: {:?}", urls);
                     present_popover(&dl_handle);
                     let _ = dl_handle.emit("clips:deep-link", urls);
@@ -263,8 +263,7 @@ pub fn run() {
                 // arguments rather than an on_open_url event. Consume it here so
                 // the popover appears and the browser does not hit its fallback.
                 if let Ok(Some(urls)) = app.deep_link().get_current() {
-                    let url_strings: Vec<String> =
-                        urls.iter().map(|u| u.to_string()).collect();
+                    let url_strings: Vec<String> = urls.iter().map(|u| u.to_string()).collect();
                     dlog!("[clips-tray] deep link cold start: {:?}", url_strings);
                     present_popover(app.handle());
                     let _ = app.handle().emit("clips:deep-link", url_strings);

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

@@ -36,8 +36,12 @@ pub(super) struct LiveUploadCtrl {
 
 pub(super) struct LiveUpload {
     pub(super) ctrl: Arc<LiveUploadCtrl>,
-    /// Resolves with the total bytes uploaded, or an error string.
-    pub(super) result_rx: tokio::sync::oneshot::Receiver<Result<u64, String>>,
+    pub(super) result_rx: tokio::sync::oneshot::Receiver<Result<LiveUploadResult, String>>,
+}
+
+pub(super) struct LiveUploadResult {
+    pub(super) bytes: u64,
+    pub(super) verification_pending: bool,
 }
 
 struct LiveUploadParams {
@@ -163,7 +167,7 @@ async fn send_live_upload_post_with_retry(
     duration_ms: Option<u128>,
     expected_source_bytes: Option<u64>,
     bytes: &[u8],
-) -> Result<(), String> {
+) -> Result<bool, String> {
     let rec = &params.recording_id;
     let mut attempt: u32 = 0;
     loop {
@@ -198,7 +202,7 @@ async fn send_live_upload_post_with_retry(
         )
         .await;
         let err = match result {
-            Ok(()) => return Ok(()),
+            Ok(verification_pending) => return Ok(verification_pending),
             Err(err) => err,
         };
         if attempt >= LIVE_UPLOAD_CHUNK_ATTEMPTS {
@@ -219,7 +223,7 @@ async fn live_upload_loop(
     app: AppHandle,
     ctrl: Arc<LiveUploadCtrl>,
     params: LiveUploadParams,
-) -> Result<u64, String> {
+) -> Result<LiveUploadResult, String> {
     let rec = params.recording_id.clone();
     eprintln!(
         "[live-upload] loop started for {rec}: file={} chunk={} bytes",
@@ -290,6 +294,7 @@ async fn live_upload_loop(
             // sentinel makes GCS silently commit only the aligned prefix, and
             // the session close then fails forever with 308 (incomplete).
             let mut final_sent = false;
+            let mut verification_pending = false;
             while final_len > offset {
                 let take = chunk.min(final_len - offset);
                 let is_last = offset + take >= final_len;
@@ -302,7 +307,7 @@ async fn live_upload_loop(
                 eprintln!(
                     "[live-upload] {rec}: sending tail chunk #{index} offset={offset} size={take} final={is_last}"
                 );
-                if let Err(e) = send_live_upload_post_with_retry(
+                let receipt = send_live_upload_post_with_retry(
                     &client,
                     &ctrl,
                     &params,
@@ -313,10 +318,16 @@ async fn live_upload_loop(
                     is_last.then_some(final_len),
                     &bytes,
                 )
-                .await
-                {
-                    eprintln!("[live-upload] {rec}: tail chunk #{index} failed: {e}");
-                    return Err(e);
+                .await;
+                let pending = match receipt {
+                    Ok(pending) => pending,
+                    Err(e) => {
+                        eprintln!("[live-upload] {rec}: tail chunk #{index} failed: {e}");
+                        return Err(e);
+                    }
+                };
+                if is_last {
+                    verification_pending = pending;
                 }
                 offset += take;
                 index += 1;
@@ -331,7 +342,7 @@ async fn live_upload_loop(
                     "[live-upload] {rec}: sending final post #{index} (total={}, duration_ms={duration_ms})",
                     index + 1
                 );
-                if let Err(e) = send_live_upload_post_with_retry(
+                verification_pending = match send_live_upload_post_with_retry(
                     &client,
                     &ctrl,
                     &params,
@@ -344,13 +355,19 @@ async fn live_upload_loop(
                 )
                 .await
                 {
-                    eprintln!("[live-upload] {rec}: final post failed: {e}");
-                    return Err(e);
-                }
+                    Ok(pending) => pending,
+                    Err(e) => {
+                        eprintln!("[live-upload] {rec}: final post failed: {e}");
+                        return Err(e);
+                    }
+                };
             }
             emit_native_upload_progress(&app, "opening", "Uploading clip", None, Some(1.0));
             eprintln!("[live-upload] {rec}: done — {index} post(s), {final_len} bytes total");
-            return Ok(final_len);
+            return Ok(LiveUploadResult {
+                bytes: final_len,
+                verification_pending,
+            });
         }
 
         if !wait_logged {

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

@@ -692,6 +692,7 @@ pub struct NativeFullscreenUploadResult {
     width: Option<u32>,
     height: Option<u32>,
     bytes: u64,
+    verification_pending: bool,
 }
 
 #[derive(Serialize, Clone)]
@@ -1388,20 +1389,23 @@ pub async fn native_fullscreen_recording_stop_and_upload(
         eprintln!(
             "[live-upload] stop: finalize result for {recording_id}: {}",
             match &result {
-                Ok(bytes) => format!("ok ({bytes} bytes)"),
+                Ok(upload) => format!("ok ({} bytes)", upload.bytes),
                 Err(e) => format!("error: {e}"),
             }
         );
         return match result {
-            Ok(bytes) => {
-                clear_saved_recording_after_success(&app, &saved);
+            Ok(upload) => {
+                if !upload.verification_pending {
+                    clear_saved_recording_after_success(&app, &saved);
+                }
                 emit_native_upload_finished(&app, &server_url, &recording_id, true, None, None);
                 Ok(NativeFullscreenUploadResult {
                     recording_id,
                     duration_ms: verified_duration_ms,
                     width: session.width,
                     height: session.height,
-                    bytes,
+                    bytes: upload.bytes,
+                    verification_pending: upload.verification_pending,
                 })
             }
             Err(err) => {
@@ -1481,7 +1485,9 @@ pub async fn native_fullscreen_recording_stop_and_upload(
 
     match result {
         Ok(result) => {
-            clear_saved_recording_after_success(&app, &saved);
+            if !result.verification_pending {
+                clear_saved_recording_after_success(&app, &saved);
+            }
             emit_native_upload_finished(&app, &server_url, &recording_id, true, None, None);
             Ok(result)
         }
@@ -2599,7 +2605,9 @@ pub async fn native_fullscreen_recording_retry_upload(
 
     match result {
         Ok(result) => {
-            clear_saved_recording_after_success(&app, &saved);
+            if !result.verification_pending {
+                clear_saved_recording_after_success(&app, &saved);
+            }
             Ok(result)
         }
         Err(err) => {
@@ -2618,6 +2626,20 @@ pub async fn native_fullscreen_recording_retry_upload(
     }
 }
 
+#[tauri::command]
+pub async fn native_fullscreen_recording_mark_upload_error(
+    app: AppHandle,
+    recording_id: String,
+    error: String,
+) -> Result<(), String> {
+    let mut saved = read_saved_recording_metadata(&app, &recording_id)?;
+    saved.last_attempt_at = Some(now_iso());
+    saved.last_error = Some(error);
+    write_saved_recording_metadata(&app, &saved)?;
+    let _ = app.emit("clips:pending-uploads-changed", ());
+    Ok(())
+}
+
 #[tauri::command]
 pub async fn native_fullscreen_recording_dismiss_upload(
     app: AppHandle,
@@ -4003,6 +4025,7 @@ async fn upload_prepared_recording_file(
         .map_err(|e| format!("upload client failed: {e}"))?;
     let mut file =
         File::open(&prepared.path).map_err(|e| format!("native recording open failed: {e}"))?;
+    let verification_pending;
 
     if upload_mode == NativeUploadMode::Streaming {
         // Resumable providers require every non-final body to be aligned. The
@@ -4055,7 +4078,7 @@ async fn upload_prepared_recording_file(
             None,
             Some(streaming_full_chunks as f32 / total_posts as f32),
         );
-        send_upload_post(
+        verification_pending = send_upload_post(
             &client,
             &server_url,
             &recording_id,
@@ -4123,7 +4146,7 @@ async fn upload_prepared_recording_file(
             None,
             Some(total_chunks as f32 / total_posts as f32),
         );
-        send_upload_post(
+        verification_pending = send_upload_post(
             &client,
             &server_url,
             &recording_id,
@@ -4153,6 +4176,7 @@ async fn upload_prepared_recording_file(
         width,
         height,
         bytes: total_bytes,
+        verification_pending,
     })
 }
 
@@ -4270,7 +4294,7 @@ async fn send_upload_post(
     locally_transcoded: bool,
     expected_source_bytes: Option<u64>,
     body: Vec<u8>,
-) -> Result<(), String> {
+) -> Result<bool, String> {
     let body_len = body.len();
     let url = upload_url(
         server_url,
@@ -4319,7 +4343,7 @@ async fn send_upload_post(
             body.chars().take(400).collect::<String>()
         ));
     }
-    if is_final {
+    let verification_pending = if is_final {
         verify_native_finalize_receipt(
             &body,
             expected_source_bytes.ok_or_else(|| {
@@ -4328,13 +4352,15 @@ async fn send_upload_post(
             duration_ms.ok_or_else(|| {
                 "Clip may be incomplete: final upload had no local duration".to_string()
             })?,
-        )?;
-    }
+        )?
+    } else {
+        false
+    };
     eprintln!(
         "[clips-tray] native upload post ok recording={recording_id} mode={} index={index}/{total} final={is_final}",
         upload_mode.label()
     );
-    Ok(())
+    Ok(verification_pending)
 }
 
 #[derive(Deserialize)]
@@ -4343,6 +4369,7 @@ struct NativeFinalizeReceipt {
     ok: bool,
     finalized: bool,
     status: Option<String>,
+    verification_pending: Option<bool>,
     source_size_bytes: Option<u64>,
     duration_ms: Option<u128>,
 }
@@ -4351,12 +4378,17 @@ fn verify_native_finalize_receipt(
     body: &str,
     expected_source_bytes: u64,
     expected_duration_ms: u128,
-) -> Result<(), String> {
+) -> Result<bool, String> {
     let receipt: NativeFinalizeReceipt = serde_json::from_str(body).map_err(|_| {
         "Clip may be incomplete. The final upload receipt was unreadable; the local backup was kept."
             .to_string()
     })?;
-    if !receipt.ok || !receipt.finalized || receipt.status.as_deref() != Some("ready") {
+    let ready = receipt.ok && receipt.finalized && receipt.status.as_deref() == Some("ready");
+    let processing = receipt.ok
+        && !receipt.finalized
+        && receipt.status.as_deref() == Some("processing")
+        && receipt.verification_pending == Some(true);
+    if !ready && !processing {
         return Err(
             "Clip may be incomplete. Finalization was not confirmed; the local backup was kept."
                 .to_string(),
@@ -4374,7 +4406,7 @@ fn verify_native_finalize_receipt(
                 .to_string(),
         );
     }
-    Ok(())
+    Ok(processing)
 }
 
 fn media_durations_materially_match(expected_ms: u128, actual_ms: u128) -> bool {
@@ -4399,9 +4431,18 @@ mod native_finalize_receipt_tests {
     }
 
     #[test]
-    fn accepts_only_matching_ready_receipts() {
+    fn accepts_matching_ready_and_pending_verification_receipts() {
         let ready = r#"{"ok":true,"finalized":true,"status":"ready","sourceSizeBytes":581614005,"durationMs":1593259}"#;
-        assert!(verify_native_finalize_receipt(ready, 581_614_005, 1_592_773).is_ok());
+        assert_eq!(
+            verify_native_finalize_receipt(ready, 581_614_005, 1_592_773),
+            Ok(false)
+        );
+
+        let processing = r#"{"ok":true,"finalized":false,"status":"processing","verificationPending":true,"sourceSizeBytes":581614005,"durationMs":1593259}"#;
+        assert_eq!(
+            verify_native_finalize_receipt(processing, 581_614_005, 1_592_773),
+            Ok(true)
+        );
 
         let short = r#"{"ok":true,"finalized":true,"status":"ready","sourceSizeBytes":581614005,"durationMs":483000}"#;
         assert!(

package/corpus/templates/clips/server/db/schema.ts

@@ -586,7 +586,15 @@ export const dictations = table("clips_dictations", {
   // are text-only since native recognition runs on-device.
   audioUrl: text("audio_url"),
   source: text("source", {
-    enum: ["fn-hold", "cmd-shift-space", "manual", "other", "fn", "custom"],
+    enum: [
+      "fn-hold",
+      "cmd-shift-space",
+      "manual",
+      "mobile",
+      "other",
+      "fn",
+      "custom",
+    ],
   })
     .notNull()
     .default("fn-hold"),