@molecule/app-react 1.6.6 → 1.7.0

package/dist/hooks/useChat.js

@@ -73,7 +73,7 @@ function persistQueue(projectId, queue) {
     }
 }
 /**
- * Load and clear the persisted queue for a project.
+ * Load the persisted queue for a project without discarding unacknowledged work.
  * @param projectId - The project identifier used as the storage key.
  * @returns The previously persisted queue entries, or an empty array if none found.
  */
@@ -81,7 +81,6 @@ function loadPersistedQueue(projectId) {
     try {
         const raw = sessionStorage.getItem(`${STORAGE_PREFIX}queue-${projectId}`);
         if (raw) {
-            sessionStorage.removeItem(`${STORAGE_PREFIX}queue-${projectId}`);
             return JSON.parse(raw);
         }
     }
@@ -132,6 +131,7 @@ function consumeStreamingFlag(projectId) {
 }
 /** Stable empty array for the SSR/initial snapshot (useSyncExternalStore needs referential stability). */
 const EMPTY_MESSAGES = [];
+const EMPTY_TASKS = [];
 const messageStores = new Map();
 /**
  * Get (creating if needed) the live message store for a conversation key.
@@ -143,9 +143,13 @@ function getMessageStore(key) {
     if (!store) {
         store = {
             messages: [],
+            backgroundTasks: [],
+            pending: { current: [] },
+            deliveredQueueIds: new Set(),
             streaming: false,
             remoteStreaming: false,
             stoppedByUser: false,
+            userIntentRevision: 0,
             remotePollTimer: null,
             listeners: new Set(),
             generation: 0,
@@ -175,6 +179,74 @@ function setStoreMessages(key, updater) {
     store.messages = typeof updater === 'function' ? updater(store.messages) : updater;
     emitStore(key);
 }
+/** Update conversation-level work independently of any assistant message. */
+function mergeBackgroundTasks(key, tasks) {
+    const store = getMessageStore(key);
+    const next = new Map(store.backgroundTasks.map((task) => [task.id, task]));
+    for (const task of tasks) {
+        const previous = next.get(task.id);
+        if (previous && previous.status !== 'running' && task.status === 'running')
+            continue;
+        next.set(task.id, {
+            ...task,
+            ...(previous?.outputChars != null
+                ? { outputChars: Math.max(previous.outputChars, task.outputChars ?? 0) }
+                : {}),
+        });
+    }
+    store.backgroundTasks = [...next.values()];
+    emitStore(key);
+}
+/** Recover durable queue handles; the server keeps full attachment payloads behind each UUID. */
+function restoreQueuedMessages(key, history, acceptedBeforeLoad = new Set()) {
+    const pending = getMessageStore(key).pending;
+    const queuedIds = new Set(history.filter((message) => message.queued).map((message) => message.id));
+    const removed = new Set([...acceptedBeforeLoad].filter((id) => !queuedIds.has(id)));
+    for (const id of removed)
+        getMessageStore(key).deliveredQueueIds.add(id);
+    pending.current = pending.current.filter((entry) => !entry.userMsgId || !removed.has(entry.userMsgId));
+    if (removed.size > 0)
+        setStoreMessages(key, (messages) => messages.filter((message) => !message.queued || !removed.has(message.id)));
+    for (const message of history) {
+        if (message.role !== 'user')
+            continue;
+        const existing = pending.current.find((entry) => entry.userMsgId === message.id);
+        if (message.queued) {
+            if (getMessageStore(key).deliveredQueueIds.has(message.id))
+                continue;
+            if (existing)
+                existing.accepted = true;
+            if (!existing)
+                pending.current.push({
+                    message: message.content,
+                    userMsgId: message.id,
+                    durable: true,
+                    accepted: true,
+                    ...(message.automatic ? { automatic: true } : {}),
+                    ...(message.viaDictation ? { viaDictation: true } : {}),
+                });
+        }
+        else {
+            pending.current = pending.current.filter((entry) => entry.userMsgId !== message.id);
+        }
+    }
+    persistQueue(key, pending.current);
+    return history.filter((message) => !message.queued || !getMessageStore(key).deliveredQueueIds.has(message.id));
+}
+/** Only acceptance known before a history request can be authoritatively reconciled by it. */
+function acceptedQueueIds(key) {
+    return new Set(getMessageStore(key)
+        .pending.current.filter((entry) => entry.accepted && entry.userMsgId != null)
+        .map((entry) => entry.userMsgId));
+}
+/** Remove a queue item in every mounted view and reject delayed acceptance snapshots. */
+function removeQueuedMessage(key, messageId) {
+    const store = getMessageStore(key);
+    store.pending.current = store.pending.current.filter((entry) => entry.userMsgId !== messageId);
+    store.deliveredQueueIds.add(messageId);
+    persistQueue(key, store.pending.current);
+    setStoreMessages(key, (messages) => messages.filter((message) => message.id !== messageId || !message.queued));
+}
 /**
  * Set whether a conversation has an active stream, notifying subscribers on change.
  * @param key - The conversation/project storage key.
@@ -295,6 +367,10 @@ export function convergeHistory(prev, history) {
         const local = prevById.get(h.id);
         if (!local)
             return h;
+        if (local.queued)
+            return h;
+        if (h.queued)
+            return local;
         // Keep the live copy when it is at least as far along; carry its streaming
         // flag either way so an in-progress message keeps its spinner across merges.
         const winner = messageProgress(local) >= messageProgress(h) ? local : h;
@@ -480,6 +556,7 @@ export function useChat(options) {
     const messages = useSyncExternalStore(subscribeStore, () => getMessageStore(storageKey).messages, () => EMPTY_MESSAGES);
     const isLoading = useSyncExternalStore(subscribeStore, () => getMessageStore(storageKey).streaming, () => false);
     const isRemoteStreaming = useSyncExternalStore(subscribeStore, () => getMessageStore(storageKey).remoteStreaming, () => false);
+    const backgroundTasks = useSyncExternalStore(subscribeStore, () => getMessageStore(storageKey).backgroundTasks, () => EMPTY_TASKS);
     // The store generation this instance last aligned with (stamped by the mount
     // effect and on each send/resume start). Null until first stamped — treated
     // as current. An UNMOUNTED instance's stream callbacks keep this ref frozen
@@ -513,8 +590,50 @@ export function useChat(options) {
     // echo (own broadcast in a second tab) or a reload-then-broadcast race never doubles
     // it. A complete message is a finished item — no streaming/finalize.
     const appendCompleteMessage = useCallback((message) => {
-        setMessages((prev) => (prev.some((m) => m.id === message.id) ? prev : [...prev, message]));
-    }, [setMessages]);
+        const store = getMessageStore(storageKey);
+        const pending = store.pending;
+        const existingMessage = store.messages.find((item) => item.id === message.id);
+        if (message.queued &&
+            (store.deliveredQueueIds.has(message.id) || (existingMessage && !existingMessage.queued)))
+            return;
+        if (!message.queued) {
+            if (message.hidden || pending.current.some((entry) => entry.userMsgId === message.id))
+                store.deliveredQueueIds.add(message.id);
+            pending.current = pending.current.filter((entry) => entry.userMsgId !== message.id);
+        }
+        else {
+            const entry = pending.current.find((item) => item.userMsgId === message.id);
+            if (entry) {
+                entry.accepted = true;
+                entry.message = message.content;
+            }
+            else if (provider.queueMessage)
+                pending.current.push({
+                    userMsgId: message.id,
+                    message: message.content,
+                    durable: true,
+                    accepted: true,
+                    ...(message.hidden ? { suppressUserMessage: true } : {}),
+                    ...(message.automatic ? { automatic: true } : {}),
+                    ...(message.viaDictation ? { viaDictation: true } : {}),
+                });
+        }
+        persistQueue(storageKey, pending.current);
+        if (message.hidden) {
+            if (!message.queued)
+                setMessages((prev) => prev.filter((item) => item.id !== message.id || !item.queued));
+            return;
+        }
+        setMessages((prev) => {
+            const existing = prev.find((item) => item.id === message.id);
+            if (!existing)
+                return [...prev, message];
+            // A delayed acceptance response cannot re-queue a message already delivered.
+            if (!existing.queued)
+                return prev;
+            return prev.map((item) => (item.id === message.id ? message : item));
+        });
+    }, [provider, setMessages, storageKey]);
     const setIsLoading = useCallback((streaming) => {
         if (isStaleGeneration())
             return;
@@ -524,8 +643,17 @@ export function useChat(options) {
     // send is in flight — confirm against the server's streaming flag and track
     // the remote turn so the Stop control stays visible (see startRemoteStreamPoll).
     const noteRemoteStreamEvent = useCallback(() => {
+        const generation = getMessageStore(storageKey).generation;
         startRemoteStreamPoll(storageKey, async () => {
-            const history = await provider.loadHistory({ endpoint, projectId });
+            const accepted = acceptedQueueIds(storageKey);
+            const intentRevision = getMessageStore(storageKey).userIntentRevision;
+            let history = await provider.loadHistory({ endpoint, projectId });
+            if (getMessageStore(storageKey).generation === generation) {
+                restoreBackgroundTasks();
+                restoreUserStop(intentRevision);
+                if (provider.queueMessage)
+                    history = restoreQueuedMessages(storageKey, history, accepted);
+            }
             return {
                 streaming: provider.isServerStreaming === true,
                 history,
@@ -575,7 +703,23 @@ export function useChat(options) {
     // than per-message on purpose: one starts under one assistant message and
     // finishes minutes later under another, so a message-scoped block could only
     // ever show half of it.
-    const [backgroundTasks, setBackgroundTasks] = useState([]);
+    const restoreBackgroundTasks = () => {
+        const tasks = provider.lastMeta
+            ?.backgroundTasks;
+        if (Array.isArray(tasks))
+            mergeBackgroundTasks(storageKey, tasks);
+    };
+    const restoreUserStop = (intentRevision) => {
+        const store = getMessageStore(storageKey);
+        const stoppedAt = provider.lastMeta?.userStoppedAt;
+        // Missing metadata must never clear a local Stop. A history request begun
+        // before the user's next send must likewise never reinstate an old Stop.
+        if (store.userIntentRevision === intentRevision &&
+            !store.streaming &&
+            typeof stoppedAt === 'string' &&
+            stoppedAt.length > 0)
+            store.stoppedByUser = true;
+    };
     // Pace status labels. A small change's verification (type-check + lint over a
     // couple of files) finishes in well under a second, so its step labels were
     // emitted in a rapid burst — they flashed by unreadably, or React batched the
@@ -631,7 +775,7 @@ export function useChat(options) {
     const loadOnMountRef = useRef(loadOnMount);
     // Queue for messages sent while a request is already in-flight
     const sendingRef = useRef(false);
-    const pendingRef = useRef([]);
+    const pendingRef = useMemo(() => getMessageStore(storageKey).pending, [storageKey]);
     // Set when the user clicks Stop, so the post-send reconcile does NOT overwrite
     // the locally-finalized streamed content with server history. The abort()
     // callback already finalizes the streaming message (keeping every streamed
@@ -758,8 +902,17 @@ export function useChat(options) {
     // — a teammate's /teamsay note against a backgrounded tab or a slept laptop —
     // is otherwise lost until the next lifecycle event happens to fire.
     const reconcileHistory = useCallback(async () => {
+        const generation = getMessageStore(storageKey).generation;
+        const intentRevision = getMessageStore(storageKey).userIntentRevision;
+        const accepted = acceptedQueueIds(storageKey);
         try {
-            const history = await provider.loadHistory({ endpoint, projectId });
+            let history = await provider.loadHistory({ endpoint, projectId });
+            if (getMessageStore(storageKey).generation !== generation)
+                return;
+            restoreBackgroundTasks();
+            restoreUserStop(intentRevision);
+            if (provider.queueMessage)
+                history = restoreQueuedMessages(storageKey, history, accepted);
             if (!mountedRef.current || sendingRef.current)
                 return;
             applyServerMode();
@@ -795,7 +948,7 @@ export function useChat(options) {
                 noteRemoteStreamEvent();
                 return;
             }
-            if (serverStreaming && history.length > 0) {
+            if (serverStreaming && history.length > 0 && !store.stoppedByUser) {
                 const last = history[history.length - 1];
                 if (last.role === 'assistant') {
                     void resumeStreamRef.current(last.id, last.content);
@@ -971,13 +1124,16 @@ export function useChat(options) {
             resumeStreamRef.current(target.id, target.content);
             return;
         }
-        // Re-send: drop the original optimistic bubble first so the re-send's own
-        // bubble doesn't duplicate it (same content, new id, re-stamped timestamp).
+        // Re-send under the original id: an acceptance whose response was lost must
+        // not create a second server message. Refresh the optimistic bubble in place.
         if (target.userMsgId) {
             const uid = target.userMsgId;
             setMessages((prev) => prev.filter((m) => m.id !== uid));
         }
-        void sendMessageRef.current(target.message, target.attachments, target.options);
+        void sendMessageRef.current(target.message, target.attachments, {
+            ...target.options,
+            ...(target.userMsgId ? { messageId: target.userMsgId } : {}),
+        });
     }, [clearRetryTimers]);
     /**
      * Schedule a cancelable, once-per-second countdown that auto-resumes the turn
@@ -1100,18 +1256,34 @@ export function useChat(options) {
             stopRemoteStreamPoll(storageKey);
             setStoreStreaming(storageKey, false);
             setStoreMessages(storageKey, []);
+            syncStore.backgroundTasks = [];
+            syncStore.pending.current = [];
+            syncStore.deliveredQueueIds.clear();
+            persistQueue(storageKey, []);
+            emitStore(storageKey);
         }
         generationRef.current = syncStore.generation;
+        const loadGeneration = syncStore.generation;
+        const intentRevision = syncStore.userIntentRevision;
         if (!loadOnMountRef.current)
             return;
         // Read persisted state synchronously before the async history fetch
         const persistedQueue = loadPersistedQueue(storageKey);
         const interrupted = consumeStreamingFlag(storageKey);
+        const accepted = acceptedQueueIds(storageKey);
         provider
             .loadHistory(config)
             .then((history) => {
-            if (!mountedRef.current)
+            if (!mountedRef.current || syncStore.generation !== loadGeneration)
                 return;
+            restoreBackgroundTasks();
+            restoreUserStop(intentRevision);
+            if (provider.queueMessage)
+                history = restoreQueuedMessages(storageKey, history, accepted);
+            // A server-accepted item absent from fresh history was consumed/deleted.
+            // Unacknowledged submissions still need their idempotent retry.
+            const queuedIds = new Set(history.filter((item) => item.queued).map((item) => item.id));
+            const restoreQueue = persistedQueue.filter((entry) => !entry.accepted || (entry.userMsgId != null && queuedIds.has(entry.userMsgId)));
             // Restore mode from server (persisted in conversation.aiContext.mode).
             // Idempotent + cheap, so do it regardless of store state. The http bond
             // surfaces app-specific GET fields generically via `lastMeta` (it no
@@ -1160,7 +1332,7 @@ export function useChat(options) {
                 }
                 return;
             }
-            const shouldResume = (interrupted || serverStreaming) && history.length > 0;
+            const shouldResume = !syncStore.stoppedByUser && (interrupted || serverStreaming) && history.length > 0;
             if (shouldResume) {
                 // Stream was interrupted — resume into the last assistant message,
                 // or create a new placeholder if the last message is from the user
@@ -1184,24 +1356,42 @@ export function useChat(options) {
                     setMessages((prev) => [...prev, placeholder]);
                     resumeTarget = { id: placeholderId, content: '' };
                 }
-                pendingRef.current.push(...persistedQueue);
+                for (const entry of restoreQueue) {
+                    if (!entry.userMsgId ||
+                        !pendingRef.current.some((item) => item.userMsgId === entry.userMsgId))
+                        pendingRef.current.push(entry);
+                }
                 const target = resumeTarget;
                 setTimeout(() => {
-                    if (mountedRef.current) {
+                    if (mountedRef.current &&
+                        syncStore.generation === loadGeneration &&
+                        !syncStore.stoppedByUser) {
                         resumeStreamRef.current(target.id, target.content);
                     }
                 }, 0);
             }
-            else if (persistedQueue.length > 0) {
-                const [first, ...rest] = persistedQueue;
-                pendingRef.current.push(...rest);
+            else if (restoreQueue.length > 0 || pendingRef.current.length > 0) {
+                for (const entry of restoreQueue) {
+                    if (!entry.userMsgId ||
+                        !pendingRef.current.some((item) => item.userMsgId === entry.userMsgId))
+                        pendingRef.current.push(entry);
+                }
+                persistQueue(storageKey, pendingRef.current);
+                if (syncStore.stoppedByUser)
+                    return;
+                const first = pendingRef.current[0];
+                if (!first.durable)
+                    pendingRef.current.shift();
                 setTimeout(() => {
-                    if (mountedRef.current) {
+                    if (mountedRef.current &&
+                        syncStore.generation === loadGeneration &&
+                        !syncStore.stoppedByUser) {
                         // Re-send with the entry's own intent flags — a queue persisted
                         // before a refresh must re-send as what it was (an auto-sent
                         // fix stays automatic, a dictated message keeps its flag), not
                         // degraded to a plain typed message.
                         sendMessageRef.current(first.message, first.attachments, {
+                            ...(first.userMsgId ? { messageId: first.userMsgId } : {}),
                             ...(first.suppressUserMessage ? { suppressUserMessage: true } : {}),
                             ...(first.automatic ? { automatic: true } : {}),
                             ...(first.userInitiated ? { userInitiated: true } : {}),
@@ -1334,15 +1524,6 @@ export function useChat(options) {
                 });
                 ctx.scheduleFlush(() => ({ blocks: [...ctx.blocks] }));
                 break;
-            case 'background_task': {
-                const incoming = event.task;
-                setBackgroundTasks((prev) => {
-                    const next = prev.filter((t) => t.id !== incoming.id);
-                    next.push(incoming);
-                    return next;
-                });
-                break;
-            }
             case 'resource_limit':
                 ctx.blocks.push({
                     type: 'resource_limit',
@@ -1496,6 +1677,14 @@ export function useChat(options) {
             onStreamEvent?.(event);
             // ── Structural / ctx-independent events ──
             switch (event.type) {
+                case 'queue_removed':
+                    removeQueuedMessage(storageKey, event.messageId);
+                    return;
+                case 'background_task':
+                    mergeBackgroundTasks(storageKey, [event.task]);
+                    return;
+                case 'context_usage':
+                    return;
                 case 'message_start':
                     // A status line shown before this message (e.g. "The AI provider
                     // dropped the reply, so Synthase is resuming it…") has done its job
@@ -1632,6 +1821,16 @@ export function useChat(options) {
     finalizeRemoteStreamRef.current = finalizeRemoteStream;
     const applyRemoteEventImpl = (event) => {
         const store = getMessageStore(storageKey);
+        if (event.type === 'queue_removed') {
+            removeQueuedMessage(storageKey, event.messageId);
+            return;
+        }
+        if (event.type === 'background_task') {
+            mergeBackgroundTasks(storageKey, [event.task]);
+            return;
+        }
+        if (event.type === 'context_usage')
+            return;
         // Complete, id-deduped items apply even while a local stream runs: the
         // sender's own SSE copy wins the dedupe, and a teammate's team note (or a
         // shared setting card) must land mid-turn too.
@@ -1642,7 +1841,10 @@ export function useChat(options) {
         if (event.type === 'message') {
             // A broadcast user message: the sender's tab already shows its optimistic
             // bubble (different local id) — never double it while its send is live.
-            if (event.message.role === 'user' && store.streaming)
+            if (event.message.role === 'user' &&
+                store.streaming &&
+                !provider.queueMessage &&
+                !store.messages.some((message) => message.id === event.message.id && message.queued))
                 return;
             appendCompleteMessage(event.message);
             return;
@@ -1716,6 +1918,21 @@ export function useChat(options) {
                 finalizeRemoteStreamRef.current();
                 resetStatusQueue();
                 setStoreRemoteStreaming(storageKey, false);
+                if (event.type === 'done' && mountedRef.current && !readOnly && !store.stoppedByUser) {
+                    const next = pendingRef.current[0];
+                    if (next) {
+                        if (!next.durable)
+                            pendingRef.current.shift();
+                        persistQueue(storageKey, pendingRef.current);
+                        void sendMessageRef.current(next.message, next.attachments, {
+                            messageId: next.userMsgId,
+                            suppressUserMessage: next.suppressUserMessage,
+                            automatic: next.automatic,
+                            userInitiated: next.userInitiated,
+                            viaDictation: next.viaDictation,
+                        });
+                    }
+                }
                 return;
             default:
                 break;
@@ -1843,6 +2060,8 @@ export function useChat(options) {
                 return;
             store.stoppedByUser = false;
         }
+        if (!automatic || options?.userInitiated)
+            store.userIntentRevision++;
         // Resolve the pending ask_user card IN THE STORE: set the most-recent unanswered
         // ask_user tool call's output to this answer. The chosen option's checked state is
         // derived from a string `output`, so persisting it here keeps it checked across the
@@ -1869,7 +2088,7 @@ export function useChat(options) {
             });
         }
         const userMsg = {
-            id: `user-${++idCounterRef.current}`,
+            id: options?.messageId ?? crypto.randomUUID(),
             role: 'user',
             content: message,
             timestamp: Date.now(),
@@ -1886,24 +2105,64 @@ export function useChat(options) {
                 : {}),
         };
         // If a request is already in-flight, mark the message as queued and defer sending
-        if (sendingRef.current) {
+        if (!options?.messageId && (sendingRef.current || store.streaming || store.remoteStreaming)) {
             if (!suppressUserMessage) {
                 userMsg.queued = true;
                 setMessages((prev) => [...prev, userMsg]);
             }
-            pendingRef.current.push({
+            const queued = {
                 message,
                 attachments,
                 ...(automatic ? { automatic: true } : {}),
                 ...(options?.userInitiated ? { userInitiated: true } : {}),
                 ...(viaDictation ? { viaDictation: true } : {}),
-                ...(suppressUserMessage ? { suppressUserMessage } : { userMsgId: userMsg.id }),
-            });
+                userMsgId: userMsg.id,
+                ...(suppressUserMessage ? { suppressUserMessage } : {}),
+                ...(provider.queueMessage ? { durable: true } : {}),
+            };
+            pendingRef.current.push(queued);
             persistQueue(storageKey, pendingRef.current);
+            if (provider.queueMessage) {
+                const queueGeneration = store.generation;
+                try {
+                    await provider.queueMessage(message, {
+                        ...config,
+                        messageId: userMsg.id,
+                        suppressUserMessage,
+                        automatic,
+                        userInitiated: options?.userInitiated,
+                        viaDictation,
+                    }, (event) => {
+                        if (getMessageStore(storageKey).generation !== queueGeneration)
+                            return;
+                        if (event.type === 'message') {
+                            const latest = pendingRef.current.find((entry) => entry.userMsgId === event.message.id);
+                            // The initial acceptance can arrive after an acknowledged edit.
+                            const accepted = event.message.queued && latest?.accepted
+                                ? { ...event.message, content: latest.message }
+                                : event.message;
+                            appendCompleteMessage(accepted);
+                        }
+                        else if (event.type === 'card') {
+                            appendCardMessage(event.id, event.timestamp, event.card);
+                        }
+                        else if (event.type === 'error')
+                            setError(event.message);
+                    }, attachments, userMsg.id);
+                }
+                catch (error) {
+                    if (getMessageStore(storageKey).generation === queueGeneration)
+                        setError(error instanceof Error
+                            ? error.message
+                            : t('chat.error.sendFailed', undefined, {
+                                defaultValue: 'Failed to send message',
+                            }));
+                }
+            }
             return;
         }
         if (!suppressUserMessage)
-            setMessages((prev) => [...prev, userMsg]);
+            setMessages((prev) => prev.some((item) => item.id === userMsg.id) ? prev : [...prev, userMsg]);
         // A fresh user-initiated send clears any prior stop so the reconcile path
         // works normally for this turn.
         userAbortedRef.current = false;
@@ -1925,7 +2184,11 @@ export function useChat(options) {
             attachments,
             // Carry the optimistic bubble's id (queued entries already do) so a
             // never-started-turn auto-retry can replace it on re-send.
-            ...(suppressUserMessage ? { suppressUserMessage: true } : { userMsgId: userMsg.id }),
+            userMsgId: userMsg.id,
+            ...(suppressUserMessage ? { suppressUserMessage: true } : {}),
+            ...(pendingRef.current.find((entry) => entry.userMsgId === userMsg.id)?.durable
+                ? { durable: true }
+                : {}),
             ...(automatic ? { automatic: true } : {}),
             ...(options?.userInitiated ? { userInitiated: true } : {}),
             ...(viaDictation ? { viaDictation: true } : {}),
@@ -1935,6 +2198,7 @@ export function useChat(options) {
         // hands off to the resume flow (which polls history live until the server
         // finishes) instead of leaving the chat frozen mid-turn.
         let resumeAfterLoop = null;
+        const sendGeneration = store.generation;
         while (current) {
             if (!mountedRef.current)
                 break;
@@ -1943,7 +2207,7 @@ export function useChat(options) {
             // the actual send time: while queued it pinned to the transcript bottom (see
             // timelineSortKey), and its queue-time timestamp predates everything that
             // streamed in since — keeping it would jump the message back UP on send.
-            if (current.userMsgId) {
+            if (current.userMsgId && !current.durable) {
                 const uid = current.userMsgId;
                 setMessages((prev) => prev.map((m) => (m.id === uid ? { ...m, queued: false, timestamp: Date.now() } : m)));
             }
@@ -2000,6 +2264,7 @@ export function useChat(options) {
             // endpoint + projectId; spread the per-message flags on top.
             const sendConfig = {
                 ...config,
+                ...(current.userMsgId ? { messageId: current.userMsgId } : {}),
                 ...(current.suppressUserMessage ? { suppressUserMessage: true } : {}),
                 ...(current.automatic ? { automatic: true } : {}),
                 ...(current.userInitiated ? { userInitiated: true } : {}),
@@ -2075,8 +2340,17 @@ export function useChat(options) {
                     // Best-effort reconciliation — the finalized placeholder is already shown; dropping history here is safe
                 }
             }
-            // Drain the queue: send next pending message, clearing any prior error
-            current = pendingRef.current.shift();
+            if (getMessageStore(storageKey).generation !== sendGeneration)
+                return;
+            if (userAbortedRef.current || getMessageStore(storageKey).stoppedByUser)
+                break;
+            // A durable entry stays editable until delivery; failed sends keep it queued.
+            if (current.durable &&
+                pendingRef.current.some((entry) => entry.userMsgId === current.userMsgId))
+                break;
+            current = pendingRef.current[0];
+            if (current && !current.durable)
+                pendingRef.current.shift();
             if (current) {
                 setError(null);
                 setErrorMeta(null);
@@ -2089,7 +2363,7 @@ export function useChat(options) {
         // code path. Skip clearing so the streaming flag survives for resume.
         if (!unloadingRef.current) {
             clearStreamingFlag(storageKey);
-            persistQueue(storageKey, []);
+            persistQueue(storageKey, pendingRef.current);
         }
         // Dropped-stream tail: the server was still streaming this turn when the
         // connection died with no terminal event (see resumeAfterLoop above).
@@ -2130,11 +2404,12 @@ export function useChat(options) {
     // partial message — the server streams its continuation as new message(s)); kept in
     // the signature for the callers + ref type.
     async (resumeId, _existingContent) => {
-        if (!mountedRef.current || sendingRef.current)
+        if (!mountedRef.current || sendingRef.current || getMessageStore(storageKey).stoppedByUser)
             return;
         // A resume can only come from the LIVE instance — align with the store's
         // current generation so this turn's writes pass the stale-stream gate.
         generationRef.current = getMessageStore(storageKey).generation;
+        const resumeGeneration = generationRef.current;
         // Show the spinner on the last assistant message immediately
         setMessages((prev) => prev.map((m) => (m.id === resumeId ? { ...m, isStreaming: true } : m)));
         sendingRef.current = true;
@@ -2243,25 +2518,36 @@ export function useChat(options) {
                 // Best-effort — the page-lifecycle reconcile or a manual reload recovers.
             }
         }
-        // Drain any queued user messages
-        let current = pendingRef.current.shift();
-        while (current) {
-            if (!mountedRef.current)
-                break;
+        if (getMessageStore(storageKey).generation !== resumeGeneration)
+            return;
+        // The regular send path drains the remaining queue and retains durable IDs.
+        const current = pendingRef.current[0];
+        if (current &&
+            mountedRef.current &&
+            !userAbortedRef.current &&
+            !getMessageStore(storageKey).stoppedByUser) {
+            if (!current.durable)
+                pendingRef.current.shift();
             // A queued send takes over the conversation — don't also re-resume.
             resumeAgain = null;
             setError(null);
             setErrorMeta(null);
             persistQueue(storageKey, pendingRef.current);
             sendingRef.current = false;
-            await sendMessageRef.current(current.message, current.attachments);
-            current = pendingRef.current.shift();
+            setIsLoading(false);
+            await sendMessageRef.current(current.message, current.attachments, {
+                messageId: current.userMsgId,
+                suppressUserMessage: current.suppressUserMessage,
+                automatic: current.automatic,
+                userInitiated: current.userInitiated,
+                viaDictation: current.viaDictation,
+            });
         }
         sendingRef.current = false;
         setIsLoading(false);
         if (!unloadingRef.current) {
             clearStreamingFlag(storageKey);
-            persistQueue(storageKey, []);
+            persistQueue(storageKey, pendingRef.current);
         }
         // Dropped again while the server still streams — schedule another resume
         // after this one fully unwinds (each cycle requires a fresh real drop, so
@@ -2302,6 +2588,7 @@ export function useChat(options) {
         // (see the sendMessage guard), and end any remote-turn tracking — the server
         // stream is being killed below, so the Stop control can retire immediately.
         getMessageStore(storageKey).stoppedByUser = true;
+        getMessageStore(storageKey).userIntentRevision++;
         stopRemoteStreamPoll(storageKey);
         // Drop any remote accumulator outright — the blanket un-stream map below
         // already marks its message aborted.
@@ -2330,39 +2617,78 @@ export function useChat(options) {
         }
         pendingFlushFnRef.current?.();
         pendingFlushFnRef.current = null;
-        pendingRef.current.length = 0;
+        pendingRef.current = pendingRef.current.filter((entry) => entry.durable);
         sendingRef.current = false;
         clearStreamingFlag(storageKey);
-        persistQueue(storageKey, []);
+        persistQueue(storageKey, pendingRef.current);
         setIsLoading(false);
         setMessages((prev) => prev.map((m) => (m.isStreaming ? { ...m, isStreaming: false, aborted: true } : m)));
     }, [provider, endpoint, projectId, storageKey]);
     const clearHistory = useCallback(async () => {
+        const clearGeneration = getMessageStore(storageKey).generation;
         pendingRef.current.length = 0;
         // Drop any pending 5XX auto-retry — the conversation is being cleared.
         resetRetry();
         clearStreamingFlag(storageKey);
         persistQueue(storageKey, []);
         await provider.clearHistory(config);
-        if (mountedRef.current) {
+        if (mountedRef.current && getMessageStore(storageKey).generation === clearGeneration) {
             setMessages([]);
+            getMessageStore(storageKey).backgroundTasks = [];
+            getMessageStore(storageKey).deliveredQueueIds.clear();
+            emitStore(storageKey);
             setError(null);
             setErrorMeta(null);
         }
     }, [provider, endpoint]);
-    const editQueuedMessage = useCallback((msgId, newContent) => {
+    const editQueuedMessage = useCallback(async (msgId, newContent) => {
         const entry = pendingRef.current.find((e) => e.userMsgId === msgId);
+        const generation = getMessageStore(storageKey).generation;
+        if (entry?.durable) {
+            if (!provider.editQueuedMessage)
+                return;
+            try {
+                await provider.editQueuedMessage(msgId, newContent, config);
+            }
+            catch (error) {
+                setError(error instanceof Error
+                    ? error.message
+                    : t('chat.error.sendFailed', undefined, { defaultValue: 'Failed to send message' }));
+                return;
+            }
+            if (getMessageStore(storageKey).generation !== generation)
+                return;
+            if (!pendingRef.current.some((item) => item.userMsgId === msgId))
+                return;
+        }
         if (entry) {
             entry.message = newContent;
+            if (entry.durable)
+                entry.accepted = true;
             persistQueue(storageKey, pendingRef.current);
         }
         setMessages((prev) => prev.map((m) => (m.id === msgId && m.queued ? { ...m, content: newContent } : m)));
-    }, [storageKey]);
-    const deleteQueuedMessage = useCallback((msgId) => {
-        pendingRef.current = pendingRef.current.filter((e) => e.userMsgId !== msgId);
-        persistQueue(storageKey, pendingRef.current);
-        setMessages((prev) => prev.filter((m) => !(m.id === msgId && m.queued)));
-    }, [storageKey]);
+    }, [provider, endpoint, storageKey]);
+    const deleteQueuedMessage = useCallback(async (msgId) => {
+        const entry = pendingRef.current.find((item) => item.userMsgId === msgId);
+        const generation = getMessageStore(storageKey).generation;
+        if (entry?.durable) {
+            if (!provider.deleteQueuedMessage)
+                return;
+            try {
+                await provider.deleteQueuedMessage(msgId, config);
+            }
+            catch (error) {
+                setError(error instanceof Error
+                    ? error.message
+                    : t('chat.error.sendFailed', undefined, { defaultValue: 'Failed to send message' }));
+                return;
+            }
+            if (getMessageStore(storageKey).generation !== generation)
+                return;
+        }
+        removeQueuedMessage(storageKey, msgId);
+    }, [provider, endpoint, storageKey]);
     /**
      * Remove queued auto-fix messages whose content references the given file path.
      * Called automatically when the AI writes to a file (file_diff event) and can
@@ -2373,11 +2699,10 @@ export function useChat(options) {
         const toRemove = pendingRef.current.filter((e) => e.message.startsWith(AUTOFIX_PREFIX) && e.message.includes(norm));
         if (toRemove.length === 0)
             return;
-        const removeIds = new Set(toRemove.map((e) => e.userMsgId));
-        pendingRef.current = pendingRef.current.filter((e) => !removeIds.has(e.userMsgId));
-        persistQueue(storageKey, pendingRef.current);
-        setMessages((prev) => prev.filter((m) => !(m.queued && removeIds.has(m.id))));
-    }, [storageKey]);
+        for (const entry of toRemove)
+            if (entry.userMsgId)
+                void deleteQueuedMessage(entry.userMsgId);
+    }, [deleteQueuedMessage]);
     // Sync clearQueuedForFile ref so stream event handlers can call the latest version
     clearQueuedForFileRef.current = clearQueuedForFile;
     const exposedSetMode = useCallback((newMode) => {