diff --git a/frontend/src/ai/OpenAIContext.tsx b/frontend/src/ai/OpenAIContext.tsx
index 3cead47cb..9d6f1b0a8 100644
--- a/frontend/src/ai/OpenAIContext.tsx
+++ b/frontend/src/ai/OpenAIContext.tsx
@@ -1,5 +1,6 @@
 import OpenAI from "openai";
 import { useOpenSecret } from "@opensecret/react";
+import { createAccountBoundChatFetch } from "@/services/chatAccountCredential";
 import { OpenAIContext } from "./OpenAIContextDef";
 
 export const OpenAIProvider = ({ children }: { children: React.ReactNode }) => {
@@ -8,7 +9,7 @@ export const OpenAIProvider = ({ children }: { children: React.ReactNode }) => {
     throw new Error("VITE_OPEN_SECRET_API_URL must be set");
   }
 
-  const { aiCustomFetch } = useOpenSecret();
+  const { aiCustomFetch, auth } = useOpenSecret();
   const access_token = window.localStorage.getItem("access_token");
 
   // If we're not logged in we can't set up openai
@@ -24,7 +25,11 @@ export const OpenAIProvider = ({ children }: { children: React.ReactNode }) => {
     defaultHeaders: {
       "Accept-Encoding": "identity"
     },
-    fetch: aiCustomFetch,
+    fetch: createAccountBoundChatFetch({
+      expectedUserId: auth.user?.user.id,
+      getAccessToken: () => window.localStorage.getItem("access_token"),
+      fetch: aiCustomFetch
+    }),
     maxRetries: 0 // Disable automatic retries
   });
 
diff --git a/frontend/src/components/AgentMode.tsx b/frontend/src/components/AgentMode.tsx
index 37fddd6cc..fb3e58294 100644
--- a/frontend/src/components/AgentMode.tsx
+++ b/frontend/src/components/AgentMode.tsx
@@ -59,6 +59,11 @@ import {
   ChatUserTurn
 } from "@/components/chat/ChatTurn";
 import { ChatCopyButton } from "@/components/chat/ChatCopyButton";
+import {
+  DiscardQueuedMessageEditButton,
+  QUEUED_MESSAGE_EDIT_PLACEHOLDER,
+  QueuedComposerMessages
+} from "@/components/chat/QueuedComposerMessages";
 import {
   continueChatComposerList,
   continueChatComposerListBeforeInput
@@ -5062,55 +5067,16 @@ function AgentComposer({
           {isExpanded ? <Shrink className="h-4 w-4" /> : <Expand className="h-4 w-4" />}
         </button>
       ) : null}
-      {queuedMessages.length > 0 ? (
-        <div className="flex flex-col gap-1 px-3 pt-2">
-          {queuedMessages.map((item) => (
-            <div
-              key={item.queueId}
-              className={cn(
-                "flex items-center gap-1 rounded-lg bg-muted/70 px-2 py-1 text-left text-xs text-muted-foreground",
-                item.queueId === editingQueueId && "bg-muted text-foreground ring-1 ring-border"
-              )}
-            >
-              <span className="min-w-0 flex-1 truncate" title={item.text}>
-                {item.text || `${item.attachments?.length ?? 0} image attachment(s)`}
-              </span>
-              {onCancelQueuedMessage ? (
-                <button
-                  type="button"
-                  className="rounded-md p-1 text-muted-foreground transition-colors hover:bg-background hover:text-foreground"
-                  onClick={() => onCancelQueuedMessage(item.queueId)}
-                  aria-label="Remove queued message"
-                >
-                  <Trash className="h-3.5 w-3.5" />
-                </button>
-              ) : null}
-              {onEditQueuedMessage ? (
-                <button
-                  type="button"
-                  className="rounded-md p-1 text-muted-foreground transition-colors hover:bg-background hover:text-foreground"
-                  onClick={() => onEditQueuedMessage(item.queueId)}
-                  aria-label="Edit queued message"
-                >
-                  <FilePenLine className="h-3.5 w-3.5" />
-                </button>
-              ) : null}
-              {onSteerQueuedMessage ? (
-                <button
-                  type="button"
-                  className="rounded-md p-1 text-muted-foreground transition-colors hover:bg-background hover:text-foreground disabled:pointer-events-none disabled:opacity-40"
-                  onClick={() => onSteerQueuedMessage(item.queueId)}
-                  disabled={isSendDisabled}
-                  title="Send into the current turn"
-                  aria-label="Send queued message into the current turn"
-                >
-                  <ArrowUp className="h-3.5 w-3.5" />
-                </button>
-              ) : null}
-            </div>
-          ))}
-        </div>
-      ) : null}
+      <QueuedComposerMessages
+        items={queuedMessages}
+        className={onToggleExpanded ? "pr-10" : undefined}
+        editingQueueId={editingQueueId}
+        getFallbackLabel={(item) => `${item.attachments?.length ?? 0} image attachment(s)`}
+        onRemove={onCancelQueuedMessage}
+        onEdit={onEditQueuedMessage}
+        onSendNow={onSteerQueuedMessage}
+        sendNowDisabled={isSendDisabled}
+      />
       {!editingQueueId && draftImages.length > 0 ? (
         <div className="flex flex-wrap gap-2 px-3 pt-3">
           {draftImages.map((image, index) => (
@@ -5149,9 +5115,7 @@ function AgentComposer({
         onPaste={onImagePaste}
         disabled={isSendDisabled}
         placeholder={
-          editingQueueId
-            ? "Edit the queued message, then send to keep its place..."
-            : "Ask Maple to work in this folder..."
+          editingQueueId ? QUEUED_MESSAGE_EDIT_PLACEHOLDER : "Ask Maple to work in this folder..."
         }
         className={cn(
           CHAT_COMPOSER_TEXTAREA_CLASS,
@@ -5234,15 +5198,7 @@ function AgentComposer({
 
         <div className="flex shrink-0 items-center self-end gap-1.5 sm:gap-2">
           {editingQueueId && onDiscardQueuedMessageEdit ? (
-            <Button
-              type="button"
-              size="sm"
-              variant="ghost"
-              className="h-8 px-2 text-xs text-muted-foreground"
-              onClick={onDiscardQueuedMessageEdit}
-            >
-              Discard
-            </Button>
+            <DiscardQueuedMessageEditButton onDiscard={onDiscardQueuedMessageEdit} />
           ) : null}
           {agentComposerShowsStop(isSending) ? (
             <Button
diff --git a/frontend/src/components/ChatHistoryList.tsx b/frontend/src/components/ChatHistoryList.tsx
index c086dabb1..61905ff98 100644
--- a/frontend/src/components/ChatHistoryList.tsx
+++ b/frontend/src/components/ChatHistoryList.tsx
@@ -48,17 +48,29 @@ import {
   type NewChatNavigationDetail
 } from "@/services/chatRuntimeNavigation";
 import { useChatRuntimeStore } from "@/contexts/ChatRuntimeContext";
+import { useOpenAI } from "@/ai/useOpenAi";
 import {
   resumeOrCreateChatDraftKey,
   rootChatDraftKeyAfterProjectDeletion
 } from "@/services/chatDraftSelection";
 import { createConversationChatKey } from "@/services/chatRuntimeStore";
+import {
+  beginAllChatRuntimeDeletionFence,
+  beginChatProjectRuntimeDeletionFence,
+  beginChatRuntimeDeletionFence
+} from "@/services/chatRuntimeDeletionFence";
 import {
   INITIAL_CHAT_HISTORY_RETRY_COUNT,
   conversationHistoryQueryKey,
   initialChatHistoryPage,
   shouldLoadConversationHistory
 } from "@/services/chatHistoryAccountScope";
+import {
+  cancelChatResponseForHistoryDeletion,
+  quiesceChatRuntimeRunsForHistoryDeletion,
+  settleChatRuntimeAfterHistoryCancellation
+} from "@/services/chatHistoryDeletionQuiescence";
+import { assertChatAccountCredential } from "@/services/chatAccountCredential";
 
 const MAX_PROJECTS = 10;
 /** Lucide default; keep sidebar list icons visually consistent. */
@@ -100,6 +112,7 @@ export function ChatHistoryList({
   containerRef
 }: ChatHistoryListProps) {
   const opensecret = useOpenSecret();
+  const openai = useOpenAI();
   const router = useRouter();
   const queryClient = useQueryClient();
   const { selectedProjectId, setSelectedProjectId } = useSelectedProjectState();
@@ -684,7 +697,22 @@ export function ChatHistoryList({
   // Handle conversation deletion via API
   const handleDeleteConversation = useCallback(
     async (conversationId: string) => {
+      const expectedUserId = opensecret.auth.user?.user.id;
+      const releaseDeletionFence = beginChatRuntimeDeletionFence(
+        runtimeStore,
+        createConversationChatKey(conversationId)
+      );
       try {
+        assertChatAccountCredential(expectedUserId);
+        await quiesceChatRuntimeRunsForHistoryDeletion({
+          store: runtimeStore,
+          keys: [createConversationChatKey(conversationId)],
+          responseOwnershipClient: openai,
+          cancelResponse: (responseId) => cancelChatResponseForHistoryDeletion(openai, responseId),
+          settleCancelledRun: (key, runToken) =>
+            settleChatRuntimeAfterHistoryCancellation(runtimeStore, key, runToken)
+        });
+        assertChatAccountCredential(expectedUserId);
         await opensecret.deleteConversation(conversationId);
 
         if (conversationId === currentChatId) {
@@ -704,9 +732,11 @@ export function ChatHistoryList({
         }
       } catch (error) {
         console.error("Error deleting conversation:", error);
+      } finally {
+        releaseDeletionFence();
       }
     },
-    [currentChatId, invalidateConversationData, opensecret, runtimeStore]
+    [currentChatId, invalidateConversationData, openai, opensecret, runtimeStore]
   );
 
   const MAX_SELECTION = 20;
@@ -734,11 +764,26 @@ export function ChatHistoryList({
     if (selectedIds.size === 0) return;
 
     setIsBulkDeleting(true);
+    const releaseDeletionFences = Array.from(selectedIds, (id) =>
+      beginChatRuntimeDeletionFence(runtimeStore, createConversationChatKey(id))
+    );
     try {
+      const expectedUserId = opensecret.auth.user?.user.id;
+      assertChatAccountCredential(expectedUserId);
       const idsToDelete = Array.from(selectedIds);
+      const keysToDelete = idsToDelete.map((id) => createConversationChatKey(id));
       const deletedIds = new Set<string>();
 
       if (opensecret) {
+        await quiesceChatRuntimeRunsForHistoryDeletion({
+          store: runtimeStore,
+          keys: keysToDelete,
+          responseOwnershipClient: openai,
+          cancelResponse: (responseId) => cancelChatResponseForHistoryDeletion(openai, responseId),
+          settleCancelledRun: (key, runToken) =>
+            settleChatRuntimeAfterHistoryCancellation(runtimeStore, key, runToken)
+        });
+        assertChatAccountCredential(expectedUserId);
         const result = await opensecret.batchDeleteConversations(idsToDelete);
 
         result.data.filter((item) => item.deleted).forEach((item) => deletedIds.add(item.id));
@@ -768,10 +813,12 @@ export function ChatHistoryList({
     } catch (error) {
       console.error("Error bulk deleting chats:", error);
     } finally {
+      for (const releaseDeletionFence of releaseDeletionFences) releaseDeletionFence();
       setIsBulkDeleting(false);
     }
   }, [
     selectedIds,
+    openai,
     opensecret,
     invalidateConversationData,
     currentChatId,
@@ -985,13 +1032,15 @@ export function ChatHistoryList({
   const handleDeleteProject = useCallback(async () => {
     if (!selectedProject) return;
     let replacementDispatched = false;
+    const projectConversationKeys = new Set<ReturnType<typeof createConversationChatKey>>();
     const projectAwayFromDeletedProject = () => {
       if (replacementDispatched) return;
       const deletingProjectedChat =
         selectedProjectId === selectedProject.id ||
         (currentChatId
-          ? runtimeStore.getActivityGroupId(createConversationChatKey(currentChatId)) ===
-            selectedProject.id
+          ? projectConversationKeys.has(createConversationChatKey(currentChatId)) ||
+            runtimeStore.getActivityGroupId(createConversationChatKey(currentChatId)) ===
+              selectedProject.id
           : false);
       if (!deletingProjectedChat) return;
 
@@ -1015,7 +1064,38 @@ export function ChatHistoryList({
       window.dispatchEvent(new Event("projectselected"));
     };
 
+    // Until server membership is known, conservatively pause every local
+    // runner. Replace this short discovery fence synchronously with exact-key
+    // plus activity-group fences before the destructive request starts.
+    const releaseDiscoveryFence = beginAllChatRuntimeDeletionFence(runtimeStore);
+    let releaseDeletionFence: (() => void) | null = null;
     try {
+      const expectedUserId = opensecret.auth.user?.user.id;
+      assertChatAccountCredential(expectedUserId);
+      const projectConversations = await listAllConversations(opensecret, {
+        project_id: selectedProject.id
+      });
+      for (const conversation of projectConversations) {
+        projectConversationKeys.add(createConversationChatKey(conversation.id));
+      }
+      releaseDeletionFence = beginChatProjectRuntimeDeletionFence(
+        runtimeStore,
+        selectedProject.id,
+        Array.from(projectConversationKeys)
+      );
+      releaseDiscoveryFence();
+
+      await quiesceChatRuntimeRunsForHistoryDeletion({
+        store: runtimeStore,
+        keys: Array.from(projectConversationKeys),
+        activityGroupId: selectedProject.id,
+        responseOwnershipClient: openai,
+        cancelResponse: (responseId) => cancelChatResponseForHistoryDeletion(openai, responseId),
+        settleCancelledRun: (key, runToken) =>
+          settleChatRuntimeAfterHistoryCancellation(runtimeStore, key, runToken)
+      });
+
+      assertChatAccountCredential(expectedUserId);
       await opensecret.deleteConversationProject(selectedProject.id);
       projectAwayFromDeletedProject();
 
@@ -1031,16 +1111,21 @@ export function ChatHistoryList({
         projectAwayFromDeletedProject();
         // A selected chat in this project has now committed its replacement;
         // grouped background runtimes can be aborted and discarded safely.
+        for (const key of projectConversationKeys) runtimeStore.delete(key);
         runtimeStore.deleteActivityGroup(selectedProject.id);
       }
     } catch (error) {
       console.error("Error deleting project:", error);
       throw error;
+    } finally {
+      releaseDeletionFence?.();
+      releaseDiscoveryFence();
     }
   }, [
     currentChatId,
     expandedProjectId,
     invalidateConversationData,
+    openai,
     opensecret,
     selectedProject,
     selectedProjectId,
diff --git a/frontend/src/components/GuestPaymentWarningDialog.tsx b/frontend/src/components/GuestPaymentWarningDialog.tsx
index 1d4b8d927..cf937b14e 100644
--- a/frontend/src/components/GuestPaymentWarningDialog.tsx
+++ b/frontend/src/components/GuestPaymentWarningDialog.tsx
@@ -18,6 +18,9 @@ import {
 import { resetWorkspaceModePreference } from "@/services/workspaceModePreference";
 import { useState } from "react";
 import { getBillingService } from "@/billing/billingService";
+import { useChatRuntimeStore } from "@/contexts/ChatRuntimeContext";
+import { beginAllChatRuntimeDeletionFence } from "@/services/chatRuntimeDeletionFence";
+import { assertChatAccountCredential } from "@/services/chatAccountCredential";
 
 interface GuestPaymentWarningDialogProps {
   open: boolean;
@@ -28,6 +31,7 @@ export function GuestPaymentWarningDialog({ open, onOpenChange }: GuestPaymentWa
   const navigate = useNavigate();
   const os = useOpenSecret();
   const queryClient = useQueryClient();
+  const runtimeStore = useChatRuntimeStore<unknown, unknown>();
   const [isLoggingOut, setIsLoggingOut] = useState(false);
   const [logoutError, setLogoutError] = useState<string | null>(null);
 
@@ -38,25 +42,42 @@ export function GuestPaymentWarningDialog({ open, onOpenChange }: GuestPaymentWa
   const handleLogout = async () => {
     setLogoutError(null);
     setIsLoggingOut(true);
+    const releaseChatFence = beginAllChatRuntimeDeletionFence(runtimeStore);
     let operationBlock: Awaited<ReturnType<typeof stopAgentRuntimeForUser>> | null = null;
     let signedOut = false;
     let nativeAuthCleared = false;
     const userId = os.auth.user?.user.id;
 
+    try {
+      assertChatAccountCredential(userId);
+    } catch (error) {
+      console.error("Account changed before sign out:", error);
+      releaseChatFence();
+      setLogoutError("Your account changed in another window. Refresh Maple before signing out.");
+      setIsLoggingOut(false);
+      return;
+    }
+
     try {
       operationBlock = await stopAgentRuntimeForUser(userId);
     } catch (error) {
       console.error("Error stopping Agent Mode:", error);
+      releaseChatFence();
       setLogoutError("Maple couldn't stop Agent Mode. Please try logging out again.");
       setIsLoggingOut(false);
       return;
     }
 
     try {
+      assertChatAccountCredential(userId);
       // Credential reset is a required part of logout.
       const { proxyService } = await import("@/services/proxyService");
-      await proxyService.stopAndResetProxy(userId, os.deleteApiKey);
+      await proxyService.stopAndResetProxy(userId, (name) => {
+        assertChatAccountCredential(userId);
+        return os.deleteApiKey(name);
+      });
 
+      assertChatAccountCredential(userId);
       // Third-party billing tokens outlive the OpenSecret browser session. If
       // one survives logout, the next account can briefly query billing as the
       // previous user until that token expires.
@@ -68,6 +89,7 @@ export function GuestPaymentWarningDialog({ open, onOpenChange }: GuestPaymentWa
 
       await clearMapleApiAuthForUser(userId);
       nativeAuthCleared = true;
+      assertChatAccountCredential(userId);
       await os.signOut();
       signedOut = true;
       resetWorkspaceModePreference();
@@ -79,6 +101,7 @@ export function GuestPaymentWarningDialog({ open, onOpenChange }: GuestPaymentWa
       );
     } finally {
       if (!signedOut) {
+        releaseChatFence();
         if (nativeAuthCleared) {
           try {
             await restoreMapleApiAuthForUser(userId);
diff --git a/frontend/src/components/ProjectDetailView.tsx b/frontend/src/components/ProjectDetailView.tsx
index 0c58b3705..286d83b36 100644
--- a/frontend/src/components/ProjectDetailView.tsx
+++ b/frontend/src/components/ProjectDetailView.tsx
@@ -46,18 +46,30 @@ import { RenameChatDialog } from "@/components/RenameChatDialog";
 import { DeleteChatDialog } from "@/components/DeleteChatDialog";
 import { BulkDeleteDialog } from "@/components/BulkDeleteDialog";
 import { MoveChatsDialog } from "@/components/MoveChatsDialog";
-import { listAllConversationProjects } from "@/utils/paginatedLists";
+import { listAllConversationProjects, listAllConversations } from "@/utils/paginatedLists";
 import { usePersistentSidebarState } from "@/contexts/PersistentHomeNavigationContext";
 import { useChatRuntimeStore } from "@/contexts/ChatRuntimeContext";
+import { useOpenAI } from "@/ai/useOpenAi";
 import {
   resumeOrCreateChatDraftKey,
   rootChatDraftKeyAfterProjectDeletion
 } from "@/services/chatDraftSelection";
 import { createConversationChatKey } from "@/services/chatRuntimeStore";
+import {
+  beginAllChatRuntimeDeletionFence,
+  beginChatProjectRuntimeDeletionFence,
+  beginChatRuntimeDeletionFence
+} from "@/services/chatRuntimeDeletionFence";
 import {
   createChatHistoryEntryForDraft,
   type NewChatNavigationDetail
 } from "@/services/chatRuntimeNavigation";
+import {
+  cancelChatResponseForHistoryDeletion,
+  quiesceChatRuntimeRunsForHistoryDeletion,
+  settleChatRuntimeAfterHistoryCancellation
+} from "@/services/chatHistoryDeletionQuiescence";
+import { assertChatAccountCredential } from "@/services/chatAccountCredential";
 
 const PROJECT_PAGE_SIZE = 20;
 const MAX_SELECTION = 20;
@@ -154,6 +166,7 @@ function ProjectInstructionsDialog({
 
 export function ProjectDetailView({ projectId }: ProjectDetailViewProps) {
   const os = useOpenSecret();
+  const openai = useOpenAI();
   const userId = os.auth.user?.user.id;
   const queryClient = useQueryClient();
   const isMobile = useIsMobile();
@@ -386,20 +399,51 @@ export function ProjectDetailView({ projectId }: ProjectDetailViewProps) {
   );
 
   const handleDeleteProject = useCallback(async () => {
-    await os.deleteConversationProject(projectId);
-    runtimeStore.deleteActivityGroup(projectId);
-    await invalidateConversationData();
-    setSelectedProjectId(null);
-    const draftRuntimeKey = rootChatDraftKeyAfterProjectDeletion(runtimeStore);
-    const chatEntry = createChatHistoryEntryForDraft(draftRuntimeKey);
-    window.history.replaceState(chatEntry.historyState, "", "/");
-    window.dispatchEvent(
-      new CustomEvent<NewChatNavigationDetail>("newchat", {
-        detail: { projectId: null, draftRuntimeKey: chatEntry.draftRuntimeKey }
-      })
-    );
-    window.dispatchEvent(new Event("projectselected"));
-  }, [invalidateConversationData, os, projectId, runtimeStore, setSelectedProjectId]);
+    const expectedUserId = os.auth.user?.user.id;
+    const releaseDiscoveryFence = beginAllChatRuntimeDeletionFence(runtimeStore);
+    let releaseDeletionFence: (() => void) | null = null;
+    try {
+      assertChatAccountCredential(expectedUserId);
+      const projectConversationKeys = (
+        await listAllConversations(os, { project_id: projectId })
+      ).map((conversation) => createConversationChatKey(conversation.id));
+      releaseDeletionFence = beginChatProjectRuntimeDeletionFence(
+        runtimeStore,
+        projectId,
+        projectConversationKeys
+      );
+      releaseDiscoveryFence();
+
+      await quiesceChatRuntimeRunsForHistoryDeletion({
+        store: runtimeStore,
+        keys: projectConversationKeys,
+        activityGroupId: projectId,
+        responseOwnershipClient: openai,
+        cancelResponse: (responseId) => cancelChatResponseForHistoryDeletion(openai, responseId),
+        settleCancelledRun: (key, runToken) =>
+          settleChatRuntimeAfterHistoryCancellation(runtimeStore, key, runToken)
+      });
+
+      assertChatAccountCredential(expectedUserId);
+      await os.deleteConversationProject(projectId);
+      for (const key of projectConversationKeys) runtimeStore.delete(key);
+      runtimeStore.deleteActivityGroup(projectId);
+      await invalidateConversationData();
+      setSelectedProjectId(null);
+      const draftRuntimeKey = rootChatDraftKeyAfterProjectDeletion(runtimeStore);
+      const chatEntry = createChatHistoryEntryForDraft(draftRuntimeKey);
+      window.history.replaceState(chatEntry.historyState, "", "/");
+      window.dispatchEvent(
+        new CustomEvent<NewChatNavigationDetail>("newchat", {
+          detail: { projectId: null, draftRuntimeKey: chatEntry.draftRuntimeKey }
+        })
+      );
+      window.dispatchEvent(new Event("projectselected"));
+    } finally {
+      releaseDeletionFence?.();
+      releaseDiscoveryFence();
+    }
+  }, [invalidateConversationData, openai, os, projectId, runtimeStore, setSelectedProjectId]);
 
   const handleRenameConversation = useCallback(
     async (conversationId: string, newTitle: string) => {
@@ -411,16 +455,35 @@ export function ProjectDetailView({ projectId }: ProjectDetailViewProps) {
 
   const handleDeleteConversation = useCallback(
     async (conversationId: string) => {
-      await os.deleteConversation(conversationId);
-      runtimeStore.delete(createConversationChatKey(conversationId));
-      setSelectedIds((prev) => {
-        const next = new Set(prev);
-        next.delete(conversationId);
-        return next;
-      });
-      await refreshProjectPage();
+      const expectedUserId = os.auth.user?.user.id;
+      const releaseDeletionFence = beginChatRuntimeDeletionFence(
+        runtimeStore,
+        createConversationChatKey(conversationId)
+      );
+      try {
+        assertChatAccountCredential(expectedUserId);
+        await quiesceChatRuntimeRunsForHistoryDeletion({
+          store: runtimeStore,
+          keys: [createConversationChatKey(conversationId)],
+          responseOwnershipClient: openai,
+          cancelResponse: (responseId) => cancelChatResponseForHistoryDeletion(openai, responseId),
+          settleCancelledRun: (key, runToken) =>
+            settleChatRuntimeAfterHistoryCancellation(runtimeStore, key, runToken)
+        });
+        assertChatAccountCredential(expectedUserId);
+        await os.deleteConversation(conversationId);
+        runtimeStore.delete(createConversationChatKey(conversationId));
+        setSelectedIds((prev) => {
+          const next = new Set(prev);
+          next.delete(conversationId);
+          return next;
+        });
+        await refreshProjectPage();
+      } finally {
+        releaseDeletionFence();
+      }
     },
-    [os, refreshProjectPage, runtimeStore]
+    [openai, os, refreshProjectPage, runtimeStore]
   );
 
   const handleToggleConversationPin = useCallback(
@@ -452,8 +515,23 @@ export function ProjectDetailView({ projectId }: ProjectDetailViewProps) {
 
     setIsBulkDeleting(true);
     setError(null);
+    const releaseDeletionFences = Array.from(selectedIds, (id) =>
+      beginChatRuntimeDeletionFence(runtimeStore, createConversationChatKey(id))
+    );
     try {
-      const result = await os.batchDeleteConversations(Array.from(selectedIds));
+      const expectedUserId = os.auth.user?.user.id;
+      assertChatAccountCredential(expectedUserId);
+      const idsToDelete = Array.from(selectedIds);
+      await quiesceChatRuntimeRunsForHistoryDeletion({
+        store: runtimeStore,
+        keys: idsToDelete.map((id) => createConversationChatKey(id)),
+        responseOwnershipClient: openai,
+        cancelResponse: (responseId) => cancelChatResponseForHistoryDeletion(openai, responseId),
+        settleCancelledRun: (key, runToken) =>
+          settleChatRuntimeAfterHistoryCancellation(runtimeStore, key, runToken)
+      });
+      assertChatAccountCredential(expectedUserId);
+      const result = await os.batchDeleteConversations(idsToDelete);
       for (const item of result.data) {
         if (item.deleted) runtimeStore.delete(createConversationChatKey(item.id));
       }
@@ -464,9 +542,10 @@ export function ProjectDetailView({ projectId }: ProjectDetailViewProps) {
       console.error("Error bulk deleting chats:", error);
       setError("Failed to delete selected chats. Please try again.");
     } finally {
+      for (const releaseDeletionFence of releaseDeletionFences) releaseDeletionFence();
       setIsBulkDeleting(false);
     }
-  }, [os, refreshProjectPage, runtimeStore, selectedIds]);
+  }, [openai, os, refreshProjectPage, runtimeStore, selectedIds]);
 
   const handleMoveSelectedConversations = useCallback(
     async (targetProjectId: string | null) => {
diff --git a/frontend/src/components/RootRuntimeLayout.test.tsx b/frontend/src/components/RootRuntimeLayout.test.tsx
index a210e86b0..3cbe0f73f 100644
--- a/frontend/src/components/RootRuntimeLayout.test.tsx
+++ b/frontend/src/components/RootRuntimeLayout.test.tsx
@@ -1,7 +1,8 @@
 import { describe, expect, mock, test } from "bun:test";
-import { useCallback, useEffect, useState, type ReactNode } from "react";
+import { useCallback, useEffect, useLayoutEffect, useState, type ReactNode } from "react";
 import { act, create, type ReactTestRenderer } from "react-test-renderer";
 import { useChatRuntimeStore } from "@/contexts/ChatRuntimeContext";
+import { createConversationChatKey } from "@/services/chatRuntimeStore";
 import { RootRuntimeLayout } from "./RootRuntimeLayout";
 
 function OAuthCallbackProbe({ processCallback }: { processCallback: () => void }) {
@@ -55,6 +56,48 @@ function ChatStoreProbe({ onStore }: { onStore: (store: unknown) => void }) {
   return null;
 }
 
+type AccountRunBoundary = {
+  previous?: {
+    store: {
+      getActiveRunKeys: () => readonly string[];
+    };
+    signal: AbortSignal;
+  };
+  observed?: {
+    activeRunKeys: readonly string[];
+    signalAborted: boolean;
+  };
+};
+
+function AccountRunBoundaryProbe({
+  userId,
+  boundary
+}: {
+  userId: string;
+  boundary: AccountRunBoundary;
+}) {
+  const store = useChatRuntimeStore<unknown, unknown>();
+
+  useLayoutEffect(() => {
+    if (userId === "user-a") {
+      const runtimeKey = createConversationChatKey("account-boundary");
+      store.ensure(runtimeKey);
+      const run = store.beginRun(runtimeKey);
+      boundary.previous = { store, signal: run.signal };
+      return;
+    }
+
+    const previous = boundary.previous;
+    if (!previous) return;
+    boundary.observed = {
+      activeRunKeys: [...previous.store.getActiveRunKeys()],
+      signalAborted: previous.signal.aborted
+    };
+  }, [boundary, store, userId]);
+
+  return null;
+}
+
 describe("RootRuntimeLayout", () => {
   test("keeps the OAuth callback route mounted when success authenticates a user", () => {
     const processCallback = mock(() => {});
@@ -160,6 +203,41 @@ describe("RootRuntimeLayout", () => {
     act(() => renderer.unmount());
   });
 
+  test("cancels the previous account's queue runner before new-account layout effects", () => {
+    const boundary: AccountRunBoundary = {};
+    let renderer: ReactTestRenderer;
+
+    act(() => {
+      renderer = create(
+        <RootRuntimeLayout
+          userId="user-a"
+          pathname="/"
+          authenticatedHome={null}
+          routeContent={<div />}
+          accountScopedUi={<AccountRunBoundaryProbe userId="user-a" boundary={boundary} />}
+        />
+      );
+    });
+
+    expect(boundary.previous?.signal.aborted).toBe(false);
+
+    act(() => {
+      renderer.update(
+        <RootRuntimeLayout
+          userId="user-b"
+          pathname="/"
+          authenticatedHome={null}
+          routeContent={<div />}
+          accountScopedUi={<AccountRunBoundaryProbe userId="user-b" boundary={boundary} />}
+        />
+      );
+    });
+
+    expect(boundary.observed).toEqual({ activeRunKeys: [], signalAborted: true });
+
+    act(() => renderer.unmount());
+  });
+
   test("shares the same-account chat store when moving from home to an ordinary route", () => {
     const homeStores: unknown[] = [];
     const routeStores: unknown[] = [];
@@ -196,6 +274,30 @@ describe("RootRuntimeLayout", () => {
     act(() => renderer.unmount());
   });
 
+  test("shares the account chat store with account-scoped UI", () => {
+    const homeStores: unknown[] = [];
+    const accountUiStores: unknown[] = [];
+    let renderer: ReactTestRenderer;
+
+    act(() => {
+      renderer = create(
+        <RootRuntimeLayout
+          userId="user-a"
+          pathname="/"
+          authenticatedHome={<ChatStoreProbe onStore={(store) => homeStores.push(store)} />}
+          routeContent={<div />}
+          accountScopedUi={<ChatStoreProbe onStore={(store) => accountUiStores.push(store)} />}
+        />
+      );
+    });
+
+    expect(homeStores).toHaveLength(1);
+    expect(accountUiStores).toHaveLength(1);
+    expect(accountUiStores[0]).toBe(homeStores[0]);
+
+    act(() => renderer.unmount());
+  });
+
   test("retains the same-account chat store while authenticated home is temporarily hidden", () => {
     const stores: unknown[] = [];
     const recordStore = mock((store: unknown) => stores.push(store));
diff --git a/frontend/src/components/RootRuntimeLayout.tsx b/frontend/src/components/RootRuntimeLayout.tsx
index 9557bdae9..936e4c470 100644
--- a/frontend/src/components/RootRuntimeLayout.tsx
+++ b/frontend/src/components/RootRuntimeLayout.tsx
@@ -32,7 +32,8 @@ function getRouteScopeKey(pathname: string, accountScopeKey: string): string {
  * ordinary routed content. The OAuth callback route stays outside that provider
  * so its one-shot effect cannot replay. Signup also retains its route state long
  * enough to show a newly created anonymous user's Account ID. Global
- * account-scoped UI retains its previous remount behavior.
+ * account-scoped UI shares the account-keyed Chat runtime while retaining its
+ * previous account-transition remount behavior.
  */
 export function RootRuntimeLayout({
   userId,
@@ -53,9 +54,9 @@ export function RootRuntimeLayout({
       <ChatRuntimeProvider key={`chat:${accountScopeKey}`}>
         {authenticatedHome}
         {!isAuthTransitionRoute ? keyedRouteContent : null}
+        <Fragment key={`global:${accountScopeKey}`}>{accountScopedUi}</Fragment>
       </ChatRuntimeProvider>
       {isAuthTransitionRoute ? keyedRouteContent : null}
-      <Fragment key={`global:${accountScopeKey}`}>{accountScopedUi}</Fragment>
     </>
   );
 }
diff --git a/frontend/src/components/UnifiedChat.tsx b/frontend/src/components/UnifiedChat.tsx
index fb763fde7..2cb30d0ef 100644
--- a/frontend/src/components/UnifiedChat.tsx
+++ b/frontend/src/components/UnifiedChat.tsx
@@ -6,7 +6,8 @@ import {
   useCallback,
   memo,
   useMemo,
-  useId
+  useId,
+  useSyncExternalStore
 } from "react";
 import { flushSync } from "react-dom";
 import {
@@ -60,6 +61,11 @@ import {
   ChatDesktopConversationHeader,
   ChatUserTurn
 } from "@/components/chat/ChatTurn";
+import {
+  DiscardQueuedMessageEditButton,
+  QUEUED_MESSAGE_EDIT_PLACEHOLDER,
+  QueuedComposerMessages
+} from "@/components/chat/QueuedComposerMessages";
 import { ChatCopyButton } from "@/components/chat/ChatCopyButton";
 import { ToolActivityCard } from "@/components/ToolActivityCard";
 import {
@@ -161,23 +167,69 @@ import {
   cleanupRecordingForTeardown,
   isRecordingOwnershipCurrent
 } from "@/services/chatRecordingNavigation";
-import {
-  canAdoptAttachmentDestination,
-  mutateAttachmentComposerWhenIdle,
-  planRestoredImageUrls
-} from "@/services/chatAttachmentOwnership";
+import { canAdoptAttachmentDestination } from "@/services/chatAttachmentOwnership";
 import {
   classifyChatStreamEof,
   createChatStreamDeltaCoalescer,
   flushRegisteredChatStreamDeltas,
   isTerminalChatStreamErrorEvent,
   registerChatStreamDeltaCoalescer,
-  removeOwnedChatStreamAttemptItems,
   unregisterChatStreamDeltaCoalescer,
   type ChatStreamTerminalState
 } from "@/services/chatStreamDeltaCoalescer";
-import { recoverFailedSendAfterDestinationAdoption } from "@/services/chatSendFailureRecovery";
-import { isImageDescriptionUnavailableError } from "@/services/chatResponseErrors";
+import {
+  isChatRequestDefinitelyNotDispatchedError,
+  isChatResponseCancellationAlreadyTerminalError,
+  isChatResponseDefinitelyRejectedError,
+  isImageDescriptionUnavailableError
+} from "@/services/chatResponseErrors";
+import { isChatAccountCredentialMismatchError } from "@/services/chatAccountCredential";
+import { chatCursorAfterSendFailure } from "@/services/chatSendFailureRecovery";
+import { normalizeChatPollingPage } from "@/services/chatPollingPage";
+import {
+  classifyChatResponseReconciliation,
+  responseIdForChatMessage
+} from "@/services/chatResponseReconciliation";
+import {
+  clearUnresolvedChatResponseMessage,
+  getUnresolvedChatResponseMessage,
+  registerUnresolvedChatResponseMessage
+} from "@/services/chatUnresolvedResponseOwnership";
+import {
+  chatAccountQueueUsage,
+  selectChatImageFilesForRetention
+} from "@/services/chatAccountQueueBudget";
+import { isChatRuntimeDeletionPending } from "@/services/chatRuntimeDeletionFence";
+import {
+  clearChatRunQueueHalt,
+  isChatRunQueueHaltRequested,
+  requestChatRunQueueHalt
+} from "@/services/chatRunQueueHalt";
+import { chatStoppingRuntimeRegistryFor } from "@/services/chatStoppingRuntimeRegistry";
+import {
+  registerChatCurrentTurn,
+  restoreRegisteredChatTurnBeforeRequest
+} from "@/services/chatCurrentTurnRegistry";
+import {
+  beginChatQueuedMessageEdit,
+  cancelChatQueuedMessage,
+  chatComposerObjectUrls,
+  chatQueuedTextByteLength,
+  discardChatQueuedMessageEdit,
+  MAX_CHAT_ACCOUNT_RETAINED_ATTACHMENT_BYTES,
+  MAX_CHAT_ACCOUNT_RETAINED_IMAGES,
+  mergeChatComposerDraftsForRekey,
+  recoverDetachedChatComposerDraft,
+  takeNextChatQueuedMessage,
+  type ChatQueuedMessage,
+  type ChatQueuedMessageMetadata
+} from "@/services/chatComposerQueue";
+import {
+  canSubmitChatComposer,
+  chatComposerWithInputOverride,
+  chatComposerShowsStop,
+  planChatComposerSubmission
+} from "@/services/chatComposerSend";
 import {
   chatToolCallStatus,
   chatToolOutputStatus,
@@ -195,6 +247,12 @@ import { toolKindFromName } from "@/services/toolPresentation";
 
 const CHAT_ALERT_CLASS = "absolute top-16 left-1/2 z-50 w-full max-w-2xl -translate-x-1/2 px-4";
 const STREAM_EVENT_DEBUG_STORAGE_KEY = "maple:sse-debug";
+const CHAT_ACCOUNT_ATTACHMENT_LIMIT_MESSAGE =
+  "Chat drafts and queued attachments can use up to 256 MiB across your account";
+const CHAT_ACCOUNT_IMAGE_LIMIT_MESSAGE = `Chat drafts and queued messages can retain up to ${MAX_CHAT_ACCOUNT_RETAINED_IMAGES} images across your account`;
+const CHAT_MESSAGE_IMAGE_LIMIT_MESSAGE = "You can attach up to 10 images to a message";
+const CHAT_STOP_WAITING_MESSAGE = "Stopping as soon as the response is ready…";
+const CHAT_STOP_REQUEST_TIMEOUT_MS = 5000;
 
 function isStreamEventDebugLoggingEnabled(): boolean {
   if (!import.meta.env.DEV || typeof window === "undefined") return false;
@@ -271,6 +329,75 @@ type Message =
   | ToolOutputItem
   | ReasoningItem;
 
+function queuedChatMessageText(item: ChatQueuedMessage): string {
+  return item.documentText + (item.documentText && item.text ? `\n\n${item.text}` : item.text);
+}
+
+function queuedChatMessageContent(
+  item: ChatQueuedMessage,
+  imageUrlForFile: (file: File) => string | undefined
+): (InputTextContent | InputImageContent)[] {
+  const content: (InputTextContent | InputImageContent)[] = [];
+  const text = queuedChatMessageText(item);
+  if (text) content.push({ type: "input_text", text });
+  for (const file of item.draftImages) {
+    const imageUrl = imageUrlForFile(file);
+    if (!imageUrl) continue;
+    content.push({
+      type: "input_image",
+      image_url: imageUrl,
+      detail: "auto",
+      file_id: null
+    });
+  }
+  return content;
+}
+
+function promotedChatUserMessage(
+  item: ChatQueuedMessage,
+  content = queuedChatMessageContent(item, (file) => item.imageUrls.get(file))
+): Message {
+  return {
+    id: item.messageId,
+    type: "message",
+    role: "user",
+    content,
+    status: "completed"
+  } as unknown as Message;
+}
+
+function queuedChatMessageFallbackLabel(item: ChatQueuedMessage): string {
+  if (item.documentName) return item.documentName;
+  const imageCount = item.draftImages.length;
+  return imageCount === 1 ? "1 image" : imageCount > 1 ? `${imageCount} images` : "Queued message";
+}
+
+function chatTranscriptObjectUrls(messages: readonly Message[]): string[] {
+  const urls = new Set<string>();
+  for (const message of messages) {
+    if (message.type !== "message" || !Array.isArray(message.content)) continue;
+    for (const content of message.content) {
+      if (
+        content.type === "input_image" &&
+        typeof content.image_url === "string" &&
+        content.image_url.startsWith("blob:")
+      ) {
+        urls.add(content.image_url);
+      }
+    }
+  }
+  return Array.from(urls);
+}
+
+function revokeQueuedChatMessageObjectUrls(
+  item: ChatQueuedMessage,
+  retainedObjectUrls: ReadonlySet<string> = new Set()
+): void {
+  for (const url of new Set(item.imageUrls.values())) {
+    if (!retainedObjectUrls.has(url)) URL.revokeObjectURL(url);
+  }
+}
+
 // Helper function to merge messages while ensuring uniqueness by ID
 // This prevents duplicate key warnings in React by deduplicating messages
 function mergeMessagesById(existingMessages: Message[], newMessages: Message[]): Message[] {
@@ -688,7 +815,7 @@ function summarizeStreamEventForLog(eventType: string, event: unknown): Record<s
 
 function updateActiveItemStatuses(
   messages: Message[],
-  status: "error" | "incomplete",
+  status: "completed" | "error" | "incomplete",
   ownedItemIds?: ReadonlySet<string>
 ): Message[] {
   const updatedMessages = messages
@@ -1412,6 +1539,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
   const runtimeStore = useChatRuntimeStore<Conversation, Message>();
   const runtimeInstanceId = useId();
   const visibleChatOwner = useRef<object>({}).current;
+  const responseReconciliationsInFlightRef = useRef(new Set<string>());
 
   const [initialRuntimeSelection] = useState(() => {
     const params = new URLSearchParams(window.location.search);
@@ -1515,18 +1643,17 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
     [runtimeStore]
   );
 
-  const updateIdleAttachmentComposerForKey = useCallback(
+  const updateAttachmentComposerForKey = useCallback(
     (key: ChatRuntimeKey, updater: (composer: ChatComposerState) => ChatComposerState) => {
-      const startSnapshot = runtimeStore.get(key);
-      if (!startSnapshot || startSnapshot.isGenerating) return false;
-
-      const result = mutateAttachmentComposerWhenIdle(startSnapshot, updater);
-      if (!result.didMutate) return false;
-      runtimeStore.update(key, (snapshot) => ({
-        ...snapshot,
-        composer: result.composer
-      }));
-      return true;
+      if (!runtimeStore.get(key)) return false;
+      let didMutate = false;
+      runtimeStore.update(key, (snapshot) => {
+        if (snapshot.composer.queue.edit) return snapshot;
+        const composer = updater(snapshot.composer);
+        didMutate = composer !== snapshot.composer;
+        return didMutate ? { ...snapshot, composer } : snapshot;
+      });
+      return didMutate;
     },
     [runtimeStore]
   );
@@ -1538,6 +1665,22 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
   const input = activeRuntime.composer.input;
   const draftProjectId = activeRuntime.composer.draftProjectId;
   const isGenerating = activeRuntime.isGenerating;
+  const queuedMessages = activeRuntime.composer.queue.items;
+  const queueEdit = activeRuntime.composer.queue.edit;
+  const stoppingRuntimeRegistry = useMemo(
+    () => chatStoppingRuntimeRegistryFor(runtimeStore),
+    [runtimeStore]
+  );
+  useSyncExternalStore(
+    stoppingRuntimeRegistry.subscribe,
+    stoppingRuntimeRegistry.getSnapshot,
+    stoppingRuntimeRegistry.getSnapshot
+  );
+  const isStopping = Array.from(stoppingRuntimeRegistry.getEntries()).some(
+    ([key, runTokens]) =>
+      runTokens.size > 0 &&
+      runtimeStore.resolveKey(key) === runtimeStore.resolveKey(activeRuntime.key)
+  );
   const [isSidebarOpen, setIsSidebarOpen] = usePersistentSidebarState(isCompactLayout);
   const [isSidebarTransitioning, setIsSidebarTransitioning] = useState(false);
   const error = activeRuntime.error;
@@ -1561,6 +1704,21 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
     attachmentError,
     audioError
   } = activeRuntime.composer;
+  const editedQueuedMessage = queueEdit
+    ? queuedMessages.find((item) => item.queueId === queueEdit.queueId)
+    : undefined;
+  const canSubmitMessage = canSubmitChatComposer({
+    text: input,
+    hasAttachments: queueEdit
+      ? Boolean(editedQueuedMessage?.draftImages.length || editedQueuedMessage?.documentText)
+      : Boolean(draftImages.length || documentText),
+    hasQueuedMessages: queuedMessages.length > 0,
+    isEditingQueuedMessage: Boolean(queueEdit),
+    hasActiveRun: isGenerating,
+    isProcessingDocument,
+    isStopping
+  });
+  const showsStop = chatComposerShowsStop(isGenerating, isStopping);
 
   const setConversationForKey = useCallback(
     (key: ChatRuntimeKey, update: StateUpdate<Conversation | null>) => {
@@ -2424,44 +2582,214 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
     };
   }, [chatId, runtimeStore, selectConversationRuntime, selectFreshDraftRuntime, selectedProjectId]);
 
+  const settleLocallyCancelledRun = useCallback(
+    (runtimeKey: ChatRuntimeKey, runToken: number, optimisticMessageId: string | undefined) => {
+      const cancelled = runtimeStore.cancelRun(runtimeKey, runToken);
+      if (!cancelled) return false;
+      clearUnresolvedChatResponseMessage(runtimeStore, runToken);
+      runtimeStore.update(runtimeKey, (snapshot) => ({
+        ...snapshot,
+        error: snapshot.error === CHAT_STOP_WAITING_MESSAGE ? null : snapshot.error,
+        messages: cancelled.responseId
+          ? updateActiveItemStatuses(snapshot.messages as Message[], "incomplete")
+          : updateActiveItemStatuses(
+              markOptimisticMessageIncomplete(snapshot.messages as Message[], optimisticMessageId),
+              "incomplete"
+            )
+      }));
+      if (optimisticMessageId) {
+        unregisterChatOptimisticMessage(runtimeStore, runToken, optimisticMessageId);
+      }
+      return true;
+    },
+    [runtimeStore]
+  );
+
+  const cancelKnownChatResponse = useCallback(
+    async (
+      runtimeKey: ChatRuntimeKey,
+      runToken: number,
+      responseId: string,
+      optimisticMessageId: string | undefined
+    ): Promise<boolean> => {
+      if (!openai) return false;
+      try {
+        await (
+          openai.responses as {
+            cancel: (id: string, options?: { timeout?: number }) => Promise<unknown>;
+          }
+        ).cancel(responseId, { timeout: CHAT_STOP_REQUEST_TIMEOUT_MS });
+        return settleLocallyCancelledRun(runtimeKey, runToken, optimisticMessageId);
+      } catch (error) {
+        console.error("Failed to cancel response:", error);
+        if (!isChatResponseCancellationAlreadyTerminalError(error)) {
+          if (runtimeStore.isRunCurrent(runtimeKey, runToken)) {
+            setErrorForKey(runtimeKey, "Failed to cancel response. Please try Stop again.");
+          }
+          return false;
+        }
+        try {
+          const response = await openai.responses.retrieve(responseId, undefined, {
+            timeout: CHAT_STOP_REQUEST_TIMEOUT_MS
+          });
+          const status = (response as { status?: string }).status;
+          const runIsCurrent = runtimeStore.isRunCurrent(runtimeKey, runToken);
+
+          if (status === "completed") {
+            // Stop intent is sticky across this reconciliation. Settle now even
+            // if a buffered stream is healthy so the outer loop cannot promote
+            // a queued turn after this helper releases the Stop UI fence. The
+            // persisted user/item cursor remains valid for ascending polling.
+            if (runIsCurrent) {
+              runtimeStore.completeRunAndAbort(runtimeKey, runToken, (owned) => ({
+                ...owned,
+                messages: updateActiveItemStatuses(owned.messages as Message[], "completed"),
+                error: "The response finished before it could be stopped."
+              }));
+              clearUnresolvedChatResponseMessage(runtimeStore, runToken);
+              return true;
+            }
+            return false;
+          }
+
+          if (status === "failed" || status === "cancelled" || status === "incomplete") {
+            return settleLocallyCancelledRun(runtimeKey, runToken, optimisticMessageId);
+          }
+        } catch (reconciliationError) {
+          console.error(
+            "Failed to reconcile response after cancellation error:",
+            reconciliationError
+          );
+        }
+
+        if (runtimeStore.isRunCurrent(runtimeKey, runToken)) {
+          setErrorForKey(runtimeKey, "Failed to cancel response. Please try Stop again.");
+        }
+        return false;
+      } finally {
+        // Keep this fence through cancellation/retrieval so the send loop
+        // cannot promote a later FIFO item under the same outer run token.
+        stoppingRuntimeRegistry.delete(runtimeKey, runToken);
+        if (!runtimeStore.isRunCurrent(runtimeKey, runToken)) {
+          clearChatRunQueueHalt(runtimeStore, runToken);
+        }
+      }
+    },
+    [openai, runtimeStore, setErrorForKey, settleLocallyCancelledRun, stoppingRuntimeRegistry]
+  );
+
+  const reconcileDetachedChatResponse = useCallback(
+    async (runtimeKey: ChatRuntimeKey) => {
+      const snapshot = runtimeStore.get(runtimeKey);
+      if (
+        !openai ||
+        !snapshot?.isGenerating ||
+        snapshot.runToken === null ||
+        !snapshot.currentResponseId
+      ) {
+        return;
+      }
+
+      const runToken = snapshot.runToken;
+      const responseId = snapshot.currentResponseId;
+      const reconciliationKey = `${runtimeStore.resolveKey(runtimeKey)}:${runToken}:${responseId}`;
+      if (responseReconciliationsInFlightRef.current.has(reconciliationKey)) return;
+      responseReconciliationsInFlightRef.current.add(reconciliationKey);
+
+      try {
+        if (isChatRunQueueHaltRequested(runtimeStore, runToken)) {
+          await cancelKnownChatResponse(runtimeKey, runToken, responseId, undefined);
+          return;
+        }
+        const response = await openai.responses.retrieve(responseId, undefined, {
+          timeout: CHAT_STOP_REQUEST_TIMEOUT_MS
+        });
+        const current = runtimeStore.get(runtimeKey);
+        if (!current || current.runToken !== runToken || current.currentResponseId !== responseId) {
+          return;
+        }
+
+        const resolution = classifyChatResponseReconciliation(
+          (response as { status?: string | null }).status
+        );
+        if (resolution === "completed") {
+          runtimeStore.completeRunAndAbort(runtimeKey, runToken, (owned) => ({
+            ...owned,
+            messages: updateActiveItemStatuses(owned.messages as Message[], "completed"),
+            error:
+              "The response completed after the connection was restored. Queued messages were kept."
+          }));
+          clearUnresolvedChatResponseMessage(runtimeStore, runToken);
+          stoppingRuntimeRegistry.delete(runtimeKey, runToken);
+          clearChatRunQueueHalt(runtimeStore, runToken);
+        } else if (resolution === "terminal") {
+          if (settleLocallyCancelledRun(runtimeKey, runToken, undefined)) {
+            setErrorForKey(
+              runtimeKey,
+              "The interrupted response stopped. Queued messages were kept."
+            );
+            stoppingRuntimeRegistry.delete(runtimeKey, runToken);
+            clearChatRunQueueHalt(runtimeStore, runToken);
+          }
+        }
+      } catch (error) {
+        console.error("Failed to reconcile interrupted response:", error);
+      } finally {
+        responseReconciliationsInFlightRef.current.delete(reconciliationKey);
+      }
+    },
+    [
+      cancelKnownChatResponse,
+      openai,
+      runtimeStore,
+      setErrorForKey,
+      settleLocallyCancelledRun,
+      stoppingRuntimeRegistry
+    ]
+  );
+
   // Cancel the current response
   const handleCancelResponse = useCallback(async () => {
-    const runtimeKey = activeRuntimeKeyRef.current;
-    const runToken = runtimeStore.get(runtimeKey)?.runToken;
-    if (runToken === null || runToken === undefined) return;
+    const runtimeKey = runtimeStore.resolveKey(activeRuntimeKeyRef.current);
+    const runSnapshot = runtimeStore.get(runtimeKey);
+    if (!runSnapshot || runSnapshot.runToken === null) return;
+    const runToken = runSnapshot.runToken;
+    stoppingRuntimeRegistry.add(runtimeKey, runToken);
+    requestChatRunQueueHalt(runtimeStore, runToken);
     const optimisticMessageId = getRegisteredChatOptimisticMessage(runtimeStore, runToken);
+    const restoredBeforeRequest = restoreRegisteredChatTurnBeforeRequest(
+      runtimeStore,
+      runToken,
+      "Stopped before sending. Your message was restored."
+    );
     // Commit the final partial frame while this run still owns its token. Once
     // cancelRun clears ownership, any delayed callback must fail closed.
     flushRegisteredChatStreamDeltas(runtimeStore, runToken);
-    const cancelled = runtimeStore.cancelRun(runtimeKey, runToken);
-    if (!cancelled) return;
-
-    runtimeStore.update(runtimeKey, (snapshot) => ({
-      ...snapshot,
-      messages: cancelled.responseId
-        ? updateActiveItemStatuses(snapshot.messages as Message[], "incomplete")
-        : updateActiveItemStatuses(
-            markOptimisticMessageIncomplete(snapshot.messages as Message[], optimisticMessageId),
-            "incomplete"
-          )
-    }));
-    if (optimisticMessageId) {
-      unregisterChatOptimisticMessage(runtimeStore, runToken, optimisticMessageId);
+
+    if (restoredBeforeRequest) {
+      settleLocallyCancelledRun(runtimeKey, runToken, optimisticMessageId);
+      stoppingRuntimeRegistry.delete(runtimeKey, runToken);
+      return;
     }
 
-    try {
-      if (cancelled.responseId && openai) {
-        await (openai.responses as { cancel: (id: string) => Promise<unknown> }).cancel(
-          cancelled.responseId
-        );
-      }
-    } catch (error) {
-      console.error("Failed to cancel response:", error);
-      if (runtimeStore.get(runtimeKey)) {
-        setErrorForKey(runtimeKey, "Failed to cancel response. Please try again.");
-      }
+    const currentResponseId = runtimeStore.get(runtimeKey)?.currentResponseId;
+    if (currentResponseId) {
+      await cancelKnownChatResponse(runtimeKey, runToken, currentResponseId, optimisticMessageId);
+      return;
     }
-  }, [openai, runtimeStore, setErrorForKey]);
+
+    // The POST may already be accepted even though response.created has not
+    // arrived. Preserve the run and Stop fence; the stream handler will cancel
+    // immediately when it learns the server response ID. Local cancellation
+    // here would orphan server work and allow the FIFO to overlap it.
+    setErrorForKey(runtimeKey, CHAT_STOP_WAITING_MESSAGE);
+  }, [
+    cancelKnownChatResponse,
+    runtimeStore,
+    setErrorForKey,
+    settleLocallyCancelledRun,
+    stoppingRuntimeRegistry
+  ]);
 
   // Load conversation from API
   const loadConversation = useCallback(
@@ -2513,6 +2841,32 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
         const newestCompletedItem = itemsResponse.data.find(
           (item) => (item as Message).status !== "in_progress"
         );
+        const snapshotBeforeItems = runtimeStore.get(runtimeKey);
+        if (
+          snapshotBeforeItems?.isGenerating &&
+          !snapshotBeforeItems.currentResponseId &&
+          snapshotBeforeItems.runToken !== null
+        ) {
+          const unresolvedMessageId = getUnresolvedChatResponseMessage(
+            runtimeStore,
+            snapshotBeforeItems.runToken
+          );
+          const recoveredResponseId = unresolvedMessageId
+            ? responseIdForChatMessage(unresolvedMessageId, itemsResponse.data)
+            : undefined;
+          if (recoveredResponseId) {
+            runtimeStore.setCurrentResponseId(
+              runtimeKey,
+              snapshotBeforeItems.runToken,
+              recoveredResponseId
+            );
+            clearUnresolvedChatResponseMessage(
+              runtimeStore,
+              snapshotBeforeItems.runToken,
+              unresolvedMessageId
+            );
+          }
+        }
         runtimeStore.update(runtimeKey, (snapshot) => ({
           ...snapshot,
           messages: mergeLoadedMessagesWithRuntime(messagesInChronologicalOrder, snapshot.messages),
@@ -2719,20 +3073,88 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
       const conversationId =
         snapshot?.conversation?.id ??
         conversationIdFromChatRuntimeKey(runtimeStore.resolveKey(runtimeKey));
-      if (!snapshot || !conversationId || !openai || snapshot.assistantStreaming) return;
+      if (
+        !snapshot ||
+        !conversationId ||
+        !openai ||
+        (snapshot.assistantStreaming && snapshot.currentResponseId)
+      ) {
+        return;
+      }
 
       try {
+        if (!snapshot.currentResponseId && snapshot.runToken !== null) {
+          const unresolvedMessageId = getUnresolvedChatResponseMessage(
+            runtimeStore,
+            snapshot.runToken
+          );
+          // Retrieve the exact persisted user item. A list page can contain ten
+          // image-description call/output pairs before the user item and is not
+          // a reliable response-ownership lookup.
+          if (unresolvedMessageId) {
+            try {
+              const linkedItem = await openai.conversations.items.retrieve(unresolvedMessageId, {
+                conversation_id: conversationId
+              });
+              const recoveredResponseId = responseIdForChatMessage(unresolvedMessageId, [
+                linkedItem
+              ]);
+              if (
+                recoveredResponseId &&
+                runtimeStore.setCurrentResponseId(
+                  runtimeKey,
+                  snapshot.runToken,
+                  recoveredResponseId
+                )
+              ) {
+                clearUnresolvedChatResponseMessage(
+                  runtimeStore,
+                  snapshot.runToken,
+                  unresolvedMessageId
+                );
+              }
+            } catch (error) {
+              const status = (error as { status?: unknown })?.status;
+              if (status !== 404) console.error("Response ownership polling error:", error);
+            }
+          }
+        }
+
         // Fetch NEW items that came after the last seen ID
         // Use order=asc to get items chronologically after the lastSeenItemId
+        const hasCursor = Boolean(snapshot.lastSeenItemId);
         const response = await openai.conversations.items.list(conversationId, {
-          ...(snapshot.lastSeenItemId ? { after: snapshot.lastSeenItemId, order: "asc" } : {}),
+          ...(snapshot.lastSeenItemId ? { after: snapshot.lastSeenItemId } : {}),
+          order: hasCursor ? "asc" : "desc",
           limit: 20 // Smaller limit since we only expect a few new messages
         });
+        const pollingPage = normalizeChatPollingPage(response.data, hasCursor);
+
+        if (!snapshot.currentResponseId && snapshot.runToken !== null) {
+          const unresolvedMessageId = getUnresolvedChatResponseMessage(
+            runtimeStore,
+            snapshot.runToken
+          );
+          const recoveredResponseId = unresolvedMessageId
+            ? responseIdForChatMessage(unresolvedMessageId, response.data)
+            : undefined;
+          if (recoveredResponseId) {
+            if (
+              runtimeStore.setCurrentResponseId(runtimeKey, snapshot.runToken, recoveredResponseId)
+            ) {
+              clearUnresolvedChatResponseMessage(
+                runtimeStore,
+                snapshot.runToken,
+                unresolvedMessageId
+              );
+            }
+          }
+        }
 
         if (response.data.length > 0) {
           // Convert API items to UI messages, grouping tool calls with their messages
           const newMessages = convertItemsToMessages(
-            response.data as Array<{
+            pollingPage.chronologicalItems as Array<{
               id: string;
               type: string;
               role?: string;
@@ -2767,10 +3189,8 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
             // Update last seen item ID for next poll
             // Since we're using order=asc, the LAST item is the newest
             // Skip in_progress messages by finding the last completed one
-            const newestCompletedItem = [...response.data]
-              .reverse()
-              .find((item) => (item as Message).status !== "in_progress");
-            if (newestCompletedItem) {
+            const newestCompletedItem = pollingPage.newestCompletedItem;
+            if (newestCompletedItem?.id) {
               setLastSeenItemIdForKey(runtimeKey, newestCompletedItem.id);
             }
           }
@@ -2779,8 +3199,28 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
         console.error("Polling error:", error);
         // Don't throw - polling should fail silently
       }
+      if (!runtimeStore.get(runtimeKey)?.conversation) {
+        try {
+          const conversation = (await openai.conversations.retrieve(
+            conversationId
+          )) as Conversation;
+          if (runtimeStore.get(runtimeKey)) {
+            runtimeStore.update(runtimeKey, (current) => ({ ...current, conversation }));
+            runtimeStore.updateActivityGroup(runtimeKey, conversation.project_id ?? null);
+          }
+        } catch (error) {
+          console.error("Conversation metadata polling error:", error);
+        }
+      }
+      await reconcileDetachedChatResponse(runtimeKey);
     },
-    [isRuntimeSelected, openai, runtimeStore, setLastSeenItemIdForKey]
+    [
+      isRuntimeSelected,
+      openai,
+      reconcileDetachedChatResponse,
+      runtimeStore,
+      setLastSeenItemIdForKey
+    ]
   );
 
   // Load conversation when URL changes or on mount. Cached runtimes—including
@@ -2795,8 +3235,11 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
   }, [activeRuntimeKey, chatId, openai, loadConversation, runtimeStore]);
 
   // Set up progressive polling interval
+  const pollingConversationId =
+    conversation?.id ?? conversationIdFromChatRuntimeKey(runtimeStore.resolveKey(activeRuntimeKey));
+
   useEffect(() => {
-    if (!conversation?.id || !openai) return;
+    if (!pollingConversationId || !openai) return;
     const runtimeKey = activeRuntimeKey;
 
     // Progressive intervals: 2s, 5s, 10s, 15s, 20s, 30s, 60s (then 60s forever)
@@ -2827,7 +3270,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
     return () => {
       if (timeoutId) clearTimeout(timeoutId);
     };
-  }, [activeRuntimeKey, conversation?.id, openai, pollForNewItems]);
+  }, [activeRuntimeKey, openai, pollForNewItems, pollingConversationId]);
 
   // Poll for title updates when it's "New Conversation" with exponential backoff
   useEffect(() => {
@@ -3400,7 +3843,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
       const selectedFiles = Array.from(e.currentTarget.files ?? []);
       e.currentTarget.value = "";
       const ownerSnapshot = runtimeStore.get(ownerKey);
-      if (selectedFiles.length === 0 || !ownerSnapshot || ownerSnapshot.isGenerating) return;
+      if (selectedFiles.length === 0 || !ownerSnapshot || ownerSnapshot.composer.queue.edit) return;
 
       const supportedTypes = ["image/jpeg", "image/jpg", "image/png", "image/webp"];
       const maxSizeInBytes = 20 * 1024 * 1024;
@@ -3417,26 +3860,50 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
         }
         return true;
       });
-      if (validationError) {
+      if (validFiles.length === 0) {
+        if (validationError) {
+          setComposerErrorForKey(ownerKey, "attachmentError", validationError);
+        }
+        return;
+      }
+      const accountUsage = chatAccountQueueUsage(runtimeStore);
+      const selection = selectChatImageFilesForRetention({
+        composer: ownerSnapshot.composer,
+        candidates: validFiles,
+        accountUsage
+      });
+      if (selection.accountLimitExceeded) {
+        setComposerErrorForKey(ownerKey, "attachmentError", CHAT_ACCOUNT_IMAGE_LIMIT_MESSAGE);
+      } else if (selection.messageLimitExceeded) {
+        setComposerErrorForKey(ownerKey, "attachmentError", CHAT_MESSAGE_IMAGE_LIMIT_MESSAGE);
+      } else if (validationError) {
         setComposerErrorForKey(ownerKey, "attachmentError", validationError);
       }
-      if (validFiles.length === 0) return;
+      if (selection.files.length === 0) return;
+      const additionalBytes = selection.files.reduce((total, file) => total + file.size, 0);
+      if (
+        accountUsage.attachmentBytes + additionalBytes >
+        MAX_CHAT_ACCOUNT_RETAINED_ATTACHMENT_BYTES
+      ) {
+        setComposerErrorForKey(ownerKey, "attachmentError", CHAT_ACCOUNT_ATTACHMENT_LIMIT_MESSAGE);
+        return;
+      }
 
-      const newUrls = validFiles.map((file) => [file, URL.createObjectURL(file)] as const);
-      const attached = updateIdleAttachmentComposerForKey(ownerKey, (composer) => ({
+      const newUrls = selection.files.map((file) => [file, URL.createObjectURL(file)] as const);
+      const attached = updateAttachmentComposerForKey(ownerKey, (composer) => ({
         ...composer,
         imageUrls: new Map([...composer.imageUrls, ...newUrls]),
-        draftImages: [...composer.draftImages, ...validFiles]
+        draftImages: [...composer.draftImages, ...selection.files]
       }));
       if (!attached) for (const [, url] of newUrls) URL.revokeObjectURL(url);
     },
-    [runtimeStore, setComposerErrorForKey, updateIdleAttachmentComposerForKey]
+    [runtimeStore, setComposerErrorForKey, updateAttachmentComposerForKey]
   );
 
   const attachPastedImages = useCallback(
     (imageFiles: File[], ownerKey: ChatRuntimeKey, expectedGeneration: number) => {
       const ownerSnapshot = runtimeStore.get(ownerKey);
-      if (!ownerSnapshot || ownerSnapshot.isGenerating) return;
+      if (!ownerSnapshot || ownerSnapshot.composer.queue.edit) return;
 
       if (!canUseImages) {
         if (isRuntimeSelected(ownerKey)) {
@@ -3461,21 +3928,44 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
         }
         return true;
       });
-      if (validationError) {
+      if (validFiles.length === 0) {
+        if (validationError) {
+          setComposerErrorForKey(ownerKey, "attachmentError", validationError);
+        }
+        return;
+      }
+      const accountUsage = chatAccountQueueUsage(runtimeStore);
+      const selection = selectChatImageFilesForRetention({
+        composer: ownerSnapshot.composer,
+        candidates: validFiles,
+        accountUsage
+      });
+      if (selection.accountLimitExceeded) {
+        setComposerErrorForKey(ownerKey, "attachmentError", CHAT_ACCOUNT_IMAGE_LIMIT_MESSAGE);
+      } else if (selection.messageLimitExceeded) {
+        setComposerErrorForKey(ownerKey, "attachmentError", CHAT_MESSAGE_IMAGE_LIMIT_MESSAGE);
+      } else if (validationError) {
         setComposerErrorForKey(ownerKey, "attachmentError", validationError);
       }
+      if (selection.files.length === 0) return;
+      const additionalBytes = selection.files.reduce((total, file) => total + file.size, 0);
+      if (
+        accountUsage.attachmentBytes + additionalBytes >
+        MAX_CHAT_ACCOUNT_RETAINED_ATTACHMENT_BYTES
+      ) {
+        setComposerErrorForKey(ownerKey, "attachmentError", CHAT_ACCOUNT_ATTACHMENT_LIMIT_MESSAGE);
+        return;
+      }
 
-      if (validFiles.length === 0) return;
-
-      const newUrls = validFiles.map((file) => [file, URL.createObjectURL(file)] as const);
+      const newUrls = selection.files.map((file) => [file, URL.createObjectURL(file)] as const);
       let generationMatched = false;
-      const attached = updateIdleAttachmentComposerForKey(ownerKey, (composer) => {
+      const attached = updateAttachmentComposerForKey(ownerKey, (composer) => {
         if (composer.imagePasteGeneration !== expectedGeneration) return composer;
         generationMatched = true;
         return {
           ...composer,
           imageUrls: new Map([...composer.imageUrls, ...newUrls]),
-          draftImages: [...composer.draftImages, ...validFiles]
+          draftImages: [...composer.draftImages, ...selection.files]
         };
       });
       if (!attached || !generationMatched) {
@@ -3487,7 +3977,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
       isRuntimeSelected,
       runtimeStore,
       setComposerErrorForKey,
-      updateIdleAttachmentComposerForKey
+      updateAttachmentComposerForKey
     ]
   );
 
@@ -3495,7 +3985,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
     (e: React.ClipboardEvent) => {
       const ownerKey = activeRuntimeKeyRef.current;
       const startSnapshot = runtimeStore.get(ownerKey);
-      if (!startSnapshot || startSnapshot.isGenerating) return;
+      if (!startSnapshot || startSnapshot.composer.queue.edit) return;
       const pasteGeneration = startSnapshot.composer.imagePasteGeneration + 1;
       updateComposerForKey(ownerKey, (composer) => ({
         ...composer,
@@ -3550,11 +4040,11 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
     (idx: number) => {
       const ownerKey = activeRuntimeKeyRef.current;
       const snapshot = runtimeStore.get(ownerKey);
-      if (!snapshot || snapshot.isGenerating) return;
+      if (!snapshot || snapshot.composer.queue.edit) return;
       const fileToRemove = snapshot?.composer.draftImages[idx];
       if (!fileToRemove) return;
       const url = snapshot.composer.imageUrls.get(fileToRemove);
-      const removed = updateIdleAttachmentComposerForKey(ownerKey, (composer) => {
+      const removed = updateAttachmentComposerForKey(ownerKey, (composer) => {
         const nextUrls = new Map(composer.imageUrls);
         nextUrls.delete(fileToRemove);
         return {
@@ -3565,7 +4055,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
       });
       if (removed && url) URL.revokeObjectURL(url);
     },
-    [runtimeStore, updateIdleAttachmentComposerForKey]
+    [runtimeStore, updateAttachmentComposerForKey]
   );
 
   const handleDocumentUpload = useCallback(
@@ -3577,7 +4067,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
       if (!file) return;
 
       const startSnapshot = runtimeStore.get(ownerKey);
-      if (!startSnapshot || startSnapshot.isGenerating) {
+      if (!startSnapshot || startSnapshot.composer.queue.edit) {
         inputElement.value = "";
         return;
       }
@@ -3590,7 +4080,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
       }
 
       const uploadGeneration = startSnapshot.composer.documentUploadGeneration + 1;
-      const started = updateIdleAttachmentComposerForKey(ownerKey, (composer) => ({
+      const started = updateAttachmentComposerForKey(ownerKey, (composer) => ({
         ...composer,
         isProcessingDocument: true,
         attachmentError: null,
@@ -3605,13 +4095,28 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
         updater: (composer: ChatComposerState) => ChatComposerState
       ) => {
         let generationMatched = false;
-        const updated = updateIdleAttachmentComposerForKey(ownerKey, (composer) => {
+        const updated = updateAttachmentComposerForKey(ownerKey, (composer) => {
           if (composer.documentUploadGeneration !== uploadGeneration) return composer;
           generationMatched = true;
           return updater(composer);
         });
         return updated && generationMatched;
       };
+      const retainDocumentIfWithinAccountBudget = (documentText: string, documentName: string) =>
+        updateDocumentIfCurrent((composer) => {
+          const accountUsage = chatAccountQueueUsage(runtimeStore);
+          const nextAttachmentBytes =
+            accountUsage.attachmentBytes -
+            chatQueuedTextByteLength(composer.documentText) +
+            chatQueuedTextByteLength(documentText);
+          if (nextAttachmentBytes > MAX_CHAT_ACCOUNT_RETAINED_ATTACHMENT_BYTES) {
+            return {
+              ...composer,
+              attachmentError: CHAT_ACCOUNT_ATTACHMENT_LIMIT_MESSAGE
+            };
+          }
+          return { ...composer, documentText, documentName };
+        });
 
       try {
         const documentType = getSupportedDocumentType(file.name);
@@ -3624,11 +4129,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
               text_content: text
             }
           };
-          updateDocumentIfCurrent((composer) => ({
-            ...composer,
-            documentText: JSON.stringify(documentData),
-            documentName: file.name
-          }));
+          retainDocumentIfWithinAccountBudget(JSON.stringify(documentData), file.name);
         } else if (documentType && isNativeDocumentType(documentType) && isTauriEnv) {
           const result = await extractDocumentContent(file, documentType);
           if (runtimeStore.get(ownerKey)?.composer.documentUploadGeneration !== uploadGeneration)
@@ -3656,11 +4157,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
             }
           };
 
-          updateDocumentIfCurrent((composer) => ({
-            ...composer,
-            documentText: JSON.stringify(cleanedParsed),
-            documentName: file.name
-          }));
+          retainDocumentIfWithinAccountBudget(JSON.stringify(cleanedParsed), file.name);
         } else if (documentType && isNativeDocumentType(documentType)) {
           setComposerErrorForKey(
             ownerKey,
@@ -3684,26 +4181,36 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
           );
         }
       } finally {
-        updateDocumentIfCurrent((composer) => ({
-          ...composer,
-          isProcessingDocument: false
-        }));
+        // An edit may begin while native document extraction is in flight.
+        // Attachment mutation stays blocked during the edit, but the owned
+        // processing flag must always settle so the composer cannot deadlock.
+        updateComposerForKey(ownerKey, (composer) =>
+          composer.documentUploadGeneration === uploadGeneration
+            ? { ...composer, isProcessingDocument: false }
+            : composer
+        );
         inputElement.value = "";
       }
     },
-    [isTauriEnv, runtimeStore, setComposerErrorForKey, updateIdleAttachmentComposerForKey]
+    [
+      isTauriEnv,
+      runtimeStore,
+      setComposerErrorForKey,
+      updateAttachmentComposerForKey,
+      updateComposerForKey
+    ]
   );
 
   const removeDocument = useCallback(() => {
     const ownerKey = activeRuntimeKeyRef.current;
-    updateIdleAttachmentComposerForKey(ownerKey, (composer) => ({
+    updateAttachmentComposerForKey(ownerKey, (composer) => ({
       ...composer,
       isProcessingDocument: false,
       documentText: "",
       documentName: "",
       documentUploadGeneration: composer.documentUploadGeneration + 1
     }));
-  }, [updateIdleAttachmentComposerForKey]);
+  }, [updateAttachmentComposerForKey]);
 
   // Audio recording functions
   const startRecording = async () => {
@@ -3972,14 +4479,102 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
     }
   };
 
-  // Helper function to process streaming response - used by both initial request and retry
+  const discardQueueEdit = useCallback(() => {
+    const runtimeKey = runtimeStore.resolveKey(activeRuntimeKeyRef.current);
+    if (!runtimeStore.get(runtimeKey)) return;
+    runtimeStore.update(runtimeKey, (snapshot) => {
+      const discarded = discardChatQueuedMessageEdit(snapshot.composer.queue);
+      if (discarded.status !== "ended") return snapshot;
+      return {
+        ...snapshot,
+        composer: {
+          ...snapshot.composer,
+          input: discarded.restoreInput,
+          queue: discarded.queue
+        }
+      };
+    });
+  }, [runtimeStore]);
+
+  const cancelQueuedMessage = useCallback(
+    (queueId: string) => {
+      const runtimeKey = runtimeStore.resolveKey(activeRuntimeKeyRef.current);
+      let removedItem: ChatQueuedMessage | null = null;
+      let retainedObjectUrls = new Set<string>();
+      if (!runtimeStore.get(runtimeKey)) return;
+      runtimeStore.update(runtimeKey, (snapshot) => {
+        const cancelled = cancelChatQueuedMessage(snapshot.composer.queue, queueId);
+        if (cancelled.status !== "cancelled") return snapshot;
+        removedItem = cancelled.item;
+        const composer = {
+          ...snapshot.composer,
+          input: cancelled.restoreInput ?? snapshot.composer.input,
+          queue: cancelled.queue
+        };
+        retainedObjectUrls = new Set([
+          ...chatComposerObjectUrls(composer),
+          ...chatTranscriptObjectUrls(snapshot.messages as Message[])
+        ]);
+        return {
+          ...snapshot,
+          composer
+        };
+      });
+      if (removedItem) {
+        revokeQueuedChatMessageObjectUrls(removedItem, retainedObjectUrls);
+      }
+    },
+    [runtimeStore]
+  );
+
+  const editQueuedMessage = useCallback(
+    (queueId: string) => {
+      const runtimeKey = runtimeStore.resolveKey(activeRuntimeKeyRef.current);
+      let shouldFocus = false;
+      if (!runtimeStore.get(runtimeKey)) return;
+      runtimeStore.update(runtimeKey, (snapshot) => {
+        const started = beginChatQueuedMessageEdit(
+          snapshot.composer.queue,
+          runtimeKey,
+          queueId,
+          snapshot.composer.input
+        );
+        if (started.status === "already_editing") {
+          const discarded = discardChatQueuedMessageEdit(snapshot.composer.queue);
+          if (discarded.status !== "ended") return snapshot;
+          return {
+            ...snapshot,
+            composer: {
+              ...snapshot.composer,
+              input: discarded.restoreInput,
+              queue: discarded.queue
+            }
+          };
+        }
+        if (started.status !== "started") return snapshot;
+        shouldFocus = true;
+        return {
+          ...snapshot,
+          composer: {
+            ...snapshot.composer,
+            input: started.input,
+            queue: started.queue
+          }
+        };
+      });
+      if (shouldFocus) requestAnimationFrame(() => textareaRef.current?.focus());
+    },
+    [runtimeStore]
+  );
+
+  // Helper function to process one streaming response.
   const processStreamingResponse = useCallback(
     async (
       stream: AsyncIterable<unknown>,
       runtimeKey: ChatRuntimeKey,
       runToken: number,
       optimisticMessageId: string,
-      discardOwnedItemsOnError: boolean
+      onResponseCreated: (responseId: string) => Promise<boolean>
     ): Promise<ChatStreamTerminalState> => {
       const messageTextBuffers = new Map<string, Map<number, string>>();
       const reasoningTextBuffers = new Map<string, Map<number, string>>();
@@ -4109,12 +4704,15 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
           if (eventType === "response.created") {
             unregisterChatOptimisticMessage(runtimeStore, runToken, optimisticMessageId);
             const eventWithResponse = event as { response?: { id?: string } };
-            if (eventWithResponse.response?.id) {
-              runtimeStore.setCurrentResponseId(
-                runtimeKey,
-                runToken,
-                eventWithResponse.response.id
-              );
+            const responseId = eventWithResponse.response?.id;
+            if (responseId) {
+              if (runtimeStore.setCurrentResponseId(runtimeKey, runToken, responseId)) {
+                clearUnresolvedChatResponseMessage(runtimeStore, runToken, optimisticMessageId);
+              }
+              if (await onResponseCreated(responseId)) {
+                terminalState = "cancelled";
+                break;
+              }
             }
           } else if (eventType === "response.output_item.added") {
             const addedEvent = event as ResponseOutputItemAddedEvent;
@@ -4290,6 +4888,9 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
             }
           } else if (eventType === "response.completed") {
             terminalState = "completed";
+            // This is the authoritative terminal frame. Do not let a later
+            // transport-close error turn a durable completion into a retry.
+            break;
           } else if (isTerminalChatStreamErrorEvent(eventType)) {
             terminalState = "error";
             console.error("Streaming error:", event);
@@ -4323,11 +4924,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
         // and account teardown clear run ownership before aborting, so their
         // resulting iterator errors remain stale-fenced here.
         deltaCoalescer.finish();
-        updateRunMessages((messages) =>
-          discardOwnedItemsOnError
-            ? removeOwnedChatStreamAttemptItems(messages, ownedItemIds)
-            : updateActiveItemStatuses(messages, "error", ownedItemIds)
-        );
+        updateRunMessages((messages) => updateActiveItemStatuses(messages, "error", ownedItemIds));
         throw error;
       } finally {
         // Natural EOF and thrown stream errors both commit the final partial
@@ -4342,134 +4939,158 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
     [logStreamEvent, runtimeStore]
   );
 
-  // Every send captures its owning runtime key. Navigation only changes the
-  // projected runtime; it never changes where this request or its SSE events land.
+  // Every submit synchronously detaches its owning composer. During an active
+  // run that creates a staged chip; otherwise one outer run drains the FIFO as
+  // separate Responses turns without an idle run-token or AbortController gap.
   const handleSendMessage = useCallback(
     async (e?: React.FormEvent, overrideInput?: string, ownerRuntimeKey?: ChatRuntimeKey) => {
       e?.preventDefault();
       let runtimeKey = runtimeStore.resolveKey(ownerRuntimeKey ?? activeRuntimeKeyRef.current);
       const startSnapshot = runtimeStore.get(runtimeKey);
-      if (!startSnapshot || !openai) return;
-
-      const originalComposer = startSnapshot.composer;
-      const textToSend = overrideInput ?? originalComposer.input;
-      const trimmedInput = textToSend.trim();
-      const originalImages = [...originalComposer.draftImages];
-      const originalDocumentText = originalComposer.documentText;
-      const originalDocumentName = originalComposer.documentName;
-      const hasContent =
-        trimmedInput.length > 0 || originalImages.length > 0 || originalDocumentText.length > 0;
-      if (!hasContent || startSnapshot.isGenerating || originalComposer.isProcessingDocument) {
+      if (!startSnapshot) return;
+      const retainOverrideInput = () => {
+        if (overrideInput === undefined) return;
+        runtimeStore.update(runtimeKey, (snapshot) => ({
+          ...snapshot,
+          composer: chatComposerWithInputOverride(snapshot.composer, overrideInput)
+        }));
+      };
+      if (!openai || isChatRuntimeDeletionPending(runtimeStore, runtimeKey)) {
+        retainOverrideInput();
+        return;
+      }
+      const isRuntimeStopping = (runToken?: number) =>
+        Array.from(stoppingRuntimeRegistry.getEntries()).some(
+          ([key, runTokens]) =>
+            (runToken === undefined || runTokens.has(runToken)) &&
+            runtimeStore.resolveKey(key) === runtimeKey
+        );
+      if (isRuntimeStopping()) {
+        retainOverrideInput();
+        return;
+      }
+
+      const metadata: ChatQueuedMessageMetadata = {
+        queueId: uuidv4(),
+        messageId: uuidv4(),
+        model: model || DEFAULT_MODEL_ID,
+        webSearchEnabled: isWebSearchEnabled,
+        createdMs: Date.now()
+      };
+      const composerAtSubmit = chatComposerWithInputOverride(startSnapshot.composer, overrideInput);
+      const preflight = planChatComposerSubmission({
+        composer: composerAtSubmit,
+        hasActiveRun: startSnapshot.isGenerating,
+        metadata,
+        accountUsage: chatAccountQueueUsage(runtimeStore)
+      });
+      const submissionError = (status: typeof preflight.status): string | null => {
+        if (status === "queue_full") return "You can queue up to 16 messages.";
+        if (status === "text_too_large") return "Queued messages must be 32 KiB or smaller.";
+        if (status === "too_many_images") {
+          return "You can attach up to 10 images to a queued message.";
+        }
+        if (status === "image_too_large") {
+          return "Each queued image must be 20 MiB or smaller.";
+        }
+        if (status === "document_too_large") {
+          return "Queued documents must be 10 MiB or smaller.";
+        }
+        if (status === "queue_payload_too_large") {
+          return "Queued attachments can use up to 256 MiB in total.";
+        }
+        if (status === "account_queue_full") {
+          return "You can retain up to 64 queued chat messages across your account.";
+        }
+        if (status === "account_payload_too_large") {
+          return "Chat drafts and queued attachments can use up to 256 MiB across your account.";
+        }
+        if (status === "processing") return "Wait for the document to finish processing.";
+        if (status === "missing_edit") return "That queued message is no longer available.";
+        return null;
+      };
+
+      if (startSnapshot.isGenerating) {
+        runtimeStore.update(runtimeKey, (snapshot) => {
+          const composer = chatComposerWithInputOverride(snapshot.composer, overrideInput);
+          const plan = planChatComposerSubmission({
+            composer,
+            hasActiveRun: true,
+            metadata,
+            accountUsage: chatAccountQueueUsage(runtimeStore)
+          });
+          if (plan.status === "queued" || plan.status === "updated") {
+            return { ...snapshot, composer: plan.composer, error: null };
+          }
+          return { ...snapshot, error: submissionError(plan.status) ?? snapshot.error };
+        });
+        return;
+      }
+
+      if (preflight.status !== "start") {
+        const message = submissionError(preflight.status);
+        if (message) setErrorForKey(runtimeKey, message);
         return;
       }
 
-      const requestModel = model || DEFAULT_MODEL_ID;
-      const requestWebSearchEnabled = isWebSearchEnabled;
-      const billingStatusAtSend = billingStatus;
-      const existingConversationId =
-        startSnapshot.conversation?.id ?? conversationIdFromChatRuntimeKey(runtimeKey);
-      const isFollowUpConversation =
-        Boolean(existingConversationId) && startSnapshot.messages.length > 1;
       const run = runtimeStore.beginRun(runtimeKey, {
         groupId:
           startSnapshot.conversation?.project_id ??
-          originalComposer.draftProjectId ??
+          preflight.item.draftProjectId ??
           selectedProjectId ??
           null
       });
-      const localMessageId = uuidv4();
-      let conversationId = existingConversationId;
-      let composerRestored = false;
-      let adoptedExistingDestination = false;
-      let completedSuccessfully = false;
-
-      const restoreOriginComposer = (message: string) => {
-        if (composerRestored) return true;
-
-        let createdUrls: string[] = [];
-        let displacedUrls: string[] = [];
-        const restored = runtimeStore.updateForRun(runtimeKey, run.token, (snapshot) => {
-          const adoptedDestinationRecovery = recoverFailedSendAfterDestinationAdoption(
-            adoptedExistingDestination,
-            snapshot.messages as Message[],
-            snapshot.composer,
-            localMessageId
-          );
-          if (adoptedDestinationRecovery) {
-            return {
-              ...snapshot,
-              messages: adoptedDestinationRecovery.messages,
-              composer: adoptedDestinationRecovery.composer,
-              error: message
-            };
-          }
-
-          const restoredUrlPlan = planRestoredImageUrls(
-            originalImages,
-            snapshot.composer.imageUrls,
-            (file) => URL.createObjectURL(file)
-          );
-          createdUrls = restoredUrlPlan.createdUrls;
-          displacedUrls = restoredUrlPlan.displacedUrls;
-
-          return {
-            ...snapshot,
-            messages: (snapshot.messages as Message[]).filter((item) => item.id !== localMessageId),
-            error: message,
-            composer: {
-              ...snapshot.composer,
-              input: textToSend,
-              draftImages: originalImages,
-              imageUrls: restoredUrlPlan.imageUrls,
-              documentText: originalDocumentText,
-              documentName: originalDocumentName,
-              isProcessingDocument: false,
-              attachmentError: null,
-              imagePasteGeneration: snapshot.composer.imagePasteGeneration + 1,
-              documentUploadGeneration: snapshot.composer.documentUploadGeneration + 1
-            }
-          };
-        });
-
-        if (!restored) {
-          for (const url of createdUrls) URL.revokeObjectURL(url);
-          return false;
-        }
-        for (const url of displacedUrls) URL.revokeObjectURL(url);
-        composerRestored = true;
-        return true;
+      type ChatQueueTurn = {
+        item: ChatQueuedMessage;
+        recoverOnFailure: boolean;
+        previousLastSeenItemId: string | undefined;
       };
+      let currentTurn: ChatQueueTurn | undefined;
+      const started = runtimeStore.updateForRun(runtimeKey, run.token, (snapshot) => {
+        const composer = chatComposerWithInputOverride(snapshot.composer, overrideInput);
+        const plan = planChatComposerSubmission({
+          composer,
+          hasActiveRun: false,
+          metadata,
+          accountUsage: chatAccountQueueUsage(runtimeStore)
+        });
+        if (plan.status !== "start") return snapshot;
+        currentTurn = {
+          item: plan.item,
+          recoverOnFailure: plan.recoverOnFailure,
+          previousLastSeenItemId: snapshot.lastSeenItemId
+        };
+        return {
+          ...snapshot,
+          composer: plan.composer,
+          messages: mergeMessagesById(snapshot.messages as Message[], [
+            promotedChatUserMessage(plan.item)
+          ]),
+          lastSeenItemId: plan.item.messageId,
+          error: null
+        };
+      });
+      if (!started || !currentTurn) {
+        runtimeStore.finishRun(runtimeKey, run.token);
+        return;
+      }
+      registerChatOptimisticMessage(runtimeStore, run.token, currentTurn.item.messageId);
+      if (
+        !isCompactLayout &&
+        startSnapshot.messages.length === 0 &&
+        isRuntimeSelected(runtimeKey)
+      ) {
+        // The first optimistic row swaps the centered composer for the bottom
+        // composer. Restore focus once after that remount so follow-ups can be
+        // queued immediately without focusing on every streamed item.
+        requestAnimationFrame(() => textareaRef.current?.focus());
+      }
 
-      const createResponseStream = async (
-        targetConversationId: string,
-        discardOwnedItemsOnError: boolean
-      ) => {
-        const stream = await openai.responses.create(
-          {
-            conversation: targetConversationId,
-            model: requestModel,
-            input: [{ role: "user", content: messageContent }],
-            metadata: { internal_message_id: localMessageId },
-            stream: true,
-            store: true,
-            ...(requestWebSearchEnabled && { tools: [{ type: "web_search" }] })
-          },
-          { signal: run.signal }
-        );
-
-        if (!runtimeStore.setAssistantStreaming(runtimeKey, run.token, true)) return null;
-        try {
-          return await processStreamingResponse(
-            stream,
-            runtimeKey,
-            run.token,
-            localMessageId,
-            discardOwnedItemsOnError
-          );
-        } finally {
-          runtimeStore.setAssistantStreaming(runtimeKey, run.token, false);
-        }
-      };
+      let conversationId =
+        startSnapshot.conversation?.id ?? conversationIdFromChatRuntimeKey(runtimeKey);
+      let completedAnyTurn = false;
+      let stopOwnsSettlement = false;
+      let detachedResponseOwnsSettlement = false;
 
       const scheduleBillingRefresh = () => {
         const timeout = setTimeout(() => {
@@ -4479,305 +5100,520 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
         billingRefreshTimeoutsRef.current.add(timeout);
       };
 
-      const messageContent: (InputTextContent | InputImageContent)[] = [];
-      let finalText = trimmedInput;
-      if (originalDocumentText) {
-        finalText = originalDocumentText + (trimmedInput ? `\n\n${trimmedInput}` : "");
-      }
-      if (finalText) {
-        messageContent.push({
-          type: "input_text",
-          text: finalText
-        });
-      }
+      const sendTurn = async (turn: ChatQueueTurn): Promise<boolean> => {
+        const { item, recoverOnFailure, previousLastSeenItemId } = turn;
+        const localMessageId = item.messageId;
+        let ownsObjectUrls = true;
+        let responseRequestStarted = false;
+        let conversationCreateInFlight = false;
+        let turnRestored = false;
+        let preserveUnresolvedResponseOwnership = false;
+
+        const releaseObjectUrls = () => {
+          if (!ownsObjectUrls) return;
+          ownsObjectUrls = false;
+          const snapshot = runtimeStore.get(runtimeKey);
+          const retainedObjectUrls = new Set(
+            snapshot
+              ? [
+                  ...chatComposerObjectUrls(snapshot.composer),
+                  ...chatTranscriptObjectUrls(snapshot.messages as Message[])
+                ]
+              : []
+          );
+          revokeQueuedChatMessageObjectUrls(item, retainedObjectUrls);
+        };
 
-      try {
-        for (const file of originalImages) {
-          try {
-            const dataUrl = await fileToDataURL(file);
-            messageContent.push({
-              type: "input_image",
-              image_url: dataUrl,
-              detail: "auto",
-              file_id: null
-            });
-          } catch (error) {
-            console.error("Failed to convert image:", error);
+        const restoreTurn = (message: string) => {
+          if (turnRestored) return true;
+          let transferred = false;
+          const restored = runtimeStore.updateForRun(runtimeKey, run.token, (snapshot) => {
+            const recovery = recoverDetachedChatComposerDraft(snapshot.composer, item);
+            let composer = recovery.composer;
+            if (!recoverOnFailure && recovery.status === "restored") {
+              composer = {
+                ...snapshot.composer,
+                queue: {
+                  ...snapshot.composer.queue,
+                  items: [item, ...snapshot.composer.queue.items]
+                }
+              };
+            }
+            transferred = true;
+            return {
+              ...snapshot,
+              messages: (snapshot.messages as Message[]).filter(
+                (messageItem) => messageItem.id !== localMessageId
+              ),
+              lastSeenItemId:
+                snapshot.lastSeenItemId === localMessageId
+                  ? previousLastSeenItemId
+                  : snapshot.lastSeenItemId,
+              composer,
+              error: message
+            };
+          });
+          if (restored && transferred) {
+            ownsObjectUrls = false;
+            turnRestored = true;
           }
-        }
-        if (!runtimeStore.isRunCurrent(runtimeKey, run.token)) return;
-
-        const userMessage = {
-          id: localMessageId,
-          type: "message",
-          role: "user",
-          content: messageContent,
-          status: "completed"
-        } as unknown as Message;
-
-        const stagedImageUrls = new Set<string>();
-        const staged = runtimeStore.updateForRun(runtimeKey, run.token, (snapshot) => {
-          for (const url of snapshot.composer.imageUrls.values()) stagedImageUrls.add(url);
-          return {
+          return restored && transferred;
+        };
+
+        const markTurnIncomplete = (message: string) => {
+          runtimeStore.updateForRun(runtimeKey, run.token, (snapshot) => ({
             ...snapshot,
-            messages: mergeMessagesById(snapshot.messages as Message[], [userMessage]),
-            lastSeenItemId: localMessageId,
-            composer: {
-              ...snapshot.composer,
-              input: "",
-              draftImages: [],
-              imageUrls: new Map(),
-              documentText: "",
-              documentName: "",
-              isProcessingDocument: false,
-              attachmentError: null,
-              imagePasteGeneration: snapshot.composer.imagePasteGeneration + 1,
-              documentUploadGeneration: snapshot.composer.documentUploadGeneration + 1
-            }
-          };
+            messages: markOptimisticMessageIncomplete(
+              snapshot.messages as Message[],
+              localMessageId
+            ),
+            lastSeenItemId: chatCursorAfterSendFailure({
+              currentCursor: snapshot.lastSeenItemId,
+              optimisticMessageId: localMessageId,
+              previousCursor: previousLastSeenItemId,
+              responseCreated: Boolean(snapshot.currentResponseId)
+            }),
+            error: message
+          }));
+        };
+
+        const unregisterCurrentTurn = registerChatCurrentTurn(runtimeStore, run.token, {
+          responseRequestStarted: () => responseRequestStarted,
+          serverRequestInFlight: () => conversationCreateInFlight,
+          restoreBeforeRequest: restoreTurn,
+          retainedPayload: item,
+          retainsPayload: () => !turnRestored,
+          countsTowardQueueLimit: true
         });
-        if (!staged) return;
-        registerChatOptimisticMessage(runtimeStore, run.token, localMessageId);
-        for (const url of stagedImageUrls) URL.revokeObjectURL(url);
-
-        if (!conversationId) {
-          const createParams: Parameters<typeof openai.conversations.create>[0] & {
-            project_id?: string;
-          } = {
-            metadata: {},
-            ...(originalComposer.draftProjectId && {
-              project_id: originalComposer.draftProjectId
-            })
-          };
-          const newConv = await openai.conversations.create(createParams, {
-            signal: run.signal
-          });
-          conversationId = newConv.id;
-          const sourceWasSelected = isRuntimeSelected(runtimeKey);
-          const destinationKey = createConversationChatKey(conversationId);
-          const destinationSnapshot = runtimeStore.get(destinationKey);
-          const rawRecordingOwnerKey = recordingOwnerKeyRef.current;
-          const canonicalRecordingOwnerKey = rawRecordingOwnerKey
-            ? runtimeStore.resolveKey(rawRecordingOwnerKey)
-            : null;
-          if (!canAdoptRecordingDestination(destinationKey, canonicalRecordingOwnerKey)) {
-            // Let pending microphone, recording, or transcription work finish on
-            // the idle destination. Adoption would make its eventual send fail.
-            restoreOriginComposer(
-              "This conversation is still processing a voice message. Your message was restored in its original draft."
-            );
-            return;
+
+        const messageContent = queuedChatMessageContent(item, () => undefined);
+        const createResponseStream = async () => {
+          if (
+            !runtimeStore.updateForRun(runtimeKey, run.token, (snapshot) => ({
+              ...snapshot,
+              assistantStreaming: false
+            }))
+          ) {
+            return null;
           }
-          if (!canAdoptAttachmentDestination(destinationSnapshot)) {
-            // Let the destination's extraction callback finish on its original
-            // idle runtime. Adopting it into this run would fence that callback
-            // and permanently strand isProcessingDocument=true.
-            restoreOriginComposer(
-              "This conversation is still processing an attachment. Your message was restored in its original draft."
+          registerChatOptimisticMessage(runtimeStore, run.token, localMessageId);
+          registerUnresolvedChatResponseMessage(runtimeStore, run.token, localMessageId);
+          responseRequestStarted = true;
+          const stream = await openai.responses.create(
+            {
+              conversation: conversationId!,
+              model: item.model,
+              input: [{ role: "user", content: messageContent }],
+              metadata: { internal_message_id: localMessageId },
+              stream: true,
+              store: true,
+              ...(item.webSearchEnabled && { tools: [{ type: "web_search" }] })
+            },
+            { signal: run.signal }
+          );
+
+          if (!runtimeStore.setAssistantStreaming(runtimeKey, run.token, true)) return null;
+          try {
+            return await processStreamingResponse(
+              stream,
+              runtimeKey,
+              run.token,
+              localMessageId,
+              async (responseId) => {
+                if (!isRuntimeStopping(run.token)) return false;
+                return cancelKnownChatResponse(runtimeKey, run.token, responseId, localMessageId);
+              }
             );
-            return;
+          } finally {
+            runtimeStore.setAssistantStreaming(runtimeKey, run.token, false);
           }
-          const migration = runtimeStore.rekeyRunAdoptingIdleDestination(
-            runtimeKey,
-            destinationKey,
-            run.token,
-            (source, destination) => ({
-              ...source,
-              conversation: destination.conversation ?? source.conversation,
-              messages: mergeLoadedMessagesWithRuntime(
-                destination.messages as Message[],
-                source.messages
-              ),
-              composer: destination.composer,
-              error: source.error ?? destination.error,
-              lastSeenItemId: source.lastSeenItemId ?? destination.lastSeenItemId,
-              historyLoaded: source.historyLoaded || destination.historyLoaded
-            })
-          );
+        };
 
-          if (migration.status === "source_stale") {
-            // Creation may already be visible to another tab or device. Without
-            // atomic server proof that C is empty and owned by this attempt,
-            // prefer a harmless empty orphan over deleting real chat history.
-            return;
+        try {
+          const dataUrls = new Map<File, string>();
+          for (const file of item.draftImages) {
+            try {
+              dataUrls.set(file, await fileToDataURL(file));
+            } catch (error) {
+              console.error("Failed to convert image:", error);
+              const restored = restoreTurn(
+                "An image could not be prepared. Your message and images were restored; please try again."
+              );
+              if (!restored && runtimeStore.get(runtimeKey)) {
+                const durableContent = queuedChatMessageContent(item, (image) =>
+                  dataUrls.get(image)
+                );
+                runtimeStore.update(runtimeKey, (snapshot) => ({
+                  ...snapshot,
+                  messages: markOptimisticMessageIncomplete(
+                    updateMessageById(snapshot.messages as Message[], localMessageId, (message) =>
+                      message.type === "message"
+                        ? ({ ...message, content: durableContent } as unknown as Message)
+                        : message
+                    ),
+                    localMessageId
+                  )
+                }));
+              }
+              return false;
+            }
           }
+          messageContent.push(
+            ...queuedChatMessageContent({ ...item, text: "", documentText: "" }, (file) =>
+              dataUrls.get(file)
+            )
+          );
 
-          if (migration.status === "destination_active") {
-            // Never replace or delete a destination that already owns a run.
-            // Browser history retains this source draft, so restoring here makes
-            // the original prompt and attachments recoverable with Back.
-            restoreOriginComposer(
-              "This conversation became active before your message was sent. Your message was restored in its original draft."
+          const updateMaterializedMessage = (messages: readonly Message[]) =>
+            updateMessageById(messages as Message[], localMessageId, (message) =>
+              message.type === "message"
+                ? ({ ...message, content: messageContent } as unknown as Message)
+                : message
             );
-            return;
+          if (!runtimeStore.isRunCurrent(runtimeKey, run.token)) {
+            if (runtimeStore.get(runtimeKey)) {
+              runtimeStore.update(runtimeKey, (snapshot) => ({
+                ...snapshot,
+                messages: updateMaterializedMessage(snapshot.messages as Message[])
+              }));
+            }
+            return false;
+          }
+          if (
+            !runtimeStore.updateForRun(runtimeKey, run.token, (snapshot) => ({
+              ...snapshot,
+              messages: updateMaterializedMessage(snapshot.messages as Message[])
+            }))
+          ) {
+            return false;
+          }
+          if (isChatRuntimeDeletionPending(runtimeStore, runtimeKey)) {
+            restoreTurn("Sending paused because this conversation is being deleted.");
+            return false;
           }
 
-          runtimeKey = migration.key;
-          adoptedExistingDestination = migration.adoptedExistingDestination;
-          runtimeStore.updateForRun(runtimeKey, run.token, (snapshot) => ({
-            ...snapshot,
-            conversation: newConv as Conversation,
-            composer: { ...snapshot.composer, draftProjectId: null }
-          }));
+          if (!conversationId) {
+            const createParams: Parameters<typeof openai.conversations.create>[0] & {
+              project_id?: string;
+            } = {
+              metadata: {},
+              ...(item.draftProjectId && { project_id: item.draftProjectId })
+            };
+            conversationCreateInFlight = true;
+            let newConv: Awaited<ReturnType<typeof openai.conversations.create>>;
+            try {
+              newConv = await openai.conversations.create(createParams, {
+                signal: run.signal
+              });
+            } finally {
+              conversationCreateInFlight = false;
+            }
+            conversationId = newConv.id;
+            const sourceWasSelected = isRuntimeSelected(runtimeKey);
+            const destinationKey = createConversationChatKey(conversationId);
+            const destinationSnapshot = runtimeStore.get(destinationKey);
+            const rawRecordingOwnerKey = recordingOwnerKeyRef.current;
+            const canonicalRecordingOwnerKey = rawRecordingOwnerKey
+              ? runtimeStore.resolveKey(rawRecordingOwnerKey)
+              : null;
+            if (!canAdoptRecordingDestination(destinationKey, canonicalRecordingOwnerKey)) {
+              restoreTurn(
+                "This conversation is still processing a voice message. Your message was restored in its original draft."
+              );
+              return false;
+            }
+            if (!canAdoptAttachmentDestination(destinationSnapshot)) {
+              restoreTurn(
+                "This conversation is still processing an attachment. Your message was restored in its original draft."
+              );
+              return false;
+            }
 
-          const keepSelection = shouldProjectMigratedConversation(
-            runtimeStore.isChatVisible(runtimeKey),
-            sourceWasSelected,
-            migration.destinationWasSelected
-          );
-          if (keepSelection) {
-            activeRuntimeKeyRef.current = runtimeKey;
-            setActiveRuntimeKey(runtimeKey);
-            setChatId(conversationId);
-            canonicalizeConversationHistoryEntry(conversationId);
-          }
-          window.dispatchEvent(new Event("conversationcreated"));
-        }
+            let displacedObjectUrls: string[] = [];
+            const migration = runtimeStore.rekeyRunAdoptingIdleDestination(
+              runtimeKey,
+              destinationKey,
+              run.token,
+              (source, destination) => {
+                const mergedComposer = mergeChatComposerDraftsForRekey(
+                  source.composer,
+                  destination.composer,
+                  destinationKey
+                );
+                displacedObjectUrls = mergedComposer.displacedObjectUrls;
+                return {
+                  ...source,
+                  conversation: destination.conversation ?? source.conversation,
+                  messages: mergeLoadedMessagesWithRuntime(
+                    destination.messages as Message[],
+                    source.messages
+                  ),
+                  composer: mergedComposer.composer,
+                  error: source.error ?? destination.error,
+                  lastSeenItemId: source.lastSeenItemId ?? destination.lastSeenItemId,
+                  historyLoaded: source.historyLoaded || destination.historyLoaded
+                };
+              }
+            );
 
-        const terminalState = await createResponseStream(conversationId, isFollowUpConversation);
-        completedSuccessfully = terminalState === "completed";
-        scheduleBillingRefresh();
-      } catch (error) {
-        console.error("Failed to send message:", error);
-        let errorMessage = error instanceof Error ? error.message : "Something went wrong";
-        const causeMessage = (error as Error & { cause?: { message?: string } })?.cause?.message;
-        if (causeMessage && causeMessage.includes("Request failed with status")) {
-          errorMessage = causeMessage;
-        }
+            if (migration.status === "source_stale") return false;
+            if (migration.status === "destination_active") {
+              restoreTurn(
+                "This conversation became active before your message was sent. Your message was restored in its original draft."
+              );
+              return false;
+            }
+            for (const url of displacedObjectUrls) URL.revokeObjectURL(url);
 
-        if (isImageDescriptionUnavailableError(error)) {
-          restoreOriginComposer(
-            "Image description is temporarily unavailable. Your message and images were restored; please try again."
-          );
-          return;
-        }
+            runtimeKey = migration.key;
+            runtimeStore.updateForRun(runtimeKey, run.token, (snapshot) => ({
+              ...snapshot,
+              conversation: newConv as Conversation,
+              composer: { ...snapshot.composer, draftProjectId: null }
+            }));
 
-        const parseStatusError = (status: number) => {
-          if (!errorMessage.includes(`Request failed with status ${status}:`)) return null;
-          try {
-            const jsonMatch = errorMessage.match(
-              new RegExp(`Request failed with status ${status}:\\s*({.*})`)
+            const keepSelection = shouldProjectMigratedConversation(
+              runtimeStore.isChatVisible(runtimeKey),
+              sourceWasSelected,
+              migration.destinationWasSelected
             );
-            return jsonMatch?.[1]
-              ? (JSON.parse(jsonMatch[1]) as { status: number; message: string })
-              : null;
-          } catch (parseError) {
-            console.error(`Failed to parse ${status} error:`, parseError);
-            return null;
+            if (keepSelection) {
+              activeRuntimeKeyRef.current = runtimeKey;
+              setActiveRuntimeKey(runtimeKey);
+              setChatId(conversationId);
+              canonicalizeConversationHistoryEntry(conversationId);
+            }
+            window.dispatchEvent(new Event("conversationcreated"));
           }
-        };
 
-        const status413Error = parseStatusError(413);
-        if (status413Error && status413Error.message === "Message exceeds context limit") {
-          restoreOriginComposer("Your message exceeds the context limit for this model.");
-          if (isRuntimeSelected(runtimeKey)) setContextLimitDialogOpen(true);
-          return;
-        }
+          if (isChatRuntimeDeletionPending(runtimeStore, runtimeKey)) {
+            restoreTurn("Sending paused because this conversation is being deleted.");
+            return false;
+          }
 
-        const status403Error = parseStatusError(403);
-        if (status403Error) {
-          let displayError: string;
-          if (status403Error.message === "Free tier token limit exceeded") {
-            displayError =
-              "This conversation is too long for the free tier. Upgrade to Pro for longer conversations.";
-            if (isRuntimeSelected(runtimeKey)) {
-              setUpgradeFeature("tokens");
-              setUpgradeDialogOpen(true);
+          const terminalState = await createResponseStream();
+          scheduleBillingRefresh();
+          return terminalState === "completed";
+        } catch (error) {
+          console.error("Failed to send message:", error);
+          let errorMessage = error instanceof Error ? error.message : "Something went wrong";
+          const causeMessage = (error as Error & { cause?: { message?: string } })?.cause?.message;
+          if (causeMessage?.includes("Request failed with status")) errorMessage = causeMessage;
+
+          const retainAmbiguousResponseOwnership = (message: string) => {
+            markTurnIncomplete(message);
+            preserveUnresolvedResponseOwnership = !runtimeStore.get(runtimeKey)?.currentResponseId;
+            detachedResponseOwnsSettlement = true;
+          };
+
+          if (isChatAccountCredentialMismatchError(error)) {
+            if (!responseRequestStarted || isChatRequestDefinitelyNotDispatchedError(error)) {
+              restoreTurn(
+                "Sending paused because the authenticated account changed. Your message was restored."
+              );
+            } else {
+              retainAmbiguousResponseOwnership(
+                "The authenticated account changed after sending began. The response may still be running; queued messages were kept."
+              );
             }
-          } else if (status403Error.message === "Usage limit reached") {
-            const isFreeTier =
-              !billingStatusAtSend?.product_name ||
-              billingStatusAtSend.product_name.toLowerCase() === "free";
+            return false;
+          }
+
+          if (isImageDescriptionUnavailableError(error)) {
+            restoreTurn(
+              "Image description is temporarily unavailable. Your message and images were restored; please try again."
+            );
+            return false;
+          }
 
-            if (isFreeTier) {
+          const parseStatusError = (status: number) => {
+            if (!errorMessage.includes(`Request failed with status ${status}:`)) return null;
+            try {
+              const jsonMatch = errorMessage.match(
+                new RegExp(`Request failed with status ${status}:\\s*({.*})`)
+              );
+              return jsonMatch?.[1]
+                ? (JSON.parse(jsonMatch[1]) as { status: number; message: string })
+                : null;
+            } catch (parseError) {
+              console.error(`Failed to parse ${status} error:`, parseError);
+              return null;
+            }
+          };
+
+          const status413Error = parseStatusError(413);
+          if (status413Error?.message === "Message exceeds context limit") {
+            restoreTurn("Your message exceeds the context limit for this model.");
+            if (isRuntimeSelected(runtimeKey)) setContextLimitDialogOpen(true);
+            return false;
+          }
+
+          const status403Error = parseStatusError(403);
+          if (status403Error) {
+            let displayError: string;
+            if (status403Error.message === "Free tier token limit exceeded") {
               displayError =
-                "You've reached your daily usage limit. Upgrade to Pro for more chats.";
+                "This conversation is too long for the free tier. Upgrade to Pro for longer conversations.";
+              if (isRuntimeSelected(runtimeKey)) {
+                setUpgradeFeature("tokens");
+                setUpgradeDialogOpen(true);
+              }
+            } else if (status403Error.message === "Usage limit reached") {
+              const isFreeTier =
+                !billingStatus?.product_name || billingStatus.product_name.toLowerCase() === "free";
+              if (isFreeTier) {
+                displayError =
+                  "You've reached your daily usage limit. Upgrade to Pro for more chats.";
+              } else {
+                const isPro =
+                  billingStatus.product_name?.toLowerCase().includes("pro") &&
+                  !billingStatus.product_name?.toLowerCase().includes("max");
+                displayError = isPro
+                  ? "You've reached your monthly Pro limit. Upgrade to Max for 10x more usage."
+                  : "You've reached your monthly usage limit. Please wait for the next billing cycle.";
+              }
+              if (isRuntimeSelected(runtimeKey)) {
+                setUpgradeFeature("usage");
+                setUpgradeDialogOpen(true);
+              }
             } else {
-              const isPro =
-                billingStatusAtSend.product_name?.toLowerCase().includes("pro") &&
-                !billingStatusAtSend.product_name?.toLowerCase().includes("max");
-              displayError = isPro
-                ? "You've reached your monthly Pro limit. Upgrade to Max for 10x more usage."
-                : "You've reached your monthly usage limit. Please wait for the next billing cycle.";
+              displayError =
+                status403Error.message || "Access denied. Please check your subscription.";
             }
-            if (isRuntimeSelected(runtimeKey)) {
-              setUpgradeFeature("usage");
-              setUpgradeDialogOpen(true);
+            restoreTurn(displayError);
+            return false;
+          }
+
+          if (
+            isChatRequestDefinitelyNotDispatchedError(error) ||
+            isChatResponseDefinitelyRejectedError(error)
+          ) {
+            restoreTurn(`${errorMessage}. Please try again.`);
+            return false;
+          }
+
+          if (error instanceof Error && error.name !== "AbortError") {
+            if (!responseRequestStarted) {
+              restoreTurn(`${errorMessage}. Please try again.`);
+            } else {
+              // Once an ambiguous streaming POST has started, replaying it can
+              // create a duplicate provider turn. Keep later FIFO items staged
+              // and retain known server ownership until polling or Stop reaches
+              // a terminal response state.
+              retainAmbiguousResponseOwnership(
+                `${errorMessage}. The response may still be running; queued messages were kept.`
+              );
             }
-          } else {
-            displayError =
-              status403Error.message || "Access denied. Please check your subscription.";
           }
-          restoreOriginComposer(displayError);
-        } else if (error instanceof Error && error.name !== "AbortError") {
-          if (isFollowUpConversation && conversationId) {
-            try {
-              console.log("Waiting 1s before retry...");
-              await new Promise((resolve) => setTimeout(resolve, 1000));
-              if (!runtimeStore.isRunCurrent(runtimeKey, run.token)) return;
-
-              console.log("Retrying request once...");
-              const terminalState = await createResponseStream(conversationId, false);
-              completedSuccessfully = terminalState === "completed";
-              scheduleBillingRefresh();
-              console.log("Retry completed successfully");
-              return;
-            } catch (retryError) {
-              console.error("Retry failed:", retryError);
-              if (!runtimeStore.isRunCurrent(runtimeKey, run.token)) return;
-
-              try {
-                const finalCheckResponse = await openai.conversations.items.list(conversationId, {
-                  limit: 5,
-                  order: "desc"
-                });
-                const foundMessage = finalCheckResponse.data.find(
-                  (item) => item.id === localMessageId
-                );
+          return false;
+        } finally {
+          unregisterCurrentTurn();
+          unregisterChatOptimisticMessage(runtimeStore, run.token, localMessageId);
+          if (!preserveUnresolvedResponseOwnership) {
+            clearUnresolvedChatResponseMessage(runtimeStore, run.token, localMessageId);
+          }
+          releaseObjectUrls();
+        }
+      };
 
-                if (!foundMessage) {
-                  console.log("Message not found after retry - restoring input");
-                  restoreOriginComposer("Failed to send message. Please try again.");
-                } else {
-                  console.log("Message found after retry failure - it actually went through");
-                }
-              } catch (finalCheckError) {
-                console.error("Final check failed:", finalCheckError);
-                restoreOriginComposer("Failed to send message. Please try again.");
+      try {
+        while (currentTurn && runtimeStore.isRunCurrent(runtimeKey, run.token)) {
+          const completed = await sendTurn(currentTurn);
+          if (!completed || !runtimeStore.isRunCurrent(runtimeKey, run.token)) {
+            if (runtimeStore.isRunCurrent(runtimeKey, run.token) && isRuntimeStopping(run.token)) {
+              const responseId = runtimeStore.get(runtimeKey)?.currentResponseId;
+              stopOwnsSettlement = Boolean(responseId);
+              if (!responseId) {
+                // A failed POST before response.created can still be accepted
+                // server-side. Keep the run and Stop intent fenced until item
+                // polling recovers its response UUID; never overlap the FIFO.
+                setErrorForKey(
+                  runtimeKey,
+                  "Maple could not confirm that the response stopped. Queued messages were kept."
+                );
               }
             }
-          } else {
-            const optimisticMessageId = getRegisteredChatOptimisticMessage(runtimeStore, run.token);
-            runtimeStore.updateForRun(runtimeKey, run.token, (snapshot) => ({
+            break;
+          }
+          completedAnyTurn = true;
+          if (isChatRunQueueHaltRequested(runtimeStore, run.token)) {
+            if (!runtimeStore.get(runtimeKey)?.currentResponseId) {
+              stoppingRuntimeRegistry.delete(runtimeKey, run.token);
+            }
+            break;
+          }
+          if (isRuntimeStopping(run.token)) break;
+          if (isChatRuntimeDeletionPending(runtimeStore, runtimeKey)) break;
+
+          let nextTurn: ChatQueueTurn | undefined;
+          const advanced = runtimeStore.updateForRun(runtimeKey, run.token, (snapshot) => {
+            const next = takeNextChatQueuedMessage(snapshot.composer.queue);
+            if (next.status !== "taken") {
+              return {
+                ...snapshot,
+                currentResponseId: undefined,
+                assistantStreaming: false
+              };
+            }
+            nextTurn = {
+              item: next.item,
+              recoverOnFailure: false,
+              previousLastSeenItemId: snapshot.lastSeenItemId
+            };
+            return {
               ...snapshot,
-              messages: markOptimisticMessageIncomplete(
-                snapshot.messages as Message[],
-                optimisticMessageId
-              ),
-              error: `${errorMessage}. Please try again.`
-            }));
+              composer: { ...snapshot.composer, queue: next.queue },
+              messages: mergeMessagesById(snapshot.messages as Message[], [
+                promotedChatUserMessage(next.item)
+              ]),
+              lastSeenItemId: next.item.messageId,
+              currentResponseId: undefined,
+              assistantStreaming: false,
+              error: null
+            };
+          });
+          if (!advanced) break;
+          if (!nextTurn) {
+            break;
           }
+          currentTurn = nextTurn;
+          registerChatOptimisticMessage(runtimeStore, run.token, currentTurn.item.messageId);
         }
       } finally {
-        unregisterChatOptimisticMessage(runtimeStore, run.token, localMessageId);
-        if (completedSuccessfully) {
-          runtimeStore.completeRun(runtimeKey, run.token);
-        } else {
-          runtimeStore.finishRun(runtimeKey, run.token);
+        if (
+          runtimeStore.isRunCurrent(runtimeKey, run.token) &&
+          !stopOwnsSettlement &&
+          !detachedResponseOwnsSettlement
+        ) {
+          if (completedAnyTurn) runtimeStore.completeRun(runtimeKey, run.token);
+          else runtimeStore.finishRun(runtimeKey, run.token);
+        }
+        if (!runtimeStore.isRunCurrent(runtimeKey, run.token)) {
+          clearUnresolvedChatResponseMessage(runtimeStore, run.token);
+        }
+        if (!runtimeStore.isRunCurrent(runtimeKey, run.token)) {
+          stoppingRuntimeRegistry.delete(runtimeKey, run.token);
+        }
+        if (!runtimeStore.isRunCurrent(runtimeKey, run.token)) {
+          clearChatRunQueueHalt(runtimeStore, run.token);
         }
       }
     },
     [
       billingRefreshTimeoutsRef,
       billingStatus,
+      cancelKnownChatResponse,
       isRuntimeSelected,
+      isCompactLayout,
       isWebSearchEnabled,
       model,
       openai,
       processStreamingResponse,
       queryClient,
       runtimeStore,
-      selectedProjectId
+      selectedProjectId,
+      setErrorForKey,
+      stoppingRuntimeRegistry
     ]
   );
 
@@ -4785,6 +5621,11 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
     // On desktop: Enter submits, Shift+Enter for new line
     // On mobile: Enter for new line, no keyboard shortcut to submit (use button)
     if (e.nativeEvent.isComposing) return;
+    if (e.key === "Escape" && queueEdit) {
+      e.preventDefault();
+      discardQueueEdit();
+      return;
+    }
     if ((e.shiftKey || isCompactLayout) && continueChatComposerList(e, setInput)) {
       return;
     }
@@ -4983,7 +5824,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
 
                 <form onSubmit={handleSendMessage} className="relative w-full">
                   <div className="space-y-2">
-                    {(draftImages.length > 0 || documentName) && (
+                    {!queueEdit && (draftImages.length > 0 || documentName) && (
                       <div className="space-y-2">
                         {draftImages.length > 0 && (
                           <div className="flex flex-wrap gap-2">
@@ -4997,7 +5838,6 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                                 <button
                                   type="button"
                                   onClick={() => removeImage(i)}
-                                  disabled={isGenerating}
                                   aria-label={`Remove attachment ${i + 1}`}
                                   className="absolute -right-1 -top-1 rounded-full border bg-background p-0.5 opacity-0 transition-opacity group-hover:opacity-100 disabled:pointer-events-none disabled:opacity-40"
                                 >
@@ -5015,7 +5855,6 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                             <button
                               type="button"
                               onClick={removeDocument}
-                              disabled={isGenerating}
                               aria-label="Remove document"
                               className="text-muted-foreground hover:text-foreground disabled:pointer-events-none disabled:opacity-40"
                             >
@@ -5037,6 +5876,14 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                         isFullscreenAnimating ? "transition-all duration-300" : "transition-colors"
                       } ${isFullscreen ? "h-[70vh] max-h-[800px] min-h-0" : ""}`}
                     >
+                      <QueuedComposerMessages
+                        items={queuedMessages}
+                        className="pr-10"
+                        editingQueueId={queueEdit?.queueId}
+                        getFallbackLabel={queuedChatMessageFallbackLabel}
+                        onRemove={cancelQueuedMessage}
+                        onEdit={editQueuedMessage}
+                      />
                       <button
                         type="button"
                         onClick={toggleFullscreen}
@@ -5056,8 +5903,10 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                         onKeyDown={handleKeyDown}
                         onBeforeInput={handleBeforeInput}
                         onPaste={handlePaste}
-                        placeholder="Message Maple..."
-                        disabled={isGenerating || isRecordingForActive}
+                        placeholder={
+                          queueEdit ? QUEUED_MESSAGE_EDIT_PLACEHOLDER : "Message Maple..."
+                        }
+                        disabled={isRecordingForActive}
                         className={`resize-none border-0 bg-transparent pl-4 pr-8 text-base leading-6 focus-visible:ring-0 focus-visible:ring-offset-0 placeholder:text-muted-foreground/60 ${
                           isFullscreen
                             ? "flex-1 min-h-0 pt-3 pb-2"
@@ -5107,13 +5956,13 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                                 variant="ghost"
                                 size="sm"
                                 className="h-8 w-8 p-0 text-[hsl(var(--maple-secondary-700))] hover:bg-[hsl(var(--maple-primary-container))] hover:text-[hsl(var(--maple-secondary-700))]"
-                                disabled={isGenerating || isProcessingDocument}
+                                disabled={Boolean(queueEdit) || isProcessingDocument}
                                 aria-busy={isProcessingDocument}
                                 aria-label={
                                   isProcessingDocument
                                     ? "Processing document"
-                                    : isGenerating
-                                      ? "Attachments unavailable while generating"
+                                    : queueEdit
+                                      ? "Attachments unavailable while editing a queued message"
                                       : "Add attachment"
                                 }
                               >
@@ -5132,7 +5981,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                             </DropdownMenuTrigger>
                             <DropdownMenuContent align="start">
                               <DropdownMenuItem
-                                disabled={isGenerating}
+                                disabled={Boolean(queueEdit)}
                                 onClick={() => {
                                   if (!canUseImages) {
                                     setUpgradeFeature("image");
@@ -5147,7 +5996,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                                 <span>Add Images</span>
                               </DropdownMenuItem>
                               <DropdownMenuItem
-                                disabled={isGenerating}
+                                disabled={Boolean(queueEdit)}
                                 onClick={() => {
                                   if (!isTauriEnv) {
                                     setDocumentPlatformDialogOpen(true);
@@ -5171,17 +6020,21 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                           <Button
                             type="button"
                             onClick={startRecording}
-                            disabled={isGenerating || isRecording || !canUseVoice}
+                            disabled={isStopping || isRecording || !canUseVoice}
                             size="icon"
                             variant="ghost"
                             className="h-8 w-8 rounded-xl hover:bg-muted sm:h-9 sm:w-9"
                           >
                             <Mic className="h-4 w-4" />
                           </Button>
-                          {isGenerating ? (
+                          {queueEdit ? (
+                            <DiscardQueuedMessageEditButton onDiscard={discardQueueEdit} />
+                          ) : null}
+                          {showsStop ? (
                             <Button
                               type="button"
                               onClick={handleCancelResponse}
+                              disabled={isStopping}
                               aria-label="Stop generating"
                               size="icon"
                               variant="destructive"
@@ -5189,19 +6042,15 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                             >
                               <div className="h-3 w-3 rounded-md bg-current" />
                             </Button>
-                          ) : (
-                            <button
-                              type="submit"
-                              aria-label="Send message"
-                              disabled={
-                                isProcessingDocument ||
-                                (!input.trim() && !draftImages.length && !documentText)
-                              }
-                              className="flex h-8 w-8 items-center justify-center rounded-full bg-gradient-to-b from-[hsl(var(--maple-primary))] to-[hsl(var(--maple-primary-strong))] text-[hsl(var(--maple-on-primary))]/90 transition-all duration-200 ease-out active:scale-[0.95] disabled:pointer-events-none disabled:opacity-40 sm:h-9 sm:w-9"
-                            >
-                              <ArrowUp className="h-3.5 w-3.5 sm:h-4 sm:w-4" />
-                            </button>
-                          )}
+                          ) : null}
+                          <button
+                            type="submit"
+                            aria-label={queueEdit ? "Save queued message" : "Send message"}
+                            disabled={!canSubmitMessage}
+                            className="flex h-8 w-8 items-center justify-center rounded-full bg-gradient-to-b from-[hsl(var(--maple-primary))] to-[hsl(var(--maple-primary-strong))] text-[hsl(var(--maple-on-primary))]/90 transition-all duration-200 ease-out active:scale-[0.95] disabled:pointer-events-none disabled:opacity-40 sm:h-9 sm:w-9"
+                          >
+                            <ArrowUp className="h-3.5 w-3.5 sm:h-4 sm:w-4" />
+                          </button>
                         </div>
                       </div>
 
@@ -5234,7 +6083,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
             <div className="mx-auto max-w-4xl px-4 landscape-short:px-3">
               <form onSubmit={handleSendMessage} className="relative">
                 <div className="space-y-2 landscape-short:space-y-1">
-                  {(draftImages.length > 0 || documentName) && (
+                  {!queueEdit && (draftImages.length > 0 || documentName) && (
                     <div className="space-y-2 landscape-short:space-y-1">
                       {draftImages.length > 0 && (
                         <div className="flex flex-wrap gap-2">
@@ -5248,7 +6097,6 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                               <button
                                 type="button"
                                 onClick={() => removeImage(i)}
-                                disabled={isGenerating}
                                 aria-label={`Remove attachment ${i + 1}`}
                                 className="absolute -right-1 -top-1 rounded-full border bg-background p-0.5 opacity-0 transition-opacity group-hover:opacity-100 disabled:pointer-events-none disabled:opacity-40"
                               >
@@ -5266,7 +6114,6 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                           <button
                             type="button"
                             onClick={removeDocument}
-                            disabled={isGenerating}
                             aria-label="Remove document"
                             className="text-muted-foreground hover:text-foreground disabled:pointer-events-none disabled:opacity-40"
                           >
@@ -5284,6 +6131,13 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                   )}
 
                   <ChatComposerSurface>
+                    <QueuedComposerMessages
+                      items={queuedMessages}
+                      editingQueueId={queueEdit?.queueId}
+                      getFallbackLabel={queuedChatMessageFallbackLabel}
+                      onRemove={cancelQueuedMessage}
+                      onEdit={editQueuedMessage}
+                    />
                     <Textarea
                       ref={textareaRef}
                       value={input}
@@ -5291,8 +6145,8 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                       onKeyDown={handleKeyDown}
                       onBeforeInput={handleBeforeInput}
                       onPaste={handlePaste}
-                      placeholder="Message Maple..."
-                      disabled={isGenerating || isRecordingForActive}
+                      placeholder={queueEdit ? QUEUED_MESSAGE_EDIT_PLACEHOLDER : "Message Maple..."}
+                      disabled={isRecordingForActive}
                       className={CHAT_COMPOSER_TEXTAREA_CLASS}
                       rows={1}
                       id="message"
@@ -5332,13 +6186,13 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                               variant="ghost"
                               size="sm"
                               className="h-8 w-8 p-0 text-[hsl(var(--maple-secondary-700))] hover:bg-[hsl(var(--maple-primary-container))] hover:text-[hsl(var(--maple-secondary-700))]"
-                              disabled={isGenerating || isProcessingDocument}
+                              disabled={Boolean(queueEdit) || isProcessingDocument}
                               aria-busy={isProcessingDocument}
                               aria-label={
                                 isProcessingDocument
                                   ? "Processing document"
-                                  : isGenerating
-                                    ? "Attachments unavailable while generating"
+                                  : queueEdit
+                                    ? "Attachments unavailable while editing a queued message"
                                     : "Add attachment"
                               }
                             >
@@ -5357,7 +6211,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                           </DropdownMenuTrigger>
                           <DropdownMenuContent align="start">
                             <DropdownMenuItem
-                              disabled={isGenerating}
+                              disabled={Boolean(queueEdit)}
                               onClick={() => {
                                 if (!canUseImages) {
                                   setUpgradeFeature("image");
@@ -5372,7 +6226,7 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                               <span>Add Images</span>
                             </DropdownMenuItem>
                             <DropdownMenuItem
-                              disabled={isGenerating}
+                              disabled={Boolean(queueEdit)}
                               onClick={() => {
                                 if (!isTauriEnv) {
                                   setDocumentPlatformDialogOpen(true);
@@ -5396,17 +6250,21 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                         <Button
                           type="button"
                           onClick={startRecording}
-                          disabled={isGenerating || isRecording || !canUseVoice}
+                          disabled={isStopping || isRecording || !canUseVoice}
                           size="icon"
                           variant="ghost"
                           className="h-8 w-8 rounded-xl text-[hsl(var(--maple-secondary-700))] hover:bg-[hsl(var(--maple-primary-container))] hover:text-[hsl(var(--maple-secondary-700))]"
                         >
                           <Mic className="h-4 w-4 text-[hsl(var(--maple-secondary-700))]" />
                         </Button>
-                        {isGenerating ? (
+                        {queueEdit ? (
+                          <DiscardQueuedMessageEditButton onDiscard={discardQueueEdit} />
+                        ) : null}
+                        {showsStop ? (
                           <Button
                             type="button"
                             onClick={handleCancelResponse}
+                            disabled={isStopping}
                             aria-label="Stop generating"
                             size="icon"
                             variant="destructive"
@@ -5414,19 +6272,15 @@ export function UnifiedChat({ isVisible = true }: { isVisible?: boolean }) {
                           >
                             <div className="h-3 w-3 rounded-md bg-current" />
                           </Button>
-                        ) : (
-                          <button
-                            type="submit"
-                            aria-label="Send message"
-                            disabled={
-                              isProcessingDocument ||
-                              (!input.trim() && !draftImages.length && !documentText)
-                            }
-                            className="flex h-8 w-8 items-center justify-center rounded-full bg-gradient-to-b from-[hsl(var(--maple-primary))] to-[hsl(var(--maple-primary-strong))] text-[hsl(var(--maple-on-primary))]/90 transition-all duration-200 ease-out active:scale-[0.95] disabled:pointer-events-none disabled:opacity-40"
-                          >
-                            <ArrowUp className="h-4 w-4" />
-                          </button>
-                        )}
+                        ) : null}
+                        <button
+                          type="submit"
+                          aria-label={queueEdit ? "Save queued message" : "Send message"}
+                          disabled={!canSubmitMessage}
+                          className="flex h-8 w-8 items-center justify-center rounded-full bg-gradient-to-b from-[hsl(var(--maple-primary))] to-[hsl(var(--maple-primary-strong))] text-[hsl(var(--maple-on-primary))]/90 transition-all duration-200 ease-out active:scale-[0.95] disabled:pointer-events-none disabled:opacity-40"
+                        >
+                          <ArrowUp className="h-4 w-4" />
+                        </button>
                       </div>
                     </div>
 
diff --git a/frontend/src/components/VerificationModal.tsx b/frontend/src/components/VerificationModal.tsx
index 1dfc18630..610498031 100644
--- a/frontend/src/components/VerificationModal.tsx
+++ b/frontend/src/components/VerificationModal.tsx
@@ -21,11 +21,15 @@ import {
 } from "@/services/agentRuntimeService";
 import { resetWorkspaceModePreference } from "@/services/workspaceModePreference";
 import { getBillingService } from "@/billing/billingService";
+import { useChatRuntimeStore } from "@/contexts/ChatRuntimeContext";
+import { beginAllChatRuntimeDeletionFence } from "@/services/chatRuntimeDeletionFence";
+import { assertChatAccountCredential } from "@/services/chatAccountCredential";
 import { navigateToSafeInternalRedirect } from "@/utils/internalRedirect";
 
 export function VerificationModal() {
   const os = useOpenSecret();
   const queryClient = useQueryClient();
+  const runtimeStore = useChatRuntimeStore<unknown, unknown>();
   const router = useRouter();
   const [isOpen, setIsOpen] = useState(() => {
     if (!os.auth.user) return false;
@@ -118,25 +122,42 @@ export function VerificationModal() {
   const handleSignOut = async () => {
     setSignOutError(null);
     setIsSigningOut(true);
+    const releaseChatFence = beginAllChatRuntimeDeletionFence(runtimeStore);
     let operationBlock: Awaited<ReturnType<typeof stopAgentRuntimeForUser>> | null = null;
     let signedOut = false;
     let nativeAuthCleared = false;
     const userId = os.auth.user?.user.id;
 
+    try {
+      assertChatAccountCredential(userId);
+    } catch (error) {
+      console.error("Account changed before sign out:", error);
+      releaseChatFence();
+      setSignOutError("Your account changed in another window. Refresh Maple before signing out.");
+      setIsSigningOut(false);
+      return;
+    }
+
     try {
       operationBlock = await stopAgentRuntimeForUser(userId);
     } catch (error) {
       console.error("Error stopping Agent Mode:", error);
+      releaseChatFence();
       setSignOutError("Maple couldn't stop Agent Mode. Please try logging out again.");
       setIsSigningOut(false);
       return;
     }
 
     try {
+      assertChatAccountCredential(userId);
       // Credential reset is a required part of logout.
       const { proxyService } = await import("@/services/proxyService");
-      await proxyService.stopAndResetProxy(userId, os.deleteApiKey);
+      await proxyService.stopAndResetProxy(userId, (name) => {
+        assertChatAccountCredential(userId);
+        return os.deleteApiKey(name);
+      });
 
+      assertChatAccountCredential(userId);
       // Do not carry this account's third-party billing JWT into the next
       // authenticated session in the same WebView.
       try {
@@ -147,6 +168,7 @@ export function VerificationModal() {
 
       await clearMapleApiAuthForUser(userId);
       nativeAuthCleared = true;
+      assertChatAccountCredential(userId);
       await os.signOut();
       signedOut = true;
       resetWorkspaceModePreference();
@@ -158,6 +180,7 @@ export function VerificationModal() {
       );
     } finally {
       if (!signedOut) {
+        releaseChatFence();
         if (nativeAuthCleared) {
           try {
             await restoreMapleApiAuthForUser(userId);
diff --git a/frontend/src/components/chat/QueuedComposerMessages.test.tsx b/frontend/src/components/chat/QueuedComposerMessages.test.tsx
new file mode 100644
index 000000000..835cd50cb
--- /dev/null
+++ b/frontend/src/components/chat/QueuedComposerMessages.test.tsx
@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test";
+import { renderToStaticMarkup } from "react-dom/server";
+import {
+  DiscardQueuedMessageEditButton,
+  QUEUED_MESSAGE_EDIT_PLACEHOLDER,
+  QueuedComposerMessages
+} from "./QueuedComposerMessages";
+
+describe("queued composer messages", () => {
+  test("renders the edit state and Agent action order", () => {
+    const markup = renderToStaticMarkup(
+      <QueuedComposerMessages
+        items={[{ queueId: "q1", text: "queued" }]}
+        editingQueueId="q1"
+        onRemove={() => {}}
+        onEdit={() => {}}
+        onSendNow={() => {}}
+      />
+    );
+
+    expect(markup).toContain("bg-muted text-foreground ring-1 ring-border");
+    expect(markup.indexOf('aria-label="Remove queued message"')).toBeLessThan(
+      markup.indexOf('aria-label="Edit queued message"')
+    );
+    expect(markup.indexOf('aria-label="Edit queued message"')).toBeLessThan(
+      markup.indexOf('aria-label="Send queued message into the current turn"')
+    );
+  });
+
+  test("supports an attachment fallback without adding a send-now action", () => {
+    const markup = renderToStaticMarkup(
+      <QueuedComposerMessages
+        items={[{ queueId: "q1", text: "", attachmentCount: 2 }]}
+        getFallbackLabel={(item) => `${item.attachmentCount} attachment(s)`}
+        onRemove={() => {}}
+        onEdit={() => {}}
+      />
+    );
+
+    expect(markup).toContain("2 attachment(s)");
+    expect(markup).not.toContain("Send queued message into the current turn");
+  });
+
+  test("disables only the optional send-now action", () => {
+    const markup = renderToStaticMarkup(
+      <QueuedComposerMessages
+        items={[{ queueId: "q1", text: "queued" }]}
+        onRemove={() => {}}
+        onEdit={() => {}}
+        onSendNow={() => {}}
+        sendNowDisabled
+      />
+    );
+
+    expect(markup.match(/disabled=""/g)).toHaveLength(1);
+  });
+
+  test("accepts layout clearance for an overlaid composer control", () => {
+    const markup = renderToStaticMarkup(
+      <QueuedComposerMessages items={[{ queueId: "q1", text: "queued" }]} className="pr-10" />
+    );
+
+    expect(markup).toContain("pr-10");
+  });
+
+  test("shares the edit prompt and discard control", () => {
+    const markup = renderToStaticMarkup(<DiscardQueuedMessageEditButton onDiscard={() => {}} />);
+
+    expect(QUEUED_MESSAGE_EDIT_PLACEHOLDER).toBe(
+      "Edit the queued message, then send to keep its place..."
+    );
+    expect(markup).toContain(">Discard</button>");
+  });
+
+  test("renders nothing for an empty queue", () => {
+    expect(renderToStaticMarkup(<QueuedComposerMessages items={[]} />)).toBe("");
+  });
+});
diff --git a/frontend/src/components/chat/QueuedComposerMessages.tsx b/frontend/src/components/chat/QueuedComposerMessages.tsx
new file mode 100644
index 000000000..a02b7c3ad
--- /dev/null
+++ b/frontend/src/components/chat/QueuedComposerMessages.tsx
@@ -0,0 +1,95 @@
+import { ArrowUp, FilePenLine, Trash } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import type { QueuedComposerMessage } from "@/services/composerQueue";
+import { cn } from "@/utils/utils";
+
+export type { QueuedComposerMessage } from "@/services/composerQueue";
+
+export const QUEUED_MESSAGE_EDIT_PLACEHOLDER =
+  "Edit the queued message, then send to keep its place...";
+
+export function QueuedComposerMessages<T extends QueuedComposerMessage>({
+  items,
+  className,
+  editingQueueId = null,
+  getFallbackLabel,
+  onRemove,
+  onEdit,
+  onSendNow,
+  sendNowDisabled = false
+}: {
+  items: readonly T[];
+  className?: string;
+  editingQueueId?: string | null;
+  getFallbackLabel?: (item: T) => string;
+  onRemove?: (queueId: string) => void;
+  onEdit?: (queueId: string) => void;
+  onSendNow?: (queueId: string) => void;
+  sendNowDisabled?: boolean;
+}) {
+  if (items.length === 0) return null;
+
+  return (
+    <div className={cn("flex flex-col gap-1 px-3 pt-2", className)}>
+      {items.map((item) => (
+        <div
+          key={item.queueId}
+          className={cn(
+            "flex items-center gap-1 rounded-lg bg-muted/70 px-2 py-1 text-left text-xs text-muted-foreground",
+            item.queueId === editingQueueId && "bg-muted text-foreground ring-1 ring-border"
+          )}
+        >
+          <span className="min-w-0 flex-1 truncate" title={item.text}>
+            {item.text || getFallbackLabel?.(item) || "Queued message"}
+          </span>
+          {onRemove ? (
+            <button
+              type="button"
+              className="rounded-md p-1 text-muted-foreground transition-colors hover:bg-background hover:text-foreground"
+              onClick={() => onRemove(item.queueId)}
+              aria-label="Remove queued message"
+            >
+              <Trash className="h-3.5 w-3.5" />
+            </button>
+          ) : null}
+          {onEdit ? (
+            <button
+              type="button"
+              className="rounded-md p-1 text-muted-foreground transition-colors hover:bg-background hover:text-foreground"
+              onClick={() => onEdit(item.queueId)}
+              aria-label="Edit queued message"
+            >
+              <FilePenLine className="h-3.5 w-3.5" />
+            </button>
+          ) : null}
+          {onSendNow ? (
+            <button
+              type="button"
+              className="rounded-md p-1 text-muted-foreground transition-colors hover:bg-background hover:text-foreground disabled:pointer-events-none disabled:opacity-40"
+              onClick={() => onSendNow(item.queueId)}
+              disabled={sendNowDisabled}
+              title="Send into the current turn"
+              aria-label="Send queued message into the current turn"
+            >
+              <ArrowUp className="h-3.5 w-3.5" />
+            </button>
+          ) : null}
+        </div>
+      ))}
+    </div>
+  );
+}
+
+export function DiscardQueuedMessageEditButton({ onDiscard }: { onDiscard: () => void }) {
+  return (
+    <Button
+      type="button"
+      size="sm"
+      variant="ghost"
+      className="h-8 px-2 text-xs text-muted-foreground"
+      onClick={onDiscard}
+    >
+      Discard
+    </Button>
+  );
+}
diff --git a/frontend/src/components/settings/DeleteAccountSettings.tsx b/frontend/src/components/settings/DeleteAccountSettings.tsx
index 9d78f67d8..f5e163d00 100644
--- a/frontend/src/components/settings/DeleteAccountSettings.tsx
+++ b/frontend/src/components/settings/DeleteAccountSettings.tsx
@@ -18,6 +18,15 @@ import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { useSettingsNavigationLock } from "@/contexts/SettingsNavigationLockContext";
+import { useChatRuntimeStore } from "@/contexts/ChatRuntimeContext";
+import { useOpenAI } from "@/ai/useOpenAi";
+import { beginAllChatRuntimeDeletionFence } from "@/services/chatRuntimeDeletionFence";
+import { assertChatAccountCredential } from "@/services/chatAccountCredential";
+import {
+  cancelChatResponseForHistoryDeletion,
+  quiesceChatRuntimeRunsForHistoryDeletion,
+  settleChatRuntimeAfterHistoryCancellation
+} from "@/services/chatHistoryDeletionQuiescence";
 import {
   clearAgentDataForUser,
   clearMapleApiAuthForUser,
@@ -29,8 +38,10 @@ import { SettingsPage, SettingsSection } from "./SettingsPage";
 
 export function DeleteAccountSettings() {
   const os = useOpenSecret();
+  const openai = useOpenAI();
   const queryClient = useQueryClient();
   const { billingStatus } = useBillingState();
+  const runtimeStore = useChatRuntimeStore<unknown, unknown>();
   const [step, setStep] = useState<"request" | "confirm">("request");
   const [confirmationCode, setConfirmationCode] = useState("");
   const [secret, setSecret] = useState("");
@@ -60,8 +71,12 @@ export function DeleteAccountSettings() {
     setIsLoading(true);
     setError(null);
     try {
+      const expectedUserId = os.auth.user?.user.id;
+      assertChatAccountCredential(expectedUserId);
       const generatedSecret = generateSecureSecret();
-      await os.requestAccountDeletion(await hashSecret(generatedSecret));
+      const hashedSecret = await hashSecret(generatedSecret);
+      assertChatAccountCredential(expectedUserId);
+      await os.requestAccountDeletion(hashedSecret);
       setSecret(generatedSecret);
       setStep("confirm");
     } catch (requestError) {
@@ -75,6 +90,7 @@ export function DeleteAccountSettings() {
   const handleConfirmDeletion = async () => {
     setIsLoading(true);
     setError(null);
+    const releaseChatFence = beginAllChatRuntimeDeletionFence(runtimeStore);
     let deletionConfirmed = isAccountDeleted;
     let agentDataCleared = cleanupBlockRef.current !== null;
     let proxyReset = false;
@@ -82,6 +98,15 @@ export function DeleteAccountSettings() {
     const userId = os.auth.user?.user.id;
 
     try {
+      assertChatAccountCredential(userId);
+      await quiesceChatRuntimeRunsForHistoryDeletion({
+        store: runtimeStore,
+        responseOwnershipClient: openai,
+        cancelResponse: (responseId) => cancelChatResponseForHistoryDeletion(openai, responseId),
+        settleCancelledRun: (key, runToken) =>
+          settleChatRuntimeAfterHistoryCancellation(runtimeStore, key, runToken)
+      });
+
       if (!cleanupBlockRef.current) {
         // Clear local Agent data before the irreversible remote deletion.
         cleanupBlockRef.current = await clearAgentDataForUser(userId);
@@ -91,19 +116,28 @@ export function DeleteAccountSettings() {
       // Proxy credential reset is required before remote deletion so a crash
       // cannot leave a deleted account's key on disk.
       const { proxyService } = await import("@/services/proxyService");
-      await proxyService.stopAndResetProxy(userId, os.deleteApiKey);
+      await proxyService.stopAndResetProxy(userId, (name) => {
+        assertChatAccountCredential(userId);
+        return os.deleteApiKey(name);
+      });
       proxyReset = true;
 
       await clearMapleApiAuthForUser(userId);
       nativeAuthCleared = true;
 
       if (!deletionConfirmed) {
+        assertChatAccountCredential(userId);
         await os.confirmAccountDeletion(confirmationCode, secret);
         deletionConfirmed = true;
         setIsAccountDeleted(true);
         cleanupBlockRef.current.retainUntilNextSession();
       }
 
+      // The remote account no longer owns any renderable client state. Clear
+      // queued messages and attachment resources before credential cleanup,
+      // which can fail independently during a cross-tab account transition.
+      runtimeStore.clearAll();
+
       resetWorkspaceModePreference();
 
       try {
@@ -122,6 +156,7 @@ export function DeleteAccountSettings() {
       // If remote deletion did not happen, the authenticated user must be able
       // to start a fresh Agent runtime after this attempt.
       if (!deletionConfirmed) {
+        releaseChatFence();
         if (nativeAuthCleared) {
           try {
             await restoreMapleApiAuthForUser(userId);
diff --git a/frontend/src/components/settings/HistorySettings.tsx b/frontend/src/components/settings/HistorySettings.tsx
index 1b8f75e0d..ab65a86ae 100644
--- a/frontend/src/components/settings/HistorySettings.tsx
+++ b/frontend/src/components/settings/HistorySettings.tsx
@@ -5,12 +5,23 @@ import { useOpenSecret } from "@opensecret/react";
 import { Loader2, Trash2 } from "lucide-react";
 import { AlertDestructive } from "@/components/AlertDestructive";
 import { Button } from "@/components/ui/button";
+import { useChatRuntimeStore } from "@/contexts/ChatRuntimeContext";
 import { useSettingsNavigationLock } from "@/contexts/SettingsNavigationLockContext";
+import { useOpenAI } from "@/ai/useOpenAi";
 import { clearAgentHistoryForUser } from "@/services/agentRuntimeService";
+import {
+  cancelChatResponseForHistoryDeletion,
+  quiesceChatRuntimeRunsForHistoryDeletion,
+  settleChatRuntimeAfterHistoryCancellation
+} from "@/services/chatHistoryDeletionQuiescence";
+import { beginAllChatRuntimeDeletionFence } from "@/services/chatRuntimeDeletionFence";
+import { assertChatAccountCredential } from "@/services/chatAccountCredential";
 import { SettingsPage, SettingsSection } from "./SettingsPage";
 
 export function HistorySettings() {
   const os = useOpenSecret();
+  const openai = useOpenAI();
+  const runtimeStore = useChatRuntimeStore<unknown, unknown>();
   const navigate = useNavigate();
   const queryClient = useQueryClient();
   const [isConfirming, setIsConfirming] = useState(false);
@@ -25,16 +36,29 @@ export function HistorySettings() {
   useSettingsNavigationLock(isDeleting);
 
   const handleDeleteHistory = async () => {
+    const expectedUserId = os.auth.user?.user.id;
     setError(null);
     setIsDeleting(true);
+    const releaseDeletionFence = beginAllChatRuntimeDeletionFence(runtimeStore);
     let operationBlock: Awaited<ReturnType<typeof clearAgentHistoryForUser>> | null = null;
     try {
-      const conversations = await os.listConversations({ limit: 1 });
-      if (conversations.data?.length) {
-        await os.deleteConversations();
-      }
+      assertChatAccountCredential(expectedUserId);
+      await quiesceChatRuntimeRunsForHistoryDeletion({
+        store: runtimeStore,
+        responseOwnershipClient: openai,
+        cancelResponse: (responseId) => cancelChatResponseForHistoryDeletion(openai, responseId),
+        settleCancelledRun: (key, runToken) =>
+          settleChatRuntimeAfterHistoryCancellation(runtimeStore, key, runToken)
+      });
+
+      assertChatAccountCredential(expectedUserId);
+      await os.deleteConversations();
+      // Chat deletion is now confirmed (including the already-empty case).
+      // Clear server-deleted transcripts and client-only queues even if the
+      // separate Agent history cleanup below fails.
+      runtimeStore.clearAll();
 
-      operationBlock = await clearAgentHistoryForUser(os.auth.user?.user.id);
+      operationBlock = await clearAgentHistoryForUser(expectedUserId);
 
       queryClient.invalidateQueries({ queryKey: ["conversations"] });
       queryClient.invalidateQueries({ queryKey: ["pinnedConversations"] });
@@ -51,9 +75,12 @@ export function HistorySettings() {
       window.dispatchEvent(new CustomEvent("newchat", { detail: { projectId: null } }));
     } catch (deleteError) {
       console.error("Error deleting chat history:", deleteError);
+      // Preserve unresolved response ownership so a retry can still issue the
+      // server cancellation before any destructive request.
       setError("Maple could not delete all chat and task history. Please try again.");
     } finally {
       operationBlock?.release();
+      releaseDeletionFence();
       setIsDeleting(false);
     }
   };
diff --git a/frontend/src/components/settings/SettingsLayout.tsx b/frontend/src/components/settings/SettingsLayout.tsx
index 1544b1aa3..e59512172 100644
--- a/frontend/src/components/settings/SettingsLayout.tsx
+++ b/frontend/src/components/settings/SettingsLayout.tsx
@@ -25,6 +25,7 @@ import { useCompactSettingsLayout } from "@/components/settings/useCompactSettin
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { usePersistentHomeNavigation } from "@/contexts/PersistentHomeNavigationContext";
+import { useChatRuntimeStore } from "@/contexts/ChatRuntimeContext";
 import {
   useSettingsNavigationLock,
   useSettingsNavigationLockState
@@ -35,6 +36,8 @@ import {
   stopAgentRuntimeForUser
 } from "@/services/agentRuntimeService";
 import { resetWorkspaceModePreference } from "@/services/workspaceModePreference";
+import { beginAllChatRuntimeDeletionFence } from "@/services/chatRuntimeDeletionFence";
+import { assertChatAccountCredential } from "@/services/chatAccountCredential";
 import { useBillingState } from "@/state/useLocalState";
 import type { TeamStatus } from "@/types/team";
 import { isIOS } from "@/utils/platform";
@@ -132,6 +135,7 @@ function SettingsNavLink({
 
 function SettingsLayoutContent() {
   const os = useOpenSecret();
+  const runtimeStore = useChatRuntimeStore<unknown, unknown>();
   const router = useRouter();
   const location = useLocation();
   const queryClient = useQueryClient();
@@ -316,27 +320,47 @@ function SettingsLayoutContent() {
 
     setSignOutError(null);
     setIsSigningOut(true);
+    // Pause every client-only FIFO before awaited account cleanup can yield.
+    // If logout fails, releasing this fence does not orphan an accepted server
+    // response; committed account teardown still cancels the store itself.
+    const releaseChatFence = beginAllChatRuntimeDeletionFence(runtimeStore);
     let operationBlock: Awaited<ReturnType<typeof stopAgentRuntimeForUser>> | null = null;
     let signedOut = false;
     let nativeAuthCleared = false;
     const userId = os.auth.user?.user.id;
 
+    try {
+      assertChatAccountCredential(userId);
+    } catch (error) {
+      console.error("Account changed before sign out:", error);
+      releaseChatFence();
+      setSignOutError("Your account changed in another window. Refresh Maple before signing out.");
+      setIsSigningOut(false);
+      return;
+    }
+
     // Never sign out while this account may still have Agent tools executing.
     try {
       operationBlock = await stopAgentRuntimeForUser(userId);
     } catch (error) {
       console.error("Error stopping Agent Mode:", error);
+      releaseChatFence();
       setSignOutError("Maple could not stop Agent Mode. Please try logging out again.");
       setIsSigningOut(false);
       return;
     }
 
     try {
+      assertChatAccountCredential(userId);
       // Credential reset is required before logout so the next account cannot
       // inherit this user's local proxy key.
       const { proxyService } = await import("@/services/proxyService");
-      await proxyService.stopAndResetProxy(userId, os.deleteApiKey);
+      await proxyService.stopAndResetProxy(userId, (name) => {
+        assertChatAccountCredential(userId);
+        return os.deleteApiKey(name);
+      });
 
+      assertChatAccountCredential(userId);
       try {
         getBillingService().clearToken();
       } catch (error) {
@@ -346,6 +370,7 @@ function SettingsLayoutContent() {
 
       await clearMapleApiAuthForUser(userId);
       nativeAuthCleared = true;
+      assertChatAccountCredential(userId);
       await os.signOut();
       signedOut = true;
       resetWorkspaceModePreference();
@@ -363,6 +388,7 @@ function SettingsLayoutContent() {
       );
     } finally {
       if (!signedOut) {
+        releaseChatFence();
         if (nativeAuthCleared) {
           try {
             await restoreMapleApiAuthForUser(userId);
diff --git a/frontend/src/contexts/ChatRuntimeContext.test.ts b/frontend/src/contexts/ChatRuntimeContext.test.ts
index 945331c26..042d274cd 100644
--- a/frontend/src/contexts/ChatRuntimeContext.test.ts
+++ b/frontend/src/contexts/ChatRuntimeContext.test.ts
@@ -1,5 +1,10 @@
 import { describe, expect, spyOn, test } from "bun:test";
-import { createChatComposerState, createChatRuntimeStore } from "./ChatRuntimeContext";
+import {
+  composerHasRetainedDraft,
+  createChatComposerState,
+  createChatRuntimeStore
+} from "./ChatRuntimeContext";
+import { cancelActiveChatRuntimeRuns } from "@/services/chatRuntimeCancellation";
 import {
   draftScopeForRuntimeSelection,
   moveRememberedChatDraftToScope,
@@ -8,11 +13,66 @@ import {
   rootChatDraftKeyAfterProjectDeletion
 } from "../services/chatDraftSelection";
 import { createChatDraftKey, createConversationChatKey } from "../services/chatRuntimeStore";
+import {
+  mergeChatComposerDraftsForRekey,
+  type ChatQueuedMessage
+} from "../services/chatComposerQueue";
 
 type Conversation = { id: string };
 type Message = { id: string };
 
+function queuedMessage(id: string, overrides: Partial<ChatQueuedMessage> = {}): ChatQueuedMessage {
+  return {
+    queueId: `queue-${id}`,
+    messageId: `message-${id}`,
+    text: id,
+    draftImages: [],
+    imageUrls: new Map(),
+    documentText: "",
+    documentName: "",
+    draftProjectId: null,
+    model: "maple-model",
+    webSearchEnabled: false,
+    createdMs: 0,
+    ...overrides
+  };
+}
+
 describe("ChatRuntimeContext eviction policy", () => {
+  test("account teardown synchronously cancels every active queue runner", () => {
+    const store = createChatRuntimeStore<Conversation, Message>();
+    const firstKey = createConversationChatKey("first-running-conversation");
+    const secondKey = createConversationChatKey("second-running-conversation");
+    store.ensure(firstKey);
+    store.ensure(secondKey);
+    const first = store.beginRun(firstKey);
+    const second = store.beginRun(secondKey);
+
+    cancelActiveChatRuntimeRuns(store);
+
+    expect(first.signal.aborted).toBe(true);
+    expect(second.signal.aborted).toBe(true);
+    expect(store.getActiveRunKeys()).toEqual([]);
+    expect(store.get(firstKey)?.composer).toBeDefined();
+    expect(store.get(secondKey)?.composer).toBeDefined();
+  });
+
+  test("retains an idle runtime whose only unsent material is its queue", () => {
+    const store = createChatRuntimeStore<Conversation, Message>(0);
+    const queuedKey = createConversationChatKey("queued-conversation");
+    const nextKey = createConversationChatKey("next-conversation");
+    const composer = createChatComposerState();
+    composer.queue.items = [queuedMessage("retained")];
+
+    store.select(queuedKey, { composer });
+    store.select(nextKey, { conversation: { id: "next-conversation" } });
+
+    expect(store.get(queuedKey)?.composer.queue.items).toEqual([
+      expect.objectContaining({ queueId: "queue-retained" })
+    ]);
+    expect(composerHasRetainedDraft(queuedKey, composer)).toBe(true);
+  });
+
   test("retains and restores an idle draft with unsent composer content across selection", () => {
     const store = createChatRuntimeStore<Conversation, Message>(0);
     const draftKey = createChatDraftKey("retained-unsent-composer");
@@ -329,10 +389,19 @@ describe("ChatRuntimeContext eviction policy", () => {
     const firstAccountKey = createChatDraftKey("first-account");
     const secondAccountKey = createChatDraftKey("second-account");
     const image = new File(["private"], "private.png", { type: "image/png" });
+    const queuedImage = new File(["queued-private"], "queued-private.png", {
+      type: "image/png"
+    });
     const composer = createChatComposerState();
     composer.input = "first account draft";
     composer.draftImages = [image];
     composer.imageUrls.set(image, "blob:first-account");
+    composer.queue.items = [
+      queuedMessage("first-account-queued", {
+        draftImages: [queuedImage],
+        imageUrls: new Map([[queuedImage, "blob:first-account-queued"]])
+      })
+    ];
 
     try {
       firstAccountStore.select(firstAccountKey, { composer });
@@ -347,6 +416,7 @@ describe("ChatRuntimeContext eviction policy", () => {
 
       expect(run.signal.aborted).toBe(true);
       expect(revokeObjectURL).toHaveBeenCalledWith("blob:first-account");
+      expect(revokeObjectURL).toHaveBeenCalledWith("blob:first-account-queued");
       expect(secondAccountStore.getRememberedDraftKey(null)).toBe(secondAccountKey);
     } finally {
       firstAccountStore.dispose();
@@ -412,4 +482,82 @@ describe("ChatRuntimeContext eviction policy", () => {
       revokeObjectURL.mockRestore();
     }
   });
+
+  test("disposal revokes active and queued object URLs exactly once", () => {
+    const revokeObjectURL = spyOn(URL, "revokeObjectURL").mockImplementation(() => {});
+    const store = createChatRuntimeStore<Conversation, Message>();
+    const key = createChatDraftKey("queued-object-urls");
+    const activeFile = new File(["active"], "active.png", { type: "image/png" });
+    const queuedFile = new File(["queued"], "queued.png", { type: "image/png" });
+    const composer = createChatComposerState();
+    composer.draftImages = [activeFile];
+    composer.imageUrls.set(activeFile, "blob:shared");
+    composer.queue.items = [
+      queuedMessage("with-images", {
+        draftImages: [queuedFile],
+        imageUrls: new Map([
+          [activeFile, "blob:shared"],
+          [queuedFile, "blob:queued"]
+        ])
+      })
+    ];
+
+    try {
+      store.ensure(key, { composer });
+      store.dispose();
+
+      expect(revokeObjectURL).toHaveBeenCalledTimes(2);
+      expect(revokeObjectURL).toHaveBeenCalledWith("blob:shared");
+      expect(revokeObjectURL).toHaveBeenCalledWith("blob:queued");
+    } finally {
+      store.dispose();
+      revokeObjectURL.mockRestore();
+    }
+  });
+
+  test("draft adoption merges source and destination queues without losing composer text", () => {
+    const store = createChatRuntimeStore<Conversation, Message>();
+    const sourceKey = createChatDraftKey("queued-source");
+    const destinationKey = createConversationChatKey("queued-destination");
+    const sourceComposer = createChatComposerState("project-a");
+    sourceComposer.input = "source draft";
+    sourceComposer.queue.items = [queuedMessage("source", { createdMs: 20 })];
+    const destinationComposer = createChatComposerState();
+    destinationComposer.input = "destination draft";
+    destinationComposer.queue.items = [queuedMessage("destination", { createdMs: 10 })];
+
+    store.select(sourceKey, { composer: sourceComposer });
+    const run = store.beginRun(sourceKey);
+    store.ensure(destinationKey, {
+      conversation: { id: "queued-destination" },
+      composer: destinationComposer,
+      historyLoaded: true
+    });
+
+    expect(
+      store.rekeyRunAdoptingIdleDestination(
+        sourceKey,
+        destinationKey,
+        run.token,
+        (source, destination) => ({
+          ...source,
+          conversation: destination.conversation,
+          historyLoaded: destination.historyLoaded,
+          composer: mergeChatComposerDraftsForRekey(
+            source.composer,
+            destination.composer,
+            destinationKey
+          ).composer
+        })
+      )
+    ).toMatchObject({ status: "migrated", key: destinationKey });
+
+    expect(store.get(destinationKey)?.composer.input).toBe("destination draft\nsource draft");
+    expect(store.get(destinationKey)?.composer.queue.items.map((item) => item.queueId)).toEqual([
+      "queue-destination",
+      "queue-source"
+    ]);
+    expect(store.isRunCurrent(destinationKey, run.token)).toBe(true);
+    expect(store.get(sourceKey)).toBe(store.get(destinationKey));
+  });
 });
diff --git a/frontend/src/contexts/ChatRuntimeContext.tsx b/frontend/src/contexts/ChatRuntimeContext.tsx
index 742baf233..d0b5c4176 100644
--- a/frontend/src/contexts/ChatRuntimeContext.tsx
+++ b/frontend/src/contexts/ChatRuntimeContext.tsx
@@ -1,4 +1,4 @@
-import { createContext, useContext, useEffect, useMemo, type ReactNode } from "react";
+import { createContext, useContext, useLayoutEffect, useMemo, type ReactNode } from "react";
 import {
   ChatRuntimeStore,
   type ChatRuntimeKey,
@@ -6,6 +6,12 @@ import {
   type ChatRuntimeStoreOptions
 } from "@/services/chatRuntimeStore";
 import { createDeferredDisposalLifecycle } from "@/services/deferredDisposalLifecycle";
+import {
+  disposeChatComposerObjectUrls,
+  emptyChatComposerQueueState,
+  type ChatComposerQueueState
+} from "@/services/chatComposerQueue";
+import { cancelActiveChatRuntimeRuns } from "@/services/chatRuntimeCancellation";
 
 export type ChatPaginationState = {
   oldestItemId: string | undefined;
@@ -25,6 +31,7 @@ export type ChatComposerState = {
   audioError: string | null;
   imagePasteGeneration: number;
   documentUploadGeneration: number;
+  queue: ChatComposerQueueState;
   pagination: ChatPaginationState;
 };
 
@@ -41,6 +48,7 @@ export function createChatComposerState(draftProjectId: string | null = null): C
     audioError: null,
     imagePasteGeneration: 0,
     documentUploadGeneration: 0,
+    queue: emptyChatComposerQueueState(),
     pagination: {
       oldestItemId: undefined,
       isLoadingOlderMessages: false,
@@ -63,16 +71,16 @@ export function composerHasRetainedDraft(
     composer.draftImages.length > 0 ||
     composer.documentText.length > 0 ||
     composer.documentName.length > 0 ||
-    composer.isProcessingDocument
+    composer.isProcessingDocument ||
+    composer.queue.items.length > 0 ||
+    composer.queue.edit !== null
   );
 }
 
 function disposeComposerResources(
   snapshot: ChatRuntimeSnapshot<unknown, unknown, ChatComposerState>
 ): void {
-  for (const url of snapshot.composer.imageUrls.values()) {
-    URL.revokeObjectURL(url);
-  }
+  disposeChatComposerObjectUrls(snapshot.composer);
 }
 
 export function createChatRuntimeStore<TConversation = unknown, TMessage = unknown>(
@@ -103,7 +111,16 @@ export function ChatRuntimeProvider({ children }: { children: ReactNode }) {
     [store]
   );
 
-  useEffect(() => disposalLifecycle.activate(), [disposalLifecycle]);
+  useLayoutEffect(() => {
+    const scheduleDisposal = disposalLifecycle.activate();
+    return () => {
+      // Account-keyed provider teardown must fence an old account's FIFO
+      // synchronously. Resource disposal stays deferred for Strict Mode replay,
+      // but no queued request may advance during that deferral window.
+      cancelActiveChatRuntimeRuns(store);
+      scheduleDisposal();
+    };
+  }, [disposalLifecycle, store]);
 
   return <ChatRuntimeContext.Provider value={store}>{children}</ChatRuntimeContext.Provider>;
 }
diff --git a/frontend/src/services/agentComposerQueue.test.ts b/frontend/src/services/agentComposerQueue.test.ts
index 1e10b107c..4d2594157 100644
--- a/frontend/src/services/agentComposerQueue.test.ts
+++ b/frontend/src/services/agentComposerQueue.test.ts
@@ -101,6 +101,28 @@ describe("agent composer queue projection", () => {
     expect(queuedMessageEditStillPresent(second!.edit, [queued("q1", "oldest")])).toBe(false);
   });
 
+  test("preserves the Agent session-keyed edit API over the shared helper", () => {
+    const next = beginQueuedMessageEdit({
+      current: {
+        sessionId: "session-1",
+        queueId: "q1",
+        stashedDraft: "session one draft"
+      },
+      sessionId: "session-2",
+      item: queued("q2", "session two queued"),
+      composerText: "session two draft"
+    });
+
+    expect(next).toEqual({
+      edit: {
+        sessionId: "session-2",
+        queueId: "q2",
+        stashedDraft: "session two draft"
+      },
+      composer: "session two queued"
+    });
+  });
+
   test("does not seed thought tracking for a staged follow-up", () => {
     expect(shouldPrepareThoughtAfterAgentSend(undefined)).toBe(true);
     expect(shouldPrepareThoughtAfterAgentSend(null)).toBe(true);
diff --git a/frontend/src/services/agentComposerQueue.ts b/frontend/src/services/agentComposerQueue.ts
index f14739e68..5922cfa36 100644
--- a/frontend/src/services/agentComposerQueue.ts
+++ b/frontend/src/services/agentComposerQueue.ts
@@ -1,3 +1,9 @@
+import {
+  beginQueuedMessageEdit as beginSharedQueuedMessageEdit,
+  discardQueuedMessageEdit as discardSharedQueuedMessageEdit,
+  queuedMessageEditStillPresent as sharedQueuedMessageEditStillPresent
+} from "./composerQueue";
+
 export interface AgentQueuedMessage {
   queueId: string;
   messageId: string;
@@ -59,28 +65,51 @@ export function beginQueuedMessageEdit({
   item: AgentQueuedMessage;
   composerText: string;
 }): { edit: AgentQueuedMessageEdit; composer: string } | null {
-  if (current?.sessionId === sessionId && current.queueId === item.queueId) {
-    return null;
-  }
+  const result = beginSharedQueuedMessageEdit({
+    current: current
+      ? {
+          scopeKey: current.sessionId,
+          queueId: current.queueId,
+          stashedDraft: current.stashedDraft
+        }
+      : null,
+    scopeKey: sessionId,
+    item,
+    composerText
+  });
+  if (!result) return null;
   return {
     edit: {
-      sessionId,
-      queueId: item.queueId,
-      stashedDraft: current?.sessionId === sessionId ? current.stashedDraft : composerText
+      sessionId: result.edit.scopeKey,
+      queueId: result.edit.queueId,
+      stashedDraft: result.edit.stashedDraft
     },
-    composer: item.text
+    composer: result.composer
   };
 }
 
 export function discardQueuedMessageEdit(edit: AgentQueuedMessageEdit): string {
-  return edit.stashedDraft;
+  return discardSharedQueuedMessageEdit({
+    scopeKey: edit.sessionId,
+    queueId: edit.queueId,
+    stashedDraft: edit.stashedDraft
+  });
 }
 
 export function queuedMessageEditStillPresent(
   edit: AgentQueuedMessageEdit | null,
   items: AgentQueuedMessage[]
 ): boolean {
-  return Boolean(edit && items.some((item) => item.queueId === edit.queueId));
+  return sharedQueuedMessageEditStillPresent(
+    edit
+      ? {
+          scopeKey: edit.sessionId,
+          queueId: edit.queueId,
+          stashedDraft: edit.stashedDraft
+        }
+      : null,
+    items
+  );
 }
 
 export function shouldPrepareThoughtAfterAgentSend(queued?: AgentQueuedMessage | null): boolean {
diff --git a/frontend/src/services/chatAccountCredential.test.ts b/frontend/src/services/chatAccountCredential.test.ts
new file mode 100644
index 000000000..324517156
--- /dev/null
+++ b/frontend/src/services/chatAccountCredential.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, test } from "bun:test";
+import {
+  CHAT_ACCOUNT_CREDENTIAL_MISMATCH_CODE,
+  ChatAccountCredentialMismatchError,
+  assertChatAccountCredential,
+  chatAccessTokenSubject,
+  createAccountBoundChatFetch,
+  isChatAccountCredentialMismatchError
+} from "./chatAccountCredential";
+
+function tokenForSubject(subject: string): string {
+  const encode = (value: object) =>
+    btoa(JSON.stringify(value)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return `${encode({ alg: "ES256K", typ: "JWT" })}.${encode({ sub: subject })}.signature`;
+}
+
+describe("account-bound Chat credentials", () => {
+  test("extracts a JWT subject and rejects malformed credentials", () => {
+    expect(chatAccessTokenSubject(tokenForSubject("user-a"))).toBe("user-a");
+    expect(chatAccessTokenSubject("not-a-jwt")).toBeNull();
+    expect(chatAccessTokenSubject(null)).toBeNull();
+  });
+
+  test("allows refreshed tokens for the same account", async () => {
+    let token = tokenForSubject("user-a");
+    const calls: string[] = [];
+    const fetch = createAccountBoundChatFetch({
+      expectedUserId: "user-a",
+      getAccessToken: () => token,
+      fetch: async (input) => {
+        calls.push(String(input));
+        return Response.json({ ok: true });
+      }
+    });
+
+    await fetch("https://example.test/first");
+    token = tokenForSubject("user-a");
+    await fetch("https://example.test/after-refresh");
+
+    expect(calls).toEqual(["https://example.test/first", "https://example.test/after-refresh"]);
+  });
+
+  test("blocks a replaced account before invoking the transport", async () => {
+    let called = false;
+    const fetch = createAccountBoundChatFetch({
+      expectedUserId: "user-a",
+      getAccessToken: () => tokenForSubject("user-b"),
+      fetch: async () => {
+        called = true;
+        return Response.json({ ok: true });
+      }
+    });
+
+    try {
+      await fetch("https://example.test/blocked");
+      throw new Error("expected account-bound fetch to reject");
+    } catch (error) {
+      expect(isChatAccountCredentialMismatchError(error)).toBe(true);
+      expect(error).toMatchObject({
+        code: CHAT_ACCOUNT_CREDENTIAL_MISMATCH_CODE,
+        requestDispatchCode: "opensecret_request_not_dispatched",
+        definitelyNotDispatched: true
+      });
+    }
+    expect(called).toBe(false);
+  });
+
+  test("guards non-Chat account operations with the same account identity", () => {
+    expect(() =>
+      assertChatAccountCredential("user-a", () => tokenForSubject("user-a"))
+    ).not.toThrow();
+    expect(() => assertChatAccountCredential("user-a", () => tokenForSubject("user-b"))).toThrow(
+      ChatAccountCredentialMismatchError
+    );
+    expect(() => assertChatAccountCredential(undefined, () => tokenForSubject("user-a"))).toThrow(
+      ChatAccountCredentialMismatchError
+    );
+  });
+
+  test("recognizes an OpenAI-style wrapped mismatch", () => {
+    const mismatch = { code: CHAT_ACCOUNT_CREDENTIAL_MISMATCH_CODE };
+    expect(isChatAccountCredentialMismatchError({ cause: mismatch })).toBe(true);
+    expect(isChatAccountCredentialMismatchError(new Error("network"))).toBe(false);
+  });
+});
diff --git a/frontend/src/services/chatAccountCredential.ts b/frontend/src/services/chatAccountCredential.ts
new file mode 100644
index 000000000..698d217f2
--- /dev/null
+++ b/frontend/src/services/chatAccountCredential.ts
@@ -0,0 +1,89 @@
+export const CHAT_ACCOUNT_CREDENTIAL_MISMATCH_CODE = "chat_account_credential_mismatch";
+const REQUEST_NOT_DISPATCHED_CODE = "opensecret_request_not_dispatched";
+
+type AccountBoundFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+function decodeBase64Url(value: string): string {
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+  return atob(padded);
+}
+
+export function chatAccessTokenSubject(accessToken: string | null): string | null {
+  if (!accessToken) return null;
+  try {
+    const parts = accessToken.split(".");
+    if (parts.length !== 3 || !parts[1]) return null;
+    const payload = JSON.parse(decodeBase64Url(parts[1])) as { sub?: unknown };
+    return typeof payload.sub === "string" && payload.sub ? payload.sub : null;
+  } catch {
+    return null;
+  }
+}
+
+export class ChatAccountCredentialMismatchError extends Error {
+  readonly code = CHAT_ACCOUNT_CREDENTIAL_MISMATCH_CODE;
+
+  constructor() {
+    super("The authenticated Chat account changed before this request could start");
+    this.name = "ChatAccountCredentialMismatchError";
+  }
+}
+
+/**
+ * Fails a user-scoped operation closed when another tab has replaced the
+ * browser credentials since this React tree was rendered.
+ */
+export function assertChatAccountCredential(
+  expectedUserId: string | undefined,
+  getAccessToken: () => string | null = () => window.localStorage.getItem("access_token")
+): void {
+  if (!expectedUserId || chatAccessTokenSubject(getAccessToken()) !== expectedUserId) {
+    throw new ChatAccountCredentialMismatchError();
+  }
+}
+
+/**
+ * Binds every Chat network request to the account that created its OpenAI
+ * client. Access-token refreshes remain valid because the stable JWT subject,
+ * rather than the token bytes, is compared. Cross-tab account replacement
+ * fails before plaintext is handed to the encrypted transport.
+ */
+export function createAccountBoundChatFetch({
+  expectedUserId,
+  getAccessToken,
+  fetch
+}: {
+  expectedUserId: string | undefined;
+  getAccessToken: () => string | null;
+  fetch: AccountBoundFetch;
+}): AccountBoundFetch {
+  return (input, init) => {
+    try {
+      assertChatAccountCredential(expectedUserId, getAccessToken);
+    } catch (error) {
+      if (typeof error === "object" && error !== null) {
+        Object.assign(error, {
+          requestDispatchCode: REQUEST_NOT_DISPATCHED_CODE,
+          definitelyNotDispatched: true
+        });
+      }
+      return Promise.reject(error);
+    }
+    return fetch(input, init);
+  };
+}
+
+export function isChatAccountCredentialMismatchError(error: unknown): boolean {
+  let current = error;
+  for (let depth = 0; depth < 3 && current && typeof current === "object"; depth += 1) {
+    if (
+      current instanceof ChatAccountCredentialMismatchError ||
+      ("code" in current && current.code === CHAT_ACCOUNT_CREDENTIAL_MISMATCH_CODE)
+    ) {
+      return true;
+    }
+    current = "cause" in current ? current.cause : undefined;
+  }
+  return false;
+}
diff --git a/frontend/src/services/chatAccountQueueBudget.test.ts b/frontend/src/services/chatAccountQueueBudget.test.ts
new file mode 100644
index 000000000..0bbf34bfb
--- /dev/null
+++ b/frontend/src/services/chatAccountQueueBudget.test.ts
@@ -0,0 +1,170 @@
+import { describe, expect, test } from "bun:test";
+import { chatAccountQueueUsage, selectChatImageFilesForRetention } from "./chatAccountQueueBudget";
+import { registerChatCurrentTurn } from "./chatCurrentTurnRegistry";
+import {
+  MAX_CHAT_ACCOUNT_RETAINED_IMAGES,
+  MAX_CHAT_QUEUED_IMAGES_PER_ITEM,
+  type ChatAccountQueueUsage,
+  type ChatQueuedMessage
+} from "./chatComposerQueue";
+
+function item(id: string, file: File, documentText = ""): ChatQueuedMessage {
+  return {
+    queueId: `queue-${id}`,
+    messageId: `message-${id}`,
+    text: id,
+    draftImages: [file],
+    imageUrls: new Map([[file, `blob:${id}`]]),
+    documentText,
+    documentName: "document.txt",
+    draftProjectId: null,
+    model: "maple-model",
+    webSearchEnabled: false,
+    createdMs: 0
+  };
+}
+
+describe("chat account queue budget", () => {
+  test("counts retained drafts and queues across runtimes without double-counting files", () => {
+    const sharedFile = new File([new Uint8Array(7)], "shared.png");
+    const queued = item("queued", sharedFile, "four");
+    const store = {
+      getSnapshots: () => [
+        {
+          composer: {
+            draftImages: [sharedFile],
+            imageUrls: new Map([[sharedFile, "blob:draft"]]),
+            documentText: "abc",
+            queue: { items: [queued] }
+          }
+        },
+        {
+          composer: {
+            draftImages: [],
+            imageUrls: new Map<File, string>(),
+            documentText: "",
+            queue: { items: [] }
+          }
+        }
+      ]
+    };
+
+    expect(chatAccountQueueUsage(store)).toEqual({
+      queuedMessageCount: 1,
+      attachmentBytes: 7 + 3 + 4,
+      imageCount: 1
+    });
+  });
+
+  test("keeps a popped FIFO item reserved and deduplicates it after recovery", () => {
+    const file = new File([new Uint8Array(11)], "queued.png");
+    const queued = item("active", file, "doc");
+    let recoveredItems: ChatQueuedMessage[] = [];
+    const store = {
+      getSnapshots: () => [
+        {
+          composer: {
+            draftImages: [],
+            imageUrls: new Map<File, string>(),
+            documentText: "",
+            queue: { items: recoveredItems }
+          }
+        }
+      ]
+    };
+    registerChatCurrentTurn(store, 1, {
+      responseRequestStarted: () => false,
+      restoreBeforeRequest: () => true,
+      retainedPayload: queued,
+      countsTowardQueueLimit: true
+    });
+
+    expect(chatAccountQueueUsage(store)).toEqual({
+      queuedMessageCount: 1,
+      attachmentBytes: 14,
+      imageCount: 1
+    });
+    recoveredItems = [queued];
+    expect(chatAccountQueueUsage(store)).toEqual({
+      queuedMessageCount: 1,
+      attachmentBytes: 14,
+      imageCount: 1
+    });
+  });
+
+  test("selects an ordered prefix within the live-message image limit", () => {
+    const existingFiles = Array.from(
+      { length: MAX_CHAT_QUEUED_IMAGES_PER_ITEM - 1 },
+      (_, index) => new File([], `existing-${index}.png`, { type: "image/png" })
+    );
+    const first = new File([], "first.png", { type: "image/png" });
+    const second = new File([], "second.png", { type: "image/png" });
+    const accountUsage: ChatAccountQueueUsage = {
+      queuedMessageCount: 0,
+      attachmentBytes: 0,
+      imageCount: existingFiles.length
+    };
+
+    const selected = selectChatImageFilesForRetention({
+      composer: { draftImages: existingFiles, imageUrls: new Map() },
+      candidates: [first, second],
+      accountUsage
+    });
+
+    expect(selected.files).toEqual([first]);
+    expect(selected.messageLimitExceeded).toBe(true);
+    expect(selected.accountLimitExceeded).toBe(false);
+  });
+
+  test("admits only the remaining account slot, including for zero-byte images", () => {
+    const first = new File([], "first.png", { type: "image/png" });
+    const second = new File([], "second.png", { type: "image/png" });
+    const accountUsage: ChatAccountQueueUsage = {
+      queuedMessageCount: 0,
+      attachmentBytes: 0,
+      imageCount: MAX_CHAT_ACCOUNT_RETAINED_IMAGES - 1
+    };
+
+    const selected = selectChatImageFilesForRetention({
+      composer: { draftImages: [], imageUrls: new Map() },
+      candidates: [first, second],
+      accountUsage
+    });
+    const full = selectChatImageFilesForRetention({
+      composer: { draftImages: [], imageUrls: new Map() },
+      candidates: [first],
+      accountUsage: { ...accountUsage, imageCount: MAX_CHAT_ACCOUNT_RETAINED_IMAGES }
+    });
+
+    expect(selected.files).toEqual([first]);
+    expect(selected.accountLimitExceeded).toBe(true);
+    expect(selected.messageLimitExceeded).toBe(false);
+    expect(full.files).toEqual([]);
+    expect(full.accountLimitExceeded).toBe(true);
+  });
+
+  test("ignores repeated and already-owned File identities", () => {
+    const existing = new File([], "existing.png", { type: "image/png" });
+    const added = new File([], "added.png", { type: "image/png" });
+    const accountUsage: ChatAccountQueueUsage = {
+      queuedMessageCount: 0,
+      attachmentBytes: 0,
+      imageCount: 1
+    };
+
+    const selected = selectChatImageFilesForRetention({
+      composer: {
+        draftImages: [existing],
+        imageUrls: new Map([[existing, "blob:existing"]])
+      },
+      candidates: [existing, existing, added, added],
+      accountUsage
+    });
+
+    expect(selected).toEqual({
+      files: [added],
+      accountLimitExceeded: false,
+      messageLimitExceeded: false
+    });
+  });
+});
diff --git a/frontend/src/services/chatAccountQueueBudget.ts b/frontend/src/services/chatAccountQueueBudget.ts
new file mode 100644
index 000000000..a4ec45858
--- /dev/null
+++ b/frontend/src/services/chatAccountQueueBudget.ts
@@ -0,0 +1,118 @@
+import {
+  chatQueuedTextByteLength,
+  MAX_CHAT_ACCOUNT_RETAINED_IMAGES,
+  MAX_CHAT_QUEUED_IMAGES_PER_ITEM,
+  type ChatAccountQueueUsage,
+  type ChatComposerDraft,
+  type ChatQueuedMessage
+} from "./chatComposerQueue";
+import { getRegisteredChatCurrentTurnPayloads } from "./chatCurrentTurnRegistry";
+
+type RetainedChatComposer = Readonly<{
+  draftImages: readonly File[];
+  imageUrls: ReadonlyMap<File, string>;
+  documentText: string;
+  queue: Readonly<{ items: readonly ChatQueuedMessage[] }>;
+}>;
+
+type ChatAccountRuntimeLookup = object & {
+  getSnapshots: () => readonly Readonly<{ composer: RetainedChatComposer }>[];
+};
+
+export type ChatImageFileSelection = Readonly<{
+  files: readonly File[];
+  accountLimitExceeded: boolean;
+  messageLimitExceeded: boolean;
+}>;
+
+function isChatQueuedMessage(payload: unknown): payload is ChatQueuedMessage {
+  return Boolean(
+    payload &&
+    typeof payload === "object" &&
+    "queueId" in payload &&
+    typeof payload.queueId === "string" &&
+    "draftImages" in payload &&
+    Array.isArray(payload.draftImages) &&
+    "imageUrls" in payload &&
+    payload.imageUrls instanceof Map &&
+    "documentText" in payload &&
+    typeof payload.documentText === "string"
+  );
+}
+
+/**
+ * Counts account-scoped attachment ownership and staged messages exactly once,
+ * including a FIFO item temporarily popped into the active send loop.
+ */
+export function chatAccountQueueUsage(store: ChatAccountRuntimeLookup): ChatAccountQueueUsage {
+  const seenFiles = new Set<File>();
+  const seenQueueItems = new Set<ChatQueuedMessage>();
+  let queuedMessageCount = 0;
+  let documentBytes = 0;
+
+  const addFile = (file: File) => {
+    if (seenFiles.has(file)) return;
+    seenFiles.add(file);
+  };
+  const addItem = (item: ChatQueuedMessage, countsTowardQueueLimit: boolean) => {
+    if (seenQueueItems.has(item)) return;
+    seenQueueItems.add(item);
+    if (countsTowardQueueLimit) queuedMessageCount += 1;
+    documentBytes += chatQueuedTextByteLength(item.documentText);
+    for (const file of item.draftImages) addFile(file);
+    for (const file of item.imageUrls.keys()) addFile(file);
+  };
+
+  for (const { composer } of store.getSnapshots()) {
+    documentBytes += chatQueuedTextByteLength(composer.documentText);
+    for (const file of composer.draftImages) addFile(file);
+    for (const file of composer.imageUrls.keys()) addFile(file);
+    for (const item of composer.queue.items) addItem(item, true);
+  }
+  for (const current of getRegisteredChatCurrentTurnPayloads(store)) {
+    if (isChatQueuedMessage(current.payload)) {
+      addItem(current.payload, current.countsTowardQueueLimit);
+    }
+  }
+
+  let attachmentBytes = documentBytes;
+  for (const file of seenFiles) attachmentBytes += file.size;
+  return { queuedMessageCount, attachmentBytes, imageCount: seenFiles.size };
+}
+
+/**
+ * Selects the prefix of new image Files that fits both the live-message and
+ * account-wide retained-image limits. Existing and repeated File identities
+ * are ignored, so callers never need to create a replacement blob URL for an
+ * image the composer already owns.
+ */
+export function selectChatImageFilesForRetention({
+  composer,
+  candidates,
+  accountUsage
+}: {
+  composer: Pick<ChatComposerDraft, "draftImages" | "imageUrls">;
+  candidates: readonly File[];
+  accountUsage: ChatAccountQueueUsage;
+}): ChatImageFileSelection {
+  const existingFiles = new Set(composer.draftImages);
+  for (const file of composer.imageUrls.keys()) existingFiles.add(file);
+
+  const uniqueCandidates: File[] = [];
+  const seenCandidates = new Set(existingFiles);
+  for (const file of candidates) {
+    if (seenCandidates.has(file)) continue;
+    seenCandidates.add(file);
+    uniqueCandidates.push(file);
+  }
+
+  const messageCapacity = Math.max(0, MAX_CHAT_QUEUED_IMAGES_PER_ITEM - existingFiles.size);
+  const accountCapacity = Math.max(0, MAX_CHAT_ACCOUNT_RETAINED_IMAGES - accountUsage.imageCount);
+  const files = uniqueCandidates.slice(0, Math.min(messageCapacity, accountCapacity));
+
+  return {
+    files,
+    messageLimitExceeded: uniqueCandidates.length > messageCapacity,
+    accountLimitExceeded: uniqueCandidates.length > accountCapacity
+  };
+}
diff --git a/frontend/src/services/chatComposerQueue.test.ts b/frontend/src/services/chatComposerQueue.test.ts
new file mode 100644
index 000000000..0527f5042
--- /dev/null
+++ b/frontend/src/services/chatComposerQueue.test.ts
@@ -0,0 +1,707 @@
+import { describe, expect, test } from "bun:test";
+import {
+  MAX_CHAT_ACCOUNT_RETAINED_ATTACHMENT_BYTES,
+  MAX_CHAT_ACCOUNT_RETAINED_QUEUE_MESSAGES,
+  MAX_CHAT_QUEUED_AGGREGATE_ATTACHMENT_BYTES,
+  MAX_CHAT_QUEUED_DOCUMENT_BYTES,
+  MAX_CHAT_QUEUED_IMAGE_BYTES,
+  MAX_CHAT_QUEUED_IMAGES_PER_ITEM,
+  MAX_CHAT_QUEUED_MESSAGES,
+  MAX_CHAT_QUEUED_TEXT_BYTES,
+  beginChatQueuedMessageEdit,
+  cancelChatQueuedMessage,
+  chatComposerObjectUrls,
+  detachChatComposerDraft,
+  discardChatQueuedMessageEdit,
+  emptyChatComposerQueueState,
+  enqueueChatQueuedMessage,
+  mergeChatComposerDraftsForRekey,
+  queuedChatMessageEditStillPresent,
+  recoverDetachedChatComposerDraft,
+  stageChatComposerDraft,
+  takeNextChatQueuedMessage,
+  updateChatQueuedMessage,
+  type ChatComposerDraft,
+  type ChatComposerQueueState,
+  type ChatQueuedMessage
+} from "./chatComposerQueue";
+
+function queuedMessage(
+  id: string,
+  text = id,
+  overrides: Partial<ChatQueuedMessage> = {}
+): ChatQueuedMessage {
+  return {
+    queueId: `queue-${id}`,
+    messageId: `message-${id}`,
+    text,
+    draftImages: [],
+    imageUrls: new Map(),
+    documentText: "",
+    documentName: "",
+    draftProjectId: null,
+    model: "maple-model",
+    webSearchEnabled: false,
+    createdMs: 0,
+    ...overrides
+  };
+}
+
+function composer(input = "", overrides: Partial<ChatComposerDraft> = {}): ChatComposerDraft {
+  return {
+    input,
+    draftImages: [],
+    imageUrls: new Map(),
+    documentText: "",
+    documentName: "",
+    draftProjectId: null,
+    isProcessingDocument: false,
+    imagePasteGeneration: 0,
+    documentUploadGeneration: 0,
+    queue: emptyChatComposerQueueState(),
+    ...overrides
+  };
+}
+
+function queueWith(...items: ChatQueuedMessage[]): ChatComposerQueueState {
+  return { items, edit: null };
+}
+
+function imageWithSize(name: string, size: number): File {
+  const file = new File([], name, { type: "image/png" });
+  Object.defineProperty(file, "size", { value: size });
+  return file;
+}
+
+describe("chat composer queue", () => {
+  test("takes messages in FIFO order", () => {
+    let queue = emptyChatComposerQueueState();
+    for (const item of [queuedMessage("first"), queuedMessage("second")]) {
+      const result = enqueueChatQueuedMessage(queue, item);
+      expect(result.status).toBe("enqueued");
+      if (result.status === "enqueued") queue = result.queue;
+    }
+
+    const first = takeNextChatQueuedMessage(queue);
+    expect(first.status).toBe("taken");
+    if (first.status !== "taken") throw new Error("expected the first queued message");
+    expect(first.item.queueId).toBe("queue-first");
+
+    const second = takeNextChatQueuedMessage(first.queue);
+    expect(second.status).toBe("taken");
+    if (second.status !== "taken") throw new Error("expected the second queued message");
+    expect(second.item.queueId).toBe("queue-second");
+    expect(takeNextChatQueuedMessage(second.queue).status).toBe("empty");
+  });
+
+  test("enforces the normal item limit and UTF-8 staged-text limit", () => {
+    let queue = emptyChatComposerQueueState();
+    for (let index = 0; index < MAX_CHAT_QUEUED_MESSAGES; index += 1) {
+      const result = enqueueChatQueuedMessage(queue, queuedMessage(String(index)));
+      expect(result.status).toBe("enqueued");
+      if (result.status === "enqueued") queue = result.queue;
+    }
+
+    const full = enqueueChatQueuedMessage(queue, queuedMessage("overflow"));
+    expect(full.status).toBe("queue_full");
+    expect(full.queue).toBe(queue);
+
+    const exactUtf8Limit = "é".repeat(MAX_CHAT_QUEUED_TEXT_BYTES / 2);
+    expect(
+      enqueueChatQueuedMessage(
+        emptyChatComposerQueueState(),
+        queuedMessage("exact", exactUtf8Limit)
+      ).status
+    ).toBe("enqueued");
+    expect(
+      enqueueChatQueuedMessage(
+        emptyChatComposerQueueState(),
+        queuedMessage("too-large", `${exactUtf8Limit}a`)
+      ).status
+    ).toBe("text_too_large");
+  });
+
+  test("enforces account-wide queued-message and retained-attachment budgets", () => {
+    const queue = emptyChatComposerQueueState();
+    const candidate = queuedMessage("account-candidate");
+    expect(
+      enqueueChatQueuedMessage(queue, candidate, {
+        queuedMessageCount: MAX_CHAT_ACCOUNT_RETAINED_QUEUE_MESSAGES,
+        attachmentBytes: 0,
+        imageCount: 0
+      }).status
+    ).toBe("account_queue_full");
+    expect(
+      enqueueChatQueuedMessage(queue, candidate, {
+        queuedMessageCount: 0,
+        attachmentBytes: MAX_CHAT_ACCOUNT_RETAINED_ATTACHMENT_BYTES + 1,
+        imageCount: 0
+      }).status
+    ).toBe("account_payload_too_large");
+  });
+
+  test("enforces per-item image and UTF-8 document payload limits", () => {
+    const exactImages = Array.from({ length: MAX_CHAT_QUEUED_IMAGES_PER_ITEM }, (_, index) =>
+      imageWithSize(`exact-count-${index}.png`, 1)
+    );
+    expect(
+      enqueueChatQueuedMessage(
+        emptyChatComposerQueueState(),
+        queuedMessage("exact-image-count", "", { draftImages: exactImages })
+      ).status
+    ).toBe("enqueued");
+    expect(
+      enqueueChatQueuedMessage(
+        emptyChatComposerQueueState(),
+        queuedMessage("too-many-images", "", {
+          draftImages: [...exactImages, imageWithSize("one-too-many.png", 1)]
+        })
+      ).status
+    ).toBe("too_many_images");
+    const mapOnlyImages = Array.from({ length: MAX_CHAT_QUEUED_IMAGES_PER_ITEM + 1 }, (_, index) =>
+      imageWithSize(`map-only-${index}.png`, 1)
+    );
+    expect(
+      enqueueChatQueuedMessage(
+        emptyChatComposerQueueState(),
+        queuedMessage("too-many-map-owned-images", "text", {
+          imageUrls: new Map(mapOnlyImages.map((image) => [image, `blob:${image.name}`]))
+        })
+      ).status
+    ).toBe("too_many_images");
+
+    expect(
+      enqueueChatQueuedMessage(
+        emptyChatComposerQueueState(),
+        queuedMessage("exact-image-size", "", {
+          draftImages: [imageWithSize("exact-size.png", MAX_CHAT_QUEUED_IMAGE_BYTES)]
+        })
+      ).status
+    ).toBe("enqueued");
+    expect(
+      enqueueChatQueuedMessage(
+        emptyChatComposerQueueState(),
+        queuedMessage("large-image", "", {
+          draftImages: [imageWithSize("too-large.png", MAX_CHAT_QUEUED_IMAGE_BYTES + 1)]
+        })
+      ).status
+    ).toBe("image_too_large");
+
+    const exactDocument = "é".repeat(MAX_CHAT_QUEUED_DOCUMENT_BYTES / 2);
+    expect(
+      enqueueChatQueuedMessage(
+        emptyChatComposerQueueState(),
+        queuedMessage("exact-document", "", { documentText: exactDocument })
+      ).status
+    ).toBe("enqueued");
+    expect(
+      enqueueChatQueuedMessage(
+        emptyChatComposerQueueState(),
+        queuedMessage("large-document", "", { documentText: `${exactDocument}d` })
+      ).status
+    ).toBe("document_too_large");
+  });
+
+  test("accepts the exact aggregate attachment limit and rejects one byte more", () => {
+    const mebibyte = 1024 * 1024;
+    const existing = queuedMessage("aggregate-existing", "", {
+      draftImages: Array.from({ length: MAX_CHAT_QUEUED_IMAGES_PER_ITEM }, (_, index) =>
+        imageWithSize(`existing-${index}.png`, MAX_CHAT_QUEUED_IMAGE_BYTES)
+      ),
+      documentText: "d".repeat(MAX_CHAT_QUEUED_DOCUMENT_BYTES)
+    });
+    const initialQueue = queueWith(existing);
+    const exactCandidate = queuedMessage("aggregate-exact", "", {
+      draftImages: [
+        imageWithSize("exact-a.png", 18 * mebibyte),
+        imageWithSize("exact-b.png", 18 * mebibyte)
+      ],
+      documentText: "d".repeat(10 * mebibyte)
+    });
+
+    expect(
+      10 * MAX_CHAT_QUEUED_IMAGE_BYTES +
+        MAX_CHAT_QUEUED_DOCUMENT_BYTES +
+        36 * mebibyte +
+        10 * mebibyte
+    ).toBe(MAX_CHAT_QUEUED_AGGREGATE_ATTACHMENT_BYTES);
+    expect(enqueueChatQueuedMessage(initialQueue, exactCandidate).status).toBe("enqueued");
+
+    const overCandidate = queuedMessage("aggregate-over", "", {
+      draftImages: [
+        imageWithSize("over-a.png", 18 * mebibyte),
+        imageWithSize("over-b.png", 18 * mebibyte + 1)
+      ],
+      documentText: "d".repeat(10 * mebibyte)
+    });
+    expect(enqueueChatQueuedMessage(initialQueue, overCandidate)).toMatchObject({
+      status: "queue_payload_too_large",
+      queue: initialQueue
+    });
+  });
+
+  test("holds FIFO promotion during an edit and restores the stashed text", () => {
+    const first = queuedMessage("first", "first text");
+    const second = queuedMessage("second", "second text");
+    const started = beginChatQueuedMessageEdit(
+      queueWith(first, second),
+      "conversation:one",
+      second.queueId,
+      "new draft"
+    );
+
+    expect(started.status).toBe("started");
+    if (started.status !== "started") throw new Error("expected edit to start");
+    expect(started.input).toBe("second text");
+    expect(started.queue.edit).toEqual({
+      scopeKey: "conversation:one",
+      queueId: second.queueId,
+      stashedDraft: "new draft"
+    });
+    expect(queuedChatMessageEditStillPresent(started.queue)).toBe(true);
+    expect(takeNextChatQueuedMessage(started.queue).status).toBe("blocked_by_edit");
+
+    const updated = updateChatQueuedMessage(started.queue, second.queueId, " revised text ");
+    expect(updated.status).toBe("updated");
+    if (updated.status !== "updated") throw new Error("expected edit to update");
+    expect(updated.queue.items.map((item) => item.text)).toEqual(["first text", "revised text"]);
+    expect(updated.restoreInput).toBe("new draft");
+    expect(updated.queue.edit).toBeNull();
+    expect(takeNextChatQueuedMessage(updated.queue)).toMatchObject({
+      status: "taken",
+      item: { queueId: first.queueId }
+    });
+  });
+
+  test("queued text edits accept the exact UTF-8 limit and reject one byte more", () => {
+    const item = queuedMessage("bounded-edit", "original");
+    const edit = {
+      scopeKey: "conversation:bounded-edit",
+      queueId: item.queueId,
+      stashedDraft: "draft"
+    };
+    const queue = { items: [item], edit };
+    const exact = "é".repeat(MAX_CHAT_QUEUED_TEXT_BYTES / 2);
+
+    expect(updateChatQueuedMessage(queue, item.queueId, exact).status).toBe("updated");
+    expect(updateChatQueuedMessage(queue, item.queueId, `${exact}a`).status).toBe("text_too_large");
+  });
+
+  test("switching edits keeps the original stash and cancel restores it", () => {
+    const first = queuedMessage("first", "first text");
+    const second = queuedMessage("second", "second text");
+    const initial = beginChatQueuedMessageEdit(
+      queueWith(first, second),
+      "conversation:one",
+      first.queueId,
+      "original draft"
+    );
+    if (initial.status !== "started") throw new Error("expected initial edit");
+    const switched = beginChatQueuedMessageEdit(
+      initial.queue,
+      "conversation:one",
+      second.queueId,
+      initial.input
+    );
+    if (switched.status !== "started") throw new Error("expected switched edit");
+    expect(switched.queue.edit?.stashedDraft).toBe("original draft");
+
+    const cancelled = cancelChatQueuedMessage(switched.queue, second.queueId);
+    expect(cancelled.status).toBe("cancelled");
+    if (cancelled.status !== "cancelled") throw new Error("expected cancel");
+    expect(cancelled.restoreInput).toBe("original draft");
+    expect(cancelled.queue.items).toEqual([first]);
+    expect(cancelled.queue.edit).toBeNull();
+  });
+
+  test("discarding an edit restores its draft without changing queue order", () => {
+    const item = queuedMessage("edit", "queued text");
+    const started = beginChatQueuedMessageEdit(
+      queueWith(item),
+      "conversation:one",
+      item.queueId,
+      "stashed"
+    );
+    if (started.status !== "started") throw new Error("expected edit");
+
+    expect(discardChatQueuedMessageEdit(started.queue)).toEqual({
+      status: "ended",
+      queue: queueWith(item),
+      restoreInput: "stashed"
+    });
+  });
+
+  test("detaches every send-owned field and stages without mutating the source draft", () => {
+    const image = new File(["image"], "draft.png", { type: "image/png" });
+    const original = composer("  prompt with context  ", {
+      draftImages: [image],
+      imageUrls: new Map([[image, "blob:draft-image"]]),
+      documentText: "document payload",
+      documentName: "notes.md",
+      draftProjectId: "project-a",
+      imagePasteGeneration: 4,
+      documentUploadGeneration: 8
+    });
+    const metadata = {
+      queueId: "queue-detached",
+      messageId: "message-detached",
+      model: "model-at-submit",
+      webSearchEnabled: true,
+      createdMs: 42
+    };
+
+    const detached = detachChatComposerDraft(original, metadata);
+    expect(detached.item).toMatchObject({
+      ...metadata,
+      text: "prompt with context",
+      documentText: "document payload",
+      documentName: "notes.md",
+      draftProjectId: "project-a"
+    });
+    expect(detached.item.draftImages).toEqual([image]);
+    expect(detached.item.imageUrls.get(image)).toBe("blob:draft-image");
+    expect(detached.composer).toMatchObject({
+      input: "",
+      draftImages: [],
+      documentText: "",
+      documentName: "",
+      draftProjectId: "project-a",
+      imagePasteGeneration: 5,
+      documentUploadGeneration: 9
+    });
+    expect(detached.composer.imageUrls.size).toBe(0);
+    expect(original.input).toBe("  prompt with context  ");
+    expect(original.draftImages).toEqual([image]);
+    expect(original.imageUrls.get(image)).toBe("blob:draft-image");
+
+    const staged = stageChatComposerDraft(original, metadata);
+    expect(staged.status).toBe("enqueued");
+    if (staged.status !== "enqueued") throw new Error("expected staged draft");
+    expect(staged.composer.queue.items).toEqual([staged.item]);
+    expect(staged.item.model).toBe("model-at-submit");
+    expect(staged.item.webSearchEnabled).toBe(true);
+  });
+
+  test("a rejected stage returns the exact draft and leaves its resources attached", () => {
+    const image = new File(["image"], "kept.png", { type: "image/png" });
+    const fullQueue = queueWith(
+      ...Array.from({ length: MAX_CHAT_QUEUED_MESSAGES }, (_, index) =>
+        queuedMessage(`existing-${index}`)
+      )
+    );
+    const original = composer("keep me", {
+      draftImages: [image],
+      imageUrls: new Map([[image, "blob:kept"]]),
+      queue: fullQueue
+    });
+    const result = stageChatComposerDraft(original, {
+      queueId: "queue-rejected",
+      messageId: "message-rejected",
+      model: "model",
+      webSearchEnabled: false,
+      createdMs: 1
+    });
+
+    expect(result.status).toBe("queue_full");
+    expect(result.composer).toBe(original);
+    expect(result.composer.imageUrls.get(image)).toBe("blob:kept");
+  });
+
+  test("stage propagates attachment-limit failures without detaching the draft", () => {
+    const images = Array.from({ length: MAX_CHAT_QUEUED_IMAGES_PER_ITEM + 1 }, (_, index) =>
+      imageWithSize(`stage-${index}.png`, 1)
+    );
+    const original = composer("keep staged payload", { draftImages: images });
+    const result = stageChatComposerDraft(original, {
+      queueId: "queue-attachment-rejected",
+      messageId: "message-attachment-rejected",
+      model: "model",
+      webSearchEnabled: false,
+      createdMs: 1
+    });
+
+    expect(result.status).toBe("too_many_images");
+    expect(result.composer).toBe(original);
+    expect(result.composer.draftImages).toBe(images);
+  });
+
+  test("recovers failed detached sends in place or in a temporary seventeenth slot", () => {
+    const image = new File(["image"], "failed.png", { type: "image/png" });
+    const failed = queuedMessage("failed", "failed prompt", {
+      draftImages: [image],
+      imageUrls: new Map([[image, "blob:failed"]]),
+      documentText: "failed document",
+      documentName: "failed.md",
+      draftProjectId: "project-a"
+    });
+
+    const restored = recoverDetachedChatComposerDraft(composer(), failed);
+    expect(restored.status).toBe("restored");
+    expect(restored.composer).toMatchObject({
+      input: "failed prompt",
+      documentText: "failed document",
+      documentName: "failed.md",
+      draftProjectId: "project-a"
+    });
+    expect(restored.composer.draftImages).toEqual([image]);
+    expect(restored.composer.imageUrls.get(image)).toBe("blob:failed");
+
+    const fullQueue = queueWith(
+      ...Array.from({ length: MAX_CHAT_QUEUED_MESSAGES }, (_, index) =>
+        queuedMessage(`existing-${index}`)
+      )
+    );
+    const requeued = recoverDetachedChatComposerDraft(
+      composer("a newer draft", { queue: fullQueue }),
+      failed
+    );
+    expect(requeued.status).toBe("requeued");
+    expect(requeued.composer.queue.items).toHaveLength(MAX_CHAT_QUEUED_MESSAGES + 1);
+    expect(requeued.composer.queue.items[0]).toBe(failed);
+    expect(
+      enqueueChatQueuedMessage(
+        requeued.composer.queue,
+        queuedMessage("normal-enqueue-remains-blocked")
+      ).status
+    ).toBe("queue_full");
+    expect(recoverDetachedChatComposerDraft(requeued.composer, failed).status).toBe(
+      "already_queued"
+    );
+  });
+
+  test("recovery and rekey remain lossless over aggregate bounds but block new admission", () => {
+    const existing = queuedMessage("recovery-existing", "", {
+      draftImages: Array.from({ length: 10 }, (_, index) =>
+        imageWithSize(`recovery-existing-${index}.png`, MAX_CHAT_QUEUED_IMAGE_BYTES)
+      ),
+      documentText: "d".repeat(MAX_CHAT_QUEUED_DOCUMENT_BYTES)
+    });
+    const failed = queuedMessage("recovery-failed", "", {
+      draftImages: Array.from({ length: 3 }, (_, index) =>
+        imageWithSize(`recovery-failed-${index}.png`, MAX_CHAT_QUEUED_IMAGE_BYTES)
+      )
+    });
+    const recovered = recoverDetachedChatComposerDraft(
+      composer("newer draft", { queue: queueWith(existing) }),
+      failed
+    );
+
+    expect(recovered.status).toBe("requeued");
+    expect(recovered.composer.queue.items).toEqual([failed, existing]);
+    expect(
+      enqueueChatQueuedMessage(recovered.composer.queue, queuedMessage("blocked-after-recovery"))
+        .status
+    ).toBe("queue_payload_too_large");
+
+    const sourceItem = queuedMessage("oversized-source", "", {
+      draftImages: Array.from({ length: 7 }, (_, index) =>
+        imageWithSize(`source-${index}.png`, MAX_CHAT_QUEUED_IMAGE_BYTES)
+      )
+    });
+    const destinationItem = queuedMessage("oversized-destination", "", {
+      draftImages: Array.from({ length: 7 }, (_, index) =>
+        imageWithSize(`destination-${index}.png`, MAX_CHAT_QUEUED_IMAGE_BYTES)
+      )
+    });
+    const merged = mergeChatComposerDraftsForRekey(
+      composer("", { queue: queueWith(sourceItem) }),
+      composer("", { queue: queueWith(destinationItem) }),
+      "conversation:oversized"
+    );
+
+    expect(merged.composer.queue.items).toHaveLength(2);
+    expect(merged.composer.queue.items).toContain(sourceItem);
+    expect(merged.composer.queue.items).toContain(destinationItem);
+    expect(
+      enqueueChatQueuedMessage(merged.composer.queue, queuedMessage("blocked-after-rekey")).status
+    ).toBe("queue_payload_too_large");
+  });
+
+  test("rekey preserves a source-only edit as the sole promotion fence", () => {
+    const sourceItem = queuedMessage("source-edit", "original queued text", {
+      queueId: "collision",
+      messageId: "message-collision",
+      createdMs: 10
+    });
+    const destinationItem = queuedMessage("destination", "destination queued text", {
+      queueId: "collision",
+      messageId: "message-collision",
+      createdMs: 20
+    });
+    const oversizedEdit = "x".repeat(MAX_CHAT_QUEUED_TEXT_BYTES + 1);
+    const source = composer(oversizedEdit, {
+      queue: {
+        items: [sourceItem],
+        edit: {
+          scopeKey: "draft:source",
+          queueId: sourceItem.queueId,
+          stashedDraft: "source stashed draft"
+        }
+      }
+    });
+    const destination = composer("destination draft", {
+      queue: queueWith(destinationItem)
+    });
+
+    const merged = mergeChatComposerDraftsForRekey(source, destination, "conversation:created");
+
+    expect(merged.composer.input).toBe(oversizedEdit);
+    expect(merged.composer.queue.edit).toEqual({
+      scopeKey: "conversation:created",
+      queueId: "collision:rekey:2",
+      stashedDraft: "destination draft\nsource stashed draft"
+    });
+    expect(
+      merged.composer.queue.items.find((item) => item.queueId === "collision:rekey:2")?.text
+    ).toBe("original queued text");
+    expect(takeNextChatQueuedMessage(merged.composer.queue).status).toBe("blocked_by_edit");
+    expect(
+      updateChatQueuedMessage(
+        merged.composer.queue,
+        merged.composer.queue.edit!.queueId,
+        merged.composer.input
+      ).status
+    ).toBe("text_too_large");
+  });
+
+  test("rekey merge preserves both drafts and queues while the destination edit stays visible", () => {
+    const sharedImage = new File(["shared"], "shared.png", { type: "image/png" });
+    const sourceOnlyImage = new File(["source"], "source.png", { type: "image/png" });
+    const destinationCollision = queuedMessage("destination-collision", "destination item", {
+      queueId: "collision",
+      messageId: "message-collision",
+      createdMs: 20,
+      draftProjectId: "destination-project"
+    });
+    const destinationEditItem = queuedMessage("destination-edit", "destination queued", {
+      createdMs: 40
+    });
+    const sourceCollision = queuedMessage("source-collision", "source queued before edit", {
+      queueId: "collision",
+      messageId: "message-collision",
+      createdMs: 10,
+      draftProjectId: "source-project"
+    });
+    const sourceLater = queuedMessage("source-later", "source later", { createdMs: 30 });
+    const source = composer("source edited queue text", {
+      draftImages: [sharedImage, sourceOnlyImage],
+      imageUrls: new Map([
+        [sharedImage, "blob:source-shared"],
+        [sourceOnlyImage, "blob:source-only"]
+      ]),
+      documentText: "source document",
+      documentName: "source.md",
+      draftProjectId: "source-project",
+      queue: {
+        items: [sourceCollision, sourceLater],
+        edit: {
+          scopeKey: "draft:source",
+          queueId: sourceCollision.queueId,
+          stashedDraft: "source stashed draft"
+        }
+      }
+    });
+    const destination = composer("destination edited queue text", {
+      draftImages: [sharedImage],
+      imageUrls: new Map([[sharedImage, "blob:destination-shared"]]),
+      documentText: "destination document",
+      documentName: "destination.md",
+      draftProjectId: "destination-project",
+      queue: {
+        items: [destinationCollision, destinationEditItem],
+        edit: {
+          scopeKey: "conversation:destination",
+          queueId: destinationEditItem.queueId,
+          stashedDraft: "destination stashed draft"
+        }
+      }
+    });
+
+    const merged = mergeChatComposerDraftsForRekey(source, destination, "conversation:merged");
+
+    expect(merged.composer.input).toBe("destination edited queue text");
+    expect(merged.composer.queue.edit).toEqual({
+      scopeKey: "conversation:merged",
+      queueId: destinationEditItem.queueId,
+      stashedDraft: "destination stashed draft\nsource stashed draft\nsource edited queue text"
+    });
+    expect(merged.composer.queue.items).toHaveLength(4);
+    expect(merged.composer.queue.items.map((item) => item.createdMs)).toEqual([10, 20, 30, 40]);
+    expect(new Set(merged.composer.queue.items.map((item) => item.queueId)).size).toBe(4);
+    expect(new Set(merged.composer.queue.items.map((item) => item.messageId)).size).toBe(4);
+    expect(merged.composer.queue.items.find((item) => item.createdMs === 10)?.text).toBe(
+      "source queued before edit"
+    );
+    expect(merged.composer.queue.items.find((item) => item.createdMs === 10)?.draftProjectId).toBe(
+      "source-project"
+    );
+    expect(merged.composer.draftImages).toEqual([sharedImage, sourceOnlyImage]);
+    expect(merged.composer.imageUrls.get(sharedImage)).toBe("blob:destination-shared");
+    expect(merged.composer.imageUrls.get(sourceOnlyImage)).toBe("blob:source-only");
+    expect(merged.displacedObjectUrls).toEqual(["blob:source-shared"]);
+    expect(merged.composer.documentText).toBe("destination document\n\nsource document");
+    expect(merged.composer.documentName).toBe("destination.md, source.md");
+    expect(merged.composer.draftProjectId).toBe("destination-project");
+    expect(takeNextChatQueuedMessage(merged.composer.queue).status).toBe("blocked_by_edit");
+
+    const resolved = updateChatQueuedMessage(
+      merged.composer.queue,
+      destinationEditItem.queueId,
+      merged.composer.input
+    );
+    expect(resolved.status).toBe("updated");
+    if (resolved.status !== "updated") throw new Error("expected explicit edit resolution");
+    expect(resolved.restoreInput).toBe(
+      "destination stashed draft\nsource stashed draft\nsource edited queue text"
+    );
+    expect(resolved.queue.items.some((item) => item.text === "source edited queue text")).toBe(
+      false
+    );
+    expect(takeNextChatQueuedMessage(resolved.queue).status).toBe("taken");
+  });
+
+  test("collects active and queued object URLs once", () => {
+    const active = new File(["active"], "active.png", { type: "image/png" });
+    const queued = new File(["queued"], "queued.png", { type: "image/png" });
+    const draft = composer("", {
+      draftImages: [active],
+      imageUrls: new Map([[active, "blob:shared"]]),
+      queue: queueWith(
+        queuedMessage("queued", "", {
+          draftImages: [queued],
+          imageUrls: new Map([
+            [queued, "blob:shared"],
+            [active, "blob:queued-only"]
+          ])
+        })
+      )
+    });
+
+    expect(chatComposerObjectUrls(draft)).toEqual(["blob:shared", "blob:queued-only"]);
+  });
+
+  test("does not displace an active URL that a merged queued item still owns", () => {
+    const sharedActiveFile = new File(["active"], "active.png", { type: "image/png" });
+    const queuedFile = new File(["queued"], "queued.png", { type: "image/png" });
+    const source = composer("", {
+      draftImages: [sharedActiveFile],
+      imageUrls: new Map([[sharedActiveFile, "blob:source-active"]]),
+      queue: queueWith(
+        queuedMessage("retains-url", "", {
+          draftImages: [queuedFile],
+          imageUrls: new Map([[queuedFile, "blob:source-active"]])
+        })
+      )
+    });
+    const destination = composer("", {
+      draftImages: [sharedActiveFile],
+      imageUrls: new Map([[sharedActiveFile, "blob:destination-active"]])
+    });
+
+    const merged = mergeChatComposerDraftsForRekey(source, destination, "conversation:destination");
+
+    expect(merged.composer.imageUrls.get(sharedActiveFile)).toBe("blob:destination-active");
+    expect(chatComposerObjectUrls(merged.composer)).toContain("blob:source-active");
+    expect(merged.displacedObjectUrls).toEqual([]);
+  });
+});
diff --git a/frontend/src/services/chatComposerQueue.ts b/frontend/src/services/chatComposerQueue.ts
new file mode 100644
index 000000000..ac70e9bd6
--- /dev/null
+++ b/frontend/src/services/chatComposerQueue.ts
@@ -0,0 +1,681 @@
+import {
+  beginQueuedMessageEdit as beginSharedQueuedMessageEdit,
+  discardQueuedMessageEdit as discardSharedQueuedMessageEdit,
+  queuedMessageEditStillPresent as sharedQueuedMessageEditStillPresent,
+  type QueuedMessageEdit
+} from "./composerQueue";
+
+export const MAX_CHAT_QUEUED_MESSAGES = 16;
+export const MAX_CHAT_QUEUED_TEXT_BYTES = 32 * 1024;
+export const MAX_CHAT_QUEUED_IMAGES_PER_ITEM = 10;
+export const MAX_CHAT_QUEUED_IMAGE_BYTES = 20 * 1024 * 1024;
+export const MAX_CHAT_QUEUED_DOCUMENT_BYTES = 10 * 1024 * 1024;
+export const MAX_CHAT_QUEUED_AGGREGATE_ATTACHMENT_BYTES = 256 * 1024 * 1024;
+export const MAX_CHAT_ACCOUNT_RETAINED_QUEUE_MESSAGES = 64;
+export const MAX_CHAT_ACCOUNT_RETAINED_IMAGES =
+  MAX_CHAT_ACCOUNT_RETAINED_QUEUE_MESSAGES * MAX_CHAT_QUEUED_IMAGES_PER_ITEM;
+export const MAX_CHAT_ACCOUNT_RETAINED_ATTACHMENT_BYTES = 256 * 1024 * 1024;
+
+export type ChatQueuedMessage = {
+  queueId: string;
+  messageId: string;
+  text: string;
+  draftImages: File[];
+  imageUrls: Map<File, string>;
+  documentText: string;
+  documentName: string;
+  draftProjectId: string | null;
+  model: string;
+  webSearchEnabled: boolean;
+  createdMs: number;
+};
+
+export type ChatQueuedMessageEdit = QueuedMessageEdit;
+
+export type ChatComposerQueueState = {
+  items: ChatQueuedMessage[];
+  edit: ChatQueuedMessageEdit | null;
+};
+
+export type ChatQueuedMessageMetadata = Pick<
+  ChatQueuedMessage,
+  "queueId" | "messageId" | "model" | "webSearchEnabled" | "createdMs"
+>;
+
+export type ChatComposerDraft = {
+  input: string;
+  draftImages: File[];
+  imageUrls: Map<File, string>;
+  documentText: string;
+  documentName: string;
+  draftProjectId: string | null;
+  isProcessingDocument: boolean;
+  imagePasteGeneration: number;
+  documentUploadGeneration: number;
+  queue: ChatComposerQueueState;
+};
+
+export type ChatQueueAdmissionFailureStatus =
+  | "empty"
+  | "queue_full"
+  | "text_too_large"
+  | "too_many_images"
+  | "image_too_large"
+  | "document_too_large"
+  | "queue_payload_too_large"
+  | "account_queue_full"
+  | "account_payload_too_large";
+
+export type ChatAccountQueueUsage = Readonly<{
+  queuedMessageCount: number;
+  attachmentBytes: number;
+  imageCount: number;
+}>;
+
+export type EnqueueChatQueuedMessageResult =
+  | Readonly<{ status: "enqueued"; queue: ChatComposerQueueState }>
+  | Readonly<{
+      status: ChatQueueAdmissionFailureStatus;
+      queue: ChatComposerQueueState;
+    }>;
+
+export type CancelChatQueuedMessageResult =
+  | Readonly<{
+      status: "cancelled";
+      queue: ChatComposerQueueState;
+      item: ChatQueuedMessage;
+      restoreInput: string | undefined;
+    }>
+  | Readonly<{ status: "missing"; queue: ChatComposerQueueState }>;
+
+export type BeginChatQueuedMessageEditResult =
+  | Readonly<{
+      status: "started";
+      queue: ChatComposerQueueState;
+      input: string;
+    }>
+  | Readonly<{
+      status: "already_editing" | "missing";
+      queue: ChatComposerQueueState;
+    }>;
+
+export type EndChatQueuedMessageEditResult =
+  | Readonly<{
+      status: "ended";
+      queue: ChatComposerQueueState;
+      restoreInput: string;
+    }>
+  | Readonly<{ status: "not_editing"; queue: ChatComposerQueueState }>;
+
+export type UpdateChatQueuedMessageResult =
+  | Readonly<{
+      status: "updated";
+      queue: ChatComposerQueueState;
+      item: ChatQueuedMessage;
+      restoreInput: string | undefined;
+    }>
+  | Readonly<{ status: "empty"; queue: ChatComposerQueueState }>
+  | Readonly<{ status: "missing"; queue: ChatComposerQueueState }>
+  | Readonly<{ status: "text_too_large"; queue: ChatComposerQueueState }>;
+
+export type TakeNextChatQueuedMessageResult =
+  | Readonly<{
+      status: "taken";
+      queue: ChatComposerQueueState;
+      item: ChatQueuedMessage;
+    }>
+  | Readonly<{ status: "blocked_by_edit" | "empty"; queue: ChatComposerQueueState }>;
+
+export type StageChatComposerDraftResult<TComposer extends ChatComposerDraft> =
+  | Readonly<{
+      status: "enqueued";
+      composer: TComposer;
+      item: ChatQueuedMessage;
+    }>
+  | Readonly<{
+      status: ChatQueueAdmissionFailureStatus;
+      composer: TComposer;
+    }>;
+
+export type RecoverDetachedChatComposerDraftResult<TComposer extends ChatComposerDraft> = Readonly<{
+  status: "restored" | "requeued" | "already_queued";
+  composer: TComposer;
+}>;
+
+export type MergeChatComposerDraftsResult<TComposer extends ChatComposerDraft> = Readonly<{
+  composer: TComposer;
+  displacedObjectUrls: string[];
+}>;
+
+export function emptyChatComposerQueueState(): ChatComposerQueueState {
+  return { items: [], edit: null };
+}
+
+export function chatQueuedTextByteLength(text: string): number {
+  return new TextEncoder().encode(text).byteLength;
+}
+
+export function chatQueuedMessageHasContent(item: ChatQueuedMessage): boolean {
+  return Boolean(item.text.trim() || item.draftImages.length || item.documentText);
+}
+
+export function chatComposerHasDraftMaterial(composer: ChatComposerDraft): boolean {
+  return Boolean(
+    composer.input.length ||
+    composer.draftImages.length ||
+    composer.documentText.length ||
+    composer.documentName.length ||
+    composer.isProcessingDocument
+  );
+}
+
+function queuedMessageImages(item: ChatQueuedMessage): File[] {
+  const images = new Set(item.draftImages);
+  for (const image of item.imageUrls.keys()) images.add(image);
+  return Array.from(images);
+}
+
+export function chatQueuedMessageAttachmentByteLength(item: ChatQueuedMessage): number {
+  let bytes = chatQueuedTextByteLength(item.documentText);
+  for (const image of queuedMessageImages(item)) bytes += image.size;
+  return bytes;
+}
+
+function queuedAttachmentByteLength(items: readonly ChatQueuedMessage[]): number {
+  let bytes = 0;
+  for (const item of items) bytes += chatQueuedMessageAttachmentByteLength(item);
+  return bytes;
+}
+
+function validateQueuedMessagePayload(
+  queue: ChatComposerQueueState,
+  item: ChatQueuedMessage,
+  accountUsage?: ChatAccountQueueUsage
+): ChatQueueAdmissionFailureStatus | null {
+  if (!chatQueuedMessageHasContent(item)) return "empty";
+  if (chatQueuedTextByteLength(item.text) > MAX_CHAT_QUEUED_TEXT_BYTES) {
+    return "text_too_large";
+  }
+  const images = queuedMessageImages(item);
+  if (images.length > MAX_CHAT_QUEUED_IMAGES_PER_ITEM) {
+    return "too_many_images";
+  }
+  if (images.some((image) => image.size > MAX_CHAT_QUEUED_IMAGE_BYTES)) {
+    return "image_too_large";
+  }
+  if (chatQueuedTextByteLength(item.documentText) > MAX_CHAT_QUEUED_DOCUMENT_BYTES) {
+    return "document_too_large";
+  }
+  if (queue.items.length >= MAX_CHAT_QUEUED_MESSAGES) return "queue_full";
+  if (
+    queuedAttachmentByteLength(queue.items) + chatQueuedMessageAttachmentByteLength(item) >
+    MAX_CHAT_QUEUED_AGGREGATE_ATTACHMENT_BYTES
+  ) {
+    return "queue_payload_too_large";
+  }
+  if (accountUsage && accountUsage.queuedMessageCount >= MAX_CHAT_ACCOUNT_RETAINED_QUEUE_MESSAGES) {
+    return "account_queue_full";
+  }
+  if (accountUsage && accountUsage.attachmentBytes > MAX_CHAT_ACCOUNT_RETAINED_ATTACHMENT_BYTES) {
+    return "account_payload_too_large";
+  }
+  return null;
+}
+
+export function enqueueChatQueuedMessage(
+  queue: ChatComposerQueueState,
+  item: ChatQueuedMessage,
+  accountUsage?: ChatAccountQueueUsage
+): EnqueueChatQueuedMessageResult {
+  const rejected = validateQueuedMessagePayload(queue, item, accountUsage);
+  if (rejected) return { status: rejected, queue };
+
+  return {
+    status: "enqueued",
+    queue: { ...queue, items: [...queue.items, item] }
+  };
+}
+
+export function cancelChatQueuedMessage(
+  queue: ChatComposerQueueState,
+  queueId: string
+): CancelChatQueuedMessageResult {
+  const index = queue.items.findIndex((item) => item.queueId === queueId);
+  if (index < 0) return { status: "missing", queue };
+
+  const item = queue.items[index];
+  const editingThisItem = queue.edit?.queueId === queueId;
+  const items = [...queue.items];
+  items.splice(index, 1);
+  return {
+    status: "cancelled",
+    queue: {
+      items,
+      edit: editingThisItem ? null : queue.edit
+    },
+    item,
+    restoreInput:
+      editingThisItem && queue.edit ? discardSharedQueuedMessageEdit(queue.edit) : undefined
+  };
+}
+
+export function beginChatQueuedMessageEdit(
+  queue: ChatComposerQueueState,
+  scopeKey: string,
+  queueId: string,
+  composerInput: string
+): BeginChatQueuedMessageEditResult {
+  const item = queue.items.find((queued) => queued.queueId === queueId);
+  if (!item) return { status: "missing", queue };
+  // Queue state is runtime-local, so a matching queue ID is the same edit even
+  // if draft-to-conversation rekeying changed the runtime scope. Normalize an
+  // older real runtime key before switching items so the shared stash logic
+  // keeps the pre-edit draft instead of treating it as a different runtime.
+  if (queue.edit?.queueId === queueId) return { status: "already_editing", queue };
+  const currentEdit = queue.edit ? { ...queue.edit, scopeKey } : null;
+  const result = beginSharedQueuedMessageEdit({
+    current: currentEdit,
+    scopeKey,
+    item,
+    composerText: composerInput
+  });
+  if (!result) return { status: "already_editing", queue };
+
+  return {
+    status: "started",
+    queue: { ...queue, edit: result.edit },
+    input: result.composer
+  };
+}
+
+export function discardChatQueuedMessageEdit(
+  queue: ChatComposerQueueState
+): EndChatQueuedMessageEditResult {
+  if (!queue.edit) return { status: "not_editing", queue };
+  return {
+    status: "ended",
+    queue: { ...queue, edit: null },
+    restoreInput: discardSharedQueuedMessageEdit(queue.edit)
+  };
+}
+
+export function updateChatQueuedMessage(
+  queue: ChatComposerQueueState,
+  queueId: string,
+  text: string
+): UpdateChatQueuedMessageResult {
+  const index = queue.items.findIndex((item) => item.queueId === queueId);
+  if (index < 0) return { status: "missing", queue };
+
+  const trimmedText = text.trim();
+  const current = queue.items[index];
+  if (!trimmedText && current.draftImages.length === 0 && !current.documentText) {
+    return { status: "empty", queue };
+  }
+  if (chatQueuedTextByteLength(trimmedText) > MAX_CHAT_QUEUED_TEXT_BYTES) {
+    return { status: "text_too_large", queue };
+  }
+
+  const item = { ...current, text: trimmedText };
+  const items = [...queue.items];
+  items[index] = item;
+  const editingThisItem = queue.edit?.queueId === queueId;
+  const restoreInput =
+    editingThisItem && queue.edit ? discardSharedQueuedMessageEdit(queue.edit) : undefined;
+  return {
+    status: "updated",
+    queue: { items, edit: editingThisItem ? null : queue.edit },
+    item,
+    restoreInput
+  };
+}
+
+export function queuedChatMessageEditStillPresent(queue: ChatComposerQueueState): boolean {
+  return sharedQueuedMessageEditStillPresent(queue.edit, queue.items);
+}
+
+export function takeNextChatQueuedMessage(
+  queue: ChatComposerQueueState
+): TakeNextChatQueuedMessageResult {
+  if (queue.edit) return { status: "blocked_by_edit", queue };
+  const item = queue.items[0];
+  if (!item) return { status: "empty", queue };
+  return {
+    status: "taken",
+    queue: { items: queue.items.slice(1), edit: null },
+    item
+  };
+}
+
+export function detachChatComposerDraft<TComposer extends ChatComposerDraft>(
+  composer: TComposer,
+  metadata: ChatQueuedMessageMetadata
+): Readonly<{ composer: TComposer; item: ChatQueuedMessage }> {
+  const item: ChatQueuedMessage = {
+    ...metadata,
+    text: composer.input.trim(),
+    draftImages: [...composer.draftImages],
+    imageUrls: new Map(composer.imageUrls),
+    documentText: composer.documentText,
+    documentName: composer.documentName,
+    draftProjectId: composer.draftProjectId
+  };
+  const nextComposer = {
+    ...composer,
+    input: "",
+    draftImages: [],
+    imageUrls: new Map<File, string>(),
+    documentText: "",
+    documentName: "",
+    isProcessingDocument: false,
+    imagePasteGeneration: composer.imagePasteGeneration + 1,
+    documentUploadGeneration: composer.documentUploadGeneration + 1
+  };
+
+  return { composer: nextComposer, item };
+}
+
+export function stageChatComposerDraft<TComposer extends ChatComposerDraft>(
+  composer: TComposer,
+  metadata: ChatQueuedMessageMetadata,
+  accountUsage?: ChatAccountQueueUsage
+): StageChatComposerDraftResult<TComposer> {
+  const detached = detachChatComposerDraft(composer, metadata);
+  const enqueued = enqueueChatQueuedMessage(composer.queue, detached.item, accountUsage);
+  if (enqueued.status !== "enqueued") {
+    return { status: enqueued.status, composer };
+  }
+
+  return {
+    status: "enqueued",
+    composer: { ...detached.composer, queue: enqueued.queue },
+    item: detached.item
+  };
+}
+
+export function recoverDetachedChatComposerDraft<TComposer extends ChatComposerDraft>(
+  composer: TComposer,
+  item: ChatQueuedMessage
+): RecoverDetachedChatComposerDraftResult<TComposer> {
+  if (
+    composer.queue.items.some(
+      (queued) => queued.queueId === item.queueId || queued.messageId === item.messageId
+    )
+  ) {
+    return { status: "already_queued", composer };
+  }
+
+  if (
+    !chatComposerHasDraftMaterial(composer) &&
+    composer.queue.items.length === 0 &&
+    composer.queue.edit === null
+  ) {
+    return {
+      status: "restored",
+      composer: {
+        ...composer,
+        input: item.text,
+        draftImages: [...item.draftImages],
+        imageUrls: new Map(item.imageUrls),
+        documentText: item.documentText,
+        documentName: item.documentName,
+        draftProjectId: item.draftProjectId,
+        isProcessingDocument: false,
+        imagePasteGeneration: composer.imagePasteGeneration + 1,
+        documentUploadGeneration: composer.documentUploadGeneration + 1
+      }
+    };
+  }
+
+  return {
+    status: "requeued",
+    composer: {
+      ...composer,
+      queue: { ...composer.queue, items: [item, ...composer.queue.items] }
+    }
+  };
+}
+
+function combineDraftText(destination: string, source: string, separator: string): string {
+  if (!destination) return source;
+  if (!source) return destination;
+  return `${destination}${separator}${source}`;
+}
+
+type PreparedComposerEdit = Readonly<{
+  items: ChatQueuedMessage[];
+  draftInput: string;
+  visibleEdit: Readonly<{ edit: ChatQueuedMessageEdit; input: string }> | null;
+}>;
+
+function preserveComposerQueueEdit(composer: ChatComposerDraft): PreparedComposerEdit {
+  const edit = composer.queue.edit;
+  if (!edit) {
+    return { items: composer.queue.items, draftInput: composer.input, visibleEdit: null };
+  }
+
+  if (!composer.queue.items.some((item) => item.queueId === edit.queueId)) {
+    return {
+      items: composer.queue.items,
+      draftInput: combineDraftText(discardSharedQueuedMessageEdit(edit), composer.input, "\n"),
+      visibleEdit: null
+    };
+  }
+
+  return {
+    items: composer.queue.items,
+    draftInput: discardSharedQueuedMessageEdit(edit),
+    visibleEdit: { edit, input: composer.input }
+  };
+}
+
+function foldComposerQueueEditIntoDraft(composer: ChatComposerDraft): PreparedComposerEdit {
+  const prepared = preserveComposerQueueEdit(composer);
+  if (!prepared.visibleEdit) return prepared;
+
+  // A concurrent destination edit owns the one visible editor. Never turn the
+  // source's partially edited text into a promotable queued item without an
+  // explicit submit: retain the original item and move both source text fields
+  // into the surviving edit's non-promotable stash.
+  return {
+    items: composer.queue.items,
+    draftInput: combineDraftText(
+      discardSharedQueuedMessageEdit(prepared.visibleEdit.edit),
+      prepared.visibleEdit.input,
+      "\n"
+    ),
+    visibleEdit: null
+  };
+}
+
+type MergedQueueItems = Readonly<{
+  items: ChatQueuedMessage[];
+  destinationEditQueueId: string | null;
+  sourceEditQueueId: string | null;
+}>;
+
+function mergeQueueItems(
+  destinationItems: ChatQueuedMessage[],
+  sourceItems: ChatQueuedMessage[],
+  destinationEditQueueId: string | null,
+  sourceEditQueueId: string | null
+): MergedQueueItems {
+  const usedQueueIds = new Set<string>();
+  const usedMessageIds = new Set<string>();
+  const makeUniqueId = (candidate: string, used: Set<string>): string => {
+    if (!used.has(candidate)) {
+      used.add(candidate);
+      return candidate;
+    }
+    let suffix = 2;
+    while (used.has(`${candidate}:rekey:${suffix}`)) suffix += 1;
+    const unique = `${candidate}:rekey:${suffix}`;
+    used.add(unique);
+    return unique;
+  };
+  let normalizedDestinationEditQueueId: string | null = null;
+  let normalizedSourceEditQueueId: string | null = null;
+  const normalizeIds = (
+    item: ChatQueuedMessage,
+    origin: "destination" | "source"
+  ): ChatQueuedMessage => {
+    const originalQueueId = item.queueId;
+    const queueId = makeUniqueId(item.queueId, usedQueueIds);
+    const messageId = makeUniqueId(item.messageId, usedMessageIds);
+    if (
+      origin === "destination" &&
+      normalizedDestinationEditQueueId === null &&
+      originalQueueId === destinationEditQueueId
+    ) {
+      normalizedDestinationEditQueueId = queueId;
+    }
+    if (
+      origin === "source" &&
+      normalizedSourceEditQueueId === null &&
+      originalQueueId === sourceEditQueueId
+    ) {
+      normalizedSourceEditQueueId = queueId;
+    }
+    return queueId === item.queueId && messageId === item.messageId
+      ? item
+      : { ...item, queueId, messageId };
+  };
+  const combined = [
+    ...destinationItems.map((item, index) => ({
+      item: normalizeIds(item, "destination"),
+      origin: 0,
+      index
+    })),
+    ...sourceItems.map((item, index) => ({
+      item: normalizeIds(item, "source"),
+      origin: 1,
+      index
+    }))
+  ];
+  return {
+    items: combined
+      .sort(
+        (left, right) =>
+          left.item.createdMs - right.item.createdMs ||
+          left.origin - right.origin ||
+          left.index - right.index
+      )
+      .map(({ item }) => item),
+    destinationEditQueueId: normalizedDestinationEditQueueId,
+    sourceEditQueueId: normalizedSourceEditQueueId
+  };
+}
+
+function mergeDraftImages(
+  destinationImages: File[],
+  destinationUrls: Map<File, string>,
+  sourceImages: File[],
+  sourceUrls: Map<File, string>
+): Readonly<{ images: File[]; urls: Map<File, string>; displacedObjectUrls: string[] }> {
+  const images = [...destinationImages];
+  const knownImages = new Set(images);
+  for (const image of sourceImages) {
+    if (!knownImages.has(image)) {
+      knownImages.add(image);
+      images.push(image);
+    }
+  }
+
+  const urls = new Map(sourceUrls);
+  const displacedObjectUrls: string[] = [];
+  for (const [file, destinationUrl] of destinationUrls) {
+    const sourceUrl = urls.get(file);
+    if (sourceUrl && sourceUrl !== destinationUrl) displacedObjectUrls.push(sourceUrl);
+    urls.set(file, destinationUrl);
+  }
+  return { images, urls, displacedObjectUrls };
+}
+
+/**
+ * Reconciles a draft runtime with an independently materialized conversation.
+ * The destination edit remains visible when both runtimes are editing. A lone
+ * source edit remains open. When both edit, the source's original item stays
+ * unchanged and both source text fields move into the destination edit's stash,
+ * keeping the entire FIFO blocked until the user explicitly resolves that edit.
+ */
+export function mergeChatComposerDraftsForRekey<TComposer extends ChatComposerDraft>(
+  source: TComposer,
+  destination: TComposer,
+  targetScopeKey: string
+): MergeChatComposerDraftsResult<TComposer> {
+  const preparedDestination = preserveComposerQueueEdit(destination);
+  const preparedSource = preparedDestination.visibleEdit
+    ? foldComposerQueueEditIntoDraft(source)
+    : preserveComposerQueueEdit(source);
+  const imageMerge = mergeDraftImages(
+    destination.draftImages,
+    destination.imageUrls,
+    source.draftImages,
+    source.imageUrls
+  );
+  const queueMerge = mergeQueueItems(
+    preparedDestination.items,
+    preparedSource.items,
+    preparedDestination.visibleEdit?.edit.queueId ?? null,
+    preparedSource.visibleEdit?.edit.queueId ?? null
+  );
+  const visibleEdit = preparedDestination.visibleEdit ?? preparedSource.visibleEdit;
+  const visibleEditQueueId = preparedDestination.visibleEdit
+    ? queueMerge.destinationEditQueueId
+    : queueMerge.sourceEditQueueId;
+  const mergedDraftInput = combineDraftText(
+    preparedDestination.draftInput,
+    preparedSource.draftInput,
+    "\n"
+  );
+  const edit =
+    visibleEdit && visibleEditQueueId
+      ? {
+          ...visibleEdit.edit,
+          scopeKey: targetScopeKey,
+          queueId: visibleEditQueueId,
+          stashedDraft: mergedDraftInput
+        }
+      : null;
+  const input = edit && visibleEdit ? visibleEdit.input : mergedDraftInput;
+
+  const composer = {
+    ...source,
+    ...destination,
+    input,
+    draftImages: imageMerge.images,
+    imageUrls: imageMerge.urls,
+    documentText: combineDraftText(destination.documentText, source.documentText, "\n\n"),
+    documentName: combineDraftText(destination.documentName, source.documentName, ", "),
+    isProcessingDocument: destination.isProcessingDocument || source.isProcessingDocument,
+    imagePasteGeneration: Math.max(destination.imagePasteGeneration, source.imagePasteGeneration),
+    documentUploadGeneration: Math.max(
+      destination.documentUploadGeneration,
+      source.documentUploadGeneration
+    ),
+    queue: { items: queueMerge.items, edit }
+  } as TComposer;
+  const retainedObjectUrls = new Set(chatComposerObjectUrls(composer));
+
+  return {
+    composer,
+    displacedObjectUrls: Array.from(new Set(imageMerge.displacedObjectUrls)).filter(
+      (url) => !retainedObjectUrls.has(url)
+    )
+  };
+}
+
+export function chatComposerObjectUrls(composer: ChatComposerDraft): string[] {
+  const urls = new Set<string>(composer.imageUrls.values());
+  for (const item of composer.queue.items) {
+    for (const url of item.imageUrls.values()) urls.add(url);
+  }
+  return Array.from(urls);
+}
+
+export function disposeChatComposerObjectUrls(
+  composer: ChatComposerDraft,
+  revokeObjectUrl: (url: string) => void = URL.revokeObjectURL
+): void {
+  for (const url of chatComposerObjectUrls(composer)) revokeObjectUrl(url);
+}
diff --git a/frontend/src/services/chatComposerSend.test.ts b/frontend/src/services/chatComposerSend.test.ts
new file mode 100644
index 000000000..7b3d31e97
--- /dev/null
+++ b/frontend/src/services/chatComposerSend.test.ts
@@ -0,0 +1,303 @@
+import { describe, expect, test } from "bun:test";
+import { createChatComposerState } from "@/contexts/ChatRuntimeContext";
+import {
+  emptyChatComposerQueueState,
+  MAX_CHAT_ACCOUNT_RETAINED_QUEUE_MESSAGES,
+  MAX_CHAT_QUEUED_MESSAGES,
+  type ChatQueuedMessage
+} from "./chatComposerQueue";
+import {
+  canSubmitChatComposer,
+  chatComposerWithInputOverride,
+  chatComposerShowsStop,
+  planChatComposerSubmission
+} from "./chatComposerSend";
+
+const metadata = {
+  queueId: "queue-new",
+  messageId: "message-new",
+  model: "test-model",
+  webSearchEnabled: false,
+  createdMs: 3
+};
+
+function queued(queueId: string, createdMs: number, text = queueId): ChatQueuedMessage {
+  return {
+    queueId,
+    messageId: `message-${queueId}`,
+    text,
+    draftImages: [],
+    imageUrls: new Map(),
+    documentText: "",
+    documentName: "",
+    draftProjectId: null,
+    model: "test-model",
+    webSearchEnabled: false,
+    createdMs
+  };
+}
+
+describe("chat composer submission planning", () => {
+  test("retains a voice input override without disturbing queue or attachments", () => {
+    const image = new File(["image"], "image.png", { type: "image/png" });
+    const composer = {
+      ...createChatComposerState(),
+      input: "before",
+      draftImages: [image],
+      queue: {
+        items: [queued("one", 1)],
+        edit: { scopeKey: "conversation:1", queueId: "one", stashedDraft: "later" }
+      }
+    };
+
+    const retained = chatComposerWithInputOverride(composer, "before dictated words");
+
+    expect(retained.input).toBe("before dictated words");
+    expect(retained.draftImages).toBe(composer.draftImages);
+    expect(retained.queue).toBe(composer.queue);
+    expect(chatComposerWithInputOverride(retained, undefined)).toBe(retained);
+  });
+
+  test("detaches an idle draft before asynchronous send work", () => {
+    const composer = { ...createChatComposerState(), input: " first message " };
+    const plan = planChatComposerSubmission({ composer, hasActiveRun: false, metadata });
+
+    expect(plan.status).toBe("start");
+    if (plan.status !== "start") return;
+    expect(plan.item.text).toBe("first message");
+    expect(plan.composer.input).toBe("");
+    expect(plan.recoverOnFailure).toBe(true);
+  });
+
+  test("stages a mid-run draft without starting a second run", () => {
+    const composer = { ...createChatComposerState(), input: "follow up" };
+    const plan = planChatComposerSubmission({ composer, hasActiveRun: true, metadata });
+
+    expect(plan.status).toBe("queued");
+    if (plan.status !== "queued") return;
+    expect(plan.composer.input).toBe("");
+    expect(plan.composer.queue.items.map((item) => item.text)).toEqual(["follow up"]);
+  });
+
+  test("appends the live draft after leftovers and starts the oldest item", () => {
+    const composer = {
+      ...createChatComposerState(),
+      input: "newest",
+      queue: { items: [queued("oldest", 1), queued("middle", 2)], edit: null }
+    };
+    const plan = planChatComposerSubmission({ composer, hasActiveRun: false, metadata });
+
+    expect(plan.status).toBe("start");
+    if (plan.status !== "start") return;
+    expect(plan.item.queueId).toBe("oldest");
+    expect(plan.composer.queue.items.map((item) => item.queueId)).toEqual(["middle", "queue-new"]);
+    expect(plan.recoverOnFailure).toBe(false);
+  });
+
+  test("resumes a full queue before appending the live draft at the tail", () => {
+    const items = Array.from({ length: MAX_CHAT_QUEUED_MESSAGES }, (_, index) =>
+      queued(`queued-${index}`, index + 1)
+    );
+    const composer = {
+      ...createChatComposerState(),
+      input: "newest",
+      queue: { items, edit: null }
+    };
+    const plan = planChatComposerSubmission({ composer, hasActiveRun: false, metadata });
+
+    expect(plan.status).toBe("start");
+    if (plan.status !== "start") return;
+    expect(plan.item.queueId).toBe("queued-0");
+    expect(plan.composer.queue.items).toHaveLength(MAX_CHAT_QUEUED_MESSAGES);
+    expect(plan.composer.queue.items.at(-1)?.queueId).toBe("queue-new");
+  });
+
+  test("starts the retained FIFO but leaves the live draft when the account queue is full", () => {
+    const composer = {
+      ...createChatComposerState(),
+      input: "keep this live",
+      queue: { items: [queued("oldest", 1)], edit: null }
+    };
+    const plan = planChatComposerSubmission({
+      composer,
+      hasActiveRun: false,
+      metadata,
+      accountUsage: {
+        queuedMessageCount: MAX_CHAT_ACCOUNT_RETAINED_QUEUE_MESSAGES,
+        attachmentBytes: 0,
+        imageCount: 0
+      }
+    });
+
+    expect(plan.status).toBe("start");
+    if (plan.status !== "start") return;
+    expect(plan.item.queueId).toBe("oldest");
+    expect(plan.composer.input).toBe("keep this live");
+    expect(plan.composer.queue.items).toEqual([]);
+  });
+
+  test("reserves a recovery slot before starting a direct idle draft", () => {
+    const composer = { ...createChatComposerState(), input: "keep this live" };
+    const plan = planChatComposerSubmission({
+      composer,
+      hasActiveRun: false,
+      metadata,
+      accountUsage: {
+        queuedMessageCount: MAX_CHAT_ACCOUNT_RETAINED_QUEUE_MESSAGES,
+        attachmentBytes: 0,
+        imageCount: 0
+      }
+    });
+
+    expect(plan.status).toBe("account_queue_full");
+    expect(composer.input).toBe("keep this live");
+  });
+
+  test("drains a losslessly recovered queue that is already over the local limit", () => {
+    const items = Array.from({ length: MAX_CHAT_QUEUED_MESSAGES + 2 }, (_, index) =>
+      queued(`recovered-${index}`, index + 1)
+    );
+    const composer = {
+      ...createChatComposerState(),
+      input: "keep this editable",
+      queue: { items, edit: null }
+    };
+    const plan = planChatComposerSubmission({ composer, hasActiveRun: false, metadata });
+
+    expect(plan.status).toBe("start");
+    if (plan.status !== "start") return;
+    expect(plan.item.queueId).toBe("recovered-0");
+    expect(plan.composer.input).toBe("keep this editable");
+    expect(plan.composer.queue.items).toHaveLength(MAX_CHAT_QUEUED_MESSAGES + 1);
+  });
+
+  test("rejects a new mid-run item when the account queue is full", () => {
+    const composer = { ...createChatComposerState(), input: "not lost" };
+    const plan = planChatComposerSubmission({
+      composer,
+      hasActiveRun: true,
+      metadata,
+      accountUsage: {
+        queuedMessageCount: MAX_CHAT_ACCOUNT_RETAINED_QUEUE_MESSAGES,
+        attachmentBytes: 0,
+        imageCount: 0
+      }
+    });
+
+    expect(plan.status).toBe("account_queue_full");
+    expect(composer.input).toBe("not lost");
+  });
+
+  test("saves an edit in place and either holds or resumes the FIFO", () => {
+    const base = {
+      ...createChatComposerState(),
+      input: "edited",
+      queue: {
+        items: [queued("one", 1), queued("two", 2)],
+        edit: { scopeKey: "conversation:1", queueId: "two", stashedDraft: "later draft" }
+      }
+    };
+
+    const held = planChatComposerSubmission({ composer: base, hasActiveRun: true, metadata });
+    expect(held.status).toBe("updated");
+    if (held.status !== "updated") return;
+    expect(held.composer.input).toBe("later draft");
+    expect(held.composer.queue.items[1].text).toBe("edited");
+
+    const resumed = planChatComposerSubmission({ composer: base, hasActiveRun: false, metadata });
+    expect(resumed.status).toBe("start");
+    if (resumed.status !== "start") return;
+    expect(resumed.item.queueId).toBe("one");
+    expect(resumed.composer.queue.items[0].text).toBe("edited");
+  });
+
+  test("empty idle send flushes a retained queue but empty active send does nothing", () => {
+    const composer = {
+      ...createChatComposerState(),
+      queue: { items: [queued("one", 1)], edit: null }
+    };
+    expect(planChatComposerSubmission({ composer, hasActiveRun: true, metadata }).status).toBe(
+      "empty"
+    );
+    expect(planChatComposerSubmission({ composer, hasActiveRun: false, metadata }).status).toBe(
+      "start"
+    );
+  });
+
+  test("send and Stop policy keeps both controls available during a run", () => {
+    expect(
+      canSubmitChatComposer({
+        text: "queue this",
+        hasAttachments: false,
+        hasQueuedMessages: true,
+        hasActiveRun: true,
+        isProcessingDocument: false,
+        isStopping: false
+      })
+    ).toBe(true);
+    expect(
+      canSubmitChatComposer({
+        text: "",
+        hasAttachments: false,
+        hasQueuedMessages: true,
+        hasActiveRun: true,
+        isProcessingDocument: false,
+        isStopping: false
+      })
+    ).toBe(false);
+    expect(chatComposerShowsStop(true, false)).toBe(true);
+    expect(chatComposerShowsStop(false, true)).toBe(true);
+  });
+
+  test("processing and stopping are hard submission fences", () => {
+    expect(
+      canSubmitChatComposer({
+        text: "message",
+        hasAttachments: false,
+        hasQueuedMessages: false,
+        hasActiveRun: false,
+        isProcessingDocument: true,
+        isStopping: false
+      })
+    ).toBe(false);
+    expect(
+      canSubmitChatComposer({
+        text: "message",
+        hasAttachments: false,
+        hasQueuedMessages: false,
+        hasActiveRun: false,
+        isProcessingDocument: false,
+        isStopping: true
+      })
+    ).toBe(false);
+  });
+
+  test("a blank text-only edit is disabled while an attachment-backed edit can submit", () => {
+    expect(
+      canSubmitChatComposer({
+        text: "",
+        hasAttachments: false,
+        hasQueuedMessages: true,
+        isEditingQueuedMessage: true,
+        hasActiveRun: false,
+        isProcessingDocument: false,
+        isStopping: false
+      })
+    ).toBe(false);
+    expect(
+      canSubmitChatComposer({
+        text: "",
+        hasAttachments: true,
+        hasQueuedMessages: true,
+        isEditingQueuedMessage: true,
+        hasActiveRun: false,
+        isProcessingDocument: false,
+        isStopping: false
+      })
+    ).toBe(true);
+  });
+
+  test("does not invent queue state while constructing a fixture", () => {
+    expect(emptyChatComposerQueueState()).toEqual({ items: [], edit: null });
+  });
+});
diff --git a/frontend/src/services/chatComposerSend.ts b/frontend/src/services/chatComposerSend.ts
new file mode 100644
index 000000000..6647e543f
--- /dev/null
+++ b/frontend/src/services/chatComposerSend.ts
@@ -0,0 +1,173 @@
+import {
+  chatQueuedMessageHasContent,
+  detachChatComposerDraft,
+  stageChatComposerDraft,
+  takeNextChatQueuedMessage,
+  updateChatQueuedMessage,
+  type ChatComposerDraft,
+  type ChatAccountQueueUsage,
+  type ChatQueueAdmissionFailureStatus,
+  type ChatQueuedMessage,
+  type ChatQueuedMessageMetadata,
+  MAX_CHAT_ACCOUNT_RETAINED_QUEUE_MESSAGES
+} from "./chatComposerQueue";
+
+export type ChatComposerSubmissionPlan<TComposer extends ChatComposerDraft> =
+  | Readonly<{
+      status: ChatQueueAdmissionFailureStatus | "processing" | "missing_edit";
+    }>
+  | Readonly<{ status: "queued" | "updated"; composer: TComposer }>
+  | Readonly<{
+      status: "start";
+      composer: TComposer;
+      item: ChatQueuedMessage;
+      recoverOnFailure: boolean;
+    }>;
+
+/**
+ * Applies an externally produced composer value, such as a completed voice
+ * transcription, without disturbing the draft's queue or attachment state.
+ * Callers can also use this before a send fence returns so the produced text
+ * remains editable instead of being dropped.
+ */
+export function chatComposerWithInputOverride<TComposer extends ChatComposerDraft>(
+  composer: TComposer,
+  overrideInput: string | undefined
+): TComposer {
+  if (overrideInput === undefined || overrideInput === composer.input) return composer;
+  return { ...composer, input: overrideInput };
+}
+
+/**
+ * Plans a submit as one synchronous composer mutation. In particular, a live
+ * draft is detached before image conversion or any network work can yield, so
+ * typing the next message can never be cleared by the previous send.
+ */
+export function planChatComposerSubmission<TComposer extends ChatComposerDraft>({
+  composer,
+  hasActiveRun,
+  metadata,
+  accountUsage
+}: {
+  composer: TComposer;
+  hasActiveRun: boolean;
+  metadata: ChatQueuedMessageMetadata;
+  accountUsage?: ChatAccountQueueUsage;
+}): ChatComposerSubmissionPlan<TComposer> {
+  if (composer.isProcessingDocument) return { status: "processing" };
+
+  if (composer.queue.edit) {
+    const updated = updateChatQueuedMessage(
+      composer.queue,
+      composer.queue.edit.queueId,
+      composer.input
+    );
+    if (updated.status === "text_too_large") return { status: "text_too_large" };
+    if (updated.status === "empty") return { status: "empty" };
+    if (updated.status === "missing") return { status: "missing_edit" };
+    if (updated.status !== "updated") return { status: "missing_edit" };
+
+    const updatedComposer = {
+      ...composer,
+      input: updated.restoreInput ?? composer.input,
+      queue: updated.queue
+    };
+    if (hasActiveRun) return { status: "updated", composer: updatedComposer };
+
+    const next = takeNextChatQueuedMessage(updatedComposer.queue);
+    if (next.status !== "taken") return { status: "missing_edit" };
+    return {
+      status: "start",
+      composer: { ...updatedComposer, queue: next.queue },
+      item: next.item,
+      recoverOnFailure: false
+    };
+  }
+
+  const detached = detachChatComposerDraft(composer, metadata);
+  const liveDraftHasContent = chatQueuedMessageHasContent(detached.item);
+
+  if (hasActiveRun) {
+    if (!liveDraftHasContent) return { status: "empty" };
+    const staged = stageChatComposerDraft(composer, metadata, accountUsage);
+    if (staged.status !== "enqueued") return { status: staged.status };
+    return { status: "queued", composer: staged.composer };
+  }
+
+  if (composer.queue.items.length === 0) {
+    if (!liveDraftHasContent) return { status: "empty" };
+    // Reserve one account-wide queue slot while this detached turn is in
+    // flight. If it fails before the request becomes authoritative, recovery
+    // may need to put it ahead of a draft the user typed meanwhile.
+    if (
+      accountUsage &&
+      accountUsage.queuedMessageCount >= MAX_CHAT_ACCOUNT_RETAINED_QUEUE_MESSAGES
+    ) {
+      return { status: "account_queue_full" };
+    }
+    return {
+      status: "start",
+      composer: detached.composer,
+      item: detached.item,
+      recoverOnFailure: true
+    };
+  }
+
+  const next = takeNextChatQueuedMessage(composer.queue);
+  if (next.status !== "taken") return { status: "empty" };
+
+  let preparedComposer = { ...composer, queue: next.queue };
+  if (liveDraftHasContent) {
+    // Free the oldest slot before appending the live draft. This keeps a full
+    // queue resumable without ever retaining more than the configured limit.
+    const staged = stageChatComposerDraft(preparedComposer, metadata, accountUsage);
+    if (
+      staged.status === "queue_full" ||
+      staged.status === "queue_payload_too_large" ||
+      staged.status === "account_queue_full" ||
+      staged.status === "account_payload_too_large"
+    ) {
+      // The oldest item is already retained by the active turn. Keep the live
+      // draft editable while an over-cap lossless recovery/rekey FIFO drains,
+      // or until the account-wide reservation is released.
+    } else if (staged.status !== "enqueued") {
+      return { status: staged.status };
+    } else {
+      preparedComposer = staged.composer;
+    }
+  }
+
+  return {
+    status: "start",
+    composer: preparedComposer,
+    item: next.item,
+    recoverOnFailure: false
+  };
+}
+
+export function canSubmitChatComposer({
+  text,
+  hasAttachments,
+  hasQueuedMessages,
+  isEditingQueuedMessage = false,
+  hasActiveRun,
+  isProcessingDocument,
+  isStopping
+}: {
+  text: string;
+  hasAttachments: boolean;
+  hasQueuedMessages: boolean;
+  isEditingQueuedMessage?: boolean;
+  hasActiveRun: boolean;
+  isProcessingDocument: boolean;
+  isStopping: boolean;
+}): boolean {
+  if (isProcessingDocument || isStopping) return false;
+  const hasLiveContent = Boolean(text.trim()) || hasAttachments;
+  if (isEditingQueuedMessage) return hasLiveContent;
+  return hasLiveContent || (hasQueuedMessages && !hasActiveRun);
+}
+
+export function chatComposerShowsStop(isGenerating: boolean, isStopping: boolean): boolean {
+  return isGenerating || isStopping;
+}
diff --git a/frontend/src/services/chatCurrentTurnRegistry.test.ts b/frontend/src/services/chatCurrentTurnRegistry.test.ts
new file mode 100644
index 000000000..0493d78a9
--- /dev/null
+++ b/frontend/src/services/chatCurrentTurnRegistry.test.ts
@@ -0,0 +1,91 @@
+import { describe, expect, test } from "bun:test";
+import {
+  getRegisteredChatCurrentTurnPayloads,
+  registeredChatTurnCanSettleLocallyForDeletion,
+  registerChatCurrentTurn,
+  restoreRegisteredChatTurnBeforeRequest
+} from "./chatCurrentTurnRegistry";
+
+describe("chat current turn registry", () => {
+  test("restores only a turn that has not started its Responses request", () => {
+    const store = {};
+    let requestStarted = false;
+    const restored: string[] = [];
+    const unregister = registerChatCurrentTurn(store, 7, {
+      responseRequestStarted: () => requestStarted,
+      restoreBeforeRequest: (message) => {
+        restored.push(message);
+        return true;
+      }
+    });
+
+    expect(restoreRegisteredChatTurnBeforeRequest(store, 7, "stopped")).toBe(true);
+    expect(restored).toEqual(["stopped"]);
+
+    requestStarted = true;
+    expect(restoreRegisteredChatTurnBeforeRequest(store, 7, "too late")).toBe(false);
+    expect(restored).toEqual(["stopped"]);
+
+    unregister();
+    expect(restoreRegisteredChatTurnBeforeRequest(store, 7, "missing")).toBe(false);
+  });
+
+  test("an older unregister cannot remove a replacement control", () => {
+    const store = {};
+    const first = registerChatCurrentTurn(store, 9, {
+      responseRequestStarted: () => false,
+      restoreBeforeRequest: () => false
+    });
+    let restored = false;
+    registerChatCurrentTurn(store, 9, {
+      responseRequestStarted: () => false,
+      restoreBeforeRequest: () => (restored = true),
+      retainedPayload: { queueId: "replacement" },
+      countsTowardQueueLimit: true
+    });
+
+    first();
+    expect(restoreRegisteredChatTurnBeforeRequest(store, 9, "replacement")).toBe(true);
+    expect(restored).toBe(true);
+    expect(getRegisteredChatCurrentTurnPayloads(store)).toEqual([
+      { payload: { queueId: "replacement" }, countsTowardQueueLimit: true }
+    ]);
+  });
+
+  test("restores for Stop but does not authorize deletion settlement during conversation creation", () => {
+    const store = {};
+    let createInFlight = true;
+    const restored: string[] = [];
+    registerChatCurrentTurn(store, 10, {
+      responseRequestStarted: () => false,
+      serverRequestInFlight: () => createInFlight,
+      restoreBeforeRequest: (message) => {
+        restored.push(message);
+        return true;
+      }
+    });
+
+    expect(restoreRegisteredChatTurnBeforeRequest(store, 10, "stop now")).toBe(true);
+    expect(registeredChatTurnCanSettleLocallyForDeletion(store, 10)).toBe(false);
+    createInFlight = false;
+    expect(restoreRegisteredChatTurnBeforeRequest(store, 10, "safe now")).toBe(true);
+    expect(registeredChatTurnCanSettleLocallyForDeletion(store, 10)).toBe(true);
+    expect(restored).toEqual(["stop now", "safe now"]);
+  });
+
+  test("stops retaining a payload as soon as ownership transfers back to a composer", () => {
+    const store = {};
+    let retainsPayload = true;
+    registerChatCurrentTurn(store, 11, {
+      responseRequestStarted: () => false,
+      restoreBeforeRequest: () => false,
+      retainedPayload: { queueId: "current" },
+      retainsPayload: () => retainsPayload,
+      countsTowardQueueLimit: true
+    });
+
+    expect(getRegisteredChatCurrentTurnPayloads(store)).toHaveLength(1);
+    retainsPayload = false;
+    expect(getRegisteredChatCurrentTurnPayloads(store)).toEqual([]);
+  });
+});
diff --git a/frontend/src/services/chatCurrentTurnRegistry.ts b/frontend/src/services/chatCurrentTurnRegistry.ts
new file mode 100644
index 000000000..e466cc788
--- /dev/null
+++ b/frontend/src/services/chatCurrentTurnRegistry.ts
@@ -0,0 +1,81 @@
+type ChatCurrentTurnControl = Readonly<{
+  responseRequestStarted: () => boolean;
+  serverRequestInFlight?: () => boolean;
+  restoreBeforeRequest: (message: string) => boolean;
+  retainedPayload?: unknown;
+  retainsPayload?: () => boolean;
+  countsTowardQueueLimit?: boolean;
+}>;
+
+export type RegisteredChatCurrentTurnPayload = Readonly<{
+  payload: unknown;
+  countsTowardQueueLimit: boolean;
+}>;
+
+const currentTurnsByStore = new WeakMap<object, Map<number, ChatCurrentTurnControl>>();
+
+function controlsFor(store: object): Map<number, ChatCurrentTurnControl> {
+  const existing = currentTurnsByStore.get(store);
+  if (existing) return existing;
+  const created = new Map<number, ChatCurrentTurnControl>();
+  currentTurnsByStore.set(store, created);
+  return created;
+}
+
+export function registerChatCurrentTurn(
+  store: object,
+  runToken: number,
+  control: ChatCurrentTurnControl
+): () => void {
+  const controls = controlsFor(store);
+  controls.set(runToken, control);
+  return () => {
+    if (controls.get(runToken) === control) controls.delete(runToken);
+  };
+}
+
+/**
+ * Restores a detached turn only while it is still entirely client-side. Once a
+ * Responses request starts, replaying it would risk a duplicate assistant turn.
+ */
+export function restoreRegisteredChatTurnBeforeRequest(
+  store: object,
+  runToken: number,
+  message: string
+): boolean {
+  const control = currentTurnsByStore.get(store)?.get(runToken);
+  if (!control || control.responseRequestStarted()) return false;
+  return control.restoreBeforeRequest(message);
+}
+
+/**
+ * Deletion may only retire the run locally when no server mutation is still
+ * capable of committing. Stop can abort a conversation-create request, but a
+ * destructive caller must keep waiting until that request settles.
+ */
+export function registeredChatTurnCanSettleLocallyForDeletion(
+  store: object,
+  runToken: number
+): boolean {
+  const control = currentTurnsByStore.get(store)?.get(runToken);
+  return Boolean(
+    control && !control.responseRequestStarted() && !control.serverRequestInFlight?.()
+  );
+}
+
+export function getRegisteredChatCurrentTurnPayloads(
+  store: object
+): readonly RegisteredChatCurrentTurnPayload[] {
+  const controls = currentTurnsByStore.get(store);
+  if (!controls) return [];
+  return Array.from(controls.values()).flatMap((control) =>
+    control.retainedPayload === undefined || control.retainsPayload?.() === false
+      ? []
+      : [
+          {
+            payload: control.retainedPayload,
+            countsTowardQueueLimit: control.countsTowardQueueLimit ?? false
+          }
+        ]
+  );
+}
diff --git a/frontend/src/services/chatHistoryDeletionQuiescence.test.ts b/frontend/src/services/chatHistoryDeletionQuiescence.test.ts
new file mode 100644
index 000000000..37164a61a
--- /dev/null
+++ b/frontend/src/services/chatHistoryDeletionQuiescence.test.ts
@@ -0,0 +1,360 @@
+import { describe, expect, test } from "bun:test";
+import {
+  cancelChatResponseForHistoryDeletion,
+  quiesceChatRuntimeRunsForHistoryDeletion,
+  settleChatRuntimeAfterHistoryCancellation
+} from "./chatHistoryDeletionQuiescence";
+import { registerChatCurrentTurn } from "./chatCurrentTurnRegistry";
+import { registerUnresolvedChatResponseMessage } from "./chatUnresolvedResponseOwnership";
+import {
+  ChatRuntimeStore,
+  createConversationChatKey,
+  type ChatRuntimeKey
+} from "./chatRuntimeStore";
+
+function fakeStore() {
+  const key = "conversation:active" as ChatRuntimeKey;
+  let snapshot: { runToken: number | null; currentResponseId: string | undefined } | undefined = {
+    runToken: 1,
+    currentResponseId: undefined
+  };
+  return {
+    key,
+    setSnapshot(next: typeof snapshot) {
+      snapshot = next;
+    },
+    getActiveRunKeys: () => (snapshot?.runToken === null || !snapshot ? [] : [key]),
+    get: () => snapshot,
+    setCurrentResponseId: (_key: ChatRuntimeKey, runToken: number, responseId: string) => {
+      if (!snapshot || snapshot.runToken !== runToken) return false;
+      snapshot = { ...snapshot, currentResponseId: responseId };
+      return true;
+    },
+    cancelRun: () => {
+      snapshot = undefined;
+    }
+  };
+}
+
+describe("chat history deletion quiescence", () => {
+  test("waits for conversation creation, then cancels the surfaced response", async () => {
+    const store = fakeStore();
+    const cancelled: string[] = [];
+    setTimeout(() => {
+      store.setSnapshot({ runToken: 1, currentResponseId: "response-late" });
+    }, 5);
+
+    await quiesceChatRuntimeRunsForHistoryDeletion({
+      store,
+      timeoutMs: 200,
+      cancelResponse: async (responseId) => {
+        cancelled.push(responseId);
+        store.setSnapshot(undefined);
+      }
+    });
+
+    expect(cancelled).toEqual(["response-late"]);
+  });
+
+  test("fails closed instead of deleting while a create request remains unresolved", async () => {
+    const store = fakeStore();
+
+    await expect(
+      quiesceChatRuntimeRunsForHistoryDeletion({
+        store,
+        timeoutMs: 1,
+        cancelResponse: async () => undefined
+      })
+    ).rejects.toThrow("Timed out waiting for active chat requests to stop");
+  });
+
+  test("allows a naturally completed run to settle after cancellation loses the race", async () => {
+    const store = fakeStore();
+    store.setSnapshot({ runToken: 1, currentResponseId: "response-completing" });
+
+    await quiesceChatRuntimeRunsForHistoryDeletion({
+      store,
+      timeoutMs: 200,
+      cancelResponse: async () => {
+        setTimeout(() => store.setSnapshot(undefined), 5);
+        throw new Error("response is already terminal");
+      }
+    });
+
+    expect(store.getActiveRunKeys()).toEqual([]);
+  });
+
+  test("still fails closed when cancellation rejects and the run stays active", async () => {
+    const store = fakeStore();
+    store.setSnapshot({ runToken: 1, currentResponseId: "response-stuck" });
+
+    await expect(
+      quiesceChatRuntimeRunsForHistoryDeletion({
+        store,
+        timeoutMs: 1,
+        cancelResponse: async () => {
+          throw new Error("cancel failed");
+        }
+      })
+    ).rejects.toThrow("Timed out waiting for active chat requests to stop");
+  });
+
+  test("retries a rejected cancellation while response ownership remains", async () => {
+    const store = fakeStore();
+    store.setSnapshot({ runToken: 1, currentResponseId: "response-retry" });
+    let attempts = 0;
+
+    await quiesceChatRuntimeRunsForHistoryDeletion({
+      store,
+      timeoutMs: 750,
+      cancelResponse: async () => {
+        attempts += 1;
+        if (attempts === 1) throw new Error("transient cancellation error");
+        store.setSnapshot(undefined);
+      }
+    });
+
+    expect(attempts).toBe(2);
+  });
+
+  test("bounds a cancellation request that never settles", async () => {
+    const store = fakeStore();
+    store.setSnapshot({ runToken: 1, currentResponseId: "response-hung" });
+
+    await expect(
+      quiesceChatRuntimeRunsForHistoryDeletion({
+        store,
+        timeoutMs: 5,
+        cancelResponse: () => new Promise(() => undefined)
+      })
+    ).rejects.toThrow("Timed out waiting for active chat requests to stop");
+  });
+
+  test("quiesces only exact target keys and leaves unrelated runs active", async () => {
+    const target = "conversation:target" as ChatRuntimeKey;
+    const unrelated = "conversation:unrelated" as ChatRuntimeKey;
+    const snapshots = new Map([
+      [target, { runToken: 1, currentResponseId: "response-target" }],
+      [unrelated, { runToken: 2, currentResponseId: "response-unrelated" }]
+    ]);
+    const store = {
+      getActiveRunKeys: () => Array.from(snapshots.keys()),
+      get: (key: ChatRuntimeKey) => snapshots.get(key),
+      resolveKey: (key: ChatRuntimeKey) => key,
+      cancelRun: (key: ChatRuntimeKey) => snapshots.delete(key)
+    };
+
+    await quiesceChatRuntimeRunsForHistoryDeletion({
+      store,
+      keys: [target],
+      timeoutMs: 100,
+      cancelResponse: async (responseId) => {
+        expect(responseId).toBe("response-target");
+        snapshots.delete(target);
+      }
+    });
+
+    expect(store.getActiveRunKeys()).toEqual([unrelated]);
+  });
+
+  test("includes active draft runs owned by a deleted project group", async () => {
+    const draft = "draft:project" as ChatRuntimeKey;
+    const unrelated = "draft:other" as ChatRuntimeKey;
+    const snapshots = new Map([
+      [draft, { runToken: 1, currentResponseId: "response-project" }],
+      [unrelated, { runToken: 2, currentResponseId: "response-other" }]
+    ]);
+    const store = {
+      getActiveRunKeys: () => Array.from(snapshots.keys()),
+      get: (key: ChatRuntimeKey) => snapshots.get(key),
+      getActiveRunGroupId: (key: ChatRuntimeKey) =>
+        key === draft ? "project-delete" : "project-other",
+      cancelRun: (key: ChatRuntimeKey) => snapshots.delete(key)
+    };
+
+    await quiesceChatRuntimeRunsForHistoryDeletion({
+      store,
+      activityGroupId: "project-delete",
+      timeoutMs: 100,
+      cancelResponse: async () => {
+        snapshots.delete(draft);
+      }
+    });
+
+    expect(store.getActiveRunKeys()).toEqual([unrelated]);
+  });
+
+  test("settles an offscreen detached run after durable server cancellation", async () => {
+    const store = fakeStore();
+    store.setSnapshot({ runToken: 7, currentResponseId: "response-detached" });
+    const cancelled: string[] = [];
+
+    await quiesceChatRuntimeRunsForHistoryDeletion({
+      store,
+      timeoutMs: 100,
+      cancelResponse: async (responseId) => {
+        cancelled.push(responseId);
+      }
+    });
+
+    expect(cancelled).toEqual(["response-detached"]);
+    expect(store.getActiveRunKeys()).toEqual([]);
+  });
+
+  test("recovers an offscreen response by the exact current optimistic message before deletion", async () => {
+    const store = fakeStore();
+    registerUnresolvedChatResponseMessage(store, 1, "message-current");
+    const retrieved: Array<{ messageId: string; conversationId: string }> = [];
+    const cancelled: string[] = [];
+
+    await quiesceChatRuntimeRunsForHistoryDeletion({
+      store,
+      timeoutMs: 100,
+      responseOwnershipClient: {
+        conversations: {
+          items: {
+            retrieve: async (messageId, query) => {
+              retrieved.push({ messageId, conversationId: query.conversation_id });
+              return {
+                id: "message-current",
+                role: "user",
+                response_id: "response-current"
+              };
+            }
+          }
+        }
+      },
+      cancelResponse: async (responseId) => {
+        cancelled.push(responseId);
+      }
+    });
+
+    expect(retrieved).toEqual([{ messageId: "message-current", conversationId: "active" }]);
+    expect(cancelled).toEqual(["response-current"]);
+    expect(store.getActiveRunKeys()).toEqual([]);
+  });
+
+  test("settles an offscreen run that became terminal before cancellation", async () => {
+    const store = fakeStore();
+    store.setSnapshot({ runToken: 8, currentResponseId: "response-completed" });
+    let cancelAttempts = 0;
+    let retrieveAttempts = 0;
+    const client = {
+      responses: {
+        cancel: async () => {
+          cancelAttempts += 1;
+          throw Object.assign(new Error("response is already terminal"), { status: 400 });
+        },
+        retrieve: async () => {
+          retrieveAttempts += 1;
+          return { status: "completed" };
+        }
+      }
+    };
+
+    await quiesceChatRuntimeRunsForHistoryDeletion({
+      store,
+      timeoutMs: 100,
+      cancelResponse: (responseId) => cancelChatResponseForHistoryDeletion(client, responseId)
+    });
+
+    expect(cancelAttempts).toBe(1);
+    expect(retrieveAttempts).toBe(1);
+    expect(store.getActiveRunKeys()).toEqual([]);
+  });
+
+  test("does not accept a terminal retrieval after an ambiguous cancel 503", async () => {
+    let retrieveAttempts = 0;
+    const cancellationError = Object.assign(new Error("cancel quiescence timed out"), {
+      status: 503
+    });
+    const client = {
+      responses: {
+        cancel: async () => {
+          throw cancellationError;
+        },
+        retrieve: async () => {
+          retrieveAttempts += 1;
+          return { status: "cancelled" };
+        }
+      }
+    };
+
+    await expect(
+      cancelChatResponseForHistoryDeletion(client, "response-not-quiescent")
+    ).rejects.toBe(cancellationError);
+    expect(retrieveAttempts).toBe(0);
+  });
+
+  test("locally settles preparation that has not started a server request", async () => {
+    const store = fakeStore();
+    let restored = false;
+    registerChatCurrentTurn(store, 1, {
+      responseRequestStarted: () => false,
+      serverRequestInFlight: () => false,
+      restoreBeforeRequest: () => {
+        restored = true;
+        return true;
+      }
+    });
+
+    await quiesceChatRuntimeRunsForHistoryDeletion({
+      store,
+      timeoutMs: 100,
+      cancelResponse: async () => {
+        throw new Error("no server response should be cancelled");
+      }
+    });
+
+    expect(restored).toBe(true);
+    expect(store.getActiveRunKeys()).toEqual([]);
+  });
+
+  test("does not locally settle while conversation creation is in flight", async () => {
+    const store = fakeStore();
+    let restored = false;
+    registerChatCurrentTurn(store, 1, {
+      responseRequestStarted: () => false,
+      serverRequestInFlight: () => true,
+      restoreBeforeRequest: () => {
+        restored = true;
+        return true;
+      }
+    });
+
+    await expect(
+      quiesceChatRuntimeRunsForHistoryDeletion({
+        store,
+        timeoutMs: 2,
+        cancelResponse: async () => undefined
+      })
+    ).rejects.toThrow("Timed out waiting for active chat requests to stop");
+
+    expect(restored).toBe(false);
+    expect(store.getActiveRunKeys()).toHaveLength(1);
+  });
+
+  test("marks partial items incomplete when cancellation succeeds but deletion later fails", () => {
+    const store = new ChatRuntimeStore<null, { id: string; status: string }, { input: string }>({
+      createComposer: () => ({ input: "" })
+    });
+    const key = createConversationChatKey("cancelled-before-delete");
+    store.select(key);
+    store.update(key, (snapshot) => ({
+      ...snapshot,
+      messages: [
+        { id: "user", status: "completed" },
+        { id: "assistant", status: "streaming" }
+      ]
+    }));
+    const run = store.beginRun(key);
+    store.setCurrentResponseId(key, run.token, "response-cancelled");
+
+    expect(settleChatRuntimeAfterHistoryCancellation(store, key, run.token)).toBe(true);
+    expect(store.get(key)).toMatchObject({ isGenerating: false, currentResponseId: undefined });
+    expect(store.get(key)?.messages).toEqual([
+      { id: "user", status: "completed" },
+      { id: "assistant", status: "incomplete" }
+    ]);
+  });
+});
diff --git a/frontend/src/services/chatHistoryDeletionQuiescence.ts b/frontend/src/services/chatHistoryDeletionQuiescence.ts
new file mode 100644
index 000000000..fbab121d3
--- /dev/null
+++ b/frontend/src/services/chatHistoryDeletionQuiescence.ts
@@ -0,0 +1,279 @@
+import {
+  registeredChatTurnCanSettleLocallyForDeletion,
+  restoreRegisteredChatTurnBeforeRequest
+} from "./chatCurrentTurnRegistry";
+import { conversationIdFromChatRuntimeKey } from "./chatRuntimeNavigation";
+import {
+  classifyChatResponseReconciliation,
+  responseIdForChatMessage
+} from "./chatResponseReconciliation";
+import { isChatResponseCancellationAlreadyTerminalError } from "./chatResponseErrors";
+import type { ChatRuntimeKey, ChatRuntimeStore } from "./chatRuntimeStore";
+import {
+  clearUnresolvedChatResponseMessage,
+  getUnresolvedChatResponseMessage
+} from "./chatUnresolvedResponseOwnership";
+
+type ActiveChatRuntimeLookup = object & {
+  getActiveRunKeys: () => readonly ChatRuntimeKey[];
+  resolveKey?: (key: ChatRuntimeKey) => ChatRuntimeKey;
+  getActiveRunGroupId?: (key: ChatRuntimeKey) => string | null | undefined;
+  get: (
+    key: ChatRuntimeKey
+  ) => Readonly<{ runToken: number | null; currentResponseId: string | undefined }> | undefined;
+  setCurrentResponseId?: (key: ChatRuntimeKey, runToken: number, responseId: string) => boolean;
+  cancelRun: (key: ChatRuntimeKey, runToken: number) => unknown;
+};
+
+const CHAT_HISTORY_CANCEL_REQUEST_TIMEOUT_MS = 5000;
+const CHAT_HISTORY_CANCEL_RETRY_INTERVAL_MS = 250;
+
+type ChatResponseCancellationClient = {
+  responses: {
+    cancel: (responseId: string, options?: { timeout?: number }) => PromiseLike<unknown>;
+    retrieve: (
+      responseId: string,
+      query?: undefined,
+      options?: { timeout?: number }
+    ) => PromiseLike<{ status?: string | null }>;
+  };
+};
+
+type ChatResponseOwnershipClient = {
+  conversations: {
+    items: {
+      retrieve: (
+        messageId: string,
+        query: { conversation_id: string }
+      ) => PromiseLike<{ id?: string; role?: string; response_id?: unknown }>;
+    };
+  };
+};
+
+async function recoverChatResponseOwnershipForHistoryDeletion(
+  client: ChatResponseOwnershipClient,
+  store: ActiveChatRuntimeLookup,
+  key: ChatRuntimeKey,
+  runToken: number
+): Promise<string | undefined> {
+  const messageId = getUnresolvedChatResponseMessage(store, runToken);
+  const conversationId = conversationIdFromChatRuntimeKey(store.resolveKey?.(key) ?? key);
+  if (!messageId || !conversationId || !store.setCurrentResponseId) return undefined;
+
+  try {
+    const item = await client.conversations.items.retrieve(messageId, {
+      conversation_id: conversationId
+    });
+    const responseId = responseIdForChatMessage(messageId, [item]);
+    if (!responseId || !store.setCurrentResponseId(key, runToken, responseId)) return undefined;
+    clearUnresolvedChatResponseMessage(store, runToken, messageId);
+    return responseId;
+  } catch (error) {
+    if ((error as { status?: unknown })?.status === 404) return undefined;
+    throw error;
+  }
+}
+
+export async function cancelChatResponseForHistoryDeletion(
+  client: ChatResponseCancellationClient,
+  responseId: string
+): Promise<unknown> {
+  try {
+    return await client.responses.cancel(responseId, {
+      timeout: CHAT_HISTORY_CANCEL_REQUEST_TIMEOUT_MS
+    });
+  } catch (cancellationError) {
+    if (!isChatResponseCancellationAlreadyTerminalError(cancellationError)) {
+      throw cancellationError;
+    }
+    // A detached response can finish between discovery and cancellation. Its
+    // cancel endpoint's explicit 400 certifies that execution is quiescent even
+    // though deletion still needs to confirm the exact durable terminal state.
+    try {
+      const response = await client.responses.retrieve(responseId, undefined, {
+        timeout: CHAT_HISTORY_CANCEL_REQUEST_TIMEOUT_MS
+      });
+      if (classifyChatResponseReconciliation(response.status) !== "pending") {
+        return response;
+      }
+    } catch {
+      // Preserve the cancellation failure so the bounded quiescence loop can
+      // retry. A failed status check is never permission to delete.
+    }
+    throw cancellationError;
+  }
+}
+
+/** Keep a failed destructive request renderable after its response was already cancelled. */
+export function settleChatRuntimeAfterHistoryCancellation<TConversation, TMessage, TComposer>(
+  store: ChatRuntimeStore<TConversation, TMessage, TComposer>,
+  key: ChatRuntimeKey,
+  runToken: number
+): boolean {
+  const cancelled = store.cancelRun(key, runToken);
+  if (!cancelled) return false;
+  store.update(key, (snapshot) => ({
+    ...snapshot,
+    messages: snapshot.messages.map((message) => {
+      if (!message || typeof message !== "object" || !("status" in message)) return message;
+      const status = (message as { status?: unknown }).status;
+      if (status !== "in_progress" && status !== "streaming" && status !== "searching") {
+        return message;
+      }
+      return { ...message, status: "incomplete" } as TMessage;
+    })
+  }));
+  return true;
+}
+
+function deletionTimeoutError(): Error {
+  return new Error("Timed out waiting for active chat requests to stop");
+}
+
+async function settleCancellationRequestsBeforeDeadline(
+  requests: readonly Promise<unknown>[],
+  deadline: number
+): Promise<PromiseSettledResult<unknown>[]> {
+  if (requests.length === 0) return [];
+  const remainingMs = deadline - Date.now();
+  if (remainingMs <= 0) throw deletionTimeoutError();
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      Promise.allSettled(requests),
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => reject(deletionTimeoutError()), remainingMs);
+      })
+    ]);
+  } finally {
+    if (timeout !== undefined) clearTimeout(timeout);
+  }
+}
+
+export async function quiesceChatRuntimeRunsForHistoryDeletion({
+  store,
+  cancelResponse,
+  responseOwnershipClient,
+  settleCancelledRun,
+  keys,
+  activityGroupId,
+  timeoutMs = 30_000
+}: {
+  store: ActiveChatRuntimeLookup;
+  cancelResponse: (responseId: string) => Promise<unknown>;
+  responseOwnershipClient?: ChatResponseOwnershipClient;
+  settleCancelledRun?: (key: ChatRuntimeKey, runToken: number) => unknown;
+  keys?: readonly ChatRuntimeKey[];
+  activityGroupId?: string;
+  timeoutMs?: number;
+}): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  const cancellationAccepted = new Set<string>();
+  const cancellationLastAttemptMs = new Map<string, number>();
+  const ownershipLastAttemptMs = new Map<string, number>();
+  const resolveKey = (key: ChatRuntimeKey) => store.resolveKey?.(key) ?? key;
+  const targetActiveRunKeys = () => {
+    const activeKeys = store.getActiveRunKeys();
+    if (!keys && !activityGroupId) return activeKeys;
+    return activeKeys.filter(
+      (activeKey) =>
+        keys?.some((key) => resolveKey(key) === resolveKey(activeKey)) ||
+        (activityGroupId !== undefined &&
+          store.getActiveRunGroupId?.(activeKey) === activityGroupId)
+    );
+  };
+
+  while (targetActiveRunKeys().length > 0) {
+    const responseIds: string[] = [];
+    const ownershipRequests: Promise<unknown>[] = [];
+    const now = Date.now();
+    for (const key of targetActiveRunKeys()) {
+      const snapshot = store.get(key);
+      if (!snapshot || snapshot.runToken === null) continue;
+      const canSettleLocally = registeredChatTurnCanSettleLocallyForDeletion(
+        store,
+        snapshot.runToken
+      );
+      const restoredLocally =
+        canSettleLocally &&
+        restoreRegisteredChatTurnBeforeRequest(
+          store,
+          snapshot.runToken,
+          "Sending paused while chat history is being deleted."
+        );
+      if (restoredLocally) {
+        store.cancelRun(key, snapshot.runToken);
+        clearUnresolvedChatResponseMessage(store, snapshot.runToken);
+        continue;
+      }
+      if (!snapshot.currentResponseId && responseOwnershipClient) {
+        const ownershipKey = `${resolveKey(key)}:${snapshot.runToken}`;
+        const lastOwnershipAttempt = ownershipLastAttemptMs.get(ownershipKey);
+        if (
+          lastOwnershipAttempt === undefined ||
+          now - lastOwnershipAttempt >= CHAT_HISTORY_CANCEL_RETRY_INTERVAL_MS
+        ) {
+          ownershipLastAttemptMs.set(ownershipKey, now);
+          ownershipRequests.push(
+            recoverChatResponseOwnershipForHistoryDeletion(
+              responseOwnershipClient,
+              store,
+              key,
+              snapshot.runToken
+            )
+          );
+        }
+      }
+      const lastAttempt = snapshot.currentResponseId
+        ? cancellationLastAttemptMs.get(snapshot.currentResponseId)
+        : undefined;
+      if (
+        snapshot.currentResponseId &&
+        !cancellationAccepted.has(snapshot.currentResponseId) &&
+        (lastAttempt === undefined || now - lastAttempt >= CHAT_HISTORY_CANCEL_RETRY_INTERVAL_MS)
+      ) {
+        cancellationLastAttemptMs.set(snapshot.currentResponseId, now);
+        responseIds.push(snapshot.currentResponseId);
+      }
+    }
+
+    await settleCancellationRequestsBeforeDeadline(ownershipRequests, deadline);
+
+    // Cancellation can lose a race with natural completion: the endpoint then
+    // rejects because the response is already terminal even though its SSE
+    // terminal frame is about to settle the local run. Treat cancellation as a
+    // request, then keep the deletion fence closed until every run actually
+    // settles (or the bounded timeout fails closed).
+    const cancellationResults = await settleCancellationRequestsBeforeDeadline(
+      responseIds.map(cancelResponse),
+      deadline
+    );
+    cancellationResults.forEach((result, index) => {
+      if (result.status !== "fulfilled") return;
+      const responseId = responseIds[index];
+      cancellationAccepted.add(responseId);
+      // The cancellation endpoint commits terminal response ownership before
+      // it resolves. An offscreen detached run has no SSE listener left to
+      // settle its client token, so retire that exact response locally here.
+      for (const key of targetActiveRunKeys()) {
+        const snapshot = store.get(key);
+        if (
+          snapshot?.runToken !== null &&
+          snapshot?.runToken !== undefined &&
+          snapshot.currentResponseId === responseId
+        ) {
+          if (settleCancelledRun) settleCancelledRun(key, snapshot.runToken);
+          else store.cancelRun(key, snapshot.runToken);
+        }
+      }
+    });
+    if (targetActiveRunKeys().length === 0) return;
+    if (Date.now() >= deadline) {
+      throw deletionTimeoutError();
+    }
+    // A conversation-create request has no response ID yet. Let it settle and
+    // surface its ID (if any), then cancel it before issuing delete-all.
+    await new Promise((resolve) => setTimeout(resolve, Math.min(25, deadline - Date.now())));
+  }
+}
diff --git a/frontend/src/services/chatPollingPage.test.ts b/frontend/src/services/chatPollingPage.test.ts
new file mode 100644
index 000000000..cf4fdc2b3
--- /dev/null
+++ b/frontend/src/services/chatPollingPage.test.ts
@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import { normalizeChatPollingPage } from "./chatPollingPage";
+
+const oldest = { id: "oldest", status: "completed" };
+const middle = { id: "middle", status: "completed" };
+const newest = { id: "newest", status: "in_progress" };
+
+describe("normalizeChatPollingPage", () => {
+  test("keeps cursor-based ascending pages chronological", () => {
+    const normalized = normalizeChatPollingPage([oldest, middle, newest], true);
+
+    expect(normalized.chronologicalItems.map((item) => item.id)).toEqual([
+      "oldest",
+      "middle",
+      "newest"
+    ]);
+    expect(normalized.newestCompletedItem?.id).toBe("middle");
+  });
+
+  test("reverses a no-cursor descending recovery page before merging", () => {
+    const normalized = normalizeChatPollingPage([newest, middle, oldest], false);
+
+    expect(normalized.chronologicalItems.map((item) => item.id)).toEqual([
+      "oldest",
+      "middle",
+      "newest"
+    ]);
+    expect(normalized.newestCompletedItem?.id).toBe("middle");
+  });
+});
diff --git a/frontend/src/services/chatPollingPage.ts b/frontend/src/services/chatPollingPage.ts
new file mode 100644
index 000000000..6ab39a306
--- /dev/null
+++ b/frontend/src/services/chatPollingPage.ts
@@ -0,0 +1,19 @@
+export type NormalizedChatPollingPage<T> = Readonly<{
+  chronologicalItems: T[];
+  newestCompletedItem: T | undefined;
+}>;
+
+/**
+ * Cursor polls arrive ascending. A recovery poll without a durable cursor asks
+ * for the newest page descending, then reverses it before transcript merging.
+ */
+export function normalizeChatPollingPage<T extends { id?: string; status?: string | null }>(
+  items: readonly T[],
+  hasCursor: boolean
+): NormalizedChatPollingPage<T> {
+  const newestFirst = hasCursor ? [...items].reverse() : [...items];
+  return {
+    chronologicalItems: hasCursor ? [...items] : [...items].reverse(),
+    newestCompletedItem: newestFirst.find((item) => item.status !== "in_progress")
+  };
+}
diff --git a/frontend/src/services/chatResponseErrors.test.ts b/frontend/src/services/chatResponseErrors.test.ts
index dbb480d2a..53213c784 100644
--- a/frontend/src/services/chatResponseErrors.test.ts
+++ b/frontend/src/services/chatResponseErrors.test.ts
@@ -1,8 +1,15 @@
 import { describe, expect, test } from "bun:test";
 import { APIConnectionError } from "openai";
-import { isImageDescriptionUnavailableError } from "./chatResponseErrors";
+import {
+  isChatRequestDefinitelyNotDispatchedError,
+  isChatResponseCancellationAlreadyTerminalError,
+  isChatResponseDefinitelyRejectedError,
+  isImageDescriptionUnavailableError
+} from "./chatResponseErrors";
 
-function codedError(
+const REQUEST_NOT_DISPATCHED_CODE = "opensecret_request_not_dispatched";
+
+function codedImageDescriptionError(
   status = 503,
   contract = "1",
   code = "image_description_unavailable"
@@ -16,21 +23,78 @@ function codedError(
   });
 }
 
-describe("Responses error classification", () => {
+describe("chat response error ownership", () => {
+  test("recognizes a nested SDK pre-transport marker without replacing error identity", () => {
+    const root = Object.assign(new Error("attestation failed"), {
+      requestDispatchCode: REQUEST_NOT_DISPATCHED_CODE,
+      definitelyNotDispatched: true
+    });
+
+    expect(isChatRequestDefinitelyNotDispatchedError(new Error("wrapped", { cause: root }))).toBe(
+      true
+    );
+  });
+
+  test("recognizes ordinary application rejections", () => {
+    expect(isChatResponseDefinitelyRejectedError({ status: 400 })).toBe(true);
+    expect(isChatResponseDefinitelyRejectedError({ cause: { status: 422 } })).toBe(true);
+    expect(isChatResponseDefinitelyRejectedError({ status: 429 })).toBe(true);
+    expect(
+      isChatResponseDefinitelyRejectedError({
+        status: 503,
+        headers: new Headers({
+          "x-opensecret-error-contract": "1",
+          "x-opensecret-error-code": "image_description_unavailable"
+        })
+      })
+    ).toBe(true);
+  });
+
+  test("keeps transport failures, server failures, and request timeouts ambiguous", () => {
+    expect(isChatRequestDefinitelyNotDispatchedError(new TypeError("fetch failed"))).toBe(false);
+    expect(isChatResponseDefinitelyRejectedError({ status: 500 })).toBe(false);
+    expect(
+      isChatResponseDefinitelyRejectedError({
+        status: 500,
+        headers: new Headers({ "x-opensecret-error-contract": "1" })
+      })
+    ).toBe(false);
+    expect(
+      isChatResponseDefinitelyRejectedError({
+        status: 503,
+        headers: new Headers({ "x-opensecret-error-contract": "1" })
+      })
+    ).toBe(false);
+    expect(isChatResponseDefinitelyRejectedError({ status: 408 })).toBe(false);
+  });
+
+  test("only recognizes the cancel endpoint's already-terminal response", () => {
+    expect(isChatResponseCancellationAlreadyTerminalError({ status: 400 })).toBe(true);
+    expect(isChatResponseCancellationAlreadyTerminalError({ cause: { status: 400 } })).toBe(true);
+    expect(isChatResponseCancellationAlreadyTerminalError({ status: 503 })).toBe(false);
+    expect(isChatResponseCancellationAlreadyTerminalError(new TypeError("fetch failed"))).toBe(
+      false
+    );
+  });
+});
+
+describe("image-description error classification", () => {
   test("recognizes the coded descriptor failure through the OpenAI connection wrapper", () => {
-    const error = new APIConnectionError({ cause: codedError() });
+    const error = new APIConnectionError({ cause: codedImageDescriptionError() });
 
     expect(isImageDescriptionUnavailableError(error)).toBe(true);
   });
 
   test("recognizes a top-level OpenAI-style HTTP error", () => {
-    expect(isImageDescriptionUnavailableError(codedError())).toBe(true);
+    expect(isImageDescriptionUnavailableError(codedImageDescriptionError())).toBe(true);
   });
 
   test("fails closed for unrelated or malformed errors", () => {
-    expect(isImageDescriptionUnavailableError(codedError(500))).toBe(false);
-    expect(isImageDescriptionUnavailableError(codedError(503, "2"))).toBe(false);
-    expect(isImageDescriptionUnavailableError(codedError(503, "1", "other_error"))).toBe(false);
+    expect(isImageDescriptionUnavailableError(codedImageDescriptionError(500))).toBe(false);
+    expect(isImageDescriptionUnavailableError(codedImageDescriptionError(503, "2"))).toBe(false);
+    expect(
+      isImageDescriptionUnavailableError(codedImageDescriptionError(503, "1", "other_error"))
+    ).toBe(false);
     expect(
       isImageDescriptionUnavailableError(
         Object.assign(new Error("missing contract"), {
diff --git a/frontend/src/services/chatResponseErrors.ts b/frontend/src/services/chatResponseErrors.ts
index 3af0d63ba..e6ae65034 100644
--- a/frontend/src/services/chatResponseErrors.ts
+++ b/frontend/src/services/chatResponseErrors.ts
@@ -4,22 +4,71 @@ const ERROR_CONTRACT_VERSION = "1";
 const IMAGE_DESCRIPTION_UNAVAILABLE_ERROR_CODE = "image_description_unavailable";
 const IMAGE_DESCRIPTION_UNAVAILABLE_STATUS = 503;
 const MAX_ERROR_CAUSE_DEPTH = 4;
+const REQUEST_NOT_DISPATCHED_CODE = "opensecret_request_not_dispatched";
 
 type ErrorResponseMetadata = {
   status?: unknown;
   headers?: unknown;
   cause?: unknown;
+  requestDispatchCode?: unknown;
+  definitelyNotDispatched?: unknown;
 };
 
-export function isImageDescriptionUnavailableError(error: unknown): boolean {
+function errorCauseChain(error: unknown): readonly ErrorResponseMetadata[] {
+  const chain: ErrorResponseMetadata[] = [];
   const seen = new Set<object>();
   let current = error;
 
   for (let depth = 0; depth < MAX_ERROR_CAUSE_DEPTH; depth += 1) {
-    if (typeof current !== "object" || current === null || seen.has(current)) return false;
+    if (typeof current !== "object" || current === null || seen.has(current)) break;
     seen.add(current);
-
     const metadata = current as ErrorResponseMetadata;
+    chain.push(metadata);
+    current = metadata.cause;
+  }
+
+  return chain;
+}
+
+export function isChatRequestDefinitelyNotDispatchedError(error: unknown): boolean {
+  return errorCauseChain(error).some(
+    (metadata) =>
+      metadata.requestDispatchCode === REQUEST_NOT_DISPATCHED_CODE &&
+      metadata.definitelyNotDispatched === true
+  );
+}
+
+/**
+ * The Responses cancel endpoint returns 400 for an already-terminal race only
+ * after its execution owner is quiescent. Other cancellation failures do not
+ * certify that background work has stopped, even if a separate retrieve sees a
+ * terminal database status.
+ */
+export function isChatResponseCancellationAlreadyTerminalError(error: unknown): boolean {
+  return errorCauseChain(error).some((metadata) => metadata.status === 400);
+}
+
+/**
+ * A non-timeout 4xx, or the explicit image-description pre-acceptance error,
+ * rejected the turn before Responses persistence. The generic error-contract
+ * version only describes the response schema, so other server failures remain
+ * ambiguous.
+ */
+export function isChatResponseDefinitelyRejectedError(error: unknown): boolean {
+  return errorCauseChain(error).some((metadata) => {
+    if (typeof metadata.status !== "number" || metadata.status === 408) return false;
+    if (metadata.status >= 400 && metadata.status < 500) return true;
+    return (
+      metadata.status === IMAGE_DESCRIPTION_UNAVAILABLE_STATUS &&
+      metadata.headers instanceof Headers &&
+      metadata.headers.get(ERROR_CONTRACT_HEADER) === ERROR_CONTRACT_VERSION &&
+      metadata.headers.get(ERROR_CODE_HEADER) === IMAGE_DESCRIPTION_UNAVAILABLE_ERROR_CODE
+    );
+  });
+}
+
+export function isImageDescriptionUnavailableError(error: unknown): boolean {
+  for (const metadata of errorCauseChain(error)) {
     if (
       metadata.status === IMAGE_DESCRIPTION_UNAVAILABLE_STATUS &&
       metadata.headers instanceof Headers &&
@@ -28,8 +77,6 @@ export function isImageDescriptionUnavailableError(error: unknown): boolean {
     ) {
       return true;
     }
-
-    current = metadata.cause;
   }
 
   return false;
diff --git a/frontend/src/services/chatResponseReconciliation.test.ts b/frontend/src/services/chatResponseReconciliation.test.ts
new file mode 100644
index 000000000..e95e7c4ae
--- /dev/null
+++ b/frontend/src/services/chatResponseReconciliation.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import {
+  classifyChatResponseReconciliation,
+  responseIdForChatMessage
+} from "./chatResponseReconciliation";
+
+describe("chat response reconciliation", () => {
+  test("distinguishes durable completion, other terminal states, and live work", () => {
+    expect(classifyChatResponseReconciliation("completed")).toBe("completed");
+    expect(classifyChatResponseReconciliation("failed")).toBe("terminal");
+    expect(classifyChatResponseReconciliation("cancelled")).toBe("terminal");
+    expect(classifyChatResponseReconciliation("incomplete")).toBe("terminal");
+    expect(classifyChatResponseReconciliation("queued")).toBe("pending");
+    expect(classifyChatResponseReconciliation("in_progress")).toBe("pending");
+    expect(classifyChatResponseReconciliation(undefined)).toBe("pending");
+  });
+
+  test("recovers only the response linked to the exact current user turn", () => {
+    expect(
+      responseIdForChatMessage("current-turn", [
+        { id: "old-failure", role: "user", response_id: "response-old" },
+        { id: "other-tab", role: "user", response_id: "response-other" },
+        { id: "current-turn", role: "user", response_id: "response-current" }
+      ])
+    ).toBe("response-current");
+  });
+
+  test("rejects older links, assistant links, and malformed response IDs", () => {
+    expect(
+      responseIdForChatMessage("current-turn", [
+        { id: "old-failure", role: "user", response_id: "response-old" }
+      ])
+    ).toBeUndefined();
+    expect(
+      responseIdForChatMessage("current-turn", [
+        { id: "current-turn", role: "assistant", response_id: "response-current" },
+        { id: "current-turn", role: "user", response_id: 42 }
+      ])
+    ).toBeUndefined();
+  });
+});
diff --git a/frontend/src/services/chatResponseReconciliation.ts b/frontend/src/services/chatResponseReconciliation.ts
new file mode 100644
index 000000000..0eb74376a
--- /dev/null
+++ b/frontend/src/services/chatResponseReconciliation.ts
@@ -0,0 +1,36 @@
+export type ChatResponseReconciliation = "completed" | "terminal" | "pending";
+
+type ChatResponseLinkedConversationItem = Readonly<{
+  id?: string;
+  role?: string;
+  response_id?: unknown;
+}>;
+
+export function classifyChatResponseReconciliation(
+  status: string | null | undefined
+): ChatResponseReconciliation {
+  if (status === "completed") return "completed";
+  if (status === "failed" || status === "cancelled" || status === "incomplete") {
+    return "terminal";
+  }
+  return "pending";
+}
+
+/**
+ * Recovers the response that owns one exact optimistic user item when the
+ * streaming request was accepted but its `response.created` frame never
+ * reached Maple.
+ */
+export function responseIdForChatMessage(
+  messageId: string,
+  polledItems: readonly ChatResponseLinkedConversationItem[]
+): string | undefined {
+  for (const item of polledItems) {
+    if (item.id !== messageId || item.role !== "user") continue;
+    if (typeof item.response_id === "string" && item.response_id.length > 0) {
+      return item.response_id;
+    }
+  }
+
+  return undefined;
+}
diff --git a/frontend/src/services/chatRunQueueHalt.test.ts b/frontend/src/services/chatRunQueueHalt.test.ts
new file mode 100644
index 000000000..d15711ba9
--- /dev/null
+++ b/frontend/src/services/chatRunQueueHalt.test.ts
@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import {
+  clearChatRunQueueHalt,
+  isChatRunQueueHaltRequested,
+  requestChatRunQueueHalt
+} from "./chatRunQueueHalt";
+
+describe("chat run queue halt", () => {
+  test("keeps Stop intent scoped to one store and outer run token", () => {
+    const firstStore = {};
+    const secondStore = {};
+
+    requestChatRunQueueHalt(firstStore, 7);
+    expect(isChatRunQueueHaltRequested(firstStore, 7)).toBe(true);
+    expect(isChatRunQueueHaltRequested(firstStore, 8)).toBe(false);
+    expect(isChatRunQueueHaltRequested(secondStore, 7)).toBe(false);
+
+    clearChatRunQueueHalt(firstStore, 7);
+    expect(isChatRunQueueHaltRequested(firstStore, 7)).toBe(false);
+  });
+
+  test("clearing one halted run preserves another", () => {
+    const store = {};
+    requestChatRunQueueHalt(store, 1);
+    requestChatRunQueueHalt(store, 2);
+
+    clearChatRunQueueHalt(store, 1);
+    expect(isChatRunQueueHaltRequested(store, 1)).toBe(false);
+    expect(isChatRunQueueHaltRequested(store, 2)).toBe(true);
+  });
+});
diff --git a/frontend/src/services/chatRunQueueHalt.ts b/frontend/src/services/chatRunQueueHalt.ts
new file mode 100644
index 000000000..0b2c2aded
--- /dev/null
+++ b/frontend/src/services/chatRunQueueHalt.ts
@@ -0,0 +1,24 @@
+const haltedRunTokensByStore = new WeakMap<object, Set<number>>();
+
+/**
+ * Sticky Stop intent for one outer Chat FIFO runner. This is deliberately
+ * separate from the transient cancellation-in-flight UI state: a failed remote
+ * cancellation may be retried, but the current runner must still never promote
+ * another queued turn after the user pressed Stop.
+ */
+export function requestChatRunQueueHalt(store: object, runToken: number): void {
+  const halted = haltedRunTokensByStore.get(store) ?? new Set<number>();
+  halted.add(runToken);
+  haltedRunTokensByStore.set(store, halted);
+}
+
+export function isChatRunQueueHaltRequested(store: object, runToken: number): boolean {
+  return haltedRunTokensByStore.get(store)?.has(runToken) ?? false;
+}
+
+export function clearChatRunQueueHalt(store: object, runToken: number): void {
+  const halted = haltedRunTokensByStore.get(store);
+  if (!halted) return;
+  halted.delete(runToken);
+  if (halted.size === 0) haltedRunTokensByStore.delete(store);
+}
diff --git a/frontend/src/services/chatRuntimeCancellation.ts b/frontend/src/services/chatRuntimeCancellation.ts
new file mode 100644
index 000000000..6dd79c51f
--- /dev/null
+++ b/frontend/src/services/chatRuntimeCancellation.ts
@@ -0,0 +1,23 @@
+import { restoreRegisteredChatTurnBeforeRequest } from "./chatCurrentTurnRegistry";
+import type { ChatRuntimeKey } from "./chatRuntimeStore";
+
+type CancellableChatRuntimeStore = object & {
+  getActiveRunKeys: () => readonly ChatRuntimeKey[];
+  get: (key: ChatRuntimeKey) => Readonly<{ runToken: number | null }> | undefined;
+  cancelRun: (key: ChatRuntimeKey, token: number) => unknown;
+};
+
+/** Synchronously fences every active client runner at an account boundary. */
+export function cancelActiveChatRuntimeRuns(store: CancellableChatRuntimeStore): void {
+  for (const key of store.getActiveRunKeys()) {
+    const token = store.get(key)?.runToken;
+    if (token !== null && token !== undefined) {
+      restoreRegisteredChatTurnBeforeRequest(
+        store,
+        token,
+        "Sending stopped because this account session is closing."
+      );
+      store.cancelRun(key, token);
+    }
+  }
+}
diff --git a/frontend/src/services/chatRuntimeDeletionFence.test.ts b/frontend/src/services/chatRuntimeDeletionFence.test.ts
new file mode 100644
index 000000000..6d9da94d4
--- /dev/null
+++ b/frontend/src/services/chatRuntimeDeletionFence.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test";
+import {
+  beginAllChatRuntimeDeletionFence,
+  beginChatActivityGroupDeletionFence,
+  beginChatProjectRuntimeDeletionFence,
+  beginChatRuntimeDeletionFence,
+  isChatRuntimeDeletionPending
+} from "./chatRuntimeDeletionFence";
+import type { ChatRuntimeKey } from "./chatRuntimeStore";
+
+function lookup() {
+  const aliases = new Map<ChatRuntimeKey, ChatRuntimeKey>();
+  const groups = new Map<ChatRuntimeKey, string | null>();
+  return {
+    aliases,
+    groups,
+    resolveKey(key: ChatRuntimeKey) {
+      return aliases.get(key) ?? key;
+    },
+    getActivityGroupId(key: ChatRuntimeKey) {
+      return groups.get(this.resolveKey(key));
+    }
+  };
+}
+
+describe("chat runtime deletion fences", () => {
+  test("fences every runtime while all history is being deleted", () => {
+    const store = lookup();
+    const firstRelease = beginAllChatRuntimeDeletionFence(store);
+    const secondRelease = beginAllChatRuntimeDeletionFence(store);
+    const key = "conversation:any" as ChatRuntimeKey;
+
+    expect(isChatRuntimeDeletionPending(store, key)).toBe(true);
+    firstRelease();
+    firstRelease();
+    expect(isChatRuntimeDeletionPending(store, key)).toBe(true);
+    secondRelease();
+    expect(isChatRuntimeDeletionPending(store, key)).toBe(false);
+  });
+
+  test("fences one runtime through rekey and releases it after deletion settles", () => {
+    const store = lookup();
+    const draftKey = "draft:deleting" as ChatRuntimeKey;
+    const conversationKey = "conversation:deleting" as ChatRuntimeKey;
+    const release = beginChatRuntimeDeletionFence(store, draftKey);
+
+    expect(isChatRuntimeDeletionPending(store, draftKey)).toBe(true);
+    store.aliases.set(draftKey, conversationKey);
+    expect(isChatRuntimeDeletionPending(store, conversationKey)).toBe(true);
+
+    release();
+    expect(isChatRuntimeDeletionPending(store, conversationKey)).toBe(false);
+  });
+
+  test("keeps one runtime fenced until every overlapping lease releases", () => {
+    const store = lookup();
+    const key = "conversation:overlapping" as ChatRuntimeKey;
+    const firstRelease = beginChatRuntimeDeletionFence(store, key);
+    const secondRelease = beginChatRuntimeDeletionFence(store, key);
+
+    expect(isChatRuntimeDeletionPending(store, key)).toBe(true);
+    firstRelease();
+    firstRelease();
+    expect(isChatRuntimeDeletionPending(store, key)).toBe(true);
+    secondRelease();
+    expect(isChatRuntimeDeletionPending(store, key)).toBe(false);
+  });
+
+  test("fences every runtime in a deleting activity group", () => {
+    const store = lookup();
+    const first = "conversation:first" as ChatRuntimeKey;
+    const second = "draft:second" as ChatRuntimeKey;
+    const unrelated = "conversation:unrelated" as ChatRuntimeKey;
+    store.groups.set(first, "project:deleting");
+    store.groups.set(second, "project:deleting");
+    store.groups.set(unrelated, "project:other");
+    const release = beginChatActivityGroupDeletionFence(store, "project:deleting");
+
+    expect(isChatRuntimeDeletionPending(store, first)).toBe(true);
+    expect(isChatRuntimeDeletionPending(store, second)).toBe(true);
+    expect(isChatRuntimeDeletionPending(store, unrelated)).toBe(false);
+
+    release();
+    expect(isChatRuntimeDeletionPending(store, first)).toBe(false);
+  });
+
+  test("keeps an activity group fenced until every overlapping lease releases", () => {
+    const store = lookup();
+    const key = "conversation:project-overlap" as ChatRuntimeKey;
+    store.groups.set(key, "project:overlapping");
+    const firstRelease = beginChatActivityGroupDeletionFence(store, "project:overlapping");
+    const secondRelease = beginChatActivityGroupDeletionFence(store, "project:overlapping");
+
+    expect(isChatRuntimeDeletionPending(store, key)).toBe(true);
+    firstRelease();
+    firstRelease();
+    expect(isChatRuntimeDeletionPending(store, key)).toBe(true);
+    secondRelease();
+    expect(isChatRuntimeDeletionPending(store, key)).toBe(false);
+  });
+
+  test("project deletion also fences exact conversations whose group metadata is unavailable", () => {
+    const store = lookup();
+    const grouped = "conversation:grouped" as ChatRuntimeKey;
+    const metadataUnavailable = "conversation:metadata-unavailable" as ChatRuntimeKey;
+    const unrelated = "conversation:unrelated" as ChatRuntimeKey;
+    store.groups.set(grouped, "project:deleting");
+    store.groups.set(metadataUnavailable, null);
+    store.groups.set(unrelated, null);
+
+    const release = beginChatProjectRuntimeDeletionFence(store, "project:deleting", [
+      metadataUnavailable
+    ]);
+
+    expect(isChatRuntimeDeletionPending(store, grouped)).toBe(true);
+    expect(isChatRuntimeDeletionPending(store, metadataUnavailable)).toBe(true);
+    expect(isChatRuntimeDeletionPending(store, unrelated)).toBe(false);
+    release();
+    release();
+    expect(isChatRuntimeDeletionPending(store, grouped)).toBe(false);
+    expect(isChatRuntimeDeletionPending(store, metadataUnavailable)).toBe(false);
+  });
+});
diff --git a/frontend/src/services/chatRuntimeDeletionFence.ts b/frontend/src/services/chatRuntimeDeletionFence.ts
new file mode 100644
index 000000000..bfa195e81
--- /dev/null
+++ b/frontend/src/services/chatRuntimeDeletionFence.ts
@@ -0,0 +1,108 @@
+import type { ChatRuntimeKey } from "./chatRuntimeStore";
+
+type ChatRuntimeDeletionLookup = object & {
+  resolveKey: (key: ChatRuntimeKey) => ChatRuntimeKey;
+  getActivityGroupId: (key: ChatRuntimeKey) => string | null | undefined;
+};
+
+type ChatRuntimeDeletionFences = {
+  keys: Map<ChatRuntimeKey, number>;
+  activityGroups: Map<string, number>;
+  all: number;
+};
+
+const deletionFencesByStore = new WeakMap<object, ChatRuntimeDeletionFences>();
+
+function fencesFor(store: object): ChatRuntimeDeletionFences {
+  const existing = deletionFencesByStore.get(store);
+  if (existing) return existing;
+  const created = {
+    keys: new Map<ChatRuntimeKey, number>(),
+    activityGroups: new Map<string, number>(),
+    all: 0
+  };
+  deletionFencesByStore.set(store, created);
+  return created;
+}
+
+export function beginAllChatRuntimeDeletionFence(store: object): () => void {
+  const fences = fencesFor(store);
+  fences.all += 1;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    fences.all = Math.max(0, fences.all - 1);
+  };
+}
+
+export function beginChatRuntimeDeletionFence(
+  store: ChatRuntimeDeletionLookup,
+  key: ChatRuntimeKey
+): () => void {
+  const fences = fencesFor(store);
+  const fencedKey = store.resolveKey(key);
+  fences.keys.set(fencedKey, (fences.keys.get(fencedKey) ?? 0) + 1);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const remaining = (fences.keys.get(fencedKey) ?? 0) - 1;
+    if (remaining > 0) fences.keys.set(fencedKey, remaining);
+    else fences.keys.delete(fencedKey);
+  };
+}
+
+export function beginChatActivityGroupDeletionFence(
+  store: ChatRuntimeDeletionLookup,
+  activityGroupId: string
+): () => void {
+  const fences = fencesFor(store);
+  fences.activityGroups.set(activityGroupId, (fences.activityGroups.get(activityGroupId) ?? 0) + 1);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const remaining = (fences.activityGroups.get(activityGroupId) ?? 0) - 1;
+    if (remaining > 0) fences.activityGroups.set(activityGroupId, remaining);
+    else fences.activityGroups.delete(activityGroupId);
+  };
+}
+
+/**
+ * Fences both the runtime's cached activity group and exact conversation keys
+ * discovered from the server. Exact keys cover runtimes whose metadata could
+ * not be loaded, and therefore do not yet expose their project group locally.
+ */
+export function beginChatProjectRuntimeDeletionFence(
+  store: ChatRuntimeDeletionLookup,
+  activityGroupId: string,
+  conversationKeys: readonly ChatRuntimeKey[]
+): () => void {
+  const releases = [
+    beginChatActivityGroupDeletionFence(store, activityGroupId),
+    ...conversationKeys.map((key) => beginChatRuntimeDeletionFence(store, key))
+  ];
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    for (const release of releases.reverse()) release();
+  };
+}
+
+export function isChatRuntimeDeletionPending(
+  store: ChatRuntimeDeletionLookup,
+  key: ChatRuntimeKey
+): boolean {
+  const fences = deletionFencesByStore.get(store);
+  if (!fences) return false;
+  if (fences.all > 0) return true;
+
+  const canonicalKey = store.resolveKey(key);
+  for (const [fencedKey, leaseCount] of fences.keys) {
+    if (leaseCount > 0 && store.resolveKey(fencedKey) === canonicalKey) return true;
+  }
+  const activityGroupId = store.getActivityGroupId(canonicalKey);
+  return Boolean(activityGroupId && (fences.activityGroups.get(activityGroupId) ?? 0) > 0);
+}
diff --git a/frontend/src/services/chatRuntimeStore.test.ts b/frontend/src/services/chatRuntimeStore.test.ts
index 3d4b1f705..f38774a1e 100644
--- a/frontend/src/services/chatRuntimeStore.test.ts
+++ b/frontend/src/services/chatRuntimeStore.test.ts
@@ -6,6 +6,7 @@ import {
   type ChatRuntimeRunUpdater,
   type ChatRuntimeSnapshot
 } from "./chatRuntimeStore";
+import { chatCursorAfterSendFailure } from "./chatSendFailureRecovery";
 
 type Conversation = { id: string; title: string };
 type Message = { id: string; text: string; status: "streaming" | "completed" };
@@ -162,6 +163,9 @@ describe("ChatRuntimeStore", () => {
       input: "updated A while offscreen",
       attachmentIds: ["a.png"]
     });
+    const snapshots = store.getSnapshots();
+    expect(Object.isFrozen(snapshots)).toBe(true);
+    expect(new Set(snapshots.map((snapshot) => snapshot.key))).toEqual(new Set([A, B]));
 
     store.select(A);
     expect(store.getActive()?.composer.input).toBe("updated A while offscreen");
@@ -444,6 +448,38 @@ describe("ChatRuntimeStore", () => {
     });
   });
 
+  test("can reconcile durable completion while aborting the stale local stream", () => {
+    const store = createStore();
+    store.select(A);
+    const run = store.beginRun(A);
+    store.updateForRun(A, run.token, (snapshot) => ({
+      ...snapshot,
+      lastSeenItemId: "persisted-user"
+    }));
+    store.setCurrentResponseId(A, run.token, "completed-response");
+    store.setAssistantStreaming(A, run.token, true);
+
+    expect(
+      store.completeRunAndAbort(A, run.token, (snapshot) => ({
+        ...snapshot,
+        lastSeenItemId: chatCursorAfterSendFailure({
+          currentCursor: snapshot.lastSeenItemId,
+          optimisticMessageId: "persisted-user",
+          previousCursor: undefined,
+          responseCreated: Boolean(snapshot.currentResponseId)
+        })
+      }))
+    ).toBe(true);
+    expect(run.signal.aborted).toBe(true);
+    expect(store.get(A)).toMatchObject({
+      isGenerating: false,
+      assistantStreaming: false,
+      currentResponseId: undefined,
+      lastSeenItemId: "persisted-user",
+      runToken: null
+    });
+  });
+
   test("stale run updates and completion cannot clear a replacement run", () => {
     const store = createStore();
     store.select(A);
@@ -870,6 +906,39 @@ describe("ChatRuntimeStore", () => {
     expect(store.deleteActivityGroup("project-delete")).toEqual([]);
   });
 
+  test("clears every runtime and resource while keeping the store reusable", () => {
+    const disposed: Array<{ key: string; reason: string }> = [];
+    const store = createStore({
+      disposeEntry: (snapshot, reason) => disposed.push({ key: snapshot.key, reason })
+    });
+    const draft = createChatDraftKey("clear-all-draft");
+    store.select(draft, { composer: { input: "unsent", attachmentIds: ["blob"] } });
+    store.rememberDraftKey(null, draft);
+    const active = store.beginRun(A, { groupId: "project-clear" });
+    const unread = store.beginRun(B, { groupId: "project-clear" });
+    expect(store.completeRun(B, unread.token)).toBe(true);
+    store.claimVisibleChat({}, A);
+
+    const cleared = store.clearAll();
+
+    expect(new Set(cleared)).toEqual(new Set([draft, A, B]));
+    expect(Object.isFrozen(cleared)).toBe(true);
+    expect(active.signal.aborted).toBe(true);
+    expect(store.getActive()).toBeUndefined();
+    expect(store.getActiveRunKeys()).toEqual([]);
+    expect(store.getCompletedUnreadKeys()).toEqual([]);
+    expect(store.getRememberedDraftKey(null)).toBeNull();
+    expect(new Set(disposed)).toEqual(
+      new Set([
+        { key: draft, reason: "deleted" },
+        { key: A, reason: "deleted" },
+        { key: B, reason: "deleted" }
+      ])
+    );
+
+    expect(store.select(createChatDraftKey("after-clear"))).toBeDefined();
+  });
+
   test("dispose resets unread and visible ownership state and notifies subscribers", () => {
     const store = createStore();
     const emptyActiveSnapshot = store.getActiveRunKeys();
diff --git a/frontend/src/services/chatRuntimeStore.ts b/frontend/src/services/chatRuntimeStore.ts
index e3991300e..18cc2cdd7 100644
--- a/frontend/src/services/chatRuntimeStore.ts
+++ b/frontend/src/services/chatRuntimeStore.ts
@@ -368,6 +368,42 @@ export class ChatRuntimeStore<TConversation, TMessage, TComposer> {
     return Object.freeze(Array.from(keys));
   }
 
+  /** Clears every account-scoped runtime while keeping this provider's store reusable. */
+  clearAll(): readonly ChatRuntimeKey[] {
+    this.assertNotDisposed();
+    const currentEntries = Array.from(this.entries.entries());
+    const keys = Object.freeze(currentEntries.map(([key]) => key));
+    const hadState =
+      currentEntries.length > 0 ||
+      this.aliases.size > 0 ||
+      this.completedUnreadGroups.size > 0 ||
+      this.rememberedDraftKeys.size > 0 ||
+      this.activeKey !== null ||
+      this.visibleChatLease !== null;
+    if (!hadState) return keys;
+
+    this.entries.clear();
+    this.aliases.clear();
+    this.completedUnreadGroups.clear();
+    this.rememberedDraftKeys.clear();
+    this.activeKey = null;
+    this.visibleChatLease = null;
+    this.visibleChatKey = null;
+
+    this.runAll([
+      ...currentEntries.flatMap(([, entry]) =>
+        entry.activeRun ? [() => entry.activeRun!.controller.abort()] : []
+      ),
+      ...currentEntries.map(
+        ([, entry]) =>
+          () =>
+            this.disposeEntry?.(entry.snapshot, "deleted")
+      ),
+      () => this.publish(true, true)
+    ]);
+    return keys;
+  }
+
   subscribeKey(key: ChatRuntimeKey, listener: () => void): () => void {
     let lastSnapshot = this.get(key);
     return this.subscribe(() => {
@@ -410,6 +446,11 @@ export class ChatRuntimeStore<TConversation, TMessage, TComposer> {
     return this.entries.get(this.resolveKey(key))?.snapshot;
   }
 
+  /** Read-only account snapshot used for aggregate resource admission checks. */
+  getSnapshots(): readonly ChatRuntimeSnapshot<TConversation, TMessage, TComposer>[] {
+    return Object.freeze(Array.from(this.entries.values(), (entry) => entry.snapshot));
+  }
+
   ensure(
     key: ChatRuntimeKey,
     initial: ChatRuntimeInitialState<TConversation, TMessage, TComposer> = {}
@@ -580,11 +621,25 @@ export class ChatRuntimeStore<TConversation, TMessage, TComposer> {
     return this.settleRun(key, token, true, updater);
   }
 
+  /**
+   * Reconciles a durably completed response while terminating a stream that
+   * can no longer provide useful ownership updates. Ownership is cleared before
+   * abort listeners run, preserving the same stale-token guarantee as cancel.
+   */
+  completeRunAndAbort(
+    key: ChatRuntimeKey,
+    token: number,
+    updater?: ChatRuntimeRunUpdater<TConversation, TMessage, TComposer>
+  ): boolean {
+    return this.settleRun(key, token, true, updater, true);
+  }
+
   private settleRun(
     key: ChatRuntimeKey,
     token: number,
     completedSuccessfully: boolean,
-    updater?: ChatRuntimeRunUpdater<TConversation, TMessage, TComposer>
+    updater?: ChatRuntimeRunUpdater<TConversation, TMessage, TComposer>,
+    abortController = false
   ): boolean {
     if (this.disposed) return false;
     const canonicalKey = this.resolveKey(key);
@@ -593,6 +648,7 @@ export class ChatRuntimeStore<TConversation, TMessage, TComposer> {
 
     const completed = updater ? { ...entry.snapshot, ...updater(entry.snapshot) } : entry.snapshot;
     const completedGroupId = entry.activeRun.groupId;
+    const run = entry.activeRun;
     entry.activeRun = null;
     entry.snapshot = this.updatedSnapshot(
       entry.snapshot,
@@ -618,6 +674,7 @@ export class ChatRuntimeStore<TConversation, TMessage, TComposer> {
     }
     this.touch(entry);
     this.evictInactiveCompletedEntries();
+    if (abortController) run.controller.abort();
     this.publish();
     return true;
   }
diff --git a/frontend/src/services/chatSendFailureRecovery.test.ts b/frontend/src/services/chatSendFailureRecovery.test.ts
index bfc14c7fb..befbf0e48 100644
--- a/frontend/src/services/chatSendFailureRecovery.test.ts
+++ b/frontend/src/services/chatSendFailureRecovery.test.ts
@@ -1,5 +1,54 @@
 import { describe, expect, test } from "bun:test";
-import { recoverFailedSendAfterDestinationAdoption } from "./chatSendFailureRecovery";
+import {
+  chatCursorAfterSendFailure,
+  recoverFailedSendAfterDestinationAdoption
+} from "./chatSendFailureRecovery";
+
+describe("chatCursorAfterSendFailure", () => {
+  test("rewinds an unconfirmed optimistic cursor to the previous durable item", () => {
+    expect(
+      chatCursorAfterSendFailure({
+        currentCursor: "optimistic-user",
+        optimisticMessageId: "optimistic-user",
+        previousCursor: "previous-item",
+        responseCreated: false
+      })
+    ).toBe("previous-item");
+  });
+
+  test("keeps the persisted user cursor after response.created", () => {
+    expect(
+      chatCursorAfterSendFailure({
+        currentCursor: "optimistic-user",
+        optimisticMessageId: "optimistic-user",
+        previousCursor: "previous-item",
+        responseCreated: true
+      })
+    ).toBe("optimistic-user");
+  });
+
+  test("never rewinds a cursor that already advanced beyond the optimistic user", () => {
+    expect(
+      chatCursorAfterSendFailure({
+        currentCursor: "assistant-item",
+        optimisticMessageId: "optimistic-user",
+        previousCursor: "previous-item",
+        responseCreated: false
+      })
+    ).toBe("assistant-item");
+  });
+
+  test("rewinds an unconfirmed first turn to an empty cursor", () => {
+    expect(
+      chatCursorAfterSendFailure({
+        currentCursor: "optimistic-user",
+        optimisticMessageId: "optimistic-user",
+        previousCursor: undefined,
+        responseCreated: false
+      })
+    ).toBeUndefined();
+  });
+});
 
 describe("recoverFailedSendAfterDestinationAdoption", () => {
   test("keeps destination B composer resources while retaining failed source A", () => {
diff --git a/frontend/src/services/chatSendFailureRecovery.ts b/frontend/src/services/chatSendFailureRecovery.ts
index bf97486a3..db8af7d99 100644
--- a/frontend/src/services/chatSendFailureRecovery.ts
+++ b/frontend/src/services/chatSendFailureRecovery.ts
@@ -3,6 +3,21 @@ export type AdoptedDestinationFailureRecovery<TMessage, TComposer> = Readonly<{
   composer: TComposer;
 }>;
 
+export function chatCursorAfterSendFailure({
+  currentCursor,
+  optimisticMessageId,
+  previousCursor,
+  responseCreated
+}: {
+  currentCursor: string | undefined;
+  optimisticMessageId: string;
+  previousCursor: string | undefined;
+  responseCreated: boolean;
+}): string | undefined {
+  if (currentCursor !== optimisticMessageId || responseCreated) return currentCursor;
+  return previousCursor;
+}
+
 /**
  * Once a source run adopts an independently selected destination runtime, that
  * destination owns its composer and object URLs. A later source-send failure
diff --git a/frontend/src/services/chatStoppingRuntimeRegistry.test.ts b/frontend/src/services/chatStoppingRuntimeRegistry.test.ts
new file mode 100644
index 000000000..2d5a4edad
--- /dev/null
+++ b/frontend/src/services/chatStoppingRuntimeRegistry.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test";
+import { chatStoppingRuntimeRegistryFor } from "./chatStoppingRuntimeRegistry";
+import type { ChatRuntimeKey } from "./chatRuntimeStore";
+
+describe("chat stopping runtime registry", () => {
+  test("clears a Stop token after its run rekeys from draft to conversation", () => {
+    const registry = chatStoppingRuntimeRegistryFor({});
+    const draftKey = "draft:one" as ChatRuntimeKey;
+    const conversationKey = "conversation:one" as ChatRuntimeKey;
+
+    registry.add(draftKey, 7);
+    registry.delete(conversationKey, 7);
+
+    expect(registry.getEntries().size).toBe(0);
+  });
+
+  test("deleting one run leaves other Stop tokens intact", () => {
+    const registry = chatStoppingRuntimeRegistryFor({});
+    const firstKey = "draft:first" as ChatRuntimeKey;
+    const secondKey = "draft:second" as ChatRuntimeKey;
+
+    registry.add(firstKey, 1);
+    registry.add(secondKey, 2);
+    registry.delete(firstKey, 1);
+
+    expect(registry.getEntries().get(firstKey)).toBeUndefined();
+    expect(registry.getEntries().get(secondKey)).toEqual(new Set([2]));
+  });
+
+  test("publishes only for effective mutations", () => {
+    const registry = chatStoppingRuntimeRegistryFor({});
+    const key = "draft:one" as ChatRuntimeKey;
+    let notifications = 0;
+    registry.subscribe(() => {
+      notifications += 1;
+    });
+
+    registry.add(key, 3);
+    registry.add(key, 3);
+    registry.delete(key, 99);
+    registry.delete(key, 3);
+
+    expect(notifications).toBe(2);
+  });
+});
diff --git a/frontend/src/services/chatStoppingRuntimeRegistry.ts b/frontend/src/services/chatStoppingRuntimeRegistry.ts
new file mode 100644
index 000000000..398133530
--- /dev/null
+++ b/frontend/src/services/chatStoppingRuntimeRegistry.ts
@@ -0,0 +1,62 @@
+import type { ChatRuntimeKey } from "./chatRuntimeStore";
+
+export type ChatStoppingRuntimeRegistry = Readonly<{
+  add: (key: ChatRuntimeKey, runToken: number) => void;
+  delete: (key: ChatRuntimeKey, runToken: number) => void;
+  getEntries: () => ReadonlyMap<ChatRuntimeKey, ReadonlySet<number>>;
+  getSnapshot: () => number;
+  subscribe: (listener: () => void) => () => void;
+}>;
+
+const registries = new WeakMap<object, ChatStoppingRuntimeRegistry>();
+
+export function chatStoppingRuntimeRegistryFor(runtimeOwner: object): ChatStoppingRuntimeRegistry {
+  const existing = registries.get(runtimeOwner);
+  if (existing) return existing;
+
+  let entries: ReadonlyMap<ChatRuntimeKey, ReadonlySet<number>> = new Map();
+  let revision = 0;
+  const listeners = new Set<() => void>();
+  const publish = () => {
+    revision += 1;
+    for (const listener of listeners) listener();
+  };
+  const registry: ChatStoppingRuntimeRegistry = {
+    add: (key, runToken) => {
+      const currentTokens = entries.get(key);
+      if (currentTokens?.has(runToken)) return;
+      const nextEntries = new Map(entries);
+      nextEntries.set(key, new Set(currentTokens).add(runToken));
+      entries = nextEntries;
+      publish();
+    },
+    delete: (_key, runToken) => {
+      // A new conversation rekeys its active run from a draft key to a
+      // conversation key. Run tokens are unique within a runtime store, so
+      // remove the token from whichever pre-rekey key still owns it.
+      let changed = false;
+      const nextEntries = new Map<ChatRuntimeKey, ReadonlySet<number>>();
+      for (const [entryKey, currentTokens] of entries) {
+        if (!currentTokens.has(runToken)) {
+          nextEntries.set(entryKey, currentTokens);
+          continue;
+        }
+        changed = true;
+        const nextTokens = new Set(currentTokens);
+        nextTokens.delete(runToken);
+        if (nextTokens.size > 0) nextEntries.set(entryKey, nextTokens);
+      }
+      if (!changed) return;
+      entries = nextEntries;
+      publish();
+    },
+    getEntries: () => entries,
+    getSnapshot: () => revision,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+  registries.set(runtimeOwner, registry);
+  return registry;
+}
diff --git a/frontend/src/services/chatUnresolvedResponseOwnership.test.ts b/frontend/src/services/chatUnresolvedResponseOwnership.test.ts
new file mode 100644
index 000000000..c926deb00
--- /dev/null
+++ b/frontend/src/services/chatUnresolvedResponseOwnership.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, test } from "bun:test";
+import {
+  clearUnresolvedChatResponseMessage,
+  getUnresolvedChatResponseMessage,
+  registerUnresolvedChatResponseMessage
+} from "./chatUnresolvedResponseOwnership";
+
+describe("chat unresolved response ownership", () => {
+  test("tracks exactly one optimistic message per active run", () => {
+    const store = {};
+    registerUnresolvedChatResponseMessage(store, 7, "current-turn");
+
+    expect(getUnresolvedChatResponseMessage(store, 7)).toBe("current-turn");
+    expect(getUnresolvedChatResponseMessage(store, 8)).toBeUndefined();
+  });
+
+  test("a stale clear cannot remove replacement ownership", () => {
+    const store = {};
+    registerUnresolvedChatResponseMessage(store, 9, "first-turn");
+    registerUnresolvedChatResponseMessage(store, 9, "replacement-turn");
+
+    clearUnresolvedChatResponseMessage(store, 9, "first-turn");
+    expect(getUnresolvedChatResponseMessage(store, 9)).toBe("replacement-turn");
+
+    clearUnresolvedChatResponseMessage(store, 9, "replacement-turn");
+    expect(getUnresolvedChatResponseMessage(store, 9)).toBeUndefined();
+  });
+
+  test("isolates stores with identical run tokens", () => {
+    const firstStore = {};
+    const secondStore = {};
+    registerUnresolvedChatResponseMessage(firstStore, 1, "first");
+    registerUnresolvedChatResponseMessage(secondStore, 1, "second");
+
+    clearUnresolvedChatResponseMessage(firstStore, 1);
+    expect(getUnresolvedChatResponseMessage(firstStore, 1)).toBeUndefined();
+    expect(getUnresolvedChatResponseMessage(secondStore, 1)).toBe("second");
+  });
+});
diff --git a/frontend/src/services/chatUnresolvedResponseOwnership.ts b/frontend/src/services/chatUnresolvedResponseOwnership.ts
new file mode 100644
index 000000000..dc1cf92d7
--- /dev/null
+++ b/frontend/src/services/chatUnresolvedResponseOwnership.ts
@@ -0,0 +1,41 @@
+const unresolvedResponseMessagesByStore = new WeakMap<object, Map<number, string>>();
+
+function messagesFor(store: object): Map<number, string> {
+  const existing = unresolvedResponseMessagesByStore.get(store);
+  if (existing) return existing;
+  const created = new Map<number, string>();
+  unresolvedResponseMessagesByStore.set(store, created);
+  return created;
+}
+
+/**
+ * Records the one optimistic user-message UUID owned by an active run before
+ * its Responses POST is dispatched. Polling must use this exact UUID rather
+ * than adopting any older incomplete transcript row.
+ */
+export function registerUnresolvedChatResponseMessage(
+  store: object,
+  runToken: number,
+  messageId: string
+): void {
+  messagesFor(store).set(runToken, messageId);
+}
+
+export function getUnresolvedChatResponseMessage(
+  store: object,
+  runToken: number
+): string | undefined {
+  return unresolvedResponseMessagesByStore.get(store)?.get(runToken);
+}
+
+export function clearUnresolvedChatResponseMessage(
+  store: object,
+  runToken: number,
+  expectedMessageId?: string
+): void {
+  const messages = unresolvedResponseMessagesByStore.get(store);
+  if (!messages) return;
+  if (expectedMessageId !== undefined && messages.get(runToken) !== expectedMessageId) return;
+  messages.delete(runToken);
+  if (messages.size === 0) unresolvedResponseMessagesByStore.delete(store);
+}
diff --git a/frontend/src/services/composerQueue.test.ts b/frontend/src/services/composerQueue.test.ts
new file mode 100644
index 000000000..bdb8f22ff
--- /dev/null
+++ b/frontend/src/services/composerQueue.test.ts
@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test";
+import {
+  beginQueuedMessageEdit,
+  discardQueuedMessageEdit,
+  queuedMessageEditStillPresent,
+  type QueuedComposerMessage
+} from "./composerQueue";
+
+function queued(queueId: string, text: string): QueuedComposerMessage {
+  return { queueId, text };
+}
+
+describe("shared composer queue editing", () => {
+  test("starts an in-place edit and keeps an unpublished draft stashed", () => {
+    const started = beginQueuedMessageEdit({
+      current: null,
+      scopeKey: "scope-1",
+      item: queued("q1", "oldest"),
+      composerText: "new draft"
+    });
+
+    expect(started).toEqual({
+      edit: { scopeKey: "scope-1", queueId: "q1", stashedDraft: "new draft" },
+      composer: "oldest"
+    });
+    expect(discardQueuedMessageEdit(started!.edit)).toBe("new draft");
+  });
+
+  test("switching items in one scope keeps the original draft and does not restack", () => {
+    const first = beginQueuedMessageEdit({
+      current: null,
+      scopeKey: "scope-1",
+      item: queued("q1", "oldest"),
+      composerText: "new draft"
+    });
+    const second = beginQueuedMessageEdit({
+      current: first!.edit,
+      scopeKey: "scope-1",
+      item: queued("q2", "middle"),
+      composerText: "oldest"
+    });
+
+    expect(second).toEqual({
+      edit: { scopeKey: "scope-1", queueId: "q2", stashedDraft: "new draft" },
+      composer: "middle"
+    });
+    expect(
+      beginQueuedMessageEdit({
+        current: second!.edit,
+        scopeKey: "scope-1",
+        item: queued("q2", "middle"),
+        composerText: "middle"
+      })
+    ).toBeNull();
+    expect(
+      queuedMessageEditStillPresent(second!.edit, [queued("q1", "oldest"), queued("q2", "middle")])
+    ).toBe(true);
+    expect(queuedMessageEditStillPresent(second!.edit, [queued("q1", "oldest")])).toBe(false);
+  });
+
+  test("a different scope stashes that scope's current draft", () => {
+    const next = beginQueuedMessageEdit({
+      current: {
+        scopeKey: "scope-1",
+        queueId: "q1",
+        stashedDraft: "scope one draft"
+      },
+      scopeKey: "scope-2",
+      item: queued("q1", "scope two queued"),
+      composerText: "scope two draft"
+    });
+
+    expect(next).toEqual({
+      edit: { scopeKey: "scope-2", queueId: "q1", stashedDraft: "scope two draft" },
+      composer: "scope two queued"
+    });
+  });
+});
diff --git a/frontend/src/services/composerQueue.ts b/frontend/src/services/composerQueue.ts
new file mode 100644
index 000000000..131346100
--- /dev/null
+++ b/frontend/src/services/composerQueue.ts
@@ -0,0 +1,45 @@
+export interface QueuedComposerMessage {
+  queueId: string;
+  text: string;
+}
+
+export interface QueuedMessageEdit {
+  scopeKey: string;
+  queueId: string;
+  stashedDraft: string;
+}
+
+export function beginQueuedMessageEdit({
+  current,
+  scopeKey,
+  item,
+  composerText
+}: {
+  current: QueuedMessageEdit | null;
+  scopeKey: string;
+  item: QueuedComposerMessage;
+  composerText: string;
+}): { edit: QueuedMessageEdit; composer: string } | null {
+  if (current?.scopeKey === scopeKey && current.queueId === item.queueId) {
+    return null;
+  }
+  return {
+    edit: {
+      scopeKey,
+      queueId: item.queueId,
+      stashedDraft: current?.scopeKey === scopeKey ? current.stashedDraft : composerText
+    },
+    composer: item.text
+  };
+}
+
+export function discardQueuedMessageEdit(edit: QueuedMessageEdit): string {
+  return edit.stashedDraft;
+}
+
+export function queuedMessageEditStillPresent(
+  edit: QueuedMessageEdit | null,
+  items: readonly Pick<QueuedComposerMessage, "queueId">[]
+): boolean {
+  return Boolean(edit && items.some((item) => item.queueId === edit.queueId));
+}
diff --git a/sdk/bun.lock b/sdk/bun.lock
index 6e622fe90..5e1473b94 100644
--- a/sdk/bun.lock
+++ b/sdk/bun.lock
@@ -36,6 +36,9 @@
       },
     },
   },
+  "overrides": {
+    "fast-uri": "3.1.6",
+  },
   "packages": {
     "@babel/code-frame": ["@babel/code-frame@7.29.7", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.29.7", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw=="],
 
@@ -447,7 +450,7 @@
 
     "fast-levenshtein": ["fast-levenshtein@2.0.6", "", {}, "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="],
 
-    "fast-uri": ["fast-uri@3.1.5", "", {}, "sha512-gHwA1O9LDIcKunMKhObS/HimwtehO1nPUECKAu5TpKgaO19fcWEl4bliWe1jWxVFvIXztJjjQ4L8XQ1EU9f7Jw=="],
+    "fast-uri": ["fast-uri@3.1.6", "", {}, "sha512-7Ical1vFEMr0onbVzEDIreM22I4khW+fzyQPwvAFWBp1iwdshSZRsL4jjRvPG9JP1uiqMHRto+YU6R2/CzDz5Q=="],
 
     "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
 
diff --git a/sdk/package.json b/sdk/package.json
index 0d859e4e8..af05f8e97 100644
--- a/sdk/package.json
+++ b/sdk/package.json
@@ -27,6 +27,9 @@
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"
   },
+  "overrides": {
+    "fast-uri": "3.1.6"
+  },
   "dependencies": {
     "@peculiar/x509": "1.14.3",
     "@stablelib/base64": "2.0.1",
diff --git a/sdk/src/lib/ai.ts b/sdk/src/lib/ai.ts
index f6399b79b..f002cd42a 100644
--- a/sdk/src/lib/ai.ts
+++ b/sdk/src/lib/ai.ts
@@ -2,7 +2,55 @@ import { decryptMessage, encryptMessage } from "./encryption";
 import { getAttestation, type Attestation } from "./getAttestation";
 import * as api from "./api";
 import { serializePcrConfig, snapshotPcrConfig, type PcrConfig } from "./pcr";
-import { classifyRecovery } from "./recovery";
+import { classifyRecovery, ERROR_CODE_HEADER, ERROR_CONTRACT_HEADER } from "./recovery";
+import {
+  ACCOUNT_CREDENTIAL_MISMATCH_CODE,
+  accessTokenSubject,
+  accountCredentialMismatchError,
+  isAccountCredentialMismatchError
+} from "./credentialIdentity";
+
+export { ACCOUNT_CREDENTIAL_MISMATCH_CODE } from "./credentialIdentity";
+
+/** Identifies a failure that occurred before the target fetch was invoked. */
+export const REQUEST_NOT_DISPATCHED_CODE = "opensecret_request_not_dispatched";
+const ERROR_CONTRACT_VERSION = "1";
+const IMAGE_DESCRIPTION_UNAVAILABLE_ERROR_CODE = "image_description_unavailable";
+const IMAGE_DESCRIPTION_UNAVAILABLE_STATUS = 503;
+
+/** Orthogonal dispatch metadata that preserves the source error's code and name. */
+export interface RequestNotDispatchedMarker {
+  readonly requestDispatchCode: typeof REQUEST_NOT_DISPATCHED_CODE;
+  readonly definitelyNotDispatched: true;
+}
+
+function markRequestNotDispatched(error: unknown): unknown & RequestNotDispatchedMarker {
+  const marker: RequestNotDispatchedMarker = {
+    requestDispatchCode: REQUEST_NOT_DISPATCHED_CODE,
+    definitelyNotDispatched: true
+  };
+
+  if ((typeof error === "object" && error !== null) || typeof error === "function") {
+    try {
+      // Errors and DOMExceptions are normally extensible. Tagging the original
+      // preserves credential codes, AbortError names, prototypes, and identity.
+      return Object.assign(error, marker);
+    } catch {
+      // Fall through for frozen or host-provided exception objects.
+    }
+  }
+
+  const wrapped = Object.assign(
+    new Error(error instanceof Error ? error.message : "Request failed before transport dispatch"),
+    { cause: error },
+    marker
+  ) as Error & { code?: unknown } & RequestNotDispatchedMarker;
+  if (typeof error === "object" && error !== null) {
+    if ("name" in error && typeof error.name === "string") wrapped.name = error.name;
+    if ("code" in error) wrapped.code = error.code;
+  }
+  return wrapped;
+}
 
 export interface CustomFetchOptions {
   /** Optional API key to use instead of a JWT token. */
@@ -11,6 +59,8 @@ export interface CustomFetchOptions {
   apiUrl?: string;
   /** PCR0 trust policy enforced before non-loopback session key exchange; defaults to production. */
   pcrConfig?: PcrConfig;
+  /** Optional user ID that every JWT attempt and retry must retain. */
+  expectedUserId?: string;
 }
 
 interface ActiveAttestation {
@@ -197,7 +247,16 @@ export function createCustomFetchWithDependencies(
     // flight; recovery must not switch between API-key and JWT credentials.
     const apiKey = options?.apiKey;
     const usesApiKey = Boolean(apiKey);
+    const expectedUserId = options?.expectedUserId;
+    let requestAcceptanceAmbiguous = false;
+    const assertExpectedAccount = () => {
+      if (!expectedUserId) return;
+      if (accessTokenSubject(window.localStorage.getItem("access_token")) !== expectedUserId) {
+        throw accountCredentialMismatchError();
+      }
+    };
     const getAuthHeader = () => {
+      assertExpectedAccount();
       // If an API key is provided, use it instead of JWT token
       if (apiKey) {
         return `Bearer ${apiKey}`;
@@ -223,6 +282,10 @@ export function createCustomFetchWithDependencies(
       throwIfAborted(request.signal);
 
       const makeRequest = async (attestation: ActiveAttestation) => {
+        // Attestation and request snapshots can yield. Re-check immediately
+        // before each network attempt so an account replacement cannot replay
+        // retained plaintext under another user's credential.
+        assertExpectedAccount();
         const headers = new Headers(request.headers);
         headers.set("Authorization", authHeader);
         headers.set("x-session-id", attestation.sessionId);
@@ -243,10 +306,17 @@ export function createCustomFetchWithDependencies(
           headers.set("Content-Type", "application/json");
         }
 
-        return {
-          attestation,
-          response: await dependencies.fetch(request.url, requestOptions)
-        };
+        // Encryption can be substantial for image-bearing requests, and another
+        // tab can replace browser credentials while this synchronous work runs.
+        // Close that preparation window before handing the request to fetch.
+        assertExpectedAccount();
+
+        // Flip this immediately before invocation: synchronous throws and
+        // rejected fetch promises are both ambiguous because the transport was
+        // asked to dispatch. Only earlier failures are safe to replay.
+        requestAcceptanceAmbiguous = true;
+        const response = await dependencies.fetch(request.url, requestOptions);
+        return { attestation, response };
       };
 
       let attestation = requireActiveAttestation(
@@ -262,12 +332,20 @@ export function createCustomFetchWithDependencies(
 
       while (true) {
         const attempt = await makeRequest(attestation);
+        assertExpectedAccount();
         const recovery = classifyRecovery(attempt.response.status, attempt.response.headers);
 
         if (recovery === "refresh_access_token" && !usesApiKey && !replayed) {
           replayed = true;
+          // This HTTP response definitively rejected the outer request. Any
+          // failure while discarding it, refreshing credentials, or preparing
+          // the retry remains safe for the caller to restore. The next fetch
+          // invocation makes acceptance ambiguous again.
+          requestAcceptanceAmbiguous = false;
           await discardResponse(attempt.response);
           throwIfAborted(request.signal);
+          // Do not consume or rotate a replacement account's refresh token.
+          assertExpectedAccount();
           console.warn("Unauthorized, refreshing access token");
           await dependencies.refreshToken();
           throwIfAborted(request.signal);
@@ -287,6 +365,7 @@ export function createCustomFetchWithDependencies(
 
         if (recovery === "renew_session" && !replayed) {
           replayed = true;
+          requestAcceptanceAmbiguous = false;
           await discardResponse(attempt.response);
           throwIfAborted(request.signal);
           console.warn("Bad Request, renewing attestation and retrying once");
@@ -303,7 +382,25 @@ export function createCustomFetchWithDependencies(
       const { sessionKey } = finalAttempt.attestation;
 
       if (!response.ok) {
+        // OpenSecret's non-timeout 4xx responses and explicit image-description
+        // failure reject a Responses turn before persistence. Record that fact
+        // before reading a possibly truncated error body so callers never wait
+        // for response ownership that cannot exist. The generic contract header
+        // only versions the error schema; it is not proof that a 5xx happened
+        // before persistence.
+        const isImageDescriptionPreAcceptanceError =
+          response.status === IMAGE_DESCRIPTION_UNAVAILABLE_STATUS &&
+          response.headers.get(ERROR_CONTRACT_HEADER) === ERROR_CONTRACT_VERSION &&
+          response.headers.get(ERROR_CODE_HEADER) === IMAGE_DESCRIPTION_UNAVAILABLE_ERROR_CODE;
+        if (
+          response.status !== 408 &&
+          ((response.status >= 400 && response.status < 500) ||
+            isImageDescriptionPreAcceptanceError)
+        ) {
+          requestAcceptanceAmbiguous = false;
+        }
         const errorText = await response.text();
+        assertExpectedAccount();
         console.error(
           "Request failed with response status:",
           response.status,
@@ -327,55 +424,75 @@ export function createCustomFetchWithDependencies(
         let buffer = "";
         const stream = new ReadableStream({
           async start(controller) {
-            while (true) {
-              const { done, value } = await reader!.read();
-              if (done) break;
-
-              const chunk = decoder.decode(value);
-              buffer += chunk;
-
-              let event;
-              while ((event = extractEvent(buffer))) {
-                buffer = buffer.slice(event.length);
-
-                // Split the event into individual lines
-                const lines = event.split("\n");
-
-                for (const line of lines) {
-                  // Handle event: lines - pass them through as-is
-                  if (line.trim().startsWith("event: ")) {
-                    controller.enqueue(line + "\n");
-                  }
-                  // Handle data: lines - decrypt them
-                  else if (line.trim().startsWith("data: ")) {
-                    const data = line.slice(6).trim();
-                    if (data === "[DONE]") {
-                      controller.enqueue(`data: [DONE]\n\n`);
-                    } else {
-                      try {
-                        const decrypted = dependencies.decryptMessage(sessionKey, data);
-
-                        // Always enqueue the decrypted data
-                        // Note: We don't add \n\n here because the empty line will be added separately
-                        controller.enqueue(`data: ${decrypted}\n`);
-                      } catch (error) {
-                        console.error("Decryption error:", error, "Data:", data);
-                        // Instead of sending the encrypted data, we'll skip this chunk
-                        console.log("Skipping corrupted chunk");
+            try {
+              while (true) {
+                const { done, value } = await reader!.read();
+                assertExpectedAccount();
+                if (done) break;
+
+                const chunk = decoder.decode(value);
+                buffer += chunk;
+
+                let event;
+                while ((event = extractEvent(buffer))) {
+                  buffer = buffer.slice(event.length);
+
+                  // Split the event into individual lines
+                  const lines = event.split("\n");
+
+                  for (const line of lines) {
+                    // Handle event: lines - pass them through as-is
+                    if (line.trim().startsWith("event: ")) {
+                      assertExpectedAccount();
+                      controller.enqueue(line + "\n");
+                    }
+                    // Handle data: lines - decrypt them
+                    else if (line.trim().startsWith("data: ")) {
+                      const data = line.slice(6).trim();
+                      if (data === "[DONE]") {
+                        assertExpectedAccount();
+                        controller.enqueue(`data: [DONE]\n\n`);
+                      } else {
+                        try {
+                          const decrypted = dependencies.decryptMessage(sessionKey, data);
+
+                          // Always enqueue the decrypted data
+                          // Note: We don't add \n\n here because the empty line will be added separately
+                          assertExpectedAccount();
+                          controller.enqueue(`data: ${decrypted}\n`);
+                        } catch (error) {
+                          if (isAccountCredentialMismatchError(error)) throw error;
+                          console.error("Decryption error:", error, "Data:", data);
+                          // Instead of sending the encrypted data, we'll skip this chunk
+                          console.log("Skipping corrupted chunk");
+                        }
                       }
                     }
-                  }
-                  // Pass through empty lines
-                  else if (line === "") {
-                    controller.enqueue("\n");
+                    // Pass through empty lines
+                    else if (line === "") {
+                      assertExpectedAccount();
+                      controller.enqueue("\n");
+                    }
                   }
                 }
               }
+              assertExpectedAccount();
+              controller.close();
+            } catch (error) {
+              try {
+                await reader?.cancel(error);
+              } catch {
+                // The upstream body may already be closed or errored.
+              }
+              controller.error(error);
             }
-            controller.close();
+          },
+          async cancel(reason) {
+            await reader?.cancel(reason);
           }
         });
 
+        assertExpectedAccount();
         return new Response(stream, {
           headers: response.headers,
           status: response.status,
@@ -385,6 +502,7 @@ export function createCustomFetchWithDependencies(
 
       // Decrypt regular JSON responses
       const responseText = await response.text();
+      assertExpectedAccount();
       try {
         const responseData = JSON.parse(responseText);
 
@@ -423,36 +541,45 @@ export function createCustomFetchWithDependencies(
               headersOut.delete("content-length");
               headersOut.delete("transfer-encoding");
 
+              assertExpectedAccount();
               return new Response(bytes, {
                 headers: headersOut,
                 status: response.status,
                 statusText: response.statusText
               });
             }
-          } catch {
+          } catch (error) {
+            if (isAccountCredentialMismatchError(error)) throw error;
             // Not JSON, continue with regular text response
           }
           // Return a new Response with the decrypted data
+          assertExpectedAccount();
           return new Response(decrypted, {
             headers: response.headers,
             status: response.status,
             statusText: response.statusText
           });
         }
-      } catch {
+      } catch (error) {
+        if (isAccountCredentialMismatchError(error)) throw error;
         // If it's not JSON or doesn't have encrypted field, return original response
         console.log("Response is not encrypted JSON, returning as-is");
       }
 
       // Return the original response text as a new Response
+      assertExpectedAccount();
       return new Response(responseText, {
         headers: response.headers,
         status: response.status,
         statusText: response.statusText
       });
     } catch (error) {
-      console.error("Error during fetch process:", error);
-      throw error;
+      // Keep the original error code/name intact and add orthogonal dispatch
+      // metadata only when no transport invocation occurred in this logical
+      // call. Once fetch is invoked, failure remains deliberately ambiguous.
+      const reportedError = !requestAcceptanceAmbiguous ? markRequestNotDispatched(error) : error;
+      console.error("Error during fetch process:", reportedError);
+      throw reportedError;
     }
   };
 }
diff --git a/sdk/src/lib/api.ts b/sdk/src/lib/api.ts
index cb41a9f2a..08ebb9e2a 100644
--- a/sdk/src/lib/api.ts
+++ b/sdk/src/lib/api.ts
@@ -2,6 +2,7 @@ import { encode } from "@stablelib/base64";
 import { authenticatedApiCall, encryptedApiCall, openAiAuthenticatedApiCall } from "./encryptedApi";
 import type { Model } from "openai/resources/models.js";
 import { snapshotPcrConfig, type PcrConfig } from "./pcr";
+import { commitRefreshedUserTokensIfCurrent } from "./credentialIdentity";
 
 let apiUrl = "";
 let apiPcrConfig: PcrConfig = snapshotPcrConfig();
@@ -144,8 +145,11 @@ export async function refreshToken(): Promise<RefreshResponse> {
       "Failed to refresh token"
     );
 
-    window.localStorage.setItem("access_token", response.access_token);
-    window.localStorage.setItem("refresh_token", response.refresh_token);
+    commitRefreshedUserTokensIfCurrent({
+      initiatingRefreshToken: refresh_token,
+      accessToken: response.access_token,
+      refreshToken: response.refresh_token
+    });
     return response;
   } catch (error) {
     console.error("Error refreshing token:", error);
@@ -171,21 +175,23 @@ export async function fetchPut(key: string, value: string): Promise<string> {
   );
 }
 
-export async function fetchDelete(key: string): Promise<void> {
+export async function fetchDelete(key: string, expectedUserId?: string): Promise<void> {
   return authenticatedApiCall<void, void>(
     `${apiUrl}/protected/kv/${key}`,
     "DELETE",
     undefined,
-    "Failed to delete key-value pair"
+    "Failed to delete key-value pair",
+    expectedUserId
   );
 }
 
-export async function fetchDeleteAllKV(): Promise<void> {
+export async function fetchDeleteAllKV(expectedUserId?: string): Promise<void> {
   return authenticatedApiCall<void, void>(
     `${apiUrl}/protected/kv`,
     "DELETE",
     undefined,
-    "Failed to delete all key-value pairs"
+    "Failed to delete all key-value pairs",
+    expectedUserId
   );
 }
 
@@ -1077,7 +1083,10 @@ export async function decryptData(
  * 3. The email contains a confirmation code that will be needed for confirmation
  * 4. The client must store the plaintext secret for confirmation
  */
-export async function requestAccountDeletion(hashedSecret: string): Promise<void> {
+export async function requestAccountDeletion(
+  hashedSecret: string,
+  expectedUserId?: string
+): Promise<void> {
   const deleteData = {
     hashed_secret: hashedSecret
   };
@@ -1085,7 +1094,8 @@ export async function requestAccountDeletion(hashedSecret: string): Promise<void
     `${apiUrl}/protected/delete-account/request`,
     "POST",
     deleteData,
-    "Failed to request account deletion"
+    "Failed to request account deletion",
+    expectedUserId
   );
 }
 
@@ -1104,7 +1114,8 @@ export async function requestAccountDeletion(hashedSecret: string): Promise<void
  */
 export async function confirmAccountDeletion(
   confirmationCode: string,
-  plaintextSecret: string
+  plaintextSecret: string,
+  expectedUserId?: string
 ): Promise<void> {
   const confirmData = {
     confirmation_code: confirmationCode,
@@ -1114,7 +1125,8 @@ export async function confirmAccountDeletion(
     `${apiUrl}/protected/delete-account/confirm`,
     "POST",
     confirmData,
-    "Failed to confirm account deletion"
+    "Failed to confirm account deletion",
+    expectedUserId
   );
 }
 
@@ -1413,14 +1425,15 @@ export async function listApiKeys(): Promise<{ keys: ApiKeyListResponse }> {
  * console.log("API key deleted successfully");
  * ```
  */
-export async function deleteApiKey(name: string): Promise<void> {
+export async function deleteApiKey(name: string, expectedUserId?: string): Promise<void> {
   // URL-encode the name to handle special characters
   const encodedName = encodeURIComponent(name);
   return authenticatedApiCall<void, void>(
     `${apiUrl}/protected/api-keys/${encodedName}`,
     "DELETE",
     undefined,
-    "Failed to delete API key"
+    "Failed to delete API key",
+    expectedUserId
   );
 }
 
@@ -1724,6 +1737,8 @@ export type ResponsesListParams = {
 
 export type ConversationItem = {
   id: string;
+  /** OpenSecret extension: response that created this item, when applicable. */
+  response_id?: string;
   type: "message";
   status: "completed" | "in_progress" | "incomplete";
   role: "user" | "assistant" | "system";
@@ -2006,12 +2021,16 @@ export type ResponsesCancelResponse = {
  * }
  * ```
  */
-export async function cancelResponse(responseId: string): Promise<ResponsesCancelResponse> {
+export async function cancelResponse(
+  responseId: string,
+  expectedUserId?: string
+): Promise<ResponsesCancelResponse> {
   return authenticatedApiCall<void, ResponsesCancelResponse>(
     `${apiUrl}/v1/responses/${encodeURIComponent(responseId)}/cancel`,
     "POST",
     undefined,
-    "Failed to cancel response"
+    "Failed to cancel response",
+    expectedUserId
   );
 }
 
@@ -2172,13 +2191,15 @@ export async function updateConversation(
  * ```
  */
 export async function deleteConversation(
-  conversationId: string
+  conversationId: string,
+  expectedUserId?: string
 ): Promise<ConversationDeleteResponse> {
   return authenticatedApiCall<void, ConversationDeleteResponse>(
     `${apiUrl}/v1/conversations/${encodeURIComponent(conversationId)}`,
     "DELETE",
     undefined,
-    "Failed to delete conversation"
+    "Failed to delete conversation",
+    expectedUserId
   );
 }
 
@@ -2201,12 +2222,15 @@ export async function deleteConversation(
  * }
  * ```
  */
-export async function deleteConversations(): Promise<ConversationsDeleteResponse> {
+export async function deleteConversations(
+  expectedUserId?: string
+): Promise<ConversationsDeleteResponse> {
   return authenticatedApiCall<void, ConversationsDeleteResponse>(
     `${apiUrl}/v1/conversations`,
     "DELETE",
     undefined,
-    "Failed to delete conversations"
+    "Failed to delete conversations",
+    expectedUserId
   );
 }
 
@@ -2238,13 +2262,15 @@ export async function deleteConversations(): Promise<ConversationsDeleteResponse
  * ```
  */
 export async function batchDeleteConversations(
-  ids: string[]
+  ids: string[],
+  expectedUserId?: string
 ): Promise<BatchDeleteConversationsResponse> {
   return authenticatedApiCall<BatchDeleteConversationsRequest, BatchDeleteConversationsResponse>(
     `${apiUrl}/v1/conversations/batch-delete`,
     "POST",
     { ids },
-    "Failed to batch delete conversations"
+    "Failed to batch delete conversations",
+    expectedUserId
   );
 }
 
@@ -2498,13 +2524,15 @@ export async function updateConversationProject(
 }
 
 export async function deleteConversationProject(
-  projectId: string
+  projectId: string,
+  expectedUserId?: string
 ): Promise<ConversationProjectDeleteResponse> {
   return authenticatedApiCall<void, ConversationProjectDeleteResponse>(
     `${apiUrl}/v1/conversation-projects/${encodeURIComponent(projectId)}`,
     "DELETE",
     undefined,
-    "Failed to delete conversation project"
+    "Failed to delete conversation project",
+    expectedUserId
   );
 }
 
@@ -2570,12 +2598,16 @@ export async function createResponse(
  * }
  * ```
  */
-export async function deleteResponse(responseId: string): Promise<ResponsesDeleteResponse> {
+export async function deleteResponse(
+  responseId: string,
+  expectedUserId?: string
+): Promise<ResponsesDeleteResponse> {
   return authenticatedApiCall<void, ResponsesDeleteResponse>(
     `${apiUrl}/v1/responses/${encodeURIComponent(responseId)}`,
     "DELETE",
     undefined,
-    "Failed to delete response"
+    "Failed to delete response",
+    expectedUserId
   );
 }
 
@@ -2786,12 +2818,16 @@ export async function updateInstruction(
  * }
  * ```
  */
-export async function deleteInstruction(instructionId: string): Promise<InstructionDeleteResponse> {
+export async function deleteInstruction(
+  instructionId: string,
+  expectedUserId?: string
+): Promise<InstructionDeleteResponse> {
   return authenticatedApiCall<void, InstructionDeleteResponse>(
     `${apiUrl}/v1/instructions/${encodeURIComponent(instructionId)}`,
     "DELETE",
     undefined,
-    "Failed to delete instruction"
+    "Failed to delete instruction",
+    expectedUserId
   );
 }
 
diff --git a/sdk/src/lib/credentialIdentity.ts b/sdk/src/lib/credentialIdentity.ts
new file mode 100644
index 000000000..bb49f11e8
--- /dev/null
+++ b/sdk/src/lib/credentialIdentity.ts
@@ -0,0 +1,147 @@
+export const ACCOUNT_CREDENTIAL_MISMATCH_CODE = "chat_account_credential_mismatch";
+
+export function accessTokenSubject(accessToken: string | null): string | null {
+  if (!accessToken) return null;
+  try {
+    const parts = accessToken.split(".");
+    if (parts.length !== 3 || !parts[1]) return null;
+    const normalized = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+    const payload = JSON.parse(atob(padded)) as { sub?: unknown };
+    return typeof payload.sub === "string" && payload.sub ? payload.sub : null;
+  } catch {
+    return null;
+  }
+}
+
+export function accountCredentialMismatchError(): Error & { code: string } {
+  return Object.assign(
+    new Error("The authenticated account changed before this request could continue"),
+    {
+      name: "AccountCredentialMismatchError",
+      code: ACCOUNT_CREDENTIAL_MISMATCH_CODE
+    }
+  );
+}
+
+export function isAccountCredentialMismatchError(
+  error: unknown
+): error is Error & { code: string } {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    error.code === ACCOUNT_CREDENTIAL_MISMATCH_CODE
+  );
+}
+
+export type UserCredentialSnapshot = Readonly<{
+  userId: string;
+  accessToken: string;
+  refreshToken: string | null;
+}>;
+
+export function assertExpectedAccessTokenSubject(
+  expectedUserId: string,
+  storage: Storage = window.localStorage
+): void {
+  if (accessTokenSubject(storage.getItem("access_token")) !== expectedUserId) {
+    throw accountCredentialMismatchError();
+  }
+}
+
+export function captureExpectedUserCredentials(
+  expectedUserId: string,
+  storage: Storage = window.localStorage
+): UserCredentialSnapshot {
+  const accessToken = storage.getItem("access_token");
+  const refreshToken = storage.getItem("refresh_token");
+
+  if (
+    !accessToken ||
+    accessTokenSubject(accessToken) !== expectedUserId ||
+    storage.getItem("access_token") !== accessToken ||
+    storage.getItem("refresh_token") !== refreshToken
+  ) {
+    throw accountCredentialMismatchError();
+  }
+
+  return {
+    userId: expectedUserId,
+    accessToken,
+    refreshToken
+  };
+}
+
+export function clearCapturedUserCredentials(
+  snapshot: UserCredentialSnapshot,
+  storage: Storage = window.localStorage
+): void {
+  if (
+    accessTokenSubject(storage.getItem("access_token")) !== snapshot.userId ||
+    storage.getItem("access_token") !== snapshot.accessToken ||
+    storage.getItem("refresh_token") !== snapshot.refreshToken
+  ) {
+    throw accountCredentialMismatchError();
+  }
+
+  // Recheck each exact value immediately before removal. This prevents a logout
+  // that crossed an asynchronous account transition from clearing the new
+  // account's credentials.
+  if (storage.getItem("access_token") !== snapshot.accessToken) {
+    throw accountCredentialMismatchError();
+  }
+  storage.removeItem("access_token");
+
+  if (storage.getItem("refresh_token") !== snapshot.refreshToken) {
+    throw accountCredentialMismatchError();
+  }
+  storage.removeItem("refresh_token");
+}
+
+export async function revokeAndClearUserCredentials({
+  expectedUserId,
+  revokeRefreshToken,
+  storage = window.localStorage
+}: {
+  expectedUserId?: string;
+  revokeRefreshToken: (refreshToken: string) => Promise<void>;
+  storage?: Storage;
+}): Promise<void> {
+  const snapshot = expectedUserId
+    ? captureExpectedUserCredentials(expectedUserId, storage)
+    : undefined;
+  const refreshToken = snapshot ? snapshot.refreshToken : storage.getItem("refresh_token");
+
+  if (refreshToken) {
+    await revokeRefreshToken(refreshToken);
+  }
+
+  if (snapshot) {
+    clearCapturedUserCredentials(snapshot, storage);
+    return;
+  }
+
+  // An unauthenticated provider has no user identity to bind. Preserve its
+  // existing best-effort credential cleanup behavior.
+  storage.removeItem("access_token");
+  storage.removeItem("refresh_token");
+}
+
+export function commitRefreshedUserTokensIfCurrent({
+  initiatingRefreshToken,
+  accessToken,
+  refreshToken,
+  storage = window.localStorage
+}: {
+  initiatingRefreshToken: string;
+  accessToken: string;
+  refreshToken: string;
+  storage?: Storage;
+}): void {
+  if (storage.getItem("refresh_token") !== initiatingRefreshToken) {
+    throw accountCredentialMismatchError();
+  }
+  storage.setItem("access_token", accessToken);
+  storage.setItem("refresh_token", refreshToken);
+}
diff --git a/sdk/src/lib/encryptedApi.ts b/sdk/src/lib/encryptedApi.ts
index 76a088604..ad4890c53 100644
--- a/sdk/src/lib/encryptedApi.ts
+++ b/sdk/src/lib/encryptedApi.ts
@@ -5,6 +5,11 @@ import { getPlatformApiUrl, getPlatformPcrConfig, platformRefreshToken } from ".
 import { apiConfig } from "./apiConfig";
 import { serializePcrConfig, snapshotPcrConfig, type PcrConfig } from "./pcr";
 import { classifyRecovery } from "./recovery";
+import {
+  accessTokenSubject,
+  accountCredentialMismatchError,
+  isAccountCredentialMismatchError
+} from "./credentialIdentity";
 
 interface EncryptedResponse {
   encrypted: string;
@@ -19,6 +24,7 @@ interface ApiResponse<T> {
 interface RequestAuthentication {
   token?: string;
   refreshAccessToken?: () => Promise<string>;
+  assertCurrentToken?: (attemptToken: string | undefined) => void;
 }
 
 interface ActiveAttestation {
@@ -168,6 +174,7 @@ async function performEncryptedApiCall<T, U>(
     );
 
     let token = authentication.token;
+    authentication.assertCurrentToken?.(token);
     let attestation = await dependencies.getAttestation(false, explicitApiUrl, pcrConfig);
     let replayed = false;
 
@@ -186,6 +193,9 @@ async function performEncryptedApiCall<T, U>(
 
     while (true) {
       const session = await requireSession(false);
+      // Attestation and recovery can yield. Bind every transport attempt to
+      // the account that initiated this logical request.
+      authentication.assertCurrentToken?.(token);
       const encryptedData = plaintextBody
         ? dependencies.encryptMessage(session.sessionKey, plaintextBody)
         : undefined;
@@ -200,6 +210,14 @@ async function performEncryptedApiCall<T, U>(
         headers,
         body: encryptedData ? JSON.stringify({ encrypted: encryptedData }) : undefined
       });
+      try {
+        // Do not publish one account's response into a replacement account's
+        // caller state, even when the transport itself succeeded.
+        authentication.assertCurrentToken?.(token);
+      } catch (error) {
+        await discardResponse(response);
+        throw error;
+      }
       const recovery = classifyRecovery(response.status, response.headers);
 
       if (!replayed && recovery === "renew_session") {
@@ -218,7 +236,10 @@ async function performEncryptedApiCall<T, U>(
       if (!replayed && recovery === "refresh_access_token" && authentication.refreshAccessToken) {
         replayed = true;
         await discardResponse(response);
+        // Never consume a replacement account's refresh credential.
+        authentication.assertCurrentToken?.(token);
         token = await authentication.refreshAccessToken();
+        authentication.assertCurrentToken?.(token);
         // The encrypted refresh request can repair a stale session with its
         // own replay budget, so always reload the current session afterward.
         attestation = await dependencies.getAttestation(false, explicitApiUrl, pcrConfig);
@@ -229,29 +250,41 @@ async function performEncryptedApiCall<T, U>(
       if (!response.ok) {
         try {
           const errorBody = (await response.json()) as { message?: string };
+          authentication.assertCurrentToken?.(token);
           result.error =
             errorBody.message || errorMessage || `HTTP error! Status: ${response.status}`;
-        } catch {
+        } catch (error) {
+          // Reading and parsing the body can yield. A credential replacement
+          // must win over the ordinary HTTP fallback rather than being hidden
+          // as a generic request error.
+          authentication.assertCurrentToken?.(token);
+          if (isAccountCredentialMismatchError(error)) throw error;
           result.error = errorMessage || `HTTP error! Status: ${response.status}`;
         }
+        authentication.assertCurrentToken?.(token);
         return result;
       }
 
       try {
         const encryptedResponse = (await response.json()) as EncryptedResponse;
+        authentication.assertCurrentToken?.(token);
         const decryptedResponse = dependencies.decryptMessage(
           session.sessionKey,
           encryptedResponse.encrypted
         );
         result.data = JSON.parse(decryptedResponse) as U;
       } catch (error) {
+        authentication.assertCurrentToken?.(token);
+        if (isAccountCredentialMismatchError(error)) throw error;
         console.error("Error decrypting or parsing response:", error);
         result.status = 500;
         result.error = "Failed to decrypt or parse the response";
       }
+      authentication.assertCurrentToken?.(token);
       return result;
     }
   } catch (error) {
+    if (isAccountCredentialMismatchError(error)) throw error;
     return {
       status: 500,
       error: error instanceof Error ? error.message : "Unknown error occurred"
@@ -269,9 +302,17 @@ export async function authenticatedApiCall<T, U>(
   url: string,
   method: string,
   data: T,
-  errorMessage?: string
+  errorMessage?: string,
+  expectedUserId?: string
 ): Promise<U> {
-  return authenticatedApiCallWithDependencies(url, method, data, errorMessage, defaultDependencies);
+  return authenticatedApiCallWithDependencies(
+    url,
+    method,
+    data,
+    errorMessage,
+    defaultDependencies,
+    expectedUserId
+  );
 }
 
 /** @internal Exported for deterministic transport tests, not from the package entry point. */
@@ -280,11 +321,26 @@ export async function authenticatedApiCallWithDependencies<T, U>(
   method: string,
   data: T,
   errorMessage: string | undefined,
-  dependencies: EncryptedApiDependencies
+  dependencies: EncryptedApiDependencies,
+  expectedUserId?: string
 ): Promise<U> {
   try {
     const accessToken = dependencies.getAccessToken();
     if (!accessToken) throw new Error("No access token available");
+    const expectedSubject = expectedUserId ?? accessTokenSubject(accessToken);
+    if (!expectedSubject || accessTokenSubject(accessToken) !== expectedSubject) {
+      throw accountCredentialMismatchError();
+    }
+
+    const assertCurrentToken = (attemptToken: string | undefined) => {
+      if (
+        accessTokenSubject(attemptToken ?? null) !== expectedSubject ||
+        accessTokenSubject(dependencies.getAccessToken()) !== expectedSubject
+      ) {
+        throw accountCredentialMismatchError();
+      }
+    };
+    assertCurrentToken(accessToken);
 
     const response = await performEncryptedApiCall<T, U>(
       url,
@@ -292,16 +348,22 @@ export async function authenticatedApiCallWithDependencies<T, U>(
       data,
       {
         token: accessToken,
+        assertCurrentToken,
         refreshAccessToken: async () => {
+          assertCurrentToken(accessToken);
           await dependencies.refreshAccessToken(url);
           const refreshedToken = dependencies.getAccessToken();
           if (!refreshedToken) throw new Error("No access token available");
+          assertCurrentToken(refreshedToken);
           return refreshedToken;
         }
       },
       errorMessage,
       dependencies
     );
+    // The inner request resolves through another promise boundary. Re-check
+    // before exposing either its data or its error to the authenticated caller.
+    assertCurrentToken(accessToken);
     return unwrapApiResponse(response, "No data received from the server");
   } catch (error) {
     console.error(error);
diff --git a/sdk/src/lib/index.ts b/sdk/src/lib/index.ts
index bd18e8879..ae6f5c9a2 100644
--- a/sdk/src/lib/index.ts
+++ b/sdk/src/lib/index.ts
@@ -114,7 +114,12 @@ export {
 } from "./api";
 
 // Export AI customization options
-export { createCustomFetch, type CustomFetchOptions } from "./ai";
+export {
+  createCustomFetch,
+  REQUEST_NOT_DISPATCHED_CODE,
+  type CustomFetchOptions,
+  type RequestNotDispatchedMarker
+} from "./ai";
 
 // Re-export Model type from OpenAI for convenience
 export type { Model } from "openai/resources/models.js";
diff --git a/sdk/src/lib/main.tsx b/sdk/src/lib/main.tsx
index e5a23ca88..677a63b84 100644
--- a/sdk/src/lib/main.tsx
+++ b/sdk/src/lib/main.tsx
@@ -13,6 +13,7 @@ import {
 import type { AttestationDocument } from "./attestation";
 import type { LoginResponse, ThirdPartyTokenResponse, DocumentResponse } from "./api";
 import { PcrConfig } from "./pcr";
+import { revokeAndClearUserCredentials } from "./credentialIdentity";
 
 const DEFAULT_PCR_CONFIG: PcrConfig = { environment: "production" };
 
@@ -1034,6 +1035,7 @@ export function OpenSecretProvider({
     loading: true,
     user: undefined
   });
+  const authenticatedUserId = auth.user?.user.id;
   const [apiKey, setApiKeyState] = useState<string | undefined>();
   const [aiCustomFetch, setAiCustomFetch] = useState<OpenSecretContextType["aiCustomFetch"]>();
 
@@ -1079,11 +1081,13 @@ export function OpenSecretProvider({
   useEffect(() => {
     if (apiUrl) {
       // Pass API key if available, otherwise falls back to JWT
-      setAiCustomFetch(() => createCustomFetch({ apiKey, apiUrl, pcrConfig }));
+      setAiCustomFetch(() =>
+        createCustomFetch({ apiKey, apiUrl, pcrConfig, expectedUserId: authenticatedUserId })
+      );
     } else {
       setAiCustomFetch(undefined);
     }
-  }, [apiUrl, apiKey, pcrConfig]);
+  }, [apiUrl, apiKey, authenticatedUserId, pcrConfig]);
 
   async function fetchUser() {
     const access_token = window.localStorage.getItem("access_token");
@@ -1185,16 +1189,16 @@ export function OpenSecretProvider({
   }
 
   async function signOut() {
-    const refresh_token = window.localStorage.getItem("refresh_token");
-    if (refresh_token) {
-      try {
-        await api.fetchLogout(refresh_token);
-      } catch (error) {
-        console.error("Error during logout:", error);
+    await revokeAndClearUserCredentials({
+      expectedUserId: authenticatedUserId,
+      revokeRefreshToken: async (refreshToken) => {
+        try {
+          await api.fetchLogout(refreshToken);
+        } catch (error) {
+          console.error("Error during logout:", error);
+        }
       }
-    }
-    localStorage.removeItem("access_token");
-    localStorage.removeItem("refresh_token");
+    });
     clearAttestationSessions();
     // Clear any in-memory API key so no post-logout calls can use it
     setApiKey(undefined);
@@ -1332,8 +1336,8 @@ export function OpenSecretProvider({
     get: api.fetchGet,
     put: api.fetchPut,
     list: api.fetchList,
-    del: api.fetchDelete,
-    delAll: api.fetchDeleteAllKV,
+    del: (key) => api.fetchDelete(key, authenticatedUserId),
+    delAll: () => api.fetchDeleteAllKV(authenticatedUserId),
     refetchUser: fetchUser,
     verifyEmail: api.verifyEmail,
     requestNewVerificationCode: api.requestNewVerificationCode,
@@ -1348,8 +1352,10 @@ export function OpenSecretProvider({
       plaintextSecret: string,
       newPassword: string
     ) => api.confirmPasswordReset(email, alphanumericCode, plaintextSecret, newPassword, clientId),
-    requestAccountDeletion: api.requestAccountDeletion,
-    confirmAccountDeletion: api.confirmAccountDeletion,
+    requestAccountDeletion: (hashedSecret) =>
+      api.requestAccountDeletion(hashedSecret, authenticatedUserId),
+    confirmAccountDeletion: (confirmationCode, plaintextSecret) =>
+      api.confirmAccountDeletion(confirmationCode, plaintextSecret, authenticatedUserId),
     initiateGitHubAuth,
     handleGitHubCallback,
     initiateGoogleAuth,
@@ -1381,35 +1387,37 @@ export function OpenSecretProvider({
     uploadDocumentWithPolling: api.uploadDocumentWithPolling,
     createApiKey: api.createApiKey,
     listApiKeys: api.listApiKeys,
-    deleteApiKey: api.deleteApiKey,
+    deleteApiKey: (name) => api.deleteApiKey(name, authenticatedUserId),
     transcribeAudio: api.transcribeAudio,
     webSearch: api.webSearch,
     webExtract: api.webExtract,
     fetchResponsesList: api.fetchResponsesList,
     fetchResponse: api.fetchResponse,
-    cancelResponse: api.cancelResponse,
-    deleteResponse: api.deleteResponse,
+    cancelResponse: (responseId) => api.cancelResponse(responseId, authenticatedUserId),
+    deleteResponse: (responseId) => api.deleteResponse(responseId, authenticatedUserId),
     createResponse: api.createResponse,
     createConversation: api.createConversation,
     getConversation: api.getConversation,
     updateConversation: api.updateConversation,
-    deleteConversation: api.deleteConversation,
+    deleteConversation: (conversationId) =>
+      api.deleteConversation(conversationId, authenticatedUserId),
     listConversationItems: api.listConversationItems,
     getConversationItem: api.getConversationItem,
     listConversations: api.listConversations,
-    deleteConversations: api.deleteConversations,
-    batchDeleteConversations: api.batchDeleteConversations,
+    deleteConversations: () => api.deleteConversations(authenticatedUserId),
+    batchDeleteConversations: (ids) => api.batchDeleteConversations(ids, authenticatedUserId),
     batchUpdateConversationProject: api.batchUpdateConversationProject,
     createConversationProject: api.createConversationProject,
     listConversationProjects: api.listConversationProjects,
     getConversationProject: api.getConversationProject,
     updateConversationProject: api.updateConversationProject,
-    deleteConversationProject: api.deleteConversationProject,
+    deleteConversationProject: (projectId) =>
+      api.deleteConversationProject(projectId, authenticatedUserId),
     createInstruction: api.createInstruction,
     listInstructions: api.listInstructions,
     getInstruction: api.getInstruction,
     updateInstruction: api.updateInstruction,
-    deleteInstruction: api.deleteInstruction,
+    deleteInstruction: (instructionId) => api.deleteInstruction(instructionId, authenticatedUserId),
     setDefaultInstruction: api.setDefaultInstruction
   };
 
diff --git a/sdk/src/lib/test/credentialIdentity.test.ts b/sdk/src/lib/test/credentialIdentity.test.ts
new file mode 100644
index 000000000..9f2734dfe
--- /dev/null
+++ b/sdk/src/lib/test/credentialIdentity.test.ts
@@ -0,0 +1,204 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import {
+  ACCOUNT_CREDENTIAL_MISMATCH_CODE,
+  accessTokenSubject,
+  assertExpectedAccessTokenSubject,
+  captureExpectedUserCredentials,
+  clearCapturedUserCredentials,
+  commitRefreshedUserTokensIfCurrent,
+  isAccountCredentialMismatchError,
+  revokeAndClearUserCredentials
+} from "../credentialIdentity";
+
+function tokenForSubject(subject: string): string {
+  const encode = (value: object) =>
+    btoa(JSON.stringify(value)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return `${encode({ alg: "ES256K", typ: "JWT" })}.${encode({ sub: subject })}.signature`;
+}
+
+describe("credential identity", () => {
+  beforeEach(() => window.localStorage.clear());
+
+  test("extracts the stable subject from refreshed JWTs", () => {
+    expect(accessTokenSubject(tokenForSubject("user-a"))).toBe("user-a");
+    expect(accessTokenSubject("invalid")).toBeNull();
+  });
+
+  test("asserts that the current access token belongs to the expected user", () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+
+    expect(() => assertExpectedAccessTokenSubject("user-a")).not.toThrow();
+    expect(() => assertExpectedAccessTokenSubject("user-b")).toThrow();
+  });
+
+  test("recognizes credential mismatch errors without matching arbitrary errors", () => {
+    expect(isAccountCredentialMismatchError({ code: ACCOUNT_CREDENTIAL_MISMATCH_CODE })).toBe(true);
+    expect(isAccountCredentialMismatchError(new Error("network"))).toBe(false);
+  });
+
+  test("captures and clears an unchanged same-account credential pair", () => {
+    const accessToken = tokenForSubject("user-a");
+    window.localStorage.setItem("access_token", accessToken);
+    window.localStorage.setItem("refresh_token", "refresh-a");
+
+    const snapshot = captureExpectedUserCredentials("user-a");
+    expect(snapshot).toEqual({
+      userId: "user-a",
+      accessToken,
+      refreshToken: "refresh-a"
+    });
+
+    clearCapturedUserCredentials(snapshot);
+
+    expect(window.localStorage.getItem("access_token")).toBeNull();
+    expect(window.localStorage.getItem("refresh_token")).toBeNull();
+  });
+
+  test("rejects a stale provider before it can capture another account's refresh token", () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+    window.localStorage.setItem("refresh_token", "refresh-b");
+
+    expect(() => captureExpectedUserCredentials("user-a")).toThrow();
+    expect(window.localStorage.getItem("access_token")).toBe(tokenForSubject("user-b"));
+    expect(window.localStorage.getItem("refresh_token")).toBe("refresh-b");
+  });
+
+  test("does not clear another account's credentials after an in-flight logout", () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    window.localStorage.setItem("refresh_token", "refresh-a");
+    const snapshot = captureExpectedUserCredentials("user-a");
+
+    window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+    window.localStorage.setItem("refresh_token", "refresh-b");
+
+    expect(() => clearCapturedUserCredentials(snapshot)).toThrow();
+    expect(window.localStorage.getItem("access_token")).toBe(tokenForSubject("user-b"));
+    expect(window.localStorage.getItem("refresh_token")).toBe("refresh-b");
+  });
+
+  test("does not clear replacement credentials for the same account", () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    window.localStorage.setItem("refresh_token", "refresh-a");
+    const snapshot = captureExpectedUserCredentials("user-a");
+
+    const refreshedAccessToken = `${tokenForSubject("user-a")}-refreshed`;
+    window.localStorage.setItem("access_token", refreshedAccessToken);
+    window.localStorage.setItem("refresh_token", "refresh-a-new");
+
+    expect(() => clearCapturedUserCredentials(snapshot)).toThrow();
+    expect(window.localStorage.getItem("access_token")).toBe(refreshedAccessToken);
+    expect(window.localStorage.getItem("refresh_token")).toBe("refresh-a-new");
+  });
+
+  test("does not revoke credentials when the provider is already stale", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+    window.localStorage.setItem("refresh_token", "refresh-b");
+    const revokedTokens: string[] = [];
+
+    await expect(
+      revokeAndClearUserCredentials({
+        expectedUserId: "user-a",
+        revokeRefreshToken: async (refreshToken) => {
+          revokedTokens.push(refreshToken);
+        }
+      })
+    ).rejects.toMatchObject({ code: ACCOUNT_CREDENTIAL_MISMATCH_CODE });
+
+    expect(revokedTokens).toEqual([]);
+    expect(window.localStorage.getItem("access_token")).toBe(tokenForSubject("user-b"));
+    expect(window.localStorage.getItem("refresh_token")).toBe("refresh-b");
+  });
+
+  test("revokes only the captured account and preserves a replacement during logout", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    window.localStorage.setItem("refresh_token", "refresh-a");
+    let releaseLogout!: () => void;
+    const revokedTokens: string[] = [];
+
+    const logout = revokeAndClearUserCredentials({
+      expectedUserId: "user-a",
+      revokeRefreshToken: async (refreshToken) => {
+        revokedTokens.push(refreshToken);
+        await new Promise<void>((resolve) => {
+          releaseLogout = resolve;
+        });
+      }
+    });
+
+    expect(revokedTokens).toEqual(["refresh-a"]);
+    window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+    window.localStorage.setItem("refresh_token", "refresh-b");
+    releaseLogout();
+
+    await expect(logout).rejects.toMatchObject({ code: ACCOUNT_CREDENTIAL_MISMATCH_CODE });
+    expect(window.localStorage.getItem("access_token")).toBe(tokenForSubject("user-b"));
+    expect(window.localStorage.getItem("refresh_token")).toBe("refresh-b");
+  });
+
+  test("preserves same-account logout and unauthenticated cleanup behavior", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    window.localStorage.setItem("refresh_token", "refresh-a");
+    const revokedTokens: string[] = [];
+
+    await revokeAndClearUserCredentials({
+      expectedUserId: "user-a",
+      revokeRefreshToken: async (refreshToken) => {
+        revokedTokens.push(refreshToken);
+      }
+    });
+
+    expect(revokedTokens).toEqual(["refresh-a"]);
+    expect(window.localStorage.getItem("access_token")).toBeNull();
+    expect(window.localStorage.getItem("refresh_token")).toBeNull();
+
+    window.localStorage.setItem("access_token", "unverified-access");
+    window.localStorage.setItem("refresh_token", "unverified-refresh");
+    await revokeAndClearUserCredentials({
+      revokeRefreshToken: async (refreshToken) => {
+        revokedTokens.push(refreshToken);
+      }
+    });
+
+    expect(revokedTokens).toEqual(["refresh-a", "unverified-refresh"]);
+    expect(window.localStorage.getItem("access_token")).toBeNull();
+    expect(window.localStorage.getItem("refresh_token")).toBeNull();
+  });
+
+  test("commits a refresh only while its initiating credential still owns storage", () => {
+    window.localStorage.setItem("refresh_token", "refresh-a");
+
+    commitRefreshedUserTokensIfCurrent({
+      initiatingRefreshToken: "refresh-a",
+      accessToken: "access-a-new",
+      refreshToken: "refresh-a-new"
+    });
+
+    expect(window.localStorage.getItem("access_token")).toBe("access-a-new");
+    expect(window.localStorage.getItem("refresh_token")).toBe("refresh-a-new");
+  });
+
+  test("does not overwrite credentials replaced while refresh was in flight", () => {
+    window.localStorage.setItem("access_token", "access-b");
+    window.localStorage.setItem("refresh_token", "refresh-b");
+
+    expect(() =>
+      commitRefreshedUserTokensIfCurrent({
+        initiatingRefreshToken: "refresh-a",
+        accessToken: "late-access-a",
+        refreshToken: "late-refresh-a"
+      })
+    ).toThrow();
+
+    try {
+      commitRefreshedUserTokensIfCurrent({
+        initiatingRefreshToken: "refresh-a",
+        accessToken: "late-access-a",
+        refreshToken: "late-refresh-a"
+      });
+    } catch (error) {
+      expect((error as { code?: string }).code).toBe(ACCOUNT_CREDENTIAL_MISMATCH_CODE);
+    }
+    expect(window.localStorage.getItem("access_token")).toBe("access-b");
+    expect(window.localStorage.getItem("refresh_token")).toBe("refresh-b");
+  });
+});
diff --git a/sdk/src/lib/test/customFetch.test.ts b/sdk/src/lib/test/customFetch.test.ts
index 5109364b6..4a365e167 100644
--- a/sdk/src/lib/test/customFetch.test.ts
+++ b/sdk/src/lib/test/customFetch.test.ts
@@ -1,5 +1,10 @@
 import { beforeEach, describe, expect, test } from "bun:test";
-import { createCustomFetchWithDependencies, type CustomFetchDependencies } from "../ai";
+import {
+  ACCOUNT_CREDENTIAL_MISMATCH_CODE,
+  createCustomFetchWithDependencies,
+  REQUEST_NOT_DISPATCHED_CODE,
+  type CustomFetchDependencies
+} from "../ai";
 import { getApiPcrConfig, getApiUrl, setApiUrl } from "../api";
 import type { Attestation } from "../getAttestation";
 import type { PcrConfig } from "../pcr";
@@ -45,6 +50,12 @@ function contractError(status: number, body: string, code?: string): Response {
   return new Response(body, { status, headers });
 }
 
+function tokenForSubject(subject: string, generation = 1): string {
+  const encode = (value: object) =>
+    btoa(JSON.stringify(value)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return `${encode({ alg: "ES256K", typ: "JWT" })}.${encode({ sub: subject, generation })}.sig`;
+}
+
 function dependencies(overrides: Partial<CustomFetchDependencies>): CustomFetchDependencies {
   return {
     decryptMessage: decryptForTest,
@@ -102,6 +113,383 @@ describe("createCustomFetch stale-session recovery", () => {
     window.sessionStorage.clear();
   });
 
+  test("rejects a mismatched account before attestation or transport", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+    let attestations = 0;
+    let requests = 0;
+    const customFetch = createCustomFetchWithDependencies(
+      { expectedUserId: "user-a" },
+      dependencies({
+        getAttestation: async () => {
+          attestations += 1;
+          return staleAttestation;
+        },
+        fetch: async () => {
+          requests += 1;
+          return Response.json({});
+        }
+      })
+    );
+
+    await expect(customFetch("https://example.test/v1/responses")).rejects.toMatchObject({
+      code: ACCOUNT_CREDENTIAL_MISMATCH_CODE,
+      requestDispatchCode: REQUEST_NOT_DISPATCHED_CODE,
+      definitelyNotDispatched: true
+    });
+    expect(attestations).toBe(0);
+    expect(requests).toBe(0);
+  });
+
+  test("rechecks account ownership after attestation yields", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    let requests = 0;
+    const customFetch = createCustomFetchWithDependencies(
+      { expectedUserId: "user-a" },
+      dependencies({
+        getAttestation: async () => {
+          window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+          return staleAttestation;
+        },
+        fetch: async () => {
+          requests += 1;
+          return Response.json({});
+        }
+      })
+    );
+
+    await expect(customFetch("https://example.test/v1/responses")).rejects.toMatchObject({
+      code: ACCOUNT_CREDENTIAL_MISMATCH_CODE
+    });
+    expect(requests).toBe(0);
+  });
+
+  test("rechecks account ownership after request encryption before transport", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    let requests = 0;
+    const customFetch = createCustomFetchWithDependencies(
+      { expectedUserId: "user-a" },
+      dependencies({
+        encryptMessage: (sessionKey, plaintext) => {
+          window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+          return encryptForTest(sessionKey, plaintext);
+        },
+        fetch: async () => {
+          requests += 1;
+          return Response.json({});
+        }
+      })
+    );
+
+    await expect(
+      customFetch("https://example.test/v1/responses", {
+        method: "POST",
+        body: JSON.stringify({ input: "private" })
+      })
+    ).rejects.toMatchObject({
+      code: ACCOUNT_CREDENTIAL_MISMATCH_CODE,
+      requestDispatchCode: REQUEST_NOT_DISPATCHED_CODE,
+      definitelyNotDispatched: true
+    });
+    expect(requests).toBe(0);
+  });
+
+  test("tags an initial attestation failure as definitely not dispatched", async () => {
+    const attestationError = new Error("attestation unavailable");
+    let requests = 0;
+    const customFetch = createCustomFetchWithDependencies(
+      { apiKey: "test-api-key" },
+      dependencies({
+        getAttestation: async () => {
+          throw attestationError;
+        },
+        fetch: async () => {
+          requests += 1;
+          return Response.json({});
+        }
+      })
+    );
+
+    await expect(customFetch("https://example.test/v1/responses")).rejects.toBe(attestationError);
+    expect(attestationError).toMatchObject({
+      requestDispatchCode: REQUEST_NOT_DISPATCHED_CODE,
+      definitelyNotDispatched: true
+    });
+    expect(requests).toBe(0);
+  });
+
+  test("does not tag a fetch rejection after dispatch was attempted", async () => {
+    const transportError = Object.assign(new Error("network failed"), { code: "network_error" });
+    let requests = 0;
+    const customFetch = createCustomFetchWithDependencies(
+      { apiKey: "test-api-key" },
+      dependencies({
+        fetch: async () => {
+          requests += 1;
+          throw transportError;
+        }
+      })
+    );
+
+    await expect(customFetch("https://example.test/v1/responses")).rejects.toBe(transportError);
+    expect((transportError as { code?: string }).code).not.toBe(REQUEST_NOT_DISPATCHED_CODE);
+    expect(transportError).not.toHaveProperty("requestDispatchCode");
+    expect(transportError).not.toHaveProperty("definitelyNotDispatched");
+    expect(requests).toBe(1);
+  });
+
+  test("does not refresh with credentials replaced by another account", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    let requests = 0;
+    let refreshes = 0;
+    const customFetch = createCustomFetchWithDependencies(
+      { expectedUserId: "user-a" },
+      dependencies({
+        fetch: async () => {
+          requests += 1;
+          window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+          return contractError(401, "expired", "access_token_expired");
+        },
+        refreshToken: async () => {
+          refreshes += 1;
+          throw new Error("must not refresh replacement credentials");
+        }
+      })
+    );
+
+    await expect(customFetch("https://example.test/v1/responses")).rejects.toMatchObject({
+      code: ACCOUNT_CREDENTIAL_MISMATCH_CODE
+    });
+    expect(requests).toBe(1);
+    expect(refreshes).toBe(0);
+  });
+
+  test("allows a JWT refresh that retains the expected account subject", async () => {
+    const initialToken = tokenForSubject("user-a", 1);
+    const refreshedToken = tokenForSubject("user-a", 2);
+    window.localStorage.setItem("access_token", initialToken);
+    const authorizations: Array<string | null> = [];
+    const customFetch = createCustomFetchWithDependencies(
+      { expectedUserId: "user-a" },
+      dependencies({
+        fetch: async (_input, init) => {
+          authorizations.push(recordRequest(init).authorization);
+          return authorizations.length === 1
+            ? contractError(401, "expired", "access_token_expired")
+            : Response.json({ encrypted: '1:{"ok":true}' });
+        },
+        refreshToken: async () => {
+          window.localStorage.setItem("access_token", refreshedToken);
+          return { access_token: refreshedToken, refresh_token: "same-account-refresh" };
+        }
+      })
+    );
+
+    expect(await (await customFetch("https://example.test/v1/responses")).json()).toEqual({
+      ok: true
+    });
+    expect(authorizations).toEqual([`Bearer ${initialToken}`, `Bearer ${refreshedToken}`]);
+  });
+
+  test("marks refresh setup failures after a definitive rejection as not accepted", async () => {
+    const initialToken = tokenForSubject("user-a", 1);
+    window.localStorage.setItem("access_token", initialToken);
+    const refreshError = new Error("refresh unavailable");
+    let requests = 0;
+    const customFetch = createCustomFetchWithDependencies(
+      { expectedUserId: "user-a" },
+      dependencies({
+        fetch: async () => {
+          requests += 1;
+          return contractError(401, "expired", "access_token_expired");
+        },
+        refreshToken: async () => {
+          throw refreshError;
+        }
+      })
+    );
+
+    await expect(customFetch("https://example.test/v1/responses")).rejects.toBe(refreshError);
+    expect(refreshError).toMatchObject({
+      requestDispatchCode: REQUEST_NOT_DISPATCHED_CODE,
+      definitelyNotDispatched: true
+    });
+    expect(requests).toBe(1);
+  });
+
+  test("marks a truncated 4xx error body as definitively rejected", async () => {
+    const bodyError = new Error("error body truncated");
+    const customFetch = createCustomFetchWithDependencies(
+      { apiKey: "test-api-key" },
+      dependencies({
+        fetch: async () => {
+          const response = new Response(null, { status: 422 });
+          Object.defineProperty(response, "text", {
+            value: async () => {
+              throw bodyError;
+            }
+          });
+          return response;
+        }
+      })
+    );
+
+    await expect(customFetch("https://example.test/v1/responses")).rejects.toBe(bodyError);
+    expect(bodyError).toMatchObject({
+      requestDispatchCode: REQUEST_NOT_DISPATCHED_CODE,
+      definitelyNotDispatched: true
+    });
+  });
+
+  test("keeps a truncated generic versioned 5xx body ambiguous", async () => {
+    const bodyError = new Error("error body truncated");
+    const customFetch = createCustomFetchWithDependencies(
+      { apiKey: "test-api-key" },
+      dependencies({
+        fetch: async () => {
+          const response = new Response(null, {
+            status: 500,
+            headers: { "x-opensecret-error-contract": "1" }
+          });
+          Object.defineProperty(response, "text", {
+            value: async () => {
+              throw bodyError;
+            }
+          });
+          return response;
+        }
+      })
+    );
+
+    await expect(customFetch("https://example.test/v1/responses")).rejects.toBe(bodyError);
+    expect(bodyError).not.toHaveProperty("requestDispatchCode");
+    expect(bodyError).not.toHaveProperty("definitelyNotDispatched");
+  });
+
+  test("marks a truncated coded pre-acceptance 5xx body as definitively rejected", async () => {
+    const bodyError = new Error("error body truncated");
+    const customFetch = createCustomFetchWithDependencies(
+      { apiKey: "test-api-key" },
+      dependencies({
+        fetch: async () => {
+          const response = contractError(
+            503,
+            "upstream unavailable",
+            "image_description_unavailable"
+          );
+          Object.defineProperty(response, "text", {
+            value: async () => {
+              throw bodyError;
+            }
+          });
+          return response;
+        }
+      })
+    );
+
+    await expect(customFetch("https://example.test/v1/responses")).rejects.toBe(bodyError);
+    expect(bodyError).toMatchObject({
+      requestDispatchCode: REQUEST_NOT_DISPATCHED_CODE,
+      definitelyNotDispatched: true
+    });
+  });
+
+  test("rejects an encrypted JSON result if the account changes while reading its body", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    const options = { expectedUserId: "user-a" };
+    let decryptions = 0;
+    const customFetch = createCustomFetchWithDependencies(
+      options,
+      dependencies({
+        decryptMessage: (sessionKey, ciphertext) => {
+          decryptions += 1;
+          return decryptForTest(sessionKey, ciphertext);
+        },
+        fetch: async () => {
+          const response = Response.json({ encrypted: '1:{"private":"user-a"}' });
+          Object.defineProperty(response, "text", {
+            value: async () => {
+              await Promise.resolve();
+              options.expectedUserId = "user-b";
+              window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+              return '{"encrypted":"1:{\\"private\\":\\"user-a\\"}"}';
+            }
+          });
+          return response;
+        }
+      })
+    );
+
+    await expect(customFetch("https://example.test/v1/responses")).rejects.toMatchObject({
+      code: ACCOUNT_CREDENTIAL_MISMATCH_CODE
+    });
+    expect(decryptions).toBe(0);
+  });
+
+  test("rejects an error body if the account changes while reading it", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    const customFetch = createCustomFetchWithDependencies(
+      { expectedUserId: "user-a" },
+      dependencies({
+        fetch: async () => {
+          const response = contractError(403, "private failure");
+          Object.defineProperty(response, "text", {
+            value: async () => {
+              await Promise.resolve();
+              window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+              return "private failure";
+            }
+          });
+          return response;
+        }
+      })
+    );
+
+    await expect(customFetch("https://example.test/v1/responses")).rejects.toMatchObject({
+      code: ACCOUNT_CREDENTIAL_MISMATCH_CODE
+    });
+  });
+
+  test("errors an SSE body before enqueueing after the account changes", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    let releaseBody!: () => void;
+    const bodyReleased = new Promise<void>((resolve) => {
+      releaseBody = resolve;
+    });
+    let decryptions = 0;
+    const customFetch = createCustomFetchWithDependencies(
+      { expectedUserId: "user-a" },
+      dependencies({
+        decryptMessage: (sessionKey, ciphertext) => {
+          decryptions += 1;
+          return decryptForTest(sessionKey, ciphertext);
+        },
+        fetch: async () =>
+          new Response(
+            new ReadableStream<Uint8Array>({
+              async start(controller) {
+                await bodyReleased;
+                controller.enqueue(
+                  new TextEncoder().encode(
+                    'event: response.output_text.delta\ndata: 1:{"delta":"private"}\n\n'
+                  )
+                );
+                controller.close();
+              }
+            }),
+            { headers: { "content-type": "text/event-stream" } }
+          )
+      })
+    );
+
+    const response = await customFetch("https://example.test/v1/responses");
+    const result = response.text();
+    window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+    releaseBody();
+
+    await expect(result).rejects.toMatchObject({ code: ACCOUNT_CREDENTIAL_MISMATCH_CODE });
+    expect(decryptions).toBe(0);
+  });
+
   test("renews once and rebuilds an API-key request with the fresh session", async () => {
     let currentAttestation = staleAttestation;
     let forcedAttestations = 0;
@@ -805,7 +1193,11 @@ describe("createCustomFetch stale-session recovery", () => {
 
     await expect(
       customFetch("https://example.test/v1/responses", { signal: controller.signal })
-    ).rejects.toMatchObject({ name: "AbortError" });
+    ).rejects.toMatchObject({
+      name: "AbortError",
+      requestDispatchCode: REQUEST_NOT_DISPATCHED_CODE,
+      definitelyNotDispatched: true
+    });
     expect(attestations).toBe(0);
     expect(requests).toBe(0);
   });
diff --git a/sdk/src/lib/test/encryptedApi.test.ts b/sdk/src/lib/test/encryptedApi.test.ts
index 281e8f44e..918e7feeb 100644
--- a/sdk/src/lib/test/encryptedApi.test.ts
+++ b/sdk/src/lib/test/encryptedApi.test.ts
@@ -8,6 +8,7 @@ import {
 import type { Attestation } from "../getAttestation";
 import { snapshotPcrConfig } from "../pcr";
 import { ERROR_CODE_HEADER, ERROR_CONTRACT_HEADER } from "../recovery";
+import { ACCOUNT_CREDENTIAL_MISMATCH_CODE } from "../credentialIdentity";
 
 const staleKey = new Uint8Array(32).fill(1);
 const freshKey = new Uint8Array(32).fill(2);
@@ -37,6 +38,12 @@ function encryptedSuccess(sessionKey: Uint8Array, value: unknown): Response {
   );
 }
 
+function tokenForSubject(subject: string, generation = 1): string {
+  const encode = (value: object) =>
+    btoa(JSON.stringify(value)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return `${encode({ alg: "ES256K", typ: "JWT" })}.${encode({ sub: subject, generation })}.sig`;
+}
+
 function dependencies(overrides: Partial<EncryptedApiDependencies> = {}): EncryptedApiDependencies {
   return {
     decryptMessage: decryptForTest,
@@ -294,14 +301,224 @@ describe("encrypted API recovery", () => {
     expect(sessionIds).not.toContain("late-extra-session");
   });
 
+  test("an authenticated request fails before transport if attestation yields to another account", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    let sends = 0;
+    let refreshes = 0;
+    const deps = dependencies({
+      getAttestation: async () => {
+        window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+        return staleAttestation;
+      },
+      refreshAccessToken: async () => {
+        refreshes += 1;
+      },
+      fetch: async () => {
+        sends += 1;
+        return encryptedSuccess(staleKey, { ok: true });
+      }
+    });
+
+    await expect(
+      authenticatedApiCallWithDependencies<undefined, { ok: boolean }>(
+        "https://api.example.test/protected/destructive-action",
+        "DELETE",
+        undefined,
+        undefined,
+        deps
+      )
+    ).rejects.toMatchObject({ code: ACCOUNT_CREDENTIAL_MISMATCH_CODE });
+    expect(sends).toBe(0);
+    expect(refreshes).toBe(0);
+  });
+
+  test("a provider-bound request rejects a replacement token before attestation", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+    let attestations = 0;
+    let sends = 0;
+    const deps = dependencies({
+      getAttestation: async () => {
+        attestations += 1;
+        return staleAttestation;
+      },
+      fetch: async () => {
+        sends += 1;
+        return encryptedSuccess(staleKey, { ok: true });
+      }
+    });
+
+    await expect(
+      authenticatedApiCallWithDependencies<undefined, { ok: boolean }>(
+        "https://api.example.test/protected/destructive-action",
+        "DELETE",
+        undefined,
+        undefined,
+        deps,
+        "user-a"
+      )
+    ).rejects.toMatchObject({ code: ACCOUNT_CREDENTIAL_MISMATCH_CODE });
+    expect(attestations).toBe(0);
+    expect(sends).toBe(0);
+  });
+
+  test("does not publish a successful response after the account changes in flight", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    let sends = 0;
+    const deps = dependencies({
+      fetch: async () => {
+        sends += 1;
+        window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+        return encryptedSuccess(staleKey, { private: "user-a" });
+      }
+    });
+
+    await expect(
+      authenticatedApiCallWithDependencies<undefined, { private: string }>(
+        "https://api.example.test/protected/user",
+        "GET",
+        undefined,
+        undefined,
+        deps
+      )
+    ).rejects.toMatchObject({ code: ACCOUNT_CREDENTIAL_MISMATCH_CODE });
+    expect(sends).toBe(1);
+  });
+
+  test("does not publish an encrypted result if the account changes while reading its body", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    let decryptions = 0;
+    const deps = dependencies({
+      decryptMessage: (sessionKey, ciphertext) => {
+        decryptions += 1;
+        return decryptForTest(sessionKey, ciphertext);
+      },
+      fetch: async () => {
+        const response = encryptedSuccess(staleKey, { private: "user-a" });
+        Object.defineProperty(response, "json", {
+          value: async () => {
+            await Promise.resolve();
+            window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+            return { encrypted: encryptForTest(staleKey, '{"private":"user-a"}') };
+          }
+        });
+        return response;
+      }
+    });
+
+    await expect(
+      authenticatedApiCallWithDependencies<undefined, { private: string }>(
+        "https://api.example.test/protected/user",
+        "GET",
+        undefined,
+        undefined,
+        deps
+      )
+    ).rejects.toMatchObject({ code: ACCOUNT_CREDENTIAL_MISMATCH_CODE });
+    expect(decryptions).toBe(0);
+  });
+
+  test("does not downgrade an account change during an error-body read to an HTTP error", async () => {
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
+    const deps = dependencies({
+      fetch: async () => {
+        const response = contractError(403, "Forbidden");
+        Object.defineProperty(response, "json", {
+          value: async () => {
+            await Promise.resolve();
+            window.localStorage.setItem("access_token", tokenForSubject("user-b"));
+            return { message: "Forbidden" };
+          }
+        });
+        return response;
+      }
+    });
+
+    await expect(
+      authenticatedApiCallWithDependencies<undefined, never>(
+        "https://api.example.test/protected/user",
+        "DELETE",
+        undefined,
+        undefined,
+        deps
+      )
+    ).rejects.toMatchObject({ code: ACCOUNT_CREDENTIAL_MISMATCH_CODE });
+  });
+
+  test("a 401 response cannot refresh or replay under a replacement account", async () => {
+    const accessTokenA = tokenForSubject("user-a");
+    const accessTokenB = tokenForSubject("user-b");
+    window.localStorage.setItem("access_token", accessTokenA);
+    let sends = 0;
+    let refreshes = 0;
+    const authorizations: Array<string | null> = [];
+    const deps = dependencies({
+      refreshAccessToken: async () => {
+        refreshes += 1;
+      },
+      fetch: async (_input, init) => {
+        sends += 1;
+        authorizations.push(new Headers(init?.headers).get("Authorization"));
+        window.localStorage.setItem("access_token", accessTokenB);
+        return contractError(401, "Invalid JWT", "access_token_expired");
+      }
+    });
+
+    await expect(
+      authenticatedApiCallWithDependencies<undefined, never>(
+        "https://api.example.test/protected/destructive-action",
+        "DELETE",
+        undefined,
+        undefined,
+        deps
+      )
+    ).rejects.toMatchObject({ code: ACCOUNT_CREDENTIAL_MISMATCH_CODE });
+    expect(sends).toBe(1);
+    expect(refreshes).toBe(0);
+    expect(authorizations).toEqual([`Bearer ${accessTokenA}`]);
+  });
+
+  test("an account replacement during refresh cannot replay the retained request", async () => {
+    const accessTokenA = tokenForSubject("user-a");
+    const accessTokenB = tokenForSubject("user-b");
+    window.localStorage.setItem("access_token", accessTokenA);
+    let sends = 0;
+    let refreshes = 0;
+    const deps = dependencies({
+      refreshAccessToken: async () => {
+        refreshes += 1;
+        window.localStorage.setItem("access_token", accessTokenB);
+      },
+      fetch: async () => {
+        sends += 1;
+        return sends === 1
+          ? contractError(401, "Invalid JWT", "access_token_expired")
+          : encryptedSuccess(staleKey, { ok: true });
+      }
+    });
+
+    await expect(
+      authenticatedApiCallWithDependencies<undefined, { ok: boolean }>(
+        "https://api.example.test/protected/destructive-action",
+        "DELETE",
+        undefined,
+        undefined,
+        deps
+      )
+    ).rejects.toMatchObject({ code: ACCOUNT_CREDENTIAL_MISMATCH_CODE });
+    expect(sends).toBe(1);
+    expect(refreshes).toBe(1);
+  });
+
   test("v1 access-token expiry refreshes once and replays with the new token", async () => {
-    window.localStorage.setItem("access_token", "expired-access-token");
+    const expiredAccessToken = tokenForSubject("user-a", 1);
+    const freshAccessToken = tokenForSubject("user-a", 2);
+    window.localStorage.setItem("access_token", expiredAccessToken);
     let tokenRefreshes = 0;
     const authorizations: Array<string | null> = [];
     const deps = dependencies({
       refreshAccessToken: async () => {
         tokenRefreshes += 1;
-        window.localStorage.setItem("access_token", "fresh-access-token");
+        window.localStorage.setItem("access_token", freshAccessToken);
       },
       fetch: async (_input, init) => {
         authorizations.push(new Headers(init?.headers).get("Authorization"));
@@ -321,7 +538,7 @@ describe("encrypted API recovery", () => {
       )
     ).toEqual({ ok: true });
     expect(tokenRefreshes).toBe(1);
-    expect(authorizations).toEqual(["Bearer expired-access-token", "Bearer fresh-access-token"]);
+    expect(authorizations).toEqual([`Bearer ${expiredAccessToken}`, `Bearer ${freshAccessToken}`]);
   });
 
   for (const ordinary of [
@@ -329,7 +546,7 @@ describe("encrypted API recovery", () => {
     { status: 401, code: "invalid_jwt", message: "Invalid JWT" }
   ]) {
     test(`v1 ordinary ${ordinary.status} fails closed`, async () => {
-      window.localStorage.setItem("access_token", "access-token");
+      window.localStorage.setItem("access_token", tokenForSubject("user-a"));
       let sends = 0;
       let forcedAttestations = 0;
       let tokenRefreshes = 0;
@@ -363,7 +580,9 @@ describe("encrypted API recovery", () => {
   }
 
   test("headerless 400 and 401 retain legacy recovery", async () => {
-    window.localStorage.setItem("access_token", "expired-access-token");
+    const expiredAccessToken = tokenForSubject("user-a", 1);
+    const freshAccessToken = tokenForSubject("user-a", 2);
+    window.localStorage.setItem("access_token", expiredAccessToken);
     let currentAttestation = staleAttestation;
     let sessionSends = 0;
     let authSends = 0;
@@ -379,7 +598,7 @@ describe("encrypted API recovery", () => {
       },
       refreshAccessToken: async () => {
         tokenRefreshes += 1;
-        window.localStorage.setItem("access_token", "fresh-access-token");
+        window.localStorage.setItem("access_token", freshAccessToken);
       },
       fetch: async (input) => {
         if (String(input).endsWith("/legacy-session")) {
@@ -421,7 +640,7 @@ describe("encrypted API recovery", () => {
   });
 
   test("one target replay budget stops alternating recovery reasons", async () => {
-    window.localStorage.setItem("access_token", "access-token");
+    window.localStorage.setItem("access_token", tokenForSubject("user-a"));
     let currentAttestation = staleAttestation;
     let sends = 0;
     let forcedAttestations = 0;
@@ -460,16 +679,16 @@ describe("encrypted API recovery", () => {
   });
 
   test("expired target JWT can refresh through one stale-session repair", async () => {
-    window.localStorage.setItem("access_token", "expired-access-token");
+    const expiredAccessToken = tokenForSubject("user-a", 1);
+    const freshAccessToken = tokenForSubject("user-a", 2);
+    window.localStorage.setItem("access_token", expiredAccessToken);
     let currentAttestation = staleAttestation;
     let forcedAttestations = 0;
     let targetSends = 0;
     let refreshSends = 0;
     const targetRequests: ReturnType<typeof recordedRequest>[] = [];
     const refreshRequests: ReturnType<typeof recordedRequest>[] = [];
-    let deps!: EncryptedApiDependencies;
-
-    deps = dependencies({
+    const deps = dependencies({
       getAttestation: async (forceRefresh) => {
         if (forceRefresh) {
           forcedAttestations += 1;
@@ -501,7 +720,7 @@ describe("encrypted API recovery", () => {
           return refreshSends === 1
             ? contractError(400, "Bad Request", "session_not_found")
             : encryptedSuccess(freshKey, {
-                access_token: "fresh-access-token",
+                access_token: freshAccessToken,
                 refresh_token: "fresh-refresh-token"
               });
         }
@@ -532,13 +751,13 @@ describe("encrypted API recovery", () => {
     ]);
     expect(targetRequests).toEqual([
       {
-        authorization: "Bearer expired-access-token",
+        authorization: `Bearer ${expiredAccessToken}`,
         method: "POST",
         plaintext: '{"prompt":"same prompt"}',
         sessionId: "stale-session"
       },
       {
-        authorization: "Bearer fresh-access-token",
+        authorization: `Bearer ${freshAccessToken}`,
         method: "POST",
         plaintext: '{"prompt":"same prompt"}',
         sessionId: "fresh-session"
diff --git a/sdk/src/lib/test/integration/platformPushSettings.test.ts b/sdk/src/lib/test/integration/platformPushSettings.test.ts
index 7438ab808..2a6b5dec0 100644
--- a/sdk/src/lib/test/integration/platformPushSettings.test.ts
+++ b/sdk/src/lib/test/integration/platformPushSettings.test.ts
@@ -10,10 +10,11 @@ import {
   updatePushSettings,
   type PushSettings
 } from "../../platformApi";
+import { testAccessTokenForSubject } from "../utils";
 
 const sessionKey = new Uint8Array(32).fill(7);
 const sessionId = "push-settings-session-id";
-const accessToken = "push-settings-access-token";
+const accessToken = testAccessTokenForSubject("push-settings-user");
 const platformApiUrl = "https://platform.example.com";
 const verifiedPcr0 =
   "eeddbb58f57c38894d6d5af5e575fbe791c5bf3bbcfb5df8da8cfcf0c2e1da1913108e6a762112444740b88c163d7f4b";
diff --git a/sdk/src/lib/test/integration/web.test.ts b/sdk/src/lib/test/integration/web.test.ts
index aa00c7233..2db28338e 100644
--- a/sdk/src/lib/test/integration/web.test.ts
+++ b/sdk/src/lib/test/integration/web.test.ts
@@ -13,9 +13,10 @@ import {
   type WebSearchRequest,
   type WebSearchResponse
 } from "../../api";
+import { testAccessTokenForSubject } from "../utils";
 
 const apiUrl = "https://api.example.com";
-const accessToken = "web-access-token";
+const accessToken = testAccessTokenForSubject("web-user");
 const sessionId = "web-session-id";
 const sessionKey = new Uint8Array(32).fill(19);
 const verifiedPcr0 =
diff --git a/sdk/src/lib/test/models.test.ts b/sdk/src/lib/test/models.test.ts
index 63e7c9e15..e8957831b 100644
--- a/sdk/src/lib/test/models.test.ts
+++ b/sdk/src/lib/test/models.test.ts
@@ -3,6 +3,7 @@ import { encryptMessage } from "../encryption";
 import { cacheAttestationSessionForTesting } from "../getAttestation";
 import type { PcrConfig } from "../pcr";
 import { fetchModelCatalog, fetchModels, getApiPcrConfig, getApiUrl, setApiUrl } from "../api";
+import { testAccessTokenForSubject } from "./utils";
 
 const apiUrl = "https://models.example.com";
 const sessionId = "models-session-id";
@@ -71,11 +72,12 @@ test("fetchModels uses the encrypted session before sign-in", async () => {
 });
 
 test("fetchModels preserves stored JWT authentication", async () => {
-  window.localStorage.setItem("access_token", "models-access-token");
+  const accessToken = testAccessTokenForSubject("models-user");
+  window.localStorage.setItem("access_token", accessToken);
 
   globalThis.fetch = mock(async (_input: string | URL | Request, init?: RequestInit) => {
     const headers = new Headers(init?.headers);
-    expect(headers.get("Authorization")).toBe("Bearer models-access-token");
+    expect(headers.get("Authorization")).toBe(`Bearer ${accessToken}`);
     expect(headers.get("x-session-id")).toBe(sessionId);
     return encryptedModelsResponse();
   }) as typeof fetch;
@@ -85,12 +87,13 @@ test("fetchModels preserves stored JWT authentication", async () => {
 
 test("fetchModels never downgrades a rejected stored JWT to anonymous access", async () => {
   let requestCount = 0;
-  window.localStorage.setItem("access_token", "rejected-access-token");
+  const accessToken = testAccessTokenForSubject("models-user");
+  window.localStorage.setItem("access_token", accessToken);
 
   globalThis.fetch = mock(async (_input: string | URL | Request, init?: RequestInit) => {
     requestCount += 1;
     const headers = new Headers(init?.headers);
-    expect(headers.get("Authorization")).toBe("Bearer rejected-access-token");
+    expect(headers.get("Authorization")).toBe(`Bearer ${accessToken}`);
 
     return Response.json({ message: "Invalid JWT" }, { status: 401 });
   }) as typeof fetch;
diff --git a/sdk/src/lib/test/utils.ts b/sdk/src/lib/test/utils.ts
index a590672c8..f04ca94ba 100644
--- a/sdk/src/lib/test/utils.ts
+++ b/sdk/src/lib/test/utils.ts
@@ -11,3 +11,9 @@ export function bytesToHex(bytes: Uint8Array): string {
     .map((b) => b.toString(16).padStart(2, "0"))
     .join("");
 }
+
+export function testAccessTokenForSubject(subject: string): string {
+  const encode = (value: object) =>
+    btoa(JSON.stringify(value)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return `${encode({ alg: "ES256K", typ: "JWT" })}.${encode({ sub: subject })}.sig`;
+}