diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 62223ba82096a..9410ecb7c1262 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -480,10 +480,12 @@ export default function ChatView(props: ChatViewProps) {
   const promptRef = useRef("");
   const localComposerRef = useRef<ChatComposerHandle | null>(null);
   const composerRef = useComposerHandleContext() ?? localComposerRef;
+  const threadStatus = useThreadStatus(routeThreadDetailRef);
   const queuedRunEdit = useQueuedRunEdit({
     environmentId,
     routeThreadRef,
     threadDraftTarget: baseComposerDraftTarget,
+    threadIsLive: threadStatus === "live",
     activeThreadId: serverThread !== null || draftThread !== null ? threadId : null,
     serverProjection,
     promptRef,
@@ -493,7 +495,6 @@ export default function ChatView(props: ChatViewProps) {
   const reportedModelSelection = serverProjection
     ? deriveReportedModelSelection(serverProjection)
     : null;
-  const threadStatus = useThreadStatus(routeThreadDetailRef);
   const threadSyncPhase = resolveThreadSyncPhase({
     detailExists: serverProjection !== null,
     shellExists: serverThread !== null,
diff --git a/apps/web/src/components/chat/queuedMessageEdit.test.ts b/apps/web/src/components/chat/queuedMessageEdit.test.ts
index fd5cc6ac17062..dbd3e25e834e4 100644
--- a/apps/web/src/components/chat/queuedMessageEdit.test.ts
+++ b/apps/web/src/components/chat/queuedMessageEdit.test.ts
@@ -1,4 +1,4 @@
-import { EnvironmentId, ThreadId } from "@t3tools/contracts";
+import { EnvironmentId, MessageId, ThreadId } from "@t3tools/contracts";
 import { scopeThreadRef } from "@t3tools/client-runtime/environment";
 import { beforeEach, describe, expect, it } from "vite-plus/test";
 import {
@@ -86,6 +86,29 @@ describe("queued message file edits", () => {
     expect(store.getComposerDraft(editTarget)).toBeNull();
   });
 
+  it.each(["", "Separate draft"])(
+    "handles attachment-only removals without overwriting composer %j",
+    (separateDraft) => {
+      const store = useComposerDraftStore.getState();
+      store.setPrompt(threadTarget, separateDraft);
+      store.setPrompt(editTarget, "Original message");
+      store.setQueuedMessageEdit(editTarget, {
+        messageId: MessageId.make("message:queued"),
+        originalText: "Original message",
+        removedAttachmentIds: ["attachment:removed"],
+      });
+      expect(
+        recoverQueuedMessageEdit({ editTarget, threadTarget, originalText: "Original message" }),
+      ).toBe(separateDraft ? "discarded" : "kept");
+      expect(store.getComposerDraft(threadTarget)?.prompt).toBe(
+        separateDraft || "Original message",
+      );
+      expect(store.getComposerDraft(threadTarget)?.files).toEqual([]);
+      expect(store.getComposerDraft(threadTarget)?.queuedMessageEdit).toBeUndefined();
+      expect(store.getComposerDraft(editTarget)).toBeNull();
+    },
+  );
+
   it("does not overwrite a separate draft when the queued run leaves", () => {
     const store = useComposerDraftStore.getState();
     store.setPrompt(threadTarget, "Separate draft");
diff --git a/apps/web/src/components/chat/queuedMessageEdit.ts b/apps/web/src/components/chat/queuedMessageEdit.ts
index 238534d91de47..5692868690151 100644
--- a/apps/web/src/components/chat/queuedMessageEdit.ts
+++ b/apps/web/src/components/chat/queuedMessageEdit.ts
@@ -16,9 +16,14 @@ export function recoverQueuedMessageEdit(input: {
   const draft = store.getComposerDraft(input.editTarget);
   const dirty =
     draft !== null &&
-    (draft.prompt !== input.originalText || draft.images.length > 0 || draft.files.length > 0);
+    (draft.prompt !== input.originalText ||
+      draft.images.length > 0 ||
+      draft.files.length > 0 ||
+      (draft.queuedMessageEdit?.removedAttachmentIds.length ?? 0) > 0);
   if (dirty && !composerDraftHasUserContent(store.getComposerDraft(input.threadTarget))) {
     store.moveComposerPromptAndImages(input.editTarget, input.threadTarget);
+    // A new composer draft keeps the edited content, not IDs belonging to the old queued message.
+    store.setQueuedMessageEdit(input.editTarget, undefined);
     return "kept";
   }
   store.clearComposerContent(input.editTarget);
diff --git a/apps/web/src/components/chat/useQueuedRunEdit.browser.test.tsx b/apps/web/src/components/chat/useQueuedRunEdit.browser.test.tsx
new file mode 100644
index 0000000000000..0cb4a5cea8ac7
--- /dev/null
+++ b/apps/web/src/components/chat/useQueuedRunEdit.browser.test.tsx
@@ -0,0 +1,329 @@
+import { EnvironmentId, MessageId, RunId, ThreadId } from "@t3tools/contracts";
+import { scopedThreadKey, scopeThreadRef } from "@t3tools/client-runtime/environment";
+import { ATTACHMENT_ONLY_BOOTSTRAP_PROMPT } from "@t3tools/shared/composerContextReferences";
+import { useRef } from "react";
+import { expect, it, vi } from "vite-plus/test";
+import { render } from "../../../test/render";
+import {
+  partializeComposerDraftStoreState,
+  DraftId,
+  useComposerDraftStore,
+  useComposerThreadDraft,
+} from "../../composerDraftStore";
+import { useQueuedRunEdit } from "./useQueuedRunEdit";
+
+const commands = vi.hoisted(() => ({
+  save: vi.fn(async (_input: unknown) => ({ _tag: "Success" })),
+}));
+vi.mock(import("../../state/use-atom-command"), () => ({
+  useAtomCommand: (() => commands.save) as never,
+}));
+vi.mock(import("../../assets/assetUrls"), () => ({ useAssetUrls: () => [] }));
+
+function Editor({
+  text = "Original message",
+  queueState = null,
+  threadIsLive = true,
+}: {
+  readonly text?: string;
+  readonly queueState?: "queued" | "running" | "missing" | null;
+  readonly threadIsLive?: boolean;
+}) {
+  const environmentId = EnvironmentId.make("environment:queue-edit");
+  const threadId = ThreadId.make("thread:queue-edit");
+  const threadRef = scopeThreadRef(environmentId, threadId);
+  const promptRef = useRef("");
+  const edit = useQueuedRunEdit({
+    environmentId,
+    routeThreadRef: threadRef,
+    threadDraftTarget: threadRef,
+    activeThreadId: threadId,
+    threadIsLive,
+    // This hook only reads run membership and message context from the projection.
+    serverProjection:
+      queueState === null
+        ? null
+        : ({
+            runs:
+              queueState === "missing"
+                ? []
+                : [{ id: RunId.make("run:queued"), status: queueState }],
+            messages: [],
+          } as unknown as NonNullable<Parameters<typeof useQueuedRunEdit>[0]["serverProjection"]>),
+    promptRef,
+    composerRef: { current: null },
+  });
+  const draft = useComposerThreadDraft(edit.draftTarget);
+  return (
+    <>
+      <button
+        onClick={() =>
+          edit.beginEdit({
+            runId: RunId.make("run:queued"),
+            messageId: MessageId.make("message:queued"),
+            text,
+            attachments: [
+              {
+                type: "file",
+                id: "file:report",
+                name: "report.pdf",
+                mimeType: "application/pdf",
+                sizeBytes: 6,
+              },
+            ],
+          })
+        }
+      >
+        Edit queued message
+      </button>
+      <textarea
+        aria-label="Message"
+        value={draft.prompt}
+        onChange={(event) =>
+          useComposerDraftStore.getState().setPrompt(edit.draftTarget, event.target.value)
+        }
+      />
+      {edit.editingAttachments?.map(({ attachment }) => (
+        <button key={attachment.id} onClick={() => edit.removeEditingAttachment(attachment.id)}>
+          Remove {attachment.name}
+        </button>
+      ))}
+      <button onClick={edit.cancelEdit}>Cancel edit</button>
+      <button onClick={() => edit.saveEdit(draft, () => undefined)}>Save edit</button>
+    </>
+  );
+}
+
+function setup() {
+  commands.save.mockClear();
+  useComposerDraftStore.setState({ draftsByThreadKey: {}, draftThreadsByThreadKey: {} });
+}
+
+it.each(["Updated message", ""])(
+  "restores the unsaved edit %j and attachment removals after leaving the thread",
+  async (text) => {
+    setup();
+    // Navigation is simulated by rerendering, without route consumers.
+    await using screen = await render(<Editor />, { router: false });
+    await screen.getByRole("textbox", { name: "Message" }).fill("Separate draft");
+    await screen.getByRole("button", { name: "Edit queued message" }).click();
+    await screen.getByRole("textbox", { name: "Message" }).fill(text);
+    await screen.getByRole("button", { name: "Remove report.pdf" }).click();
+    await screen.rerender(<div>Another thread</div>);
+    const persisted = JSON.parse(
+      JSON.stringify(partializeComposerDraftStoreState(useComposerDraftStore.getState())),
+    );
+    useComposerDraftStore.setState(
+      useComposerDraftStore.persist.getOptions().merge!(
+        persisted,
+        useComposerDraftStore.getInitialState(),
+      ),
+    );
+    await screen.rerender(<Editor />);
+    await screen.getByRole("button", { name: "Edit queued message" }).click();
+    await expect.element(screen.getByRole("textbox", { name: "Message" })).toHaveValue(text);
+    await expect
+      .element(screen.getByRole("button", { name: "Remove report.pdf" }))
+      .not.toBeInTheDocument();
+    if (text) {
+      await screen.getByRole("button", { name: "Save edit" }).click();
+      await vi.waitFor(() =>
+        expect(commands.save).toHaveBeenCalledWith(
+          expect.objectContaining({
+            input: expect.objectContaining({
+              text,
+              edit: expect.objectContaining({ attachments: [] }),
+            }),
+          }),
+        ),
+      );
+    } else {
+      await screen.getByRole("button", { name: "Cancel edit" }).click();
+    }
+    await expect
+      .element(screen.getByRole("textbox", { name: "Message" }))
+      .toHaveValue("Separate draft");
+    await screen.getByRole("button", { name: "Edit queued message" }).click();
+    await expect
+      .element(screen.getByRole("textbox", { name: "Message" }))
+      .toHaveValue("Original message");
+    await expect.element(screen.getByRole("button", { name: "Remove report.pdf" })).toBeVisible();
+  },
+);
+
+it("saves an empty restored edit that keeps its attachment", async () => {
+  setup();
+  // Navigation is simulated by rerendering, without route consumers.
+  await using screen = await render(<Editor />, { router: false });
+  await screen.getByRole("button", { name: "Edit queued message" }).click();
+  await screen.getByRole("textbox", { name: "Message" }).fill("");
+  await screen.rerender(<div>Another thread</div>);
+  const persisted = JSON.parse(
+    JSON.stringify(partializeComposerDraftStoreState(useComposerDraftStore.getState())),
+  );
+  useComposerDraftStore.setState(
+    useComposerDraftStore.persist.getOptions().merge!(
+      persisted,
+      useComposerDraftStore.getInitialState(),
+    ),
+  );
+  await screen.rerender(<Editor />);
+  await screen.getByRole("button", { name: "Edit queued message" }).click();
+  await expect.element(screen.getByRole("textbox", { name: "Message" })).toHaveValue("");
+  await expect.element(screen.getByRole("button", { name: "Remove report.pdf" })).toBeVisible();
+  await screen.getByRole("button", { name: "Save edit" }).click();
+  await vi.waitFor(() =>
+    expect(commands.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        input: expect.objectContaining({
+          text: ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
+          edit: expect.objectContaining({ attachments: [expect.anything()] }),
+        }),
+      }),
+    ),
+  );
+});
+
+it("reopens an untouched edit with the queued message saved by another client", async () => {
+  setup();
+  // Navigation is simulated by rerendering, without route consumers.
+  await using screen = await render(<Editor />, { router: false });
+  await screen.getByRole("button", { name: "Edit queued message" }).click();
+  await screen.rerender(<div>Another thread</div>);
+  await screen.rerender(<Editor text="Updated message" />);
+  await screen.getByRole("button", { name: "Edit queued message" }).click();
+  await expect
+    .element(screen.getByRole("textbox", { name: "Message" }))
+    .toHaveValue("Updated message");
+});
+
+it.each(["running", "missing"] as const)(
+  "recovers a retained edit when its run became %s while the user was away",
+  async (queueState) => {
+    setup();
+    // Navigation is simulated by rerendering, without route consumers.
+    await using screen = await render(<Editor />, { router: false });
+    await screen.getByRole("button", { name: "Edit queued message" }).click();
+    await screen.getByRole("textbox", { name: "Message" }).fill("Keep this unsaved edit");
+    await screen.rerender(<div>Another thread</div>);
+    await screen.rerender(<Editor />);
+    await expect.element(screen.getByRole("textbox", { name: "Message" })).toHaveValue("");
+    await screen.rerender(<Editor queueState={queueState} />);
+    await expect
+      .element(screen.getByRole("textbox", { name: "Message" }))
+      .toHaveValue("Keep this unsaved edit");
+  },
+);
+
+it("keeps a separate composer draft and leaves other threads' retained edits alone", async () => {
+  setup();
+  const otherRef = scopeThreadRef(
+    EnvironmentId.make("environment:queue-edit"),
+    ThreadId.make("thread:other"),
+  );
+  const otherTarget = DraftId.make(`queued-edit:${scopedThreadKey(otherRef)}:run:other`);
+  const store = useComposerDraftStore.getState();
+  store.setPrompt(otherTarget, "Other thread edit");
+  store.setQueuedMessageEdit(otherTarget, {
+    messageId: MessageId.make("message:other"),
+    originalText: "Original",
+    removedAttachmentIds: [],
+  });
+  // Navigation is simulated by rerendering, without route consumers.
+  await using screen = await render(<Editor />, { router: false });
+  await screen.getByRole("textbox", { name: "Message" }).fill("Separate draft");
+  await screen.getByRole("button", { name: "Edit queued message" }).click();
+  await screen.getByRole("textbox", { name: "Message" }).fill("Unsaved edit");
+  await screen.rerender(<div>Another thread</div>);
+  await screen.rerender(<Editor queueState="running" />);
+  await expect
+    .element(screen.getByRole("textbox", { name: "Message" }))
+    .toHaveValue("Separate draft");
+  const editRef = scopeThreadRef(
+    EnvironmentId.make("environment:queue-edit"),
+    ThreadId.make("thread:queue-edit"),
+  );
+  expect(
+    store.getComposerDraft(DraftId.make(`queued-edit:${scopedThreadKey(editRef)}:run:queued`)),
+  ).toBeNull();
+  expect(store.getComposerDraft(otherTarget)?.prompt).toBe("Other thread edit");
+});
+
+it("retains the edit while its run is still queued", async () => {
+  setup();
+  // Navigation is simulated by rerendering, without route consumers.
+  await using screen = await render(<Editor queueState="queued" />, { router: false });
+  await screen.getByRole("button", { name: "Edit queued message" }).click();
+  await screen.getByRole("textbox", { name: "Message" }).fill("Still queued");
+  await screen.rerender(<div>Another thread</div>);
+  await screen.rerender(<Editor queueState="queued" />);
+  await expect.element(screen.getByRole("textbox", { name: "Message" })).toHaveValue("");
+  await screen.getByRole("button", { name: "Edit queued message" }).click();
+  await expect
+    .element(screen.getByRole("textbox", { name: "Message" }))
+    .toHaveValue("Still queued");
+});
+
+it.each(["missing", "running"] as const)(
+  "does not recover a retained edit from a stale %s projection before synchronization",
+  async (queueState) => {
+    setup();
+    // Navigation is simulated by rerendering, without route consumers.
+    await using screen = await render(<Editor />, { router: false });
+    await screen.getByRole("button", { name: "Edit queued message" }).click();
+    await screen.getByRole("textbox", { name: "Message" }).fill("Keep the queued edit");
+    await screen.rerender(<div>Another thread</div>);
+    await screen.rerender(<Editor queueState={queueState} threadIsLive={false} />);
+    await expect.element(screen.getByRole("textbox", { name: "Message" })).toHaveValue("");
+    const ref = scopeThreadRef(
+      EnvironmentId.make("environment:queue-edit"),
+      ThreadId.make("thread:queue-edit"),
+    );
+    await vi.waitFor(() =>
+      expect(
+        useComposerDraftStore
+          .getState()
+          .getComposerDraft(DraftId.make(`queued-edit:${scopedThreadKey(ref)}:run:queued`))?.prompt,
+      ).toBe("Keep the queued edit"),
+    );
+    await screen.rerender(<Editor queueState="queued" />);
+    await screen.getByRole("button", { name: "Edit queued message" }).click();
+    await expect
+      .element(screen.getByRole("textbox", { name: "Message" }))
+      .toHaveValue("Keep the queued edit");
+  },
+);
+
+it("recovers an expired edit only after the cached projection becomes live", async () => {
+  setup();
+  // Navigation is simulated by rerendering, without route consumers.
+  await using screen = await render(<Editor />, { router: false });
+  await screen.getByRole("button", { name: "Edit queued message" }).click();
+  await screen.getByRole("textbox", { name: "Message" }).fill("Recover after sync");
+  await screen.rerender(<div>Another thread</div>);
+  await screen.rerender(<Editor queueState="missing" threadIsLive={false} />);
+  await expect.element(screen.getByRole("textbox", { name: "Message" })).toHaveValue("");
+  await screen.rerender(<Editor queueState="missing" />);
+  await expect
+    .element(screen.getByRole("textbox", { name: "Message" }))
+    .toHaveValue("Recover after sync");
+});
+
+it("does not copy an untouched queued message back into the composer", async () => {
+  setup();
+  // Navigation is simulated by rerendering, without route consumers.
+  await using screen = await render(<Editor />, { router: false });
+  await screen.getByRole("button", { name: "Edit queued message" }).click();
+  await screen.rerender(<div>Another thread</div>);
+  await screen.rerender(<Editor queueState="running" />);
+  await expect.element(screen.getByRole("textbox", { name: "Message" })).toHaveValue("");
+  const ref = scopeThreadRef(
+    EnvironmentId.make("environment:queue-edit"),
+    ThreadId.make("thread:queue-edit"),
+  );
+  expect(
+    useComposerDraftStore
+      .getState()
+      .getComposerDraft(DraftId.make(`queued-edit:${scopedThreadKey(ref)}:run:queued`)),
+  ).toBeNull();
+});
diff --git a/apps/web/src/components/chat/useQueuedRunEdit.ts b/apps/web/src/components/chat/useQueuedRunEdit.ts
index 4ac1af47bf3c6..d5b69580edbef 100644
--- a/apps/web/src/components/chat/useQueuedRunEdit.ts
+++ b/apps/web/src/components/chat/useQueuedRunEdit.ts
@@ -16,6 +16,7 @@ import { ATTACHMENT_ONLY_BOOTSTRAP_PROMPT } from "@t3tools/shared/composerContex
 import { useEffect, useRef, useState, type RefObject } from "react";
 import { useAssetUrls } from "../../assets/assetUrls";
 import {
+  composerDraftHasUserContent,
   DraftId,
   useComposerDraftStore,
   type ComposerFileAttachment,
@@ -168,6 +169,7 @@ export function useQueuedRunEdit(input: {
   readonly environmentId: EnvironmentId;
   readonly routeThreadRef: ScopedThreadRef;
   readonly threadDraftTarget: ComposerThreadTarget;
+  readonly threadIsLive: boolean;
   // Null while the route has no thread yet; an edit needs one to target.
   readonly activeThreadId: ThreadId | null;
   readonly serverProjection: ThreadStructure | null;
@@ -178,6 +180,7 @@ export function useQueuedRunEdit(input: {
     environmentId,
     routeThreadRef,
     threadDraftTarget,
+    threadIsLive,
     activeThreadId,
     serverProjection,
     promptRef,
@@ -219,17 +222,34 @@ export function useQueuedRunEdit(input: {
 
   const beginEdit = useStableCallback((request: EditQueuedRunRequest) => {
     if (activeThreadId === null) return;
-    if (editing !== null && editing.runId !== request.runId) clearEditDraft(editing.runId);
     const target = queuedEditDraftTarget(routeThreadRef, request.runId);
     const store = useComposerDraftStore.getState();
-    store.clearComposerContent(target);
-    store.setPrompt(target, request.text);
+    const savedDraft = store.getComposerDraft(target);
+    const savedEdit = savedDraft?.queuedMessageEdit;
+    // An untouched draft reseeds, so it never restores text another client replaced.
+    const savedEditIsDirty =
+      savedDraft !== null &&
+      savedEdit !== undefined &&
+      (savedDraft.prompt !== savedEdit.originalText ||
+        savedEdit.removedAttachmentIds.length > 0 ||
+        composerDraftHasUserContent({ ...savedDraft, prompt: "" }));
+    const edit =
+      savedEdit?.messageId === request.messageId && savedEditIsDirty
+        ? savedEdit
+        : { messageId: request.messageId, originalText: request.text, removedAttachmentIds: [] };
+    if (edit !== savedEdit) {
+      store.clearComposerContent(target);
+      store.setQueuedMessageEdit(target, edit);
+      store.setPrompt(target, request.text);
+    }
     setEditing({
       threadId: activeThreadId,
       runId: request.runId,
       messageId: request.messageId,
-      originalText: request.text,
-      existingAttachments: request.attachments,
+      originalText: edit.originalText,
+      existingAttachments: request.attachments.filter(
+        (attachment) => !edit.removedAttachmentIds.includes(attachment.id),
+      ),
       context: serverProjection?.messages.find((message) => message.id === request.messageId)
         ?.context,
     });
@@ -242,6 +262,14 @@ export function useQueuedRunEdit(input: {
     focusComposerSoon();
   });
   const removeEditingAttachment = useStableCallback((attachmentId: string) => {
+    if (editing === null) return;
+    const store = useComposerDraftStore.getState();
+    const draft = store.getComposerDraft(draftTarget)?.queuedMessageEdit;
+    if (draft)
+      store.setQueuedMessageEdit(draftTarget, {
+        ...draft,
+        removedAttachmentIds: [...draft.removedAttachmentIds, attachmentId],
+      });
     setEditing((current) =>
       current === null
         ? current
@@ -254,34 +282,45 @@ export function useQueuedRunEdit(input: {
     );
   });
 
-  // Exit edit mode when the edited run leaves the queue (it started, or was
-  // cancelled from another client). A dirty edit moves into the thread's own
-  // draft when that draft is empty; otherwise it is dropped with a toast.
+  // Recover retained edits too: their run may have left the queue while this
+  // thread was unmounted. A dirty edit uses the same keep-or-discard path.
+  const runs = serverProjection?.runs;
   useEffect(() => {
-    if (editing === null || activeThreadId !== editing.threadId) return;
-    if (serverProjection === null) return;
-    const run = serverProjection.runs.find((candidate) => candidate.id === editing.runId);
-    if (run !== undefined && run.status === "queued") return;
-    const recovery = recoverQueuedMessageEdit({
-      editTarget: queuedEditDraftTarget(routeThreadRef, editing.runId),
-      threadTarget: threadDraftTarget,
-      originalText: editing.originalText,
-    });
-    if (recovery !== "clean") {
-      toastManager.add(
-        stackedThreadToast({
-          type: recovery === "kept" ? "info" : "warning",
-          title: "Queued message is no longer queued",
-          description:
-            recovery === "kept"
-              ? "Your unsaved edit was kept in the composer."
-              : "Your unsaved edit was discarded.",
-        }),
-      );
+    if (!threadIsLive || activeThreadId === null || runs === undefined) return;
+    const prefix = `queued-edit:${scopedThreadKey(routeThreadRef)}:`;
+    const queuedTargets = new Set(
+      runs
+        .filter((run) => run.status === "queued")
+        .map((run) => queuedEditDraftTarget(routeThreadRef, run.id)),
+    );
+    const drafts = useComposerDraftStore.getState().draftsByThreadKey;
+    for (const [key, draft] of Object.entries(drafts)) {
+      if (!key.startsWith(prefix) || draft.queuedMessageEdit === undefined) continue;
+      const editTarget = DraftId.make(key);
+      if (queuedTargets.has(editTarget)) continue;
+      const recovery = recoverQueuedMessageEdit({
+        editTarget,
+        threadTarget: threadDraftTarget,
+        originalText: draft.queuedMessageEdit.originalText,
+      });
+      if (recovery !== "clean") {
+        toastManager.add(
+          stackedThreadToast({
+            type: recovery === "kept" ? "info" : "warning",
+            title: "Queued message is no longer queued",
+            description:
+              recovery === "kept"
+                ? "Your unsaved edit was kept in the composer."
+                : "Your unsaved edit was discarded.",
+          }),
+        );
+      }
+      if (editing !== null && editTarget === queuedEditDraftTarget(routeThreadRef, editing.runId)) {
+        // oxlint-disable-next-line react/set-state-in-effect -- Leaving edit mode follows recovery and its notification after commit.
+        setEditing(null);
+      }
     }
-    // oxlint-disable-next-line react/set-state-in-effect -- Leaving edit mode follows the draft recovery and toast above, which must run once after commit.
-    setEditing(null);
-  }, [activeThreadId, editing, routeThreadRef, serverProjection, threadDraftTarget]);
+  }, [activeThreadId, editing, routeThreadRef, runs, threadDraftTarget, threadIsLive]);
 
   /**
    * Saves the composer content into the queued message being edited. Reports
diff --git a/apps/web/src/composerDraftStore.ts b/apps/web/src/composerDraftStore.ts
index 57ffde65949ff..aa1da0c85c0f3 100644
--- a/apps/web/src/composerDraftStore.ts
+++ b/apps/web/src/composerDraftStore.ts
@@ -6,6 +6,7 @@ import {
   DEFAULT_MODEL_BY_PROVIDER,
   defaultInstanceIdForDriver,
   EnvironmentId,
+  MessageId,
   ModelSelection,
   ProjectId,
   ProviderInstanceId,
@@ -233,8 +234,17 @@ const PersistedTerminalContextDraft = Schema.Struct({
 });
 type PersistedTerminalContextDraft = typeof PersistedTerminalContextDraft.Type;
 
+const QueuedMessageEditDraft = Schema.Struct({
+  messageId: MessageId,
+  originalText: Schema.String,
+  removedAttachmentIds: Schema.Array(Schema.String),
+});
+type QueuedMessageEditDraft = typeof QueuedMessageEditDraft.Type;
+const isQueuedMessageEditDraft = Schema.is(QueuedMessageEditDraft);
+
 const PersistedComposerThreadDraftState = Schema.Struct({
   prompt: Schema.String,
+  queuedMessageEdit: Schema.optionalKey(QueuedMessageEditDraft),
   attachments: Schema.Array(PersistedComposerImageAttachment),
   files: Schema.optionalKey(Schema.Array(PersistedComposerDraftFileAttachment)),
   terminalContexts: Schema.optionalKey(Schema.Array(PersistedTerminalContextDraft)),
@@ -360,6 +370,7 @@ const contextInsertionHandlers = new Map<string, ComposerContextInsertionHandler
 
 export interface ComposerThreadDraftState {
   prompt: string;
+  queuedMessageEdit?: QueuedMessageEditDraft | undefined;
   images: ComposerImageAttachment[];
   files: ComposerFileAttachment[];
   nonPersistedImageIds: string[];
@@ -499,6 +510,10 @@ interface ComposerDraftStoreState {
   clearDraftThread: (threadRef: ComposerThreadTarget) => void;
   setStickyModelSelection: (modelSelection: ModelSelection | null | undefined) => void;
   setPrompt: (threadRef: ComposerThreadTarget, prompt: string) => void;
+  setQueuedMessageEdit: (
+    threadRef: ComposerThreadTarget,
+    edit: QueuedMessageEditDraft | undefined,
+  ) => void;
   setTerminalContexts: (threadRef: ComposerThreadTarget, contexts: TerminalContextDraft[]) => void;
   setModelSelection: (
     threadRef: ComposerThreadTarget,
@@ -866,6 +881,7 @@ function normalizeTerminalContextsForThread(
 
 function shouldRemoveDraft(draft: ComposerThreadDraftState): boolean {
   return (
+    draft.queuedMessageEdit === undefined &&
     draft.prompt.length === 0 &&
     draft.images.length === 0 &&
     draft.files.length === 0 &&
@@ -1761,6 +1777,12 @@ function normalizePersistedDraftsByThreadId(
       continue;
     }
     const draftCandidate = draftValue as PersistedComposerThreadDraftState;
+    const queuedMessageEdit = isQueuedMessageEditDraft(draftCandidate.queuedMessageEdit)
+      ? {
+          ...draftCandidate.queuedMessageEdit,
+          removedAttachmentIds: [...draftCandidate.queuedMessageEdit.removedAttachmentIds],
+        }
+      : undefined;
     const promptCandidate = typeof draftCandidate.prompt === "string" ? draftCandidate.prompt : "";
     const attachments = Array.isArray(draftCandidate.attachments)
       ? draftCandidate.attachments.flatMap((entry) => {
@@ -1893,6 +1915,7 @@ function normalizePersistedDraftsByThreadId(
       Object.keys(modelSelectionByProvider).length > 0 || activeProvider !== null;
     if (
       promptCandidate.length === 0 &&
+      queuedMessageEdit === undefined &&
       attachments.length === 0 &&
       files.length === 0 &&
       terminalContexts.length === 0 &&
@@ -1919,6 +1942,7 @@ function normalizePersistedDraftsByThreadId(
             })();
     nextDraftsByThreadKey[normalizedThreadKey] = {
       prompt,
+      ...(queuedMessageEdit ? { queuedMessageEdit } : {}),
       attachments,
       ...(files.length > 0 ? { files } : {}),
       ...(terminalContexts.length > 0 ? { terminalContexts } : {}),
@@ -2021,6 +2045,7 @@ export function partializeComposerDraftStoreState(
       Object.keys(draft.modelSelectionByProvider).length > 0 || draft.activeProvider !== null;
     if (
       draft.prompt.length === 0 &&
+      draft.queuedMessageEdit === undefined &&
       draft.persistedAttachments.length === 0 &&
       draft.files.length === 0 &&
       draft.terminalContexts.length === 0 &&
@@ -2035,6 +2060,14 @@ export function partializeComposerDraftStoreState(
     }
     const persistedDraft: DeepMutable<PersistedComposerThreadDraftState> = {
       prompt: draft.prompt,
+      ...(draft.queuedMessageEdit
+        ? {
+            queuedMessageEdit: {
+              ...draft.queuedMessageEdit,
+              removedAttachmentIds: [...draft.queuedMessageEdit.removedAttachmentIds],
+            },
+          }
+        : {}),
       attachments: draft.persistedAttachments,
       ...(draft.files.length > 0
         ? {
@@ -2344,6 +2377,9 @@ function toHydratedThreadDraft(
       ...files.map(fileContextReference),
     ]),
     images: hydrateImagesFromPersisted(persistedDraft.attachments),
+    ...(persistedDraft.queuedMessageEdit
+      ? { queuedMessageEdit: persistedDraft.queuedMessageEdit }
+      : {}),
     files,
     nonPersistedImageIds: [],
     persistedAttachments: [...persistedDraft.attachments],
@@ -2867,6 +2903,18 @@ const composerDraftStore = create<ComposerDraftStoreState>()(
             return { draftsByThreadKey: nextDraftsByThreadKey };
           });
         },
+        setQueuedMessageEdit: (threadRef, queuedMessageEdit) => {
+          const threadKey = resolveComposerDraftKey(get(), threadRef);
+          if (!threadKey) return;
+          set((state) => {
+            const existing = state.draftsByThreadKey[threadKey] ?? createEmptyThreadDraft();
+            const nextDraft = { ...existing, queuedMessageEdit };
+            const draftsByThreadKey = { ...state.draftsByThreadKey };
+            if (shouldRemoveDraft(nextDraft)) delete draftsByThreadKey[threadKey];
+            else draftsByThreadKey[threadKey] = nextDraft;
+            return { draftsByThreadKey };
+          });
+        },
         setPrompt: (threadRef, prompt) => {
           const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
           if (threadKey.length === 0) {
@@ -3950,6 +3998,7 @@ const composerDraftStore = create<ComposerDraftStoreState>()(
             }
             const nextDraft: ComposerThreadDraftState = {
               ...current,
+              queuedMessageEdit: undefined,
               prompt: "",
               images: [],
               files: [],