@xenosystem/agent-interface-ui 0.1.25 → 0.1.26

package/dist/stores/agentChatStore.js

@@ -393,6 +393,102 @@ export function findOldestQueuedTurn(conversations) {
     }
     return oldest;
 }
+/**
+ * 🔴 THE CONCURRENCY CEILING, and it is not optional.
+ *
+ * The global turn lock this file used to hold was accidentally also a RESOURCE ceiling:
+ * exactly one provider process could run at a time. Making turns per-conversation without
+ * replacing that ceiling would let a user with fifteen conversations spawn fifteen agent
+ * child processes, each with a real model bill — a worse bug than the one being fixed, and
+ * one a two-conversation test would never show.
+ *
+ * So the model is: **one turn per conversation, N turns overall.** Anything beyond N queues
+ * exactly as it does today, which is why the queue machinery is preserved rather than
+ * deleted — it becomes the ceiling's overflow path.
+ *
+ * N is a resource decision, not a correctness one. Three is chosen to be plainly more than
+ * one (the reported bug) and plainly less than "unbounded"; raise it deliberately, with the
+ * cost of a concurrent provider process in mind.
+ */
+export const MAX_CONCURRENT_TURNS = 3;
+/** The requestId currently running IN this conversation, or null. */
+export function conversationActiveRequestId(activeTurnsByConversation, conversationId) {
+    return activeTurnsByConversation[conversationId] ?? null;
+}
+export function activeTurnCount(activeTurnsByConversation) {
+    return Object.keys(activeTurnsByConversation).length;
+}
+export function decideTurnAdmission(conversations, activeTurnsByConversation, conversationId, maxConcurrentTurns = MAX_CONCURRENT_TURNS) {
+    if (conversationActiveRequestId(activeTurnsByConversation, conversationId)) {
+        return { admit: false, reason: 'conversation_busy' };
+    }
+    if ((conversations[conversationId]?.pendingTurns?.length ?? 0) > 0) {
+        return { admit: false, reason: 'conversation_queued' };
+    }
+    if (activeTurnCount(activeTurnsByConversation) >= maxConcurrentTurns) {
+        return { admit: false, reason: 'ceiling' };
+    }
+    return { admit: true };
+}
+/**
+ * The oldest queued turn in a conversation that could actually run right now.
+ *
+ * The old drain took the globally oldest queued turn and ran it only when NOTHING was
+ * active. With per-conversation turns that starves every other conversation behind one
+ * long-running turn, so the candidate set is filtered by the same admission rule.
+ */
+/**
+ * 🔴 COMPLETION MATCHING, and this is the function the whole design rests on.
+ *
+ * It releases the slot held BY THIS requestId, wherever it is — never "the current slot".
+ * That distinction is the entire bug the global field had: with one scalar, completing the
+ * SECOND turn freed the lock while the FIRST was still streaming, and the first completing
+ * later matched nothing and freed nothing. Keyed by requestId, a late or out-of-order
+ * terminal event can only ever free its own turn, and a stale one frees nothing.
+ *
+ * Returns the SAME object when there is nothing to release, so an unrelated terminal event
+ * cannot invalidate referential equality and churn every subscriber.
+ */
+export function releaseTurnSlot(activeTurnsByConversation, requestId) {
+    const owner = Object.keys(activeTurnsByConversation)
+        .find((conversationId) => activeTurnsByConversation[conversationId] === requestId);
+    if (!owner)
+        return activeTurnsByConversation;
+    const next = { ...activeTurnsByConversation };
+    delete next[owner];
+    return next;
+}
+/**
+ * Release whatever slot a conversation holds, because the conversation itself is going away.
+ *
+ * ⚠️ Without this, deleting a conversation mid-turn leaks its slot FOREVER: the map entry
+ * survives, no terminal event can ever arrive for a conversation that no longer exists, and
+ * the ceiling silently tightens by one every time it happens until nothing may start at all.
+ * The old global lock had no equivalent failure because it was cleared by conversation
+ * identity on the same path.
+ */
+export function releaseConversationSlot(activeTurnsByConversation, conversationId) {
+    if (!(conversationId in activeTurnsByConversation))
+        return activeTurnsByConversation;
+    const next = { ...activeTurnsByConversation };
+    delete next[conversationId];
+    return next;
+}
+export function findOldestAdmissibleQueuedTurn(conversations, activeTurnsByConversation, maxConcurrentTurns = MAX_CONCURRENT_TURNS) {
+    if (activeTurnCount(activeTurnsByConversation) >= maxConcurrentTurns)
+        return null;
+    let oldest = null;
+    for (const [conversationId, conversation] of Object.entries(conversations)) {
+        // A conversation with a live turn waits; its own queue drains in order behind it.
+        if (conversationActiveRequestId(activeTurnsByConversation, conversationId))
+            continue;
+        for (const turn of conversation.pendingTurns || []) {
+            if (!oldest || turn.queuedAt < oldest.turn.queuedAt)
+                oldest = { conversationId, turn };
+        }
+    }
+    return oldest;
+}
 function generateTitle(content) {
     const clean = content.replace(/\n/g, ' ').slice(0, 30);
     return clean.length < content.length ? `${clean}...` : clean;
@@ -1618,6 +1714,7 @@ function reconcileRuntimeToolEvent(messages, requestId, event) {
     const isToolTerminal = event.type === 'tool.completed'
         || event.type === 'acp.tool.completed'
         || event.type === 'acp.tool.failed';
+    const hasToolOutputUpdate = event.type === 'acp.tool.updated' && event.rawOutput !== undefined;
     // ACP `tool_call_update` notifications are allowed to carry only the
     // stable toolCallId and terminal status. The started event already owns the
     // human title. Requiring the title again here leaves the real card running,
@@ -1626,7 +1723,7 @@ function reconcileRuntimeToolEvent(messages, requestId, event) {
     // shape a progress-only update takes. Requiring a title here dropped every such
     // frame, so an in-flight job reported by a well-behaved agent was invisible for
     // the same reason a completion without a title used to close the wrong card.
-    if (!toolName && !(toolCallId && (isToolTerminal || eventWebJobProgress)))
+    if (!toolName && !(toolCallId && (isToolTerminal || eventWebJobProgress || hasToolOutputUpdate)))
         return messages;
     const resolvedToolName = toolName || 'ACP Tool';
     if (event.type === 'tool.started' || event.type === 'acp.tool.started') {
@@ -1672,7 +1769,7 @@ function reconcileRuntimeToolEvent(messages, requestId, event) {
     // tool call is touched here: status, result and outcome stay exactly where the
     // started and terminal branches put them, so a tool with no progress behaves as
     // it did before this branch existed.
-    if (!isToolTerminal && eventWebJobProgress) {
+    if (!isToolTerminal && (eventWebJobProgress || hasToolOutputUpdate)) {
         return messages.map((message) => {
             if (message.id !== requestId)
                 return message;
@@ -1683,9 +1780,13 @@ function reconcileRuntimeToolEvent(messages, requestId, event) {
                 : reversed.find((toolCall) => (normalizeToolName(toolCall.toolName) === normalizeToolName(resolvedToolName) && toolCall.status === 'running'));
             if (!target)
                 return message;
+            // A delayed progress frame cannot reopen or overwrite a completed tool.
+            if (target.status !== 'running')
+                return message;
             const merged = normalizeToolCall({
                 ...target,
-                webJobProgress: eventWebJobProgress,
+                ...(eventWebJobProgress ? { webJobProgress: eventWebJobProgress } : {}),
+                ...(hasToolOutputUpdate ? { result: getRuntimeEventOutput(event) } : {}),
             }, target);
             return {
                 ...message,
@@ -2710,8 +2811,12 @@ export const useAgentChatStore = create((set, get) => {
     let queueDrainMicrotaskScheduled = false;
     const runQueueDrain = () => {
         const state = get();
-        if (state.activeRequestId && findOldestQueuedTurn(state.conversations)) {
-            scheduleQueueDrain(250);
+        /* Retry while work exists that cannot run YET — a conversation still busy, or the ceiling
+         * full. The old test was "is anything active at all", which parked the queue behind any
+         * single turn anywhere; this parks it only behind the thing actually blocking it. */
+        if (!findOldestAdmissibleQueuedTurn(state.conversations, state.activeTurnsByConversation)) {
+            if (findOldestQueuedTurn(state.conversations))
+                scheduleQueueDrain(250);
             return;
         }
         get().resumeQueuedTurns();
@@ -3195,6 +3300,8 @@ export const useAgentChatStore = create((set, get) => {
                     ...state.conversations,
                     [conversationId]: updated
                 },
+                // The map is the authority; the two scalars below stay as the FOREGROUND turn.
+                activeTurnsByConversation: { ...state.activeTurnsByConversation, [conversationId]: requestId },
                 activeRequestId: requestId,
                 activeConversationId: conversationId
             };
@@ -3333,6 +3440,7 @@ export const useAgentChatStore = create((set, get) => {
                     execution: acpExecution,
                     contextCompaction: compactedContext.stats,
                     providerModel: options?.acpProviderModel,
+                    reasoningOptionId: runtime.reasoning.optionId,
                     ...(resumableAcpBinding
                         ? {
                             resumeSessionId: conv?.sessionUi?.acpSessionId,
@@ -3399,6 +3507,7 @@ export const useAgentChatStore = create((set, get) => {
                 requestId,
                 conversationId,
                 providerKind: 'xeno-cloud',
+                reasoningOptionId: runtime.reasoning.optionId,
                 mode: agentRunMode,
                 workspaceId: conv?.workspaceId,
                 teamId: conv?.teamId,
@@ -3463,6 +3572,7 @@ export const useAgentChatStore = create((set, get) => {
                     requestId,
                     conversationId,
                     sdkSessionId: conv?.sessionUi?.sdkSessionId,
+                    reasoningOptionId: runtime.reasoning.optionId,
                     subagentRunId,
                     workspaceId: conv?.workspaceId,
                     teamId: conv?.teamId,
@@ -3526,6 +3636,7 @@ export const useAgentChatStore = create((set, get) => {
             if (!conversationId) {
                 return {
                     ...state,
+                    activeTurnsByConversation: releaseTurnSlot(state.activeTurnsByConversation, requestId),
                     activeRequestId: state.activeRequestId === requestId ? null : state.activeRequestId,
                     activeConversationId: state.activeRequestId === requestId ? null : state.activeConversationId
                 };
@@ -3549,6 +3660,7 @@ export const useAgentChatStore = create((set, get) => {
                     ...state.conversations,
                     [conversationId]: updated
                 },
+                activeTurnsByConversation: releaseTurnSlot(state.activeTurnsByConversation, requestId),
                 activeRequestId: state.activeRequestId === requestId ? null : state.activeRequestId,
                 activeConversationId: state.activeRequestId === requestId ? null : state.activeConversationId
             };
@@ -3625,6 +3737,8 @@ export const useAgentChatStore = create((set, get) => {
                     ...state.conversations,
                     [conversationId]: updated
                 },
+                // The map is the authority; the two scalars below stay as the FOREGROUND turn.
+                activeTurnsByConversation: { ...state.activeTurnsByConversation, [conversationId]: requestId },
                 activeRequestId: requestId,
                 activeConversationId: conversationId
             };
@@ -3701,6 +3815,7 @@ export const useAgentChatStore = create((set, get) => {
             ];
             try {
                 const existingFileResult = await getAgentPlatformBridge().workspace.readFile({
+                    conversationId,
                     path: targetPath,
                     allowedDirs: allowedDirectoriesForWrite
                 });
@@ -3755,6 +3870,7 @@ export const useAgentChatStore = create((set, get) => {
                     });
                 }
                 const writeResult = await getAgentPlatformBridge().workspace.writeFile({
+                    conversationId,
                     path: targetPath,
                     content: fileCreate.content,
                     allowedDirs: allowedDirectoriesForWrite
@@ -3815,11 +3931,70 @@ export const useAgentChatStore = create((set, get) => {
     };
     return {
         conversations: {},
+        activeTurnsByConversation: {},
         activeRequestId: null,
         activeConversationId: null,
         cloudRunEnabled: false,
         cloudRuns: {},
+        activeNotifications: {},
+        availableCommands: {},
+        mcpStatuses: {},
         setCloudRunEnabled: (enabled) => set({ cloudRunEnabled: enabled }),
+        dismissNotification: (conversationId, notificationIdOrKey) => {
+            set((state) => {
+                const convNotifs = { ...(state.activeNotifications[conversationId] || {}) };
+                let matchedKey = notificationIdOrKey;
+                if (convNotifs[notificationIdOrKey]) {
+                    delete convNotifs[notificationIdOrKey];
+                }
+                for (const [k, notif] of Object.entries(convNotifs)) {
+                    if (notif.id === notificationIdOrKey || notif.deduplicationKey === notificationIdOrKey) {
+                        matchedKey = notif.deduplicationKey || notif.id;
+                        delete convNotifs[k];
+                    }
+                }
+                const conv = state.conversations[conversationId];
+                if (conv) {
+                    const dismissedKeys = Array.from(new Set([...(conv.dismissedNotificationKeys || []), matchedKey, notificationIdOrKey]));
+                    const updatedConv = {
+                        ...conv,
+                        activeNotifications: convNotifs,
+                        dismissedNotificationKeys: dismissedKeys,
+                    };
+                    persistConversation(updatedConv);
+                    return {
+                        activeNotifications: {
+                            ...state.activeNotifications,
+                            [conversationId]: convNotifs,
+                        },
+                        conversations: {
+                            ...state.conversations,
+                            [conversationId]: updatedConv,
+                        },
+                    };
+                }
+                return {
+                    activeNotifications: {
+                        ...state.activeNotifications,
+                        [conversationId]: convNotifs,
+                    },
+                };
+            });
+        },
+        clearNotifications: (conversationId) => {
+            set((state) => {
+                const { [conversationId]: _, ...rest } = state.activeNotifications;
+                return { activeNotifications: rest };
+            });
+        },
+        setAvailableCommands: (conversationId, commands) => {
+            set((state) => ({
+                availableCommands: {
+                    ...state.availableCommands,
+                    [conversationId]: commands,
+                },
+            }));
+        },
         getConversation: (conversationId) => get().conversations[conversationId],
         getConversationRuntimeProjection: (conversationId) => {
             const conversation = get().conversations[conversationId];
@@ -4232,6 +4407,10 @@ export const useAgentChatStore = create((set, get) => {
                 const isActive = state.activeConversationId === conversationId;
                 return {
                     conversations: next,
+                    // Keyed by the conversation, not by `isActive`: a BACKGROUND conversation being
+                    // deleted mid-turn also holds a slot, and that is precisely the case the foreground
+                    // scalars cannot see.
+                    activeTurnsByConversation: releaseConversationSlot(state.activeTurnsByConversation, conversationId),
                     activeConversationId: isActive ? null : state.activeConversationId,
                     activeRequestId: isActive ? null : state.activeRequestId
                 };
@@ -4262,7 +4441,7 @@ export const useAgentChatStore = create((set, get) => {
                 ...options,
                 allowedDirectories: workspaceBinding.mode === 'workspace' ? workspaceBinding.allowedDirectories : [],
             };
-            if (get().activeRequestId || findOldestQueuedTurn(get().conversations)) {
+            if (!decideTurnAdmission(get().conversations, get().activeTurnsByConversation, conversationId).admit) {
                 logRendererAgentDebug('sendMessage queued', {
                     conversationId,
                     agentId,
@@ -4296,7 +4475,7 @@ export const useAgentChatStore = create((set, get) => {
                 acpAgentConfigId,
                 allowedDirectories: workspaceBinding.mode === 'workspace' ? workspaceBinding.allowedDirectories : [],
             };
-            if (get().activeRequestId || findOldestQueuedTurn(get().conversations)) {
+            if (!decideTurnAdmission(get().conversations, get().activeTurnsByConversation, conversationId).admit) {
                 logRendererAgentDebug('sendAcpMessage queued', {
                     conversationId,
                     agentId,
@@ -4327,7 +4506,7 @@ export const useAgentChatStore = create((set, get) => {
                 return;
             }
             const scopedOptions = { ...options, allowedDirectories: workspaceBinding.allowedDirectories };
-            if (get().activeRequestId || findOldestQueuedTurn(get().conversations)) {
+            if (!decideTurnAdmission(get().conversations, get().activeTurnsByConversation, conversationId).admit) {
                 logRendererAgentDebug('sendDeterministicFileCreate queued', {
                     conversationId,
                     agentId,
@@ -4513,6 +4692,48 @@ export const useAgentChatStore = create((set, get) => {
                     },
                     lastMessageAt: Date.now()
                 };
+                let nextActiveNotifications = state.activeNotifications;
+                if (eventWithRequest.type === 'acp.notification' && eventWithRequest.notification) {
+                    const notif = eventWithRequest.notification;
+                    const conv = state.conversations[conversationId];
+                    const key = notif.deduplicationKey || notif.id;
+                    const isDismissed = conv?.dismissedNotificationKeys?.includes(key)
+                        || conv?.dismissedNotificationKeys?.includes(notif.id);
+                    if (!isDismissed) {
+                        const convNotifs = { ...(state.activeNotifications[conversationId] || {}) };
+                        convNotifs[key] = notif;
+                        nextActiveNotifications = {
+                            ...state.activeNotifications,
+                            [conversationId]: convNotifs,
+                        };
+                    }
+                }
+                let nextAvailableCommands = state.availableCommands;
+                if (eventWithRequest.type === 'acp.commands.update' && Array.isArray(eventWithRequest.availableCommands)) {
+                    nextAvailableCommands = {
+                        ...state.availableCommands,
+                        [conversationId]: eventWithRequest.availableCommands,
+                    };
+                }
+                let nextMcpStatuses = state.mcpStatuses;
+                if (eventWithRequest.type === 'acp.mcp.update' && eventWithRequest.mcpStatus) {
+                    const mcp = eventWithRequest.mcpStatus;
+                    const convMcp = { ...(state.mcpStatuses[conversationId] || {}) };
+                    convMcp[mcp.server] = mcp;
+                    nextMcpStatuses = {
+                        ...state.mcpStatuses,
+                        [conversationId]: convMcp,
+                    };
+                }
+                if (nextActiveNotifications[conversationId]) {
+                    updated.activeNotifications = nextActiveNotifications[conversationId];
+                }
+                if (nextAvailableCommands[conversationId]) {
+                    updated.availableCommands = nextAvailableCommands[conversationId];
+                }
+                if (nextMcpStatuses[conversationId]) {
+                    updated.mcpStatuses = nextMcpStatuses[conversationId];
+                }
                 if (isRuntimeTurnTerminal(eventWithRequest)) {
                     persistConversation(updated);
                 }
@@ -4524,6 +4745,17 @@ export const useAgentChatStore = create((set, get) => {
                         ...state.conversations,
                         [conversationId]: updated
                     },
+                    activeNotifications: nextActiveNotifications,
+                    availableCommands: nextAvailableCommands,
+                    mcpStatuses: nextMcpStatuses,
+                    /* 🔴 Released on the requestId ALONE, deliberately not on `state.activeRequestId ===
+                     * requestId` like the two scalars below. A terminal event for a BACKGROUND turn never
+                     * matches the foreground scalar, so gating the map on it would leak that turn's slot
+                     * permanently — the exact asymmetry that makes a single global field unable to
+                     * represent two live turns. */
+                    activeTurnsByConversation: isRuntimeTurnTerminal(eventWithRequest)
+                        ? releaseTurnSlot(state.activeTurnsByConversation, requestId)
+                        : state.activeTurnsByConversation,
                     activeRequestId: isRuntimeTurnTerminal(eventWithRequest) && state.activeRequestId === requestId ? null : state.activeRequestId,
                     activeConversationId: isRuntimeTurnTerminal(eventWithRequest) && state.activeRequestId === requestId ? null : state.activeConversationId,
                 };
@@ -4940,6 +5172,7 @@ export const useAgentChatStore = create((set, get) => {
                         ...state.conversations,
                         [conversationId]: updated
                     },
+                    activeTurnsByConversation: releaseTurnSlot(state.activeTurnsByConversation, requestId),
                     activeRequestId: state.activeRequestId === requestId ? null : state.activeRequestId,
                     activeConversationId: state.activeRequestId === requestId ? null : state.activeConversationId
                 };
@@ -4957,11 +5190,26 @@ export const useAgentChatStore = create((set, get) => {
             const convId = findConversationIdForRequest(get().conversations, requestId, get().activeConversationId);
             set(state => {
                 const conversationId = findConversationIdForRequest(state.conversations, requestId, state.activeConversationId);
-                if (!conversationId)
-                    return state;
-                const conv = state.conversations[conversationId];
-                if (!conv)
-                    return state;
+                const conv = conversationId ? state.conversations[conversationId] : undefined;
+                if (!conversationId || !conv) {
+                    /* Release the turn lock even though there is nothing to render on.
+                     *
+                     * `findConversationIdForRequest` matches on a MESSAGE carrying this
+                     * requestId, so a turn that failed before its assistant placeholder
+                     * existed resolves to null -- which is precisely what a provider that
+                     * accepts a prompt and then says nothing produces. Returning `state`
+                     * here would leave `activeRequestId` held forever, and because the busy
+                     * check is global that wedges EVERY conversation, including ones that
+                     * have never run anything.
+                     *
+                     * There is no path on which "nothing happened" is a valid resting state
+                     * for a failed turn. */
+                    return {
+                        activeTurnsByConversation: releaseTurnSlot(state.activeTurnsByConversation, requestId),
+                        activeRequestId: state.activeRequestId === requestId ? null : state.activeRequestId,
+                        activeConversationId: state.activeRequestId === requestId ? null : state.activeConversationId
+                    };
+                }
                 const updated = {
                     ...conv,
                     messages: conv.messages.map(m => m.id === requestId
@@ -4995,6 +5243,7 @@ export const useAgentChatStore = create((set, get) => {
                         ...state.conversations,
                         [conversationId]: updated
                     },
+                    activeTurnsByConversation: releaseTurnSlot(state.activeTurnsByConversation, requestId),
                     activeRequestId: state.activeRequestId === requestId ? null : state.activeRequestId,
                     activeConversationId: state.activeRequestId === requestId ? null : state.activeConversationId
                 };
@@ -5009,9 +5258,11 @@ export const useAgentChatStore = create((set, get) => {
         },
         resumeQueuedTurns: () => {
             const state = get();
-            if (state.activeRequestId)
-                return;
-            const next = findOldestQueuedTurn(state.conversations);
+            /* 🔴 No `if (state.activeRequestId) return` any more. That single line was what made the
+             * queue global: one live turn anywhere held every other conversation's queued work, even
+             * work that could have run immediately. Admissibility is now decided per conversation,
+             * under the ceiling, by the same rule that admits a fresh send. */
+            const next = findOldestAdmissibleQueuedTurn(state.conversations, state.activeTurnsByConversation);
             if (!next)
                 return;
             if (next.turn.kind === 'deterministic_file_create') {
@@ -5039,8 +5290,14 @@ export const useAgentChatStore = create((set, get) => {
                 runtime: next.turn.runtime,
             });
         },
-        abort: () => {
-            const { activeRequestId } = get();
+        abort: (targetConversationId) => {
+            /* Prefer the turn running in the NAMED conversation; fall back to the foreground turn
+             * only when no conversation was given. Reading the global scalar unconditionally would
+             * cancel whichever turn started most recently, which under concurrency is very often not
+             * the one whose Stop button was pressed. */
+            const activeRequestId = targetConversationId
+                ? conversationActiveRequestId(get().activeTurnsByConversation, targetConversationId)
+                : get().activeRequestId;
             if (!activeRequestId)
                 return;
             const conversationId = findConversationIdForRequest(get().conversations, activeRequestId, get().activeConversationId);
@@ -5109,6 +5366,36 @@ export function setupAgentChatListeners() {
     const hasNativeEquivalentRuntimeEvent = (requestId, event) => {
         return hasRuntimeEventDedupFamily(nativeRuntimeEventFamiliesByRequest.get(requestId), event);
     };
+    /**
+     * Terminal transition for a failed turn, reachable from EVERY error channel.
+     *
+     * 🔴 Finalisation is deliberately NOT behind `legacyCallbackRuntimeEventsEnabled`.
+     * That flag decides whether a legacy runtime event is DISPLAYED; it must never
+     * decide whether a failed turn is FINALISED. It used to: both error handlers did
+     * nothing but call `appendCallbackRuntimeEvent`, whose first line returns early
+     * when the flag is off -- and the flag is off unless DEV *and* a localStorage key
+     * is set. So in every real build a failed turn released nothing, rendered nothing,
+     * and held `activeRequestId` forever. Because the busy check is global, that one
+     * dead turn queued every other conversation, including brand-new ones.
+     *
+     * The signal was never missing: the host publishes `turn.execution.abandoned` /
+     * `.failed` (and arms the same path from its own deadlines), and
+     * `agentHostPlatformBridge` already converts both into these error listeners.
+     * Only this last link was broken.
+     *
+     * Idempotent and first-writer-wins via `nativeRuntimeTerminalRequestIds`, so a
+     * native terminal event and a callback for the same turn cannot double-finalise.
+     */
+    const finalizeFailedTurn = (requestId, error, context) => {
+        if (nativeRuntimeTerminalRequestIds.has(requestId))
+            return;
+        nativeRuntimeTerminalRequestIds.add(requestId);
+        // Display-only, and still gated exactly as before.
+        appendCallbackRuntimeEvent(requestId, createLegacyTurnFailedRuntimeEvent({ requestId, error, context }));
+        // Correctness: renders the error, clears streaming, releases the turn lock,
+        // persists, and drains the queue. Never gated.
+        useAgentChatStore.getState().setStreamError(requestId, error);
+    };
     const appendCallbackRuntimeEvent = (requestId, event) => {
         if (!legacyCallbackRuntimeEventsEnabled) {
             return false;
@@ -5175,14 +5462,7 @@ export function setupAgentChatListeners() {
             }
         });
         getAgentPlatformBridge().llm.onChatError((data) => {
-            if (!nativeRuntimeTerminalRequestIds.has(data.requestId)) {
-                nativeRuntimeTerminalRequestIds.add(data.requestId);
-                appendCallbackRuntimeEvent(data.requestId, createLegacyTurnFailedRuntimeEvent({
-                    requestId: data.requestId,
-                    error: data.error,
-                    context: 'llm',
-                }));
-            }
+            finalizeFailedTurn(data.requestId, data.error, 'llm');
         });
         getAgentPlatformBridge().llm.onToolCall((data) => {
             if (data.status === 'start') {
@@ -5399,14 +5679,7 @@ export function setupAgentChatListeners() {
                 error: displayError,
                 context: data.context
             });
-            if (!nativeRuntimeTerminalRequestIds.has(data.requestId)) {
-                nativeRuntimeTerminalRequestIds.add(data.requestId);
-                appendCallbackRuntimeEvent(data.requestId, createLegacyTurnFailedRuntimeEvent({
-                    requestId: data.requestId,
-                    error: displayError,
-                    context: data.context,
-                }));
-            }
+            finalizeFailedTurn(data.requestId, displayError, data.context);
         });
     }
     if (getAgentPlatformBridge()?.agentsCloud) {
@@ -5561,12 +5834,33 @@ export async function loadLocalAgentConversations() {
                 })),
                 branches: normalizeConversationBranches(conv.branches),
                 materializedBranches: { ...(conv.materializedBranches || {}) },
+                activeNotifications: conv.activeNotifications,
+                availableCommands: conv.availableCommands,
+                mcpStatuses: conv.mcpStatuses,
+                dismissedNotificationKeys: conv.dismissedNotificationKeys,
                 sessionUi
             };
         }
         if (Object.keys(loaded).length > 0) {
+            const persistedNotifs = {};
+            const persistedCommands = {};
+            const persistedMcp = {};
+            for (const [id, c] of Object.entries(loaded)) {
+                if (c.activeNotifications && Object.keys(c.activeNotifications).length > 0) {
+                    persistedNotifs[id] = c.activeNotifications;
+                }
+                if (c.availableCommands && c.availableCommands.length > 0) {
+                    persistedCommands[id] = c.availableCommands;
+                }
+                if (c.mcpStatuses && Object.keys(c.mcpStatuses).length > 0) {
+                    persistedMcp[id] = c.mcpStatuses;
+                }
+            }
             useAgentChatStore.setState(state => ({
-                conversations: { ...loaded, ...state.conversations }
+                conversations: { ...loaded, ...state.conversations },
+                activeNotifications: { ...persistedNotifs, ...state.activeNotifications },
+                availableCommands: { ...persistedCommands, ...state.availableCommands },
+                mcpStatuses: { ...persistedMcp, ...state.mcpStatuses },
             }));
             window.setTimeout(() => {
                 useAgentChatStore.getState().resumeQueuedTurns();