@parhelia/core 0.1.12776 → 0.1.12780

package/dist/editor/ai/AgentTerminal.js

@@ -21,7 +21,7 @@ import { QueuedPromptsPanel } from "./QueuedPromptsPanel";
 import { AgentCapacityBanner, AgentCostLimitBanner, AgentErrorBanner, } from "./AgentBanners";
 import { InitialThinkingSplash } from "./InitialThinkingSplash";
 import { AgentInlineDialogContent } from "./AgentInlineDialogContent";
-import { AGENT_HISTORY_LIMIT, MACHINE_CAPACITY_REASON, buildPlaceholderAgentDetails, formatAllowanceLabel, formatAllowanceSource, getAgentRunMessageAgentId, getAgentRunMessageDetail, getAgentRunMessageSeq, isInactiveServerExecutionStatus, isAgentErrorStatusValue, isHeartbeatRunEventMessage, mergeAgentOperationHistory, normalizeDialogAgentId, normalizeProfileAllowanceOperations, normalizeServerExecutionStatus, } from "./agentMessageHelpers";
+import { AGENT_HISTORY_LIMIT, MACHINE_CAPACITY_REASON, buildPlaceholderAgentDetails, formatAllowanceLabel, formatAllowanceSource, getAgentRunMessageAgentId, getAgentRunMessageDetail, getAgentRunMessageSeq, isAgentErrorStatusValue, isHeartbeatRunEventMessage, mergeAgentOperationHistory, normalizeDialogAgentId, normalizeProfileAllowanceOperations, normalizeServerExecutionStatus, } from "./agentMessageHelpers";
 import { AgentDocumentList, } from "./AgentDocumentList";
 import { AgentEditOperationsPanel } from "./EditOperationsPanel";
 import { SpawnedAgentsPanel } from "./SpawnedAgentsPanel";
@@ -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 { checkReplayVerified, createRecoveryStateSlice, decideRecoveryAction, interpretAgentRunDiagnostics, reconcilePendingDialogTracker, } 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";
@@ -80,7 +82,7 @@ function hasStaleRunningLoadSuppression(agentId) {
 // interface AgentTerminalProps {
 //   agentStub: Agent;
 // }
-export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadProfiles, isActive, isVisible, isFocused, compact = false, displayMode = "full", showSummaryInput = false, hideContext = false, hideBottomControls = false, hideGreeting = false, defaultCollapseJson = false, simpleMode = false, className, initialPrompt, onAgentUpdate, onMessage, onInteractionSubmitted, onQuestionnaireOpenChange, questionnaireFooterActions, hideSummaryMessages = false, summaryPlaceholderActions, summaryPlaceholderMessage, hideSummaryWaitingPlaceholder = false, }) {
+export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadProfiles, isActive, isVisible, isFocused, compact = false, displayMode = "full", showSummaryInput = false, hideContext = false, hideBottomControls = false, showStatusBar, showAgentConfigControls, hideGreeting = false, defaultCollapseJson = false, simpleMode = false, className, initialPrompt, onAgentUpdate, onMessage, onInteractionSubmitted, onQuestionnaireOpenChange, questionnaireFooterActions, hideSummaryMessages = false, summaryPlaceholderActions, summaryPlaceholderMessage, hideSummaryWaitingPlaceholder = false, }) {
     // Derived from props. `isVisible` controls "is this terminal mounted and
     // streaming" (subscriptions, polling). `isFocused` controls "does this
     // terminal own keyboard focus and dialogs". Both fall back to legacy
@@ -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,18 +1268,33 @@ 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);
-    // Recovery ladder state. The graduated replay → reconnect → stale path lives in the
-    // diagnostics polling effect below. State is keyed by agentId so switching between
-    // agents in the same terminal doesn't cross-contaminate cooldowns.
-    const recoveryStateByAgentRef = useRef(new Map());
-    const replayVerifyTimeoutRef = useRef(null);
-    // Mirror refs so the one-shot verify timer (which fires outside the polling effect's
-    // closure) can read the latest snapshot/diagnostics without re-running the effect.
-    const runDiagnosticsSnapshotRef = useRef(null);
-    const lastDiagnosticsResponseRef = useRef(null);
-    const [showStaleAgentBanner, setShowStaleAgentBanner] = useState(false);
+    // Stream-stall watchdog timestamps. `lastNonHeartbeatUpdateAtRef` is set every time
+    // something non-heartbeat advances the run (prompt submit, isExecuting transition,
+    // status/delta/complete/error event, socket reconnect, or a stall reload).
+    // `lastStallReloadAtRef` enforces a minimum gap between automatic reloads so a
+    // backend that keeps advancing while our socket keeps bouncing can't trigger reloads
+    // every 15 seconds.
+    const lastNonHeartbeatUpdateAtRef = useRef(0);
+    const lastStallReloadAtRef = useRef(0);
     const toolCallFirstSeenAtRef = useRef({});
     const pendingToolCompletionTimersRef = useRef({});
     // Cache mode/model/profile changes made while the agent is still "new" (not yet persisted)
@@ -1620,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
@@ -1652,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
@@ -1769,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
@@ -1783,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;
@@ -2139,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,
@@ -2207,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
@@ -2316,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
@@ -2462,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([
@@ -2659,7 +2664,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             }
             reconcileServerStateInFlightRef.current = true;
             try {
-                await loadAgent();
+                await loadAgent({ silent: true });
             }
             finally {
                 reconcileServerStateInFlightRef.current = false;
@@ -2842,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" ||
@@ -2849,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);
@@ -2868,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)) {
@@ -2912,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
@@ -2977,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
@@ -3019,6 +3097,9 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             if (seq) {
                 lastSeqRef.current = seq;
             }
+            if (!isHeartbeat) {
+                lastNonHeartbeatUpdateAtRef.current = Date.now();
+            }
             // Route based on delta type
             const agentStreamMessage = {
                 type,
@@ -3079,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) {
@@ -3092,6 +3183,9 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             if (seq) {
                 lastSeqRef.current = seq;
             }
+            // Status events never carry a "Heartbeat" payload — heartbeats are deltas. Any
+            // status update is meaningful progress for the watchdog.
+            lastNonHeartbeatUpdateAtRef.current = Date.now();
             // Route based on statusData.state
             try {
                 // Normalize various status shapes and handle Cancelled uniformly
@@ -3363,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
@@ -3423,14 +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();
@@ -3452,10 +3658,13 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         agent,
         appendToolUiEvent,
         clearHeartbeatMessages,
+        createNewStreamMessage,
         handleContentChunk,
         handleHeartbeatMessage,
         handleToolCall,
         handleToolResult,
+        noteMissingRunId,
+        normalizeRunId,
         onAgentUpdate,
         schedulePendingDialogReplay,
         settleCompletedRun,
@@ -4103,10 +4312,24 @@ 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
+            // delta of the previous run (which could be hours ago for a reused chat).
+            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;
@@ -4396,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);
@@ -4999,7 +5224,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         const lastEvent = recentAgentRunEvents[recentAgentRunEvents.length - 1];
         const { receivedSeqs, missingSeqs, totalCount } = currentRunDiagnostics;
         const observedMaxSeq = receivedSeqs[receivedSeqs.length - 1] ?? 0;
-        const inlineCallback = activeInlineDialogRef.current?.request.callbackId?.trim() || null;
         return {
             agentId: currentAgentId,
             isSubmitting,
@@ -5026,8 +5250,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             totalToolCallCount,
             incompleteToolCallCount,
             recentToolUiEvents,
-            activeInlineDialogCallbackId: inlineCallback,
-            pendingDialogReplayCallbackIds: Array.from(pendingDialogReplayCallbackIdsRef.current),
         };
     }, [
         assistantGroupCount,
@@ -5048,239 +5270,176 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
         recentToolUiEvents,
         totalToolCallCount,
         agent?.statusMessage,
-        activeInlineDialog,
     ]);
-    // Mirror the latest snapshot/diagnostics so the one-shot replay verify timer can read
-    // them after the polling effect's closure has gone stale.
+    // Bump the watchdog timestamp when isExecuting goes false→true. Covers resumed and
+    // foreign starts (where another browser kicks off a run we're observing) on top of
+    // the explicit submit-time bump in handleSubmit.
+    const previousIsExecutingRef = useRef(false);
     useEffect(() => {
-        runDiagnosticsSnapshotRef.current = runDiagnosticsSnapshot;
-    }, [runDiagnosticsSnapshot]);
-    // Reset all per-agent recovery state when the active agent changes.
+        if (isExecuting && !previousIsExecutingRef.current) {
+            lastNonHeartbeatUpdateAtRef.current = Date.now();
+        }
+        previousIsExecutingRef.current = isExecuting;
+    }, [isExecuting]);
+    // When the editor socket reconnects, the subscription registry resubscribes for us.
+    // Give it a fresh window before the watchdog judges silence — otherwise a slow
+    // resubscribe handshake would look like a stall.
     useEffect(() => {
-        recoveryStateByAgentRef.current.clear();
-        if (replayVerifyTimeoutRef.current) {
-            clearTimeout(replayVerifyTimeoutRef.current);
-            replayVerifyTimeoutRef.current = null;
+        if (isExecuting) {
+            lastNonHeartbeatUpdateAtRef.current = Date.now();
         }
-        setShowStaleAgentBanner(false);
+    }, [editContext?.socketConnectionVersion, isExecuting]);
+    // Reset watchdog cooldown timestamps when the active agent changes — otherwise a
+    // recent reload on agent A would suppress the first reload for agent B.
+    useEffect(() => {
+        lastNonHeartbeatUpdateAtRef.current = 0;
+        lastStallReloadAtRef.current = 0;
     }, [currentAgentId]);
-    // When the editor socket reconnects (socketConnectionVersion bump) clear the stale
-    // banner — the registry has just re-issued subscriptions, so any "stuck" state should
-    // resolve on the next poll. If it doesn't, the banner will reappear.
+    // Stream-stall watchdog. While the run is active and the terminal is visible, the
+    // watchdog ticks every 5s and checks whether the gap since the last non-heartbeat
+    // 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(() => {
-        setShowStaleAgentBanner(false);
-    }, [editContext?.socketConnectionVersion]);
+        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;
         }
         let disposed = false;
         const agentIdAtMount = currentAgentId;
-        const getRecoveryState = () => {
-            let state = recoveryStateByAgentRef.current.get(agentIdAtMount);
-            if (!state) {
-                state = createRecoveryStateSlice();
-                recoveryStateByAgentRef.current.set(agentIdAtMount, state);
-            }
-            return state;
-        };
+        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 }));
             }
             catch {
-                // Telemetry must never throw out of the polling path.
+                // Telemetry must never throw out of the watchdog path.
             }
-        };
-        const clearVerifyTimer = () => {
-            if (replayVerifyTimeoutRef.current) {
-                clearTimeout(replayVerifyTimeoutRef.current);
-                replayVerifyTimeoutRef.current = null;
+            try {
+                emitAgentRecoveryEvent({
+                    agentId: agentIdAtMount,
+                    kind,
+                    payload,
+                    timestamp: new Date().toISOString(),
+                });
             }
-        };
-        const tryReconnect = (state, reason) => {
-            const now = Date.now();
-            if (state.lastReconnectAt > 0 &&
-                now - state.lastReconnectAt < 60_000) {
-                logRecoveryEvent("reconnect-cooldown", { reason });
-                return false;
+            catch {
+                // Telemetry must never throw out of the watchdog path.
             }
-            state.lastReconnectAt = now;
-            const closed = forceEditorSocketReconnect(reason);
-            logRecoveryEvent("reconnect-started", { reason, closed });
-            return true;
         };
-        const checkServerCompletion = async () => {
+        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,
+                isStopping: isStoppingRef.current,
+                isWaitingForCapacity: lastRunStatusReason === MACHINE_CAPACITY_REASON,
+                lastUpdateAt: lastNonHeartbeatUpdateAtRef.current,
+                now: Date.now(),
+            })) {
+                return;
+            }
+            logRecoveryEvent("stall-check", {
+                silentMs: Date.now() - lastNonHeartbeatUpdateAtRef.current,
+                localSeq: lastSeqRef.current,
+            });
+            let diagnostics;
             try {
-                const diagnostics = await getAgentDiagnostics(agentIdAtMount, editContext?.sessionId);
-                if (disposed) {
-                    return;
-                }
-                lastDiagnosticsResponseRef.current = diagnostics;
-                const serverStatus = diagnostics.execution?.status;
-                if (isInactiveServerExecutionStatus(serverStatus)) {
-                    setShowStaleAgentBanner(false);
-                    const lastRunRequestedAt = Date.parse(diagnostics.lastRunRequest?.requestedAt || "");
-                    const cancelRequestedAt = Date.parse(diagnostics.lastCancellation?.requestedAt || "");
-                    const cancellationAppliesToCurrentRun = Number.isFinite(cancelRequestedAt) &&
-                        (!Number.isFinite(lastRunRequestedAt) ||
-                            cancelRequestedAt >= lastRunRequestedAt);
-                    settleCompletedRun(normalizeServerExecutionStatus(serverStatus) === "cancelled" ||
-                        cancellationAppliesToCurrentRun
-                        ? "cancelled"
-                        : "completed");
-                    return;
-                }
-                // Backstop: if the backend reports an error but we never received the
-                // agent:run:error lifecycle event (e.g. it was missed or the broadcast
-                // path failed to fire), surface the error locally instead of waiting
-                // for the user to reload.
-                if (normalizeServerExecutionStatus(serverStatus) === "error") {
-                    const rawError = diagnostics.execution?.error ?? null;
-                    const errorMsg = toUserFacingAgentErrorMessage(rawError) ||
-                        rawError ||
-                        "AI could not complete this request.";
-                    clearHeartbeatMessages();
-                    setLastRunStatusReason(null);
-                    setError(errorMsg);
-                    setAgent((prev) => prev ? { ...prev, status: "error", statusMessage: errorMsg } : prev);
-                    setIsWaitingForResponse(false);
-                    isWaitingRef.current = false;
-                    setIsConnecting(false);
-                    setIsAgentThinking(false);
-                    setShowStaleAgentBanner(false);
-                    return;
-                }
-                const snapshot = runDiagnosticsSnapshot;
-                if (!editContext?.socketDiagnostics) {
-                    // No edit context to read socket diagnostics from — recovery decisions need it,
-                    // and without it we'd misclassify the stream. Wait for the next tick.
-                    return;
-                }
-                const summary = interpretAgentRunDiagnostics({
-                    socketDiagnostics: editContext.socketDiagnostics,
-                    localSnapshot: snapshot,
-                    serverDiagnostics: diagnostics,
-                });
-                const state = getRecoveryState();
-                const now = Date.now();
-                reconcilePendingDialogTracker(state, diagnostics.pendingDialogs, now);
-                // --- Verify-window resolution. Structured to avoid the "expired branch
-                // unreachable" pitfall: first check whether a verify is in flight, then branch on
-                // whether it's still inside the window or just expired.
-                if (state.lastReplayVerifyDeadlineAt > 0) {
-                    if (now < state.lastReplayVerifyDeadlineAt) {
-                        // Still inside the 4s window — leave verification to the one-shot timer.
-                        return;
-                    }
-                    const verified = checkReplayVerified(state, snapshot, diagnostics);
-                    state.lastReplayVerifyDeadlineAt = 0;
-                    state.lastReplayVerifySnapshot = null;
-                    logRecoveryEvent(verified ? "replay-succeeded" : "replay-failed", { kind: "poll", summaryCode: summary.code });
-                    if (verified) {
-                        setShowStaleAgentBanner(false);
-                        return;
-                    }
-                    // Fall through — decideRecoveryAction will likely return "reconnect" now.
-                }
-                const decision = decideRecoveryAction({
-                    summary,
-                    localSnapshot: snapshot,
-                    serverDiagnostics: diagnostics,
-                    recoveryState: state,
-                    now,
-                });
-                state.lastDecidedAction = decision.action;
-                logRecoveryEvent("decided", {
-                    action: decision.action,
-                    summaryCode: summary.code,
-                    reasonCode: decision.reasonCode,
-                    replayKey: decision.replayKey,
+                diagnostics = await getAgentDiagnostics(agentIdAtMount, sessionId);
+            }
+            catch (error) {
+                console.warn("[AgentTerminal] Stall watchdog failed to fetch diagnostics", error);
+                logRecoveryEvent("diagnostics-failed", {
+                    message: error instanceof Error ? error.message : String(error),
                 });
-                switch (decision.action) {
-                    case "replay": {
-                        const sent = requestAgentSubscriptionReplay(agentIdAtMount);
-                        if (!sent) {
-                            tryReconnect(state, "agent-recovery-replay-no-socket");
-                            break;
-                        }
-                        const serverLastSeq = diagnostics.currentSession?.lastDelivery?.lastSeq ??
-                            diagnostics.transport?.lastSeq ??
-                            null;
-                        const replayCallbackId = decision.replayKey?.split("|").pop() ?? null;
-                        state.lastReplayKey = decision.replayKey;
-                        state.lastReplayAt = now;
-                        state.lastReplayVerifyDeadlineAt = now + 4_000;
-                        state.lastReplayVerifySnapshot = {
-                            localSeq: snapshot.lastSeq,
-                            serverLastSeq,
-                            pendingDialogCallbackId: replayCallbackId === "none" ? null : replayCallbackId,
-                        };
-                        clearVerifyTimer();
-                        replayVerifyTimeoutRef.current = setTimeout(() => {
-                            replayVerifyTimeoutRef.current = null;
-                            if (disposed)
-                                return;
-                            const latestSnapshot = runDiagnosticsSnapshotRef.current ?? snapshot;
-                            const latestDiagnostics = lastDiagnosticsResponseRef.current;
-                            const verified = checkReplayVerified(state, latestSnapshot, latestDiagnostics);
-                            state.lastReplayVerifyDeadlineAt = 0;
-                            state.lastReplayVerifySnapshot = null;
-                            logRecoveryEvent(verified ? "replay-succeeded" : "replay-failed", { kind: "one-shot" });
-                            if (verified) {
-                                setShowStaleAgentBanner(false);
-                            }
-                            // Do not auto-escalate from here; the next poll will see the failed verify
-                            // and ask decideRecoveryAction for the next step (typically reconnect).
-                        }, 4_000);
-                        logRecoveryEvent("replay-started", {
-                            replayKey: decision.replayKey,
-                            summaryCode: summary.code,
-                            serverLastSeq,
-                            localSeq: snapshot.lastSeq,
-                        });
-                        break;
-                    }
-                    case "reconnect": {
-                        tryReconnect(state, "agent-recovery-escalation");
-                        break;
-                    }
-                    case "stale": {
-                        setShowStaleAgentBanner(true);
-                        logRecoveryEvent("stale", {
-                            summaryCode: summary.code,
-                            reasonCode: decision.reasonCode,
-                        });
-                        break;
-                    }
-                    case "none":
-                        break;
-                }
+                // Reset so we don't refire diagnostics every 5s while the call keeps failing.
+                lastNonHeartbeatUpdateAtRef.current = Date.now();
+                return;
+            }
+            if (disposed || agentIdAtMount !== currentAgentId) {
+                return;
+            }
+            const backendSeq = diagnostics.currentSession?.lastDelivery?.lastSeq ??
+                diagnostics.transport?.lastSeq ??
+                null;
+            const localSeq = lastSeqRef.current;
+            if (!shouldReloadAfterDiagnostics({ localSeq, backendSeq })) {
+                // Backend is at or behind us — silence is something else (idle, server lag).
+                // Suppress the watchdog for another full window instead of refiring every 5s.
+                lastNonHeartbeatUpdateAtRef.current = Date.now();
+                return;
+            }
+            const sinceLastReload = Date.now() - lastStallReloadAtRef.current;
+            if (lastStallReloadAtRef.current > 0 && sinceLastReload < 30_000) {
+                logRecoveryEvent("reload-cooldown", { sinceLastReload });
+                lastNonHeartbeatUpdateAtRef.current = Date.now();
+                return;
+            }
+            lastStallReloadAtRef.current = Date.now();
+            logRecoveryEvent("reload-fired", { backendSeq, localSeq });
+            lastSeqRef.current = 0;
+            seenMessageIdsRef.current.clear();
+            try {
+                await loadAgent();
             }
             catch (error) {
-                console.warn("[AgentTerminal] Failed to reconcile agent run status", error);
+                console.warn("[AgentTerminal] Stall reload loadAgent() failed", error);
+            }
+            if (disposed || agentIdAtMount !== currentAgentId) {
+                return;
             }
+            forceEditorSocketReconnect("agent-stream-stalled");
+            lastNonHeartbeatUpdateAtRef.current = Date.now();
         };
-        // Avoid racing a freshly submitted run before the backend has registered it.
-        const timeoutId = window.setTimeout(checkServerCompletion, 10_000);
-        const intervalId = window.setInterval(checkServerCompletion, 15_000);
+        const intervalId = window.setInterval(() => {
+            void tick();
+        }, 5_000);
         return () => {
             disposed = true;
-            window.clearTimeout(timeoutId);
             window.clearInterval(intervalId);
-            clearVerifyTimer();
+            updateAgentWatchdogStatus(agentIdAtMount, {
+                running: false,
+                stoppedAt: Date.now(),
+            });
         };
     }, [
         currentAgentId,
         editContext?.sessionId,
-        editContext?.socketConnectionVersion,
-        editContext?.socketDiagnostics,
         effectiveIsVisible,
         isExecuting,
+        lastRunStatusReason,
         appendToolUiEvent,
-        clearHeartbeatMessages,
-        runDiagnosticsSnapshot,
-        settleCompletedRun,
+        loadAgent,
     ]);
     const showInitialThinkingSplash = messages.length === 0 &&
         !error &&
@@ -5439,33 +5598,6 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
             "Waiting for capacity. The agent will start automatically when a slot becomes available.";
         return _jsx(AgentCapacityBanner, { message: message });
     };
-    const renderStaleAgentBanner = () => {
-        if (!showStaleAgentBanner || !currentAgentId)
-            return null;
-        const handleRefreshStream = () => {
-            const state = recoveryStateByAgentRef.current.get(currentAgentId);
-            if (state) {
-                state.lastReplayKey = null;
-                state.lastReplayAt = 0;
-            }
-            requestAgentSubscriptionReplay(currentAgentId);
-            void loadAgent();
-            setShowStaleAgentBanner(false);
-        };
-        const handleReconnect = () => {
-            const state = recoveryStateByAgentRef.current.get(currentAgentId);
-            if (state) {
-                state.lastReconnectAt = 0;
-            }
-            forceEditorSocketReconnect("user-stale-agent-action");
-            setShowStaleAgentBanner(false);
-        };
-        const handleCancel = () => {
-            void handleStop();
-            setShowStaleAgentBanner(false);
-        };
-        return (_jsxs("div", { role: "status", className: "m-3 rounded border border-amber-300 bg-amber-50 p-3 text-[12px] text-amber-900", children: [_jsx("p", { className: "font-medium", children: "Agent run looks stuck" }), _jsx("p", { className: "mt-1 text-[11px] text-amber-800", children: "The backend reports this run is still active, but recent recovery attempts did not resolve the stream. Pick an action below \u2014 automatic retries are paused until then." }), _jsxs("div", { className: "mt-2 flex flex-wrap gap-2", children: [_jsx(Button, { size: "sm", variant: "outline", onClick: handleRefreshStream, children: "Refresh stream" }), _jsx(Button, { size: "sm", variant: "outline", onClick: handleReconnect, children: "Reconnect socket" }), _jsx(Button, { size: "sm", variant: "outline", onClick: handleCancel, children: "Cancel agent" })] })] }));
-    };
     const renderBrowserClaimBanner = (variant = "inline") => {
         if (!agent?.id || !editContext?.sessionId)
             return null;
@@ -5589,7 +5721,7 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                 ? getOperationsForMessageGroup(summaryMessages, agentOperations)
                 : [];
             return (_jsxs("div", { className: `flex h-full min-h-0 flex-col ${className || ""}`, children: [fixedBrowserClaimBanner, readOnlyAccessNotice, error &&
-                        !isAgentErrorStatusValue((agent || agentStub)?.status) && (_jsx("div", { className: "m-4 rounded-lg border-l-4 border-red-500 bg-red-50 p-3 select-text", children: _jsxs("div", { className: "flex items-start", children: [_jsx(AlertCircle, { className: "mt-0.5 h-5 w-5 text-red-400", strokeWidth: 1 }), _jsxs("div", { className: "ml-3", children: [_jsx("p", { className: "text-[11px] font-medium text-red-800", children: "Error" }), _jsx("p", { className: "mt-1 text-[11px] text-red-700", children: error })] })] }) })), renderCapacityBanner(), renderErrorBanner(), renderStaleAgentBanner(), _jsxs("div", { ref: messagesContainerRef, className: "flex-1 overflow-y-auto", onScroll: handleScroll, children: [showInitialThinkingSplash && (_jsx(InitialThinkingSplash, { svgIcon: activeProfile?.svgIcon })), inlineBrowserClaimBanner, inlineDialog ? (inlineDialog) : latestSummaryAssistantGroup ? (_jsx("div", { className: "space-y-0 divide-y divide-gray-100 select-text", children: _jsx(AiResponseMessage, { messages: summaryMessages, finished: !latestSummaryAssistantGroup.isLastGroup || !isExecuting, editOperations: summaryOperations, defaultCollapseJson: defaultCollapseJson, profileSvgIcon: activeProfile?.svgIcon, agentId: agent?.id || agentStub.id, agentName: activeProfile?.agentName ||
+                        !isAgentErrorStatusValue((agent || agentStub)?.status) && (_jsx("div", { className: "m-4 rounded-lg border-l-4 border-red-500 bg-red-50 p-3 select-text", children: _jsxs("div", { className: "flex items-start", children: [_jsx(AlertCircle, { className: "mt-0.5 h-5 w-5 text-red-400", strokeWidth: 1 }), _jsxs("div", { className: "ml-3", children: [_jsx("p", { className: "text-[11px] font-medium text-red-800", children: "Error" }), _jsx("p", { className: "mt-1 text-[11px] text-red-700", children: error })] })] }) })), renderCapacityBanner(), renderErrorBanner(), _jsxs("div", { ref: messagesContainerRef, className: "flex-1 overflow-y-auto", onScroll: handleScroll, children: [showInitialThinkingSplash && (_jsx(InitialThinkingSplash, { svgIcon: activeProfile?.svgIcon })), inlineBrowserClaimBanner, inlineDialog ? (inlineDialog) : latestSummaryAssistantGroup ? (_jsx("div", { className: "space-y-0 divide-y divide-gray-100 select-text", children: _jsx(AiResponseMessage, { messages: summaryMessages, finished: !latestSummaryAssistantGroup.isLastGroup || !isExecuting, editOperations: summaryOperations, 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) => {
                                         const text = (action.prompt ||
@@ -5732,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
@@ -5754,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) => {
@@ -5796,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: {
@@ -5951,9 +6090,10 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                         const placeholderShowsOwnButtons = hideBottomControls && isInPlaceholderMode;
                         if (placeholderShowsOwnButtons)
                             return null;
-                        return (_jsxs("div", { className: cn("mt-2 flex items-stretch gap-2", hideBottomControls || simpleMode || isInPlaceholderMode
-                                ? "justify-end"
-                                : "justify-between"), children: [!hideBottomControls && !simpleMode && !isInPlaceholderMode && (_jsxs("div", { className: "flex flex-wrap items-center justify-start gap-2", children: [readOnly && (_jsx("span", { className: "shrink-0 rounded bg-gray-100 px-1 py-0.5 text-[10px] text-gray-600", title: "You have View-only access to this agent.", "data-testid": "agent-read-only-badge", children: "Read-only" })), _jsx(Select, { "data-testid": "agent-mode-selector", size: "xs", maxWidth: 240, disabled: readOnly, className: cn("h-5 w-auto min-w-[95px] rounded border px-1.5 text-[11px] font-normal", mode === "read-only"
+                        const showConfigControls = (showAgentConfigControls ?? !hideBottomControls) &&
+                            !simpleMode &&
+                            !isInPlaceholderMode;
+                        return (_jsxs("div", { className: cn("mt-2 flex items-stretch gap-2", showConfigControls ? "justify-between" : "justify-end"), children: [showConfigControls && (_jsxs("div", { className: "flex flex-wrap items-center justify-start gap-2", children: [readOnly && (_jsx("span", { className: "shrink-0 rounded bg-gray-100 px-1 py-0.5 text-[10px] text-gray-600", title: "You have View-only access to this agent.", "data-testid": "agent-read-only-badge", children: "Read-only" })), _jsx(Select, { "data-testid": "agent-mode-selector", size: "xs", maxWidth: 240, disabled: readOnly, className: cn("h-5 w-auto min-w-[95px] rounded border px-1.5 text-[11px] font-normal", mode === "read-only"
                                                 ? "border-green-300 bg-green-50! text-green-700 hover:bg-green-100!"
                                                 : mode === "supervised"
                                                     ? "border-amber-300 bg-amber-50! text-amber-700 hover:bg-amber-100!"
@@ -6175,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,
@@ -6212,10 +6352,10 @@ export function AgentTerminal({ agentStub, initialMetadata, profiles, onReloadPr
                                                     : allPendingApprovals.length > 0
                                                         ? "Approve or reject pending tool calls first"
                                                         : "Send", "aria-label": isExecuting ? "Stop" : "Send", "data-testid": "agent-send-stop-button", "data-executing": isExecuting ? "true" : "false", children: isExecuting ? (_jsx(Square, { className: "size-3", strokeWidth: 1 })) : (_jsx(Send, { className: "size-3", strokeWidth: 1 })) })] })] }));
-                    })(), !hideBottomControls &&
+                    })(), (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,