@guildai/cli 0.12.0 → 0.12.1

package/dist/{chunk-IBRKVGMZ.js → chunk-7JJT3RNI.js}

@@ -4,7 +4,7 @@ import {
   Option,
   getOutputMode,
   isQuietMode
-} from "./chunk-DOIYVBNY.js";
+} from "./chunk-YQWI6SUV.js";
 import {
   open_default
 } from "./chunk-56YCMGL3.js";
@@ -14,6 +14,7 @@ import {
   fetchTasks,
   getAgentName,
   getAgentNotificationText,
+  getEventAgentName,
   getTaskDisplayName,
   isDoneResponseStreamEvent,
   isFilteredTaskName,
@@ -21,7 +22,7 @@ import {
   isRootTaskEvent,
   isUnfulfilledAgentInstallRequest,
   pollForOnce
-} from "./chunk-SPZPZXUN.js";
+} from "./chunk-F3F5CUO3.js";
 import {
   DEFAULT_EVENT_TYPES,
   GuildAPIClient,
@@ -29,7 +30,7 @@ import {
   getWorkspaceSourceLabel,
   parseEventFilter,
   shouldShowEvent
-} from "./chunk-RIG2HZWM.js";
+} from "./chunk-RJHD6XTV.js";
 import {
   BRAND_COLOR,
   ErrorCodes,
@@ -54,7 +55,7 @@ import {
   source_default,
   stringWidth,
   stripAnsi
-} from "./chunk-LFMQJOKC.js";
+} from "./chunk-JQRJ4A4S.js";
 import {
   require_ansi_styles,
   require_is_fullwidth_code_point
@@ -87752,18 +87753,28 @@ function sanitizeTab(tab2, fallbackTab) {
   }
 }
 
-// src/lib/session-resume.ts
+// src/lib/markdown.ts
 marked.use(markedTerminal({}, { theme: {} }));
-function renderMarkdown(text) {
-  let rendered = marked.parse(text);
-  rendered = rendered.replace(/\*\*([^*]+)\*\*/g, (_, content) => source_default.bold(content));
-  rendered = rendered.replace(/`([^`]+)`/g, (_, content) => code(content));
-  rendered = rendered.replace(
+function fixListItemMarkdown(text) {
+  text = text.replace(/\*\*([^*]+)\*\*/g, (_, content) => source_default.bold(content));
+  text = text.replace(/`([^`]+)`/g, (_, content) => code(content));
+  text = text.replace(
     /(?<![\\w])_([^_]+)_(?![\\w])/g,
     (_, content) => source_default.italic(content)
   );
-  return rendered;
+  return text;
+}
+function renderMarkdownSync(content) {
+  const rendered = marked.parse(content);
+  return fixListItemMarkdown(rendered);
+}
+function renderAssistantMessageContent(text, taskName) {
+  const rendered = renderMarkdownSync(text);
+  return `${source_default.green("\u25CF")} ${source_default.bold(taskName)}
+  ${rendered.trim().split("\n").join("\n  ")}`;
 }
+
+// src/lib/session-resume.ts
 function printResumeHint(sessionId, command) {
   console.error("");
   console.error(source_default.dim("[Session interrupted]"));
@@ -87777,19 +87788,22 @@ async function fetchSession(client, sessionId) {
   const session = await client.get(`/sessions/${sessionId}`);
   return session;
 }
-function renderAssistantText(key, text, timestamp) {
-  const rendered = renderMarkdown(text);
-  const messageContent = `${source_default.green("\u25CF")} ${source_default.bold("assistant")}
-${rendered.trim()}`;
+function renderAssistantText(key, text, timestamp, taskName) {
   return {
     key,
-    content: messageContent,
+    content: renderAssistantMessageContent(text, taskName),
     type: "assistant",
     timestamp
   };
 }
 function textMatches(left, right) {
-  return left === right;
+  return left.trim() === right.trim();
+}
+function isTerminalTaskStatus(status) {
+  return status === "DONE" || status === "ERROR" || status === "INTERRUPTED";
+}
+function shouldTrackResumeEntry(entry) {
+  return !isTerminalTaskStatus(entry.taskStatus);
 }
 function formatDisplayTimestamp(timestamp) {
   if (timestamp === void 0) return void 0;
@@ -87857,7 +87871,9 @@ function collectResponseStreamResumeEntries(events) {
         text,
         status: latest.content.status,
         timestamp: formatDisplayTimestamp(latest.created_at),
-        taskId
+        taskId,
+        taskName: getEventAgentName(latest),
+        taskStatus: latest.task?.status
       });
     }
   }
@@ -87873,6 +87889,7 @@ function responseStreamResumeStateFromEntries(entries) {
     keysByTask: /* @__PURE__ */ new Map()
   };
   for (const entry of entries) {
+    if (!shouldTrackResumeEntry(entry)) continue;
     state.keys.set(entry.streamId, entry.key);
     state.contents.set(entry.streamId, entry.contents);
     state.texts.set(entry.streamId, entry.text);
@@ -87911,21 +87928,34 @@ function eventsToDisplayMessagesWithResponseStreamEntries(events, responseStream
         if (!streamEntry) continue;
         renderedResponseStreamIds.add(streamId);
         messages.push(
-          renderAssistantText(streamEntry.key, streamEntry.text, streamEntry.timestamp)
+          renderAssistantText(
+            streamEntry.key,
+            streamEntry.text,
+            streamEntry.timestamp,
+            streamEntry.taskName
+          )
         );
         continue;
       }
       const text = getAgentNotificationText(event);
       if (text.trim()) {
-        messages.push(renderAssistantText(event.id, text, event.created_at));
+        messages.push(
+          renderAssistantText(
+            event.id,
+            text,
+            event.created_at,
+            getEventAgentName(event)
+          )
+        );
       }
     } else if (event.type === "agent_notification_error") {
       const text = typeof event.content === "string" ? event.content : event.content?.data || "";
       if (text.trim()) {
+        const taskName = getEventAgentName(event);
         messages.push({
           key: event.id,
-          content: `${source_default.red("\u25CF")} ${source_default.bold("assistant")}
-${source_default.red(text)}`,
+          content: `${source_default.red("\u25CF")} ${source_default.bold(taskName)}
+  ${source_default.red(text)}`,
           type: "assistant",
           timestamp: event.created_at
         });
@@ -87945,6 +87975,165 @@ function prepareSessionResumeDisplay(events) {
   };
 }
 
+// src/lib/response-stream-display-state.ts
+function deleteTrackedResponseStream(state, streamId) {
+  state.keys.delete(streamId);
+  state.contents.delete(streamId);
+  state.texts.delete(streamId);
+  state.timestamps.delete(streamId);
+  state.statuses.delete(streamId);
+}
+function updateTaskKeys(state, taskId, inactiveKeys) {
+  const keys = state.keysByTask.get(taskId);
+  if (!keys?.size) return;
+  const remainingKeys = new Set([...keys].filter((key) => !inactiveKeys.has(key)));
+  if (remainingKeys.size > 0) {
+    state.keysByTask.set(taskId, remainingKeys);
+  } else {
+    state.keysByTask.delete(taskId);
+  }
+}
+function textMatchesForDisplay(left, right) {
+  if (left === void 0 || right === void 0) return false;
+  return left.trim() === right.trim();
+}
+function splitResponseStreamDisplayMessages(displayMessages, responseStreamState) {
+  const responseStreamKeys = new Set(responseStreamState?.keys.values() ?? []);
+  const firstActiveIndex = displayMessages.findIndex(
+    (message) => responseStreamKeys.has(message.key)
+  );
+  if (firstActiveIndex === -1) {
+    return {
+      transcriptMessages: displayMessages,
+      dynamicMessages: [],
+      activeMessages: []
+    };
+  }
+  const dynamicMessages = displayMessages.slice(firstActiveIndex);
+  return {
+    transcriptMessages: displayMessages.slice(0, firstActiveIndex),
+    dynamicMessages,
+    activeMessages: dynamicMessages.filter(
+      (message) => responseStreamKeys.has(message.key)
+    )
+  };
+}
+function createActiveResponseStreamMessageMap(messages) {
+  return new Map(messages.map((message) => [message.key, message]));
+}
+function upsertDynamicResponseStreamMessage(dynamicMessages, activeMessagesByKey, message) {
+  const existingIndex = dynamicMessages.findIndex((item) => item.key === message.key);
+  if (existingIndex === -1) {
+    activeMessagesByKey.set(message.key, message);
+    return [...dynamicMessages, message];
+  }
+  const currentMessage = dynamicMessages[existingIndex];
+  if (currentMessage?.content === message.content && currentMessage.type === message.type && currentMessage.timestamp === message.timestamp) {
+    activeMessagesByKey.set(message.key, currentMessage);
+    return dynamicMessages;
+  }
+  activeMessagesByKey.set(message.key, message);
+  const nextMessages = [...dynamicMessages];
+  nextMessages[existingIndex] = message;
+  return nextMessages;
+}
+function removeDynamicResponseStreamMessages(dynamicMessages, activeMessagesByKey, keys) {
+  const affectedMessages = [];
+  for (const key of keys) {
+    const message = activeMessagesByKey.get(key);
+    if (message) affectedMessages.push(message);
+    activeMessagesByKey.delete(key);
+  }
+  return {
+    dynamicMessages: dynamicMessages.filter((message) => !keys.has(message.key)),
+    affectedMessages
+  };
+}
+function commitDynamicResponseStreamMessages(dynamicMessages, activeMessagesByKey, keys) {
+  const affectedMessages = [];
+  for (const key of keys) {
+    const message = activeMessagesByKey.get(key);
+    if (message) affectedMessages.push(message);
+    activeMessagesByKey.delete(key);
+  }
+  if (affectedMessages.length === 0) {
+    return {
+      dynamicMessages,
+      committedMessages: [],
+      affectedMessages
+    };
+  }
+  const existingKeys = new Set(dynamicMessages.map((message) => message.key));
+  const committedMessages = affectedMessages.filter(
+    (message) => !existingKeys.has(message.key)
+  );
+  return {
+    dynamicMessages: committedMessages.length > 0 ? [...dynamicMessages, ...committedMessages] : dynamicMessages,
+    committedMessages,
+    affectedMessages
+  };
+}
+function flushDynamicMessagesIntoTranscript(transcriptMessages, dynamicMessages) {
+  if (dynamicMessages.length === 0) return transcriptMessages;
+  const existingKeys = new Set(transcriptMessages.map((message) => message.key));
+  const newMessages = dynamicMessages.filter(
+    (message) => !existingKeys.has(message.key)
+  );
+  return newMessages.length > 0 ? [...transcriptMessages, ...newMessages] : transcriptMessages;
+}
+function abortTrackedResponseStream(state, streamId, taskId) {
+  const key = state.keys.get(streamId);
+  const removedKeys = key ? /* @__PURE__ */ new Set([key]) : /* @__PURE__ */ new Set();
+  deleteTrackedResponseStream(state, streamId);
+  if (taskId) updateTaskKeys(state, taskId, removedKeys);
+  return removedKeys;
+}
+function clearTrackedResponseStreamsForTask(state, taskId, options2 = {}) {
+  const removedKeys = /* @__PURE__ */ new Set();
+  const detachedKeys = /* @__PURE__ */ new Set();
+  if (!taskId) return { removedKeys, detachedKeys };
+  const keys = state.keysByTask.get(taskId);
+  if (!keys?.size) return { removedKeys, detachedKeys };
+  for (const [streamId, key] of state.keys.entries()) {
+    if (!keys.has(key)) continue;
+    if (options2.preserveContinued && state.statuses.get(streamId) === "continued" && !textMatchesForDisplay(state.texts.get(streamId), options2.finalText)) {
+      deleteTrackedResponseStream(state, streamId);
+      detachedKeys.add(key);
+      continue;
+    }
+    deleteTrackedResponseStream(state, streamId);
+    removedKeys.add(key);
+  }
+  updateTaskKeys(state, taskId, /* @__PURE__ */ new Set([...removedKeys, ...detachedKeys]));
+  return { removedKeys, detachedKeys };
+}
+function commitTerminalTrackedResponseStreamsForTask(state, taskId) {
+  const committedKeys = /* @__PURE__ */ new Set();
+  if (!taskId) return committedKeys;
+  const keys = state.keysByTask.get(taskId);
+  if (!keys?.size) return committedKeys;
+  for (const [streamId, key] of state.keys.entries()) {
+    if (!keys.has(key)) continue;
+    if (state.statuses.get(streamId) === "streaming") continue;
+    deleteTrackedResponseStream(state, streamId);
+    committedKeys.add(key);
+  }
+  updateTaskKeys(state, taskId, committedKeys);
+  return committedKeys;
+}
+function commitAllTerminalTrackedResponseStreams(state) {
+  const committedKeys = /* @__PURE__ */ new Set();
+  for (const [streamId, key] of [...state.keys.entries()]) {
+    if (state.statuses.get(streamId) === "streaming") continue;
+    deleteTrackedResponseStream(state, streamId);
+    committedKeys.add(key);
+  }
+  for (const taskId of [...state.keysByTask.keys()]) {
+    updateTaskKeys(state, taskId, committedKeys);
+  }
+  return committedKeys;
+}
+
 // src/components/AgentInstallPrompt.tsx
 var import_react22 = __toESM(require_react(), 1);
 var brand2 = (text) => source_default.hex("#F97316")(text);
@@ -95613,6 +95802,7 @@ function createRainSpinner() {
 
 // src/commands/chat.tsx
 var cliVersion = getCliVersion();
+var RENDERED_STREAM_TEXT_DEDUPE_LIMIT = 100;
 var WorkspaceNotConfiguredError = class extends Error {
   constructor() {
     super("No workspace configured.");
@@ -95629,16 +95819,6 @@ var WorkspaceNotFoundError = class extends Error {
 };
 var WORKSPACE_NOT_CONFIGURED_MSG = "No workspace configured. Pass a --workspace <id_or_name> argument or run guild workspace select";
 var WORKSPACE_NOT_FOUND_MSG = "The workspace doesn't exist.";
-marked.use(markedTerminal({}, { theme: {} }));
-function fixListItemMarkdown(text) {
-  text = text.replace(/\*\*([^*]+)\*\*/g, (_, content) => source_default.bold(content));
-  text = text.replace(/`([^`]+)`/g, (_, content) => code(content));
-  text = text.replace(
-    /(?<![\\w])_([^_]+)_(?![\\w])/g,
-    (_, content) => source_default.italic(content)
-  );
-  return text;
-}
 function extractMessageText(text) {
   const trimmed = text.trim();
   if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return text;
@@ -95667,23 +95847,7 @@ function extractRuntimeDoneText(content) {
   return JSON.stringify(content);
 }
 function renderAssistantMessage(text, taskName) {
-  const rendered = fixListItemMarkdown(marked.parse(text));
-  return `${source_default.green("\u25CF")} ${source_default.bold(taskName)}
-  ${rendered.trim().split("\n").join("\n  ")}`;
-}
-function getEventAgentName(event, fallbackName) {
-  const task = event.task;
-  if (!task) return fallbackName;
-  if ("agent" in task && task.agent) {
-    return getAgentName(task.agent);
-  }
-  if ("parent_task" in task && task.parent_task) {
-    const parent = task.parent_task;
-    if ("agent" in parent && parent.agent) {
-      return getAgentName(parent.agent);
-    }
-  }
-  return fallbackName;
+  return renderAssistantMessageContent(text, taskName);
 }
 function applyResponseStreamContentsInSequence(contents) {
   return [...contents].sort((left, right) => left.sequence - right.sequence).reduce(
@@ -95691,6 +95855,33 @@ function applyResponseStreamContentsInSequence(contents) {
     ""
   );
 }
+function cloneResponseStreamResumeState(state) {
+  if (!state) {
+    return {
+      keys: /* @__PURE__ */ new Map(),
+      contents: /* @__PURE__ */ new Map(),
+      texts: /* @__PURE__ */ new Map(),
+      timestamps: /* @__PURE__ */ new Map(),
+      statuses: /* @__PURE__ */ new Map(),
+      keysByTask: /* @__PURE__ */ new Map()
+    };
+  }
+  return {
+    keys: new Map(state.keys),
+    contents: new Map(
+      [...state.contents.entries()].map(([streamId, contents]) => [
+        streamId,
+        [...contents]
+      ])
+    ),
+    texts: new Map(state.texts),
+    timestamps: new Map(state.timestamps),
+    statuses: new Map(state.statuses),
+    keysByTask: new Map(
+      [...state.keysByTask.entries()].map(([taskId, keys]) => [taskId, new Set(keys)])
+    )
+  };
+}
 async function outputOnceResult(sessionId, events, mode) {
   if (mode === "json") {
     console.log(JSON.stringify({ session_id: sessionId, events }, null, 2));
@@ -95927,7 +96118,7 @@ function ChatApp({
         }
       }
     }
-  ), phase === "chat" && /* @__PURE__ */ import_react25.default.createElement(
+  ), phase === "chat" && (!connectedSession || !connectedClient) && /* @__PURE__ */ import_react25.default.createElement(Box_default, { flexDirection: "column" }, /* @__PURE__ */ import_react25.default.createElement(Text, null, `${brand(">")} ${initialPrompt}`), /* @__PURE__ */ import_react25.default.createElement(Box_default, { height: 1 }, /* @__PURE__ */ import_react25.default.createElement(Text, { color: "gray" }, "> "), /* @__PURE__ */ import_react25.default.createElement(Text, null, source_default.dim("(connecting...)")))), connectedSession && connectedClient && /* @__PURE__ */ import_react25.default.createElement(
     ChatUIWithConnection,
     {
       key: chatInstanceKey,
@@ -95938,24 +96129,12 @@ function ChatApp({
       client: connectedClient,
       session: connectedSession,
       onFirstMessage: () => setFirstMessageReceived(true),
+      isVisible: phase === "chat",
       resumeEvents,
       resumeCommand,
       eventFilter
     }
-  ), (phase === "splash" || phase === "finalizing") && connectedSession && connectedClient && /* @__PURE__ */ import_react25.default.createElement(Box_default, { display: "none" }, /* @__PURE__ */ import_react25.default.createElement(
-    ChatUIWithConnection,
-    {
-      initialPrompt,
-      version,
-      versionId,
-      agentName,
-      client: connectedClient,
-      session: connectedSession,
-      onFirstMessage: () => setFirstMessageReceived(true),
-      isActive: false,
-      eventFilter
-    }
-  )));
+  ));
 }
 function ChatUIWithConnection({
   initialPrompt,
@@ -95965,41 +96144,71 @@ function ChatUIWithConnection({
   client: preConnectedClient,
   session: preConnectedSession,
   onFirstMessage,
-  isActive = true,
+  isVisible = true,
   resumeEvents,
   resumeCommand,
-  eventFilter
+  eventFilter,
+  fetchEventsFn = fetchEvents,
+  fetchTasksFn = fetchTasks
 }) {
   const activeFilter = eventFilter ?? DEFAULT_EVENT_TYPES;
   const [showTaskPanel, setShowTaskPanel] = (0, import_react25.useState)(true);
   const [tasks, setTasks] = (0, import_react25.useState)([]);
   const [pendingInstallRequest, setPendingInstallRequest] = (0, import_react25.useState)(null);
   const promptedEventIds = (0, import_react25.useRef)(/* @__PURE__ */ new Set());
-  const [resumeDisplay] = (0, import_react25.useState)(
-    () => resumeEvents ? prepareSessionResumeDisplay(resumeEvents) : null
-  );
-  const resumeDisplayMessages = resumeDisplay?.displayMessages ?? null;
-  const responseStreamResumeState = resumeDisplay?.responseStreamState ?? null;
-  const sessionLinkMessage = isActive && preConnectedSession?.session_url ? [
-    {
-      key: "session-link",
-      content: source_default.dim(
-        `Session: ${hyperlink(preConnectedSession.id, preConnectedSession.session_url)}`
-      ),
-      type: "progress"
-    }
-  ] : [];
-  const [messages, setMessages] = (0, import_react25.useState)(
-    resumeDisplayMessages ? resumeDisplayMessages : isActive ? [
-      ...sessionLinkMessage,
+  const [initialChatState] = (0, import_react25.useState)(() => {
+    const resumeDisplay = resumeEvents ? prepareSessionResumeDisplay(resumeEvents) : null;
+    const splitResumeDisplay = splitResponseStreamDisplayMessages(
+      resumeDisplay?.displayMessages ?? [],
+      resumeDisplay?.responseStreamState
+    );
+    const sessionLinkMessage = preConnectedSession?.session_url ? [
       {
-        key: "initial",
-        content: `${brand(">")} ${initialPrompt}`,
-        type: "user"
+        key: "session-link",
+        content: source_default.dim(
+          `Session: ${hyperlink(preConnectedSession.id, preConnectedSession.session_url)}`
+        ),
+        type: "progress"
       }
-    ] : []
+    ] : [];
+    return {
+      responseStreamResumeState: resumeDisplay?.responseStreamState ?? null,
+      transcriptMessages: resumeDisplay ? splitResumeDisplay.transcriptMessages : [
+        ...sessionLinkMessage,
+        {
+          key: "initial",
+          content: `${brand(">")} ${initialPrompt}`,
+          type: "user"
+        }
+      ],
+      dynamicMessages: splitResumeDisplay.dynamicMessages,
+      activeStreamMessages: splitResumeDisplay.activeMessages
+    };
+  });
+  const messagesRef = (0, import_react25.useRef)(initialChatState.transcriptMessages);
+  const [messages, setMessagesState] = (0, import_react25.useState)(
+    initialChatState.transcriptMessages
+  );
+  const setMessages = (update) => {
+    const nextMessages = typeof update === "function" ? update(messagesRef.current) : update;
+    messagesRef.current = nextMessages;
+    setMessagesState(nextMessages);
+  };
+  const dynamicMessagesRef = (0, import_react25.useRef)(initialChatState.dynamicMessages);
+  const [dynamicMessages, setDynamicMessagesState] = (0, import_react25.useState)(
+    initialChatState.dynamicMessages
+  );
+  const setDynamicMessages = (update) => {
+    const nextMessages = typeof update === "function" ? update(dynamicMessagesRef.current) : update;
+    dynamicMessagesRef.current = nextMessages;
+    setDynamicMessagesState(nextMessages);
+  };
+  const [responseStreamMessagesByKey] = (0, import_react25.useState)(
+    () => createActiveResponseStreamMessageMap(initialChatState.activeStreamMessages)
+  );
+  const [responseStreamState] = (0, import_react25.useState)(
+    () => cloneResponseStreamResumeState(initialChatState.responseStreamResumeState)
   );
-  const [streamingMessage, setStreamingMessage] = (0, import_react25.useState)(null);
   const [input, setInput] = (0, import_react25.useState)("");
   const inputTextRef = (0, import_react25.useRef)("");
   const updateInput = (value) => {
@@ -96019,6 +96228,9 @@ function ChatUIWithConnection({
     width: process.stdout.columns || 80,
     height: process.stdout.rows || 24
   });
+  const client = preConnectedClient;
+  const session = preConnectedSession;
+  const isReady = session !== null;
   const resizeTimeout = (0, import_react25.useRef)(null);
   (0, import_react25.useEffect)(() => {
     const handleResize = () => {
@@ -96040,57 +96252,60 @@ function ChatUIWithConnection({
       }
     };
   }, []);
-  use_input_default((input2, key) => {
-    if (key.escape && client && session && currentOperation && !isInterrupting.current && Date.now() - mountedAt.current > 300) {
-      isInterrupting.current = true;
-      client.post(`/sessions/${session.id}/interrupt`, {}).then(() => {
-        debug("Session interrupted");
-      }).catch((err) => {
-        debug("Interrupt failed (session may already be done):", err);
-      }).finally(() => {
-        isInterrupting.current = false;
-      });
-      return;
-    }
-    const isCtrlC = input2 === "" || key.ctrl && input2 === "c";
-    if (isCtrlC) {
-      if (inputTextRef.current && !exitKeyPressed.current) {
-        updateInput("");
+  use_input_default(
+    (input2, key) => {
+      if (key.escape && isVisible && client && session && currentOperation && !isInterrupting.current && Date.now() - mountedAt.current > 300) {
+        isInterrupting.current = true;
+        client.post(`/sessions/${session.id}/interrupt`, {}).then(() => {
+          debug("Session interrupted");
+        }).catch((err) => {
+          debug("Interrupt failed (session may already be done):", err);
+        }).finally(() => {
+          isInterrupting.current = false;
+        });
         return;
       }
-      if (exitKeyPressed.current) {
-        if (preConnectedSession?.id && resumeCommand) {
-          printResumeHint(preConnectedSession.id, resumeCommand);
+      const isCtrlC = input2 === "" || key.ctrl && input2 === "c";
+      if (isCtrlC) {
+        if (inputTextRef.current && !exitKeyPressed.current) {
+          updateInput("");
+          return;
         }
-        process.exit(0);
+        if (exitKeyPressed.current) {
+          if (preConnectedSession?.id && resumeCommand) {
+            printResumeHint(preConnectedSession.id, resumeCommand);
+          }
+          process.exit(0);
+        }
+        exitKeyPressed.current = true;
+        setExitHint("ctrl-c");
+        if (exitKeyTimeout.current) clearTimeout(exitKeyTimeout.current);
+        exitKeyTimeout.current = setTimeout(() => {
+          exitKeyPressed.current = false;
+          setExitHint(null);
+        }, 2e3);
+        return;
       }
-      exitKeyPressed.current = true;
-      setExitHint("ctrl-c");
-      if (exitKeyTimeout.current) clearTimeout(exitKeyTimeout.current);
-      exitKeyTimeout.current = setTimeout(() => {
-        exitKeyPressed.current = false;
-        setExitHint(null);
-      }, 2e3);
-      return;
-    }
-    const isCtrlD = input2 === "" || key.ctrl && input2 === "d";
-    if (isCtrlD) {
-      if (exitKeyPressed.current) {
-        if (preConnectedSession?.id && resumeCommand) {
-          printResumeHint(preConnectedSession.id, resumeCommand);
-        }
-        process.exit(0);
-      }
-      exitKeyPressed.current = true;
-      setExitHint("ctrl-d");
-      if (exitKeyTimeout.current) clearTimeout(exitKeyTimeout.current);
-      exitKeyTimeout.current = setTimeout(() => {
-        exitKeyPressed.current = false;
-        setExitHint(null);
-      }, 2e3);
-      return;
-    }
-  });
+      const isCtrlD = input2 === "" || key.ctrl && input2 === "d";
+      if (isCtrlD) {
+        if (exitKeyPressed.current) {
+          if (preConnectedSession?.id && resumeCommand) {
+            printResumeHint(preConnectedSession.id, resumeCommand);
+          }
+          process.exit(0);
+        }
+        exitKeyPressed.current = true;
+        setExitHint("ctrl-d");
+        if (exitKeyTimeout.current) clearTimeout(exitKeyTimeout.current);
+        exitKeyTimeout.current = setTimeout(() => {
+          exitKeyPressed.current = false;
+          setExitHint(null);
+        }, 2e3);
+        return;
+      }
+    },
+    { isActive: isReady && isVisible }
+  );
   (0, import_react25.useEffect)(() => {
     return () => {
       if (exitKeyTimeout.current) {
@@ -96098,9 +96313,6 @@ function ChatUIWithConnection({
       }
     };
   }, []);
-  const client = preConnectedClient;
-  const session = preConnectedSession;
-  const isReady = session !== null;
   const animatedSpinner = (0, import_react25.useRef)(null);
   const spinnerSwapInterval = (0, import_react25.useRef)(null);
   const spinnerTheme = process.env.GUILD_SPINNER_THEME;
@@ -96120,85 +96332,150 @@ function ChatUIWithConnection({
   const isPolling = (0, import_react25.useRef)(false);
   const receivedResponseSinceLastInput = (0, import_react25.useRef)(false);
   const firstMessageNotified = (0, import_react25.useRef)(!!resumeEvents);
-  const responseStreamKeys = (0, import_react25.useRef)(
-    responseStreamResumeState?.keys ?? /* @__PURE__ */ new Map()
-  );
-  const responseStreamContents = (0, import_react25.useRef)(
-    responseStreamResumeState?.contents ?? /* @__PURE__ */ new Map()
-  );
-  const responseStreamTexts = (0, import_react25.useRef)(
-    responseStreamResumeState?.texts ?? /* @__PURE__ */ new Map()
-  );
-  const responseStreamTimestamps = (0, import_react25.useRef)(
-    responseStreamResumeState?.timestamps ?? /* @__PURE__ */ new Map()
-  );
-  const responseStreamStatuses = (0, import_react25.useRef)(
-    responseStreamResumeState?.statuses ?? /* @__PURE__ */ new Map()
-  );
-  const responseStreamKeysByTask = (0, import_react25.useRef)(
-    responseStreamResumeState?.keysByTask ?? /* @__PURE__ */ new Map()
-  );
-  const renderedStreamTexts = (0, import_react25.useRef)(/* @__PURE__ */ new Set());
-  const clearResponseStreamsForTask = (taskId, options2 = {}) => {
-    if (!taskId) return;
-    const keys = responseStreamKeysByTask.current.get(taskId);
-    if (!keys?.size) return;
-    const removedKeys = /* @__PURE__ */ new Set();
-    const detachedKeys = /* @__PURE__ */ new Set();
-    for (const [streamId, key] of responseStreamKeys.current.entries()) {
-      if (keys.has(key)) {
-        if (options2.preserveContinued && responseStreamStatuses.current.get(streamId) === "continued" && responseStreamTexts.current.get(streamId) !== options2.finalText) {
-          responseStreamKeys.current.delete(streamId);
-          responseStreamContents.current.delete(streamId);
-          responseStreamTexts.current.delete(streamId);
-          responseStreamTimestamps.current.delete(streamId);
-          responseStreamStatuses.current.delete(streamId);
-          detachedKeys.add(key);
-          continue;
-        }
-        responseStreamKeys.current.delete(streamId);
-        responseStreamContents.current.delete(streamId);
-        responseStreamTexts.current.delete(streamId);
-        responseStreamTimestamps.current.delete(streamId);
-        responseStreamStatuses.current.delete(streamId);
-        removedKeys.add(key);
+  const closedResponseStreamIds = (0, import_react25.useRef)(/* @__PURE__ */ new Set());
+  const flushDynamicMessagesIfIdle = () => {
+    if (responseStreamMessagesByKey.size > 0) return;
+    if (dynamicMessagesRef.current.length === 0) return;
+    setMessages(
+      (prev) => flushDynamicMessagesIntoTranscript(prev, dynamicMessagesRef.current)
+    );
+    setDynamicMessages([]);
+  };
+  const appendDisplayMessage = (message) => {
+    if (dynamicMessagesRef.current.length > 0) {
+      setDynamicMessages((prev) => [...prev, message]);
+      return;
+    }
+    setMessages((prev) => [...prev, message]);
+  };
+  const setActiveResponseStreamMessage = (message) => {
+    setDynamicMessages(
+      (prev) => upsertDynamicResponseStreamMessage(prev, responseStreamMessagesByKey, message)
+    );
+  };
+  const removeActiveResponseStreamMessageKeys = (keys) => {
+    const { dynamicMessages: dynamicMessages2, affectedMessages } = removeDynamicResponseStreamMessages(
+      dynamicMessagesRef.current,
+      responseStreamMessagesByKey,
+      keys
+    );
+    if (affectedMessages.length > 0 || dynamicMessages2.length !== dynamicMessagesRef.current.length) {
+      setDynamicMessages(dynamicMessages2);
+      flushDynamicMessagesIfIdle();
+    }
+    return affectedMessages;
+  };
+  const commitActiveResponseStreamMessageKeys = (keys) => {
+    const result = commitDynamicResponseStreamMessages(
+      dynamicMessagesRef.current,
+      responseStreamMessagesByKey,
+      keys
+    );
+    if (result.affectedMessages.length === 0) return;
+    setDynamicMessages(result.dynamicMessages);
+    flushDynamicMessagesIfIdle();
+  };
+  const renderedStreamTextLru = (0, import_react25.useRef)(/* @__PURE__ */ new Set());
+  const trackedStreamIdsForTask = (taskId, options2 = {}) => {
+    const streamIds = /* @__PURE__ */ new Set();
+    if (!taskId) return streamIds;
+    const keys = responseStreamState.keysByTask.get(taskId);
+    if (!keys?.size) return streamIds;
+    for (const [streamId, key] of responseStreamState.keys.entries()) {
+      if (!keys.has(key)) continue;
+      if (options2.terminalOnly && responseStreamState.statuses.get(streamId) === "streaming") {
+        continue;
       }
+      streamIds.add(streamId);
     }
-    const inactiveKeys = /* @__PURE__ */ new Set([...removedKeys, ...detachedKeys]);
-    const remainingKeys = new Set([...keys].filter((key) => !inactiveKeys.has(key)));
-    if (remainingKeys.size > 0) {
-      responseStreamKeysByTask.current.set(taskId, remainingKeys);
-    } else {
-      responseStreamKeysByTask.current.delete(taskId);
+    return streamIds;
+  };
+  const allTerminalTrackedStreamIds = () => {
+    const streamIds = /* @__PURE__ */ new Set();
+    for (const streamId of responseStreamState.keys.keys()) {
+      if (responseStreamState.statuses.get(streamId) !== "streaming") {
+        streamIds.add(streamId);
+      }
+    }
+    return streamIds;
+  };
+  const closeResponseStreamIds = (streamIds) => {
+    for (const streamId of streamIds) {
+      closedResponseStreamIds.current.add(streamId);
+    }
+  };
+  const rememberRenderedStreamText = (text) => {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    renderedStreamTextLru.current.delete(trimmed);
+    renderedStreamTextLru.current.add(trimmed);
+    while (renderedStreamTextLru.current.size > RENDERED_STREAM_TEXT_DEDUPE_LIMIT) {
+      const oldestKey = renderedStreamTextLru.current.keys().next().value;
+      if (oldestKey === void 0) break;
+      renderedStreamTextLru.current.delete(oldestKey);
     }
-    setMessages((prev) => prev.filter((message) => !removedKeys.has(message.key)));
-    setStreamingMessage(
-      (prev) => prev && (removedKeys.has(prev.key) || detachedKeys.has(prev.key)) ? null : prev
+  };
+  const consumeRenderedStreamText = (text) => {
+    const trimmed = text.trim();
+    if (!trimmed) return false;
+    return renderedStreamTextLru.current.delete(trimmed);
+  };
+  const clearResponseStreamsForTask = (taskId, options2 = {}) => {
+    const streamIdsToClose = trackedStreamIdsForTask(taskId);
+    const { removedKeys, detachedKeys } = clearTrackedResponseStreamsForTask(
+      responseStreamState,
+      taskId,
+      options2
     );
+    if (removedKeys.size > 0 || detachedKeys.size > 0) {
+      closeResponseStreamIds(streamIdsToClose);
+    }
+    removeActiveResponseStreamMessageKeys(removedKeys);
+    commitActiveResponseStreamMessageKeys(detachedKeys);
+    if (removedKeys.size > 0) {
+      setMessages((prev) => prev.filter((message) => !removedKeys.has(message.key)));
+    }
+  };
+  const commitTerminalResponseStreamsForTask = (taskId) => {
+    const streamIdsToClose = trackedStreamIdsForTask(taskId, { terminalOnly: true });
+    const committedKeys = commitTerminalTrackedResponseStreamsForTask(
+      responseStreamState,
+      taskId
+    );
+    if (committedKeys.size > 0) {
+      closeResponseStreamIds(streamIdsToClose);
+    }
+    commitActiveResponseStreamMessageKeys(committedKeys);
+  };
+  const commitAllTerminalResponseStreams = () => {
+    const streamIdsToClose = allTerminalTrackedStreamIds();
+    const committedKeys = commitAllTerminalTrackedResponseStreams(responseStreamState);
+    if (committedKeys.size > 0) {
+      closeResponseStreamIds(streamIdsToClose);
+    }
+    commitActiveResponseStreamMessageKeys(committedKeys);
   };
   const upsertResponseStreamMessage = (event) => {
     if (!isResponseStreamEvent(event)) return;
     if (!isRootTaskEvent(event)) return;
     const streamId = event.content.stream_id;
+    if (closedResponseStreamIds.current.has(streamId)) return;
     const taskId = event.task?.id;
-    const existingKey = responseStreamKeys.current.get(streamId);
+    const existingKey = responseStreamState.keys.get(streamId);
     if (event.content.status === "aborted") {
-      responseStreamContents.current.delete(streamId);
-      responseStreamTexts.current.delete(streamId);
-      responseStreamTimestamps.current.delete(streamId);
-      responseStreamStatuses.current.delete(streamId);
-      if (existingKey) {
-        responseStreamKeys.current.delete(streamId);
-        if (taskId) {
-          const keys = responseStreamKeysByTask.current.get(taskId);
-          keys?.delete(existingKey);
-          if (keys?.size === 0) responseStreamKeysByTask.current.delete(taskId);
-        }
-        setMessages((prev) => prev.filter((message2) => message2.key !== existingKey));
+      closeResponseStreamIds(/* @__PURE__ */ new Set([streamId]));
+      const removedKeys = abortTrackedResponseStream(
+        responseStreamState,
+        streamId,
+        taskId
+      );
+      removeActiveResponseStreamMessageKeys(removedKeys);
+      if (removedKeys.size > 0) {
+        setMessages((prev) => prev.filter((message) => !removedKeys.has(message.key)));
       }
       return;
     }
-    const streamContents = responseStreamContents.current.get(streamId) ?? [];
+    const streamContents = responseStreamState.contents.get(streamId) ?? [];
     const existingContentIndex = streamContents.findIndex(
       (content) => content.sequence === event.content.sequence
     );
@@ -96207,45 +96484,32 @@ function ChatUIWithConnection({
     } else {
       streamContents[existingContentIndex] = event.content;
     }
-    responseStreamContents.current.set(streamId, streamContents);
+    responseStreamState.contents.set(streamId, streamContents);
     const text = applyResponseStreamContentsInSequence(streamContents);
     if (!text.trim()) return;
     const key = existingKey ?? `response-stream-${streamId}`;
-    responseStreamKeys.current.set(streamId, key);
-    responseStreamTexts.current.set(streamId, text);
-    responseStreamStatuses.current.set(streamId, event.content.status);
+    responseStreamState.keys.set(streamId, key);
+    responseStreamState.texts.set(streamId, text);
+    responseStreamState.statuses.set(streamId, event.content.status);
     if (taskId) {
-      const keys = responseStreamKeysByTask.current.get(taskId) ?? /* @__PURE__ */ new Set();
+      const keys = responseStreamState.keysByTask.get(taskId) ?? /* @__PURE__ */ new Set();
       keys.add(key);
-      responseStreamKeysByTask.current.set(taskId, keys);
+      responseStreamState.keysByTask.set(taskId, keys);
     }
-    const taskName = agentName || "assistant";
+    const taskName = getEventAgentName(event, agentName || "assistant");
     const messageContent = renderAssistantMessage(text, taskName);
-    const timestamp = responseStreamTimestamps.current.get(streamId) ?? (/* @__PURE__ */ new Date()).toLocaleTimeString();
-    responseStreamTimestamps.current.set(streamId, timestamp);
-    const message = {
+    const timestamp = responseStreamState.timestamps.get(streamId) ?? (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    responseStreamState.timestamps.set(streamId, timestamp);
+    setActiveResponseStreamMessage({
       key,
       content: messageContent,
       type: "assistant",
       timestamp
-    };
-    if (event.content.status === "done" || event.content.status === "continued") {
-      setStreamingMessage(null);
-      setMessages((prev) => {
-        const index = prev.findIndex((m) => m.key === key);
-        if (index === -1) return [...prev, message];
-        const next = [...prev];
-        next[index] = message;
-        return next;
-      });
-      if (event.content.status === "done") {
-        const trimmed = text.trim();
-        if (trimmed) renderedStreamTexts.current.add(trimmed);
-        receivedResponseSinceLastInput.current = true;
-        setCurrentOperation("");
-      }
-    } else {
-      setStreamingMessage(message);
+    });
+    if (event.content.status === "done") {
+      rememberRenderedStreamText(text);
+      receivedResponseSinceLastInput.current = true;
+      setCurrentOperation("");
     }
     if (!firstMessageNotified.current && onFirstMessage) {
       firstMessageNotified.current = true;
@@ -96295,7 +96559,7 @@ function ChatUIWithConnection({
       if (isPollingTasks.current) return;
       isPollingTasks.current = true;
       try {
-        const tasksList = await fetchTasks(client, session.id);
+        const tasksList = await fetchTasksFn(client, session.id);
         setTasks(tasksList);
       } catch (error) {
         debug("Tasks poll error:", error);
@@ -96308,7 +96572,7 @@ function ChatUIWithConnection({
     return () => {
       clearInterval(interval);
     };
-  }, [client, session, isReady]);
+  }, [client, session, isReady, fetchTasksFn]);
   (0, import_react25.useEffect)(() => {
     if (!client || !session || !isReady) return;
     const poll = async () => {
@@ -96316,7 +96580,7 @@ function ChatUIWithConnection({
       isPolling.current = true;
       debug(`poll() called, session=${session.id}, fromId=${lastEventIdRef.current}`);
       try {
-        const newEvents = await fetchEvents(client, session.id, {
+        const newEvents = await fetchEventsFn(client, session.id, {
           fromId: lastEventIdRef.current
         });
         debug(`Events: fromId=${lastEventIdRef.current}, new=${newEvents.length}`);
@@ -96338,100 +96602,76 @@ function ChatUIWithConnection({
               if (shouldShowEvent("runtime_error", activeFilter)) {
                 const errorText = typeof event.content === "string" ? event.content : "Unknown error";
                 const taskName = getEventAgentName(event, agentName || "assistant");
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    key: `error-${Date.now()}`,
-                    content: `${source_default.red("\u25CF")} ${source_default.bold(taskName)}
+                appendDisplayMessage({
+                  key: `error-${Date.now()}`,
+                  content: `${source_default.red("\u25CF")} ${source_default.bold(taskName)}
   ${source_default.red(`Error: ${errorText}`)}`,
-                    type: "assistant"
-                  }
-                ]);
+                  type: "assistant"
+                });
               }
             } else if (event.type === "runtime_start") {
               if (shouldShowEvent("runtime_start", activeFilter)) {
                 const taskName = getEventAgentName(event, agentName || "assistant");
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    key: `runtime-start-${Date.now()}`,
-                    content: source_default.dim(`${source_default.green("\u25B6")} Started ${taskName}`),
-                    type: "assistant"
-                  }
-                ]);
+                appendDisplayMessage({
+                  key: `runtime-start-${Date.now()}`,
+                  content: source_default.dim(`${source_default.green("\u25B6")} Started ${taskName}`),
+                  type: "assistant"
+                });
               }
             } else if (event.type === "runtime_running") {
               if (shouldShowEvent("runtime_running", activeFilter)) {
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    key: `runtime-running-${Date.now()}`,
-                    content: source_default.dim(`${source_default.blue("\u25CF")} Running`),
-                    type: "assistant"
-                  }
-                ]);
+                appendDisplayMessage({
+                  key: `runtime-running-${Date.now()}`,
+                  content: source_default.dim(`${source_default.blue("\u25CF")} Running`),
+                  type: "assistant"
+                });
               }
             } else if (event.type === "runtime_waiting") {
               if (shouldShowEvent("runtime_waiting", activeFilter)) {
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    key: `runtime-waiting-${Date.now()}`,
-                    content: source_default.dim(`${source_default.yellow("\u25D0")} Waiting for input`),
-                    type: "assistant"
-                  }
-                ]);
+                appendDisplayMessage({
+                  key: `runtime-waiting-${Date.now()}`,
+                  content: source_default.dim(`${source_default.yellow("\u25D0")} Waiting for input`),
+                  type: "assistant"
+                });
               }
             } else if (event.type === "trigger_message") {
               if (shouldShowEvent("trigger_message", activeFilter)) {
                 const triggerText = typeof event.content === "object" ? event.content?.data || "" : "";
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    key: `trigger-${Date.now()}`,
-                    content: `${source_default.cyan("\u26A1")} ${source_default.cyan("Trigger")} ${triggerText}`,
-                    type: "assistant"
-                  }
-                ]);
+                appendDisplayMessage({
+                  key: `trigger-${Date.now()}`,
+                  content: `${source_default.cyan("\u26A1")} ${source_default.cyan("Trigger")} ${triggerText}`,
+                  type: "assistant"
+                });
               }
             } else if (event.type === "system_error") {
               if (shouldShowEvent("system_error", activeFilter)) {
                 const errText = typeof event.content === "object" ? event.content?.data || "" : "";
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    key: `system-error-${Date.now()}`,
-                    content: `${source_default.red("\u2717")} ${source_default.red("System error:")} ${errText}`,
-                    type: "assistant"
-                  }
-                ]);
+                appendDisplayMessage({
+                  key: `system-error-${Date.now()}`,
+                  content: `${source_default.red("\u2717")} ${source_default.red("System error:")} ${errText}`,
+                  type: "assistant"
+                });
               }
             } else if (event.type === "llm_start") {
               if (shouldShowEvent("llm_start", activeFilter)) {
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    key: `llm-start-${Date.now()}`,
-                    content: source_default.dim(
-                      `${source_default.magenta("\u2726")} LLM request \u2192 ${event.provider}`
-                    ),
-                    type: "assistant"
-                  }
-                ]);
+                appendDisplayMessage({
+                  key: `llm-start-${Date.now()}`,
+                  content: source_default.dim(
+                    `${source_default.magenta("\u2726")} LLM request \u2192 ${event.provider}`
+                  ),
+                  type: "assistant"
+                });
               }
             } else if (event.type === "llm_done") {
               if (shouldShowEvent("llm_done", activeFilter)) {
                 const statusColor = event.status_code < 400 ? source_default.green : source_default.red;
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    key: `llm-done-${Date.now()}`,
-                    content: source_default.dim(
-                      `${source_default.magenta("\u2726")} LLM response ${statusColor(`${event.status_code}`)}`
-                    ),
-                    type: "assistant"
-                  }
-                ]);
+                appendDisplayMessage({
+                  key: `llm-done-${Date.now()}`,
+                  content: source_default.dim(
+                    `${source_default.magenta("\u2726")} LLM response ${statusColor(`${event.status_code}`)}`
+                  ),
+                  type: "assistant"
+                });
               }
             } else if (event.type === "agent_notification_progress") {
               const rawProgressText = typeof event.content === "string" ? event.content : event.content?.data || "";
@@ -96446,8 +96686,8 @@ function ChatUIWithConnection({
               const text = extractMessageText(getAgentNotificationText(event));
               const trimmedText = text.trim();
               if (trimmedText) {
-                if (renderedStreamTexts.current.has(trimmedText)) {
-                  renderedStreamTexts.current.delete(trimmedText);
+                if (consumeRenderedStreamText(trimmedText)) {
+                  commitTerminalResponseStreamsForTask(taskInfo?.id);
                   receivedResponseSinceLastInput.current = true;
                   setCurrentOperation("");
                   continue;
@@ -96458,15 +96698,12 @@ function ChatUIWithConnection({
                 });
                 const taskName = getEventAgentName(event, agentName || "assistant");
                 const messageContent = renderAssistantMessage(text, taskName);
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    key: `msg-${Date.now()}-${Math.random()}`,
-                    content: messageContent,
-                    type: "assistant",
-                    timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString()
-                  }
-                ]);
+                appendDisplayMessage({
+                  key: `msg-${Date.now()}-${Math.random()}`,
+                  content: messageContent,
+                  type: "assistant",
+                  timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString()
+                });
                 if (!firstMessageNotified.current && onFirstMessage) {
                   firstMessageNotified.current = true;
                   onFirstMessage();
@@ -96478,42 +96715,34 @@ function ChatUIWithConnection({
               clearResponseStreamsForTask(taskInfo?.id);
               const errorText = typeof event.content === "string" ? event.content : event.content?.data || "Unknown error";
               const taskName = getEventAgentName(event, agentName || "assistant");
-              setMessages((prev) => [
-                ...prev,
-                {
-                  key: `error-${Date.now()}`,
-                  content: `${source_default.red("\u25CF")} ${source_default.bold(taskName)}
+              appendDisplayMessage({
+                key: `error-${Date.now()}`,
+                content: `${source_default.red("\u25CF")} ${source_default.bold(taskName)}
   ${source_default.red(`Error: ${errorText}`)}`,
-                  type: "assistant"
-                }
-              ]);
+                type: "assistant"
+              });
               setCurrentOperation("");
             } else if (event.type === "agent_console") {
               if (shouldShowEvent("agent_console", activeFilter) || isDebugMode()) {
                 const content = typeof event.content === "string" ? event.content : "";
                 const levelIcon = event.level === "error" ? source_default.red("\u2717") : event.level === "warn" ? source_default.yellow("\u26A0") : source_default.dim("\u25AA");
                 const levelColor = event.level === "error" ? source_default.red : event.level === "warn" ? source_default.yellow : source_default.dim;
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    key: `console-${Date.now()}-${Math.random()}`,
-                    content: `${levelIcon} ${levelColor(`console.${event.level}`)} ${source_default.dim(content)}`,
-                    type: "assistant"
-                  }
-                ]);
+                appendDisplayMessage({
+                  key: `console-${Date.now()}-${Math.random()}`,
+                  content: `${levelIcon} ${levelColor(`console.${event.level}`)} ${source_default.dim(content)}`,
+                  type: "assistant"
+                });
               }
             } else if (event.type === "runtime_done") {
               if (shouldShowEvent("runtime_done", activeFilter)) {
                 const taskName = getEventAgentName(event, agentName || "assistant");
-                setMessages((prev) => [
-                  ...prev,
-                  {
-                    key: `runtime-done-${Date.now()}`,
-                    content: source_default.dim(`${source_default.green("\u2713")} Done ${taskName}`),
-                    type: "assistant"
-                  }
-                ]);
+                appendDisplayMessage({
+                  key: `runtime-done-${Date.now()}`,
+                  content: source_default.dim(`${source_default.green("\u2713")} Done ${taskName}`),
+                  type: "assistant"
+                });
               }
+              commitTerminalResponseStreamsForTask(taskInfo?.id);
               if (!receivedResponseSinceLastInput.current && event.content !== void 0 && taskInfo && "agent" in taskInfo) {
                 const contentStr = typeof event.content === "string" ? event.content : JSON.stringify(event.content);
                 clearResponseStreamsForTask(taskInfo.id, {
@@ -96523,15 +96752,12 @@ function ChatUIWithConnection({
                 if (contentStr && contentStr !== "{}" && contentStr !== "null") {
                   const taskName = getEventAgentName(event, agentName || "assistant");
                   const messageContent = renderAssistantMessage(contentStr, taskName);
-                  setMessages((prev) => [
-                    ...prev,
-                    {
-                      key: `msg-${Date.now()}-${Math.random()}`,
-                      content: messageContent,
-                      type: "assistant",
-                      timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString()
-                    }
-                  ]);
+                  appendDisplayMessage({
+                    key: `msg-${Date.now()}-${Math.random()}`,
+                    content: messageContent,
+                    type: "assistant",
+                    timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString()
+                  });
                   if (!firstMessageNotified.current && onFirstMessage) {
                     firstMessageNotified.current = true;
                     onFirstMessage();
@@ -96542,14 +96768,11 @@ function ChatUIWithConnection({
               }
             } else if (event.type === "interrupted") {
               clearResponseStreamsForTask(taskInfo?.id);
-              setMessages((prev) => [
-                ...prev,
-                {
-                  key: `interrupted-${Date.now()}`,
-                  content: source_default.dim("\u2298 Interrupted"),
-                  type: "assistant"
-                }
-              ]);
+              appendDisplayMessage({
+                key: `interrupted-${Date.now()}`,
+                content: source_default.dim("\u2298 Interrupted"),
+                type: "assistant"
+              });
               setCurrentOperation("");
               setIsInterrupted(true);
             } else if (isUnfulfilledAgentInstallRequest(event)) {
@@ -96575,7 +96798,7 @@ function ChatUIWithConnection({
         pollInterval.current = null;
       }
     };
-  }, [client, session, isReady, pendingInstallRequest]);
+  }, [client, session, isReady, pendingInstallRequest, fetchEventsFn]);
   const handleSubmit = async (value) => {
     const text = value.trim();
     if (text === "exit" || text === "quit") {
@@ -96586,32 +96809,27 @@ function ChatUIWithConnection({
     }
     if (!text || !client || !session || !isReady) return;
     sentMessages.current.add(value);
-    setMessages((prev) => [
-      ...prev,
-      {
-        key: `user-${Date.now()}`,
-        content: `${brand(">")} ${value}`,
-        type: "user"
-      }
-    ]);
+    commitAllTerminalResponseStreams();
+    appendDisplayMessage({
+      key: `user-${Date.now()}`,
+      content: `${brand(">")} ${value}`,
+      type: "user"
+    });
     updateInput("");
     try {
       await client.post(`/sessions/${session.id}/events`, {
         content: value
       });
       receivedResponseSinceLastInput.current = false;
-      renderedStreamTexts.current.clear();
+      renderedStreamTextLru.current.clear();
       setCurrentOperation("Waiting for response...");
     } catch (error) {
       debug("Send error:", error);
-      setMessages((prev) => [
-        ...prev,
-        {
-          key: `error-${Date.now()}`,
-          content: source_default.red("Failed to send message"),
-          type: "assistant"
-        }
-      ]);
+      appendDisplayMessage({
+        key: `error-${Date.now()}`,
+        content: source_default.red("Failed to send message"),
+        type: "assistant"
+      });
     }
   };
   const activeTasksList = tasks.filter(
@@ -96701,6 +96919,18 @@ function ChatUIWithConnection({
   const handleInstallComplete = () => {
     setPendingInstallRequest(null);
   };
+  if (!isVisible) {
+    return null;
+  }
+  const dynamicMessageBlock = dynamicMessages.length === 0 ? null : /* @__PURE__ */ import_react25.default.createElement(Box_default, { flexDirection: "column" }, dynamicMessages.map((msg, index) => /* @__PURE__ */ import_react25.default.createElement(
+    Box_default,
+    {
+      key: msg.key,
+      flexDirection: "column",
+      marginTop: msg.type === "user" && index > 0 ? 1 : 0
+    },
+    /* @__PURE__ */ import_react25.default.createElement(Text, null, msg.content)
+  )));
   return /* @__PURE__ */ import_react25.default.createElement(Box_default, { flexDirection: "column" }, /* @__PURE__ */ import_react25.default.createElement(Static, { items: messages }, (msg, index) => /* @__PURE__ */ import_react25.default.createElement(
     Box_default,
     {
@@ -96709,7 +96939,7 @@ function ChatUIWithConnection({
       marginTop: msg.type === "user" && index > 0 ? 1 : 0
     },
     /* @__PURE__ */ import_react25.default.createElement(Text, null, msg.content)
-  )), streamingMessage && /* @__PURE__ */ import_react25.default.createElement(Box_default, { flexDirection: "column" }, /* @__PURE__ */ import_react25.default.createElement(Text, null, streamingMessage.content)), showTaskPanel && tasks.length > 0 && currentOperation && /* @__PURE__ */ import_react25.default.createElement(Box_default, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ import_react25.default.createElement(TaskView, { tasks })), pendingInstallRequest && /* @__PURE__ */ import_react25.default.createElement(
+  )), dynamicMessageBlock, showTaskPanel && tasks.length > 0 && currentOperation && /* @__PURE__ */ import_react25.default.createElement(Box_default, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ import_react25.default.createElement(TaskView, { tasks })), pendingInstallRequest && /* @__PURE__ */ import_react25.default.createElement(
     AgentInstallPrompt,
     {
       event: pendingInstallRequest,
@@ -96727,7 +96957,7 @@ function ChatUIWithConnection({
       handleSubmit,
       trackedTasksSize: tasks.length,
       setShowTaskPanel,
-      isActive
+      isActive: isVisible
     }
   ));
 }
@@ -96741,7 +96971,7 @@ async function ensureAuthenticated() {
     const client = new GuildAPIClient();
     await client.get("/me");
   } catch {
-    const { clearAuthToken } = await import("./auth-CRMO5O3N.js");
+    const { clearAuthToken } = await import("./auth-67G3BIAW.js");
     await clearAuthToken();
     format.error("Session expired. Run: guild auth login");
     process.exit(1);
@@ -96943,6 +97173,7 @@ export {
   WorkspaceNotConfiguredError,
   WorkspaceNotFoundError,
   ChatApp,
+  ChatUIWithConnection,
   ensureAuthenticated,
   createSession,
   createChatCommand,
@@ -97038,4 +97269,4 @@ react-reconciler/cjs/react-reconciler-constants.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-IBRKVGMZ.js.map
+//# sourceMappingURL=chunk-7JJT3RNI.js.map