@@ -117,7 +117,7 @@ import {
   shouldShowFileExplorer,
   workspaceAssetResource,
 } from "./filePreviewMode";
-import { useFileSaveCoordinator } from "./useFileSaveCoordinator";
+import { changeFileSaveSession, useFileSaveSession } from "./fileSaveSessions";
 import { revisionedQuery } from "~/state/revisionedQuery";
 import {
   getOptimisticProjectFileQueryData,
@@ -675,12 +675,8 @@ function EditableFileSurface({
   };
   const surfaceRef = useRef<HTMLDivElement>(null);
   const selectionFrameRef = useRef<number | null>(null);
-  const saveCoordinator = useFileSaveCoordinator({
-    environmentId,
-    cwd,
-    relativePath,
-    onPendingChange,
-  });
+  const saveTarget = { environmentId, cwd, relativePath };
+  useFileSaveSession(saveTarget, onPendingChange);
   // Retain file identity for echoed editor changes; only external changes replace the editor's draft.
   const [externalFile, setExternalFile] = useState(() =>
     editableFileContents(environmentId, cwd, relativePath, contents),
@@ -709,7 +705,7 @@ function EditableFileSurface({
     if (file.contents === getProjectFileContents(environmentId, cwd, relativePath)) return;
     setEditedContents(file.contents);
     setProjectFileQueryData(environmentId, cwd, relativePath, file.contents);
-    saveCoordinator.change(file.contents);
+    changeFileSaveSession(saveTarget, file.contents);
     if (!nextLineAnnotations) return;
     const remapped = remapFileCommentAnnotations(nextLineAnnotations);
     // The editor hands back the array it was given until an edit moves an annotation.
@@ -926,12 +922,8 @@ function RenderedMarkdownSurface({
   readOnly: boolean;
   workspaceMutationId: string | null;
 }) {
-  const saveCoordinator = useFileSaveCoordinator({
-    environmentId,
-    cwd,
-    relativePath,
-    onPendingChange,
-  });
+  const saveTarget = { environmentId, cwd, relativePath };
+  useFileSaveSession(saveTarget, onPendingChange);
 
   return (
     <ScrollArea className="min-h-0 flex-1">
@@ -951,7 +943,7 @@ function RenderedMarkdownSurface({
                 const nextContents = setMarkdownTaskChecked(currentContents, markerOffset, checked);
                 if (nextContents === currentContents) return;
                 setProjectFileQueryData(environmentId, cwd, relativePath, nextContents);
-                saveCoordinator.change(nextContents);
+                changeFileSaveSession(saveTarget, nextContents);
               }
         }
       />
 
@@ -7,6 +7,8 @@ export interface FileSaveCoordinatorOptions<A, E> {
   readonly onPendingChange: (pending: boolean) => void;
   /** Return false when another editor has newer unsaved contents. */
   readonly onConfirmed: (contents: string) => boolean | void;
+  /** Called when a write pass ends with nothing further scheduled. */
+  readonly onSettled?: () => void;
 }
 
 export class FileSaveCoordinator<A = unknown, E = unknown> {
@@ -17,6 +19,7 @@ export class FileSaveCoordinator<A = unknown, E = unknown> {
   private lastChangeAt = 0;
   private saving = false;
   private disposed = false;
+  private flushing = false;
 
   constructor(private readonly options: FileSaveCoordinatorOptions<A, E>) {}
 
@@ -29,6 +32,18 @@ export class FileSaveCoordinator<A = unknown, E = unknown> {
     this.schedule(this.options.debounceMs);
   }
 
+  /** The newest contents not yet written, which is the last write this coordinator will make. */
+  get unconfirmedContents(): string | null {
+    return this.latestRevision === this.confirmedRevision ? null : this.latestContents;
+  }
+
+  /** Writes the newest draft now instead of after the debounce, then any draft queued behind it. */
+  flush(): void {
+    this.clearTimer();
+    this.flushing = true;
+    void this.persistLatest();
+  }
+
   dispose(): void {
     this.disposed = true;
     this.clearTimer();
@@ -50,8 +65,9 @@ export class FileSaveCoordinator<A = unknown, E = unknown> {
   }
 
   private async persistLatest(): Promise<void> {
-    if (this.saving || this.latestRevision === this.confirmedRevision) return;
-    if (this.options.canPersist?.() === false) {
+    if (this.saving) return;
+    if (this.latestRevision === this.confirmedRevision || this.options.canPersist?.() === false) {
+      this.settle();
       return;
     }
 
@@ -69,17 +85,23 @@ export class FileSaveCoordinator<A = unknown, E = unknown> {
     this.saving = false;
     if (revision === this.latestRevision) {
       if (confirmed) this.options.onPendingChange(false);
+      this.settle();
       return;
     }
 
     const remainingDebounce = Math.max(
       0,
       this.options.debounceMs - (Date.now() - this.lastChangeAt),
     );
-    if (this.disposed) {
+    if (this.disposed || this.flushing) {
       void this.persistLatest();
     } else {
       this.schedule(remainingDebounce);
     }
   }
+
+  private settle(): void {
+    this.flushing = false;
+    this.options.onSettled?.();
+  }
 }
@@ -0,0 +1,83 @@
+import { render, fakeTimers } from "../../../test/render";
+import { EnvironmentId } from "@t3tools/contracts";
+import { AsyncResult } from "effect/reactivity";
+import { StrictMode } from "react";
+import { describe, expect, it, vi } from "vite-plus/test";
+
+const { runAtomCommand, getUnsavedFile } = vi.hoisted(() => ({
+  runAtomCommand: vi.fn(),
+  getUnsavedFile: vi.fn(),
+}));
+vi.mock(import("@t3tools/client-runtime/state/runtime"), async (original) => ({
+  ...(await original()),
+  runAtomCommand: runAtomCommand as never,
+}));
+vi.mock(import("~/state/session"), async (original) => ({
+  ...(await original()),
+  readEnvironmentScope: () => true,
+}));
+vi.mock(import("./projectFilesQueryState"), async (original) => ({
+  ...(await original()),
+  confirmProjectFileQueryData: () => true,
+  getUnsavedProjectFileQueryData: getUnsavedFile,
+}));
+
+import { changeFileSaveSession, useFileSaveSession } from "./fileSaveSessions";
+
+const target = {
+  environmentId: EnvironmentId.make("file-save-sessions-browser"),
+  cwd: "/workspace",
+  relativePath: "README.md",
+};
+const onPendingChange = vi.fn();
+
+// The editor and rendered-markdown surfaces are different component types, so
+// switching between them unmounts one session holder and mounts another.
+function EditorSurface() {
+  useFileSaveSession({ ...target }, onPendingChange);
+  return <div>editor</div>;
+}
+function MarkdownSurface() {
+  useFileSaveSession({ ...target }, onPendingChange);
+  return <div>markdown</div>;
+}
+
+describe("file save sessions in React", () => {
+  it("writes a pending draft once when the file switches surfaces under StrictMode", async () => {
+    let finishWrite = () => {};
+    runAtomCommand.mockReset().mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          finishWrite = () => resolve(AsyncResult.success(undefined));
+        }),
+    );
+    getUnsavedFile.mockReset().mockReturnValue(null);
+    await using screen = await render(
+      <StrictMode>
+        <EditorSurface />
+      </StrictMode>,
+      { router: false }, // no routes involved; the surfaces are bare effect hosts
+    );
+    using _timers = fakeTimers();
+    // An edit lands in the query cache, unconfirmed until its write settles.
+    getUnsavedFile.mockReturnValue({ contents: "draft" });
+    changeFileSaveSession(target, "draft");
+
+    await screen.rerender(
+      <StrictMode>
+        <MarkdownSurface />
+      </StrictMode>,
+    );
+    finishWrite();
+    getUnsavedFile.mockReturnValue(null);
+    await vi.runAllTimersAsync();
+
+    expect(runAtomCommand.mock.calls.map(([, , request]) => request)).toEqual([
+      {
+        environmentId: target.environmentId,
+        input: { cwd: "/workspace", relativePath: "README.md", contents: "draft" },
+      },
+    ]);
+    expect(onPendingChange).toHaveBeenLastCalledWith("README.md", false);
+  });
+});