@parhelia/core 0.1.12777 → 0.1.12780

package/dist/editor/ai/AgentTerminal.js

@@ -40,7 +40,9 @@ import { cn } from "../../lib/utils";
 import { sanitizeSvg } from "../../lib/sanitize";
 import { Select } from "../../components/ui/select";
 import { AgentTerminalStatusBar } from "./AgentTerminalStatusBar";
-import { isStreamStalled, shouldReloadAfterDiagnostics, } from "./agentDiagnostics";
+import { isStreamStalled, shouldReloadAfterDiagnostics, STREAM_STALLED_AFTER_MS, } from "./agentDiagnostics";
+import { emitAgentRecoveryEvent } from "./agentRecoveryEventBus";
+import { updateAgentWatchdogStatus } from "./agentWatchdogStatusRegistry";
 import { forceEditorSocketReconnect } from "../client/hooks/useEditorWebSocket";
 import { SimpleTabs } from "../ui/SimpleTabs";
 import { Splitter } from "../ui/Splitter";
@@ -384,11 +386,13 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             pendingDialogReplayTimeoutsRef.current.clear();
         };
     }, []);
-    // Collect all pending tool calls for batch approval functionality
+    // Collect all pending tool calls for batch approval functionality.
+    // Returns a stable reference when the content is equivalent so consumers
+    // (memoized children) don't re-render on every streaming token.
+    const allPendingApprovalsRef = useRef([]);
     const allPendingApprovals = useMemo(() => {
         const pending = [];
         const seenToolCallIds = new Set();
-        // Iterate messages in reverse to get the latest version of each tool call
         for (let i = messages.length - 1; i >= 0; i--) {
             const msg = messages[i];
             if (!msg)
@@ -416,9 +420,26 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                 }
             }
         }
-        // Reverse back to maintain some chronological order if needed,
-        // though for batch approval it doesn't matter much.
-        return pending.reverse();
+        pending.reverse();
+        const prev = allPendingApprovalsRef.current;
+        if (prev.length === pending.length) {
+            let same = true;
+            for (let i = 0; i < pending.length; i++) {
+                const a = prev[i];
+                const b = pending[i];
+                if (a?.toolCallId !== b?.toolCallId ||
+                    a?.messageId !== b?.messageId ||
+                    a?.dbMessageId !== b?.dbMessageId ||
+                    a?.riskLevel !== b?.riskLevel) {
+                    same = false;
+                    break;
+                }
+            }
+            if (same)
+                return prev;
+        }
+        allPendingApprovalsRef.current = pending;
+        return pending;
     }, [messages]);
     const hasPendingApprovals = useCallback(() => {
         return allPendingApprovals.length > 0;
@@ -1247,6 +1268,23 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
     // WebSocket subscription state for agent streaming
     const seenMessageIdsRef = useRef(new Set());
     const lastSeqRef = useRef(0);
+    // Run id (Guid string, lowercased) of the run we're currently displaying.
+    // Set on accepted agent:run:start, used to drop stale delta/status from a
+    // previous run that arrives after a new one has begun.
+    const currentRunIdRef = useRef(null);
+    // Run id of the most recently settled run. Used so a replayed
+    // agent:run:complete / agent:run:start for an already-finished run is
+    // dropped without clobbering live state.
+    const lastSettledRunIdRef = useRef(null);
+    // True once we've warned that the server is emitting lifecycle/delta/status
+    // payloads without a runId (un-upgraded server during rollout). One-shot
+    // to keep the console quiet.
+    const warnedMissingRunIdRef = useRef(false);
+    // Per-message ids the server has resynced via agent:run:resync. Subsequent
+    // legacy agent:run:delta with seq=0 (the replay-marker seq used by older
+    // replay paths) for the same messageId is dropped, so we don't double-
+    // append content the resync envelope already wrote in full.
+    const lastResyncedMessageIdsRef = useRef(new Set());
     const subscribedAgentIdRef = useRef(null);
     const reconcileServerStateInFlightRef = useRef(false);
     // Stream-stall watchdog timestamps. `lastNonHeartbeatUpdateAtRef` is set every time
@@ -1618,7 +1656,46 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             return updated;
         });
     }, [stripHeartbeatMessages]);
-    const settleCompletedRun = useCallback((finalStatus = "completed") => {
+    // Normalize a server-issued runId (Guid in any case / format) into a
+    // stable lowercase string for comparison. Returns null when the value is
+    // missing or a zero-Guid (an old server that does not populate RunId).
+    const normalizeRunId = useCallback((value) => {
+        if (typeof value !== "string")
+            return null;
+        const trimmed = value.trim().toLowerCase();
+        if (!trimmed)
+            return null;
+        // Accept the canonical 8-4-4-4-12 hex form. Zero-Guid is treated as
+        // "no runId" because that's how older code paths surface "unknown".
+        if (trimmed === "00000000-0000-0000-0000-000000000000")
+            return null;
+        return trimmed;
+    }, []);
+    const noteMissingRunId = useCallback((source) => {
+        if (warnedMissingRunIdRef.current)
+            return;
+        warnedMissingRunIdRef.current = true;
+        console.warn("[AgentTerminal] received lifecycle/delta payload without runId; " +
+            "falling back to legacy run scoping. Server may need upgrade. source=" +
+            source);
+    }, []);
+    const settleCompletedRun = useCallback((finalStatus = "completed", runId) => {
+        // Run-scoped idempotency. If we've already settled this run, drop the
+        // duplicate (e.g. lifecycle replay or the legacy status === "completed"
+        // fallback firing after agent:run:complete already ran).
+        const normalized = normalizeRunId(runId);
+        if (normalized !== null) {
+            if (lastSettledRunIdRef.current === normalized) {
+                return;
+            }
+            // Settle for a stale run (the live run already advanced past this
+            // one) — drop it instead of clobbering current run state.
+            if (currentRunIdRef.current !== null &&
+                currentRunIdRef.current !== normalized) {
+                return;
+            }
+            lastSettledRunIdRef.current = normalized;
+        }
         clearStopGuard();
         setError(null);
         // Keep lastSeqRef populated so the diagnostic popover can show the
@@ -1650,41 +1727,35 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         setIsSubmitting(false);
         shouldCreateNewMessage.current = false;
         setIsAgentThinking(false);
-    }, [clearHeartbeatMessages]);
+    }, [clearHeartbeatMessages, normalizeRunId]);
+    // With backend invariant "every envelope carries the final assistant messageId"
+    // (see AgentOrchestrator), the resolver collapses to a plain find-by-id with
+    // optional create-if-missing. No more synthetic/DB reconciliation.
+    const resolveAssistantMessage = useCallback((prev, dbMessageId, options) => {
+        const dbIndex = prev.findIndex((m) => m.id === dbMessageId);
+        if (dbIndex !== -1) {
+            return { messages: prev, targetIndex: dbIndex };
+        }
+        if (options.createIfMissing) {
+            const created = createNewStreamMessage(dbMessageId, options.agentData);
+            const messages = [...prev, created];
+            return { messages, targetIndex: messages.length - 1 };
+        }
+        return { messages: prev, targetIndex: -1 };
+    }, [createNewStreamMessage]);
     const handleContentChunk = useCallback((message, agentData) => {
-        // Get messageId from data, or generate one from agent ID (for backward compatibility)
-        // If no messageId is provided, we'll use the last assistant message or create a new one
-        let messageId = message.data?.messageId;
-        if (!messageId && agentData?.id) {
-            console.warn("[AgentTerminal] Content chunk missing messageId; falling back to local resolution", {
-                agentId: agentData.id,
+        const messageId = message.data?.messageId;
+        // Backend invariant: every assistant content chunk carries a final messageId.
+        // If we ever see one without, drop it loudly — synthesizing a client-side id would
+        // corrupt the conversation (the resync buffer is also keyed by messageId, so the
+        // delta cannot be recovered either way; better to surface the bug than paper over it).
+        if (!messageId) {
+            console.error("[AgentTerminal] Backend invariant violation: content chunk arrived without messageId. Dropping.", {
+                agentId: agentData?.id,
                 isIncremental: message.data?.isIncremental,
                 previousContentLength: message.data?.previousContentLength,
                 totalContentLength: message.data?.totalContentLength,
             });
-            // For backward compatibility: if no messageId, find or create the current streaming message
-            // This handles cases where the backend doesn't send messageId
-            const currentMessages = messagesRef.current;
-            const lastStreamingMessage = [...currentMessages]
-                .reverse()
-                .find((m) => m.role === "assistant" && !m.isCompleted);
-            if (lastStreamingMessage) {
-                messageId = lastStreamingMessage.id;
-            }
-            else {
-                // If the agent isn't currently running (e.g., we switched tabs after the run
-                // completed), skip creating a new streaming message to avoid duplicates.
-                const currentAgentStatus = (agentData || agent)?.status;
-                const isAgentRunning = currentAgentStatus === "running";
-                if (!isAgentRunning) {
-                    return;
-                }
-                // Create a new message ID based on timestamp when the agent is still running
-                messageId = crypto.randomUUID();
-            }
-        }
-        if (!messageId) {
-            console.error("Unable to determine messageId for content chunk!");
             return;
         }
         // Clear waiting state when first content chunk arrives
@@ -1767,7 +1838,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         }
         // Always call setMessages and handle all logic in the callback with latest messages
         setMessages((prev) => {
-            // Find existing message by messageId in the latest messages
             const existingMessageIndex = prev.findIndex((msg) => msg.id === messageId);
             if (existingMessageIndex === -1) {
                 // Message doesn't exist - create new streaming message
@@ -1781,267 +1851,188 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                     });
                 }
                 const newStreamMessage = createNewStreamMessage(messageId, agentData);
-                // Set the content for the new message
-                const updatedNewMessage = { ...newStreamMessage };
-                if (!message.data.isIncremental) {
-                    updatedNewMessage.content = message.data?.deltaContent || "";
-                    updatedNewMessage.reasoning = message.data?.reasoning || "";
-                }
-                else {
-                    updatedNewMessage.content = message.data?.deltaContent || "";
-                    updatedNewMessage.reasoning = message.data?.reasoning || "";
-                }
+                const updatedNewMessage = {
+                    ...newStreamMessage,
+                    content: message.data?.deltaContent || "",
+                    reasoning: message.data?.reasoning || "",
+                };
                 const updated = [...prev, updatedNewMessage];
                 messagesRef.current = updated;
                 return updated;
             }
-            else {
-                // Message exists - update it
-                const existingMessage = prev[existingMessageIndex];
-                if (!existingMessage)
-                    return prev;
-                // Check if existing content is already longer than what we're trying to stream
-                const currentContentLength = existingMessage.content?.length || 0;
-                const previousContentLength = message.data?.previousContentLength || 0;
-                const totalContentLength = message.data?.totalContentLength || 0;
-                if (message.data?.isIncremental &&
-                    previousContentLength !== currentContentLength &&
-                    (previousContentLength > 0 || currentContentLength > 0)) {
-                    console.warn("[AgentTerminal] Content chunk length mismatch", {
-                        messageId,
-                        previousContentLength,
-                        currentContentLength,
-                        totalContentLength,
-                        deltaLength: (message.data?.deltaContent || "").length,
-                    });
-                }
-                if (message.data?.isIncremental &&
-                    currentContentLength >= totalContentLength &&
-                    totalContentLength > 0) {
-                    return prev;
-                }
-                const updatedMessage = { ...existingMessage };
-                if (!message.data.isIncremental) {
-                    updatedMessage.content = message.data?.deltaContent || "";
-                    updatedMessage.reasoning = message.data?.reasoning || "";
-                }
-                else {
-                    updatedMessage.content =
-                        existingMessage.content + (message.data?.deltaContent || "");
-                    // Reasoning is sent as full content from backend, not as a delta,
-                    // so we replace instead of append to avoid duplication
-                    updatedMessage.reasoning =
-                        message.data?.reasoning || existingMessage.reasoning || "";
-                }
-                const updated = prev.map((msg, index) => index === existingMessageIndex ? updatedMessage : msg);
-                messagesRef.current = updated;
-                return updated;
+            const existingMessage = prev[existingMessageIndex];
+            if (!existingMessage)
+                return prev;
+            const currentContentLength = existingMessage.content?.length || 0;
+            const previousContentLength = message.data?.previousContentLength || 0;
+            const totalContentLength = message.data?.totalContentLength || 0;
+            if (message.data?.isIncremental &&
+                previousContentLength !== currentContentLength &&
+                (previousContentLength > 0 || currentContentLength > 0)) {
+                console.warn("[AgentTerminal] Content chunk length mismatch", {
+                    messageId,
+                    previousContentLength,
+                    currentContentLength,
+                    totalContentLength,
+                    deltaLength: (message.data?.deltaContent || "").length,
+                });
             }
+            if (message.data?.isIncremental &&
+                currentContentLength >= totalContentLength &&
+                totalContentLength > 0) {
+                return prev;
+            }
+            const updatedMessage = { ...existingMessage };
+            if (!message.data.isIncremental) {
+                updatedMessage.content = message.data?.deltaContent || "";
+                updatedMessage.reasoning = message.data?.reasoning || "";
+            }
+            else {
+                updatedMessage.content =
+                    existingMessage.content + (message.data?.deltaContent || "");
+                // Reasoning is sent as full content from backend, not as a delta,
+                // so we replace instead of append to avoid duplication
+                updatedMessage.reasoning =
+                    message.data?.reasoning || existingMessage.reasoning || "";
+            }
+            const updated = prev.map((msg, index) => index === existingMessageIndex ? updatedMessage : msg);
+            messagesRef.current = updated;
+            return updated;
         });
-    }, [createNewStreamMessage, agent]);
+    }, [createNewStreamMessage]);
     const handleToolCall = useCallback((message, agentData) => {
         const extractedToolCall = extractToolCallFields(message.data);
         const toolCallId = extractedToolCall.toolCallId || crypto.randomUUID();
-        // Prefer provided messageId, otherwise fall back to the last streaming assistant message
-        let toolCallMessageId = message.data?.messageId;
-        if (!toolCallMessageId) {
-            console.warn("[AgentTerminal] Tool call missing messageId; falling back", {
+        const toolCallMessageId = message.data?.messageId;
+        // Backend invariant: every tool-call envelope carries the final assistant messageId.
+        // Drop loudly rather than minting a client-side id (which collapses turns into one bubble).
+        if (!toolCallMessageId || !message.data) {
+            console.error("[AgentTerminal] Backend invariant violation: tool call arrived without messageId. Dropping.", {
+                agentId: agentData?.id,
                 toolCallId,
                 toolName: message.data?.name || message.data?.displayName,
             });
-            const current = messagesRef.current;
-            const lastStreaming = [...current]
-                .reverse()
-                .find((m) => m.role === "assistant" && !m.isCompleted);
-            if (lastStreaming?.id) {
-                toolCallMessageId = lastStreaming.id;
-            }
-            else {
-                // Tool calls can arrive before any assistant content chunk (common for dialog tools like ask-questionnaire).
-                // Create a synthetic streaming message so the UI can render the tool call immediately.
-                toolCallMessageId = crypto.randomUUID();
-            }
+            return;
         }
-        appendToolUiEvent("ui:tool-call-targeted", `${extractedToolCall.functionName || "unknown"} toolCallId=${toolCallId} targetMessageId=${toolCallMessageId || "none"} providedMessageId=${String(message.data?.messageId || "none")}`);
-        // Find or create the target message for this tool call
-        if (toolCallMessageId) {
-            const currentMessages = messagesRef.current;
-            const existingMessageIndex = currentMessages.findIndex((msg) => msg.id === toolCallMessageId);
-            if (existingMessageIndex === -1) {
-                // Double-check with current ref to prevent race conditions
-                const currentMessages = messagesRef.current;
-                const existsInRef = currentMessages.find((msg) => msg.id === toolCallMessageId);
-                if (!existsInRef) {
-                    // Create new message for this tool call
-                    const newStreamMessage = createNewStreamMessage(toolCallMessageId, agentData);
-                    setMessages((prev) => {
-                        // Final check before adding to prevent duplicates
-                        const finalCheck = prev.find((msg) => msg.id === toolCallMessageId);
-                        if (finalCheck) {
-                            return prev;
-                        }
-                        const updated = [...prev, newStreamMessage];
-                        messagesRef.current = updated;
-                        return updated;
-                    });
+        appendToolUiEvent("ui:tool-call-targeted", `${extractedToolCall.functionName || "unknown"} toolCallId=${toolCallId} targetMessageId=${toolCallMessageId} providedMessageId=${String(message.data?.messageId || "none")}`);
+        // Build the tool-call record once, outside the reducer.
+        const toolCallError = message.data.functionError || message.data.error || "";
+        const isPruned = !!message.data?.isPruned || /^PRUNED$/i.test(String(toolCallError));
+        const toolCallCreatedDate = message.data.createdDate ||
+            message.timestamp ||
+            new Date().toISOString();
+        const toolCallState = String(message.data?.state || "").toLowerCase();
+        const isExplicitApprovalRequired = toolCallState === "toolapprovalsrequired" ||
+            toolCallState === "waitingforapproval";
+        const requiresApproval = isExplicitApprovalRequired
+            ? message.data?.requiresApproval
+            : undefined;
+        const incomingToolCall = {
+            id: toolCallId,
+            messageId: toolCallMessageId,
+            dbMessageId: message.data.messageId, // Database message ID for approval/rejection
+            toolCallId: toolCallId,
+            functionName: extractedToolCall.functionName,
+            functionArguments: extractedToolCall.functionArguments,
+            functionResult: message.data.functionResult || message.data.result || "",
+            functionResultRichContent: message.data.richContent || undefined,
+            functionError: toolCallError,
+            isPruned,
+            isCompleted: false,
+            responseTimeMs: message.data.responseTimeMs,
+            createdDate: toolCallCreatedDate,
+            requiresApproval,
+        };
+        // Single reducer: resolver finds-or-creates the row by messageId, then we
+        // upsert the tool call onto the resolved row by toolCallId.
+        flushSync(() => {
+            setMessages((prev) => {
+                const resolution = resolveAssistantMessage(prev, toolCallMessageId, {
+                    createIfMissing: true,
+                    agentData,
+                });
+                if (resolution.targetIndex < 0) {
+                    return prev;
                 }
-            }
-        }
-        // Add tool call to the message in the array
-        if (toolCallMessageId && message.data && toolCallId) {
-            const toolCallError = message.data.functionError || message.data.error || "";
-            const isPruned = !!message.data?.isPruned || /^PRUNED$/i.test(String(toolCallError));
-            const toolCallCreatedDate = message.data.createdDate ||
-                message.timestamp ||
-                new Date().toISOString();
-            const toolCallState = String(message.data?.state || "").toLowerCase();
-            const isExplicitApprovalRequired = toolCallState === "toolapprovalsrequired" ||
-                toolCallState === "waitingforapproval";
-            const requiresApproval = isExplicitApprovalRequired
-                ? message.data?.requiresApproval
-                : undefined;
-            const toolCall = {
-                id: toolCallId,
-                messageId: toolCallMessageId,
-                dbMessageId: message.data.messageId, // Database message ID for approval/rejection
-                toolCallId: toolCallId,
-                functionName: extractedToolCall.functionName,
-                functionArguments: extractedToolCall.functionArguments,
-                functionResult: message.data.functionResult || message.data.result || "",
-                functionResultRichContent: message.data.richContent || undefined,
-                functionError: toolCallError,
-                isPruned,
-                isCompleted: false,
-                responseTimeMs: message.data.responseTimeMs,
-                createdDate: toolCallCreatedDate,
-                requiresApproval,
-            };
-            // Check for existing tool call - search across ALL messages by toolCallId first
-            // This handles the case where the first message had messageId: null (used fallback UI ID)
-            // and the second message has the actual DB messageId
-            const currentMessages = messagesRef.current;
-            let targetMessage = currentMessages.find((msg) => msg.id === toolCallMessageId);
-            let existingToolCallIndex = -1;
-            let existingToolCalls = [];
-            // First, try to find by toolCallMessageId
-            if (targetMessage) {
-                existingToolCalls = targetMessage.toolCalls || [];
-                existingToolCallIndex = existingToolCalls.findIndex((tc) => tc.toolCallId === toolCallId);
-            }
-            // If not found, search across ALL messages for this toolCallId
-            // This handles the messageId mismatch between first (null) and second (DB ID) messages
-            if (existingToolCallIndex === -1) {
-                for (const msg of currentMessages) {
-                    const tcIndex = (msg.toolCalls || []).findIndex((tc) => tc.toolCallId === toolCallId);
-                    if (tcIndex !== -1) {
-                        targetMessage = msg;
-                        existingToolCalls = msg.toolCalls || [];
-                        existingToolCallIndex = tcIndex;
-                        break;
-                    }
+                const working = resolution.messages;
+                const targetMsg = working[resolution.targetIndex];
+                if (!targetMsg) {
+                    return prev;
                 }
-            }
-            if (existingToolCallIndex !== -1 && targetMessage) {
-                // Tool call already exists - update it with any new/more complete data
-                const existingToolCall = existingToolCalls[existingToolCallIndex];
-                if (!existingToolCall) {
-                    return; // Safety check - shouldn't happen
+                const existingToolCalls = targetMsg.toolCalls || [];
+                const idx = existingToolCalls.findIndex((tc) => tc.toolCallId === toolCallId);
+                let nextToolCalls;
+                if (idx === -1) {
+                    nextToolCalls = [...existingToolCalls, incomingToolCall];
                 }
-                // Use the actual message ID where the tool call was found (may differ from toolCallMessageId)
-                const actualMessageId = targetMessage.id;
-                // Check if the new data has more information than what we have
-                const newArgs = toolCall.functionArguments;
-                const existingArgs = existingToolCall.functionArguments;
-                const newArgsText = stringifyToolField(newArgs) || "";
-                const existingArgsText = stringifyToolField(existingArgs) || "";
-                const hasMoreCompleteArgs = (newArgsText.length > existingArgsText.length &&
-                    newArgsText !== existingArgsText) ||
-                    (existingArgsText === "{}" && newArgsText !== "{}");
-                const hasNewResult = toolCall.functionResult && !existingToolCall.functionResult;
-                const hasNewRichContent = toolCall.functionResultRichContent &&
-                    !existingToolCall.functionResultRichContent;
-                const hasNewError = toolCall.functionError && !existingToolCall.functionError;
-                const hasNewApprovalInfo = toolCall.requiresApproval && !existingToolCall.requiresApproval;
-                const hasNewDbMessageId = toolCall.dbMessageId && !existingToolCall.dbMessageId;
-                // Only update if there's meaningful new data
-                if (hasMoreCompleteArgs ||
-                    hasNewResult ||
-                    hasNewRichContent ||
-                    hasNewError ||
-                    hasNewApprovalInfo ||
-                    hasNewDbMessageId) {
-                    setMessages((prev) => {
-                        const updated = prev.map((msg) => {
-                            if (msg.id !== actualMessageId)
-                                return msg;
-                            const updatedToolCalls = [...(msg.toolCalls || [])];
-                            const idx = updatedToolCalls.findIndex((tc) => tc.toolCallId === toolCallId);
-                            if (idx !== -1 && updatedToolCalls[idx]) {
-                                const existing = updatedToolCalls[idx];
-                                // Merge: prefer new non-empty values, keep existing values as fallback
-                                // Use type assertion for dbMessageId which is added dynamically
-                                updatedToolCalls[idx] = {
-                                    ...existing,
-                                    functionArguments: hasMoreCompleteArgs
-                                        ? newArgsText
-                                        : existingArgsText || existing.functionArguments,
-                                    functionResult: toolCall.functionResult || existing.functionResult,
-                                    functionResultRichContent: toolCall.functionResultRichContent ||
-                                        existing.functionResultRichContent,
-                                    functionError: toolCall.functionError || existing.functionError,
-                                    requiresApproval: toolCall.requiresApproval || existing.requiresApproval,
-                                };
-                                // Copy dbMessageId if present (dynamically added field)
-                                if (toolCall.dbMessageId || existing.dbMessageId) {
-                                    updatedToolCalls[idx].dbMessageId =
-                                        toolCall.dbMessageId || existing.dbMessageId;
-                                }
-                            }
-                            return { ...msg, toolCalls: updatedToolCalls };
-                        });
-                        messagesRef.current = updated;
-                        return updated;
-                    });
+                else {
+                    const existing = existingToolCalls[idx];
+                    if (!existing) {
+                        return prev;
+                    }
+                    const newArgsText = stringifyToolField(incomingToolCall.functionArguments) || "";
+                    const existingArgsText = stringifyToolField(existing.functionArguments) || "";
+                    const hasMoreCompleteArgs = (newArgsText.length > existingArgsText.length &&
+                        newArgsText !== existingArgsText) ||
+                        (existingArgsText === "{}" && newArgsText !== "{}");
+                    const hasNewResult = incomingToolCall.functionResult && !existing.functionResult;
+                    const hasNewRichContent = incomingToolCall.functionResultRichContent &&
+                        !existing.functionResultRichContent;
+                    const hasNewError = incomingToolCall.functionError && !existing.functionError;
+                    const hasNewApprovalInfo = incomingToolCall.requiresApproval && !existing.requiresApproval;
+                    const hasNewDbMessageId = incomingToolCall.dbMessageId && !existing.dbMessageId;
+                    // No new info — bail without re-rendering the tool calls array.
+                    if (!hasMoreCompleteArgs &&
+                        !hasNewResult &&
+                        !hasNewRichContent &&
+                        !hasNewError &&
+                        !hasNewApprovalInfo &&
+                        !hasNewDbMessageId) {
+                        return prev;
+                    }
+                    const merged = {
+                        ...existing,
+                        functionArguments: hasMoreCompleteArgs
+                            ? newArgsText
+                            : existingArgsText || existing.functionArguments,
+                        functionResult: incomingToolCall.functionResult || existing.functionResult,
+                        functionResultRichContent: incomingToolCall.functionResultRichContent ||
+                            existing.functionResultRichContent,
+                        functionError: incomingToolCall.functionError || existing.functionError,
+                        requiresApproval: incomingToolCall.requiresApproval || existing.requiresApproval,
+                    };
+                    if (incomingToolCall.dbMessageId ||
+                        existing.dbMessageId) {
+                        merged.dbMessageId =
+                            incomingToolCall.dbMessageId || existing.dbMessageId;
+                    }
+                    nextToolCalls = [...existingToolCalls];
+                    nextToolCalls[idx] = merged;
                 }
-                return; // Done updating existing tool call
-            }
-            flushSync(() => {
-                setMessages((prev) => {
-                    const updated = prev.map((msg) => {
-                        if (msg.id !== toolCallMessageId)
-                            return msg;
-                        const existingToolCalls = msg.toolCalls || [];
-                        return { ...msg, toolCalls: [...existingToolCalls, toolCall] };
-                    });
-                    messagesRef.current = updated;
-                    return updated;
-                });
+                const updated = working.map((m, i) => i === resolution.targetIndex ? { ...m, toolCalls: nextToolCalls } : m);
+                messagesRef.current = updated;
+                return updated;
             });
-            const messageWithToolCall = messagesRef.current.find((msg) => msg.id === toolCallMessageId);
-            appendToolUiEvent("ui:tool-call-attached", `${extractedToolCall.functionName || "unknown"} toolCallId=${toolCallId} targetMessageId=${toolCallMessageId} messageToolCalls=${messageWithToolCall?.toolCalls?.length || 0} assistantMessages=${messagesRef.current.filter((msg) => msg.role === "assistant").length}`);
-            // If tool requires approval, agent is now waiting for user action - stop thinking
-            if (requiresApproval) {
-                setIsAgentThinking(false);
-            }
+        });
+        const messageWithToolCall = messagesRef.current.find((msg) => msg.id === toolCallMessageId);
+        appendToolUiEvent("ui:tool-call-attached", `${extractedToolCall.functionName || "unknown"} toolCallId=${toolCallId} targetMessageId=${toolCallMessageId} messageToolCalls=${messageWithToolCall?.toolCalls?.length || 0} assistantMessages=${messagesRef.current.filter((msg) => msg.role === "assistant").length}`);
+        // If tool requires approval, agent is now waiting for user action - stop thinking
+        if (requiresApproval) {
+            setIsAgentThinking(false);
         }
-    }, [appendToolUiEvent, createNewStreamMessage]);
+    }, [appendToolUiEvent, resolveAssistantMessage]);
     const handleToolResult = useCallback((message, agentData) => {
         const extractedToolCall = extractToolCallFields(message.data);
         const resultToolCallId = extractedToolCall.toolCallId || crypto.randomUUID();
-        // Prefer provided messageId, otherwise fall back to the last streaming assistant message
-        let resultMessageId = message.data?.messageId;
+        const resultMessageId = message.data?.messageId;
+        // Backend invariant: every tool-result envelope carries the final assistant messageId.
         if (!resultMessageId) {
-            console.warn("[AgentTerminal] Tool result missing messageId; falling back", {
+            console.error("[AgentTerminal] Backend invariant violation: tool result arrived without messageId. Dropping.", {
+                agentId: agentData?.id,
                 toolCallId: resultToolCallId,
                 toolName: message.data?.functionName || message.data?.displayName,
             });
-            const current = messagesRef.current;
-            const lastStreaming = [...current]
-                .reverse()
-                .find((m) => m.role === "assistant" && !m.isCompleted);
-            if (lastStreaming?.id) {
-                resultMessageId = lastStreaming.id;
-            }
+            return;
         }
         // Extract cost/token data from tool result if present
         const cost = message.cost;
@@ -2137,63 +2128,69 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                 }
             }
         }
-        // Update tool result directly in the messages array
-        if (!resultMessageId) {
-            appendToolUiEvent("ui:tool-result-dropped", `${extractedToolCall.functionName || "unknown"} toolCallId=${resultToolCallId} reason=no-result-message-id`);
-            return;
-        }
         appendToolUiEvent("ui:tool-result-targeted", `${extractedToolCall.functionName || "unknown"} toolCallId=${resultToolCallId} targetMessageId=${resultMessageId}`);
-        // Update the message with tool result
+        // Single reducer: resolver merges any synthetic row carrying this
+        // toolCallId into the DB row first, then we apply the result update
+        // by toolCallId on the resolved row.
         setMessages((prev) => {
-            const updated = prev.map((msg) => {
-                if (msg.id !== resultMessageId)
-                    return msg;
-                const updatedMessage = { ...msg };
-                if (!updatedMessage.toolCalls) {
-                    updatedMessage.toolCalls = [];
-                }
-                // Find and update the tool call with the result
-                const toolCallIndex = updatedMessage.toolCalls.findIndex((tc) => tc.toolCallId === resultToolCallId);
-                if (toolCallIndex >= 0) {
-                    const existingToolCall = updatedMessage.toolCalls[toolCallIndex];
-                    if (existingToolCall && message.data) {
-                        const updatedToolCalls = [...updatedMessage.toolCalls];
-                        const nextArgsText = stringifyToolField(extractedToolCall.functionArguments) || "";
-                        const existingArgsText = stringifyToolField(existingToolCall.functionArguments) || "";
-                        const hasMoreCompleteArgs = (nextArgsText.length > existingArgsText.length &&
-                            nextArgsText !== existingArgsText) ||
-                            (existingArgsText === "{}" && nextArgsText !== "{}");
-                        const toolCall = {
-                            id: existingToolCall.id,
-                            messageId: existingToolCall.messageId,
-                            toolCallId: existingToolCall.toolCallId,
-                            functionName: existingToolCall.functionName,
-                            functionArguments: hasMoreCompleteArgs
-                                ? nextArgsText
-                                : existingToolCall.functionArguments,
-                            functionResult: message.data.functionResult || message.data.result || "",
-                            functionResultRichContent: message.data.richContent ||
-                                existingToolCall.functionResultRichContent,
-                            functionError: message.data.functionError || message.data.error || "",
-                            isCompleted: true,
-                            responseTimeMs: message.data.responseTimeMs,
-                            createdDate: existingToolCall.createdDate,
-                        };
-                        updatedToolCalls[toolCallIndex] = toolCall;
-                        updatedMessage.toolCalls = updatedToolCalls;
-                    }
-                    // Check if all tool calls in message are completed
-                    const allToolCallsCompleted = updatedMessage.toolCalls.every((tc) => tc.isCompleted);
-                    if (allToolCallsCompleted) {
-                        shouldCreateNewMessage.current = true;
-                    }
+            const resolution = resolveAssistantMessage(prev, resultMessageId, {
+                createIfMissing: false,
+                agentData,
+            });
+            if (resolution.targetIndex < 0) {
+                // No row for this DB id — nothing to attach the result to. Drop with
+                // a diagnostic. Should not happen given backend invariants.
+                appendToolUiEvent("ui:tool-result-dropped", `${extractedToolCall.functionName || "unknown"} toolCallId=${resultToolCallId} reason=no-target-row`);
+                return prev;
+            }
+            const working = resolution.messages;
+            const targetMsg = working[resolution.targetIndex];
+            if (!targetMsg) {
+                return prev;
+            }
+            const existingToolCalls = targetMsg.toolCalls || [];
+            const toolCallIndex = existingToolCalls.findIndex((tc) => tc.toolCallId === resultToolCallId);
+            let nextToolCalls;
+            if (toolCallIndex >= 0) {
+                const existingToolCall = existingToolCalls[toolCallIndex];
+                if (!existingToolCall || !message.data) {
+                    return working;
                 }
-                else if (message.data && resultToolCallId && resultMessageId) {
-                    // Create new tool call if it doesn't exist
-                    const toolCallCreatedDate = message.data.createdDate ||
-                        message.timestamp ||
-                        new Date().toISOString();
-                    const toolCall = {
+                const nextArgsText = stringifyToolField(extractedToolCall.functionArguments) || "";
+                const existingArgsText = stringifyToolField(existingToolCall.functionArguments) || "";
+                const hasMoreCompleteArgs = (nextArgsText.length > existingArgsText.length &&
+                    nextArgsText !== existingArgsText) ||
+                    (existingArgsText === "{}" && nextArgsText !== "{}");
+                const updatedToolCall = {
+                    id: existingToolCall.id,
+                    messageId: existingToolCall.messageId,
+                    toolCallId: existingToolCall.toolCallId,
+                    functionName: existingToolCall.functionName,
+                    functionArguments: hasMoreCompleteArgs
+                        ? nextArgsText
+                        : existingToolCall.functionArguments,
+                    functionResult: message.data.functionResult || message.data.result || "",
+                    functionResultRichContent: message.data.richContent ||
+                        existingToolCall.functionResultRichContent,
+                    functionError: message.data.functionError || message.data.error || "",
+                    isCompleted: true,
+                    responseTimeMs: message.data.responseTimeMs,
+                    createdDate: existingToolCall.createdDate,
+                };
+                nextToolCalls = [...existingToolCalls];
+                nextToolCalls[toolCallIndex] = updatedToolCall;
+            }
+            else if (message.data && resultToolCallId) {
+                // Tool call wasn't found on the resolved row — append it as a
+                // completed call. This path is rare (would imply we got a result
+                // without ever seeing the call), but the original code preserved
+                // it as a defense.
+                const toolCallCreatedDate = message.data.createdDate ||
+                    message.timestamp ||
+                    new Date().toISOString();
+                nextToolCalls = [
+                    ...existingToolCalls,
+                    {
                         id: resultToolCallId,
                         messageId: resultMessageId,
                         toolCallId: resultToolCallId,
@@ -2205,22 +2202,27 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                         isCompleted: true,
                         responseTimeMs: message.data.responseTimeMs,
                         createdDate: toolCallCreatedDate,
-                    };
-                    updatedMessage.toolCalls = [...updatedMessage.toolCalls, toolCall];
-                }
-                // Updated tool calls count
-                return updatedMessage;
-            });
+                    },
+                ];
+            }
+            else {
+                return working;
+            }
+            // After upserting, check if all tool calls on this row are complete.
+            if (nextToolCalls.every((tc) => tc.isCompleted)) {
+                shouldCreateNewMessage.current = true;
+            }
+            const updated = working.map((m, i) => i === resolution.targetIndex ? { ...m, toolCalls: nextToolCalls } : m);
             messagesRef.current = updated;
-            const messageWithToolResult = updated.find((msg) => msg.id === resultMessageId);
+            const messageWithToolResult = updated[resolution.targetIndex];
             const matchingToolCall = messageWithToolResult?.toolCalls?.find((tc) => tc.toolCallId === resultToolCallId);
-            appendToolUiEvent("ui:tool-result-applied", `${extractedToolCall.functionName || "unknown"} toolCallId=${resultToolCallId} targetMessageId=${resultMessageId} completed=${matchingToolCall?.isCompleted ? "yes" : "no"} messageToolCalls=${messageWithToolResult?.toolCalls?.length || 0}`);
+            appendToolUiEvent("ui:tool-result-applied", `${extractedToolCall.functionName || "unknown"} toolCallId=${resultToolCallId} targetMessageId=${messageWithToolResult?.id || resultMessageId} completed=${matchingToolCall?.isCompleted ? "yes" : "no"} messageToolCalls=${messageWithToolResult?.toolCalls?.length || 0}`);
             return updated;
         });
         // Document-store refresh is now triggered by the backend agent:documents:changed
         // WebSocket message (fired from AgentDocumentRepository), bridged to the in-process
         // emitAgentDocumentsChanged event in EditorShell. No per-tool allow-list here.
-    }, [agent?.id, agentStub.id, appendToolUiEvent]);
+    }, [agent?.id, agentStub.id, appendToolUiEvent, resolveAssistantMessage]);
     // Listen for local approval resolution to update UI.
     // Filters on detail.agentId so that with multi-pane (same agent in two panes,
     // or any visible terminal that isn't the dispatch source) only the matching
@@ -2314,8 +2316,11 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         window.addEventListener("agent:toolApprovalResolved", onApprovalResolved);
         return () => window.removeEventListener("agent:toolApprovalResolved", onApprovalResolved);
     }, []);
-    // Load agent data and messages
-    const loadAgent = useCallback(async () => {
+    // Load agent data and messages.
+    // `silent: true` skips the loading-spinner UI; used for background reconciles
+    // (e.g. after a status change) where replacing the whole terminal with a
+    // spinner would unmount the prompt textarea and reset its cursor.
+    const loadAgent = useCallback(async ({ silent = false } = {}) => {
         try {
             // Even if agentStub.status is "new", try to load from backend first
             // The agent might have been persisted after sending a prompt
@@ -2460,7 +2465,9 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                     return;
                 }
             }
-            setIsLoading(true);
+            if (!silent) {
+                setIsLoading(true);
+            }
             setError(null);
             // Fetch agent details and initial queued prompts in parallel
             const [agentData, prompts] = await Promise.all([
@@ -2657,7 +2664,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             }
             reconcileServerStateInFlightRef.current = true;
             try {
-                await loadAgent();
+                await loadAgent({ silent: true });
             }
             finally {
                 reconcileServerStateInFlightRef.current = false;
@@ -2840,6 +2847,48 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                 console.log("[AgentTerminal] Ignoring agent:run:start during stop operation");
                 return;
             }
+            // Run-id bookkeeping runs BEFORE any other branch (paused-state
+            // early-return, dedup reset). Replayed starts for paused runs still
+            // need to establish currentRunIdRef so subsequent run-scoped messages
+            // are accepted as live; without that, deltas for the same run would
+            // be dropped as "stale".
+            const startRunId = normalizeRunId(message.payload?.runId);
+            if (startRunId === null) {
+                noteMissingRunId("agent:run:start");
+            }
+            if (startRunId !== null) {
+                // Replayed start for a run we've already settled — drop it.
+                if (lastSettledRunIdRef.current === startRunId) {
+                    return;
+                }
+                // Duplicate start for the live run — drop without wiping live state
+                // (do not reset lastSeqRef / seenMessageIdsRef on the second start).
+                if (currentRunIdRef.current === startRunId) {
+                    return;
+                }
+                // Accepted: this is a fresh run. Take ownership of the run id and
+                // (only here) reset run-scoped dedup state.
+                currentRunIdRef.current = startRunId;
+                lastSeqRef.current = 0;
+                // #3: clear and reseed seenMessageIdsRef with currently rendered
+                // message ids so dedup stays live for messages already on screen
+                // but stale ids (from prior runs) don't accumulate forever.
+                seenMessageIdsRef.current.clear();
+                for (const msg of messagesRef.current) {
+                    if (msg.id) {
+                        seenMessageIdsRef.current.add(msg.id.toLowerCase());
+                    }
+                }
+                // #7: any "already resynced" markers from a prior run no longer
+                // apply — clear so live deltas of the new run are processed
+                // normally (they carry seq>=1 anyway, but keep the set bounded).
+                lastResyncedMessageIdsRef.current.clear();
+            }
+            else {
+                // Legacy / un-upgraded server: keep the historical reset behaviour
+                // so the existing seq dedup keeps working.
+                lastSeqRef.current = 0;
+            }
             const currentStatus = agentRef.current?.status;
             if (currentStatus === "waitingForInput" ||
                 currentStatus === "waitingForApproval" ||
@@ -2847,11 +2896,10 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                 // Replayed start messages arrive before the buffered status payload when
                 // reopening an already-paused agent. Preserve the attention state instead
                 // of flashing "running" until the follow-up status update lands.
+                // (currentRunIdRef is already established above so subsequent
+                // delta/status events for this run are accepted.)
                 return;
             }
-            // Reset run-scoped deduplication so new run seq values (starting at 1)
-            // are not discarded due to previous run's lastSeqRef
-            lastSeqRef.current = 0;
             setLastRunStatusReason(null);
             // Prep streaming UI state for the new run
             setIsConnecting(true);
@@ -2866,7 +2914,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         }
         // Handle agent:user:message
         if (messageType === "agent:user:message") {
-            const { messageId, content, timestamp, sourceAgentName, sourceAgent } = message.payload;
+            const { messageId, content, timestamp, sourceAgentName, sourceAgent, clientMessageId, } = message.payload;
             // Track in seenMessageIds for deduplication
             const normalizedId = messageId.toLowerCase();
             if (seenMessageIdsRef.current.has(normalizedId)) {
@@ -2910,11 +2958,20 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                     console.log("[AgentTerminal] Message already exists by ID, skipping:", messageId);
                     return prev;
                 }
-                // Look for an optimistic (temp) message with matching content to replace
-                // Temp messages have IDs starting with "temp-"
-                const tempMessageIndex = prev.findIndex((m) => m.id?.startsWith("temp-") &&
-                    m.role === "user" &&
-                    m.content === content);
+                // Look for an optimistic (temp) message to replace.
+                // Prefer matching by clientMessageId (the temp id we sent up at
+                // submit time and the server echoes back). Fall back to content
+                // equality for legacy paths and for messages that never went
+                // through this client (spawned-agent / system-injected).
+                let tempMessageIndex = -1;
+                if (clientMessageId) {
+                    tempMessageIndex = prev.findIndex((m) => m.id === clientMessageId && m.role === "user");
+                }
+                if (tempMessageIndex === -1) {
+                    tempMessageIndex = prev.findIndex((m) => m.id?.startsWith("temp-") &&
+                        m.role === "user" &&
+                        m.content === content);
+                }
                 let updated;
                 if (tempMessageIndex !== -1) {
                     // Replace the optimistic message with the server version
@@ -2975,7 +3032,30 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             if (isStoppingRef.current) {
                 return;
             }
+            // Drop stale-run delta — a delta that belongs to a previous run on
+            // this same agent (e.g. the previous run's final delta arriving
+            // after we accepted agent:run:start for the new run).
+            const deltaRunId = normalizeRunId(message.payload?.runId);
+            if (deltaRunId === null) {
+                noteMissingRunId("agent:run:delta");
+            }
+            else if (currentRunIdRef.current !== null &&
+                deltaRunId !== currentRunIdRef.current) {
+                appendToolUiEvent("ui:stream-runid-dropped", `agent:run:delta runId=${deltaRunId} currentRunId=${currentRunIdRef.current}`);
+                return;
+            }
             const { seq, type, data, cost } = message.payload;
+            // Post-resync guard: a legacy replay delta carries seq=0. If we've
+            // already received an agent:run:resync envelope for this message id,
+            // the replay delta would re-append content the resync wrote in full.
+            // Drop it. Live-run deltas always carry seq>=1 and are unaffected.
+            if ((!seq || seq === 0) && data?.messageId) {
+                const replayMessageId = String(data.messageId).toLowerCase();
+                if (lastResyncedMessageIdsRef.current.has(replayMessageId)) {
+                    appendToolUiEvent("ui:stream-resync-skip-delta", `agent:run:delta messageId=${data.messageId} reason=already-resynced`);
+                    return;
+                }
+            }
             if (type === "ToolCall" || type === "toolCall") {
             }
             // Always allow ContextUpdate messages (metadata updates) regardless of agent status
@@ -3080,6 +3160,16 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         }
         // Unified: agent:run:status (state only)
         if (messageType === "agent:run:status") {
+            // Drop stale-run status — see matching block in agent:run:delta handler.
+            const statusRunId = normalizeRunId(message.payload?.runId);
+            if (statusRunId === null) {
+                noteMissingRunId("agent:run:status");
+            }
+            else if (currentRunIdRef.current !== null &&
+                statusRunId !== currentRunIdRef.current) {
+                appendToolUiEvent("ui:stream-runid-dropped", `agent:run:status runId=${statusRunId} currentRunId=${currentRunIdRef.current}`);
+                return;
+            }
             const { seq, data: statusData } = message.payload;
             // Reset on new-run detection — see matching block in agent:run:delta handler.
             if (seq === 1 && lastSeqRef.current > 0) {
@@ -3367,7 +3457,10 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                 }
                 // Handle "completed" state (fallback for legacy code paths that send status instead of lifecycle event)
                 if (normalizedStatus === "completed") {
-                    settleCompletedRun("completed");
+                    // Pass through the runId from the status payload so the
+                    // run-scoped idempotency guard in settleCompletedRun can drop
+                    // duplicates of agent:run:complete that already settled this run.
+                    settleCompletedRun("completed", message.payload?.runId);
                     return;
                 }
                 // Handle "Running" state - agent is actively processing
@@ -3427,16 +3520,123 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             }
             return;
         }
+        // Replay: agent:run:resync
+        // Sent (additively, after the legacy agent:run:delta) on
+        // reconnect / late-subscribe. Carries the full accumulated content for
+        // one assistant message at a time. Replace (do NOT append) the message's
+        // content / reasoning / toolCalls. Marks the messageId in
+        // lastResyncedMessageIdsRef so any subsequent legacy seq=0 delta for
+        // this same id is dropped (see agent:run:delta handler above).
+        if (messageType === "agent:run:resync") {
+            const resyncRunId = normalizeRunId(message.payload?.runId);
+            if (resyncRunId === null) {
+                noteMissingRunId("agent:run:resync");
+            }
+            else if (currentRunIdRef.current !== null &&
+                resyncRunId !== currentRunIdRef.current) {
+                appendToolUiEvent("ui:stream-runid-dropped", `agent:run:resync runId=${resyncRunId} currentRunId=${currentRunIdRef.current}`);
+                return;
+            }
+            const resyncMessageId = message.payload?.messageId;
+            if (!resyncMessageId) {
+                return;
+            }
+            const totalContent = String(message.payload?.totalContent ?? "");
+            const reasoning = String(message.payload?.reasoning ?? "");
+            const seq = Number(message.payload?.seq ?? 0);
+            const rawToolCalls = Array.isArray(message.payload?.toolCalls)
+                ? message.payload.toolCalls
+                : [];
+            // Normalize each tool call snapshot. The server stores raw JObjects
+            // from the live ToolCall / ToolResult emit shapes, which use slightly
+            // different field names (id vs toolCallId, arguments vs functionArguments,
+            // result vs functionResult, etc.). Map both into the frontend's
+            // canonical toolCall shape.
+            const normalizedToolCalls = rawToolCalls
+                .filter((tc) => tc && typeof tc === "object")
+                .map((tc) => {
+                const toolCallId = tc.toolCallId || tc.id || crypto.randomUUID();
+                return {
+                    id: toolCallId,
+                    messageId: resyncMessageId,
+                    toolCallId,
+                    functionName: tc.functionName || tc.name || tc.displayName || "",
+                    functionArguments: tc.functionArguments ?? tc.arguments ?? "",
+                    functionResult: tc.functionResult ?? tc.result ?? "",
+                    functionResultRichContent: tc.functionResultRichContent ?? tc.richContent ?? undefined,
+                    functionError: tc.functionError ?? tc.error ?? "",
+                    isCompleted: tc.isCompleted === true,
+                    responseTimeMs: tc.responseTimeMs,
+                    createdDate: tc.createdDate ||
+                        message.payload?.timestamp ||
+                        new Date().toISOString(),
+                    requiresApproval: tc.requiresApproval,
+                    ...(tc.dbMessageId
+                        ? { dbMessageId: tc.dbMessageId }
+                        : {}),
+                };
+            });
+            setMessages((prev) => {
+                const idx = prev.findIndex((m) => m.id === resyncMessageId);
+                if (idx === -1) {
+                    // Resync arrived before any live message exists for this id —
+                    // create a streaming row and seed it with the full snapshot.
+                    const created = createNewStreamMessage(resyncMessageId, agent);
+                    const seeded = {
+                        ...created,
+                        content: totalContent,
+                        reasoning,
+                        toolCalls: normalizedToolCalls,
+                    };
+                    const updated = [...prev, seeded];
+                    messagesRef.current = updated;
+                    return updated;
+                }
+                const updated = prev.map((m, i) => i === idx
+                    ? {
+                        ...m,
+                        content: totalContent,
+                        reasoning,
+                        toolCalls: normalizedToolCalls,
+                    }
+                    : m);
+                messagesRef.current = updated;
+                return updated;
+            });
+            if (seq && seq > lastSeqRef.current) {
+                lastSeqRef.current = seq;
+            }
+            lastResyncedMessageIdsRef.current.add(resyncMessageId.toLowerCase());
+            return;
+        }
         // Lifecycle: agent:run:complete
         if (messageType === "agent:run:complete") {
             lastNonHeartbeatUpdateAtRef.current = Date.now();
+            const completeRunId = message.payload?.runId;
+            if (normalizeRunId(completeRunId) === null) {
+                noteMissingRunId("agent:run:complete");
+            }
             const finalStatus = normalizeServerExecutionStatus(message.payload?.finalStatus);
-            settleCompletedRun(finalStatus === "cancelled" ? "cancelled" : "completed");
+            settleCompletedRun(finalStatus === "cancelled" ? "cancelled" : "completed", completeRunId);
             return;
         }
         // Lifecycle: agent:run:error
         if (messageType === "agent:run:error") {
             lastNonHeartbeatUpdateAtRef.current = Date.now();
+            const errorRunId = normalizeRunId(message.payload?.runId);
+            if (errorRunId === null) {
+                noteMissingRunId("agent:run:error");
+            }
+            else if (lastSettledRunIdRef.current === errorRunId ||
+                (currentRunIdRef.current !== null &&
+                    currentRunIdRef.current !== errorRunId)) {
+                // Replayed error for a settled run, or error for a stale run that
+                // a fresh run has already superseded. Drop it.
+                return;
+            }
+            if (errorRunId !== null) {
+                lastSettledRunIdRef.current = errorRunId;
+            }
             const errorMsg = toUserFacingAgentErrorMessage(message.payload?.error) ||
                 "AI could not complete this request.";
             clearHeartbeatMessages();
@@ -3458,10 +3658,13 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         agent,
         appendToolUiEvent,
         clearHeartbeatMessages,
+        createNewStreamMessage,
         handleContentChunk,
         handleHeartbeatMessage,
         handleToolCall,
         handleToolResult,
+        noteMissingRunId,
+        normalizeRunId,
         onAgentUpdate,
         schedulePendingDialogReplay,
         settleCompletedRun,
@@ -4109,6 +4312,9 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                 model: requestSettings.modelId,
                 mode: requestSettings.mode,
                 context: canonicalizeAgentMetadata(effectiveContext), // Use fresh live context when in live mode
+                // #4: correlate optimistic user bubble (tempMessageId) with server's
+                // agent:user:message echo so the temp can be replaced by id.
+                clientMessageId: tempMessageId,
             };
             console.log("[AgentTerminal] Calling startAgent API for agent:", agentId);
             // Reset the stall watchdog so its 15s window starts at submit, not at the last
@@ -4116,6 +4322,14 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             lastNonHeartbeatUpdateAtRef.current = Date.now();
             const response = await startAgent(request);
             console.log("[AgentTerminal] startAgent response:", response);
+            // The agent has now been persisted server-side. Tell the parent so a
+            // remount (e.g. splash chat after a workspace switch) sees a non-"new"
+            // stub and goes through loadAgent's server-fetch path instead of the
+            // local-only draft branch — otherwise the remounted terminal would
+            // present an empty message list.
+            if (agentStub.status === "new") {
+                onAgentUpdate?.({ status: "running" });
+            }
             const isQueuedForCapacity = response.reason === MACHINE_CAPACITY_REASON ||
                 response.message?.toLowerCase().includes("machine slot") ||
                 false;
@@ -4405,6 +4619,8 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                 model: requestSettings.modelId,
                 mode: requestSettings.mode,
                 context: canonicalizeAgentMetadata(effectiveContext), // Use fresh live context when in live mode
+                // #4: correlate optimistic quick-message bubble with server echo.
+                clientMessageId: tempMessageId,
             };
             console.log("[AgentTerminal] Calling startAgent API for quick message");
             await startAgent(request);
@@ -5084,6 +5300,22 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
     // update exceeds 15s. If it does, it asks the backend whether it has produced
     // sequence numbers we have not applied — and only if so, falls back to what a user
     // would do: reload the agent and reconnect the socket.
+    useEffect(() => {
+        if (!currentAgentId)
+            return;
+        updateAgentWatchdogStatus(currentAgentId, {
+            isExecuting,
+            isVisible: effectiveIsVisible,
+            isStopping: isStoppingRef.current,
+            isWaitingForCapacity: lastRunStatusReason === MACHINE_CAPACITY_REASON,
+            stalledThresholdMs: STREAM_STALLED_AFTER_MS,
+        });
+    }, [
+        currentAgentId,
+        isExecuting,
+        effectiveIsVisible,
+        lastRunStatusReason,
+    ]);
     useEffect(() => {
         if (!effectiveIsVisible || !isExecuting || !currentAgentId) {
             return;
@@ -5091,6 +5323,11 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         let disposed = false;
         const agentIdAtMount = currentAgentId;
         lastNonHeartbeatUpdateAtRef.current = Date.now();
+        updateAgentWatchdogStatus(agentIdAtMount, {
+            running: true,
+            startedAt: Date.now(),
+            stalledThresholdMs: STREAM_STALLED_AFTER_MS,
+        });
         const logRecoveryEvent = (kind, payload) => {
             try {
                 appendToolUiEvent(`recovery:${kind}`, JSON.stringify({ agentId: agentIdAtMount, ...payload }));
@@ -5098,9 +5335,30 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             catch {
                 // Telemetry must never throw out of the watchdog path.
             }
+            try {
+                emitAgentRecoveryEvent({
+                    agentId: agentIdAtMount,
+                    kind,
+                    payload,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+            catch {
+                // Telemetry must never throw out of the watchdog path.
+            }
         };
         const sessionId = editContext?.sessionId;
         const tick = async () => {
+            updateAgentWatchdogStatus(agentIdAtMount, {
+                running: true,
+                lastTickAt: Date.now(),
+                isExecuting: true,
+                isVisible: true,
+                isStopping: isStoppingRef.current,
+                isWaitingForCapacity: lastRunStatusReason === MACHINE_CAPACITY_REASON,
+                lastNonHeartbeatUpdateAt: lastNonHeartbeatUpdateAtRef.current,
+                stalledThresholdMs: STREAM_STALLED_AFTER_MS,
+            });
             if (!isStreamStalled({
                 isExecuting: true,
                 isVisible: true,
@@ -5169,6 +5427,10 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         return () => {
             disposed = true;
             window.clearInterval(intervalId);
+            updateAgentWatchdogStatus(agentIdAtMount, {
+                running: false,
+                stoppedAt: Date.now(),
+            });
         };
     }, [
         currentAgentId,
@@ -5602,11 +5864,14 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                                 return groups.map((group, groupIndex) => {
                                     const isLastGroup = groupIndex === groups.length - 1;
                                     if (group.type === "user" && group.messages[0]) {
-                                        // Render user message
-                                        return (_jsx(UserMessage, { message: group.messages[0] }, groupIndex));
+                                        const userKey = group.messages[0].id;
+                                        if (!userKey) {
+                                            console.warn("[AgentTerminal] user message group missing id", { groupIndex });
+                                        }
+                                        return (_jsx(UserMessage, { message: group.messages[0] }, userKey ?? `user-${groupIndex}`));
                                     }
                                     else if (group.type === "heartbeat" && group.messages[0]) {
-                                        return (_jsx(HeartbeatMessage, { message: group.messages[0] }, group.messages[0].id || groupIndex));
+                                        return (_jsx(HeartbeatMessage, { message: group.messages[0] }, group.messages[0].id));
                                     }
                                     else {
                                         // Render bundled assistant messages
@@ -5624,6 +5889,10 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                                         }
                                         const convertedMessages = convertAgentMessagesToAiFormat(filteredMessages);
                                         const operationsForGroup = getOperationsForMessageGroup(convertedMessages, agentOperations);
+                                        const assistantKey = filteredMessages[0]?.id;
+                                        if (!assistantKey) {
+                                            console.warn("[AgentTerminal] assistant message group missing id", { groupIndex });
+                                        }
                                         return (_jsx(AiResponseMessage, { messages: convertedMessages, finished: !isLastGroup || !isExecuting, editOperations: operationsForGroup, defaultCollapseJson: defaultCollapseJson, profileSvgIcon: activeProfile?.svgIcon, agentId: agent?.id || agentStub.id, agentName: activeProfile?.agentName ||
                                                 activeProfile?.displayTitle ||
                                                 activeProfile?.name, allPendingApprovals: allPendingApprovals, onSwitchToAutonomous: handleSwitchToAutonomous, browserCaptureInlinePrompt: browserCaptureInlinePrompt, readOnly: readOnly, onQuickAction: (action) => {
@@ -5666,7 +5935,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                                                     catch { }
                                                 }
                                                 sendQuickMessage(text);
-                                            } }, groupIndex));
+                                            } }, assistantKey ?? `assistant-${groupIndex}`));
                                     }
                                 });
                             })(), shouldShowThinkingDots && (_jsxs("div", { className: "flex gap-3 px-4 py-3", "data-testid": "agent-thinking-dots", children: [_jsx("div", { className: "shrink-0", children: activeProfile?.svgIcon ? (_jsx("div", { className: "text-gray-2 flex h-6 w-6 items-center justify-center [&>svg]:h-full [&>svg]:w-full", dangerouslySetInnerHTML: {
@@ -6046,7 +6315,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                                                                 setShowCostAndAgent((prev) => !prev);
                                                         }, variant: "outline", size: "sm", className: "h-5.5 w-5.5 cursor-pointer rounded-full", "aria-expanded": editContext?.isMobile
                                                             ? showCostAndAgent
-                                                            : undefined, "aria-label": "Toggle cost and context info", children: _jsx(DollarSign, { className: "size-3", strokeWidth: 1 }) }) }), _jsx(PopoverContent, { className: "w-64 p-0", align: "start", children: _jsx("div", { className: "max-h-56 overflow-y-auto p-2", children: _jsx(AgentTerminalStatusBar, { agent: agent, contextWindowStatus: contextWindowStatus, effectiveModelName: effectiveModelName, socketDiagnostics: editContext.socketDiagnostics, runDiagnosticsSnapshot: runDiagnosticsSnapshot, liveTotals: liveTotals, totalTokens: liveTotals
+                                                            : undefined, "aria-label": "Toggle cost and context info", children: _jsx(DollarSign, { className: "size-3", strokeWidth: 1 }) }) }), _jsx(PopoverContent, { className: "w-64 p-0", align: "start", children: _jsx("div", { className: "max-h-56 overflow-y-auto p-2", children: _jsx(AgentTerminalStatusBar, { agent: agent, contextWindowStatus: contextWindowStatus, effectiveModelName: effectiveModelName, socketDiagnostics: editContext.socketDiagnostics, addSocketMessageListener: editContext.addSocketMessageListener, runDiagnosticsSnapshot: runDiagnosticsSnapshot, liveTotals: liveTotals, totalTokens: liveTotals
                                                                 ? {
                                                                     input: liveTotals.input,
                                                                     output: liveTotals.output,
@@ -6086,7 +6355,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                     })(), (showStatusBar ?? !hideBottomControls) &&
                         !simpleMode &&
                         editContext &&
-                        !editContext.isMobile && (_jsx(AgentTerminalStatusBar, { agent: agent, contextWindowStatus: contextWindowStatus, effectiveModelName: effectiveModelName, socketDiagnostics: editContext.socketDiagnostics, runDiagnosticsSnapshot: runDiagnosticsSnapshot, liveTotals: liveTotals, totalTokens: liveTotals
+                        !editContext.isMobile && (_jsx(AgentTerminalStatusBar, { agent: agent, contextWindowStatus: contextWindowStatus, effectiveModelName: effectiveModelName, socketDiagnostics: editContext.socketDiagnostics, addSocketMessageListener: editContext.addSocketMessageListener, runDiagnosticsSnapshot: runDiagnosticsSnapshot, liveTotals: liveTotals, totalTokens: liveTotals
                             ? {
                                 input: liveTotals.input,
                                 output: liveTotals.output,