@agent-native/core 0.93.0 → 0.94.1

package/corpus/templates/clips/desktop/src/styles.css

@@ -2040,21 +2040,19 @@ body[data-clips-route="recording-pill"] #root {
   padding: 0 8px;
 }
 
-.pending-upload-discard {
+.pending-upload-dismiss {
   width: 28px;
   height: 28px;
-  border: 1px solid #bfdbfe;
+  border: 0;
   border-radius: var(--radius-sm);
-  background: rgba(255, 255, 255, 0.76);
-  color: #2563eb;
+  background: transparent;
+  color: #3b5f9a;
   cursor: pointer;
   display: inline-flex;
   align-items: center;
   justify-content: center;
   padding: 0;
   transition:
-    background 120ms,
-    border-color 120ms,
     color 120ms,
     opacity 120ms;
 }
@@ -2093,16 +2091,14 @@ body[data-clips-route="recording-pill"] #root {
   border-color: #93c5fd;
 }
 
-.pending-upload-discard:hover {
-  background: #fee2e2;
-  border-color: #fecaca;
-  color: #b91c1c;
+.pending-upload-dismiss:hover {
+  color: #1e3a8a;
 }
 
 .pending-upload-retry:disabled,
 .pending-upload-connect:disabled,
 .pending-upload-folder:disabled,
-.pending-upload-discard:disabled {
+.pending-upload-dismiss:disabled {
   cursor: default;
   opacity: 0.6;
 }
@@ -2288,10 +2284,8 @@ body[data-clips-route="recording-pill"] #root {
     color: #dbeafe;
   }
 
-  .pending-upload-discard {
-    background: rgba(23, 23, 23, 0.58);
-    border-color: rgba(96, 165, 250, 0.38);
-    color: #bfdbfe;
+  .pending-upload-dismiss {
+    color: #93c5fd;
   }
 
   .pending-upload-folder {
@@ -2315,10 +2309,8 @@ body[data-clips-route="recording-pill"] #root {
     border-color: rgba(147, 197, 253, 0.62);
   }
 
-  .pending-upload-discard:hover {
-    background: rgba(127, 29, 29, 0.34);
-    border-color: rgba(248, 113, 113, 0.62);
-    color: #fecaca;
+  .pending-upload-dismiss:hover {
+    color: #dbeafe;
   }
 
   .error-banner {

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

@@ -136,7 +136,8 @@ 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_discard_upload,
+            native_screen::native_fullscreen_recording_dismiss_upload,
+            native_screen::native_fullscreen_open_drafts_folder,
             // local-only always-on screen memory compatibility helpers
             screen_memory::screen_memory_query,
             screen_memory::screen_memory_delete_all,

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

@@ -111,6 +111,7 @@ const FFMPEG_CANDIDATE_PATHS: &[&str] = &[
     "/opt/local/bin/ffmpeg",
 ];
 const PENDING_UPLOADS_DIR: &str = "pending-recording-uploads";
+const CLIP_DRAFTS_DIR: &str = "Drafts";
 const THUMBNAIL_MIME_TYPE: &str = "image/jpeg";
 const THUMBNAIL_MAX_BYTES: u64 = 2 * 1024 * 1024;
 const THUMBNAIL_WIDTH: &str = "1280";
@@ -2103,12 +2104,60 @@ pub async fn native_fullscreen_recording_retry_upload(
 }
 
 #[tauri::command]
-pub async fn native_fullscreen_recording_discard_upload(
+pub async fn native_fullscreen_recording_dismiss_upload(
     app: AppHandle,
     recording_id: String,
-) -> Result<(), String> {
-    let saved = read_saved_recording_metadata(&app, &recording_id)?;
-    clear_saved_recording(&app, &saved)
+) -> Result<String, String> {
+    let mut saved = read_saved_recording_metadata(&app, &recording_id)?;
+    let draft_dir = clip_drafts_dir(&app)?.join(sanitize_recording_id(&recording_id));
+    std::fs::create_dir_all(&draft_dir)
+        .map_err(|e| format!("clip draft directory unavailable: {e}"))?;
+
+    let mut sources = vec![saved.file_path.clone()];
+    for segment_path in &saved.segment_paths {
+        if !sources.contains(segment_path) {
+            sources.push(segment_path.clone());
+        }
+    }
+
+    let mut moved_any = false;
+    for source in sources {
+        if !source.exists() {
+            continue;
+        }
+        if source.parent() == Some(draft_dir.as_path()) {
+            moved_any = true;
+            continue;
+        }
+        let destination = available_draft_path(&draft_dir, &source);
+        move_or_copy_file(&source, &destination)?;
+        moved_any = true;
+
+        if saved.file_path == source {
+            saved.file_path = destination.clone();
+        }
+        for segment_path in &mut saved.segment_paths {
+            if *segment_path == source {
+                *segment_path = destination.clone();
+            }
+        }
+        // Keep metadata recoverable if a later segment move fails.
+        write_saved_recording_metadata(&app, &saved)?;
+    }
+
+    if !moved_any {
+        return Err("No saved clip file was available to move into Clip Drafts.".into());
+    }
+
+    let metadata_path = saved_recording_metadata_path(&app, &saved.recording_id)?;
+    remove_saved_file(&metadata_path, "pending recording metadata")?;
+    Ok(draft_dir.to_string_lossy().to_string())
+}
+
+#[tauri::command]
+pub fn native_fullscreen_open_drafts_folder(app: AppHandle) -> Result<(), String> {
+    let dir = clip_drafts_dir(&app)?;
+    crate::clips::open_local_recording_folder(dir.to_string_lossy().to_string())
 }
 
 fn sanitize_recording_id(value: &str) -> String {
@@ -2152,6 +2201,74 @@ fn pending_uploads_dir(app: &AppHandle) -> Result<PathBuf, String> {
     Ok(dir)
 }
 
+fn clip_drafts_dir(app: &AppHandle) -> Result<PathBuf, String> {
+    let dir = app
+        .path()
+        .video_dir()
+        .map_err(|e| format!("videos directory unavailable: {e}"))?
+        .join("Clips")
+        .join(CLIP_DRAFTS_DIR);
+    std::fs::create_dir_all(&dir).map_err(|e| format!("clip drafts directory unavailable: {e}"))?;
+    Ok(dir)
+}
+
+fn available_draft_path(draft_dir: &Path, source: &Path) -> PathBuf {
+    let file_name = source
+        .file_name()
+        .and_then(|value| value.to_str())
+        .unwrap_or("clip");
+    let preferred = draft_dir.join(file_name);
+    if !preferred.exists() {
+        return preferred;
+    }
+
+    let stem = source
+        .file_stem()
+        .and_then(|value| value.to_str())
+        .unwrap_or("clip");
+    let extension = source.extension().and_then(|value| value.to_str());
+    for suffix in 2.. {
+        let candidate_name = match extension {
+            Some(extension) => format!("{stem}-{suffix}.{extension}"),
+            None => format!("{stem}-{suffix}"),
+        };
+        let candidate = draft_dir.join(candidate_name);
+        if !candidate.exists() {
+            return candidate;
+        }
+    }
+    unreachable!()
+}
+
+#[cfg(test)]
+mod clip_draft_tests {
+    use super::available_draft_path;
+
+    #[test]
+    fn keeps_existing_drafts_when_file_names_collide() {
+        let root = std::env::temp_dir().join(format!(
+            "clips-draft-path-test-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        let drafts = root.join("Drafts");
+        std::fs::create_dir_all(&drafts).unwrap();
+        std::fs::write(drafts.join("clip.mp4"), b"first").unwrap();
+        std::fs::write(drafts.join("clip-2.mp4"), b"second").unwrap();
+
+        let source = root.join("clip.mp4");
+        assert_eq!(
+            available_draft_path(&drafts, &source),
+            drafts.join("clip-3.mp4")
+        );
+
+        let _ = std::fs::remove_dir_all(root);
+    }
+}
+
 fn pending_recording_path(
     app: &AppHandle,
     safe_id: &str,

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

@@ -177,6 +177,16 @@ pub(crate) mod macos {
         }
     }
 
+    fn native_speech_voice_processing_mode(owner: SessionOwner) -> MicVoiceProcessingMode {
+        match owner {
+            // Meeting-owned native speech is the last-resort path after local
+            // Whisper capture fails. It still needs a VPIO allocation to share
+            // the mic with call apps, but must not process their live uplink.
+            SessionOwner::Meeting => MicVoiceProcessingMode::Bypassed,
+            SessionOwner::Dictation => MicVoiceProcessingMode::Disabled,
+        }
+    }
+
     /// One in-flight dictation. Holds strong references to the AppKit objects
     /// so they don't drop while the recognition task is still emitting
     /// results.
@@ -625,15 +635,30 @@ pub(crate) mod macos {
         Ok(())
     }
 
-    fn enable_voice_processing(input_node: &AVAudioInputNode) {
-        if let Err(err) = unsafe { input_node.setVoiceProcessingEnabled_error(true) } {
-            eprintln!(
-                "[whisper-mic] voice processing enable failed: {} — continuing without AEC",
-                ns_error_message(&err)
-            );
+    fn enable_voice_processing(input_node: &AVAudioInputNode) -> Result<(), String> {
+        match unsafe { input_node.setVoiceProcessingEnabled_error(true) } {
+            Ok(()) => Ok(()),
+            Err(err) => {
+                let message = ns_error_message(&err);
+                eprintln!("[whisper-mic] voice processing enable failed: {message}");
+                Err(format!("VoiceProcessingIO enable failed: {message}"))
+            }
         }
     }
 
+    fn enable_bypassed_voice_processing(input_node: &AVAudioInputNode) -> Result<(), String> {
+        enable_voice_processing(input_node)?;
+        // VPIO owns a shareable voice input path, but Clips should receive and
+        // forward the unprocessed microphone signal. This also prevents AGC
+        // from changing the level seen by the live-call app.
+        unsafe {
+            input_node.setVoiceProcessingBypassed(true);
+            input_node.setVoiceProcessingAGCEnabled(false);
+        }
+        eprintln!("[whisper-mic] VoiceProcessingIO enabled in bypass mode for meeting fallback");
+        Ok(())
+    }
+
     fn disable_voice_processing_ducking(input_node: &AVAudioInputNode) {
         // Disable other-audio ducking so the separately-captured system audio
         // isn't dropped to near-silent while the mic VPIO runs.
@@ -793,7 +818,7 @@ pub(crate) mod macos {
         let engine: Retained<AVAudioEngine> = unsafe { AVAudioEngine::new() };
         configure_engine_input_device(&engine, mic_device_id, mic_device_label)?;
         let input_node: Retained<AVAudioInputNode> = unsafe { engine.inputNode() };
-        enable_voice_processing(&input_node);
+        let _ = enable_voice_processing(&input_node);
         // Finalize input format negotiation once. Dictation-owned Whisper starts
         // can then reuse this stopped VPIO engine instead of paying the
         // per-press VoiceProcessingIO setup cost.
@@ -995,6 +1020,15 @@ pub(crate) mod macos {
             mic_device_label.as_deref(),
         )?;
         let input_node = unsafe { engine.inputNode() };
+        let native_voice_processing = native_speech_voice_processing_mode(owner);
+        let voice_processing_enabled = match native_voice_processing {
+            MicVoiceProcessingMode::Bypassed => {
+                enable_bypassed_voice_processing(&input_node)?;
+                true
+            }
+            MicVoiceProcessingMode::Enabled => enable_voice_processing(&input_node).is_ok(),
+            MicVoiceProcessingMode::Disabled => false,
+        };
         // `prepare()` must run after pinning the device so the AUHAL adopts
         // the new hardware format before we install a tap. It can throw
         // NSException when a Bluetooth device (e.g. AirPods) is mid-SCO↔A2DP
@@ -1079,6 +1113,10 @@ pub(crate) mod macos {
             msg
         })?;
 
+        if voice_processing_enabled {
+            disable_voice_processing_ducking(&input_node);
+        }
+
         // Cancel + stop flags shared with the result handler.
         let cancelled = Arc::new(AtomicBool::new(false));
         let stopped = Arc::new(AtomicBool::new(false));
@@ -1338,18 +1376,29 @@ pub(crate) mod macos {
         })
     }
 
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    pub(crate) enum MicVoiceProcessingMode {
+        Disabled,
+        Enabled,
+        /// Allocate VoiceProcessingIO so a live-call app cannot starve this
+        /// parallel mic tap, but bypass its uplink processing so Clips does not
+        /// alter the microphone signal Zoom, Meet, or Teams receives.
+        Bypassed,
+    }
+
     /// Start mic capture and forward a mono mix of every available channel to
-    /// `on_samples`. Recording transcription can disable VPIO so the tap does
-    /// not precondition the shared mic before ScreenCaptureKit opens it.
+    /// `on_samples`. Recordings can keep VPIO disabled before ScreenCaptureKit
+    /// opens the microphone; legacy meeting capture uses bypassed VPIO so it
+    /// receives buffers without processing the live-call uplink.
     pub(crate) fn start_raw_mic_capture(
         app: AppHandle,
         mic_device_id: Option<String>,
         mic_device_label: Option<String>,
-        voice_processing: bool,
+        voice_processing: MicVoiceProcessingMode,
         reuse_voice_processing_engine: bool,
         on_samples: Arc<dyn Fn(&[f32]) + Send + Sync>,
     ) -> Result<RawMicCapture, String> {
-        if voice_processing && reuse_voice_processing_engine {
+        if voice_processing == MicVoiceProcessingMode::Enabled && reuse_voice_processing_engine {
             return start_warmed_raw_mic_capture(app, mic_device_id, mic_device_label, on_samples);
         }
         clear_warmed_raw_mic_engine();
@@ -1364,11 +1413,21 @@ pub(crate) mod macos {
         )?;
         let input_node: Retained<AVAudioInputNode> = unsafe { engine.inputNode() };
 
-        if voice_processing {
-            enable_voice_processing(&input_node);
-        } else {
-            eprintln!("[whisper-mic] voice processing disabled for shared mic capture");
-        }
+        let voice_processing_enabled = match voice_processing {
+            MicVoiceProcessingMode::Bypassed => {
+                // This mode exists specifically to close the shared-mic gap.
+                // If VPIO cannot be allocated, fail loudly so the caller can
+                // move to its next transcription fallback instead of silently
+                // running the known-unreliable raw meeting tap.
+                enable_bypassed_voice_processing(&input_node)?;
+                true
+            }
+            MicVoiceProcessingMode::Enabled => enable_voice_processing(&input_node).is_ok(),
+            MicVoiceProcessingMode::Disabled => {
+                eprintln!("[whisper-mic] voice processing disabled for shared mic capture");
+                false
+            }
+        };
         // Finalize input format negotiation.
         objc2::exception::catch(std::panic::AssertUnwindSafe(|| unsafe { engine.prepare() }))
             .map_err(|e| format!("AVAudioEngine prepare threw: {e:?}"))?;
@@ -1430,7 +1489,7 @@ pub(crate) mod macos {
             unsafe { format.channelCount() }
         );
 
-        if voice_processing {
+        if voice_processing_enabled {
             disable_voice_processing_ducking(&input_node);
         }
 
@@ -1488,4 +1547,25 @@ pub(crate) mod macos {
         unsafe { session.task.cancel() };
         Ok(())
     }
+
+    #[cfg(test)]
+    mod tests {
+        use super::{native_speech_voice_processing_mode, MicVoiceProcessingMode, SessionOwner};
+
+        #[test]
+        fn meeting_native_speech_fallback_uses_bypassed_voice_processing() {
+            assert_eq!(
+                native_speech_voice_processing_mode(SessionOwner::Meeting),
+                MicVoiceProcessingMode::Bypassed
+            );
+        }
+
+        #[test]
+        fn dictation_native_speech_keeps_raw_input() {
+            assert_eq!(
+                native_speech_voice_processing_mode(SessionOwner::Dictation),
+                MicVoiceProcessingMode::Disabled
+            );
+        }
+    }
 }

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

@@ -109,7 +109,9 @@ mod macos {
     use tauri::{AppHandle, Emitter};
     use whisper_rs::{FullParams, SamplingStrategy, WhisperContext, WhisperContextParameters};
 
-    use crate::native_speech::macos::{start_raw_mic_capture, RawMicCapture};
+    use crate::native_speech::macos::{
+        start_raw_mic_capture, MicVoiceProcessingMode, RawMicCapture,
+    };
     use crate::system_audio::macos::{
         start_raw_meeting_capture, start_raw_system_capture, supports_sck_microphone_capture,
         RawSckAudioCapture,
@@ -583,6 +585,35 @@ mod macos {
         owner == SessionOwner::Meeting && microphone_capture_supported
     }
 
+    #[derive(Debug, PartialEq, Eq)]
+    struct SplitMicCaptureOptions {
+        voice_processing: MicVoiceProcessingMode,
+        reuse_voice_processing_engine: bool,
+    }
+
+    fn split_mic_capture_options(
+        owner: SessionOwner,
+        capture_system: bool,
+        requested_voice_processing: bool,
+    ) -> SplitMicCaptureOptions {
+        let voice_processing = match owner {
+            // If SCK microphone capture is unavailable or fails, keep a VPIO
+            // allocation so Zoom/Meet/Teams cannot starve Clips of mic buffers,
+            // but bypass its uplink processing to preserve call volume/quality.
+            SessionOwner::Meeting => MicVoiceProcessingMode::Bypassed,
+            SessionOwner::Dictation if requested_voice_processing => {
+                MicVoiceProcessingMode::Enabled
+            }
+            SessionOwner::Dictation => MicVoiceProcessingMode::Disabled,
+        };
+        SplitMicCaptureOptions {
+            voice_processing,
+            reuse_voice_processing_engine: owner == SessionOwner::Dictation
+                && !capture_system
+                && voice_processing == MicVoiceProcessingMode::Enabled,
+        }
+    }
+
     struct Session {
         // macOS 15+ meetings use a combined SCK capture, so there is no
         // competing AVAudioEngine / VoiceProcessingIO mic input to stop.
@@ -723,13 +754,13 @@ mod macos {
             mic_stream.set_src_rate(48000.0);
             (None, Some(combined_cap))
         } else {
-            let reuse_voice_processing_engine = owner == SessionOwner::Dictation && !capture_system;
+            let mic_options = split_mic_capture_options(owner, capture_system, voice_processing);
             let mic_cap = start_raw_mic_capture(
                 app.clone(),
                 mic_device_id,
                 mic_device_label,
-                voice_processing,
-                reuse_voice_processing_engine,
+                mic_options.voice_processing,
+                mic_options.reuse_voice_processing_engine,
                 mic_callback,
             )
             .map_err(|e| {
@@ -832,7 +863,8 @@ mod macos {
 
     #[cfg(test)]
     mod tests {
-        use super::{should_use_combined_sck_capture, SessionOwner};
+        use super::{should_use_combined_sck_capture, split_mic_capture_options, SessionOwner};
+        use crate::native_speech::macos::MicVoiceProcessingMode;
 
         #[test]
         fn combined_sck_capture_is_only_selected_for_supported_meetings() {
@@ -846,5 +878,48 @@ mod macos {
                 true
             ));
         }
+
+        #[test]
+        fn meeting_split_capture_uses_bypassed_voice_processing() {
+            assert_eq!(
+                split_mic_capture_options(SessionOwner::Meeting, true, false),
+                super::SplitMicCaptureOptions {
+                    voice_processing: MicVoiceProcessingMode::Bypassed,
+                    reuse_voice_processing_engine: false,
+                }
+            );
+            assert_eq!(
+                split_mic_capture_options(SessionOwner::Meeting, false, true),
+                super::SplitMicCaptureOptions {
+                    voice_processing: MicVoiceProcessingMode::Bypassed,
+                    reuse_voice_processing_engine: false,
+                }
+            );
+        }
+
+        #[test]
+        fn dictation_split_capture_preserves_requested_processing() {
+            assert_eq!(
+                split_mic_capture_options(SessionOwner::Dictation, false, true),
+                super::SplitMicCaptureOptions {
+                    voice_processing: MicVoiceProcessingMode::Enabled,
+                    reuse_voice_processing_engine: true,
+                }
+            );
+            assert_eq!(
+                split_mic_capture_options(SessionOwner::Dictation, true, false),
+                super::SplitMicCaptureOptions {
+                    voice_processing: MicVoiceProcessingMode::Disabled,
+                    reuse_voice_processing_engine: false,
+                }
+            );
+            assert_eq!(
+                split_mic_capture_options(SessionOwner::Dictation, true, true),
+                super::SplitMicCaptureOptions {
+                    voice_processing: MicVoiceProcessingMode::Enabled,
+                    reuse_voice_processing_engine: false,
+                }
+            );
+        }
     }
 }

package/corpus/templates/clips/desktop/src-tauri/tauri.conf.json

@@ -40,7 +40,7 @@
   },
   "plugins": {
     "shell": {
-      "open": true
+      "open": "(((mailto:\\w+)|(tel:\\w+)|(https?://\\w+)).+|(zoommtg://([A-Za-z0-9-]+\\.)*zoom\\.us/join\\?.+))"
     },
     "updater": {
       "active": true,

package/corpus/templates/clips/vitest.config.ts

@@ -0,0 +1,23 @@
+import path from "node:path";
+
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./app"),
+      "@shared": path.resolve(__dirname, "./shared"),
+    },
+  },
+  test: {
+    include: ["**/*.{test,spec}.?(c|m)[jt]s?(x)"],
+    exclude: [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/.output/**",
+      "**/.react-router/**",
+      "**/e2e/**",
+    ],
+  },
+});

package/corpus/templates/content/app/components/editor/DocumentEditor.tsx

@@ -5,6 +5,7 @@ import {
   emailToColor,
   emailToName,
   useAvatarUrl,
+  useDbSync,
   useSession,
   useT,
   agentNativePath,
@@ -343,6 +344,23 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
   const [localContentUpdatedAt, setLocalContentUpdatedAt] = useState<
     string | null
   >(document.updatedAt ?? null);
+  const flushRequestKey = `flush-request-${documentId}`;
+  const [flushRequestWake, setFlushRequestWake] = useState(0);
+  const handleFlushRequestEvent = useCallback(
+    (event: { source?: string; key?: string }) => {
+      if (
+        event.source === "app-state" &&
+        (event.key === flushRequestKey || event.key === "*")
+      ) {
+        setFlushRequestWake((wake) => wake + 1);
+      }
+    },
+    [flushRequestKey],
+  );
+  // Reuse the root's shared SSE/poll transport. This subscriber only wakes the
+  // flush reader when its exact application-state key changes; it does not open
+  // another EventSource or polling loop.
+  useDbSync({ onEvent: handleFlushRequestEvent });
   const saveTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const promotedBuilderBodyRef = useRef<string | null>(null);
   const pendingDocumentSaveRef = useRef<PendingDocumentSave | null>(null);
@@ -1033,16 +1051,18 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
   // the in-memory Y.Doc, so the open editor is the only place that can
   // serialize the live content through its existing serializer. On seeing the
   // key we force an immediate (non-debounced) save of the current editor
-  // state, then delete the key so `pull-document` knows the flush landed.
+  // state, then acknowledge it so `pull-document` knows the flush landed.
+  // The shared sync transport wakes this reader for the exact app-state key;
+  // the first run covers a request that was already pending when the editor
+  // mounted.
   useEffect(() => {
     if (!editorCanEdit || isLocalFileDocument) return;
     let active = true;
-    const flushKey = `flush-request-${documentId}`;
     const flushPath = agentNativePath(
-      `/_agent-native/application-state/${flushKey}`,
+      `/_agent-native/application-state/${flushRequestKey}`,
     );
 
-    async function poll() {
+    async function flushIfRequested() {
       try {
         const res = await fetch(flushPath);
         if (res.ok) {
@@ -1058,7 +1078,6 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
             // read and clear it. Retrying here could hide a failed flush or
             // replace the explicit success signal before the server sees it.
             if (pending.status === "error" || pending.status === "success") {
-              if (active) setTimeout(poll, 600);
               return;
             }
             const title = localTitleRef.current;
@@ -1131,19 +1150,19 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
           }
         }
       } catch {
-        // Ignore — next tick retries.
+        // Best-effort read. A later app-state event will wake the reader again.
       }
-      if (active) setTimeout(poll, 600);
     }
 
-    const timer = setTimeout(poll, 600);
+    void flushIfRequested();
     return () => {
       active = false;
-      clearTimeout(timer);
     };
   }, [
     documentId,
     editorCanEdit,
+    flushRequestKey,
+    flushRequestWake,
     isLocalFileDocument,
     persistDocumentUpdates,
     t,

package/corpus/templates/content/changelog/2026-07-10-open-documents-no-longer-make-constant-background-requests-w.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-10
+---
+
+Open documents no longer make constant background requests while waiting for sync operations.