diff --git a/apps/mobile/src/features/threads/ComposerQueuedEdit.tsx b/apps/mobile/src/features/threads/ComposerQueuedEdit.tsx
index 3263a3af35602..028129d1e3180 100644
--- a/apps/mobile/src/features/threads/ComposerQueuedEdit.tsx
+++ b/apps/mobile/src/features/threads/ComposerQueuedEdit.tsx
@@ -1,12 +1,8 @@
 import { Button } from "../../components/ui/Button";
-import type { ChatAttachment, EnvironmentId } from "@t3tools/contracts";
-import { Image } from "expo-image";
-import { Pressable, ScrollView, View } from "react-native";
+import { View } from "react-native";
 
 import { AppText as Text } from "../../components/ui/AppText";
 import { SymbolView } from "../../components/ui/AppSymbol";
-import { useAssetUrl } from "../../state/assets";
-import { assetImageSource } from "../../lib/assetImageSource";
 
 export function ComposerQueuedEditBanner(props: {
   readonly saving: boolean;
@@ -28,84 +24,3 @@ export function ComposerQueuedEditBanner(props: {
     </View>
   );
 }
-
-export function ComposerQueuedEditAttachments(props: {
-  readonly environmentId: EnvironmentId;
-  readonly attachments: ReadonlyArray<ChatAttachment>;
-  readonly disabled: boolean;
-  readonly onRemove: (attachmentId: string) => void;
-}) {
-  if (props.attachments.length === 0) return null;
-  return (
-    <ScrollView
-      horizontal
-      showsHorizontalScrollIndicator={false}
-      keyboardShouldPersistTaps="always"
-      className="grow-0"
-      contentContainerClassName="flex-row items-center gap-2"
-    >
-      {props.attachments.map((attachment) => (
-        <QueuedEditAttachmentChip
-          key={attachment.id}
-          environmentId={props.environmentId}
-          attachment={attachment}
-          disabled={props.disabled}
-          onRemove={props.onRemove}
-        />
-      ))}
-    </ScrollView>
-  );
-}
-
-function QueuedEditAttachmentChip(props: {
-  readonly environmentId: EnvironmentId;
-  readonly attachment: ChatAttachment;
-  readonly disabled: boolean;
-  readonly onRemove: (attachmentId: string) => void;
-}) {
-  const { attachment } = props;
-  const isImage = attachment.mimeType.startsWith("image/");
-  const resource = {
-    _tag: "attachment",
-    attachmentId: attachment.id,
-    fileName: attachment.name,
-    mimeType: attachment.mimeType,
-    disposition: "inline",
-  } as const;
-  const url = useAssetUrl(props.environmentId, isImage ? resource : null);
-
-  return (
-    <View className="max-w-[180px] flex-row items-center gap-2 rounded-xl border border-border bg-card py-1 pl-1 pr-2">
-      {isImage && url !== null ? (
-        <Image
-          source={assetImageSource(props.environmentId, resource, url)}
-          cachePolicy="memory-disk"
-          contentFit="cover"
-          style={{ width: 24, height: 24, borderRadius: 6 }}
-          accessibilityIgnoresInvertColors
-        />
-      ) : (
-        <View className="h-6 w-6 items-center justify-center rounded-md bg-subtle">
-          <SymbolView
-            name={isImage ? "photo" : "doc"}
-            size={12}
-            tintColorClassName="accent-icon-subtle"
-          />
-        </View>
-      )}
-      <Text className="min-w-0 shrink text-xs text-foreground" numberOfLines={1}>
-        {attachment.name}
-      </Text>
-      <Pressable
-        accessibilityRole="button"
-        accessibilityLabel={`Remove ${attachment.name}`}
-        disabled={props.disabled}
-        hitSlop={8}
-        onPress={() => props.onRemove(attachment.id)}
-        className="active:opacity-70 disabled:opacity-40"
-      >
-        <SymbolView name="xmark.circle.fill" size={14} tintColorClassName="accent-icon-subtle" />
-      </Pressable>
-    </View>
-  );
-}
diff --git a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
index 2bc26707324e2..cb8e76a307a43 100644
--- a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
+++ b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
@@ -997,12 +997,14 @@ export function NewTaskDraftScreen(props: {
         activeThreadBusy={false}
         canStopThread={false}
         queuedRunEdit={null}
+        savedQueuedEditDrafts={[]}
+        recoveryDraftKey={null}
+        onSelectRecoveryDraft={() => {}}
         composerDraftKey={flow.draftKey}
         followUpBehavior="queue"
         canSteerActiveTurn={false}
         isSavingQueuedEdit={false}
         onCancelQueuedRunEdit={() => {}}
-        onRemoveQueuedEditAttachment={() => {}}
         projectWorkspaceRoot={selectedProject.workspaceRoot}
         threadCwd={composerWorkspaceCwd}
         selectedThreadQueueCount={0}
diff --git a/apps/mobile/src/features/threads/ThreadComposer.tsx b/apps/mobile/src/features/threads/ThreadComposer.tsx
index e36900736e8e2..582e9b9fcb5e3 100644
--- a/apps/mobile/src/features/threads/ThreadComposer.tsx
+++ b/apps/mobile/src/features/threads/ThreadComposer.tsx
@@ -17,7 +17,6 @@ import { pastedTextDisposition, replaceTextSelection } from "@t3tools/client-run
 import {
   PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
   PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
-  type ChatAttachment,
   type EnvironmentId,
   type MessageId,
   type ModelSelection,
@@ -100,7 +99,6 @@ import {
 import { compactEditorInsets } from "./compactEditorInsets";
 import { ComposerCommandPopover } from "./ComposerCommandPopover";
 import { ComposerPopoverAnchor } from "./ComposerPopoverAnchor";
-import { ComposerQueuedEditAttachments } from "./ComposerQueuedEdit";
 import { useComposerCommandMenu } from "./use-composer-command-menu";
 import type { ComposerEnvironmentCandidate } from "@t3tools/client-runtime/composerThreadItems";
 import { offersLinkedEnvironments } from "@t3tools/client-runtime/link-request";
@@ -228,9 +226,7 @@ export interface ThreadComposerProps {
   readonly interactionLocked?: boolean;
   readonly draftKey?: string;
   readonly queuedEdit?: {
-    readonly existingAttachments: ReadonlyArray<ChatAttachment>;
     readonly saving: boolean;
-    readonly onRemoveExistingAttachment: (attachmentId: string) => void;
   } | null;
   readonly followUpBehavior: FollowUpBehavior;
   readonly canSteerActiveTurn: boolean;
@@ -452,10 +448,7 @@ export const ThreadComposer = function ThreadComposer(props: ThreadComposerProps
   const composerDraftKey = props.draftKey ?? composerOwnerKey;
   const { text: draftMessage, attachments: draftAttachments } = useComposerDraft(composerDraftKey);
   const queuedEdit = props.queuedEdit ?? null;
-  const hasContent =
-    draftMessage.trim().length > 0 ||
-    draftAttachments.length > 0 ||
-    (queuedEdit?.existingAttachments.length ?? 0) > 0;
+  const hasContent = draftMessage.trim().length > 0 || draftAttachments.length > 0;
   const stripAttachments = composerStripAttachments(draftAttachments);
   const showStopAction = !hasContent && props.canStopThread && queuedEdit === null;
   const onResumeQueue = props.onResumeQueue;
@@ -599,9 +592,7 @@ export const ThreadComposer = function ThreadComposer(props: ThreadComposerProps
   const compactEditor = useCompactComposerEditor(bodyText, draftMessage);
   const showsCompactDictation = isVoiceInputPresented;
   const isToolbarVisible = isVoiceInputPresented;
-  const hasEditingAttachments =
-    (queuedEdit !== null && queuedEdit.existingAttachments.length > 0) ||
-    stripAttachments.length > 0;
+  const hasEditingAttachments = stripAttachments.length > 0;
   const attachmentBlockReason = composerAttachmentUploadBlockReason({
     environmentId: props.environmentId,
     attachments: draftAttachments,
@@ -753,20 +744,6 @@ export const ThreadComposer = function ThreadComposer(props: ThreadComposerProps
   // Removable attachments: inside the card, or above the focused one-row composer.
   const editingAttachments = hasEditingAttachments ? (
     <>
-      {queuedEdit !== null && queuedEdit.existingAttachments.length > 0 ? (
-        <Animated.View
-          className="px-[14px] pb-2.5 pt-2"
-          entering={COMPOSER_ATTACHMENT_ENTERING}
-          exiting={FadeOut.duration(120)}
-        >
-          <ComposerQueuedEditAttachments
-            environmentId={props.environmentId}
-            attachments={queuedEdit.existingAttachments}
-            disabled={isSubmissionLocked}
-            onRemove={queuedEdit.onRemoveExistingAttachment}
-          />
-        </Animated.View>
-      ) : null}
       {stripAttachments.length > 0 ? (
         <Animated.View
           className="px-[14px] pb-2.5 pt-2"
diff --git a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
index 72361dd242047..fe17e92b9d01e 100644
--- a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
@@ -1,3 +1,4 @@
+import { Button } from "../../components/ui/Button";
 import { ChildThreadApprovals } from "./ChildThreadApprovals";
 import { useOpenThreadInspector } from "./thread-inspector-navigation";
 import { useSidebarWorkspaceTabs } from "../layout/workspace/useSystemWorkspaceTabBar";
@@ -265,12 +266,14 @@ export interface ThreadDetailScreenProps {
   readonly activeThreadBusy: boolean;
   readonly canStopThread: boolean;
   readonly queuedRunEdit: QueuedRunEdit | null;
+  readonly savedQueuedEditDrafts: ReadonlyArray<string>;
+  readonly recoveryDraftKey: string | null;
+  readonly onSelectRecoveryDraft: (key: string | null) => void;
   readonly composerDraftKey: string | null;
   readonly followUpBehavior: FollowUpBehavior;
   readonly canSteerActiveTurn: boolean;
   readonly isSavingQueuedEdit: boolean;
   readonly onCancelQueuedRunEdit: () => void;
-  readonly onRemoveQueuedEditAttachment: (attachmentId: string) => void;
   readonly environmentId: EnvironmentId;
   readonly projectWorkspaceRoot: string | null;
   readonly threadCwd: string | null;
@@ -1588,6 +1591,29 @@ function ThreadDetailBody(
                 pushes the resting content floor up by the same amount. */}
               <View onLayout={handleComposerOverlayLayout} className="w-full">
                 <View className="w-full self-center" style={{ maxWidth: contentMaxWidth }}>
+                  {props.savedQueuedEditDrafts.length > 0 ? (
+                    <View className="flex-row flex-wrap gap-2 py-1">
+                      {props.recoveryDraftKey !== null ? (
+                        <Button
+                          label="Main draft"
+                          tone="text"
+                          onPress={() => props.onSelectRecoveryDraft(null)}
+                        />
+                      ) : null}
+                      {props.savedQueuedEditDrafts.map((key, index) => (
+                        <Button
+                          key={key}
+                          label={
+                            props.recoveryDraftKey === key
+                              ? "Recovered queued edit"
+                              : `Saved queued edit ${index + 1}`
+                          }
+                          tone="text"
+                          onPress={() => props.onSelectRecoveryDraft(key)}
+                        />
+                      ))}
+                    </View>
+                  ) : null}
                   <FloatingWorkingControl
                     colorScheme={isDarkMode ? "dark" : "light"}
                     status={floatingStatus}
@@ -1895,9 +1921,7 @@ function ThreadDetailBody(
                           props.queuedRunEdit === null
                             ? null
                             : {
-                                existingAttachments: props.queuedRunEdit.existingAttachments,
                                 saving: props.isSavingQueuedEdit,
-                                onRemoveExistingAttachment: props.onRemoveQueuedEditAttachment,
                               }
                         }
                         bottomInset={composerBottomInset}
diff --git a/apps/mobile/src/features/threads/ThreadQueueControl.tsx b/apps/mobile/src/features/threads/ThreadQueueControl.tsx
index 7a3abe625a1ed..ff5c43e9b6199 100644
--- a/apps/mobile/src/features/threads/ThreadQueueControl.tsx
+++ b/apps/mobile/src/features/threads/ThreadQueueControl.tsx
@@ -6,7 +6,15 @@ import {
 } from "@t3tools/client-runtime/queued-run-edit";
 import { scopeThreadRef } from "@t3tools/client-runtime/environment";
 import { resolveUserMessagePresentation } from "@t3tools/client-runtime/user-message";
-import type { ChatAttachment, EnvironmentId, RunId, ThreadId } from "@t3tools/contracts";
+import {
+  ComposerContextId,
+  type ChatAttachment,
+  type ChatImageAttachment,
+  type ChatFileAttachment,
+  type EnvironmentId,
+  type RunId,
+  type ThreadId,
+} from "@t3tools/contracts";
 import { Atom } from "effect/reactivity";
 import { Image } from "expo-image";
 import * as Haptics from "expo-haptics";
@@ -31,7 +39,17 @@ import { useQuietThreadShell } from "../../state/entities";
 import { useEnvironmentQuery } from "../../state/query";
 import { serverEnvironment } from "../../state/server";
 import { assetImageSource } from "../../lib/assetImageSource";
-import { beginQueuedRunEdit, useQueuedRunEdit } from "../../state/queued-run-edit";
+import {
+  prepareQueuedRunEditDraft,
+  restoreQueuedEditAttachments,
+  queuedEditDraftKey,
+  recoverQueuedRunEdit,
+  watchQueuedRunEdit,
+  useQueuedRunEdit,
+} from "../../state/queued-run-edit";
+import { getComposerDraftSnapshot } from "../../state/use-composer-drafts";
+import { importAttachment } from "../../lib/composerContextClipboard";
+import * as Dialog from "../../components/ui/Dialog";
 import { environmentThreadDetails, threadEnvironment } from "../../state/threads";
 import { useAtomCommand } from "../../state/use-atom-command";
 import {
@@ -128,6 +146,11 @@ export function ThreadQueueSheet({ route }: StaticScreenProps<QueueTarget>) {
     openQuestionCount: pendingRequests?.userInputs.length ?? 0,
   });
   const promote = useAtomCommand(threadEnvironment.promoteQueuedRun, "promote queued message");
+  const acquireEdit = useAtomCommand(threadEnvironment.beginQueuedRunEdit, "edit queued message");
+  const releaseEdit = useAtomCommand(threadEnvironment.cancelQueuedRunEdit, "finish queued edit");
+  const releaseFailedPreparation = useAtomCommand(threadEnvironment.cancelQueuedRunEdit, {
+    reportFailure: false,
+  });
   const cancel = useAtomCommand(threadEnvironment.cancelQueuedRun, "remove queued message");
   const resume = useAtomCommand(threadEnvironment.resumeThreadQueue, "resume queue");
   const [resuming, setResuming] = useState(false);
@@ -152,26 +175,143 @@ export function ThreadQueueSheet({ route }: StaticScreenProps<QueueTarget>) {
     if (action === "edit") {
       if (editBlockedReason !== null) return;
       const entry = queuedRuns[index]!;
-      void Haptics.selectionAsync();
-      beginQueuedRunEdit(
-        threadKey,
-        {
-          runId,
-          messageId: entry.messageId,
-          originalText: entry.text,
-          existingAttachments: entry.attachments,
-          ...(entry.context ? { context: entry.context } : {}),
-        },
-        makeQueuedRunsAtom({
-          threadId: target.threadId,
-          snapshot: threadEnvironment.snapshotAtom(target.environmentId),
-          detailStatus: environmentThreadDetails.statusAtom(target),
-          runs: Atom.make(
-            (get) => get(environmentThreadDetails.quietThreadAtom(target))?.projection.runs ?? null,
-          ),
-        }),
-      );
-      navigation.goBack();
+      const previousEditId = entry.run.queueEditId ?? null;
+      if (editing?.runId === runId && editing.editId === previousEditId) {
+        navigation.goBack();
+        return;
+      }
+      if (previousEditId !== null) {
+        const confirmed = await new Promise<boolean>((resolve) =>
+          Dialog.confirm({
+            title: "Take over editing?",
+            message:
+              "This message is being edited elsewhere. The other editor will keep their unsaved changes.",
+            confirmText: "Take over",
+            onConfirm: () => resolve(true),
+            onCancel: () => resolve(false),
+          }),
+        );
+        if (!confirmed) return;
+      }
+      busyRef.current = true;
+      setBusyRunId(runId);
+      const openEdit = async () => {
+        if (editing !== null) {
+          const released = await releaseEdit({
+            environmentId: target.environmentId,
+            input: { threadId: target.threadId, runId: editing.runId, editId: editing.editId },
+          });
+          if (released._tag !== "Success") return;
+          recoverQueuedRunEdit(threadKey);
+        }
+        const acquired = await acquireEdit({
+          environmentId: target.environmentId,
+          input: { threadId: target.threadId, runId, previousEditId },
+        });
+        if (acquired._tag !== "Success") return;
+        const preparation = prepareQueuedRunEditDraft(
+          threadKey,
+          {
+            ...acquired.value,
+            runId,
+            messageId: entry.messageId,
+            originalText: entry.text,
+            originalAttachmentIds: entry.attachments.map((attachment) => attachment.id),
+            ...(entry.context ? { context: entry.context } : {}),
+          },
+          async () => {
+            if (
+              entry.attachments.some(
+                (attachment) => attachment.type !== "image" && attachment.type !== "file",
+              )
+            )
+              throw new Error("This attachment cannot be edited.");
+            return await restoreQueuedEditAttachments(
+              entry.attachments
+                .filter(
+                  (attachment): attachment is ChatImageAttachment | ChatFileAttachment =>
+                    attachment.type === "image" || attachment.type === "file",
+                )
+                .map(async (attachment) => {
+                  const local = await importAttachment(
+                    {
+                      version: 1,
+                      kind: attachment.type,
+                      contextId: ComposerContextId.make(attachment.id),
+                      label: attachment.name,
+                      attachmentId: attachment.id,
+                      name: attachment.name,
+                      mimeType: attachment.mimeType,
+                      sizeBytes: attachment.sizeBytes,
+                    },
+                    target.environmentId,
+                    new AbortController().signal,
+                  );
+                  const restored = {
+                    ...local,
+                    id: attachment.id,
+                    uploadedAttachmentId: attachment.id,
+                    uploadEnvironmentId: target.environmentId,
+                  };
+                  if (restored.type === "image" && attachment.type === "image")
+                    return {
+                      ...restored,
+                      ...(attachment.source ? { source: attachment.source } : {}),
+                    };
+                  if (restored.type === "file" && attachment.type === "file")
+                    return {
+                      ...restored,
+                      ...(attachment.source ? { source: attachment.source } : {}),
+                    };
+                  return restored;
+                }),
+            );
+          },
+        );
+        const preparedEdit = getComposerDraftSnapshot(
+          queuedEditDraftKey(threadKey, runId),
+        ).queuedEdit;
+        try {
+          await preparation;
+          watchQueuedRunEdit(
+            threadKey,
+            makeQueuedRunsAtom({
+              threadId: target.threadId,
+              snapshot: threadEnvironment.snapshotAtom(target.environmentId),
+              detailStatus: environmentThreadDetails.statusAtom(target),
+              runs: Atom.make(
+                (get) =>
+                  get(environmentThreadDetails.quietThreadAtom(target))?.projection.runs ?? null,
+              ),
+            }),
+          );
+        } catch (error) {
+          const released = await releaseFailedPreparation({
+            environmentId: target.environmentId,
+            input: { threadId: target.threadId, runId, editId: acquired.value.editId },
+          });
+          if (released._tag === "Success" && preparedEdit?.ownership)
+            recoverQueuedRunEdit(threadKey, preparedEdit);
+          Dialog.alert(
+            "Could not open queued edit",
+            error instanceof Error ? error.message : "Could not restore attachments.",
+          );
+          return;
+        }
+        void Haptics.selectionAsync();
+        navigation.goBack();
+      };
+      await openEdit()
+        .catch((error: unknown) => {
+          Dialog.alert(
+            "Could not open queued edit",
+            error instanceof Error ? error.message : "Please try again.",
+          );
+        })
+        .finally(() => {
+          busyRef.current = false;
+          setBusyRunId(null);
+        });
       return;
     }
     if (action !== "steer" && action !== "remove") return;
@@ -180,9 +320,13 @@ export function ThreadQueueSheet({ route }: StaticScreenProps<QueueTarget>) {
     void Haptics.selectionAsync();
     if (action === "remove") {
       await cancel(buildCancelQueuedRunCommand({ ...target, runId }));
-    } else if (workflow?.canSendNow) {
+    } else if (workflow?.canSendNow && queuedRuns[index]?.run.queueEditId == null) {
       await resume({ ...target, input: { threadId: target.threadId, runId } });
-    } else if (workflow?.activeRun && workflow.canPromoteToSteer) {
+    } else if (
+      workflow?.activeRun &&
+      workflow.canPromoteToSteer &&
+      queuedRuns[index]?.run.queueEditId == null
+    ) {
       await promote({
         ...target,
         input: {
@@ -236,8 +380,9 @@ export function ThreadQueueSheet({ route }: StaticScreenProps<QueueTarget>) {
           // A fresh message starts its own turn: it may skip compaction, but not steer into a turn.
           canPromoteToSteer:
             (workflow?.canPromoteToSteer ?? false) &&
+            run.queueEditId == null &&
             (run.freshContext !== true || workflow?.promoteSkipsCompaction === true),
-          canSendNow: workflow?.canSendNow ?? false,
+          canSendNow: (workflow?.canSendNow ?? false) && run.queueEditId == null,
           editBlocked: editBlockedReason !== null,
           isEditing: editing?.runId === run.id,
           isGuestMessage: context?.guest !== undefined,
@@ -320,9 +465,9 @@ export function ThreadQueueSheet({ route }: StaticScreenProps<QueueTarget>) {
                         {title}
                       </Text>
                     </View>
-                    {controls.isEditing ? (
+                    {controls.isEditing || run.queueEditId != null ? (
                       <Text className="shrink-0 text-2xs uppercase tracking-wide text-primary">
-                        Editing
+                        {controls.isEditing ? "Editing" : "Editing elsewhere"}
                       </Text>
                     ) : null}
                   </Pressable>
diff --git a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
index ab0b5cdb9bd4d..e250c1d62c427 100644
--- a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
@@ -1023,12 +1023,14 @@ function ThreadRouteContent(
           activeThreadBusy={composer.activeThreadBusy}
           canStopThread={awaitingBootstrapTurn || composer.interruptibleRunId !== null}
           queuedRunEdit={composer.queuedRunEdit}
+          savedQueuedEditDrafts={composer.savedQueuedEditDrafts}
+          recoveryDraftKey={composer.recoveryDraftKey}
+          onSelectRecoveryDraft={composer.selectRecoveryDraft}
           composerDraftKey={composer.composerDraftKey}
           followUpBehavior={composer.followUpBehavior}
           canSteerActiveTurn={composer.canSteerActiveTurn}
           isSavingQueuedEdit={composer.isSavingQueuedEdit}
           onCancelQueuedRunEdit={composer.cancelQueuedRunEdit}
-          onRemoveQueuedEditAttachment={composer.onRemoveQueuedEditAttachment}
           environmentId={selectedThread.environmentId}
           projectWorkspaceRoot={selectedThreadProject?.workspaceRoot ?? null}
           threadCwd={selectedThreadCwd}
diff --git a/apps/mobile/src/lib/attachmentUpload.ts b/apps/mobile/src/lib/attachmentUpload.ts
index 57699af22819e..a6ce83cfcf966 100644
--- a/apps/mobile/src/lib/attachmentUpload.ts
+++ b/apps/mobile/src/lib/attachmentUpload.ts
@@ -146,7 +146,7 @@ function uploadedReference(
     sizeBytes: attachment.sizeBytes,
   };
   return isComposerImageAttachment(attachment)
-    ? { type: "image", ...fields }
+    ? { type: "image", ...fields, ...(attachment.source ? { source: attachment.source } : {}) }
     : {
         type: "file",
         ...fields,
diff --git a/apps/mobile/src/lib/composer-image-schema.ts b/apps/mobile/src/lib/composer-image-schema.ts
index b8ccf9b9055c0..5eed9cecb41f1 100644
--- a/apps/mobile/src/lib/composer-image-schema.ts
+++ b/apps/mobile/src/lib/composer-image-schema.ts
@@ -1,5 +1,5 @@
 import * as Schema from "effect/Schema";
-import { EnvironmentId, PastedTextAttachmentSource } from "@t3tools/contracts";
+import { EnvironmentId, PastedTextAttachmentSource, SnapShotSource } from "@t3tools/contracts";
 
 export const DraftComposerImageAttachmentSchema = Schema.Struct({
   id: Schema.String,
@@ -12,6 +12,7 @@ export const DraftComposerImageAttachmentSchema = Schema.Struct({
   dataUrl: Schema.optional(Schema.String.check(Schema.isNonEmpty())),
   uploadedAttachmentId: Schema.optional(Schema.String),
   uploadEnvironmentId: Schema.optional(EnvironmentId),
+  source: Schema.optional(SnapShotSource),
 }).check(
   Schema.makeFilter(
     ({ fileUri, dataUrl }) =>
diff --git a/apps/mobile/src/lib/composerContextClipboard.ts b/apps/mobile/src/lib/composerContextClipboard.ts
index 8c5a31cdb7e44..d15e07308c6ea 100644
--- a/apps/mobile/src/lib/composerContextClipboard.ts
+++ b/apps/mobile/src/lib/composerContextClipboard.ts
@@ -162,7 +162,7 @@ export async function importComposerContextClipboard(
   }
 }
 
-async function importAttachment(
+export async function importAttachment(
   record: Extract<ComposerContextRecord, { attachmentId: string }>,
   environmentId: EnvironmentId,
   signal: AbortSignal,
diff --git a/apps/mobile/src/state/queued-run-edit.test.ts b/apps/mobile/src/state/queued-run-edit.test.ts
index 8a6176c1140c0..8ecf21a7e25ee 100644
--- a/apps/mobile/src/state/queued-run-edit.test.ts
+++ b/apps/mobile/src/state/queued-run-edit.test.ts
@@ -1,35 +1,55 @@
+import {
+  collectComposerContextReferences,
+  formatComposerContextReference,
+} from "@t3tools/shared/composerContextReferences";
 import { describe, expect, it, vi } from "vite-plus/test";
 import { Atom } from "effect/reactivity";
+import { threadComposerErrorsAtom } from "./thread-composer-error";
+vi.mock("../lib/uuid", () => ({ uuidv4: () => "saved-edit" }));
 import {
   ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
   restoreAttachmentOnlyBootstrapPrompt,
 } from "@t3tools/shared/composerContextReferences";
 import {
   ChatAttachmentId,
+  CommandId,
+  EnvironmentId,
   ComposerContextId,
   MessageId,
   RunId,
+  ProviderInstanceId,
   type ChatAttachment,
-  type OrchestrationMessageContext,
 } from "@t3tools/contracts";
 
-import { appAtomRegistry } from "./atom-registry";
+import { composerDraftEnvironmentId } from "../lib/composerAttachmentUploadQueue";
+import { queuedEditDraftKey } from "./queued-edit-draft-key";
 import {
-  activeComposerDraftKey,
   beginQueuedRunEdit,
+  activeComposerDraftKey,
+  watchQueuedRunEdit,
+  startQueuedRunEditSave,
+  prepareQueuedRunEditDraft,
+  restoreQueuedEditAttachments,
+  getQueuedRecoverySendDraft,
+  canReuseQueuedRunEditDraft,
+  recoverQueuedRunEdit,
   getQueuedRunEdit,
-  queuedEditDraftKey,
-  removeQueuedRunEditAttachment,
+  forgetQueuedRunEdit,
+  endQueuedRunEdit,
   resolveQueuedEditPayload,
   type QueuedRunEdit,
 } from "./queued-run-edit";
-import { threadComposerErrorsAtom } from "./thread-composer-error";
+import { appAtomRegistry } from "./atom-registry";
 import {
-  flushComposerDrafts,
+  composerDraftsAtom,
+  decodePersistedComposerState,
   getComposerDraftSnapshot,
+  replaceComposerDraftAttachments,
+  removeComposerDraftAttachment,
   setComposerDraftText,
-  waitForComposerDraftsLoaded,
+  updateComposerDraftSettings,
 } from "./use-composer-drafts";
+import * as composerImages from "../lib/composerImages";
 
 vi.mock("expo-file-system", () => ({
   Directory: class {
@@ -44,8 +64,8 @@ vi.mock("expo-file-system", () => ({
   Paths: { document: { uri: "file:///documents" } },
 }));
 
-const image = (id: string): ChatAttachment => ({
-  type: "image",
+const image = (id: string) => ({
+  type: "image" as const,
   id: ChatAttachmentId.make(id),
   name: `${id}.png`,
   mimeType: "image/png",
@@ -54,176 +74,375 @@ const image = (id: string): ChatAttachment => ({
 
 function edit(attachments: ReadonlyArray<ChatAttachment>): QueuedRunEdit {
   return {
+    editId: CommandId.make("edit-1"),
+    sequence: 1,
     runId: RunId.make("run-1"),
     messageId: MessageId.make("message-1"),
     originalText: "original",
-    existingAttachments: attachments,
+    originalAttachmentIds: attachments.map((attachment) => attachment.id),
   };
 }
 
-function context(attachmentIds: ReadonlyArray<string>): OrchestrationMessageContext {
-  return {
-    version: 1,
-    records: attachmentIds.map((attachmentId, index) => ({
-      version: 1,
-      kind: "image",
-      contextId: ComposerContextId.make(`ctx-${index}`),
-      label: `${attachmentId}.png`,
-      attachmentId,
-      name: `${attachmentId}.png`,
-      mimeType: "image/png",
-      sizeBytes: 10,
-    })),
-  };
-}
+describe("queued edit draft key", () => {
+  it("keeps the environment readable so attachment uploads still resolve it", () => {
+    const key = queuedEditDraftKey("env-1:thread-9", "run-3");
 
-describe("resolveQueuedEditPayload", () => {
-  it("resends the kept server attachments ahead of the newly uploaded ones", () => {
-    const payload = resolveQueuedEditPayload({
-      edit: edit([image("kept")]),
-      draftContext: undefined,
-      draftAttachments: [{ id: "draft-1" }],
-      uploaded: [image("uploaded")],
-    });
+    expect(composerDraftEnvironmentId(key, [EnvironmentId.make("env-1")], [])).toBe("env-1");
+  });
+});
 
-    expect(payload.attachments.map((attachment) => attachment.id)).toEqual(["kept", "uploaded"]);
+describe("resolveQueuedEditPayload", () => {
+  it("restores owned edits after persisted draft hydration and across thread navigation", () => {
+    vi.useFakeTimers();
+    try {
+      const first = "env:thread-reload";
+      const second = "env:other-thread";
+      appAtomRegistry.set(composerDraftsAtom, {});
+      beginQueuedRunEdit(first, edit([]), []);
+      setComposerDraftText(queuedEditDraftKey(first, "run-1"), "");
+      beginQueuedRunEdit(second, { ...edit([]), editId: CommandId.make("edit-2") }, []);
+      const restored = decodePersistedComposerState(
+        JSON.parse(
+          JSON.stringify({ schemaVersion: 1, drafts: appAtomRegistry.get(composerDraftsAtom) }),
+        ),
+      );
+      appAtomRegistry.set(composerDraftsAtom, {});
+      expect(getQueuedRunEdit(first)).toBeNull();
+      appAtomRegistry.set(composerDraftsAtom, restored.drafts);
+      expect(getQueuedRunEdit(first)?.editId).toBe("edit-1");
+      expect(getQueuedRunEdit(second)?.editId).toBe("edit-2");
+      expect(getComposerDraftSnapshot(queuedEditDraftKey(first, "run-1")).text).toBe("");
+      recoverQueuedRunEdit(first);
+      expect(
+        appAtomRegistry.get(composerDraftsAtom)[queuedEditDraftKey(first, "run-1")],
+      ).toBeUndefined();
+      endQueuedRunEdit(first);
+      expect(getQueuedRunEdit(first)).toBeNull();
+      expect(getQueuedRunEdit(second)?.editId).toBe("edit-2");
+    } finally {
+      appAtomRegistry.set(composerDraftsAtom, {});
+      vi.clearAllTimers();
+      vi.useRealTimers();
+    }
   });
 
-  it("rebinds context records from the draft's ids to the uploaded ones", () => {
-    const payload = resolveQueuedEditPayload({
-      edit: edit([]),
-      draftContext: context(["draft-1"]),
-      draftAttachments: [{ id: "draft-1" }],
-      uploaded: [image("uploaded")],
-    });
+  it("keeps failed preparation owned across hydration and drops untouched content after release", async () => {
+    vi.useFakeTimers();
+    try {
+      const threadKey = "env:failed-open";
+      appAtomRegistry.set(composerDraftsAtom, {});
+      const editing = edit([image("original-image")]);
+      await expect(
+        prepareQueuedRunEditDraft(threadKey, editing, async () => {
+          throw new Error("offline");
+        }),
+      ).rejects.toThrow("offline");
+      const restored = decodePersistedComposerState(
+        JSON.parse(
+          JSON.stringify({
+            schemaVersion: 1,
+            drafts: appAtomRegistry.get(composerDraftsAtom),
+          }),
+        ),
+      );
+      appAtomRegistry.set(composerDraftsAtom, restored.drafts);
+      expect(getQueuedRunEdit(threadKey)?.editId).toBe(editing.editId);
+      expect(
+        getComposerDraftSnapshot(queuedEditDraftKey(threadKey, editing.runId)).queuedEdit
+          ?.originalAttachmentIds,
+      ).toEqual(["original-image"]);
+      expect(recoverQueuedRunEdit(threadKey)).toBe(false);
+      expect(getQueuedRunEdit(threadKey)).toBeNull();
+      expect(appAtomRegistry.get(composerDraftsAtom)).toEqual({});
+    } finally {
+      appAtomRegistry.set(composerDraftsAtom, {});
+      vi.clearAllTimers();
+      vi.useRealTimers();
+    }
+  });
 
-    expect(payload.context?.records).toEqual([
-      expect.objectContaining({ attachmentId: "uploaded" }),
-    ]);
+  it("keeps a replacement fallback edit when an old attachment import rejects", async () => {
+    vi.useFakeTimers();
+    try {
+      const threadKey = "env:replaced-import";
+      appAtomRegistry.set(composerDraftsAtom, {});
+      const editing = { ...edit([image("original-image")]), editId: null };
+      const read = Promise.withResolvers<never>();
+      const preparation = prepareQueuedRunEditDraft(threadKey, editing, () => read.promise);
+      const preparedEdit = getComposerDraftSnapshot(
+        queuedEditDraftKey(threadKey, editing.runId),
+      ).queuedEdit!;
+      endQueuedRunEdit(threadKey);
+      const replacement = { ...editing, originalAttachmentIds: [] };
+      beginQueuedRunEdit(threadKey, replacement, []);
+      const replacementKey = queuedEditDraftKey(threadKey, replacement.runId);
+      setComposerDraftText(replacementKey, "Keep replacement edit");
+      const draft = getComposerDraftSnapshot(replacementKey);
+      read.reject(new Error("offline"));
+      await expect(preparation).rejects.toThrow("offline");
+      recoverQueuedRunEdit(threadKey, preparedEdit);
+      expect(getQueuedRunEdit(threadKey)?.runId).toBe(replacement.runId);
+      expect(getComposerDraftSnapshot(replacementKey)).toEqual(draft);
+      expect(getComposerDraftSnapshot(replacementKey).queuedEdit?.ownership).toBe(
+        draft.queuedEdit?.ownership,
+      );
+    } finally {
+      appAtomRegistry.set(composerDraftsAtom, {});
+      vi.clearAllTimers();
+      vi.useRealTimers();
+    }
   });
 
-  it("drops the record of an attachment the user removed", () => {
-    const payload = resolveQueuedEditPayload({
-      edit: edit([image("kept")]),
-      draftContext: context(["kept", "gone"]),
-      draftAttachments: [],
-      uploaded: [],
-    });
+  it.each(["text", "attachments"])(
+    "keeps a retained edit separate from newer server %s",
+    (change) => {
+      vi.useFakeTimers();
+      try {
+        const threadKey = "env:stale-thread";
+        const draftKey = queuedEditDraftKey(threadKey, "run-1");
+        appAtomRegistry.set(composerDraftsAtom, {});
+        beginQueuedRunEdit(threadKey, edit([]), []);
+        setComposerDraftText(draftKey, "My older edit");
+        forgetQueuedRunEdit(threadKey);
+        beginQueuedRunEdit(threadKey, edit([]), []);
+        expect(getComposerDraftSnapshot(draftKey).text).toBe("My older edit");
+        forgetQueuedRunEdit(threadKey);
+        const newer = {
+          ...edit(change === "attachments" ? [image("new")] : []),
+          originalText: change === "text" ? "New server text" : "original",
+        };
+        beginQueuedRunEdit(
+          threadKey,
+          newer,
+          change === "attachments"
+            ? [
+                {
+                  type: "image",
+                  id: "new",
+                  name: "new.png",
+                  mimeType: "image/png",
+                  sizeBytes: 10,
+                  previewUri: "data:image/png;base64,YWJj",
+                  dataUrl: "data:image/png;base64,YWJj",
+                },
+              ]
+            : [],
+        );
+        expect(getComposerDraftSnapshot(draftKey).text).toBe(newer.originalText);
+        expect(
+          getComposerDraftSnapshot(draftKey).attachments.map((attachment) => attachment.id),
+        ).toEqual(change === "attachments" ? ["new"] : []);
+        const retained = Object.entries(appAtomRegistry.get(composerDraftsAtom)).find(([key]) =>
+          key.startsWith(`${draftKey}~saved~`),
+        )?.[1];
+        expect(retained?.text).toBe("My older edit");
+        expect(retained?.queuedEdit?.ownership).toBeUndefined();
+        const retainedKey = Object.keys(appAtomRegistry.get(composerDraftsAtom)).find((key) =>
+          key.includes("~saved~"),
+        )!;
+        setComposerDraftText(retainedKey, "");
+        expect(appAtomRegistry.get(composerDraftsAtom)[retainedKey]).toBeUndefined();
+      } finally {
+        appAtomRegistry.set(composerDraftsAtom, {});
+        vi.clearAllTimers();
+        vi.useRealTimers();
+      }
+    },
+  );
+
+  it.each(["attachment removal", "text edit"])(
+    "recovers the selected attachments after %s and restart beside an occupied main draft",
+    (change) => {
+      vi.useFakeTimers();
+      try {
+        const threadKey = "env:thread";
+        const editing = edit([image("first"), image("second")]);
+        const draftKey = queuedEditDraftKey(threadKey, editing.runId);
+        const main = { text: "Unrelated draft", attachments: [] };
+        appAtomRegistry.set(composerDraftsAtom, { [threadKey]: main });
+        beginQueuedRunEdit(
+          threadKey,
+          editing,
+          [image("first"), image("second")].map((attachment) => ({
+            type: "image" as const,
+            id: attachment.id,
+            name: attachment.name,
+            mimeType: attachment.mimeType,
+            sizeBytes: attachment.sizeBytes,
+            previewUri: "data:image/png;base64,YWJj",
+            dataUrl: "data:image/png;base64,YWJj",
+            uploadedAttachmentId: attachment.id,
+            uploadEnvironmentId: EnvironmentId.make("env"),
+            source: {
+              kind: "snap-shot" as const,
+              capturedAt: "2026-10-19T00:00:00.000Z",
+              appName: "Browser",
+              windowTitle: "Test",
+            },
+          })),
+        );
+        if (change === "attachment removal") {
+          replaceComposerDraftAttachments(
+            draftKey,
+            getComposerDraftSnapshot(draftKey).attachments.filter(
+              (attachment) => attachment.id !== "first",
+            ),
+          );
+          expect(getComposerDraftSnapshot(draftKey).text).toBe(editing.originalText);
+        } else setComposerDraftText(draftKey, "edited");
+        expect(recoverQueuedRunEdit(threadKey)).toBe(true);
+        expect(getQueuedRunEdit(threadKey)).toBeNull();
+        const restored = decodePersistedComposerState(
+          JSON.parse(
+            JSON.stringify({ schemaVersion: 1, drafts: appAtomRegistry.get(composerDraftsAtom) }),
+          ),
+        );
+        expect(restored.drafts[threadKey]).toEqual(main);
+        appAtomRegistry.set(composerDraftsAtom, restored.drafts);
+        expect(
+          canReuseQueuedRunEditDraft(
+            threadKey,
+            editing.runId,
+            editing.originalText,
+            editing.originalAttachmentIds.map((id) => ({ id })),
+          ),
+        ).toBe(true);
+        expect(restored.drafts[draftKey]?.attachments.map((attachment) => attachment.id)).toEqual(
+          change === "attachment removal" ? ["second"] : ["first", "second"],
+        );
+        expect(restored.drafts[draftKey]?.attachments).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              id: "second",
+              uploadedAttachmentId: "second",
+              uploadEnvironmentId: "env",
+              source: expect.objectContaining({ kind: "snap-shot" }),
+            }),
+          ]),
+        );
+      } finally {
+        appAtomRegistry.set(composerDraftsAtom, {});
+        vi.clearAllTimers();
+        vi.useRealTimers();
+      }
+    },
+  );
 
-    expect(payload.attachments.map((attachment) => attachment.id)).toEqual(["kept"]);
-    expect(payload.context?.records).toEqual([expect.objectContaining({ attachmentId: "kept" })]);
+  it("keeps distinct stored context identities on save and removes references with their attachments", () => {
+    vi.useFakeTimers();
+    try {
+      const threadKey = "env:binding";
+      const draftKey = queuedEditDraftKey(threadKey, "run-1");
+      const saved = [
+        image("server-image"),
+        { ...image("server-file"), type: "file" as const, mimeType: "application/pdf" },
+      ];
+      const records = saved.map((attachment, index) => ({
+        version: 1 as const,
+        contextId: ComposerContextId.make(`local-context-${index}`),
+        ...(attachment.type === "file" ? { kind: "file" as const } : { kind: "image" as const }),
+        label: attachment.name,
+        attachmentId: attachment.id,
+        name: attachment.name,
+        mimeType: attachment.mimeType,
+        sizeBytes: attachment.sizeBytes,
+      }));
+      const originalText = records.map(formatComposerContextReference).join(" ");
+      appAtomRegistry.set(composerDraftsAtom, {});
+      beginQueuedRunEdit(
+        threadKey,
+        { ...edit(saved), originalText, context: { version: 1, records } },
+        saved.map((attachment) => ({
+          ...attachment,
+          ...(attachment.type === "file"
+            ? { type: "file" as const, fileUri: "file:///report.pdf" }
+            : {
+                type: "image" as const,
+                previewUri: "data:image/png;base64,YWJj",
+                dataUrl: "data:image/png;base64,YWJj",
+              }),
+        })),
+      );
+      const draft = getComposerDraftSnapshot(draftKey);
+      expect(collectComposerContextReferences(draft.text)).toHaveLength(2);
+      const kept = resolveQueuedEditPayload({
+        draftContext: draft.context,
+        draftAttachments: draft.attachments,
+        uploaded: saved,
+      });
+      expect(kept.attachments).toEqual(saved);
+      expect(kept.context?.records.map((record) => record.contextId)).toEqual(
+        records.map((record) => record.contextId),
+      );
+      for (const attachment of saved) removeComposerDraftAttachment(draftKey, attachment.id);
+      const removed = getComposerDraftSnapshot(draftKey);
+      expect(collectComposerContextReferences(removed.text)).toEqual([]);
+      expect(
+        resolveQueuedEditPayload({
+          draftContext: removed.context,
+          draftAttachments: removed.attachments,
+          uploaded: [],
+        }),
+      ).toEqual({ attachments: [], context: undefined });
+    } finally {
+      appAtomRegistry.set(composerDraftsAtom, {});
+      vi.clearAllTimers();
+      vi.useRealTimers();
+    }
   });
 });
 
 describe("beginQueuedRunEdit", () => {
   it.each(["", "Ultrathink:\n"])(
-    "opens attachment-only edits without the placeholder and treats them as untouched (%j)",
+    "opens attachment-only edits without changing their source (%j)",
     (prefix) => {
-      const threadKey = `env-exit:attachment-only-${prefix.length}`;
+      const threadKey = `env:attachment-only-${prefix.length}`;
       const original = {
-        ...edit([image("kept")]),
+        ...edit([]),
         originalText: prefix + ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
       };
-      const runs = Atom.make<ReadonlyArray<{ readonly id: RunId; readonly status: string }> | null>(
-        [{ id: original.runId, status: "queued" }],
-      );
-      beginQueuedRunEdit(threadKey, original, runs);
+      beginQueuedRunEdit(threadKey, original, []);
       const draft = getComposerDraftSnapshot(queuedEditDraftKey(threadKey, original.runId));
       expect(draft.text).toBe(prefix.trimEnd());
-      expect(
-        restoreAttachmentOnlyBootstrapPrompt(draft.text, original.existingAttachments.length > 0),
-      ).toBe(original.originalText);
-      expect(getQueuedRunEdit(threadKey)).toEqual({ ...original, originalText: prefix.trimEnd() });
-      appAtomRegistry.set(runs, [{ id: original.runId, status: "running" }]);
+      expect(restoreAttachmentOnlyBootstrapPrompt(draft.text, true)).toBe(original.originalText);
+      expect(draft.queuedEdit?.sourceText).toBe(original.originalText);
+      expect(recoverQueuedRunEdit(threadKey)).toBe(false);
       expect(getQueuedRunEdit(threadKey)).toBeNull();
-      expect(appAtomRegistry.get(threadComposerErrorsAtom)[threadKey]?.message).toBeUndefined();
     },
   );
-
-  it("silently drops an untouched edit when its run starts", () => {
-    const threadKey = "env-exit:thread-untouched";
-    const runId = RunId.make("run-1");
-    const runs = Atom.make<ReadonlyArray<{ readonly id: RunId; readonly status: string }> | null>([
-      { id: runId, status: "queued" },
-    ]);
-    beginQueuedRunEdit(threadKey, edit([]), runs);
-
-    appAtomRegistry.set(runs, [{ id: runId, status: "running" }]);
-
-    expect(getQueuedRunEdit(threadKey)).toBeNull();
-    expect(getComposerDraftSnapshot(threadKey).text).toBe("");
-    expect(getComposerDraftSnapshot(queuedEditDraftKey(threadKey, runId)).text).toBe("");
-    expect(appAtomRegistry.get(threadComposerErrorsAtom)[threadKey]?.message).toBeUndefined();
-  });
-
-  it("recovers text after a server attachment was removed", async () => {
-    await waitForComposerDraftsLoaded();
-    const threadKey = "env-exit:thread-removed-recover";
-    const runId = RunId.make("run-1");
-    const runs = Atom.make<ReadonlyArray<{ readonly id: RunId; readonly status: string }> | null>([
-      { id: runId, status: "queued" },
-    ]);
-    beginQueuedRunEdit(threadKey, edit([image("removed")]), runs);
-    removeQueuedRunEditAttachment(threadKey, "removed");
-
-    appAtomRegistry.set(runs, [{ id: runId, status: "running" }]);
-    await flushComposerDrafts();
-
-    expect(getQueuedRunEdit(threadKey)).toBeNull();
-    expect(getComposerDraftSnapshot(threadKey).text).toBe("original");
-    expect(getComposerDraftSnapshot(queuedEditDraftKey(threadKey, runId)).text).toBe("");
-    expect(appAtomRegistry.get(threadComposerErrorsAtom)[threadKey]?.message).toBe(
-      "That message already started. Your edit is back in the composer.",
-    );
-  });
-
-  it("recovers changed text into an empty thread draft", async () => {
-    await waitForComposerDraftsLoaded();
-    const threadKey = "env-exit:thread-changed-recover";
-    const runId = RunId.make("run-1");
-    const runs = Atom.make<ReadonlyArray<{ readonly id: RunId; readonly status: string }> | null>([
-      { id: runId, status: "queued" },
-    ]);
-    beginQueuedRunEdit(threadKey, edit([]), runs);
-    setComposerDraftText(queuedEditDraftKey(threadKey, runId), "revised");
-
-    appAtomRegistry.set(runs, [{ id: runId, status: "running" }]);
-    await flushComposerDrafts();
-
-    expect(getQueuedRunEdit(threadKey)).toBeNull();
-    expect(getComposerDraftSnapshot(threadKey).text).toBe("revised");
-    expect(getComposerDraftSnapshot(queuedEditDraftKey(threadKey, runId)).text).toBe("");
-    expect(appAtomRegistry.get(threadComposerErrorsAtom)[threadKey]?.message).toBe(
-      "That message already started. Your edit is back in the composer.",
-    );
-  });
-
-  it("ends a changed edit when its run starts, without the thread's composer mounted", () => {
+  it("recovers a changed edit after a failed save when its run starts offscreen", () => {
     const threadKey = "env-exit:thread-exit";
     const runId = RunId.make("run-1");
     const runs = Atom.make<ReadonlyArray<{ readonly id: RunId; readonly status: string }> | null>([
       { id: runId, status: "queued" },
     ]);
     setComposerDraftText(threadKey, "other work");
-    beginQueuedRunEdit(threadKey, edit([]), runs);
+    beginQueuedRunEdit(threadKey, edit([]), []);
+    watchQueuedRunEdit(threadKey, runs);
     setComposerDraftText(queuedEditDraftKey(threadKey, runId), "changed");
+    const finishSave = startQueuedRunEditSave(threadKey);
+    expect(finishSave).not.toBeNull();
 
     appAtomRegistry.set(runs, [{ id: runId, status: "running" }]);
+    expect(getQueuedRunEdit(threadKey)?.runId).toBe(runId);
+    expect(finishSave!(false)).toBe(false);
 
     expect(getQueuedRunEdit(threadKey)).toBeNull();
     expect(getComposerDraftSnapshot(threadKey).text).toBe("other work");
+    expect(getComposerDraftSnapshot(queuedEditDraftKey(threadKey, runId)).text).toBe("changed");
     expect(appAtomRegistry.get(threadComposerErrorsAtom)[threadKey]?.message).toBe(
-      "That message already started, so the edit was discarded.",
+      "Editing ended. Open Saved queued edit above the composer to recover your changes.",
     );
   });
 
-  it("reports a cleared edit as discarded when the run starts", () => {
+  it("retains a cleared edit when the run starts", () => {
     const threadKey = "env-exit:thread-cleared";
     const runId = RunId.make("run-1");
     const runs = Atom.make<ReadonlyArray<{ readonly id: RunId; readonly status: string }> | null>([
       { id: runId, status: "queued" },
     ]);
-    beginQueuedRunEdit(threadKey, edit([]), runs);
+    beginQueuedRunEdit(threadKey, edit([]), []);
+    watchQueuedRunEdit(threadKey, runs);
     setComposerDraftText(queuedEditDraftKey(threadKey, runId), "");
 
     appAtomRegistry.set(runs, [{ id: runId, status: "running" }]);
@@ -231,7 +450,7 @@ describe("beginQueuedRunEdit", () => {
     expect(getQueuedRunEdit(threadKey)).toBeNull();
     expect(getComposerDraftSnapshot(threadKey).text).toBe("");
     expect(appAtomRegistry.get(threadComposerErrorsAtom)[threadKey]?.message).toBe(
-      "That message already started, so the edit was discarded.",
+      "Editing ended. Open Saved queued edit above the composer to recover your changes.",
     );
   });
 
@@ -242,14 +461,21 @@ describe("beginQueuedRunEdit", () => {
       { id: runId, status: "queued" },
     ]);
     setComposerDraftText(threadKey, "other work");
-    beginQueuedRunEdit(threadKey, edit([image("kept")]), runs);
-    removeQueuedRunEditAttachment(threadKey, "kept");
+    beginQueuedRunEdit(threadKey, edit([image("kept")]), [
+      {
+        ...image("kept"),
+        previewUri: "data:image/png;base64,YWJj",
+        dataUrl: "data:image/png;base64,YWJj",
+      },
+    ]);
+    watchQueuedRunEdit(threadKey, runs);
+    removeComposerDraftAttachment(queuedEditDraftKey(threadKey, runId), "kept");
 
     appAtomRegistry.set(runs, [{ id: runId, status: "running" }]);
 
     expect(getQueuedRunEdit(threadKey)).toBeNull();
     expect(appAtomRegistry.get(threadComposerErrorsAtom)[threadKey]?.message).toBe(
-      "That message already started, so the edit was discarded.",
+      "Editing ended. Open Saved queued edit above the composer to recover your changes.",
     );
   });
 });
@@ -266,3 +492,53 @@ describe("activeComposerDraftKey", () => {
     expect(activeComposerDraftKey(threadKey, editKey, null)).toBe(threadKey);
   });
 });
+
+describe("queued edit recovery", () => {
+  it("sends recovered content with the settings displayed by the thread controls", () => {
+    const threadKey = "env:recovery-settings";
+    const recoveryKey = queuedEditDraftKey(threadKey, "run-1");
+    setComposerDraftText(threadKey, "Unrelated draft");
+    setComposerDraftText(recoveryKey, "Recovered message");
+    const modelSelection = {
+      instanceId: ProviderInstanceId.make("codex"),
+      model: "selected-model",
+    };
+    updateComposerDraftSettings(threadKey, {
+      modelSelection,
+      runtimeMode: "approval-required",
+      interactionMode: "plan",
+    });
+    expect(getQueuedRecoverySendDraft(threadKey, recoveryKey)).toMatchObject({
+      text: "Recovered message",
+      modelSelection,
+      runtimeMode: "approval-required",
+      interactionMode: "plan",
+    });
+    updateComposerDraftSettings(threadKey, { modelSelection: undefined });
+    expect(getQueuedRecoverySendDraft(threadKey, recoveryKey).modelSelection).toBeUndefined();
+    expect(getComposerDraftSnapshot(threadKey).text).toBe("Unrelated draft");
+  });
+
+  it("waits for late imports and removes their local files when another import fails", async () => {
+    const cleanup = vi
+      .spyOn(composerImages, "removePersistedComposerAttachmentFile")
+      .mockResolvedValue();
+    try {
+      const late = Promise.withResolvers<composerImages.DraftComposerAttachment>();
+      const error = new Error("Download failed");
+      const result = restoreQueuedEditAttachments([Promise.reject(error), late.promise]);
+      const rejected = expect(result).rejects.toBe(error);
+      await Promise.resolve();
+      expect(cleanup).not.toHaveBeenCalled();
+      late.resolve({
+        ...image("late"),
+        previewUri: "file:///late.png",
+        fileUri: "file:///late.png",
+      });
+      await rejected;
+      expect(cleanup).toHaveBeenCalledExactlyOnceWith("file:///late.png");
+    } finally {
+      cleanup.mockRestore();
+    }
+  });
+});
diff --git a/apps/mobile/src/state/queued-run-edit.ts b/apps/mobile/src/state/queued-run-edit.ts
index 45dab37d0528a..b18f457327219 100644
--- a/apps/mobile/src/state/queued-run-edit.ts
+++ b/apps/mobile/src/state/queued-run-edit.ts
@@ -1,54 +1,110 @@
+import {
+  queuedEditDraftMatchesSource,
+  queuedEditDraftHasMissingAttachments,
+  type QueuedRunEditDraft,
+} from "@t3tools/client-runtime/state/queued-run-edit-draft";
+import { uuidv4 } from "../lib/uuid";
+import { useMemo } from "react";
 import type {
   ChatAttachment,
+  CommandId,
   MessageId,
   OrchestrationMessageContext,
   RunId,
   UploadChatAttachment,
 } from "@t3tools/contracts";
 import { useAtomValue } from "@effect/atom-react";
+import { Atom } from "effect/reactivity";
 import { stripAttachmentOnlyBootstrapPrompt } from "@t3tools/shared/composerContextReferences";
 import {
   makeQueuedRunEditStore,
-  resolveQueuedEditExit,
   type QueuedRunsAtom,
 } from "@t3tools/client-runtime/queued-run-edit";
 
 import { uploadedComposerContext } from "../lib/composerContext";
+import type { DraftComposerAttachment } from "../lib/composerImages";
+import { removePersistedComposerAttachmentFile } from "../lib/composerImages";
 import { appAtomRegistry } from "./atom-registry";
 import { abortComposerDraftOperations } from "./composerDraftOperations";
 import { queuedEditDraftKey } from "./queued-edit-draft-key";
 import { setThreadComposerError } from "./thread-composer-error";
 import {
   clearComposerDraft,
-  getComposerDraftSnapshot,
-  mergeComposerDraftContent,
+  updateComposerDrafts,
   setComposerDraftContext,
   setComposerDraftText,
+  getComposerDraftSnapshot,
+  composerDraftsAtom,
+  isComposerDraftEmpty,
+  appendComposerDraftAttachments,
 } from "./use-composer-drafts";
 
 export interface QueuedRunEdit {
+  readonly editId: CommandId | null;
+  readonly sequence: number;
   readonly runId: RunId;
   readonly messageId: MessageId;
   readonly originalText: string;
-  readonly existingAttachments: ReadonlyArray<ChatAttachment>;
+  readonly originalAttachmentIds: ReadonlyArray<string>;
   readonly context?: OrchestrationMessageContext;
-  /** Removing a server attachment changes the message even when the draft looks untouched. */
-  readonly removedExistingAttachment?: true;
 }
 
-const queuedRunEdits = makeQueuedRunEditStore<QueuedRunEdit>({
+export { queuedEditDraftKey } from "./queued-edit-draft-key";
+
+export function getQueuedRecoverySendDraft(threadKey: string, draftKey: string) {
+  const content = getComposerDraftSnapshot(draftKey);
+  const settings = getComposerDraftSnapshot(threadKey);
+  return {
+    ...content,
+    modelSelection: settings.modelSelection,
+    runtimeMode: settings.runtimeMode,
+    interactionMode: settings.interactionMode,
+  };
+}
+
+export async function restoreQueuedEditAttachments(
+  imports: ReadonlyArray<Promise<DraftComposerAttachment>>,
+): Promise<ReadonlyArray<DraftComposerAttachment>> {
+  const results = await Promise.allSettled(imports);
+  const restored = results.flatMap((result) =>
+    result.status === "fulfilled" ? [result.value] : [],
+  );
+  const failure = results.find((result) => result.status === "rejected");
+  if (failure) {
+    await Promise.allSettled(
+      restored.map((attachment) =>
+        attachment.fileUri
+          ? removePersistedComposerAttachmentFile(attachment.fileUri)
+          : Promise.resolve(),
+      ),
+    );
+    throw failure.reason;
+  }
+  return restored;
+}
+
+const queuedRunEdits = makeQueuedRunEditStore<QueuedRunEditDraft>({
   registry: appAtomRegistry,
   label: "mobile-queued-run-edits",
 });
 
-export { queuedEditDraftKey } from "./queued-edit-draft-key";
-
-export const getQueuedRunEdit = queuedRunEdits.get;
+export function watchQueuedRunEdit(threadKey: string, runs: QueuedRunsAtom): void {
+  const draft = activeEditDraft(appAtomRegistry.get(composerDraftsAtom), threadKey);
+  if (!draft?.ownership || queuedRunEdits.get(threadKey)?.ownership === draft.ownership) return;
+  queuedRunEdits.begin(threadKey, draft, {
+    runs,
+    onRunLeftQueue: (_, endedEdit) => {
+      const dirty = recoverQueuedRunEdit(threadKey, endedEdit);
+      setThreadComposerError(
+        threadKey,
+        dirty
+          ? "Editing ended. Open Saved queued edit above the composer to recover your changes."
+          : "The message left the queue or another editor took over.",
+      );
+    },
+  });
+}
 
-/**
- * The draft a sheet opened for `requestedKey` should edit now: a queued edit's
- * draft only while that edit is still open, else the thread's own draft.
- */
 export function activeComposerDraftKey(
   threadKey: string,
   requestedKey: string,
@@ -57,87 +113,218 @@ export function activeComposerDraftKey(
   if (requestedKey === threadKey) return threadKey;
   return edit !== null && queuedEditDraftKey(threadKey, edit.runId) === requestedKey
     ? requestedKey
-    : threadKey;
+    : getQueuedEditRecovery(threadKey) === requestedKey
+      ? requestedKey
+      : threadKey;
+}
+
+const queuedEditRecoverySelectionAtom = Atom.make<Readonly<Record<string, string>>>({}).pipe(
+  Atom.keepAlive,
+);
+
+export function selectQueuedEditRecovery(threadKey: string, draftKey: string | null): void {
+  const next = { ...appAtomRegistry.get(queuedEditRecoverySelectionAtom) };
+  if (draftKey === null) delete next[threadKey];
+  else next[threadKey] = draftKey;
+  appAtomRegistry.set(queuedEditRecoverySelectionAtom, next);
+}
+
+export function getQueuedEditRecovery(threadKey: string): string | null {
+  const key = appAtomRegistry.get(queuedEditRecoverySelectionAtom)[threadKey];
+  return key !== undefined && appAtomRegistry.get(composerDraftsAtom)[key] !== undefined
+    ? key
+    : null;
+}
+
+export function useQueuedEditRecovery(threadKey: string | null): string | null {
+  const selections = useAtomValue(queuedEditRecoverySelectionAtom);
+  const drafts = useSavedQueuedEditDrafts(threadKey);
+  const selected = threadKey === null ? undefined : selections[threadKey];
+  return selected !== undefined && drafts.includes(selected) ? selected : null;
 }
 
+const savedEditDraftsAtom = Atom.family((threadKey: string) =>
+  Atom.make((get) =>
+    Object.keys(get(composerDraftsAtom)).filter((key) =>
+      key.startsWith(`${threadKey}~queued-edit~`),
+    ),
+  ).pipe(
+    Atom.withEquality<ReadonlyArray<string>>(
+      (left, right) =>
+        left.length === right.length && left.every((key, index) => key === right[index]),
+    ),
+  ),
+);
+
+export function useSavedQueuedEditDrafts(threadKey: string | null) {
+  return useAtomValue(savedEditDraftsAtom(threadKey ?? ""));
+}
+
+function activeEditDraft(
+  drafts: Readonly<Record<string, { readonly queuedEdit?: QueuedRunEditDraft }>>,
+  threadKey: string,
+) {
+  return (
+    Object.entries(drafts).find(
+      ([key, draft]) =>
+        key.startsWith(`${threadKey}~queued-edit~`) && draft.queuedEdit?.ownership !== undefined,
+    )?.[1].queuedEdit ?? null
+  );
+}
+
+function editFromDraft(draft: QueuedRunEditDraft | null): QueuedRunEdit | null {
+  return draft?.ownership ? { ...draft, ...draft.ownership } : null;
+}
+
+export function getQueuedRunEdit(threadKey: string | null): QueuedRunEdit | null {
+  return threadKey === null
+    ? null
+    : editFromDraft(activeEditDraft(appAtomRegistry.get(composerDraftsAtom), threadKey));
+}
+
+const activeEditDraftAtom = Atom.family((threadKey: string) =>
+  Atom.make((get) => activeEditDraft(get(composerDraftsAtom), threadKey)),
+);
+
 export function useQueuedRunEdit(threadKey: string | null): QueuedRunEdit | null {
-  const edits = useAtomValue(queuedRunEdits.atom);
-  return threadKey === null ? null : (edits[threadKey] ?? null);
+  const draft = useAtomValue(activeEditDraftAtom(threadKey ?? ""));
+  return useMemo(() => editFromDraft(draft), [draft]);
 }
 
-/**
- * The run started or was cancelled elsewhere. A changed edit goes back into
- * the thread's composer when that is empty; otherwise it is dropped. Either
- * way the thread says so, wherever the user is when it happens.
- */
-function exitQueuedRunEdit(threadKey: string, edit: QueuedRunEdit): void {
-  const editDraftKey = queuedEditDraftKey(threadKey, edit.runId);
-  const editDraft = getComposerDraftSnapshot(editDraftKey);
-  const threadDraft = getComposerDraftSnapshot(threadKey);
-  const editRestorable = editDraft.text.trim().length > 0 || editDraft.attachments.length > 0;
-  const recovery = resolveQueuedEditExit({
-    editChanged:
-      editDraft.text !== edit.originalText ||
-      editDraft.attachments.length > 0 ||
-      edit.removedExistingAttachment === true,
-    // A cleared edit has nothing to put back, so it can only be discarded.
-    threadDraftEmpty:
-      editRestorable &&
-      threadDraft.text.trim().length === 0 &&
-      threadDraft.attachments.length === 0,
+export function useQueuedRunEditSaving(threadKey: string | null): boolean {
+  const saving = useAtomValue(queuedRunEdits.savingAtom);
+  return threadKey !== null && saving[threadKey] === true;
+}
+
+export function forgetQueuedRunEdit(threadKey: string): void {
+  queuedRunEdits.end(threadKey);
+  updateComposerDrafts((current) => {
+    const next = { ...current };
+    for (const [key, draft] of Object.entries(current)) {
+      if (!key.startsWith(threadKey + "~queued-edit~") || !draft.queuedEdit?.ownership) continue;
+      const retained = { ...draft, queuedEdit: { ...draft.queuedEdit, ownership: undefined } };
+      if (isComposerDraftEmpty(retained)) delete next[key];
+      else next[key] = retained;
+    }
+    return next;
   });
-  if (recovery === "kept") {
-    // The merge publishes the draft before writing it, so a failed write only delays persistence to the next one.
-    mergeComposerDraftContent(threadKey, {
-      text: editDraft.text,
-      attachments: editDraft.attachments,
-      ...(editDraft.context ? { context: editDraft.context } : {}),
-    }).catch((error: unknown) => {
-      console.warn("[queued-run-edit] could not persist the recovered edit", error);
-    });
-  }
-  clearComposerDraft(editDraftKey, { deferAttachmentCleanup: recovery === "kept" });
-  if (recovery === "clean") return;
-  setThreadComposerError(
-    threadKey,
-    recovery === "kept"
-      ? "That message already started. Your edit is back in the composer."
-      : "That message already started, so the edit was discarded.",
+}
+
+export function canReuseQueuedRunEditDraft(
+  threadKey: string,
+  runId: RunId,
+  text: string,
+  attachments: ReadonlyArray<{ readonly id: string }>,
+) {
+  const draft = getComposerDraftSnapshot(queuedEditDraftKey(threadKey, runId));
+  return (
+    queuedEditDraftMatchesSource(draft.queuedEdit, text, attachments) &&
+    draft.queuedEdit !== undefined &&
+    !queuedEditDraftHasMissingAttachments(draft.queuedEdit, draft.attachments)
   );
 }
 
-/** `runs` is the thread's runs; the edit ends when its run leaves the queue. */
 export function beginQueuedRunEdit(
   threadKey: string,
   edit: QueuedRunEdit,
-  runs: QueuedRunsAtom,
+  attachments: ReadonlyArray<DraftComposerAttachment>,
 ): void {
+  abortComposerDraftOperations(threadKey);
   const previous = getQueuedRunEdit(threadKey);
   if (previous !== null && previous.runId !== edit.runId) {
-    clearComposerDraft(queuedEditDraftKey(threadKey, previous.runId));
+    forgetQueuedRunEdit(threadKey);
   }
-  // The composer moves off the thread draft, so a paste or pick still running for it is dropped.
-  abortComposerDraftOperations(threadKey);
+  selectQueuedEditRecovery(threadKey, null);
   const draftKey = queuedEditDraftKey(threadKey, edit.runId);
-  const originalText = stripAttachmentOnlyBootstrapPrompt(edit.originalText);
-  clearComposerDraft(draftKey);
-  setComposerDraftText(draftKey, originalText);
-  setComposerDraftContext(draftKey, edit.context);
-  queuedRunEdits.begin(
+  const existing = appAtomRegistry.get(composerDraftsAtom)[draftKey];
+  const reuse = canReuseQueuedRunEditDraft(
     threadKey,
-    { ...edit, originalText },
-    { runs, onRunLeftQueue: exitQueuedRunEdit },
+    edit.runId,
+    edit.originalText,
+    edit.originalAttachmentIds.map((id) => ({ id })),
   );
+  if (existing && !reuse) {
+    updateComposerDrafts((current) => {
+      const retained = existing.queuedEdit
+        ? { ...existing, queuedEdit: { ...existing.queuedEdit, ownership: undefined } }
+        : existing;
+      const next = { ...current };
+      if (!isComposerDraftEmpty(retained)) next[`${draftKey}~saved~${uuidv4()}`] = retained;
+      delete next[draftKey];
+      return next;
+    });
+  }
+  if (!reuse) {
+    setComposerDraftText(draftKey, stripAttachmentOnlyBootstrapPrompt(edit.originalText));
+    setComposerDraftContext(draftKey, edit.context);
+    appendComposerDraftAttachments(draftKey, attachments);
+  }
+  updateComposerDrafts((current) => {
+    const draft = current[draftKey] ?? { text: "", attachments: [] };
+    return {
+      ...current,
+      [draftKey]: {
+        ...draft,
+        queuedEdit: {
+          runId: edit.runId,
+          messageId: edit.messageId,
+          sourceText: edit.originalText,
+          originalText: reuse ? (existing?.queuedEdit?.originalText ?? draft.text) : draft.text,
+          originalAttachmentIds: edit.originalAttachmentIds,
+          ...(reuse && existing?.queuedEdit?.removedAttachmentIds
+            ? { removedAttachmentIds: existing.queuedEdit.removedAttachmentIds }
+            : {}),
+          ...(edit.context ? { context: edit.context } : {}),
+          ownership: { editId: edit.editId, sequence: edit.sequence },
+        },
+      },
+    };
+  });
 }
 
-export function removeQueuedRunEditAttachment(threadKey: string, attachmentId: string): void {
-  queuedRunEdits.update(threadKey, (edit) => ({
-    ...edit,
-    removedExistingAttachment: true,
-    existingAttachments: edit.existingAttachments.filter(
-      (attachment) => attachment.id !== attachmentId,
-    ),
-  }));
+export async function prepareQueuedRunEditDraft(
+  threadKey: string,
+  edit: QueuedRunEdit,
+  readAttachments: () => Promise<ReadonlyArray<DraftComposerAttachment>>,
+): Promise<void> {
+  const reuse = canReuseQueuedRunEditDraft(
+    threadKey,
+    edit.runId,
+    edit.originalText,
+    edit.originalAttachmentIds.map((id) => ({ id })),
+  );
+  beginQueuedRunEdit(threadKey, edit, []);
+  if (reuse) return;
+  const draftKey = queuedEditDraftKey(threadKey, edit.runId);
+  const ownership = getComposerDraftSnapshot(draftKey).queuedEdit?.ownership;
+  const attachments = await readAttachments();
+  if (getComposerDraftSnapshot(draftKey).queuedEdit?.ownership !== ownership) return;
+  appendComposerDraftAttachments(draftKey, attachments, {
+    allowOverflow: true,
+  });
+}
+
+export function recoverQueuedRunEdit(
+  threadKey: string,
+  expectedEdit?: Pick<QueuedRunEditDraft, "runId" | "ownership">,
+): boolean {
+  const currentEdit = activeEditDraft(appAtomRegistry.get(composerDraftsAtom), threadKey);
+  if (
+    expectedEdit &&
+    (currentEdit?.runId !== expectedEdit.runId || currentEdit?.ownership !== expectedEdit.ownership)
+  )
+    return false;
+  const edit = editFromDraft(currentEdit);
+  if (edit === null) return false;
+  const draft = getComposerDraftSnapshot(queuedEditDraftKey(threadKey, edit.runId));
+  const ids = edit.originalAttachmentIds ?? [];
+  const dirty =
+    draft.text !== edit.originalText ||
+    (draft.queuedEdit?.removedAttachmentIds?.length ?? 0) > 0 ||
+    draft.attachments.some((attachment) => !ids.includes(attachment.id));
+  if (dirty) forgetQueuedRunEdit(threadKey);
+  else endQueuedRunEdit(threadKey);
+  return dirty;
 }
 
 export function endQueuedRunEdit(
@@ -158,7 +345,6 @@ export const startQueuedRunEditSave = queuedRunEdits.startSave;
 
 /** Attachments replace wholesale; resend kept server attachments with uploads in composer order. */
 export function resolveQueuedEditPayload(input: {
-  readonly edit: QueuedRunEdit;
   readonly draftContext: OrchestrationMessageContext | undefined;
   readonly draftAttachments: ReadonlyArray<{ readonly id: string }>;
   readonly uploaded: ReadonlyArray<ChatAttachment | UploadChatAttachment>;
@@ -166,7 +352,7 @@ export function resolveQueuedEditPayload(input: {
   readonly attachments: ReadonlyArray<ChatAttachment | UploadChatAttachment>;
   readonly context: OrchestrationMessageContext | undefined;
 } {
-  const attachments = [...input.edit.existingAttachments, ...input.uploaded];
+  const attachments = input.uploaded;
   const rebound = uploadedComposerContext(
     input.draftContext,
     input.draftAttachments,
diff --git a/apps/mobile/src/state/thread-task-permissions.test.ts b/apps/mobile/src/state/thread-task-permissions.test.ts
index 5a31c1955b928..147bf070c242c 100644
--- a/apps/mobile/src/state/thread-task-permissions.test.ts
+++ b/apps/mobile/src/state/thread-task-permissions.test.ts
@@ -27,6 +27,7 @@ import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
 const state = vi.hoisted(() => ({
   grantedEnvironments: new Set<string>(),
   connectionState: "connected",
+  recoveryText: null as string | null,
   draft: {
     text: "Keep my draft",
     attachments: [] as DraftComposerImageAttachment[],
@@ -83,9 +84,15 @@ vi.mock("@t3tools/client-runtime/state/context-window", async (importOriginal) =
 }));
 vi.mock("../lib/attachmentUpload", () => ({ prepareTurnAttachments: vi.fn() }));
 vi.mock("../lib/uuid", () => ({ uuidv4: () => "uuid" }));
-vi.mock("./queued-run-edit", () => ({
+vi.mock("./queued-run-edit", async (importOriginal) => ({
+  getQueuedRecoverySendDraft: (await importOriginal<typeof import("./queued-run-edit")>())
+    .getQueuedRecoverySendDraft,
   useQueuedRunEdit: () => null,
+  useQueuedRunEditSaving: () => false,
   getQueuedRunEdit: () => null,
+  useSavedQueuedEditDrafts: () => [],
+  useQueuedEditRecovery: () => (state.recoveryText === null ? null : "secondary:thread:recovery"),
+  getQueuedEditRecovery: () => (state.recoveryText === null ? null : "secondary:thread:recovery"),
 }));
 vi.mock("./preferences", async () => {
   const { Atom, AsyncResult } = await import("effect/reactivity");
@@ -121,6 +128,7 @@ vi.mock("./use-atom-command", () => ({ useAtomCommand: <A>(command: A) => comman
 vi.mock("./threads", async () => {
   const { Atom } = await import("effect/reactivity");
   return {
+    useEnvironmentThread: () => null,
     environmentThreadDetails: {
       queueWorkflowAtom: () => Atom.make(null),
       checkpointSummariesAtom: () => Atom.make([]),
@@ -152,7 +160,10 @@ vi.mock("./use-composer-drafts", async () => {
   return {
     composerDraftsAtom: Atom.make({}),
     composerContextImportsAtom: Atom.make({}),
-    getComposerDraftSnapshot: () => state.draft,
+    getComposerDraftSnapshot: (key: string) =>
+      key === "secondary:thread:recovery"
+        ? { ...state.draft, text: state.recoveryText }
+        : state.draft,
     isFreshSessionPending: () => state.freshPending,
     setFreshSessionPending: state.setFreshPending,
     clearComposerDraftContent: state.clearDraft,
@@ -196,6 +207,7 @@ const NO_SIDE_CHATS = { startSideChat: async () => false };
 beforeEach(() => {
   state.grantedEnvironments = new Set(["primary"]);
   state.connectionState = "connected";
+  state.recoveryText = null;
   state.draft = {
     text: "Keep my draft",
     attachments: [],
@@ -228,6 +240,27 @@ beforeEach(() => {
 });
 
 describe("mobile task permissions", () => {
+  it.each(["/clear", "/side explain this", "approval"])(
+    "clears only the selected recovery draft for %s",
+    async (text) => {
+      state.grantedEnvironments.add("secondary");
+      state.recoveryText = text;
+      state.thread.latestRun = { runId: "run" };
+      state.serverConfig = {
+        ...state.serverConfig,
+        environment: { capabilities: { freshContext: true, sideChats: true } },
+      } as ServerConfig;
+      const composer = useThreadComposerState({ startSideChat: async () => true });
+      await composer.onSendMessage(
+        undefined,
+        text === "approval" ? async () => "responded" : undefined,
+      );
+      expect(state.clearDraft).toHaveBeenCalledExactlyOnceWith("secondary:thread:recovery");
+      expect(state.draft.text).toBe("Keep my draft");
+      expect(state.enqueue).not.toHaveBeenCalled();
+    },
+  );
+
   it("consumes an approval reply without queueing a parent message", async () => {
     state.grantedEnvironments.add("secondary");
     const composer = useThreadComposerState(NO_SIDE_CHATS);
diff --git a/apps/mobile/src/state/use-composer-drafts.test.ts b/apps/mobile/src/state/use-composer-drafts.test.ts
index f8a14977acca9..46c8d4124550d 100644
--- a/apps/mobile/src/state/use-composer-drafts.test.ts
+++ b/apps/mobile/src/state/use-composer-drafts.test.ts
@@ -19,6 +19,7 @@ import {
   ComposerContextId,
   EnvironmentId,
   MessageId,
+  RunId,
   ProjectId,
   ProviderInstanceId,
   ThreadId,
@@ -821,6 +822,21 @@ describe("mobile composer drafts", () => {
         fileUri: `file:///notes-${index}.txt`,
       }));
       appendComposerDraftAttachments(key, files, { appendReference: true });
+      const original = getComposerDraftSnapshot(key);
+      appAtomRegistry.set(composerDraftsAtom, {
+        ...appAtomRegistry.get(composerDraftsAtom),
+        [key]: {
+          ...original,
+          queuedEdit: {
+            runId: RunId.make("run-1"),
+            messageId: MessageId.make("message-1"),
+            sourceText: original.text,
+            originalText: original.text,
+            originalAttachmentIds: files.map((file) => file.id),
+            ownership: { editId: null, sequence: 0 },
+          },
+        },
+      });
       const firstLink = "[notes-0.txt](t3-context://v1/file/file-0)";
       const insertion = captureComposerDraftInsertion(key, { start: 0, end: firstLink.length });
       expect(countComposerDraftAttachmentsAfterSelection(key, insertion)).toBe(99);
@@ -866,6 +882,7 @@ describe("mobile composer drafts", () => {
       }
       const draft = getComposerDraftSnapshot(key);
       expect(draft.attachments.map((file) => file.id)).not.toContain("file-0");
+      expect(draft.queuedEdit?.removedAttachmentIds).toEqual(["file-0"]);
       expect(draft.attachments.slice(0, 99)).toEqual(files.slice(1));
       expect(draft.context?.records.some((record) => record.contextId === "file-0")).toBe(false);
       await cleanup.promise;
diff --git a/apps/mobile/src/state/use-composer-drafts.ts b/apps/mobile/src/state/use-composer-drafts.ts
index b233034c5cf84..9b63512804672 100644
--- a/apps/mobile/src/state/use-composer-drafts.ts
+++ b/apps/mobile/src/state/use-composer-drafts.ts
@@ -1,3 +1,5 @@
+import { QueuedRunEditDraft } from "@t3tools/client-runtime/state/queued-run-edit-draft";
+import { isQueuedEditDraftKey } from "./queued-edit-draft-key";
 import { useAtomValue } from "@effect/atom-react";
 import {
   EnvironmentId as EnvironmentIdSchema,
@@ -34,7 +36,6 @@ import { draftModelPickMatchesThread } from "@t3tools/shared/model";
 
 import { writeFileAtomically } from "../lib/atomic-file";
 import { createComposerContextHistory, referencedComposerContext } from "../lib/composerContext";
-import { isQueuedEditDraftKey } from "./queued-edit-draft-key";
 import {
   collectComposerContextReferences,
   formatComposerContextReference,
@@ -352,7 +353,7 @@ export function insertComposerDraftContext(
     if (!nextDraft) return current;
     inserted = true;
     removed = draft.attachments.filter((attachment) => !nextDraft.attachments.includes(attachment));
-    return { ...current, [draftKey]: nextDraft };
+    return withComposerDraft(current, draftKey, nextDraft);
   });
   scheduleUnusedComposerAttachmentCleanup(inserted ? removed : (content.attachments ?? []));
   return inserted;
@@ -397,6 +398,7 @@ export class ComposerDraftPersistenceError extends Schema.TaggedError<ComposerDr
 const isComposerDraftPersistenceError = Schema.is(ComposerDraftPersistenceError);
 
 export interface ComposerDraft {
+  readonly queuedEdit?: QueuedRunEditDraft;
   readonly text: string;
   readonly context?: OrchestrationMessageContext;
   readonly attachments: ReadonlyArray<DraftComposerAttachment>;
@@ -469,6 +471,7 @@ const PersistedComposerContextSchema = Schema.Struct({
 });
 
 const ComposerDraftSchema = Schema.Struct({
+  queuedEdit: Schema.optional(QueuedRunEditDraft),
   text: Schema.String,
   context: Schema.optional(PersistedComposerContextSchema),
   attachments: Schema.Array(DraftComposerAttachmentSchema),
@@ -657,7 +660,8 @@ function isEmptyDraft(draft: ComposerDraft): boolean {
     draft.runtimeMode === undefined &&
     draft.interactionMode === undefined &&
     draft.freshContext !== true &&
-    draft.workspaceSelection === undefined
+    draft.workspaceSelection === undefined &&
+    draft.queuedEdit?.ownership === undefined
   );
 }
 
@@ -666,6 +670,25 @@ function withComposerDraft(
   draftKey: string,
   draft: ComposerDraft,
 ): Record<string, ComposerDraft> {
+  const removedOriginalIds =
+    current[draftKey]?.attachments
+      .filter(
+        (attachment) =>
+          draft.queuedEdit?.originalAttachmentIds.includes(attachment.id) &&
+          !draft.attachments.some((retained) => retained.id === attachment.id),
+      )
+      .map((attachment) => attachment.id) ?? [];
+  if (draft.queuedEdit && removedOriginalIds.length > 0) {
+    draft = {
+      ...draft,
+      queuedEdit: {
+        ...draft.queuedEdit,
+        removedAttachmentIds: [
+          ...new Set([...(draft.queuedEdit.removedAttachmentIds ?? []), ...removedOriginalIds]),
+        ],
+      },
+    };
+  }
   if (isEmptyDraft(draft) && draft.project === undefined) {
     const next = { ...current };
     delete next[draftKey];
@@ -723,16 +746,16 @@ export function decodePersistedComposerState(value: unknown): {
               draft.attachments.length === 0 &&
               draft.runtimeMode === undefined &&
               draft.interactionMode === undefined &&
-              draft.workspaceSelection === undefined
+              draft.workspaceSelection === undefined &&
+              draft.queuedEdit?.ownership === undefined
               ? { ...draft, modelSelection: undefined }
               : draft,
             now,
           ),
         )
-        // Retain contentless drafts with import receipts to prevent re-importing native shares after restart.
+        // Keep import receipts and durable queued edits across restarts.
         .filter(([, draft]) => !isEmptyDraft(draft) || (draft.importedShareIds?.length ?? 0) > 0)
-        // Queued-edit sessions are memory-only; persisted drafts would outlive their run association and become unreachable.
-        .filter(([key]) => !isQueuedEditDraftKey(key)),
+        .filter(([key, draft]) => !isQueuedEditDraftKey(key) || draft.queuedEdit !== undefined),
     ),
     stickyModelSelection: parsed.stickyModelSelection ?? null,
     modelOptionMemory: parsed.modelOptionMemory ?? {},
@@ -1316,7 +1339,7 @@ export async function restoreCloudComposerDrafts(accountId: string): Promise<voi
   await flushComposerDrafts();
 }
 
-function updateComposerDrafts(
+export function updateComposerDrafts(
   update: (current: Record<string, ComposerDraft>) => Record<string, ComposerDraft>,
 ): void {
   const current = appAtomRegistry.get(composerDraftsAtom);
@@ -1432,10 +1455,7 @@ export function appendComposerDraftAttachments(
         (attachment) => !draft.attachments.includes(attachment),
       );
     }
-    return {
-      ...current,
-      [draftKey]: draft,
-    };
+    return withComposerDraft(current, draftKey, draft);
   });
   scheduleUnusedComposerAttachmentCleanup([...rejected, ...removed]);
   return rejected.length;
@@ -1644,6 +1664,7 @@ export function clearComposerDraftContentState(
     return current;
   }
   const {
+    queuedEdit: _queuedEdit,
     importedShareIds: _importedShareIds,
     context: _context,
     modelSelection,
diff --git a/apps/mobile/src/state/use-thread-composer-state.ts b/apps/mobile/src/state/use-thread-composer-state.ts
index 61a72f1af65dc..16d7ead66eaf9 100644
--- a/apps/mobile/src/state/use-thread-composer-state.ts
+++ b/apps/mobile/src/state/use-thread-composer-state.ts
@@ -1,3 +1,4 @@
+import { queuedEditDraftHasMissingAttachments } from "@t3tools/client-runtime/state/queued-run-edit-draft";
 import { useComposerAttachmentActions } from "./use-composer-attachment-actions";
 import * as Dialog from "../components/ui/Dialog";
 import { AuthOrchestrationOperateScope } from "@t3tools/contracts";
@@ -17,6 +18,7 @@ import {
   threadRuntimeHasInterruptibleRun,
 } from "@t3tools/client-runtime/state/thread-execution";
 import { useEffect, useRef, useState } from "react";
+import { makeQueuedRunsAtom } from "@t3tools/client-runtime/queued-run-edit";
 
 import {
   CommandId,
@@ -93,15 +95,23 @@ import { settlePromise, squashAtomCommandFailure } from "@t3tools/client-runtime
 import { prepareTurnAttachments } from "../lib/attachmentUpload";
 import { DEFAULT_FOLLOW_UP_BEHAVIOR } from "../lib/followUpBehavior";
 import { mobilePreferencesAtom } from "./preferences";
-import { environmentThreadDetails } from "./threads";
+import { queuedRunEditOwnership } from "@t3tools/client-runtime/state/threads";
+import { environmentThreadDetails, useEnvironmentThread } from "./threads";
 import {
   endQueuedRunEdit,
+  recoverQueuedRunEdit,
+  getQueuedRecoverySendDraft,
+  useSavedQueuedEditDrafts,
+  useQueuedEditRecovery,
+  selectQueuedEditRecovery,
+  getQueuedEditRecovery,
   getQueuedRunEdit,
   queuedEditDraftKey,
-  removeQueuedRunEditAttachment,
   resolveQueuedEditPayload,
   startQueuedRunEditSave,
+  watchQueuedRunEdit,
   useQueuedRunEdit,
+  useQueuedRunEditSaving,
 } from "./queued-run-edit";
 import { setPendingConnectionError } from "./use-remote-environment-registry";
 import { clearThreadComposerError, setThreadComposerError } from "./thread-composer-error";
@@ -121,6 +131,24 @@ const EMPTY_QUEUE_WORKFLOW_ATOM = Atom.make<null>(null).pipe(
 const EMPTY_CHECKPOINT_SUMMARIES_ATOM = Atom.make<ReadonlyArray<ThreadCheckpointSummary>>([]);
 const EMPTY_THREAD_SEQUENCE_ATOM = Atom.make(0);
 
+function watchThreadQueuedEdit(thread: {
+  readonly environmentId: EnvironmentId;
+  readonly id: ThreadId;
+}) {
+  const target = { environmentId: thread.environmentId, threadId: thread.id };
+  watchQueuedRunEdit(
+    scopedThreadKey(thread.environmentId, thread.id),
+    makeQueuedRunsAtom({
+      threadId: thread.id,
+      snapshot: threadEnvironment.snapshotAtom(thread.environmentId),
+      detailStatus: environmentThreadDetails.statusAtom(target),
+      runs: Atom.make(
+        (get) => get(environmentThreadDetails.quietThreadAtom(target))?.projection.runs ?? null,
+      ),
+    }),
+  );
+}
+
 export function appendReviewCommentToDraft(input: {
   readonly environmentId: EnvironmentId;
   readonly threadId: ThreadId;
@@ -157,7 +185,9 @@ function activeComposerDraftKey(thread: {
 }): string {
   const threadKey = scopedThreadKey(thread.environmentId, thread.id);
   const edit = getQueuedRunEdit(threadKey);
-  return edit === null ? threadKey : queuedEditDraftKey(threadKey, edit.runId);
+  return edit === null
+    ? (getQueuedEditRecovery(threadKey) ?? threadKey)
+    : queuedEditDraftKey(threadKey, edit.runId);
 }
 
 export function useThreadDraftForThread(input: {
@@ -206,7 +236,13 @@ export function useThreadComposerState(input: {
     label: "edit queued message",
     reportFailure: false,
   });
-  const [isSavingQueuedEdit, setIsSavingQueuedEdit] = useState(false);
+  const releaseQueuedEdit = useAtomCommand(threadEnvironment.cancelQueuedRunEdit, {
+    label: "cancel queued edit",
+  });
+  const editThreadState = useEnvironmentThread(
+    selectedThreadShell?.environmentId ?? null,
+    selectedThreadShell?.id ?? null,
+  );
   const savingQueuedEditRef = useRef(false);
   const startingSideChatRef = useRef(false);
 
@@ -290,12 +326,15 @@ export function useThreadComposerState(input: {
       : environmentThreadDetails.queueWorkflowAtom(selectedThreadDetailRef),
   );
   const queuedRunEdit = useQueuedRunEdit(selectedThreadKey);
+  const isSavingQueuedEdit = useQueuedRunEditSaving(selectedThreadKey);
+  const savedQueuedEditDrafts = useSavedQueuedEditDrafts(selectedThreadKey);
+  const selectedRecoveryDraftKey = useQueuedEditRecovery(selectedThreadKey);
   const composerDraftKey =
     selectedThreadKey === null
       ? null
-      : queuedRunEdit === null
-        ? selectedThreadKey
-        : queuedEditDraftKey(selectedThreadKey, queuedRunEdit.runId);
+      : queuedRunEdit !== null
+        ? queuedEditDraftKey(selectedThreadKey, queuedRunEdit.runId)
+        : (selectedRecoveryDraftKey ?? selectedThreadKey);
   const selectedDraft = useComposerDraftSettings(selectedThreadKey);
   const selectedThreadQueueCount = selectedThreadQueuedMessages.length;
   const selectedThread = selectedThreadShell;
@@ -387,19 +426,46 @@ export function useThreadComposerState(input: {
     ? deriveProviderSubagentStatus(selectedThreadProjection.projection)
     : null;
 
+  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- restores the projection watch after navigation and recovers edits whose server ownership ended
+  useEffect(() => {
+    if (selectedThreadShell && queuedRunEdit) watchThreadQueuedEdit(selectedThreadShell);
+    if (
+      selectedThreadKey === null ||
+      queuedRunEdit === null ||
+      savingQueuedEditRef.current ||
+      isSavingQueuedEdit
+    )
+      return;
+    if (queuedRunEditOwnership(editThreadState, queuedRunEdit) !== "lost") return;
+    const dirty = recoverQueuedRunEdit(selectedThreadKey);
+    setThreadComposerError(
+      selectedThreadKey,
+      dirty
+        ? "Editing ended. Open Saved queued edit above the composer to recover your changes."
+        : "The message left the queue or another editor took over.",
+    );
+  }, [selectedThreadKey, selectedThreadShell, queuedRunEdit, editThreadState, isSavingQueuedEdit]);
   const activeThreadBusy = threadRuntimeIsActive(selectedThreadRuntime);
   const interruptibleRunId = threadRuntimeHasInterruptibleRun(selectedThreadRuntime)
     ? (selectedThreadRuntime?.activeRunId ?? null)
     : null;
 
-  const cancelQueuedRunEdit = () => {
-    if (selectedThreadKey === null || savingQueuedEditRef.current) return;
-    endQueuedRunEdit(selectedThreadKey);
-  };
-
-  const onRemoveQueuedEditAttachment = (attachmentId: string) => {
-    if (selectedThreadKey === null) return;
-    removeQueuedRunEditAttachment(selectedThreadKey, attachmentId);
+  const cancelQueuedRunEdit = async () => {
+    if (selectedThreadKey === null || selectedThreadShell === null || savingQueuedEditRef.current)
+      return;
+    const edit = getQueuedRunEdit(selectedThreadKey);
+    if (edit === null) return;
+    watchThreadQueuedEdit(selectedThreadShell);
+    const finishCancel = startQueuedRunEditSave(selectedThreadKey);
+    if (finishCancel === null) return;
+    savingQueuedEditRef.current = true;
+    const result = await releaseQueuedEdit({
+      environmentId: selectedThreadShell.environmentId,
+      input: { threadId: selectedThreadShell.id, runId: edit.runId, editId: edit.editId },
+    });
+    savingQueuedEditRef.current = false;
+    if (finishCancel(result._tag === "Success") && result._tag === "Success")
+      endQueuedRunEdit(selectedThreadKey);
   };
 
   const saveQueuedRunEdit = async () => {
@@ -409,29 +475,32 @@ export function useThreadComposerState(input: {
     const edit = getQueuedRunEdit(threadKey);
     if (edit === null) return;
     const draft = getComposerDraftSnapshot(queuedEditDraftKey(threadKey, edit.runId));
-    const text = draft.text.trim();
     if (
-      text.length === 0 &&
-      edit.existingAttachments.length === 0 &&
-      draft.attachments.length === 0
+      draft.queuedEdit &&
+      queuedEditDraftHasMissingAttachments(draft.queuedEdit, draft.attachments)
     ) {
+      Dialog.alert(
+        "Could not save the queued message",
+        "An attachment could not be restored. Cancel and reopen the edit to restore it before saving.",
+      );
+      return;
+    }
+    const text = draft.text.trim();
+    if (text.length === 0 && draft.attachments.length === 0) {
       Dialog.alert("Add a message", "A queued message cannot be left empty.");
       return;
     }
-    if (
-      edit.existingAttachments.length + draft.attachments.length >
-      PROVIDER_SEND_TURN_MAX_ATTACHMENTS
-    ) {
+    if (draft.attachments.length > PROVIDER_SEND_TURN_MAX_ATTACHMENTS) {
       Dialog.alert(
         "Too many attachments",
         `Remove attachments until there are at most ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS}.`,
       );
       return;
     }
+    watchThreadQueuedEdit(thread);
     const finishSave = startQueuedRunEditSave(threadKey);
     if (finishSave === null) return;
     savingQueuedEditRef.current = true;
-    setIsSavingQueuedEdit(true);
     const capabilities = selectedEnvironmentRuntime?.serverConfig?.environment.capabilities;
     const prepared = await settlePromise(() =>
       prepareTurnAttachments({
@@ -442,7 +511,6 @@ export function useThreadComposerState(input: {
     );
     if (AsyncResult.isFailure(prepared)) {
       savingQueuedEditRef.current = false;
-      setIsSavingQueuedEdit(false);
       finishSave(false);
       const error = squashAtomCommandFailure(prepared);
       Dialog.alert(
@@ -453,12 +521,10 @@ export function useThreadComposerState(input: {
     }
     if (prepared.value.status !== "ready") {
       savingQueuedEditRef.current = false;
-      setIsSavingQueuedEdit(false);
       finishSave(false);
       return;
     }
     const payload = resolveQueuedEditPayload({
-      edit,
       draftContext: draft.context,
       draftAttachments: draft.attachments,
       uploaded: prepared.value.attachments,
@@ -468,6 +534,7 @@ export function useThreadComposerState(input: {
       input: {
         threadId: thread.id,
         runId: edit.runId,
+        editId: edit.editId,
         text: restoreAttachmentOnlyBootstrapPrompt(text, payload.attachments.length > 0),
         edit: {
           messageId: edit.messageId,
@@ -477,7 +544,6 @@ export function useThreadComposerState(input: {
       },
     });
     savingQueuedEditRef.current = false;
-    setIsSavingQueuedEdit(false);
     if (result._tag !== "Success") {
       // The run left the queue during the save; its exit already told the composer what happened.
       if (!finishSave(false)) return;
@@ -488,7 +554,10 @@ export function useThreadComposerState(input: {
       return;
     }
     // False when the edit was cancelled or begun again meanwhile; its draft is the newer edit's.
-    if (finishSave(true)) {
+    if (
+      finishSave(true) &&
+      getComposerDraftSnapshot(queuedEditDraftKey(threadKey, edit.runId)) === draft
+    ) {
       clearComposerDraft(queuedEditDraftKey(threadKey, edit.runId), {
         deferAttachmentCleanup: true,
       });
@@ -525,8 +594,9 @@ export function useThreadComposerState(input: {
     }
 
     const threadKey = scopedThreadKey(selectedThreadShell.environmentId, selectedThreadShell.id);
-    const draft = getComposerDraftSnapshot(threadKey);
-    if (appAtomRegistry.get(composerContextImportsAtom)[threadKey]) return null;
+    const draftKey = activeComposerDraftKey(selectedThreadShell);
+    const draft = getQueuedRecoverySendDraft(threadKey, draftKey);
+    if (appAtomRegistry.get(composerContextImportsAtom)[draftKey]) return null;
     const thread = selectedThreadShell;
     const text = draft.text.trim();
     const attachments = draft.attachments;
@@ -585,14 +655,14 @@ export function useThreadComposerState(input: {
             startingSideChatRef.current = false;
           });
         // Clear only what was sent; the draft may have changed while the side chat started.
-        const current = getComposerDraftSnapshot(threadKey);
+        const current = getComposerDraftSnapshot(draftKey);
         if (
           started &&
           current.text === draft.text &&
           current.attachments.length === 0 &&
           (current.context?.records.length ?? 0) === 0
         ) {
-          clearComposerDraftContent(threadKey);
+          clearComposerDraftContent(draftKey);
         }
       }
       return null;
@@ -607,7 +677,7 @@ export function useThreadComposerState(input: {
       isClearComposerCommand(text)
     ) {
       setFreshSessionPending(threadKey, true);
-      clearComposerDraftContent(threadKey);
+      clearComposerDraftContent(draftKey);
       return null;
     }
     // Recovery preserves over-cap attachments; require trimming or outbox delivery would reject indefinitely.
@@ -650,7 +720,7 @@ export function useThreadComposerState(input: {
           command: text,
           createdAt: metadata.createdAt,
         },
-        clearDraft: () => clearComposerDraftContent(threadKey),
+        clearDraft: () => clearComposerDraftContent(draftKey),
         onUpdate: (submission) => {
           setFeedbackSubmissionsByThreadKey((current) => {
             const existing = current[threadKey] ?? [];
@@ -680,8 +750,8 @@ export function useThreadComposerState(input: {
       if (!response) return null;
       // A context paste still landing, or any draft or settings change while approvals were
       // declined, means this snapshot is no longer what the user sent.
-      if (appAtomRegistry.get(composerContextImportsAtom)[threadKey]) return null;
-      const current = getComposerDraftSnapshot(threadKey);
+      if (appAtomRegistry.get(composerContextImportsAtom)[draftKey]) return null;
+      const current = getQueuedRecoverySendDraft(threadKey, draftKey);
       if (
         current.text !== draft.text ||
         JSON.stringify(current.context) !== JSON.stringify(draft.context) ||
@@ -693,7 +763,7 @@ export function useThreadComposerState(input: {
       )
         return null;
       if (response === "responded") {
-        clearComposerDraftContent(threadKey);
+        clearComposerDraftContent(draftKey);
         return null;
       }
     }
@@ -764,18 +834,18 @@ export function useThreadComposerState(input: {
       ...(freshContext ? { freshContext: true } : {}),
       createdAt: metadata.createdAt,
     });
-    clearComposerDraftContent(threadKey, { deferAttachmentCleanup: true });
+    clearComposerDraftContent(draftKey, { deferAttachmentCleanup: true });
     if (freshContext) setFreshSessionPending(threadKey, false);
     enqueuePromise.then(
       () => scheduleUnusedComposerAttachmentCleanup(attachments),
       (error: unknown) => {
         // Restore with uncapped append; capped merge could drop attachments added during the failed write.
-        void mergeComposerDraftContent(threadKey, {
+        void mergeComposerDraftContent(draftKey, {
           text,
           context: draft.context,
           attachments: [],
         });
-        appendComposerDraftAttachments(threadKey, attachments, { allowOverflow: true });
+        appendComposerDraftAttachments(draftKey, attachments, { allowOverflow: true });
         if (freshContext) setFreshSessionPending(threadKey, true);
         setThreadComposerError(
           threadKey,
@@ -857,9 +927,13 @@ export function useThreadComposerState(input: {
     queueHeld,
     resumableRunId,
     queuedRunEdit,
+    savedQueuedEditDrafts: queuedRunEdit === null ? savedQueuedEditDrafts : [],
+    recoveryDraftKey: selectedRecoveryDraftKey,
+    selectRecoveryDraft: (key: string | null) => {
+      if (selectedThreadKey !== null) selectQueuedEditRecovery(selectedThreadKey, key);
+    },
     isSavingQueuedEdit,
     cancelQueuedRunEdit,
-    onRemoveQueuedEditAttachment,
     modelSelection,
     pendingHandoff,
     canSwitchThreadProvider,
diff --git a/apps/server/src/environment/ServerEnvironment.test.ts b/apps/server/src/environment/ServerEnvironment.test.ts
index dc719ed93c41b..d4103cda452c3 100644
--- a/apps/server/src/environment/ServerEnvironment.test.ts
+++ b/apps/server/src/environment/ServerEnvironment.test.ts
@@ -242,6 +242,7 @@ it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))("ServerEnvironmen
       expect(second.capabilities.fileAttachments).toEqual({ maxUploadBytes: 50 * 1024 * 1024 });
       expect(second.capabilities.pullRequests).toBe(true);
       expect(second.capabilities.requiredWorktreeBootstrap).toBe(true);
+      expect(second.capabilities.queuedRunEditHold).toBe(true);
       expect(second.capabilities.usagePriceOverrides).toBe(true);
       expect(second.capabilities.threadActiveReorder).toBe(true);
       expect(second.capabilities.threadTitleRegeneration).toBe(true);
diff --git a/apps/server/src/environment/ServerEnvironment.ts b/apps/server/src/environment/ServerEnvironment.ts
index 9e29b0fdedc95..de30144cc7d0b 100644
--- a/apps/server/src/environment/ServerEnvironment.ts
+++ b/apps/server/src/environment/ServerEnvironment.ts
@@ -229,6 +229,7 @@ export const make = Effect.gen(function* () {
       sideChats: true,
       vcsBranchStatus: true,
       inlineMessageContext: true,
+      queuedRunEditHold: true,
       requiredWorktreeBootstrap: true,
       threadSettlement: true,
       threadAutoSettlement: true,
diff --git a/apps/server/src/orchestration-v2/Orchestrator.ts b/apps/server/src/orchestration-v2/Orchestrator.ts
index 07c1a544798be..f1097ae95e994 100644
--- a/apps/server/src/orchestration-v2/Orchestrator.ts
+++ b/apps/server/src/orchestration-v2/Orchestrator.ts
@@ -602,6 +602,8 @@ function commandThreadId(command: OrchestrationV2ServerCommand): ThreadId {
     case "queue.resume":
     case "queued-run.reorder":
     case "queued-run.cancel":
+    case "queued-run.edit.begin":
+    case "queued-run.edit.cancel":
     case "queued-run.edit":
     case "runtime-request.respond":
     case "runtime-request.delivery.fail":
@@ -1888,8 +1890,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
     function* (
       threadId: ThreadId,
       options?: {
-        readonly failedRunId?: RunId;
-        readonly endedRunId?: RunId;
+        readonly userResumed?: boolean;
         readonly queuedRunId?: RunId;
       },
     ) {
@@ -1931,14 +1932,21 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
       }
       // Failed worktree creation would run queued work in the project checkout; wait for the user.
       const failedRun = latestExecutedRun(projection.runs);
-      const failureClass =
-        failedRun?.id === options?.failedRunId
-          ? latestRootProviderFailure(failedRun, projection.turnItems)?.class
-          : undefined;
+      const failureClass = latestRootProviderFailure(failedRun, projection.turnItems)?.class;
       const worktreeMissing =
-        failedRun?.id === options?.endedRunId &&
         failedRun?.workspacePreparation?.type === "worktree" &&
         projection.thread.worktreePath === null;
+      // A client message sent after the failure already released its pause.
+      const failedAt = failedRun?.completedAt ?? null;
+      const sentByUserAfterFailure =
+        failedAt !== null &&
+        projection.messages.some(
+          (message) =>
+            message.createdBy === "user" &&
+            (message.creationSource === "web" || message.creationSource === "mobile") &&
+            message.scheduledTaskId === undefined &&
+            DateTime.isGreaterThan(message.createdAt, failedAt),
+        );
       const settings = yield* serverSettings.getSettings.pipe(Effect.orDie);
       const projectOverride =
         settings.projectSettingsOverrides[projection.thread.projectId]?.providerInstances?.[
@@ -1955,9 +1963,11 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
           ? !projectOverride
           : machineInstance !== undefined && !resolveProviderInstanceEnabled(machineInstance);
       if (
-        worktreeMissing ||
+        (worktreeMissing && options?.userResumed !== true) ||
         instanceDisabledForProject ||
-        (failureClass !== undefined &&
+        (options?.userResumed !== true &&
+          !sentByUserAfterFailure &&
+          failureClass !== undefined &&
           failureClass !== "validation_error" &&
           failedRun?.providerInstanceId === queuedRun.providerInstanceId)
       ) {
@@ -1976,6 +1986,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         );
         return;
       }
+      if (queuedRun.queueEditId != null) return;
       // Move queued ordinals after runs that started while they waited to preserve transcript and checkpoint order.
       // Started runs have prompts; cancelled queued messages do not.
       const newerRunIds = projection.runs
@@ -6387,7 +6398,12 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
       projection.thread.worktreePath === null
         ? latestRun
         : undefined;
-    const queueBehindRun = activeRun ?? worktreeMissingRun;
+    const nextQueuedRun =
+      dispatchMode.type === "queue_after_active"
+        ? queuedRunsInDeliveryOrder(projection)[0]
+        : undefined;
+    const editingQueueRun = nextQueuedRun?.queueEditId != null ? nextQueuedRun : undefined;
+    const queueBehindRun = activeRun ?? worktreeMissingRun ?? editingQueueRun;
     const pendingMergeBackTransfers = pendingMergeBackTransfersForThread(projection);
     const startsOrQueuesRun =
       dispatchMode.type === "defer_start" ||
@@ -10071,6 +10087,13 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         cause: `Queued run ${command.queuedRunId} is not queued.`,
       });
     }
+    if (queuedRun.queueEditId != null) {
+      return yield* new OrchestratorDispatchError({
+        commandId: command.commandId,
+        commandType: command.type,
+        cause: "Finish editing this queued message before steering with it.",
+      });
+    }
     const queuedRootNode =
       queuedRun.rootNodeId === null
         ? undefined
@@ -10394,10 +10417,13 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
   });
 
   const dispatchQueuedRunEdit = Effect.fn("Orchestrator.dispatchQueuedRunEdit")(function* (
-    command: Extract<OrchestrationV2Command, { readonly type: "queued-run.edit" }>,
+    command: Extract<
+      OrchestrationV2Command,
+      { readonly type: "queued-run.edit" | "queued-run.edit.begin" | "queued-run.edit.cancel" }
+    >,
     events: Ref.Ref<Array<OrchestrationV2DomainEvent>>,
   ) {
-    if (command.text.trim().length === 0) {
+    if (command.type === "queued-run.edit" && command.text.trim().length === 0) {
       return yield* new OrchestratorDispatchError({
         commandId: command.commandId,
         commandType: command.type,
@@ -10416,6 +10442,16 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         cause: `Run ${command.runId} is not queued.`,
       });
     }
+    const currentEditId = queuedRun.queueEditId ?? null;
+    const expectedEditId =
+      command.type === "queued-run.edit.begin" ? command.previousEditId : (command.editId ?? null);
+    if (currentEditId !== expectedEditId) {
+      return yield* new OrchestratorDispatchError({
+        commandId: command.commandId,
+        commandType: command.type,
+        cause: "This queued message is being edited by another editor.",
+      });
+    }
     const queuedMessage = projection.messages.find(
       (candidate) => candidate.id === queuedRun.userMessageId,
     );
@@ -10444,17 +10480,31 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         cause: "A guest's message cannot be edited. Cancel it instead.",
       });
     }
-    yield* ensureGoalCommandSupported(
-      command,
-      { text: command.text, attachments: command.attachments ?? queuedMessage.attachments },
-      queuedRun.providerInstanceId,
-    );
+    if (command.type === "queued-run.edit") {
+      yield* ensureGoalCommandSupported(
+        command,
+        { text: command.text, attachments: command.attachments ?? queuedMessage.attachments },
+        queuedRun.providerInstanceId,
+      );
+    }
     const queuedTurnItem = projection.turnItems.find(
       (candidate) => candidate.type === "user_message" && candidate.messageId === queuedMessage.id,
     );
 
     const now = yield* DateTime.now;
     const emitEvent = emit(events, command);
+    yield* emitEvent({
+      type: "run.updated",
+      threadId: command.threadId,
+      runId: queuedRun.id,
+      providerInstanceId: queuedRun.providerInstanceId,
+      occurredAt: now,
+      payload: {
+        ...queuedRun,
+        queueEditId: command.type === "queued-run.edit.begin" ? command.commandId : null,
+      },
+    });
+    if (command.type !== "queued-run.edit") return;
     const editedAttachments =
       command.attachments === undefined ? {} : { attachments: command.attachments };
     yield* emitEvent({
@@ -13772,6 +13822,13 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
             ? undefined
             : projection.runs.find((run) => run.id === selectedRunId && run.status === "queued");
         if (selectedRunId !== undefined) {
+          if (selectedRun?.queueEditId != null) {
+            return yield* new OrchestratorDispatchError({
+              commandId: command.commandId,
+              commandType: command.type,
+              cause: "Finish editing this queued message before sending it now.",
+            });
+          }
           const selectedMessage = projection.messages.find(
             (message) => message.id === selectedRun?.userMessageId,
           );
@@ -13838,6 +13895,8 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
       case "queued-run.cancel":
         yield* dispatchQueuedRunCancel(command, events);
         break;
+      case "queued-run.edit.begin":
+      case "queued-run.edit.cancel":
       case "queued-run.edit":
         yield* dispatchQueuedRunEdit(command, events);
         break;
@@ -13940,12 +13999,19 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
           }),
       ),
     );
-    if (command.type === "queue.resume" || command.type === "queued-run.start") {
+    if (
+      command.type === "queue.resume" ||
+      command.type === "queued-run.start" ||
+      command.type === "queued-run.edit" ||
+      command.type === "queued-run.edit.cancel" ||
+      command.type === "queued-run.reorder" ||
+      command.type === "queued-run.cancel"
+    ) {
       yield* mapDispatchError(command)(
-        startNextQueuedRun(
-          command.threadId,
-          command.type === "queued-run.start" ? { queuedRunId: command.runId } : undefined,
-        ),
+        startNextQueuedRun(command.threadId, {
+          userResumed: command.type === "queue.resume" || command.type === "queued-run.start",
+          ...(command.type === "queued-run.start" ? { queuedRunId: command.runId } : {}),
+        }),
       );
     }
     return {
@@ -14159,13 +14225,17 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
     if (
       command.type === "queue.resume" ||
       command.type === "queued-run.start" ||
+      command.type === "queued-run.edit" ||
+      command.type === "queued-run.edit.cancel" ||
+      command.type === "queued-run.reorder" ||
+      command.type === "queued-run.cancel" ||
       (command.type === "thread.runtime-mode.set" && runtimeModeCeiling !== undefined)
     ) {
       yield* mapDispatchError(command)(
-        startNextQueuedRun(
-          command.threadId,
-          command.type === "queued-run.start" ? { queuedRunId: command.runId } : undefined,
-        ),
+        startNextQueuedRun(command.threadId, {
+          userResumed: command.type === "queue.resume" || command.type === "queued-run.start",
+          ...(command.type === "queued-run.start" ? { queuedRunId: command.runId } : {}),
+        }),
       );
     }
     if (
@@ -14276,14 +14346,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
             (run.status === "completed"
               ? releaseUnattendedHolds(threadId, run.id)
               : Effect.void
-            ).pipe(
-              Effect.andThen(
-                startNextQueuedRun(threadId, {
-                  endedRunId: run.id,
-                  ...(run.status === "failed" ? { failedRunId: run.id } : {}),
-                }),
-              ),
-            ),
+            ).pipe(Effect.andThen(startNextQueuedRun(threadId))),
           )
           .pipe(
             Effect.catchCause((cause) =>
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.ts b/apps/server/src/orchestration-v2/ProjectionStore.ts
index 0c4976dc90598..cf1638b5e7d35 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.ts
@@ -6283,12 +6283,20 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
     };
     // The newest run not waiting in a held queue, matching latestUnheldRun.
     const presentedShellRunId = (threadId: Statement.Fragment) => sql`(
+      WITH edit_position AS MATERIALIZED (
+        SELECT MIN(COALESCE(json_extract(edit.payload_json, '$.queuePosition'), edit.ordinal)) AS position
+        FROM orchestration_v2_projection_runs edit
+        WHERE edit.thread_id = ${threadId} AND edit.status = 'queued'
+          AND json_extract(edit.payload_json, '$.queueEditId') IS NOT NULL
+      )
       SELECT candidate.run_id
       FROM orchestration_v2_projection_runs candidate
+      CROSS JOIN edit_position
       WHERE candidate.thread_id = ${threadId}
         AND NOT (
           candidate.status = 'queued'
-          AND json_extract(candidate.payload_json, '$.queueHeld') IS 1
+          AND (json_extract(candidate.payload_json, '$.queueHeld') IS 1
+            OR COALESCE(COALESCE(json_extract(candidate.payload_json, '$.queuePosition'), candidate.ordinal) >= edit_position.position, 0))
         )
         AND NOT ${isSilentShellRun("candidate")}
       ORDER BY candidate.ordinal DESC, candidate.run_id DESC
diff --git a/apps/server/src/orchestration-v2/runtimeLayer.test.ts b/apps/server/src/orchestration-v2/runtimeLayer.test.ts
index a49e323770cc1..ad2a3d56178b7 100644
--- a/apps/server/src/orchestration-v2/runtimeLayer.test.ts
+++ b/apps/server/src/orchestration-v2/runtimeLayer.test.ts
@@ -40,6 +40,7 @@ import * as Effect from "effect/Effect";
 import * as DateTime from "effect/DateTime";
 import * as Deferred from "effect/Deferred";
 import * as Fiber from "effect/Fiber";
+import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
@@ -9165,3 +9166,567 @@ it.layer(layerQueueResumeDisabledInstanceTest)(
     );
   },
 );
+
+const editableQueue = Effect.fnUntraced(function* (
+  name: string,
+  worktreePath: string | null = process.cwd(),
+) {
+  const orchestrator = yield* Orchestrator.OrchestratorV2;
+  const threadId = ThreadId.make(`edit-hold:${name}`);
+  const projectId = ProjectId.make(`${threadId}:project`);
+  yield* seedProject({
+    projectId,
+    title: name,
+    workspaceRoot: process.cwd(),
+    defaultModelSelection: modelSelection,
+    createdAt: DateTime.formatIso(yield* DateTime.now),
+  });
+  yield* orchestrator.dispatch({
+    type: "thread.create",
+    commandId: CommandId.make(`${threadId}:create`),
+    threadId,
+    projectId,
+    title: name,
+    modelSelection,
+    createdBy: "user",
+    creationSource: "web",
+    runtimeMode: "full-access",
+    interactionMode: "default",
+    branch: null,
+    worktreePath,
+  });
+  for (const [index, text] of ["Active", "Original", "Later"].entries()) {
+    yield* orchestrator.dispatch({
+      type: "message.dispatch",
+      commandId: CommandId.make(`${threadId}:message:${index}`),
+      threadId,
+      messageId: MessageId.make(`${threadId}:message:${index}`),
+      text,
+      attachments: [],
+      createdBy: "user",
+      creationSource: "web",
+      modelSelection,
+      dispatchMode: { type: index === 0 ? "start_immediately" : "queue_after_active" },
+    });
+  }
+  const [active, queued, later] = (yield* orchestrator.getThreadProjection(threadId)).runs;
+  assert.isDefined(active);
+  assert.isDefined(queued);
+  assert.isDefined(later);
+  const editId = CommandId.make(`${threadId}:begin`);
+  const begin = {
+    type: "queued-run.edit.begin" as const,
+    commandId: editId,
+    threadId,
+    runId: queued.id,
+    previousEditId: null,
+  };
+  const finish = (action: "save" | "cancel", token = editId) =>
+    action === "save"
+      ? {
+          type: "queued-run.edit" as const,
+          commandId: CommandId.make(`${threadId}:save:${token}`),
+          threadId,
+          runId: queued.id,
+          editId: token,
+          text: "Edited",
+        }
+      : {
+          type: "queued-run.edit.cancel" as const,
+          commandId: CommandId.make(`${threadId}:cancel:${token}`),
+          threadId,
+          runId: queued.id,
+          editId: token,
+        };
+  return { orchestrator, threadId, active, queued, later, editId, begin, finish };
+});
+
+const endQueueActiveRun = Effect.fnUntraced(function* (
+  active: OrchestrationV2Run,
+  reason: "completed" | "provider_error" | "missing_worktree" = "completed",
+) {
+  const sink = yield* EventSink.EventSinkV2;
+  const now = yield* DateTime.now;
+  yield* sink.write({
+    events: [
+      ...(reason === "provider_error"
+        ? [
+            {
+              id: EventId.make(`${active.id}:error`),
+              type: "turn-item.updated" as const,
+              threadId: active.threadId,
+              occurredAt: now,
+              payload: {
+                id: TurnItemId.make(`${active.id}:error`),
+                type: "error" as const,
+                threadId: active.threadId,
+                runId: active.id,
+                nodeId: active.rootNodeId,
+                providerThreadId: active.providerThreadId,
+                providerTurnId: null,
+                nativeItemRef: null,
+                parentItemId: null,
+                ordinal: 2,
+                status: "failed" as const,
+                title: "Provider failure",
+                startedAt: now,
+                completedAt: now,
+                updatedAt: now,
+                failure: {
+                  class: "provider_error" as const,
+                  message: "Provider failed.",
+                  code: "provider_failed",
+                  retryable: null,
+                },
+              },
+            },
+          ]
+        : []),
+      {
+        id: EventId.make(`${active.id}:terminal`),
+        type: "run.updated",
+        threadId: active.threadId,
+        runId: active.id,
+        occurredAt: now,
+        payload: {
+          ...active,
+          status:
+            reason === "completed"
+              ? "completed"
+              : reason === "provider_error"
+                ? "failed"
+                : "interrupted",
+          completedAt: now,
+          ...(reason === "missing_worktree"
+            ? { workspacePreparation: { type: "worktree" as const, baseRef: "main" } }
+            : {}),
+        },
+      },
+    ],
+  });
+});
+
+// Hold the terminal listener before its first lock so user commands can race
+// with its queue-pause reconciliation after the terminal event is durable.
+const pauseQueueTerminalListener = Effect.fnUntraced(function* (threadId: ThreadId) {
+  const executor = yield* ThreadCommandExecutor.ThreadCommandExecutor;
+  const entered = yield* Deferred.make<void>();
+  const released = yield* Deferred.make<void>();
+  const withLock = executor.withLock;
+  let paused = false;
+  const intercept: typeof withLock = (key, effect) => {
+    if (key !== threadId || paused) return withLock(key, effect);
+    paused = true;
+    return Deferred.succeed(entered, undefined).pipe(
+      Effect.andThen(Deferred.await(released)),
+      Effect.andThen(withLock(key, effect)),
+    );
+  };
+  const spy = vi.spyOn(executor, "withLock").mockImplementation(intercept);
+  yield* Effect.addFinalizer(() =>
+    Effect.sync(() => spy.mockRestore()).pipe(
+      Effect.andThen(Deferred.succeed(released, undefined)),
+    ),
+  );
+  return { entered: Deferred.await(entered) };
+});
+
+it.layer(layerTest)("queued edit holds", (it) => {
+  it.effect("queues new messages behind an edit even when Stop held the entire queue", () =>
+    Effect.gen(function* () {
+      const q = yield* editableQueue("send-after-stop");
+      yield* q.orchestrator.dispatch(q.begin);
+      yield* q.orchestrator.dispatch({
+        type: "run.interrupt",
+        commandId: CommandId.make(`${q.threadId}:stop`),
+        threadId: q.threadId,
+        runId: q.active.id,
+        holdQueue: true,
+      });
+      yield* q.orchestrator.dispatch({
+        type: "message.dispatch",
+        commandId: CommandId.make(`${q.threadId}:new-message`),
+        threadId: q.threadId,
+        messageId: MessageId.make(`${q.threadId}:new-message`),
+        text: "Wait behind the edit",
+        attachments: [],
+        createdBy: "user",
+        creationSource: "web",
+        modelSelection,
+        dispatchMode: { type: "queue_after_active" },
+      });
+      const after = yield* q.orchestrator.getThreadProjection(q.threadId);
+      assert.deepEqual(
+        after.runs.slice(1).map((run) => run.status),
+        ["queued", "queued", "queued"],
+      );
+      assert.isAbove(after.runs.at(-1)!.queuePosition!, q.later.queuePosition ?? q.later.ordinal);
+      yield* q.orchestrator.dispatch(q.finish("save"));
+      const resumed = yield* q.orchestrator.getThreadProjection(q.threadId);
+      assert.equal(resumed.runs.find((run) => run.id === q.queued.id)?.status, "starting");
+      assert.equal(resumed.runs.at(-1)?.status, "queued");
+    }),
+  );
+
+  it.effect("starts a new message after Stop when the edit is not first in line", () =>
+    Effect.gen(function* () {
+      const q = yield* editableQueue("send-after-stop-later-edit");
+      yield* q.orchestrator.dispatch({ ...q.begin, runId: q.later.id });
+      yield* q.orchestrator.dispatch({
+        type: "run.interrupt",
+        commandId: CommandId.make(`${q.threadId}:stop`),
+        threadId: q.threadId,
+        runId: q.active.id,
+        holdQueue: true,
+      });
+      yield* q.orchestrator.dispatch({
+        type: "message.dispatch",
+        commandId: CommandId.make(`${q.threadId}:new-message`),
+        threadId: q.threadId,
+        messageId: MessageId.make(`${q.threadId}:new-message`),
+        text: "Start now",
+        attachments: [],
+        createdBy: "user",
+        creationSource: "web",
+        modelSelection,
+        dispatchMode: { type: "queue_after_active" },
+      });
+      const after = yield* q.orchestrator.getThreadProjection(q.threadId);
+      assert.deepEqual(
+        after.runs.slice(1).map((run) => run.status),
+        ["queued", "queued", "starting"],
+      );
+    }),
+  );
+
+  it.effect("saving an edit after a send does not re-hold a released failure pause", () =>
+    Effect.gen(function* () {
+      const q = yield* editableQueue("send-after-failure");
+      yield* q.orchestrator.dispatch(q.begin);
+      yield* endQueueActiveRun(q.active, "provider_error");
+      yield* q.orchestrator.resumeQueuedRuns;
+      yield* TestClock.adjust("1 second");
+      yield* q.orchestrator.dispatch({
+        type: "message.dispatch",
+        commandId: CommandId.make(`${q.threadId}:new-message`),
+        threadId: q.threadId,
+        messageId: MessageId.make(`${q.threadId}:new-message`),
+        text: "Send after failure",
+        attachments: [],
+        createdBy: "user",
+        creationSource: "web",
+        modelSelection,
+        dispatchMode: { type: "queue_after_active" },
+      });
+      yield* q.orchestrator.dispatch(q.finish("save"));
+      const after = yield* q.orchestrator.getThreadProjection(q.threadId);
+      assert.deepEqual(
+        after.runs.slice(1).map((run) => run.status),
+        ["starting", "queued", "queued"],
+      );
+    }),
+  );
+
+  it.effect("lets an explicit Resume release a missing-worktree pause", () =>
+    Effect.gen(function* () {
+      const q = yield* editableQueue("resume-missing-worktree", null);
+      yield* endQueueActiveRun(q.active, "missing_worktree");
+      yield* q.orchestrator.resumeQueuedRuns;
+      assert.isTrue(
+        (yield* q.orchestrator.getThreadProjection(q.threadId)).runs.find(
+          (run) => run.id === q.queued.id,
+        )?.queueHeld,
+      );
+      yield* q.orchestrator.dispatch({
+        type: "queue.resume",
+        commandId: CommandId.make(`${q.threadId}:resume`),
+        threadId: q.threadId,
+      });
+      assert.equal(
+        (yield* q.orchestrator.getThreadProjection(q.threadId)).runs.find(
+          (run) => run.id === q.queued.id,
+        )?.status,
+        "starting",
+      );
+    }),
+  );
+
+  it.effect.each(["save", "cancel"] as const)(
+    "%s releases a durable hold after the active run completes, preserving queue order",
+    (action) =>
+      Effect.gen(function* () {
+        const q = yield* editableQueue(action);
+        const acquired = yield* q.orchestrator.dispatch(q.begin);
+        assert.deepEqual(yield* q.orchestrator.dispatch(q.begin), { ...acquired, replayed: true });
+        const holding = yield* q.orchestrator.getThreadProjection(q.threadId);
+        assert.deepEqual(
+          holding.runs.find((run) => run.id === q.active.id),
+          q.active,
+        );
+        assert.equal(holding.runs.find((run) => run.id === q.queued.id)?.queueEditId, q.editId);
+        const maintenance = yield* ProjectionReplay.ProjectionReplay;
+        assert.isTrue((yield* maintenance.rebuild).valid);
+        assert.equal(
+          (yield* q.orchestrator.getThreadProjection(q.threadId)).runs.find(
+            (run) => run.id === q.queued.id,
+          )?.queueEditId,
+          q.editId,
+        );
+
+        yield* endQueueActiveRun(q.active);
+        yield* q.orchestrator.resumeQueuedRuns;
+        yield* q.orchestrator.dispatch({
+          type: "queue.resume",
+          commandId: CommandId.make(`${q.threadId}:resume-while-editing`),
+          threadId: q.threadId,
+        });
+        assert.isTrue(
+          Exit.isFailure(
+            yield* Effect.exit(
+              q.orchestrator.dispatch({
+                type: "queued-run.start",
+                commandId: CommandId.make(`${q.threadId}:send-now-while-editing`),
+                threadId: q.threadId,
+                runId: q.queued.id,
+              }),
+            ),
+          ),
+        );
+        const held = yield* q.orchestrator.getThreadProjection(q.threadId);
+        const shell = (yield* q.orchestrator.getShellSnapshot()).threads.find(
+          (thread) => thread.id === q.threadId,
+        );
+        assert.equal(shell?.latestRunId, q.active.id);
+        assert.equal(shell?.status, "completed");
+        assert.deepEqual(
+          held.runs.map((run) => run.status),
+          ["completed", "queued", "queued"],
+        );
+        assert.isFalse(
+          held.turnItems.some((item) => item.runId === q.queued.id || item.runId === q.later.id),
+        );
+
+        yield* q.orchestrator.dispatch({
+          type: "message.dispatch",
+          commandId: CommandId.make(`${q.threadId}:while-held`),
+          threadId: q.threadId,
+          messageId: MessageId.make(`${q.threadId}:while-held`),
+          text: "Queued while editing an idle thread",
+          attachments: [],
+          createdBy: "user",
+          creationSource: "web",
+          modelSelection,
+          dispatchMode: { type: "queue_after_active" },
+        });
+        assert.equal(
+          (yield* q.orchestrator.getThreadProjection(q.threadId)).runs.at(-1)?.status,
+          "queued",
+        );
+        const finish = q.finish(action);
+        yield* q.orchestrator.dispatch(finish);
+        yield* q.orchestrator.dispatch(finish);
+        const after = yield* q.orchestrator.getThreadProjection(q.threadId);
+        assert.deepEqual(
+          after.runs.map((run) => run.status),
+          ["completed", "starting", "queued", "queued"],
+        );
+        assert.isNull(after.runs.find((run) => run.id === q.queued.id)?.queueEditId);
+        const messages = after.turnItems.filter(
+          (item) => item.type === "user_message" && item.runId === q.queued.id,
+        );
+        assert.equal(messages.length, 1);
+        assert.equal(
+          messages[0]?.type === "user_message" ? messages[0].text : null,
+          action === "save" ? "Edited" : "Original",
+        );
+      }),
+  );
+
+  it.effect("requires explicit takeover and rejects stale saves, cancels, and steering", () =>
+    Effect.gen(function* () {
+      const q = yield* editableQueue("takeover");
+      yield* q.orchestrator.dispatch(q.begin);
+      assert.isTrue(
+        Exit.isFailure(
+          yield* Effect.exit(
+            q.orchestrator.dispatch({
+              ...q.begin,
+              commandId: CommandId.make("takeover:unconfirmed"),
+            }),
+          ),
+        ),
+      );
+      const replacementId = CommandId.make("takeover:confirmed");
+      yield* q.orchestrator.dispatch({
+        ...q.begin,
+        commandId: replacementId,
+        previousEditId: q.editId,
+      });
+      for (const action of ["save", "cancel"] as const) {
+        assert.isTrue(
+          Exit.isFailure(yield* Effect.exit(q.orchestrator.dispatch(q.finish(action)))),
+        );
+      }
+      assert.isTrue(
+        Exit.isFailure(
+          yield* Effect.exit(
+            q.orchestrator.dispatch({
+              type: "queued-run.edit",
+              commandId: CommandId.make("takeover:tokenless-save"),
+              threadId: q.threadId,
+              runId: q.queued.id,
+              text: "Unowned overwrite",
+            }),
+          ),
+        ),
+      );
+      assert.isTrue(
+        Exit.isFailure(
+          yield* Effect.exit(
+            q.orchestrator.dispatch({
+              type: "queued-message.promote-to-steer",
+              commandId: CommandId.make("takeover:steer"),
+              threadId: q.threadId,
+              queuedRunId: q.queued.id,
+              targetRunId: q.active.id,
+            }),
+          ),
+        ),
+      );
+      const held = yield* q.orchestrator.getThreadProjection(q.threadId);
+      assert.equal(held.runs.find((run) => run.id === q.queued.id)?.queueEditId, replacementId);
+      assert.equal(
+        held.messages.find((message) => message.id === q.queued.userMessageId)?.text,
+        "Original",
+      );
+      yield* q.orchestrator.dispatch(q.finish("save", replacementId));
+      const saved = yield* q.orchestrator.getThreadProjection(q.threadId);
+      assert.equal(
+        saved.messages.find((message) => message.id === q.queued.userMessageId)?.text,
+        "Edited",
+      );
+      assert.equal(saved.runs.find((run) => run.id === q.queued.id)?.status, "queued");
+    }),
+  );
+
+  it.effect("dispatches an unheld predecessor reordered ahead of the held head", () =>
+    Effect.gen(function* () {
+      const q = yield* editableQueue("reorder");
+      yield* q.orchestrator.dispatch(q.begin);
+      yield* endQueueActiveRun(q.active);
+      yield* q.orchestrator.resumeQueuedRuns;
+      const reorder = {
+        type: "queued-run.reorder" as const,
+        commandId: CommandId.make("edit-hold:reorder:move"),
+        threadId: q.threadId,
+        runId: q.later.id,
+        beforeRunId: q.queued.id,
+      };
+      yield* q.orchestrator.dispatch(reorder);
+      yield* q.orchestrator.dispatch(reorder);
+      const after = yield* q.orchestrator.getThreadProjection(q.threadId);
+      assert.equal(after.runs.find((run) => run.id === q.later.id)?.status, "starting");
+      assert.equal(after.runs.find((run) => run.id === q.queued.id)?.status, "queued");
+      assert.equal(after.runs.find((run) => run.id === q.queued.id)?.queueEditId, q.editId);
+      assert.isFalse(after.turnItems.some((item) => item.runId === q.queued.id));
+      assert.equal(
+        after.turnItems.filter((item) => item.type === "user_message" && item.runId === q.later.id)
+          .length,
+        1,
+      );
+    }),
+  );
+
+  it.effect.each(["provider_error", "missing_worktree"] as const)(
+    "Save and Cancel preserve a %s pause before the terminal listener runs",
+    (reason) =>
+      Effect.gen(function* () {
+        const q = yield* editableQueue(reason, null);
+        yield* q.orchestrator.dispatch(q.begin);
+        const laterEditId = CommandId.make(`${q.threadId}:later-edit`);
+        yield* q.orchestrator.dispatch({
+          ...q.begin,
+          runId: q.later.id,
+          commandId: laterEditId,
+        });
+        const listener = yield* pauseQueueTerminalListener(q.threadId);
+        yield* endQueueActiveRun(q.active, reason);
+        yield* listener.entered;
+        assert.isFalse(
+          (yield* q.orchestrator.getThreadProjection(q.threadId)).runs.some((run) => run.queueHeld),
+        );
+        yield* q.orchestrator.resumeQueuedRuns;
+        const pausedDuringEdit = yield* q.orchestrator.getThreadProjection(q.threadId);
+        assert.isTrue(pausedDuringEdit.runs.find((run) => run.id === q.queued.id)?.queueHeld);
+        assert.equal(
+          pausedDuringEdit.runs.find((run) => run.id === q.queued.id)?.queueEditId,
+          q.editId,
+        );
+        yield* q.orchestrator.dispatch(q.finish("save"));
+        yield* q.orchestrator.dispatch({
+          type: "queued-run.edit.cancel",
+          commandId: CommandId.make(`${q.threadId}:later-cancel`),
+          threadId: q.threadId,
+          runId: q.later.id,
+          editId: laterEditId,
+        });
+        yield* q.orchestrator.resumeQueuedRuns;
+        const after = yield* q.orchestrator.getThreadProjection(q.threadId);
+        for (const runId of [q.queued.id, q.later.id]) {
+          const run = after.runs.find((run) => run.id === runId);
+          assert.equal(run?.status, "queued");
+          assert.isTrue(run?.queueHeld);
+          assert.isNull(run?.queueEditId);
+          assert.isFalse(after.turnItems.some((item) => item.runId === runId));
+        }
+      }),
+  );
+
+  it.effect.each(["stop", "restart"] as const)(
+    "releasing edit holds preserves the %s pause",
+    (reason) =>
+      Effect.gen(function* () {
+        const q = yield* editableQueue(reason);
+        yield* q.orchestrator.dispatch(q.begin);
+        if (reason === "stop") {
+          yield* q.orchestrator.dispatch({
+            type: "run.interrupt",
+            commandId: CommandId.make(`${q.threadId}:stop`),
+            threadId: q.threadId,
+            runId: q.active.id,
+            holdQueue: true,
+          });
+        } else {
+          const recovery = yield* ProviderRuntimeRecoveryService.ProviderRuntimeRecoveryService;
+          yield* recovery.reconcile("startup");
+        }
+        assert.isTrue(
+          Exit.isFailure(
+            yield* Effect.exit(
+              q.orchestrator.dispatch({
+                type: "queued-run.start",
+                commandId: CommandId.make(`${q.threadId}:stale-send-now`),
+                threadId: q.threadId,
+                runId: q.queued.id,
+              }),
+            ),
+          ),
+        );
+        assert.equal(
+          (yield* q.orchestrator.getThreadProjection(q.threadId)).runs.find(
+            (run) => run.id === q.queued.id,
+          )?.queueEditId,
+          q.editId,
+        );
+        yield* q.orchestrator.dispatch(q.finish(reason === "stop" ? "save" : "cancel"));
+        yield* q.orchestrator.resumeQueuedRuns;
+        const after = yield* q.orchestrator.getThreadProjection(q.threadId);
+        for (const id of [q.queued.id, q.later.id]) {
+          assert.equal(after.runs.find((run) => run.id === id)?.status, "queued");
+          assert.isTrue(after.runs.find((run) => run.id === id)?.queueHeld);
+          assert.isFalse(after.turnItems.some((item) => item.runId === id));
+        }
+        assert.isNull(after.runs.find((run) => run.id === q.queued.id)?.queueEditId);
+      }),
+  );
+});
diff --git a/apps/server/src/orchestration-v2/testkit/OrchestratorScenario.ts b/apps/server/src/orchestration-v2/testkit/OrchestratorScenario.ts
index b413c0aefa259..0df7dc6b28f6e 100644
--- a/apps/server/src/orchestration-v2/testkit/OrchestratorScenario.ts
+++ b/apps/server/src/orchestration-v2/testkit/OrchestratorScenario.ts
@@ -178,6 +178,8 @@ function commandThreadIds(command: OrchestrationV2Command): ReadonlyArray<Thread
     case "queue.resume":
     case "queued-run.reorder":
     case "queued-run.cancel":
+    case "queued-run.edit.begin":
+    case "queued-run.edit.cancel":
     case "queued-run.edit":
     case "runtime-request.respond":
     case "thread.user-input.dismiss":
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index f4561188df0cc..672151808b844 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -154,6 +154,7 @@ import { useMediaQuery } from "../hooks/useMediaQuery";
 import { FileMetadataThreadProvider } from "../hooks/FileMetadataThreadProvider";
 import { RIGHT_PANEL_INLINE_LAYOUT_MEDIA_QUERY } from "../rightPanelLayout";
 import { PopoverCreateHandle } from "./ui/popover";
+import { Button } from "./ui/button";
 import {
   selectActiveRightPanel,
   selectActiveRightPanelSurface,
@@ -503,7 +504,7 @@ export default function ChatView(props: ChatViewProps) {
     environmentId,
     routeThreadRef,
     threadDraftTarget: baseComposerDraftTarget,
-    activeThreadId: serverThread !== null || draftThread !== null ? threadId : null,
+    activeThreadId: routeThreadDetailRef?.threadId ?? null,
     serverProjection,
     promptRef,
     composerRef,
@@ -3529,6 +3530,31 @@ export default function ChatView(props: ChatViewProps) {
                         : undefined
                     }
                   >
+                    {queuedRunEdit.savedEditDrafts.length > 0 ? (
+                      <div className="flex flex-wrap gap-2 py-1">
+                        {queuedRunEdit.recoveryTarget !== null ? (
+                          <Button
+                            size="xs"
+                            variant="ghost-muted"
+                            onClick={() => queuedRunEdit.selectRecoveryTarget(null)}
+                          >
+                            Main draft
+                          </Button>
+                        ) : null}
+                        {queuedRunEdit.savedEditDrafts.map((target, index) => (
+                          <Button
+                            key={target}
+                            size="xs"
+                            variant="ghost-muted"
+                            onClick={() => queuedRunEdit.selectRecoveryTarget(target)}
+                          >
+                            {queuedRunEdit.recoveryTarget === target
+                              ? "Recovered queued edit"
+                              : `Saved queued edit ${index + 1}`}
+                          </Button>
+                        ))}
+                      </div>
+                    ) : null}
                     <ChildThreadApprovals threadRef={activeThreadRef} />
                     <div className="relative">
                       <ComposerSurface.Shell contextRow={showComposerContextStrip}>
@@ -3714,10 +3740,7 @@ export default function ChatView(props: ChatViewProps) {
                                 setThreadError={setThreadError}
                                 onExpandImage={onExpandTimelineImageStable}
                                 onFileOpen={openFileAttachmentStable}
-                                editingQueuedAttachments={queuedRunEdit.editingAttachments}
-                                onRemoveEditingQueuedAttachment={
-                                  queuedRunEdit.removeEditingAttachment
-                                }
+                                isEditingQueuedMessage={queuedRunEdit.isEditing}
                               />
                             )}
                           </div>
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx
index cba7c434b1bab..6b45aa6bf5d0d 100644
--- a/apps/web/src/components/chat/ChatComposer.tsx
+++ b/apps/web/src/components/chat/ChatComposer.tsx
@@ -20,7 +20,6 @@ import {
 import type {
   KeybindingCommand,
   AssistantCitation,
-  ChatAttachment as ContractChatAttachment,
   ChatFileAttachment,
   EnvironmentId,
   ModelSelection,
@@ -203,7 +202,6 @@ import {
   ComposerAttachmentFileList,
   ComposerAttachmentMediaRow,
   ComposerFilePreviewDialog,
-  ComposerQueuedAttachmentRow,
   ComposerRestingImagePreviews,
 } from "./ComposerAttachmentStrip";
 import { ComposerPrimaryActions } from "./ComposerPrimaryActions";
@@ -442,11 +440,7 @@ export interface ChatComposerProps {
   onPageScrollKeyUp: (key: string) => void;
   onPageScrollRelease: () => void;
 
-  editingQueuedAttachments: ReadonlyArray<{
-    readonly attachment: ContractChatAttachment;
-    readonly url: string | null;
-  }> | null;
-  onRemoveEditingQueuedAttachment: (attachmentId: string) => void;
+  isEditingQueuedMessage: boolean;
 
   onCompactContext: () => void;
   onSend: (
@@ -573,8 +567,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     setThreadError,
     onExpandImage,
     onFileOpen,
-    editingQueuedAttachments,
-    onRemoveEditingQueuedAttachment,
+    isEditingQueuedMessage,
   } = props;
   const primaryEnvironmentId = usePrimaryEnvironmentId();
   const composerDraftTargetKey = composerTargetKey(composerDraftTarget);
@@ -604,7 +597,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
   const activePendingProgress = holdingUserInput ? null : incomingPendingProgress;
   const activePendingIsResponding = !holdingUserInput && incomingPendingIsResponding;
   const isLiteralPendingAnswer = activePendingProgress?.activeQuestion?.initialAnswer !== undefined;
-  const isEditingQueuedMessage = editingQueuedAttachments !== null;
   const applyThreadModelPick = useApplyThreadModelPick();
   const composerDraft = useComposerThreadDraft(composerDraftTarget);
   const composerDraftTargetKeyRef = useRef("");
@@ -1076,7 +1068,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
   const composerSendState = deriveComposerSendState({
     prompt,
     imageCount: composerImages.length + composerFiles.length,
-    existingAttachmentCount: editingQueuedAttachments?.length ?? 0,
     terminalContexts: composerTerminalContexts,
     elementContextCount: composerPreviewAnnotations.length + composerReviewComments.length,
   });
@@ -3421,16 +3412,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
                 </ComposerCommandMenuLayer>
               )}
 
-              {!isComposerCollapsedMobile &&
-                pendingUserInputs.length === 0 &&
-                editingQueuedAttachments !== null &&
-                editingQueuedAttachments.length > 0 && (
-                  <ComposerQueuedAttachmentRow
-                    attachments={editingQueuedAttachments}
-                    onRemove={onRemoveEditingQueuedAttachment}
-                  />
-                )}
-
               {composerAttachmentMediaRow}
 
               {composerAttachmentFileList}
diff --git a/apps/web/src/components/chat/ComposerAttachmentStrip.tsx b/apps/web/src/components/chat/ComposerAttachmentStrip.tsx
index ca98b4d2f6c79..2177506fd8bed 100644
--- a/apps/web/src/components/chat/ComposerAttachmentStrip.tsx
+++ b/apps/web/src/components/chat/ComposerAttachmentStrip.tsx
@@ -1,5 +1,4 @@
 import type {
-  ChatAttachment,
   ChatFileAttachment,
   EnvironmentId,
   ScopedThreadRef,
@@ -659,46 +658,6 @@ export function ComposerRestingImagePreviews({
   );
 }
 
-/** Attachments of the queued message being edited; they are already uploaded. */
-export function ComposerQueuedAttachmentRow({
-  attachments,
-  onRemove,
-}: {
-  readonly attachments: ReadonlyArray<{
-    readonly attachment: ChatAttachment;
-    readonly url: string | null;
-  }>;
-  readonly onRemove: (attachmentId: string) => void;
-}) {
-  return (
-    <div className="mb-3 flex flex-wrap gap-2">
-      {attachments.map(({ attachment, url }) => (
-        <div
-          key={attachment.id}
-          className="relative h-16 w-16 overflow-hidden rounded-lg border border-border/80 bg-background"
-        >
-          {attachment.type === "image" && url ? (
-            <img src={url} alt={attachment.name} className="h-full w-full object-cover" />
-          ) : (
-            <div className="flex h-full w-full items-center justify-center px-1 text-center text-3xs text-secondary-label">
-              {attachment.name}
-            </div>
-          )}
-          <Button
-            variant="media-close"
-            size="icon-xs"
-            className="absolute right-1 top-1"
-            onClick={() => onRemove(attachment.id)}
-            aria-label={`Remove ${attachment.name}`}
-          >
-            <XIcon />
-          </Button>
-        </div>
-      ))}
-    </div>
-  );
-}
-
 export function ComposerAttachButton({
   addComposerAttachments,
   focusComposer,
diff --git a/apps/web/src/components/chat/QueuedRunsControl.browser.test.tsx b/apps/web/src/components/chat/QueuedRunsControl.browser.test.tsx
index 7e25e84135ba5..bc5b409d17f42 100644
--- a/apps/web/src/components/chat/QueuedRunsControl.browser.test.tsx
+++ b/apps/web/src/components/chat/QueuedRunsControl.browser.test.tsx
@@ -65,6 +65,30 @@ async function renderQueue(props: Partial<ComponentProps<typeof QueuedRunsContro
   return renderUi(<QueuedRunsControl {...baseProps} {...props} />);
 }
 
+it("keeps held messages editable without offering Send now", async () => {
+  setup();
+  state.projection = { projection: { messages: [] } };
+  state.workflow = {
+    activeRun: null,
+    canSendNow: true,
+    queuedRuns: [
+      {
+        run: { id: "run:held", userMessageId: "message:held", queueEditId: "edit:other-device" },
+        text: "Wait for my edit",
+        attachments: [],
+      },
+    ],
+  };
+  const onEditQueuedRun = vi.fn();
+  await using _screen = await renderQueue({ onEditQueuedRun });
+  await expect.element(page.getByText("Editing elsewhere")).toBeVisible();
+  await expect.element(page.getByRole("button", { name: "Send now" })).not.toBeInTheDocument();
+  await page.getByRole("button", { name: "Edit queued message", exact: true }).click();
+  expect(onEditQueuedRun).toHaveBeenCalledExactlyOnceWith(
+    expect.objectContaining({ runId: "run:held" }),
+  );
+});
+
 it("previews assistant quotes as readable text and preserves the citation when editing", async () => {
   setup();
   const quotedText = "Cache the parsed config per worktree.";
diff --git a/apps/web/src/components/chat/QueuedRunsControl.tsx b/apps/web/src/components/chat/QueuedRunsControl.tsx
index 2b2cfa78dce2b..a1c52b7702d36 100644
--- a/apps/web/src/components/chat/QueuedRunsControl.tsx
+++ b/apps/web/src/components/chat/QueuedRunsControl.tsx
@@ -147,6 +147,7 @@ export function QueuedRunsControl({
           url: queuedImageUrlById.get(attachment.id) ?? null,
         })),
       pending: false,
+      held: run.queueEditId != null,
     })),
     ...optimisticQueued.map((message) => ({
       key: message.id,
@@ -166,14 +167,19 @@ export function QueuedRunsControl({
           url: attachment.previewUrl ?? null,
         })),
       pending: true,
+      held: false,
     })),
   ];
 
   const sendQueuedMessage = async (queuedRunId: RunId) => {
-    const freshContext = queued.some(
-      ({ run }) => run.id === queuedRunId && run.freshContext === true,
-    );
-    if (!canSendRun(freshContext) || steerInFlightRef.current) return;
+    const item = queued.find(({ run }) => run.id === queuedRunId);
+    if (
+      !item ||
+      item.run.queueEditId != null ||
+      !canSendRun(item.run.freshContext === true) ||
+      steerInFlightRef.current
+    )
+      return;
     steerInFlightRef.current = true;
     setBusyRunId(queuedRunId);
     if (workflow?.canSendNow) {
@@ -194,7 +200,8 @@ export function QueuedRunsControl({
   useImperativeHandle(ref, () => ({
     steerNext(repeat) {
       const next = queued[0];
-      if (!next || !canSendRun(next.run.freshContext === true)) return false;
+      if (!next || next.run.queueEditId != null || !canSendRun(next.run.freshContext === true))
+        return false;
       if (!repeat && busyRunId === null) void sendQueuedMessage(next.run.id);
       return true;
     },
@@ -275,7 +282,7 @@ export function QueuedRunsControl({
                 timestampFormat={props.timestampFormat}
                 onOpenThread={props.onOpenThread}
               >
-                {canSendRun(item.freshContext) && !isEditing ? (
+                {canSendRun(item.freshContext) && !isEditing && !item.held ? (
                   <>
                     <Tooltip>
                       <TooltipTrigger render={<span className="flex shrink-0" />}>
@@ -305,6 +312,9 @@ export function QueuedRunsControl({
                     Saving
                   </span>
                 ) : null}
+                {item.held && !isEditing ? (
+                  <span className="px-1 text-foreground">Editing elsewhere</span>
+                ) : null}
                 {isEditing ? (
                   <>
                     <span className="px-1 text-foreground">Editing in the composer</span>
diff --git a/apps/web/src/components/chat/queuedMessageEdit.test.ts b/apps/web/src/components/chat/queuedMessageEdit.test.ts
index f7aed151f2fcc..cbea9e83bdd31 100644
--- a/apps/web/src/components/chat/queuedMessageEdit.test.ts
+++ b/apps/web/src/components/chat/queuedMessageEdit.test.ts
@@ -1,20 +1,57 @@
-import { EnvironmentId, ThreadId } from "@t3tools/contracts";
+import {
+  collectComposerContextReferences,
+  formatComposerContextReference,
+} from "@t3tools/shared/composerContextReferences";
+import {
+  ChatAttachmentId,
+  CommandId,
+  ComposerContextId,
+  EnvironmentId,
+  MessageId,
+  RunId,
+  ThreadId,
+} from "@t3tools/contracts";
 import { scopeThreadRef } from "@t3tools/client-runtime/environment";
-import { beforeEach, describe, expect, it } from "vite-plus/test";
+import { afterAll, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+vi.hoisted(() => {
+  const values = new Map<string, string>();
+  const storage = {
+    getItem: (key: string) => values.get(key) ?? null,
+    setItem: (key: string, value: string) => values.set(key, value),
+    removeItem: (key: string) => values.delete(key),
+  };
+  vi.stubGlobal("localStorage", storage);
+  vi.stubGlobal("window", { localStorage: storage });
+});
+afterAll(() => vi.unstubAllGlobals());
 import {
   DraftId,
   useComposerDraftStore,
+  partializeComposerDraftStoreState,
+  hydrateImagesFromPersisted,
   type ComposerFileAttachment,
   type ComposerImageAttachment,
 } from "../../composerDraftStore";
-import { prepareQueuedEditAttachments, recoverQueuedMessageEdit } from "./queuedMessageEdit";
+import {
+  prepareQueuedEditPayload,
+  prepareQueuedMessageEditDraft,
+  recoverQueuedMessageEdit,
+  releaseQueuedMessageEditDraft,
+} from "./queuedMessageEdit";
 
 const environmentId = EnvironmentId.make("remote-environment");
 const threadTarget = scopeThreadRef(environmentId, ThreadId.make("thread:edit"));
 const editTarget = DraftId.make("queued-edit:test");
+const edit = {
+  editId: CommandId.make("edit-1"),
+  sequence: 1,
+  runId: RunId.make("run-1"),
+  messageId: MessageId.make("message-1"),
+};
+
 const file: ComposerFileAttachment = {
   type: "file",
-  id: "file:report",
+  id: ChatAttachmentId.make("file-report"),
   name: "report.pdf",
   mimeType: "application/pdf",
   sizeBytes: 6,
@@ -22,22 +59,60 @@ const file: ComposerFileAttachment = {
 };
 const image: ComposerImageAttachment = {
   type: "image",
-  id: "image:screen",
+  id: ChatAttachmentId.make("image-screen"),
   name: "screen.png",
   mimeType: "image/png",
   sizeBytes: 5,
   file: new File(["image"], "screen.png", { type: "image/png" }),
   previewUrl: "blob:screen",
 };
+const emptyContent = {
+  images: [],
+  files: [],
+  terminalContexts: [],
+  reviewComments: [],
+  previewAnnotations: [],
+  threadContexts: [],
+  environmentContexts: [],
+};
+const payloadEdit = { ...edit, sourceText: "", originalText: "", originalAttachmentIds: [] };
 const uploadedFile = {
   type: "file" as const,
-  id: "upload:report",
+  id: ChatAttachmentId.make("upload-report"),
   name: file.name,
   mimeType: file.mimeType,
   sizeBytes: file.sizeBytes,
 };
 
 describe("queued message file edits", () => {
+  it("records stashed attachments as intentional removals", async () => {
+    const store = useComposerDraftStore.getState();
+    await prepareQueuedMessageEditDraft({
+      editTarget,
+      edit,
+      environmentId,
+      text: "Original message",
+      attachments: [uploadedFile],
+      readImage: async () => {
+        throw new Error("Unexpected image");
+      },
+    });
+    store.clearComposerPromptAndImages(editTarget);
+    store.setPrompt(editTarget, "Replacement text");
+    const draft = store.getComposerDraft(editTarget)!;
+    expect(draft.queuedEdit?.removedAttachmentIds).toEqual([uploadedFile.id]);
+    await expect(
+      prepareQueuedEditPayload({
+        edit: draft.queuedEdit!,
+        content: draft,
+        readImage: async () => {
+          throw new Error("Unexpected image");
+        },
+        uploadFiles: async () => [],
+      }),
+    ).resolves.toMatchObject({ attachments: [] });
+  });
+
   beforeEach(() => {
     useComposerDraftStore.setState({ draftsByThreadKey: {}, draftThreadsByThreadKey: {} });
   });
@@ -46,17 +121,16 @@ describe("queued message file edits", () => {
     { images: [], label: "file-only" },
     { images: [image], label: "mixed" },
   ])("preserves a generic file in a $label save", async ({ images }) => {
-    const attachments = await prepareQueuedEditAttachments({
-      existingAttachments: [],
-      images,
-      files: [file],
+    const attachments = await prepareQueuedEditPayload({
+      edit: payloadEdit,
+      content: { ...emptyContent, images, files: [file] },
       uploadFiles: async () => [uploadedFile],
       readImage: async () => "data:image/png;base64,aW1hZ2U=",
     });
-    expect(attachments.at(-1)).toEqual(uploadedFile);
-    expect(attachments.length).toBe(images.length + 1);
+    expect(attachments.attachments.at(-1)).toEqual(uploadedFile);
+    expect(attachments.attachments.length).toBe(images.length + 1);
     if (images.length > 0)
-      expect(attachments[0]).toMatchObject({
+      expect(attachments.attachments[0]).toMatchObject({
         type: "image",
         dataUrl: "data:image/png;base64,aW1hZ2U=",
       });
@@ -64,10 +138,9 @@ describe("queued message file edits", () => {
 
   it("fails a save instead of dropping a file whose upload is missing", async () => {
     await expect(
-      prepareQueuedEditAttachments({
-        existingAttachments: [],
-        images: [image],
-        files: [file],
+      prepareQueuedEditPayload({
+        edit: payloadEdit,
+        content: { ...emptyContent, images: [image], files: [file] },
         uploadFiles: async () => [],
         readImage: async () => "image",
       }),
@@ -86,39 +159,445 @@ describe("queued message file edits", () => {
     expect(store.getComposerDraft(editTarget)).toBeNull();
   });
 
-  it("reports a removed queued attachment as an edit when the run leaves", () => {
+  it("reports a removed queued attachment as an edit when the run leaves", async () => {
     const store = useComposerDraftStore.getState();
-    store.setPrompt(editTarget, "Original message");
+    await prepareQueuedMessageEditDraft({
+      editTarget,
+      edit,
+      environmentId,
+      text: "Original message",
+      attachments: [uploadedFile],
+      readImage: async () => {
+        throw new Error("Unexpected image");
+      },
+    });
+    store.removeFile(editTarget, uploadedFile.id);
     expect(
       recoverQueuedMessageEdit({
         editTarget,
         threadTarget,
         originalText: "Original message",
-        removedExistingAttachment: true,
+        originalAttachmentIds: [uploadedFile.id],
       }),
     ).toBe("kept");
     expect(store.getComposerDraft(threadTarget)?.prompt).toBe("Original message");
-    store.clearComposerContent(threadTarget);
-    // An attachment-only message leaves nothing to put back in the composer.
+  });
+
+  it("does not overwrite a separate draft when the queued run leaves", () => {
+    const store = useComposerDraftStore.getState();
+    store.setPrompt(threadTarget, "Separate draft");
+    store.addFiles(editTarget, [file]);
+    expect(recoverQueuedMessageEdit({ editTarget, threadTarget, originalText: "" })).toBe(
+      "retained",
+    );
+    expect(store.getComposerDraft(threadTarget)?.prompt).toBe("Separate draft");
+    expect(store.getComposerDraft(editTarget)?.files).toEqual([file]);
+  });
+
+  it("restores ownership and dirty content through draft hydration, then releases locally", async () => {
+    const store = useComposerDraftStore.getState();
+    await prepareQueuedMessageEditDraft({
+      editTarget,
+      edit,
+      environmentId,
+      text: "Original",
+      attachments: [],
+      readImage: async () => {
+        throw new Error("unused");
+      },
+    });
+    store.setPrompt(editTarget, "");
+    store.setPrompt(threadTarget, "Separate draft");
+    const persisted = JSON.parse(
+      JSON.stringify(partializeComposerDraftStoreState(useComposerDraftStore.getState())),
+    );
+    useComposerDraftStore.setState({ draftsByThreadKey: {} });
+    const merge = useComposerDraftStore.persist.getOptions().merge!;
+    useComposerDraftStore.setState(merge(persisted, useComposerDraftStore.getState()));
+    expect(store.getComposerDraft(editTarget)?.queuedEdit?.ownership).toEqual({
+      editId: edit.editId,
+      sequence: 1,
+    });
+    expect(store.getComposerDraft(editTarget)?.prompt).toBe("");
+    expect(store.getComposerDraft(threadTarget)?.prompt).toBe("Separate draft");
+    releaseQueuedMessageEditDraft(editTarget);
+    expect(store.getComposerDraft(editTarget)).toBeNull();
+    expect(
+      partializeComposerDraftStoreState(useComposerDraftStore.getState()).draftsByThreadKey[
+        editTarget
+      ],
+    ).toBeUndefined();
+  });
+
+  it("retains the acquired hold through attachment failure and reload until Cancel succeeds", async () => {
+    const store = useComposerDraftStore.getState();
+    await expect(
+      prepareQueuedMessageEditDraft({
+        editTarget,
+        edit,
+        environmentId,
+        text: "Original",
+        attachments: [
+          {
+            type: "image",
+            id: image.id,
+            name: image.name,
+            mimeType: image.mimeType,
+            sizeBytes: image.sizeBytes,
+          },
+        ],
+        readImage: async () => {
+          throw new Error("offline");
+        },
+      }),
+    ).rejects.toThrow("offline");
+    // Cleanup cannot reach the server while offline, so ownership must survive reload.
+    const persisted = JSON.parse(
+      JSON.stringify(partializeComposerDraftStoreState(useComposerDraftStore.getState())),
+    );
+    useComposerDraftStore.setState({ draftsByThreadKey: {} });
+    useComposerDraftStore.setState(
+      useComposerDraftStore.persist.getOptions().merge!(
+        persisted,
+        useComposerDraftStore.getState(),
+      ),
+    );
+    const draft = store.getComposerDraft(editTarget)!;
+    expect(draft.queuedEdit?.ownership).toEqual({ editId: edit.editId, sequence: edit.sequence });
+    await expect(
+      prepareQueuedEditPayload({
+        edit: draft.queuedEdit!,
+        content: draft,
+        readImage: async () => {
+          throw new Error("unused");
+        },
+        uploadFiles: async () => [],
+      }),
+    ).rejects.toThrow("attachment could not be restored");
+    // The normal Cancel path clears the draft only after the token's release succeeds.
+    store.clearComposerContent(editTarget);
+    expect(store.getComposerDraft(editTarget)).toBeNull();
+  });
+
+  it("recovers text typed while failed image preparation was pending after release", async () => {
+    const store = useComposerDraftStore.getState();
+    let rejectFetch!: (error: Error) => void;
+    const fetch = new Promise<never>((_resolve, reject) => {
+      rejectFetch = reject;
+    });
+    const preparation = prepareQueuedMessageEditDraft({
+      editTarget,
+      edit,
+      environmentId,
+      text: "Original",
+      attachments: [image],
+      readImage: () => fetch,
+    });
+    const preparedEdit = store.getComposerDraft(editTarget)!.queuedEdit!;
+    store.setPrompt(editTarget, "Keep what I typed during loading");
+    rejectFetch(new Error("offline"));
+    await expect(preparation).rejects.toThrow("offline");
     expect(
       recoverQueuedMessageEdit({
         editTarget,
         threadTarget,
-        originalText: "",
-        removedExistingAttachment: true,
+        originalText: preparedEdit.originalText,
+        originalAttachmentIds: preparedEdit.originalAttachmentIds,
+        expectedEdit: preparedEdit,
       }),
-    ).toBe("discarded");
+    ).toBe("kept");
+    expect(store.getComposerDraft(threadTarget)?.prompt).toBe("Keep what I typed during loading");
+    expect(store.getComposerDraft(editTarget)).toBeNull();
+  });
+
+  it("leaves a replacement fallback edit intact after an old preparation fails", async () => {
+    const store = useComposerDraftStore.getState();
+    let rejectFetch!: (error: Error) => void;
+    const fetch = new Promise<never>((_resolve, reject) => {
+      rejectFetch = reject;
+    });
+    const preparation = prepareQueuedMessageEditDraft({
+      editTarget,
+      edit: { ...edit, editId: null },
+      environmentId,
+      text: "Original",
+      attachments: [image],
+      readImage: () => fetch,
+    });
+    const preparedEdit = store.getComposerDraft(editTarget)!.queuedEdit!;
+    store.clearComposerContent(editTarget);
+    await prepareQueuedMessageEditDraft({
+      editTarget,
+      edit: { ...edit, editId: null },
+      environmentId,
+      text: "Original",
+      attachments: [],
+      readImage: async () => {
+        throw new Error("unused");
+      },
+    });
+    store.setPrompt(editTarget, "Replacement edit");
+    const replacement = store.getComposerDraft(editTarget);
+    rejectFetch(new Error("offline"));
+    await expect(preparation).rejects.toThrow("offline");
+    recoverQueuedMessageEdit({
+      editTarget,
+      threadTarget,
+      originalText: preparedEdit.originalText,
+      originalAttachmentIds: preparedEdit.originalAttachmentIds,
+      expectedEdit: preparedEdit,
+    });
+    expect(store.getComposerDraft(editTarget)).toBe(replacement);
     expect(store.getComposerDraft(threadTarget)).toBeNull();
   });
 
-  it("does not overwrite a separate draft when the queued run leaves", () => {
+  it.each(["text", "attachments"])(
+    "retains an older dirty edit separately when server %s changes",
+    async (change) => {
+      const store = useComposerDraftStore.getState();
+      const prepare = (text: string, attachments: (typeof uploadedFile)[]) =>
+        prepareQueuedMessageEditDraft({
+          editTarget,
+          edit,
+          environmentId,
+          text,
+          attachments,
+          readImage: async () => {
+            throw new Error("unused");
+          },
+        });
+      await prepare("Original", []);
+      store.setPrompt(editTarget, "My older edit");
+      releaseQueuedMessageEditDraft(editTarget);
+      await prepare("Original", []);
+      expect(store.getComposerDraft(editTarget)?.prompt).toBe("My older edit");
+      releaseQueuedMessageEditDraft(editTarget);
+      await prepare(
+        change === "text" ? "New server text" : "Original",
+        change === "attachments" ? [uploadedFile] : [],
+      );
+      const fresh = store.getComposerDraft(editTarget)!;
+      expect(fresh.prompt).toContain(change === "text" ? "New server text" : "Original");
+      expect(fresh.files.map((file) => file.id)).toEqual(
+        change === "attachments" ? [uploadedFile.id] : [],
+      );
+      const retained = Object.entries(useComposerDraftStore.getState().draftsByThreadKey).find(
+        ([key]) => key.startsWith(`${editTarget}:saved:`),
+      )?.[1];
+      expect(retained?.prompt).toBe("My older edit");
+      expect(retained?.queuedEdit?.ownership).toBeUndefined();
+      const retainedKey = Object.keys(useComposerDraftStore.getState().draftsByThreadKey).find(
+        (key) => key.startsWith(editTarget + ":saved:"),
+      )!;
+      store.setPrompt(DraftId.make(retainedKey), "");
+      expect(store.getComposerDraft(DraftId.make(retainedKey))).toBeNull();
+    },
+  );
+
+  it.each(["attachment removal", "text edit"])(
+    "recovers the selected server attachments after %s and restart",
+    async (change) => {
+      const store = useComposerDraftStore.getState();
+      const first = {
+        type: "image" as const,
+        id: ChatAttachmentId.make("saved-first"),
+        name: "first.png",
+        mimeType: "image/png",
+        sizeBytes: 5,
+      };
+      const second = { ...first, id: "saved:second", name: "second.png" };
+      const savedFile = { ...uploadedFile, id: "saved:file" };
+      const attachments = [first, second, savedFile];
+      await prepareQueuedMessageEditDraft({
+        editTarget,
+        edit,
+        environmentId,
+        text: "Original message",
+        attachments,
+        readImage: async (attachment) => ({
+          file: new File(["image"], attachment.name, { type: attachment.mimeType }),
+          dataUrl: "data:image/png;base64,aW1hZ2U=",
+        }),
+      });
+      const originalText = store.getComposerDraft(editTarget)!.prompt;
+      store.setPrompt(threadTarget, "Unrelated main draft");
+      if (change === "attachment removal") {
+        store.removeImage(editTarget, first.id);
+        expect(store.getComposerDraft(editTarget)?.prompt).toBe(originalText);
+      } else store.setPrompt(editTarget, `${originalText} edited`);
+      expect(
+        recoverQueuedMessageEdit({
+          editTarget,
+          threadTarget,
+          originalText,
+          originalAttachmentIds: attachments.map((attachment) => attachment.id),
+        }),
+      ).toBe("retained");
+      const persisted = JSON.parse(
+        JSON.stringify(partializeComposerDraftStoreState(useComposerDraftStore.getState())),
+      );
+      expect(
+        persisted.draftsByThreadKey["queued-edit:test"].attachments.map(
+          (attachment: { id: string }) => attachment.id,
+        ),
+      ).toEqual(change === "attachment removal" ? [second.id] : [first.id, second.id]);
+      expect(
+        hydrateImagesFromPersisted(persisted.draftsByThreadKey["queued-edit:test"].attachments).map(
+          (attachment) => attachment.id,
+        ),
+      ).toEqual(change === "attachment removal" ? [second.id] : [first.id, second.id]);
+      expect(persisted.draftsByThreadKey["queued-edit:test"].files).toEqual([
+        expect.objectContaining({ attachmentId: savedFile.id, environmentId }),
+      ]);
+      expect(store.getComposerDraft(threadTarget)?.prompt).toBe("Unrelated main draft");
+    },
+  );
+  it("saves bound existing image and file references, then removes them without orphaning text", async () => {
     const store = useComposerDraftStore.getState();
-    store.setPrompt(threadTarget, "Separate draft");
-    store.addFiles(editTarget, [file]);
-    expect(recoverQueuedMessageEdit({ editTarget, threadTarget, originalText: "" })).toBe(
-      "discarded",
+    const savedImage = {
+      type: "image" as const,
+      id: ChatAttachmentId.make("server-image"),
+      name: "screen.png",
+      mimeType: "image/png",
+      sizeBytes: 5,
+      source: {
+        kind: "snap-shot" as const,
+        capturedAt: "2026-10-19T00:00:00.000Z",
+        appName: "Browser",
+        windowTitle: "Test",
+      },
+    };
+    const savedFile = { ...uploadedFile, id: "server-file" };
+    const attachments = [savedFile, savedImage];
+    const records = attachments.map((attachment, index) => ({
+      version: 1 as const,
+      ...(attachment.type === "file" ? { kind: "file" as const } : { kind: "image" as const }),
+      contextId: ComposerContextId.make(`local-context-${index}`),
+      label: attachment.name,
+      attachmentId: attachment.id,
+      name: attachment.name,
+      mimeType: attachment.mimeType,
+      sizeBytes: attachment.sizeBytes,
+    }));
+    const text = records.map(formatComposerContextReference).join(" ");
+    await prepareQueuedMessageEditDraft({
+      editTarget,
+      edit: { ...edit, context: { version: 1, records } },
+      environmentId,
+      text,
+      attachments,
+      readImage: async () => ({ file: image.file, dataUrl: "data:image/png;base64,aW1hZ2U=" }),
+    });
+    const readImage = vi.fn(async () => "data:image/png;base64,aW1hZ2U=");
+    const save = () => {
+      const draft = store.getComposerDraft(editTarget)!;
+      return prepareQueuedEditPayload({
+        edit: draft.queuedEdit!,
+        content: draft,
+        readImage,
+        uploadFiles: async (files) =>
+          files.map((file) => ({ ...savedFile, id: file.uploadedAttachmentId! })),
+      });
+    };
+    store.setPrompt(editTarget, store.getComposerDraft(editTarget)!.prompt + " edited");
+    const kept = await save();
+    expect(readImage).not.toHaveBeenCalled();
+    expect(kept.attachments).toEqual(attachments);
+    expect(kept.attachments.map((attachment) => attachment.id)).toEqual([
+      savedFile.id,
+      savedImage.id,
+    ]);
+    const refs = collectComposerContextReferences(store.getComposerDraft(editTarget)!.prompt);
+    expect(refs).toHaveLength(2);
+    for (const ref of refs) {
+      expect(
+        kept.context.records.find((record) => record.contextId === ref.contextId),
+      ).toMatchObject({
+        attachmentId: ref.kind === "image" ? savedImage.id : savedFile.id,
+      });
+    }
+    const savedText = store.getComposerDraft(editTarget)!.prompt;
+    store.clearComposerContent(editTarget);
+    await prepareQueuedMessageEditDraft({
+      editTarget,
+      edit: { ...edit, context: kept.context },
+      environmentId,
+      text: savedText,
+      attachments: kept.attachments,
+      readImage: async () => ({ file: image.file, dataUrl: "data:image/png;base64,aW1hZ2U=" }),
+    });
+    store.removeImage(editTarget, savedImage.id);
+    store.removeFile(editTarget, savedFile.id);
+    const persisted = JSON.parse(
+      JSON.stringify(partializeComposerDraftStoreState(useComposerDraftStore.getState())),
     );
-    expect(store.getComposerDraft(threadTarget)?.prompt).toBe("Separate draft");
+    const merge = useComposerDraftStore.persist.getOptions().merge!;
+    useComposerDraftStore.setState(merge(persisted, useComposerDraftStore.getState()));
+    const removed = await save();
+    expect(removed.attachments).toEqual([]);
+    expect(removed.context.records).toEqual([]);
+    expect(collectComposerContextReferences(store.getComposerDraft(editTarget)!.prompt)).toEqual(
+      [],
+    );
+  });
+
+  it("rejects an image lost during persistence but saves an intentional removal after hydration", async () => {
+    const store = useComposerDraftStore.getState();
+    const saved = {
+      type: "image" as const,
+      id: ChatAttachmentId.make("server-image"),
+      name: image.name,
+      mimeType: image.mimeType,
+      sizeBytes: image.sizeBytes,
+    };
+    const prepare = () =>
+      prepareQueuedMessageEditDraft({
+        editTarget,
+        edit,
+        environmentId,
+        text: "Original",
+        attachments: [saved],
+        readImage: async () => ({ file: image.file, dataUrl: "data:image/png;base64,aW1hZ2U=" }),
+      });
+    await prepare();
+    store.setPrompt(threadTarget, "Occupied draft");
+    // Simulate the quota verifier omitting the image while retaining owned edit metadata.
+    const persisted = JSON.parse(
+      JSON.stringify(partializeComposerDraftStoreState(useComposerDraftStore.getState())),
+    );
+    persisted.draftsByThreadKey[editTarget].attachments = [];
+    const merge = useComposerDraftStore.persist.getOptions().merge!;
+    useComposerDraftStore.setState(merge(persisted, useComposerDraftStore.getState()));
+    const save = () => {
+      const draft = store.getComposerDraft(editTarget)!;
+      return prepareQueuedEditPayload({
+        edit: draft.queuedEdit!,
+        content: draft,
+        readImage: async () => "unused",
+        uploadFiles: async () => [],
+      });
+    };
+    await expect(save()).rejects.toThrow("attachment could not be restored");
+    expect(
+      recoverQueuedMessageEdit({
+        editTarget,
+        threadTarget,
+        originalText: "Original",
+        originalAttachmentIds: [saved.id],
+      }),
+    ).toBe("clean");
     expect(store.getComposerDraft(editTarget)).toBeNull();
+    expect(store.getComposerDraft(threadTarget)?.prompt).toBe("Occupied draft");
+    // Missing content cannot be reused as an intentional selection when reopening.
+    await prepare();
+    expect(store.getComposerDraft(editTarget)?.images.map((image) => image.id)).toEqual([saved.id]);
+    store.removeImage(editTarget, saved.id);
+    const removed = JSON.parse(
+      JSON.stringify(partializeComposerDraftStoreState(useComposerDraftStore.getState())),
+    );
+    useComposerDraftStore.setState(merge(removed, useComposerDraftStore.getState()));
+    expect((await save()).attachments).toEqual([]);
+    await prepare();
+    expect(store.getComposerDraft(editTarget)?.images).toEqual([]);
   });
 });
diff --git a/apps/web/src/components/chat/queuedMessageEdit.ts b/apps/web/src/components/chat/queuedMessageEdit.ts
index 40a222a9f383a..f408224f1cced 100644
--- a/apps/web/src/components/chat/queuedMessageEdit.ts
+++ b/apps/web/src/components/chat/queuedMessageEdit.ts
@@ -1,61 +1,297 @@
-import { resolveQueuedEditExit } from "@t3tools/client-runtime/queued-run-edit";
-import type { ChatAttachment } from "@t3tools/contracts";
+import {
+  stripAttachmentOnlyBootstrapPrompt,
+  replaceComposerContextReferences,
+  formatComposerContextReference,
+  toKindScopedComposerContextId,
+} from "@t3tools/shared/composerContextReferences";
+import { buildMessageContext } from "../../lib/composerContextRecords";
+import { randomUUID } from "../../lib/utils";
+import {
+  queuedEditDraftMatchesSource,
+  queuedEditDraftHasMissingAttachments,
+  type QueuedRunEditDraft,
+} from "@t3tools/client-runtime/state/queued-run-edit-draft";
+import type {
+  ChatAttachment,
+  ChatImageAttachment,
+  ChatFileAttachment,
+  EnvironmentId,
+} from "@t3tools/contracts";
 import {
   composerDraftHasUserContent,
+  createEmptyThreadDraft,
+  resolveComposerDraftKey,
   useComposerDraftStore,
   type ComposerFileAttachment,
-  type ComposerImageAttachment,
   type ComposerThreadTarget,
+  type ComposerThreadDraftState,
 } from "../../composerDraftStore";
 
+export async function prepareQueuedMessageEditDraft(input: {
+  readonly editTarget: ComposerThreadTarget;
+  readonly edit: Pick<QueuedRunEditDraft, "runId" | "messageId" | "context"> &
+    NonNullable<QueuedRunEditDraft["ownership"]>;
+  readonly environmentId: EnvironmentId;
+  readonly text: string;
+  readonly attachments: ReadonlyArray<ChatAttachment>;
+  readonly readImage: (attachment: ChatAttachment) => Promise<{ file: File; dataUrl: string }>;
+}) {
+  const store = useComposerDraftStore.getState();
+  const existing = store.getComposerDraft(input.editTarget);
+  const key = resolveComposerDraftKey(store, input.editTarget);
+  if (key === null) throw new Error("Queued edit draft unavailable.");
+  const contextIds = new Map(
+    (input.edit.context?.records ?? []).flatMap((record) =>
+      "attachmentId" in record && (record.kind === "image" || record.kind === "file")
+        ? [
+            [
+              record.contextId,
+              toKindScopedComposerContextId(record.kind, record.attachmentId),
+            ] as const,
+          ]
+        : [],
+    ),
+  );
+  const text = replaceComposerContextReferences(
+    stripAttachmentOnlyBootstrapPrompt(input.text),
+    (ref) => {
+      const contextId = contextIds.get(ref.contextId);
+      return contextId ? formatComposerContextReference({ ...ref, contextId }) : ref.source;
+    },
+  );
+  const context = input.edit.context && {
+    version: 1 as const,
+    records: input.edit.context.records.map((record) => ({
+      ...record,
+      contextId: contextIds.get(record.contextId) ?? record.contextId,
+      ...("screenshotContextId" in record && record.screenshotContextId
+        ? {
+            screenshotContextId:
+              contextIds.get(record.screenshotContextId) ?? record.screenshotContextId,
+          }
+        : {}),
+    })),
+  };
+  const matches =
+    queuedEditDraftMatchesSource(existing?.queuedEdit, input.text, input.attachments) &&
+    existing?.queuedEdit !== undefined &&
+    !queuedEditDraftHasMissingAttachments(existing.queuedEdit, [
+      ...existing.images,
+      ...existing.files,
+    ]) &&
+    existing.queuedEdit.context?.records.every(
+      (record) =>
+        !("attachmentId" in record) ||
+        (record.kind !== "image" && record.kind !== "file") ||
+        record.contextId === toKindScopedComposerContextId(record.kind, record.attachmentId),
+    ) !== false;
+  if (existing !== null && !matches) {
+    const { queuedEdit, ...content } = existing;
+    const retained = queuedEdit
+      ? { ...content, queuedEdit: { ...queuedEdit, ownership: undefined } }
+      : content;
+    const next = { ...store.draftsByThreadKey };
+    if (composerDraftHasUserContent(retained)) next[`${key}:saved:${randomUUID()}`] = retained;
+    delete next[key];
+    useComposerDraftStore.setState({ draftsByThreadKey: next });
+  }
+  if (matches && existing?.queuedEdit) {
+    const queuedEdit = existing.queuedEdit;
+    useComposerDraftStore.setState((state) => ({
+      draftsByThreadKey: {
+        ...state.draftsByThreadKey,
+        [key]: {
+          ...existing,
+          queuedEdit: {
+            ...queuedEdit,
+            ownership: { editId: input.edit.editId, sequence: input.edit.sequence },
+          },
+        },
+      },
+    }));
+    return;
+  }
+  useComposerDraftStore.setState((state) => {
+    const draft = state.draftsByThreadKey[key] ?? createEmptyThreadDraft();
+    return {
+      draftsByThreadKey: {
+        ...state.draftsByThreadKey,
+        [key]: {
+          ...draft,
+          prompt: text,
+          queuedEdit: {
+            runId: input.edit.runId,
+            messageId: input.edit.messageId,
+            sourceText: input.text,
+            originalText: text,
+            originalAttachmentIds: input.attachments.map((attachment) => attachment.id),
+            ...(context ? { context } : {}),
+            ownership: { editId: input.edit.editId, sequence: input.edit.sequence },
+          },
+        },
+      },
+    };
+  });
+  const ownership = store.getComposerDraft(input.editTarget)?.queuedEdit?.ownership;
+  const ownsDraft = () =>
+    store.getComposerDraft(input.editTarget)?.queuedEdit?.ownership === ownership;
+  if (
+    input.attachments.some(
+      (attachment) => attachment.type !== "image" && attachment.type !== "file",
+    )
+  )
+    throw new Error("This attachment cannot be edited.");
+  const images = await Promise.all(
+    input.attachments
+      .filter((attachment): attachment is ChatImageAttachment => attachment.type === "image")
+      .map(async (image) => {
+        const { file, dataUrl } = await input.readImage(image);
+        return { ...image, file, previewUrl: dataUrl, dataUrl };
+      }),
+  );
+  if (!ownsDraft()) return;
+  store.addImages(input.editTarget, images, { allowDuplicates: true });
+  await store.syncPersistedAttachments(input.editTarget, images);
+  if (!ownsDraft()) return;
+  store.addFiles(
+    input.editTarget,
+    input.attachments
+      .filter((attachment): attachment is ChatFileAttachment => attachment.type === "file")
+      .map((file) => ({
+        ...file,
+        file: null,
+        uploadedAttachmentId: file.id,
+        uploadEnvironmentId: input.environmentId,
+      })),
+    { allowDuplicates: true },
+  );
+}
+
+export function releaseQueuedMessageEditDraft(editTarget: ComposerThreadTarget) {
+  const store = useComposerDraftStore.getState();
+  const key = resolveComposerDraftKey(store, editTarget);
+  if (key === null) return;
+  const draft = store.draftsByThreadKey[key];
+  if (!draft?.queuedEdit) return;
+  useComposerDraftStore.setState({
+    draftsByThreadKey: {
+      ...store.draftsByThreadKey,
+      [key]: { ...draft, queuedEdit: { ...draft.queuedEdit, ownership: undefined } },
+    },
+  });
+  store.setPrompt(editTarget, draft.prompt);
+}
+
 export function recoverQueuedMessageEdit(input: {
   readonly editTarget: ComposerThreadTarget;
   readonly threadTarget: ComposerThreadTarget;
   readonly originalText: string;
-  readonly removedExistingAttachment?: boolean;
-}): "kept" | "discarded" | "clean" {
+  readonly originalAttachmentIds?: ReadonlyArray<string>;
+  readonly expectedEdit?: Pick<QueuedRunEditDraft, "runId" | "ownership">;
+}): "kept" | "retained" | "clean" {
   const store = useComposerDraftStore.getState();
+  const currentEdit = store.getComposerDraft(input.editTarget)?.queuedEdit;
+  if (
+    input.expectedEdit &&
+    (currentEdit?.runId !== input.expectedEdit.runId ||
+      currentEdit?.ownership !== input.expectedEdit.ownership)
+  )
+    return "clean";
+  releaseQueuedMessageEditDraft(input.editTarget);
   const draft = store.getComposerDraft(input.editTarget);
-  const recovery = resolveQueuedEditExit({
-    editChanged:
-      input.removedExistingAttachment === true ||
-      (draft !== null &&
-        (draft.prompt !== input.originalText || draft.images.length > 0 || draft.files.length > 0)),
-    // A cleared edit has nothing to put back, so it can only be discarded.
-    threadDraftEmpty:
-      composerDraftHasUserContent(draft) &&
-      !composerDraftHasUserContent(store.getComposerDraft(input.threadTarget)),
-  });
-  if (recovery === "kept") {
-    store.moveComposerPromptAndImages(input.editTarget, input.threadTarget);
-  } else {
+  const dirty =
+    draft !== null &&
+    (draft.prompt !== input.originalText ||
+      (draft.queuedEdit?.removedAttachmentIds?.length ?? 0) > 0 ||
+      [...draft.images, ...draft.files].some(
+        (attachment) => !input.originalAttachmentIds?.includes(attachment.id),
+      ) ||
+      draft.terminalContexts.length > 0 ||
+      draft.reviewComments.length > 0 ||
+      draft.previewAnnotations.length > 0 ||
+      draft.threadContexts.length > 0);
+  if (!dirty || draft === null) {
     store.clearComposerContent(input.editTarget);
+    return "clean";
   }
-  return recovery;
+  const fromKey = resolveComposerDraftKey(store, input.editTarget);
+  const toKey = resolveComposerDraftKey(store, input.threadTarget);
+  if (fromKey === null || toKey === null || fromKey === toKey) return "kept";
+  const destination = store.getComposerDraft(input.threadTarget);
+  if (composerDraftHasUserContent(destination)) return "retained";
+  const { queuedEdit: _queuedEdit, ...recovered } = draft;
+  const next = { ...store.draftsByThreadKey, [toKey]: recovered };
+  delete next[fromKey];
+  useComposerDraftStore.setState({ draftsByThreadKey: next });
+  return "kept";
 }
 
-export async function prepareQueuedEditAttachments(input: {
-  readonly existingAttachments: ReadonlyArray<ChatAttachment>;
-  readonly images: ReadonlyArray<ComposerImageAttachment>;
-  readonly files: ReadonlyArray<ComposerFileAttachment>;
+export async function prepareQueuedEditPayload(input: {
+  readonly edit: QueuedRunEditDraft;
+  readonly content: {
+    readonly [
+      Key in
+        | "images"
+        | "files"
+        | "terminalContexts"
+        | "reviewComments"
+        | "previewAnnotations"
+        | "threadContexts"
+        | "environmentContexts"
+    ]: Readonly<ComposerThreadDraftState[Key]>;
+  };
   readonly uploadFiles: (
     files: ReadonlyArray<ComposerFileAttachment>,
   ) => Promise<ReadonlyArray<ChatAttachment>>;
   readonly readImage: (file: File) => Promise<string>;
 }) {
-  const files = input.files.length === 0 ? [] : await input.uploadFiles(input.files);
-  if (files.length !== input.files.length)
+  const { edit, content } = input;
+  const drafts = [...content.images, ...content.files];
+  if (queuedEditDraftHasMissingAttachments(edit, drafts))
+    throw new Error(
+      "An attachment could not be restored. Cancel and reopen the edit to restore it before saving.",
+    );
+  const files = content.files.length === 0 ? [] : await input.uploadFiles(content.files);
+  if (files.length !== content.files.length)
     throw new Error("Retry or remove failed uploads before saving.");
   const images = await Promise.all(
-    input.images.map(async (image) => ({
+    content.images.map(async (image) => ({
       type: "image" as const,
       id: image.id,
       name: image.name,
       mimeType: image.mimeType,
       sizeBytes: image.sizeBytes,
-      dataUrl: await input.readImage(image.file),
+      ...(!edit.originalAttachmentIds.includes(image.id)
+        ? { dataUrl: await input.readImage(image.file) }
+        : {}),
       ...(image.source ? { source: image.source } : {}),
     })),
   );
-  return [...input.existingAttachments, ...images, ...files];
+  const uploaded = [...images, ...files];
+  const originalOrder = new Map(edit.originalAttachmentIds.map((id, index) => [id, index]));
+  const attachments = [...uploaded].sort(
+    (left, right) =>
+      (originalOrder.get(left.id) ?? originalOrder.size) -
+      (originalOrder.get(right.id) ?? originalOrder.size),
+  );
+  const records = [
+    ...(edit.context?.records ?? []).filter((record) => !("attachmentId" in record)),
+    ...(buildMessageContext({
+      ...content,
+      terminalContexts: content.terminalContexts.filter(
+        (context) => context.text.trim().length > 0,
+      ),
+      attachments: drafts.map((attachment, index) => ({
+        attachment,
+        attachmentId: uploaded[index]!.id,
+      })),
+    })?.records ?? []),
+  ];
+  return {
+    attachments,
+    context: {
+      version: 1 as const,
+      records: [...new Map(records.map((record) => [record.contextId, record])).values()],
+    },
+  };
 }
diff --git a/apps/web/src/components/chat/useQueuedRunEdit.browser.test.tsx b/apps/web/src/components/chat/useQueuedRunEdit.browser.test.tsx
index 4a58d25e48757..df88b54cd85d6 100644
--- a/apps/web/src/components/chat/useQueuedRunEdit.browser.test.tsx
+++ b/apps/web/src/components/chat/useQueuedRunEdit.browser.test.tsx
@@ -6,6 +6,7 @@ import {
   RunId,
   ThreadId,
   type ScopedThreadRef,
+  type ChatAttachment,
 } from "@t3tools/contracts";
 import { useImperativeHandle, type RefObject } from "react";
 import { describe, expect, it, vi } from "vite-plus/test";
@@ -27,6 +28,9 @@ interface RunStatus {
 const mocks = await vi.hoisted(async () => {
   const { Atom } = await import("effect/reactivity");
   return {
+    acquireEdit: vi.fn(async () => ({ _tag: "Success", value: { editId: null, sequence: 0 } })),
+    releaseEdit: vi.fn(async () => ({ _tag: "Success" })),
+    setThreadError: vi.fn(),
     editQueuedRun: vi.fn<(value: unknown) => Promise<{ readonly _tag: "Success" | "Failure" }>>(),
     // The projection's runs per thread, written by each test to stand in for the server.
     threadRuns: Atom.family((_key: string) =>
@@ -36,22 +40,58 @@ const mocks = await vi.hoisted(async () => {
 });
 
 vi.mock("../../state/use-atom-command", () => ({
-  useAtomCommand: () => mocks.editQueuedRun,
+  useAtomCommand: (command: unknown) =>
+    command === "begin"
+      ? mocks.acquireEdit
+      : command === "cancel"
+        ? mocks.releaseEdit
+        : mocks.editQueuedRun,
 }));
 
 vi.mock("../../hooks/useSettings", () => ({
   useEnvironmentIdentificationMode: () => "none",
 }));
 
+vi.mock("./composerAttachmentFiles", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("./composerAttachmentFiles")>()),
+  fileAttachmentCapabilityBlockReason: () => null,
+}));
+
+vi.mock("../../lib/attachmentUploadQueue", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../../lib/attachmentUploadQueue")>()),
+  startAttachmentUpload: () => {},
+  awaitAttachmentUploads: async () => {},
+  getUploadedAttachments: ({ images }: { images: ReadonlyArray<ChatAttachment> }) =>
+    images.map(({ type, id, name, mimeType, sizeBytes }) => ({
+      type,
+      id,
+      name,
+      mimeType,
+      sizeBytes,
+    })),
+}));
+
 const runsKey = (ref: ScopedThreadRef) => `${ref.environmentId}:${ref.threadId}`;
 
 vi.mock("../../state/threads", async () => {
   const { Atom } = await import("effect/reactivity");
+  const { useAtomValue } = await import("@effect/atom-react");
+  const Option = await import("effect/Option");
   const key = (ref: ScopedThreadRef) => `${ref.environmentId}:${ref.threadId}`;
   return {
+    useEnvironmentThread: (environmentId: string, threadId: string) => {
+      const runs = useAtomValue(mocks.threadRuns(`${environmentId}:${threadId}`));
+      return {
+        status: "live",
+        sequence: 0,
+        data: runs === null ? Option.none() : Option.some({ runs }),
+      };
+    },
     threadEnvironment: {
       snapshotAtom: () => Atom.make(null),
       editQueuedRun: {},
+      beginQueuedRunEdit: "begin",
+      cancelQueuedRunEdit: "cancel",
     },
     environmentThreadDetails: {
       statusAtom: () => Atom.make("ready"),
@@ -101,7 +141,6 @@ function Harness(props: {
   const sendState = deriveComposerSendState({
     prompt: draft.prompt,
     imageCount: draft.images.length + draft.files.length,
-    existingAttachmentCount: result.editingAttachments?.length ?? 0,
     terminalContexts: draft.terminalContexts,
   });
   return result.isEditing ? (
@@ -117,7 +156,12 @@ function Harness(props: {
       isPreparingWorktree={false}
       hasSendableContent={sendState.hasSendableContent}
       isEditingQueuedMessage
-      onSubmitMessage={() => void result.saveEdit(savedContent(draft.prompt), () => {})}
+      onSubmitMessage={() =>
+        void result.saveEdit(
+          { ...savedContent(draft.prompt), images: draft.images, files: draft.files },
+          mocks.setThreadError,
+        )
+      }
       onPreviousPendingQuestion={() => {}}
       onInterrupt={() => {}}
     />
@@ -134,6 +178,7 @@ function view(threadRef: ScopedThreadRef, runStatus: string, hook: { current: Ho
 
 function setup() {
   mocks.editQueuedRun.mockReset();
+  mocks.setThreadError.mockReset();
   useComposerDraftStore.setState({ draftsByThreadKey: {}, draftThreadsByThreadKey: {} });
   setRuns(THREAD_A, "queued");
   setRuns(THREAD_B, "queued");
@@ -183,10 +228,10 @@ describe("useQueuedRunEdit", () => {
       using toast = vi.spyOn(toastManager, "add");
       const attachments = [
         {
-          type: "image" as const,
+          type: "file" as const,
           id: ChatAttachmentId.make("kept"),
-          name: "kept.png",
-          mimeType: "image/png",
+          name: "kept.pdf",
+          mimeType: "application/pdf",
           sizeBytes: 10,
         },
       ];
@@ -201,9 +246,9 @@ describe("useQueuedRunEdit", () => {
         useComposerDraftStore.getState().getComposerDraft(requireHook(hook).draftTarget)?.prompt ??
           "",
       ).toBe(prefix.trimEnd());
-      expect(requireHook(hook).editingAttachments?.map(({ attachment }) => attachment)).toEqual(
-        attachments,
-      );
+      expect(
+        useComposerDraftStore.getState().getComposerDraft(requireHook(hook).draftTarget)?.files,
+      ).toEqual([expect.objectContaining(attachments[0])]);
       await act(() =>
         useComposerDraftStore
           .getState()
@@ -217,6 +262,9 @@ describe("useQueuedRunEdit", () => {
       const update = screen.getByRole("button", { name: "Update queued message" });
       await expect.element(update).toBeEnabled();
       await update.click();
+      await vi.waitFor(() =>
+        expect(mocks.setThreadError).toHaveBeenCalledWith(THREAD_A.threadId, null),
+      );
       await vi.waitFor(() => expect(mocks.editQueuedRun).toHaveBeenCalledOnce());
       expect(mocks.editQueuedRun).toHaveBeenCalledWith(
         expect.objectContaining({
@@ -240,16 +288,18 @@ describe("useQueuedRunEdit", () => {
         text: `Ultrathink:\n${ATTACHMENT_ONLY_BOOTSTRAP_PROMPT}`,
         attachments: [
           {
-            type: "image",
+            type: "file",
             id: ChatAttachmentId.make("removed"),
-            name: "removed.png",
-            mimeType: "image/png",
+            name: "removed.pdf",
+            mimeType: "application/pdf",
             sizeBytes: 10,
           },
         ],
       }),
     );
-    await act(() => requireHook(hook).removeEditingAttachment("removed"));
+    await act(() =>
+      useComposerDraftStore.getState().removeFile(requireHook(hook).draftTarget, "removed"),
+    );
     await screen.getByRole("button", { name: "Update queued message" }).click();
     await vi.waitFor(() => expect(mocks.editQueuedRun).toHaveBeenCalledOnce());
     expect(mocks.editQueuedRun).toHaveBeenCalledWith(
diff --git a/apps/web/src/components/chat/useQueuedRunEdit.ts b/apps/web/src/components/chat/useQueuedRunEdit.ts
index 8feb302dc6aae..25e70389e4b61 100644
--- a/apps/web/src/components/chat/useQueuedRunEdit.ts
+++ b/apps/web/src/components/chat/useQueuedRunEdit.ts
@@ -1,30 +1,31 @@
+import type { ThreadStructure } from "@t3tools/client-runtime/state/shell";
 import { useAtomValue } from "@effect/atom-react";
 import {
   makeQueuedRunEditStore,
   makeQueuedRunsAtom,
 } from "@t3tools/client-runtime/queued-run-edit";
-import type { ThreadStructure } from "@t3tools/client-runtime/state/shell";
+import { Atom } from "effect/reactivity";
 import {
   PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
-  type ChatAttachment,
+  type CommandId,
   type EnvironmentContextRecord,
   type EnvironmentId,
-  type MessageId,
-  type OrchestrationMessageContext,
   type PreviewAnnotationPayload,
-  type RunId,
   type ScopedThreadRef,
   type ThreadContextRecord,
+  type RunId,
   type ThreadId,
 } from "@t3tools/contracts";
+import { queuedRunEditOwnership } from "@t3tools/client-runtime/state/threads";
+import { readLocalApi } from "../../localApi";
 import { scopedThreadKey } from "@t3tools/client-runtime/environment";
-import {
-  restoreAttachmentOnlyBootstrapPrompt,
-  stripAttachmentOnlyBootstrapPrompt,
-} from "@t3tools/shared/composerContextReferences";
-import { Atom } from "effect/reactivity";
-import type { RefObject } from "react";
-import { useAssetUrls } from "../../assets/assetUrls";
+import { useShallow } from "zustand/react/shallow";
+import { useEffect, useRef, useState, type RefObject } from "react";
+import { resolveAssetUrl } from "@t3tools/client-runtime/state/assets";
+import { executeAtomQuery, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
+import { assetEnvironment } from "../../state/assets";
+import { readPreparedConnection } from "../../state/session";
+import { restoreAttachmentOnlyBootstrapPrompt } from "@t3tools/shared/composerContextReferences";
 import {
   DraftId,
   useComposerDraftStore,
@@ -39,7 +40,6 @@ import {
   releaseDraftAttachments,
   startAttachmentUpload,
 } from "../../lib/attachmentUploadQueue";
-import { buildMessageContext } from "../../lib/composerContextRecords";
 import { readFileAsDataUrl } from "../../lib/imageCompression";
 import type { TerminalContextDraft } from "../../lib/terminalContext";
 import type { ReviewCommentContext } from "../../reviewCommentContext";
@@ -47,34 +47,64 @@ import { appAtomRegistry } from "../../rpc/atomRegistry";
 import { environmentServerConfigsAtom } from "../../state/server";
 import {
   environmentThreadDetails,
-  environmentThreadShells,
   threadEnvironment,
+  useEnvironmentThread,
 } from "../../state/threads";
 import { useAtomCommand } from "../../state/use-atom-command";
 import { stackedThreadToast, toastManager } from "../ui/toast";
 import type { ChatComposerHandle } from "./ChatComposer";
 import { fileAttachmentCapabilityBlockReason } from "./composerAttachmentFiles";
-import { prepareQueuedEditAttachments, recoverQueuedMessageEdit } from "./queuedMessageEdit";
+import {
+  prepareQueuedEditPayload,
+  prepareQueuedMessageEditDraft,
+  recoverQueuedMessageEdit,
+} from "./queuedMessageEdit";
 import type { EditQueuedRunRequest } from "./QueuedRunsControl";
 
-interface EditingQueuedRun {
+import type { QueuedRunEditDraft } from "@t3tools/client-runtime/state/queued-run-edit-draft";
+
+interface EditingQueuedRun extends QueuedRunEditDraft {
+  readonly editId: CommandId | null;
+  readonly sequence: number;
   readonly threadId: ThreadId;
-  readonly runId: RunId;
-  readonly messageId: MessageId;
-  readonly originalText: string;
-  readonly existingAttachments: ReadonlyArray<ChatAttachment>;
-  readonly context?: OrchestrationMessageContext | undefined;
-  /** Removing a server attachment changes the message even when the draft looks untouched. */
-  readonly removedExistingAttachment?: true;
 }
 
-// Keyed by the route thread, so an edit survives navigating away and back.
 const queuedRunEdits = makeQueuedRunEditStore<EditingQueuedRun>({
   registry: appAtomRegistry,
   label: "web-queued-run-edits",
 });
 
-interface QueuedRunEditContent {
+function watchQueuedEdit(
+  routeThreadRef: ScopedThreadRef,
+  threadTarget: ComposerThreadTarget,
+  edit: EditingQueuedRun,
+) {
+  const key = scopedThreadKey(routeThreadRef);
+  if (queuedRunEdits.get(key)?.ownership === edit.ownership) return;
+  queuedRunEdits.begin(key, edit, {
+    runs: makeQueuedRunsAtom({
+      threadId: edit.threadId,
+      snapshot: threadEnvironment.snapshotAtom(routeThreadRef.environmentId),
+      detailStatus: environmentThreadDetails.statusAtom(routeThreadRef),
+      runs: Atom.make(
+        (get) =>
+          get(environmentThreadDetails.quietThreadAtom(routeThreadRef))?.projection.runs ?? null,
+      ),
+    }),
+    onRunLeftQueue: (_, endedEdit) => {
+      recoverQueuedMessageEdit({
+        editTarget: queuedEditDraftTarget(routeThreadRef, endedEdit.runId),
+        threadTarget,
+        originalText: endedEdit.originalText,
+        originalAttachmentIds: endedEdit.originalAttachmentIds,
+        expectedEdit: endedEdit,
+      });
+    },
+  });
+}
+
+/** What the composer holds when the user saves a queued-message edit. */
+export interface QueuedRunEditContent {
   readonly prompt: string;
   readonly images: ReadonlyArray<ComposerImageAttachment>;
   readonly files: ReadonlyArray<ComposerFileAttachment>;
@@ -85,10 +115,12 @@ interface QueuedRunEditContent {
   readonly environmentContexts: ReadonlyArray<EnvironmentContextRecord>;
 }
 
+/** Draft id for editing a queued run of the route thread. */
 function queuedEditDraftTarget(routeThreadRef: ScopedThreadRef, runId: RunId) {
   return DraftId.make(`queued-edit:${scopedThreadKey(routeThreadRef)}:${runId}`);
 }
 
+/** Uploads the edit's new attachments and saves it. Returns the error to show, or null. */
 async function submitQueuedRunEdit(input: {
   readonly environmentId: EnvironmentId;
   readonly draftTarget: ComposerThreadTarget;
@@ -98,7 +130,6 @@ async function submitQueuedRunEdit(input: {
 }): Promise<string | null> {
   const { environmentId, draftTarget, editing, content } = input;
   const editText = content.prompt.trim();
-  const newAttachments = [...content.images, ...content.files];
   const uploadFiles = async (files: ReadonlyArray<ComposerFileAttachment>) => {
     const validateFiles = () => {
       const config = appAtomRegistry.get(environmentServerConfigsAtom).get(environmentId) ?? null;
@@ -120,51 +151,22 @@ async function submitQueuedRunEdit(input: {
     return uploaded;
   };
   try {
-    const uploads = await prepareQueuedEditAttachments({
-      existingAttachments: editing.existingAttachments,
-      images: content.images,
-      files: content.files,
+    const payload = await prepareQueuedEditPayload({
+      edit: editing,
+      content,
       readImage: readFileAsDataUrl,
       uploadFiles,
     });
-    const keptRecords = (editing.context?.records ?? []).filter(
-      (record) =>
-        !("attachmentId" in record) ||
-        editing.existingAttachments.some((attachment) => attachment.id === record.attachmentId),
-    );
-    const newRecords =
-      buildMessageContext({
-        terminalContexts: content.terminalContexts.filter(
-          (context) => context.text.trim().length > 0,
-        ),
-        reviewComments: content.reviewComments,
-        previewAnnotations: content.previewAnnotations,
-        threadContexts: content.threadContexts,
-        environmentContexts: content.environmentContexts,
-        attachments: newAttachments.map((attachment, index) => ({
-          attachment,
-          attachmentId: uploads[editing.existingAttachments.length + index]?.id ?? attachment.id,
-        })),
-      })?.records ?? [];
     const result = await input.editQueuedRun({
       environmentId,
       input: {
         threadId: editing.threadId,
         runId: editing.runId,
-        text: restoreAttachmentOnlyBootstrapPrompt(editText, uploads.length > 0),
+        editId: editing.editId,
+        text: restoreAttachmentOnlyBootstrapPrompt(editText, payload.attachments.length > 0),
         edit: {
           messageId: editing.messageId,
-          attachments: uploads,
-          context: {
-            version: 1,
-            records: [
-              ...new Map(
-                [...keptRecords, ...newRecords].map(
-                  (record) => [record.contextId, record] as const,
-                ),
-              ).values(),
-            ],
-          },
+          ...payload,
         },
       },
     });
@@ -178,11 +180,17 @@ function useEditQueuedRunCommand() {
   return useAtomCommand(threadEnvironment.editQueuedRun, { reportFailure: false });
 }
 
-/** Edits preserve the thread draft; attachment removals stay local until save. */
+/**
+ * Queued-message edit mode. While active, the composer is retargeted to a
+ * per-run edit draft so the user's in-progress draft on the thread survives
+ * untouched. Stored attachments join that draft so its current selection can
+ * be recovered through the same paths as newly attached files.
+ */
 export function useQueuedRunEdit(input: {
   readonly environmentId: EnvironmentId;
   readonly routeThreadRef: ScopedThreadRef;
   readonly threadDraftTarget: ComposerThreadTarget;
+  // Null while the route has no thread yet; an edit needs one to target.
   readonly activeThreadId: ThreadId | null;
   readonly serverProjection: ThreadStructure | null;
   readonly promptRef: { current: string };
@@ -198,27 +206,45 @@ export function useQueuedRunEdit(input: {
     composerRef,
   } = input;
   const editQueuedRunCommand = useEditQueuedRunCommand();
+  const acquireEdit = useAtomCommand(threadEnvironment.beginQueuedRunEdit);
+  const releaseEdit = useAtomCommand(threadEnvironment.cancelQueuedRunEdit);
+  const releaseFailedPreparation = useAtomCommand(threadEnvironment.cancelQueuedRunEdit, {
+    reportFailure: false,
+  });
+  const threadState = useEnvironmentThread(environmentId, activeThreadId);
+  const beginInFlight = useRef(false);
+  const recoveryPrefix = `queued-edit:${scopedThreadKey(routeThreadRef)}:`;
+  const activeEdit = useComposerDraftStore(
+    (state) =>
+      Object.entries(state.draftsByThreadKey).find(
+        ([key, draft]) =>
+          key.startsWith(recoveryPrefix) && draft.queuedEdit?.ownership !== undefined,
+      )?.[1].queuedEdit ?? null,
+  );
+  const editing: EditingQueuedRun | null =
+    activeEdit?.ownership && activeThreadId !== null
+      ? {
+          ...activeEdit,
+          ...activeEdit.ownership,
+          threadId: activeThreadId,
+        }
+      : null;
   const editKey = scopedThreadKey(routeThreadRef);
-  const storedEdit = useAtomValue(queuedRunEdits.atom)[editKey] ?? null;
-  const editing = activeThreadId === null ? null : storedEdit;
   const isSaving = useAtomValue(queuedRunEdits.savingAtom)[editKey] === true;
-  const draftTarget =
-    editing === null ? threadDraftTarget : queuedEditDraftTarget(routeThreadRef, editing.runId);
-
-  const imageResources = (editing?.existingAttachments ?? [])
-    .filter((attachment) => attachment.type === "image")
-    .map((attachment) => ({ _tag: "attachment" as const, attachmentId: attachment.id }));
-  const imageUrls = useAssetUrls(environmentId, imageResources);
-  const urlByAttachmentId = new Map(
-    imageResources.map((resource, index) => [resource.attachmentId, imageUrls[index] ?? null]),
+  const savedEditDrafts = useComposerDraftStore(
+    useShallow((state) =>
+      Object.keys(state.draftsByThreadKey).filter((key) => key.startsWith(recoveryPrefix)),
+    ),
   );
-  const editingAttachments =
-    editing === null
-      ? null
-      : editing.existingAttachments.map((attachment) => ({
-          attachment,
-          url: urlByAttachmentId.get(attachment.id) ?? null,
-        }));
+  const [recoveryTarget, setRecoveryTarget] = useState<string | null>(null);
+  const selectedRecoveryTarget =
+    recoveryTarget !== null && savedEditDrafts.includes(recoveryTarget)
+      ? DraftId.make(recoveryTarget)
+      : null;
+  const draftTarget =
+    editing !== null
+      ? queuedEditDraftTarget(routeThreadRef, editing.runId)
+      : (selectedRecoveryTarget ?? threadDraftTarget);
 
   const focusComposerSoon = () => {
     window.requestAnimationFrame(() => composerRef.current?.focusAtEnd());
@@ -228,109 +254,192 @@ export function useQueuedRunEdit(input: {
       .getState()
       .clearComposerContent(queuedEditDraftTarget(routeThreadRef, runId));
 
-  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 text = stripAttachmentOnlyBootstrapPrompt(request.text);
-    const store = useComposerDraftStore.getState();
-    store.clearComposerContent(target);
-    store.setPrompt(target, text);
-    const threadRef = { environmentId, threadId: activeThreadId };
-    queuedRunEdits.begin(
-      editKey,
-      {
-        threadId: activeThreadId,
-        runId: request.runId,
-        messageId: request.messageId,
-        originalText: text,
-        existingAttachments: request.attachments,
-        context: serverProjection?.messages.find((message) => message.id === request.messageId)
-          ?.context,
-      },
-      {
-        runs: makeQueuedRunsAtom({
-          threadId: activeThreadId,
-          snapshot: threadEnvironment.snapshotAtom(environmentId),
-          detailStatus: environmentThreadDetails.statusAtom(threadRef),
-          runs: Atom.make(
-            (get) =>
-              get(environmentThreadDetails.quietThreadAtom(threadRef))?.projection.runs ?? null,
-          ),
-        }),
-        // The run started or was cancelled from another client. A changed
-        // edit moves into the thread's own draft when that draft is empty;
-        // otherwise it is dropped. Edits outlive navigation, so the toast is
-        // unscoped and names the thread: the user may be anywhere by now.
-        onRunLeftQueue: (_, edit) => {
-          const recovery = recoverQueuedMessageEdit({
-            editTarget: queuedEditDraftTarget(routeThreadRef, edit.runId),
+  const beginEdit = useStableCallback(async (request: EditQueuedRunRequest) => {
+    if (
+      activeThreadId === null ||
+      beginInFlight.current ||
+      appAtomRegistry.get(queuedRunEdits.savingAtom)[editKey]
+    )
+      return;
+    beginInFlight.current = true;
+    const openEdit = async () => {
+      try {
+        const run = serverProjection?.runs.find((run) => run.id === request.runId);
+        const previousEditId = run?.queueEditId ?? null;
+        if (editing?.runId === request.runId && editing.editId === previousEditId) {
+          focusComposerSoon();
+          return;
+        }
+        if (previousEditId !== null) {
+          const confirmed = await readLocalApi()?.dialogs.confirm(
+            "This message is being edited elsewhere. Take over editing? The other editor will keep their unsaved changes.",
+          );
+          if (!confirmed) return;
+        }
+        if (editing !== null) {
+          const released = await releaseEdit({
+            environmentId,
+            input: { threadId: editing.threadId, runId: editing.runId, editId: editing.editId },
+          });
+          if (released._tag !== "Success") return;
+          recoverQueuedMessageEdit({
+            editTarget: queuedEditDraftTarget(routeThreadRef, editing.runId),
             threadTarget: threadDraftTarget,
-            originalText: edit.originalText,
-            removedExistingAttachment: edit.removedExistingAttachment === true,
+            originalText: editing.originalText,
+            originalAttachmentIds: editing.originalAttachmentIds,
           });
-          if (recovery === "clean") return;
-          const title = appAtomRegistry.get(
-            environmentThreadShells.threadShellAtom(threadRef),
-          )?.title;
-          const where = title === undefined ? "" : ` in “${title}”`;
-          toastManager.add(
-            stackedThreadToast({
-              type: recovery === "kept" ? "info" : "warning",
-              title: "Queued message is no longer queued",
-              description:
-                recovery === "kept"
-                  ? `Your unsaved edit${where} was kept in the composer.`
-                  : `Your unsaved edit${where} was discarded.`,
-            }),
-          );
-        },
-      },
-    );
-    focusComposerSoon();
+        }
+        const acquired = await acquireEdit({
+          environmentId,
+          input: { threadId: activeThreadId, runId: request.runId, previousEditId },
+        });
+        if (acquired._tag !== "Success") return;
+        const target = queuedEditDraftTarget(routeThreadRef, request.runId);
+        const preparation = prepareQueuedMessageEditDraft({
+          editTarget: target,
+          edit: {
+            ...acquired.value,
+            runId: request.runId,
+            messageId: request.messageId,
+            context: serverProjection?.messages.find((message) => message.id === request.messageId)
+              ?.context,
+          },
+          environmentId,
+          text: request.text,
+          attachments: request.attachments,
+          readImage: async (attachment) => {
+            const connection = readPreparedConnection(environmentId);
+            if (!connection) throw new Error("Reconnect before editing attachments.");
+            const result = await executeAtomQuery(
+              appAtomRegistry,
+              assetEnvironment.createUrl({
+                environmentId,
+                input: { resource: { _tag: "attachment", attachmentId: attachment.id } },
+              }),
+              { refresh: true, reportFailure: false },
+            );
+            if (result._tag === "Failure") throw squashAtomCommandFailure(result);
+            const url = resolveAssetUrl(connection.httpBaseUrl, result.value.relativeUrl);
+            if (url === null) throw new Error("Attachment URL unavailable.");
+            const response = await fetch(url, { signal: AbortSignal.timeout(30_000) });
+            if (!response.ok) throw new Error(`Could not restore attachment: ${attachment.name}`);
+            const file = new File([await response.blob()], attachment.name, {
+              type: attachment.mimeType,
+            });
+            return { file, dataUrl: await readFileAsDataUrl(file) };
+          },
+        });
+        const preparedEdit = useComposerDraftStore.getState().getComposerDraft(target)?.queuedEdit;
+        try {
+          await preparation;
+        } catch (error) {
+          const released = await releaseFailedPreparation({
+            environmentId,
+            input: {
+              threadId: activeThreadId,
+              runId: request.runId,
+              editId: acquired.value.editId,
+            },
+          });
+          if (released._tag === "Success" && preparedEdit?.ownership)
+            recoverQueuedMessageEdit({
+              editTarget: target,
+              threadTarget: threadDraftTarget,
+              originalText: preparedEdit.originalText,
+              originalAttachmentIds: preparedEdit.originalAttachmentIds,
+              expectedEdit: preparedEdit,
+            });
+          toastManager.add({
+            type: "error",
+            title: "Could not open queued edit",
+            description: error instanceof Error ? error.message : "Could not restore attachments.",
+          });
+          return;
+        }
+        focusComposerSoon();
+      } catch (error) {
+        toastManager.add({
+          type: "error",
+          title: "Could not open queued edit",
+          description: error instanceof Error ? error.message : "Please try again.",
+        });
+      }
+    };
+    await openEdit().finally(() => {
+      beginInFlight.current = false;
+    });
   });
-  const cancelEdit = useStableCallback(() => {
+  const cancelEdit = useStableCallback(async () => {
     if (editing === null) return;
+    watchQueuedEdit(routeThreadRef, threadDraftTarget, editing);
+    const finishCancel = queuedRunEdits.startSave(editKey);
+    if (finishCancel === null) return;
+    const cancelledDraft = useComposerDraftStore.getState().getComposerDraft(draftTarget);
+    const released = await releaseEdit({
+      environmentId,
+      input: { threadId: editing.threadId, runId: editing.runId, editId: editing.editId },
+    });
+    const current = finishCancel(released._tag === "Success");
+    if (
+      released._tag !== "Success" ||
+      !current ||
+      useComposerDraftStore.getState().getComposerDraft(draftTarget) !== cancelledDraft
+    )
+      return;
     clearEditDraft(editing.runId);
-    queuedRunEdits.end(editKey);
     focusComposerSoon();
   });
-  const removeEditingAttachment = useStableCallback((attachmentId: string) => {
-    queuedRunEdits.update(editKey, (current) => ({
-      ...current,
-      removedExistingAttachment: true,
-      existingAttachments: current.existingAttachments.filter(
-        (attachment) => attachment.id !== attachmentId,
-      ),
-    }));
-  });
+  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- keeps the edit projection watch and recovery toast in sync with server ownership after navigation
+  useEffect(() => {
+    if (editing === null || activeThreadId !== editing.threadId || isSaving) return;
+    watchQueuedEdit(routeThreadRef, threadDraftTarget, editing);
+    if (queuedRunEditOwnership(threadState, editing) !== "lost") return;
+    queuedRunEdits.end(editKey);
+    const recovery = recoverQueuedMessageEdit({
+      editTarget: queuedEditDraftTarget(routeThreadRef, editing.runId),
+      threadTarget: threadDraftTarget,
+      originalText: editing.originalText,
+      originalAttachmentIds: editing.originalAttachmentIds,
+    });
+    toastManager.add(
+      stackedThreadToast({
+        type: "info",
+        title: "Queued message edit ended",
+        description:
+          recovery === "kept"
+            ? "Your unsaved changes are in the composer."
+            : recovery === "retained"
+              ? "Open Saved queued edit above the composer to recover your changes."
+              : "The message left the queue or another editor took over.",
+      }),
+    );
+  }, [activeThreadId, editing, routeThreadRef, threadState, threadDraftTarget, isSaving, editKey]);
 
+  /**
+   * Saves the composer content into the queued message being edited. Reports
+   * failures through `setThreadError`, which callers own because the error
+   * banner lives with the thread.
+   */
   const saveEdit = async (
     content: QueuedRunEditContent,
     setThreadError: (threadId: ThreadId, error: string | null) => void,
   ) => {
     if (editing === null || isSaving) return;
     const newAttachments = [...content.images, ...content.files];
-    if (
-      editing.existingAttachments.length + newAttachments.length >
-      PROVIDER_SEND_TURN_MAX_ATTACHMENTS
-    ) {
+    if (newAttachments.length > PROVIDER_SEND_TURN_MAX_ATTACHMENTS) {
       setThreadError(
         editing.threadId,
         `A message can have at most ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} attachments.`,
       );
       return;
     }
-    if (
-      content.prompt.trim().length === 0 &&
-      editing.existingAttachments.length === 0 &&
-      newAttachments.length === 0
-    ) {
+    if (content.prompt.trim().length === 0 && newAttachments.length === 0) {
       return;
     }
-    // The save's result decides the edit's fate, even if the run starts meanwhile.
+    watchQueuedEdit(routeThreadRef, threadDraftTarget, editing);
     const finishSave = queuedRunEdits.startSave(editKey);
     if (finishSave === null) return;
+    const savedDraft = useComposerDraftStore.getState().getComposerDraft(draftTarget);
     const error = await submitQueuedRunEdit({
       environmentId,
       draftTarget,
@@ -340,10 +449,13 @@ export function useQueuedRunEdit(input: {
     });
     setThreadError(editing.threadId, error);
     const current = finishSave(error === null);
-    if (error !== null) return;
+    if (
+      error !== null ||
+      !current ||
+      useComposerDraftStore.getState().getComposerDraft(draftTarget) !== savedDraft
+    )
+      return;
     releaseDraftAttachments(newAttachments);
-    // The edit was cancelled or begun again while this save ran; its drafts are the newer edit's.
-    if (!current) return;
     promptRef.current = "";
     clearEditDraft(editing.runId);
     composerRef.current?.resetCursorState();
@@ -351,14 +463,15 @@ export function useQueuedRunEdit(input: {
   };
 
   return {
+    savedEditDrafts: editing === null ? savedEditDrafts : [],
+    recoveryTarget: selectedRecoveryTarget,
+    selectRecoveryTarget: setRecoveryTarget,
     editingRunId: editing?.runId ?? null,
     isEditing: editing !== null,
     isSaving,
     draftTarget,
-    editingAttachments,
     beginEdit,
     cancelEdit,
-    removeEditingAttachment,
     saveEdit,
   };
 }
diff --git a/apps/web/src/composerDraftStore.ts b/apps/web/src/composerDraftStore.ts
index dde304da3d03e..c4490793cf5a9 100644
--- a/apps/web/src/composerDraftStore.ts
+++ b/apps/web/src/composerDraftStore.ts
@@ -1,3 +1,4 @@
+import { QueuedRunEditDraft } from "@t3tools/client-runtime/state/queued-run-edit-draft";
 import { stripInlineContextReferences } from "./lib/composerContextReferences";
 import { composerFileAttachmentMimeType } from "./components/chat/composerAttachmentFiles";
 import { elementContextToPreviewAnnotation } from "./lib/elementContext";
@@ -101,6 +102,7 @@ import {
 import { UnifiedSettings } from "@t3tools/contracts/settings";
 
 const isElementContextDetails = Schema.is(ElementContextDetails);
+const isQueuedRunEditDraft = Schema.is(QueuedRunEditDraft);
 import { ReviewCommentContextSchema, type ReviewCommentContext } from "./reviewCommentContext";
 const isRuntimeMode = Schema.is(RuntimeMode);
 const isProviderDriverKind = Schema.is(ProviderDriverKind);
@@ -240,6 +242,7 @@ const PersistedTerminalContextDraft = Schema.Struct({
 type PersistedTerminalContextDraft = typeof PersistedTerminalContextDraft.Type;
 
 const PersistedComposerThreadDraftState = Schema.Struct({
+  queuedEdit: Schema.optionalKey(QueuedRunEditDraft),
   prompt: Schema.String,
   attachments: Schema.Array(PersistedComposerImageAttachment),
   files: Schema.optionalKey(Schema.Array(PersistedComposerDraftFileAttachment)),
@@ -362,6 +365,7 @@ export type ComposerContextInsertionHandler = (
 const contextInsertionHandlers = new Map<string, ComposerContextInsertionHandler>();
 
 export interface ComposerThreadDraftState {
+  queuedEdit?: QueuedRunEditDraft | undefined;
   prompt: string;
   images: ComposerImageAttachment[];
   files: ComposerFileAttachment[];
@@ -763,7 +767,7 @@ const EMPTY_THREAD_DRAFT = Object.freeze<ComposerThreadDraftState>({
   interactionMode: null,
 });
 
-function createEmptyThreadDraft(): ComposerThreadDraftState {
+export function createEmptyThreadDraft(): ComposerThreadDraftState {
   return {
     prompt: "",
     images: [],
@@ -884,7 +888,8 @@ function shouldRemoveDraft(draft: ComposerThreadDraftState): boolean {
     Object.keys(draft.modelSelectionByProvider).length === 0 &&
     draft.activeProvider === null &&
     draft.runtimeMode === null &&
-    draft.interactionMode === null
+    draft.interactionMode === null &&
+    draft.queuedEdit?.ownership === undefined
   );
 }
 
@@ -1985,7 +1990,9 @@ function normalizePersistedDraftsByThreadId(
       environmentContexts.length === 0 &&
       !hasModelData &&
       !runtimeMode &&
-      !interactionMode
+      !interactionMode &&
+      (!isQueuedRunEditDraft(draftCandidate.queuedEdit) ||
+        draftCandidate.queuedEdit.ownership === undefined)
     ) {
       continue;
     }
@@ -2002,6 +2009,13 @@ function normalizePersistedDraftsByThreadId(
                 : threadKeyOrId;
             })();
     nextDraftsByThreadKey[normalizedThreadKey] = {
+      ...(isQueuedRunEditDraft(draftCandidate.queuedEdit)
+        ? {
+            queuedEdit: structuredClone(
+              draftCandidate.queuedEdit,
+            ) as DeepMutable<QueuedRunEditDraft>,
+          }
+        : {}),
       prompt,
       attachments,
       ...(files.length > 0 ? { files } : {}),
@@ -2116,11 +2130,15 @@ export function partializeComposerDraftStoreState(
       draft.environmentContexts.length === 0 &&
       !hasModelData &&
       draft.runtimeMode === null &&
-      draft.interactionMode === null
+      draft.interactionMode === null &&
+      draft.queuedEdit?.ownership === undefined
     ) {
       continue;
     }
     const persistedDraft: DeepMutable<PersistedComposerThreadDraftState> = {
+      ...(draft.queuedEdit
+        ? { queuedEdit: structuredClone(draft.queuedEdit) as DeepMutable<QueuedRunEditDraft> }
+        : {}),
       prompt: draft.prompt,
       attachments: draft.persistedAttachments,
       ...(draft.files.length > 0
@@ -2426,6 +2444,7 @@ function toHydratedThreadDraft(
     })) ?? [];
 
   return {
+    ...(persistedDraft.queuedEdit ? { queuedEdit: persistedDraft.queuedEdit } : {}),
     prompt: ensureInlineContextReferences(persistedDraft.prompt, [
       ...(persistedDraft.reviewComments ?? []).map(reviewCommentContextReference),
       ...(persistedDraft.previewAnnotations ?? []).map(previewAnnotationContextReference),
@@ -3322,6 +3341,16 @@ const composerDraftStore = create<ComposerDraftStoreState>()(
             }
             const nextDraft: ComposerThreadDraftState = {
               ...current,
+              ...(current.queuedEdit && current.queuedEdit.originalAttachmentIds.includes(imageId)
+                ? {
+                    queuedEdit: {
+                      ...current.queuedEdit,
+                      removedAttachmentIds: [
+                        ...new Set([...(current.queuedEdit.removedAttachmentIds ?? []), imageId]),
+                      ],
+                    },
+                  }
+                : {}),
               prompt: removeInlineContextReference(
                 current.prompt,
                 toKindScopedComposerContextId("image", imageId),
@@ -3434,6 +3463,16 @@ const composerDraftStore = create<ComposerDraftStoreState>()(
             }
             const nextDraft = {
               ...current,
+              ...(current.queuedEdit && current.queuedEdit.originalAttachmentIds.includes(fileId)
+                ? {
+                    queuedEdit: {
+                      ...current.queuedEdit,
+                      removedAttachmentIds: [
+                        ...new Set([...(current.queuedEdit.removedAttachmentIds ?? []), fileId]),
+                      ],
+                    },
+                  }
+                : {}),
               prompt: removeInlineContextReference(
                 current.prompt,
                 toKindScopedComposerContextId("file", fileId),
@@ -4055,6 +4094,7 @@ const composerDraftStore = create<ComposerDraftStoreState>()(
             }
             const nextDraft: ComposerThreadDraftState = {
               ...current,
+              queuedEdit: undefined,
               prompt: "",
               images: [],
               files: [],
@@ -4097,6 +4137,23 @@ const composerDraftStore = create<ComposerDraftStoreState>()(
                 ...current.environmentContexts.map(environmentContextReference),
                 ...current.previewAnnotations.map(previewAnnotationContextReference),
               ]),
+              ...(current.queuedEdit
+                ? {
+                    queuedEdit: {
+                      ...current.queuedEdit,
+                      removedAttachmentIds: [
+                        ...new Set([
+                          ...(current.queuedEdit.removedAttachmentIds ?? []),
+                          ...[...current.images, ...current.files]
+                            .filter((attachment) =>
+                              current.queuedEdit?.originalAttachmentIds.includes(attachment.id),
+                            )
+                            .map((attachment) => attachment.id),
+                        ]),
+                      ],
+                    },
+                  }
+                : {}),
               images: [],
               files: [],
               nonPersistedImageIds: [],
diff --git a/docs/user/composer.md b/docs/user/composer.md
index df880e49c6ca5..d87f4c8f8cccf 100644
--- a/docs/user/composer.md
+++ b/docs/user/composer.md
@@ -83,6 +83,18 @@ Press `Option+Up` on macOS or `Alt+Up` on Windows and Linux with the cursor at t
 start of the composer to edit the most recently queued message. Change
 `thread.editQueuedMessage` to use another shortcut.
 
+Editing holds that message and the messages behind it until you Save or Cancel;
+the active turn continues. The hold survives disconnects, restarts, and resuming
+the queue. Return to the thread after navigating away or restarting the client to
+continue your edit. To edit a message held on another device, choose Edit and
+confirm takeover.
+If another editor takes over or the message is removed, unsaved changes stay in
+the composer or remain available as a saved queued edit above it. If another device
+saves a newer version, reopening Edit starts from that version and keeps the older
+draft under Saved queued edit. Failure and workspace pauses remain separate: finish
+the edit, then resume a paused queue. Older servers allow local editing but cannot
+hold the queue while you edit.
+
 Mobile has the same choice under **Settings → Chat**. While a turn is
 running the send button shows which action it will take. Long-press it to use the
 other action for a single message. From a hardware keyboard, `Cmd+Return`
@@ -255,7 +267,8 @@ shortcut described above.
 On web and desktop, queued messages appear at the end of the thread as dashed messages that have
 not been sent yet. On mobile they appear above the composer. Each shows its text and any attached
 images. **Send now** sends a message right away, into the running turn if there is one. You can
-also edit or remove it.
+also edit or remove it. Finish an open edit with Save or Cancel before using **Send now**;
+trying to send an edit-held message does not release a Stop pause.
 
 If you stop the agent or the server restarts, queued messages keep their order and are held.
 Press **Resume** in an empty composer to continue. **Resume** also continues a stopped
@@ -266,9 +279,9 @@ The pencil on a queued message opens it in the composer for editing. The origina
 stays in the queue until you save, and it is highlighted while you edit. The message's
 attachments appear above the text with a remove control, and new images can be added the usual way.
 The checkmark saves the queued message in place; **Cancel** next to it leaves it unchanged. Whatever
-you had typed in the composer before starting the edit is restored afterwards. If the queued
-message starts or is removed while you are editing, the edit ends: changed content moves into the
-composer when it is empty, and is discarded otherwise.
+you had typed in the composer before starting the edit is restored afterwards. If another editor
+takes over or the message leaves the queue, your changes return to an empty composer or remain
+available under **Saved queued edit**. They do not overwrite an existing draft.
 
 ## Commands and skills
 
diff --git a/packages/client-runtime/package.json b/packages/client-runtime/package.json
index c9e1260b956f7..ef950f28b1ff9 100644
--- a/packages/client-runtime/package.json
+++ b/packages/client-runtime/package.json
@@ -323,6 +323,10 @@
       "types": "./src/state/terminal.ts",
       "default": "./src/state/terminal.ts"
     },
+    "./state/queued-run-edit-draft": {
+      "types": "./src/state/queuedRunEditDraft.ts",
+      "default": "./src/state/queuedRunEditDraft.ts"
+    },
     "./state/threads": {
       "types": "./src/state/threads.ts",
       "default": "./src/state/threads.ts"
diff --git a/packages/client-runtime/src/operations/commands.test.ts b/packages/client-runtime/src/operations/commands.test.ts
index 821a92721d357..9a4124d432bbc 100644
--- a/packages/client-runtime/src/operations/commands.test.ts
+++ b/packages/client-runtime/src/operations/commands.test.ts
@@ -37,6 +37,9 @@ import type { WsRpcProtocolClient } from "../rpc/protocol.ts";
 import { v2Now, v2Projection, v2ThreadId } from "../state/orchestrationV2TestFixtures.ts";
 import {
   archiveThread,
+  editQueuedRun,
+  beginQueuedRunEdit,
+  cancelQueuedRunEdit,
   interruptThreadTurn,
   revertThreadCheckpoint,
   resumeThreadQueue,
@@ -61,6 +64,7 @@ const makeSupervisor = Effect.fn("TestEnvironmentCommands.makeSupervisor")(funct
   readonly launches?: OrchestrationV2ThreadLaunchInput[];
   readonly projection?: OrchestrationV2ThreadProjection;
   readonly projectionRequests?: ThreadId[];
+  readonly queuedRunEditHold?: boolean;
   readonly advertiseThreadStop?: boolean;
 }) {
   const client = {
@@ -109,6 +113,9 @@ const makeSupervisor = Effect.fn("TestEnvironmentCommands.makeSupervisor")(funct
       environment: {
         capabilities: {
           repositoryIdentity: true,
+          ...(input.queuedRunEditHold === undefined
+            ? {}
+            : { queuedRunEditHold: input.queuedRunEditHold }),
           ...(input.advertiseThreadStop === true ? { threadStop: true } : {}),
         },
       },
@@ -131,6 +138,41 @@ const makeSupervisor = Effect.fn("TestEnvironmentCommands.makeSupervisor")(funct
 });
 
 describe("V2 environment commands", () => {
+  it.effect.each([false, true])(
+    "negotiates queued edit holds with advertised capability %s",
+    (supported) =>
+      Effect.gen(function* () {
+        const commands: OrchestrationV2Command[] = [];
+        const supervisor = yield* makeSupervisor({
+          commands,
+          projects: [],
+          ...(supported ? { queuedRunEditHold: true } : {}),
+        });
+        const provide = Effect.provideService(
+          EnvironmentSupervisor.EnvironmentSupervisor,
+          supervisor,
+        );
+        const target = { threadId: v2ThreadId, runId: RunId.make("queued-run") };
+        const acquired = yield* beginQueuedRunEdit({
+          ...target,
+          commandId: CommandId.make("acquire"),
+          previousEditId: null,
+        }).pipe(provide);
+        expect(acquired).toEqual(
+          supported ? { editId: "acquire", sequence: 1 } : { editId: null, sequence: 0 },
+        );
+        yield* editQueuedRun({ ...target, editId: acquired.editId, text: "Saved" }).pipe(provide);
+        yield* cancelQueuedRunEdit({ ...target, editId: acquired.editId }).pipe(provide);
+        expect(commands.map((command) => command.type)).toEqual(
+          supported
+            ? ["queued-run.edit.begin", "queued-run.edit", "queued-run.edit.cancel"]
+            : ["queued-run.edit"],
+        );
+        const saved = commands.find((command) => command.type === "queued-run.edit");
+        if (supported) expect(saved).toHaveProperty("editId", acquired.editId);
+        else expect(saved).not.toHaveProperty("editId");
+      }).pipe(Effect.provide(layerTestRandom)),
+  );
   it.effect("distinguishes sending a selected queued message from resuming queue order", () =>
     Effect.gen(function* () {
       const commands: OrchestrationV2Command[] = [];
diff --git a/packages/client-runtime/src/operations/commands.ts b/packages/client-runtime/src/operations/commands.ts
index f813ece95dc45..c8ce87bbdd639 100644
--- a/packages/client-runtime/src/operations/commands.ts
+++ b/packages/client-runtime/src/operations/commands.ts
@@ -254,7 +254,18 @@ export interface RetryWorkspacePreparationInput extends ThreadCommandInput {
   readonly runId: RunId;
 }
 
+export interface BeginQueuedRunEditInput extends ThreadCommandInput {
+  readonly runId: RunId;
+  readonly previousEditId: CommandId | null;
+}
+
+export interface CancelQueuedRunEditInput extends ThreadCommandInput {
+  readonly runId: RunId;
+  readonly editId: CommandId | null;
+}
+
 export interface EditQueuedRunInput extends ThreadCommandInput {
+  readonly editId?: CommandId | null;
   readonly runId: RunId;
   readonly text: string;
   /**
@@ -1072,6 +1083,37 @@ export const retryWorkspacePreparation = Effect.fn("EnvironmentCommands.retryWor
   },
 );
 
+export const beginQueuedRunEdit = Effect.fn("EnvironmentCommands.beginQueuedRunEdit")(function* (
+  input: BeginQueuedRunEditInput,
+) {
+  const config = yield* getInitialServerConfig();
+  if (config.environment.capabilities.queuedRunEditHold !== true) {
+    return { editId: null, sequence: 0 };
+  }
+  const editId = yield* allocateCommandId(input);
+  const receipt = yield* dispatch({
+    type: "queued-run.edit.begin",
+    commandId: editId,
+    threadId: input.threadId,
+    runId: input.runId,
+    previousEditId: input.previousEditId,
+  });
+  return { editId, sequence: receipt.sequence };
+});
+
+export const cancelQueuedRunEdit = Effect.fn("EnvironmentCommands.cancelQueuedRunEdit")(function* (
+  input: CancelQueuedRunEditInput,
+) {
+  if (input.editId === null) return { sequence: 0 };
+  return yield* dispatch({
+    type: "queued-run.edit.cancel",
+    commandId: yield* allocateCommandId(input),
+    threadId: input.threadId,
+    runId: input.runId,
+    editId: input.editId,
+  });
+});
+
 export const editQueuedRun = Effect.fn("EnvironmentCommands.editQueuedRun")(function* (
   input: EditQueuedRunInput,
 ) {
@@ -1084,6 +1126,7 @@ export const editQueuedRun = Effect.fn("EnvironmentCommands.editQueuedRun")(func
     commandId: yield* allocateCommandId(input),
     threadId: input.threadId,
     runId: input.runId,
+    ...(input.editId == null ? {} : { editId: input.editId }),
     text: input.text,
     ...(attachments === undefined ? {} : { attachments }),
     ...(input.edit?.context && attachments
diff --git a/packages/client-runtime/src/state/queuedRunEditDraft.ts b/packages/client-runtime/src/state/queuedRunEditDraft.ts
new file mode 100644
index 0000000000000..e770d7726c668
--- /dev/null
+++ b/packages/client-runtime/src/state/queuedRunEditDraft.ts
@@ -0,0 +1,44 @@
+import { CommandId, MessageId, OrchestrationMessageContext, RunId } from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
+
+export const QueuedRunEditDraft = Schema.Struct({
+  runId: RunId,
+  messageId: MessageId,
+  // File references can normalize composer text; compare newer saves against the server text.
+  sourceText: Schema.String,
+  originalText: Schema.String,
+  originalAttachmentIds: Schema.Array(Schema.String),
+  removedAttachmentIds: Schema.optional(Schema.Array(Schema.String)),
+  context: Schema.optional(OrchestrationMessageContext),
+  ownership: Schema.optional(
+    Schema.Struct({
+      editId: Schema.NullOr(CommandId),
+      sequence: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    }),
+  ),
+});
+export type QueuedRunEditDraft = typeof QueuedRunEditDraft.Type;
+
+export function queuedEditDraftHasMissingAttachments(
+  draft: QueuedRunEditDraft,
+  attachments: ReadonlyArray<{ readonly id: string }>,
+): boolean {
+  return draft.originalAttachmentIds.some(
+    (id) =>
+      !draft.removedAttachmentIds?.includes(id) &&
+      !attachments.some((attachment) => attachment.id === id),
+  );
+}
+
+export function queuedEditDraftMatchesSource(
+  draft: QueuedRunEditDraft | undefined,
+  text: string,
+  attachments: ReadonlyArray<{ readonly id: string }>,
+): boolean {
+  return (
+    draft !== undefined &&
+    draft.sourceText === text &&
+    draft.originalAttachmentIds.length === attachments.length &&
+    draft.originalAttachmentIds.every((id, index) => id === attachments[index]?.id)
+  );
+}
diff --git a/packages/client-runtime/src/state/threadCommands.ts b/packages/client-runtime/src/state/threadCommands.ts
index 3761d0fa6e715..7ece513cf50de 100644
--- a/packages/client-runtime/src/state/threadCommands.ts
+++ b/packages/client-runtime/src/state/threadCommands.ts
@@ -18,6 +18,8 @@ import {
   createEnvironmentRpcCommand,
 } from "./runtime.ts";
 import {
+  type BeginQueuedRunEditInput,
+  type CancelQueuedRunEditInput,
   type InterruptThreadTurnInput,
   type UpdateThreadMetadataInput,
   archiveThread,
@@ -27,6 +29,8 @@ import {
   createThread,
   deleteThread,
   editQueuedRun,
+  beginQueuedRunEdit,
+  cancelQueuedRunEdit,
   interruptThreadTurn,
   forkSideChat,
   forkThreadFromRun,
@@ -359,6 +363,18 @@ export function createThreadEnvironmentAtoms<R, E>(
       scheduler,
       concurrency,
     }),
+    beginQueuedRunEdit: createEnvironmentCommand(runtime, {
+      label: "environment-data:commands:thread:begin-queued-run-edit",
+      execute: (input: BeginQueuedRunEditInput) => beginQueuedRunEdit(input),
+      scheduler,
+      concurrency,
+    }),
+    cancelQueuedRunEdit: createEnvironmentCommand(runtime, {
+      label: "environment-data:commands:thread:cancel-queued-run-edit",
+      execute: (input: CancelQueuedRunEditInput) => cancelQueuedRunEdit(input),
+      scheduler,
+      concurrency,
+    }),
     editQueuedRun: createEnvironmentCommand(runtime, {
       label: "environment-data:commands:thread:edit-queued-run",
       execute: editQueuedRun,
diff --git a/packages/client-runtime/src/state/threadExecution.test.ts b/packages/client-runtime/src/state/threadExecution.test.ts
index fd9f1c4de8cfa..ee2f13d762eed 100644
--- a/packages/client-runtime/src/state/threadExecution.test.ts
+++ b/packages/client-runtime/src/state/threadExecution.test.ts
@@ -1,4 +1,5 @@
 import {
+  CommandId,
   TurnItemId,
   NodeId,
   MessageId,
@@ -59,6 +60,30 @@ function run(id: string, ordinal: number, status: OrchestrationV2RunStatus) {
 }
 
 describe("thread execution presentation", () => {
+  it("shows a completed thread as idle behind an edit hold while preserving active work", () => {
+    const completed = { ...run("done", 1, "completed"), completedAt: now };
+    const edited = { ...run("edited", 2, "queued"), queueEditId: CommandId.make("edit") };
+    const later = run("later", 3, "queued");
+    const projection = { ...v2Projection, runs: [completed, edited, later], updatedAt: now };
+    expect(deriveLatestThreadRun(projection)?.runId).toBe(completed.id);
+    expect(deriveThreadRuntime(projection)).toMatchObject({
+      status: "completed",
+      activeRunId: null,
+    });
+    expect(
+      deriveThreadRuntime({
+        ...projection,
+        runs: [{ ...completed, status: "running" }, edited, later],
+      }),
+    ).toMatchObject({ status: "running", activeRunId: completed.id });
+    expect(
+      deriveThreadRuntime({
+        ...projection,
+        runs: [completed, { ...edited, queuePosition: 4 }, later],
+      }),
+    ).toMatchObject({ status: "queued" });
+  });
+
   it("shows extension statuses only from the selected provider's current live session", () => {
     const instanceId = v2Projection.thread.modelSelection.instanceId;
     const providerThreadId = ProviderThreadId.make("native-status-thread");
diff --git a/packages/client-runtime/src/state/threads-sync.test.ts b/packages/client-runtime/src/state/threads-sync.test.ts
index 131d277c5e6fc..c2025297ef1d5 100644
--- a/packages/client-runtime/src/state/threads-sync.test.ts
+++ b/packages/client-runtime/src/state/threads-sync.test.ts
@@ -1,4 +1,6 @@
 import {
+  CommandId,
+  RunId,
   EnvironmentAuthorizationError,
   EnvironmentId,
   EventId,
@@ -54,6 +56,7 @@ import * as ThreadHistoryController from "./threadHistoryController.ts";
 import {
   EMPTY_ENVIRONMENT_THREAD_STATE,
   makeEnvironmentThreadState,
+  queuedRunEditOwnership,
   type EnvironmentThreadState,
   type ThreadSnapshotLoadResult,
 } from "./threads.ts";
@@ -404,6 +407,81 @@ const deleted = (sequence = 3): OrchestrationV2ThreadStreamItem => {
 };
 
 describe("EnvironmentThreads", () => {
+  it.effect(
+    "keeps edit ownership pending until the receipt sequence and detects a later takeover",
+    () =>
+      Effect.gen(function* () {
+        const run = {
+          id: RunId.make("queued-edit-run"),
+          threadId: THREAD_ID,
+          ordinal: 1,
+          providerInstanceId: BASE_PROJECTION.thread.providerInstanceId,
+          modelSelection: BASE_PROJECTION.thread.modelSelection,
+          providerThreadId: null,
+          userMessageId: MessageId.make("queued-edit-message"),
+          rootNodeId: null,
+          activeAttemptId: null,
+          status: "queued" as const,
+          queueEditId: CommandId.make("previous-editor"),
+          requestedAt: BASE_PROJECTION.updatedAt,
+          startedAt: null,
+          completedAt: null,
+          checkpointId: null,
+          contextHandoffId: null,
+        };
+        const h = yield* makeHarness({ cached: { ...BASE_PROJECTION, runs: [run] } });
+        const before = yield* awaitThreadState(h.observed, (value) => value.status === "live");
+        const edit = { runId: run.id, editId: CommandId.make("accepted-editor"), sequence: 10 };
+        expect(queuedRunEditOwnership(before, edit)).toBe("pending");
+
+        yield* Queue.offer(h.inputs, titleUpdated("Buffered before acquisition", 9));
+        const buffered = yield* awaitThreadState(h.observed, (value) => value.sequence === 9);
+        expect(queuedRunEditOwnership(buffered, edit)).toBe("pending");
+
+        yield* Queue.offer(h.inputs, {
+          kind: "event",
+          sequence: edit.sequence,
+          event: {
+            id: EventId.make("edit-acquired"),
+            type: "run.updated",
+            threadId: THREAD_ID,
+            occurredAt: BASE_PROJECTION.updatedAt,
+            payload: { ...run, queueEditId: edit.editId },
+          },
+        });
+        const acquired = yield* awaitThreadState(h.observed, (value) => value.sequence === 10);
+        expect(queuedRunEditOwnership(acquired, edit)).toBe("owned");
+        expect(queuedRunEditOwnership({ ...acquired, status: "cached" }, edit)).toBe("pending");
+        const legacy = { ...edit, editId: null, sequence: 0 };
+        expect(
+          queuedRunEditOwnership(
+            {
+              ...acquired,
+              data: Option.some({ ...BASE_PROJECTION, runs: [{ ...run, queueEditId: undefined }] }),
+            },
+            legacy,
+          ),
+        ).toBe("owned");
+        expect(queuedRunEditOwnership(acquired, legacy)).toBe("lost");
+
+        const reopened = { ...edit, editId: CommandId.make("reopened-editor"), sequence: 11 };
+        expect(queuedRunEditOwnership(acquired, reopened)).toBe("pending");
+        yield* Queue.offer(
+          h.inputs,
+          snapshot(
+            {
+              ...BASE_PROJECTION,
+              runs: [{ ...run, queueEditId: CommandId.make("another-device") }],
+            },
+            12,
+          ),
+        );
+        const superseded = yield* awaitThreadState(h.observed, (value) => value.sequence === 12);
+        expect(queuedRunEditOwnership(superseded, edit)).toBe("lost");
+        expect(queuedRunEditOwnership(superseded, reopened)).toBe("lost");
+      }),
+  );
+
   it.effect.each([
     ["disk", false],
     ["retained", false],
diff --git a/packages/client-runtime/src/state/threads.ts b/packages/client-runtime/src/state/threads.ts
index 3e8f3709a915e..efc703f05b9ab 100644
--- a/packages/client-runtime/src/state/threads.ts
+++ b/packages/client-runtime/src/state/threads.ts
@@ -1,6 +1,8 @@
 import {
   isOrchestrationV2WorkActive,
   ORCHESTRATION_V2_WS_METHODS,
+  type CommandId,
+  type RunId,
   type EnvironmentId as EnvironmentIdType,
   type OrchestrationV2ThreadDetailSnapshot,
   type OrchestrationV2ThreadProjection,
@@ -55,6 +57,19 @@ import {
   type EnvironmentThreadStatus,
 } from "./threadState.ts";
 
+export function queuedRunEditOwnership(
+  state: EnvironmentThreadState,
+  edit: { readonly runId: RunId; readonly editId: CommandId | null; readonly sequence: number },
+): "pending" | "owned" | "lost" {
+  if (
+    (state.status !== "live" && state.status !== "deleted") ||
+    (state.sequence ?? 0) < edit.sequence
+  )
+    return "pending";
+  const run = Option.getOrNull(state.data)?.runs.find((run) => run.id === edit.runId);
+  return run?.status === "queued" && (run.queueEditId ?? null) === edit.editId ? "owned" : "lost";
+}
+
 function statusWithoutLiveData(
   data: Option.Option<OrchestrationV2ThreadProjection>,
 ): EnvironmentThreadStatus {
@@ -524,7 +539,10 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make
     }
     if (sequence === appliedSequence) return;
     yield* SubscriptionRef.set(lastSequence, sequence);
-    if (fresh.length === 0) return;
+    if (fresh.length === 0) {
+      yield* SubscriptionRef.update(state, (current) => ({ ...current, sequence }));
+      return;
+    }
 
     const waiting = yield* Ref.get(awaitingCompletion);
     // Apply against the latest projection/history in one update so a concurrent
@@ -581,6 +599,7 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make
 
       const updated: EnvironmentThreadState = {
         ...current,
+        sequence,
         data: Option.some(next),
         status: waiting ? "synchronizing" : "live",
         error: Option.none(),
diff --git a/packages/contracts/src/environment.ts b/packages/contracts/src/environment.ts
index 5e9cca70752b6..f9c28a7ca7e23 100644
--- a/packages/contracts/src/environment.ts
+++ b/packages/contracts/src/environment.ts
@@ -92,6 +92,7 @@ export const ExecutionEnvironmentCapabilities = Schema.Struct({
   /** Every protocol-2 server sends this; older mobile builds still read it. */
   inlineMessageContext: Schema.optionalKey(Schema.Boolean),
   requiredWorktreeBootstrap: Schema.optionalKey(Schema.Boolean),
+  queuedRunEditHold: Schema.optionalKey(Schema.Boolean),
   threadSettlement: Schema.optionalKey(Schema.Boolean),
   threadAutoSettlement: Schema.optionalKey(Schema.Boolean),
   storageCleanup: Schema.optionalKey(Schema.Boolean),
diff --git a/packages/contracts/src/orchestrationV2.ts b/packages/contracts/src/orchestrationV2.ts
index b1fd02b3d3a07..d00cf052347c0 100644
--- a/packages/contracts/src/orchestrationV2.ts
+++ b/packages/contracts/src/orchestrationV2.ts
@@ -694,6 +694,7 @@ export const OrchestrationV2Run = Schema.Struct({
   status: OrchestrationV2RunStatus,
   queuePosition: Schema.optional(Schema.NullOr(PositiveInt)),
   queueHeld: Schema.optional(Schema.Boolean),
+  queueEditId: Schema.optional(Schema.NullOr(CommandId)),
   requestedAt: Schema.DateTimeUtc,
   startedAt: Schema.NullOr(Schema.DateTimeUtc),
   completedAt: Schema.NullOr(Schema.DateTimeUtc),
@@ -3304,8 +3305,23 @@ export const OrchestrationV2Command = Schema.Union([
     threadId: ThreadId,
     runId: RunId,
   }),
+  Schema.Struct({
+    type: Schema.Literal("queued-run.edit.begin"),
+    commandId: CommandId,
+    threadId: ThreadId,
+    runId: RunId,
+    previousEditId: Schema.NullOr(CommandId),
+  }),
+  Schema.Struct({
+    type: Schema.Literal("queued-run.edit.cancel"),
+    commandId: CommandId,
+    threadId: ThreadId,
+    runId: RunId,
+    editId: CommandId,
+  }),
   Schema.Struct({
     type: Schema.Literal("queued-run.edit"),
+    editId: Schema.optional(CommandId),
     context: Schema.optional(OrchestrationMessageContext),
     commandId: CommandId,
     threadId: ThreadId,
diff --git a/packages/shared/src/orchestrationV2ThreadError.ts b/packages/shared/src/orchestrationV2ThreadError.ts
index 5b9940729e2e1..a66b74f30c303 100644
--- a/packages/shared/src/orchestrationV2ThreadError.ts
+++ b/packages/shared/src/orchestrationV2ThreadError.ts
@@ -101,8 +101,19 @@ export function latestUnheldRun(
   runs: ReadonlyArray<OrchestrationV2Run>,
 ): OrchestrationV2Run | null {
   let latest: OrchestrationV2Run | null = null;
+  const editPosition = runs.reduce(
+    (position, run) =>
+      run.status === "queued" && run.queueEditId != null
+        ? Math.min(position, run.queuePosition ?? run.ordinal)
+        : position,
+    Number.POSITIVE_INFINITY,
+  );
   for (const run of runs) {
-    if (run.status === "queued" && run.queueHeld === true) continue;
+    if (
+      run.status === "queued" &&
+      (run.queueHeld === true || (run.queuePosition ?? run.ordinal) >= editPosition)
+    )
+      continue;
     if (latest === null || run.ordinal > latest.ordinal) latest = run;
   }
   return latest;