@google/gemini-cli 0.65.0-nightly.20261013.g51617c1bc → 0.65.0-preview.0

package/bundle/{interactiveCli-GBXKC6IY.js → interactiveCli-E3PUPYMZ.js}

@@ -171,10 +171,10 @@ import {
   widestLineFromStyledChars,
   wordBreakStyledChars,
   wrapStyledChars
-} from "./chunk-LB7T3Q3K.js";
+} from "./chunk-WTRK3NVX.js";
 import {
   require_source
-} from "./chunk-SSAL6PAH.js";
+} from "./chunk-H2CZXS7F.js";
 import {
   appEvents
 } from "./chunk-5PS3AYFU.js";
@@ -227,24 +227,24 @@ import {
   stripAnsi,
   stripUnsafeCharacters,
   toCodePoints
-} from "./chunk-LJV6OKHI.js";
+} from "./chunk-2WVLIJA5.js";
 import {
   handleAutoUpdate,
   isDevelopment,
   relaunchApp,
   setUpdateHandler
-} from "./chunk-VLEIPZMF.js";
+} from "./chunk-4DCA4L53.js";
 import {
   isTodoList,
   mapCoreStatusToDisplayStatus,
   require_react
-} from "./chunk-LZISQJNJ.js";
+} from "./chunk-NL7ZHGCH.js";
 import {
   registerCleanup,
   removeCleanup,
   runExitCleanup,
   setupTtyCheck
-} from "./chunk-LBJNFX6K.js";
+} from "./chunk-RPHDSDL6.js";
 import {
   ACTIVATE_SKILL_TOOL_NAME,
   AGENT_TOOL_NAME,
@@ -450,7 +450,7 @@ import {
   validatePlanContent,
   validatePlanPath,
   writeToStdout
-} from "./chunk-B22AOTUS.js";
+} from "./chunk-K7AA35SP.js";
 import "./chunk-664ZODQF.js";
 import "./chunk-IUUIT4SU.js";
 import "./chunk-L6PII3GR.js";
@@ -18733,6 +18733,9 @@ function useDebouncedValue(value, delay2 = 200) {
   }, [value, delay2]);
   return debounced;
 }
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function useReverseSearchCompletion(buffer, history, reverseSearchActive) {
   const {
     suggestions,
@@ -18762,11 +18765,12 @@ function useReverseSearchCompletion(buffer, history, reverseSearchActive) {
   const searchHistory = (0, import_react63.useCallback)(
     (query, items) => {
       const out = [];
+      const regex = new RegExp(escapeRegExp(query), "iu");
       for (let i = 0; i < items.length; i++) {
         const cmd = items[i];
-        const idx = cmd.toLowerCase().indexOf(query);
-        if (idx !== -1) {
-          out.push({ label: cmd, value: cmd, matchedIndex: idx });
+        const match = regex.exec(cmd);
+        if (match) {
+          out.push({ label: cmd, value: cmd, matchedIndex: match.index });
         }
       }
       return out;
@@ -18781,10 +18785,10 @@ function useReverseSearchCompletion(buffer, history, reverseSearchActive) {
         value: cmd,
         matchedIndex: -1
       }));
-    const query = debouncedQuery.toLowerCase();
-    const canUseCache = prevQueryRef.current && query.startsWith(prevQueryRef.current) && prevMatchesRef.current.length > 0;
+    const lowerQuery = debouncedQuery.toLowerCase();
+    const canUseCache = prevQueryRef.current && lowerQuery.startsWith(prevQueryRef.current) && prevMatchesRef.current.length > 0;
     const source = canUseCache ? prevMatchesRef.current.map((m) => m.value) : history;
-    return searchHistory(query, source);
+    return searchHistory(debouncedQuery, source);
   }, [debouncedQuery, history, reverseSearchActive, searchHistory]);
   (0, import_react63.useEffect)(() => {
     if (!reverseSearchActive) {
@@ -26709,7 +26713,7 @@ var useLogger = (config) => {
 };
 
 // packages/cli/src/ui/hooks/useGeminiStream.ts
-var import_react97 = __toESM(require_react(), 1);
+var import_react99 = __toESM(require_react(), 1);
 
 // packages/cli/src/ui/utils/markdownUtilities.ts
 var isIndexInsideCodeBlock = (content, indexToTest) => {
@@ -27075,6 +27079,638 @@ function adaptToolCalls(coreCalls, prevTracked) {
 // packages/cli/src/ui/hooks/useGeminiStream.ts
 import { promises as fs6 } from "node:fs";
 import path13 from "node:path";
+
+// packages/cli/src/ui/hooks/useAgentStream.ts
+var import_react98 = __toESM(require_react(), 1);
+
+// packages/cli/src/ui/hooks/useTurnActivityMonitor.ts
+var import_react97 = __toESM(require_react(), 1);
+var useTurnActivityMonitor = (streamingState, activePtyId, pendingToolCalls = []) => {
+  const [operationStartTime, setOperationStartTime] = (0, import_react97.useState)(0);
+  const prevPtyIdRef = (0, import_react97.useRef)(void 0);
+  const prevStreamingStateRef = (0, import_react97.useRef)(void 0);
+  (0, import_react97.useEffect)(() => {
+    const isNowResponding = streamingState === "responding" /* Responding */;
+    const wasResponding = prevStreamingStateRef.current === "responding" /* Responding */;
+    const ptyChanged = activePtyId !== prevPtyIdRef.current;
+    if (isNowResponding && (!wasResponding || ptyChanged)) {
+      setOperationStartTime(Date.now());
+    } else if (!isNowResponding && wasResponding) {
+      setOperationStartTime(0);
+    }
+    prevPtyIdRef.current = activePtyId;
+    prevStreamingStateRef.current = streamingState;
+  }, [streamingState, activePtyId]);
+  const isRedirectionActive = (0, import_react97.useMemo)(
+    () => (
+      // Check active tool calls for run_shell_command
+      pendingToolCalls.some((tc) => {
+        if (tc.request.name !== "run_shell_command") return false;
+        const command = tc.request.args?.command || "";
+        return hasRedirection(command);
+      })
+    ),
+    [pendingToolCalls]
+  );
+  return {
+    operationStartTime,
+    isRedirectionActive
+  };
+};
+
+// packages/cli/src/ui/hooks/useAgentStream.ts
+var CANCELLED_TOOL_ERROR_MESSAGE = "[Operation Cancelled] Reason: User cancelled operation";
+function createCancelledToolCall(request, tool, invocation) {
+  const fallbackToolName = request.name.trim() || "generic_tool";
+  return {
+    status: CoreToolCallStatus.Cancelled,
+    request,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    tool: tool ?? {
+      name: fallbackToolName,
+      displayName: fallbackToolName
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    invocation: invocation ?? {
+      getDescription: () => fallbackToolName
+    },
+    response: {
+      callId: request.callId,
+      responseParts: [
+        {
+          functionResponse: {
+            id: request.callId,
+            name: request.name,
+            response: {
+              error: CANCELLED_TOOL_ERROR_MESSAGE
+            }
+          }
+        }
+      ],
+      resultDisplay: void 0,
+      error: new Error(CANCELLED_TOOL_ERROR_MESSAGE),
+      errorType: ToolErrorType.UNHANDLED_EXCEPTION
+    }
+  };
+}
+var useAgentStream = ({
+  agent,
+  config,
+  addItem,
+  onCancelSubmit,
+  isShellFocused,
+  logger
+}) => {
+  const [initError] = (0, import_react98.useState)(null);
+  const [retryStatus] = (0, import_react98.useState)(null);
+  const [streamingState, setStreamingState] = (0, import_react98.useState)(
+    "idle" /* Idle */
+  );
+  const [thought, setThought] = (0, import_react98.useState)(null);
+  const [lastOutputTime, setLastOutputTime] = (0, import_react98.useState)(Date.now());
+  const currentStreamIdRef = (0, import_react98.useRef)(null);
+  const userMessageTimestampRef = (0, import_react98.useRef)(0);
+  const geminiMessageBufferRef = (0, import_react98.useRef)("");
+  const [pendingHistoryItem, pendingHistoryItemRef, setPendingHistoryItem] = useStateAndRef(null);
+  const [trackedTools, trackedToolsRef, setTrackedTools] = useStateAndRef([]);
+  const toolRequestArgsRef = (0, import_react98.useRef)(
+    /* @__PURE__ */ new Map()
+  );
+  const cancellationStateRef = (0, import_react98.useRef)(
+    "idle" /* Idle */
+  );
+  const cancelPromiseRef = (0, import_react98.useRef)(Promise.resolve());
+  const [pushedToolCallIds, pushedToolCallIdsRef, setPushedToolCallIds] = useStateAndRef(/* @__PURE__ */ new Set());
+  const [_isFirstToolInGroup, isFirstToolInGroupRef, setIsFirstToolInGroup] = useStateAndRef(true);
+  const [_hasEmittedBoxInTurn, hasEmittedBoxInTurnRef, setHasEmittedBoxInTurn] = useStateAndRef(false);
+  const { startNewPrompt } = useSessionStats();
+  const activePtyId = void 0;
+  const backgroundTaskCount = 0;
+  const isBackgroundTaskVisible = false;
+  const toggleBackgroundTasks = (0, import_react98.useCallback)(() => {
+  }, []);
+  const backgroundCurrentExecution = void 0;
+  const backgroundTasks = (0, import_react98.useMemo)(() => /* @__PURE__ */ new Map(), []);
+  const dismissBackgroundTask = (0, import_react98.useCallback)(async (_pid) => {
+  }, []);
+  const pendingToolCalls = (0, import_react98.useMemo)(
+    () => trackedTools.map((t) => ({
+      request: {
+        name: t.originalRequestName || t.name,
+        args: { command: t.description },
+        callId: t.callId,
+        isClientInitiated: t.isClientInitiated ?? false,
+        prompt_id: ""
+      },
+      status: t.status
+    })),
+    [trackedTools]
+  );
+  const [loopDetectionConfirmationRequest] = (0, import_react98.useState)(null);
+  const flushPendingText = (0, import_react98.useCallback)(() => {
+    if (pendingHistoryItemRef.current) {
+      addItem(pendingHistoryItemRef.current, userMessageTimestampRef.current);
+      setPendingHistoryItem(null);
+      geminiMessageBufferRef.current = "";
+    }
+  }, [addItem, pendingHistoryItemRef, setPendingHistoryItem]);
+  const cancelOngoingRequest = (0, import_react98.useCallback)(
+    async (clearBuffer = true) => {
+      if (!agent) {
+        return;
+      }
+      if (cancellationStateRef.current === "cancelling" /* Cancelling */) {
+        if (clearBuffer) {
+          onCancelSubmit(false, true);
+        }
+        try {
+          await cancelPromiseRef.current;
+        } catch (error) {
+          debugLogger.warn(`Error awaiting cancelTask: ${error}`);
+        }
+        return;
+      }
+      cancellationStateRef.current = "cancelling" /* Cancelling */;
+      const cancelTask = (async () => {
+        try {
+          let timeoutId2;
+          try {
+            await Promise.race([
+              agent.abort(),
+              new Promise((resolve3) => {
+                timeoutId2 = setTimeout(resolve3, 1e3);
+              })
+            ]);
+          } finally {
+            if (timeoutId2 !== void 0) {
+              clearTimeout(timeoutId2);
+            }
+          }
+          const unpushedTools = trackedToolsRef.current.filter(
+            (tc) => !pushedToolCallIdsRef.current.has(tc.callId)
+          );
+          if (unpushedTools.length > 0) {
+            setTrackedTools(
+              (prev) => prev.map((tc) => {
+                if (!pushedToolCallIdsRef.current.has(tc.callId) && tc.status !== CoreToolCallStatus.Success && tc.status !== CoreToolCallStatus.Error && tc.status !== CoreToolCallStatus.Cancelled) {
+                  return {
+                    ...tc,
+                    status: CoreToolCallStatus.Cancelled
+                  };
+                }
+                return tc;
+              })
+            );
+          }
+          try {
+            const client = config?.getGeminiClient?.();
+            const chat = client?.getChat?.();
+            if (chat) {
+              const seenCallIds = /* @__PURE__ */ new Set();
+              const synthesizedCalls = [];
+              for (const tc of unpushedTools) {
+                if (tc.isClientInitiated) {
+                  continue;
+                }
+                seenCallIds.add(tc.callId);
+                const name = tc.originalRequestName || tc.name;
+                const args = toolRequestArgsRef.current.get(tc.callId) ?? {};
+                synthesizedCalls.push(
+                  createCancelledToolCall({
+                    callId: tc.callId,
+                    name,
+                    args,
+                    isClientInitiated: false,
+                    prompt_id: ""
+                  })
+                );
+              }
+              const clientHistory = client?.getHistory?.() ?? [];
+              const lastTurn = clientHistory.at(-1);
+              if (lastTurn?.role === "model" && Array.isArray(lastTurn.parts)) {
+                let index = 0;
+                for (const part of lastTurn.parts) {
+                  const fc = part.functionCall;
+                  if (fc?.name) {
+                    const callId = fc.id ?? `${fc.name}-${Date.now()}-${index++}`;
+                    if (!seenCallIds.has(callId)) {
+                      seenCallIds.add(callId);
+                      synthesizedCalls.push(
+                        createCancelledToolCall({
+                          callId,
+                          name: fc.name,
+                          args: fc.args ?? {},
+                          isClientInitiated: false,
+                          prompt_id: ""
+                        })
+                      );
+                    }
+                  }
+                }
+              }
+              if (synthesizedCalls.length > 0) {
+                const currentModel = client?.getCurrentSequenceModel?.() ?? config?.getModel?.() ?? "";
+                chat.recordCompletedToolCalls(currentModel, synthesizedCalls);
+              }
+            }
+          } catch (error) {
+            debugLogger.warn(
+              `Error recording cancelled tool calls in agent stream: ${error}`
+            );
+          }
+          setStreamingState("idle" /* Idle */);
+          onCancelSubmit(false, clearBuffer);
+        } finally {
+          cancellationStateRef.current = "idle" /* Idle */;
+        }
+      })();
+      cancelPromiseRef.current = cancelTask;
+      try {
+        await cancelTask;
+      } catch (error) {
+        debugLogger.warn(`Error awaiting cancelTask: ${error}`);
+      }
+    },
+    [
+      agent,
+      config,
+      onCancelSubmit,
+      pushedToolCallIdsRef,
+      setStreamingState,
+      setTrackedTools,
+      trackedToolsRef
+    ]
+  );
+  const handleApprovalModeChange = (0, import_react98.useCallback)(
+    async (newApprovalMode) => {
+      debugLogger.debug(`Approval mode changed to ${newApprovalMode} (stub)`);
+    },
+    []
+  );
+  const handleEvent = (0, import_react98.useCallback)(
+    (event) => {
+      setLastOutputTime(Date.now());
+      switch (event.type) {
+        case "agent_start":
+          setStreamingState("responding" /* Responding */);
+          break;
+        case "agent_end":
+          setStreamingState("idle" /* Idle */);
+          flushPendingText();
+          break;
+        case "message":
+          if (event.role === "agent") {
+            for (const part of event.content) {
+              if (part.type === "text") {
+                geminiMessageBufferRef.current += part.text;
+                const splitPoint = findLastSafeSplitPoint(
+                  geminiMessageBufferRef.current
+                );
+                if (splitPoint === geminiMessageBufferRef.current.length) {
+                  setPendingHistoryItem({
+                    type: "gemini",
+                    text: geminiMessageBufferRef.current
+                  });
+                } else {
+                  const before = geminiMessageBufferRef.current.substring(
+                    0,
+                    splitPoint
+                  );
+                  const after = geminiMessageBufferRef.current.substring(splitPoint);
+                  addItem(
+                    { type: "gemini", text: before },
+                    userMessageTimestampRef.current
+                  );
+                  geminiMessageBufferRef.current = after;
+                  setPendingHistoryItem({
+                    type: "gemini_content",
+                    text: after
+                  });
+                }
+              } else if (part.type === "thought") {
+                setThought(parseThought(part.thought));
+              }
+            }
+          }
+          break;
+        case "tool_request": {
+          flushPendingText();
+          toolRequestArgsRef.current.set(event.requestId, event.args);
+          const legacyState = event._meta?.legacyState;
+          const displayName = legacyState?.displayName ?? event.name;
+          const isOutputMarkdown = legacyState?.isOutputMarkdown ?? false;
+          const desc = legacyState?.description ?? "";
+          const fallbackKind = Kind.Other;
+          const newCall = {
+            callId: event.requestId,
+            name: displayName,
+            originalRequestName: event.name,
+            description: desc,
+            display: event.display,
+            status: CoreToolCallStatus.Scheduled,
+            isClientInitiated: false,
+            renderOutputAsMarkdown: isOutputMarkdown,
+            kind: legacyState?.kind ?? fallbackKind,
+            confirmationDetails: void 0,
+            resultDisplay: void 0
+          };
+          setTrackedTools((prev) => [...prev, newCall]);
+          break;
+        }
+        case "tool_update": {
+          setTrackedTools(
+            (prev) => prev.map((tc) => {
+              if (tc.callId !== event.requestId) return tc;
+              const legacyState = event._meta?.legacyState;
+              const evtStatus = legacyState?.status;
+              let status = tc.status;
+              if (evtStatus === "executing")
+                status = CoreToolCallStatus.Executing;
+              else if (evtStatus === "error") status = CoreToolCallStatus.Error;
+              else if (evtStatus === "success")
+                status = CoreToolCallStatus.Success;
+              const display = event.display?.result;
+              const liveOutput = displayContentToString(display) ?? tc.resultDisplay;
+              const progressMessage = legacyState?.progressMessage ?? tc.progressMessage;
+              const progress = legacyState?.progress ?? tc.progress;
+              const progressTotal = legacyState?.progressTotal ?? tc.progressTotal;
+              const ptyId = legacyState?.pid ?? tc.ptyId;
+              const description = legacyState?.description ?? tc.description;
+              return {
+                ...tc,
+                status,
+                display: event.display ? { ...tc.display, ...event.display } : tc.display,
+                resultDisplay: liveOutput,
+                progressMessage,
+                progress,
+                progressTotal,
+                ptyId,
+                description
+              };
+            })
+          );
+          break;
+        }
+        case "tool_response": {
+          setTrackedTools(
+            (prev) => prev.map((tc) => {
+              if (tc.callId !== event.requestId) return tc;
+              const legacyState = event._meta?.legacyState;
+              const outputFile = legacyState?.outputFile;
+              const display = event.display?.result;
+              const resultDisplay = displayContentToString(display) ?? tc.resultDisplay;
+              return {
+                ...tc,
+                status: event.isError ? CoreToolCallStatus.Error : CoreToolCallStatus.Success,
+                display: event.display ? { ...tc.display, ...event.display } : tc.display,
+                resultDisplay,
+                outputFile
+              };
+            })
+          );
+          break;
+        }
+        case "error": {
+          const message = event._meta?.["code"] === "AGENT_EXECUTION_BLOCKED" ? `Agent execution blocked: ${event.message}` : event.message;
+          addItem(
+            { type: "error" /* ERROR */, text: message },
+            userMessageTimestampRef.current
+          );
+          break;
+        }
+        case "initialize":
+        case "session_update":
+        case "elicitation_request":
+        case "elicitation_response":
+        case "usage":
+        case "custom":
+          break;
+        default:
+          debugLogger.error("Unknown agent event type:", event);
+          event;
+          break;
+      }
+    },
+    [
+      addItem,
+      flushPendingText,
+      setPendingHistoryItem,
+      setTrackedTools,
+      setStreamingState,
+      setThought,
+      setLastOutputTime
+    ]
+  );
+  (0, import_react98.useEffect)(() => {
+    const unsubscribe = agent?.subscribe(handleEvent);
+    return () => unsubscribe?.();
+  }, [agent, handleEvent]);
+  useKeypress(
+    (key) => {
+      if (key.name === "escape" && !isShellFocused) {
+        void cancelOngoingRequest(false);
+        return true;
+      }
+      return false;
+    },
+    {
+      isActive: streamingState === "responding" /* Responding */ || streamingState === "waiting_for_confirmation" /* WaitingForConfirmation */
+    }
+  );
+  const submitQuery = (0, import_react98.useCallback)(
+    async (query, options, _prompt_id) => {
+      if (!agent) return;
+      const timestamp = Date.now();
+      setLastOutputTime(timestamp);
+      userMessageTimestampRef.current = timestamp;
+      geminiMessageBufferRef.current = "";
+      if (!options?.isContinuation) {
+        toolRequestArgsRef.current.clear();
+        if (typeof query === "string") {
+          addItem({ type: "user" /* USER */, text: query }, timestamp);
+          void logger?.logMessage(MessageSenderType.USER, query);
+        }
+        startNewPrompt();
+      }
+      const parts = geminiPartsToContentParts(
+        typeof query === "string" ? [{ text: query }] : query
+      );
+      try {
+        const { streamId } = await agent.send({
+          message: { content: parts }
+        });
+        currentStreamIdRef.current = streamId;
+      } catch (err) {
+        addItem(
+          { type: "error" /* ERROR */, text: getErrorMessage(err) },
+          timestamp
+        );
+      }
+    },
+    [agent, addItem, logger, startNewPrompt]
+  );
+  (0, import_react98.useEffect)(() => {
+    if (trackedTools.length > 0) {
+      const isNewBatch = !trackedTools.some(
+        (tc) => pushedToolCallIdsRef.current.has(tc.callId)
+      );
+      if (isNewBatch) {
+        setPushedToolCallIds(/* @__PURE__ */ new Set());
+        setIsFirstToolInGroup(true);
+      }
+    } else if (streamingState === "idle" /* Idle */) {
+      setPushedToolCallIds(/* @__PURE__ */ new Set());
+      setIsFirstToolInGroup(true);
+    }
+  }, [
+    trackedTools,
+    pushedToolCallIdsRef,
+    setPushedToolCallIds,
+    setIsFirstToolInGroup,
+    streamingState
+  ]);
+  (0, import_react98.useEffect)(() => {
+    if (trackedTools.length === 0) return;
+    const allTerminal = trackedTools.every(
+      (tc) => tc.status === "success" || tc.status === "error" || tc.status === "cancelled"
+    );
+    const toolsToPush = trackedTools.filter(
+      (tc) => !pushedToolCallIdsRef.current.has(tc.callId)
+    );
+    if (allTerminal && toolsToPush.length > 0) {
+      const newPushed = new Set(pushedToolCallIdsRef.current);
+      for (const tc of toolsToPush) {
+        newPushed.add(tc.callId);
+      }
+      const appearance = getToolGroupBorderAppearance(
+        { type: "tool_group", tools: trackedTools },
+        activePtyId,
+        !!isShellFocused,
+        [],
+        backgroundTasks
+      );
+      const hasBoxInBatch = toolsToPush.some(
+        (tc) => tc.display?.format !== "notice"
+      );
+      const shouldStartNewBlock = isFirstToolInGroupRef.current || !hasEmittedBoxInTurnRef.current && hasBoxInBatch;
+      const historyItem = {
+        type: "tool_display_group",
+        tools: toolsToPush.map((tc) => ({
+          name: tc.name,
+          description: tc.description,
+          ...tc.display,
+          status: tc.status,
+          originalRequestName: tc.originalRequestName
+        })),
+        borderTop: shouldStartNewBlock,
+        borderBottom: true,
+        ...appearance
+      };
+      addItem(historyItem);
+      setPushedToolCallIds(newPushed);
+      if (hasBoxInBatch) {
+        setHasEmittedBoxInTurn(true);
+      }
+      setIsFirstToolInGroup(false);
+    }
+  }, [
+    trackedTools,
+    pushedToolCallIdsRef,
+    isFirstToolInGroupRef,
+    hasEmittedBoxInTurnRef,
+    setPushedToolCallIds,
+    setIsFirstToolInGroup,
+    setHasEmittedBoxInTurn,
+    addItem,
+    activePtyId,
+    isShellFocused,
+    backgroundTasks
+  ]);
+  const pendingToolGroupItems = (0, import_react98.useMemo)(() => {
+    const remainingTools = trackedTools.filter(
+      (tc) => !pushedToolCallIdsRef.current.has(tc.callId)
+    );
+    const items = [];
+    const appearance = getToolGroupBorderAppearance(
+      { type: "tool_group", tools: trackedTools },
+      activePtyId,
+      !!isShellFocused,
+      [],
+      backgroundTasks
+    );
+    if (remainingTools.length > 0) {
+      const hasBoxInPending = remainingTools.some(
+        (tc) => tc.display?.format !== "notice"
+      );
+      const shouldStartNewBlock = pushedToolCallIds.size === 0 || !hasEmittedBoxInTurnRef.current && hasBoxInPending;
+      items.push({
+        type: "tool_display_group",
+        tools: remainingTools.map((tc) => ({
+          name: tc.name,
+          description: tc.description,
+          ...tc.display,
+          status: tc.status,
+          originalRequestName: tc.originalRequestName
+        })),
+        borderTop: shouldStartNewBlock,
+        borderBottom: false,
+        ...appearance
+      });
+    }
+    const allTerminal = trackedTools.length > 0 && trackedTools.every(
+      (tc) => tc.status === "success" || tc.status === "error" || tc.status === "cancelled"
+    );
+    const allPushed = trackedTools.length > 0 && trackedTools.every((tc) => pushedToolCallIds.has(tc.callId));
+    const anyVisibleInHistory = pushedToolCallIds.size > 0;
+    const anyVisibleInPending = remainingTools.length > 0;
+    if (trackedTools.length > 0 && !(allTerminal && allPushed) && (anyVisibleInHistory || anyVisibleInPending)) {
+      items.push({
+        type: "tool_display_group",
+        tools: [],
+        borderTop: false,
+        borderBottom: true,
+        ...appearance
+      });
+    }
+    return items;
+  }, [
+    trackedTools,
+    pushedToolCallIds,
+    pushedToolCallIdsRef,
+    hasEmittedBoxInTurnRef,
+    activePtyId,
+    isShellFocused,
+    backgroundTasks
+  ]);
+  const pendingHistoryItems = (0, import_react98.useMemo)(
+    () => [pendingHistoryItem, ...pendingToolGroupItems].filter(
+      (i) => i !== void 0 && i !== null
+    ),
+    [pendingHistoryItem, pendingToolGroupItems]
+  );
+  return {
+    streamingState,
+    submitQuery,
+    initError,
+    pendingHistoryItems,
+    thought,
+    cancelOngoingRequest,
+    pendingToolCalls,
+    handleApprovalModeChange,
+    activePtyId,
+    loopDetectionConfirmationRequest,
+    lastOutputTime,
+    backgroundTaskCount,
+    isBackgroundTaskVisible,
+    toggleBackgroundTasks,
+    backgroundCurrentExecution,
+    backgroundTasks,
+    retryStatus,
+    dismissBackgroundTask
+  };
+};
+
+// packages/cli/src/ui/hooks/useGeminiStream.ts
 var isTopicTool2 = (name) => name === UPDATE_TOPIC_TOOL_NAME || name === UPDATE_TOPIC_DISPLAY_NAME;
 var SUPPRESSED_TOOL_ERRORS_NOTE = 'Some internal tool attempts failed before this final error. Press F12 for diagnostics, or run /settings and change "Error Verbosity" to full for details.';
 var LOW_VERBOSITY_FAILURE_NOTE = 'This request failed. Press F12 for diagnostics, or run /settings and change "Error Verbosity" to full for full details.';
@@ -27122,35 +27758,41 @@ function calculateStreamingState(isResponding, toolCalls) {
   return "idle" /* Idle */;
 }
 var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, _performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onCancelSubmit, setShellInputFocused, terminalWidth, terminalHeight, isShellFocused, consumeUserHint) => {
-  const [initError, setInitError] = (0, import_react97.useState)(null);
-  const [retryStatus, setRetryStatus] = (0, import_react97.useState)(
+  const [initError, setInitError] = (0, import_react99.useState)(null);
+  const [retryStatus, setRetryStatus] = (0, import_react99.useState)(
     null
   );
   const isLowErrorVerbosity = settings.merged.ui?.errorVerbosity !== "full";
-  const suppressedToolErrorCountRef = (0, import_react97.useRef)(0);
-  const suppressedToolErrorNoteShownRef = (0, import_react97.useRef)(false);
-  const lowVerbosityFailureNoteShownRef = (0, import_react97.useRef)(false);
-  const abortControllerRef = (0, import_react97.useRef)(null);
-  const turnCancelledRef = (0, import_react97.useRef)(false);
-  const activeQueryIdRef = (0, import_react97.useRef)(null);
-  const previousApprovalModeRef = (0, import_react97.useRef)(
+  const suppressedToolErrorCountRef = (0, import_react99.useRef)(0);
+  const suppressedToolErrorNoteShownRef = (0, import_react99.useRef)(false);
+  const lowVerbosityFailureNoteShownRef = (0, import_react99.useRef)(false);
+  const abortControllerRef = (0, import_react99.useRef)(null);
+  const turnCancelledRef = (0, import_react99.useRef)(false);
+  const pendingToolCallRequestsRef = (0, import_react99.useRef)([]);
+  const activeSchedulePromiseRef = (0, import_react99.useRef)(null);
+  const cancellationStateRef = (0, import_react99.useRef)(
+    "idle" /* Idle */
+  );
+  const cancelPromiseRef = (0, import_react99.useRef)(Promise.resolve());
+  const activeQueryIdRef = (0, import_react99.useRef)(null);
+  const previousApprovalModeRef = (0, import_react99.useRef)(
     config.getApprovalMode()
   );
   const [isResponding, isRespondingRef, setIsResponding] = useStateAndRef(false);
   const [thought, thoughtRef, setThought] = useStateAndRef(null);
   const [pendingHistoryItem, pendingHistoryItemRef, setPendingHistoryItem] = useStateAndRef(null);
-  const [lastGeminiActivityTime, setLastGeminiActivityTime] = (0, import_react97.useState)(0);
+  const [lastGeminiActivityTime, setLastGeminiActivityTime] = (0, import_react99.useState)(0);
   const [pushedToolCallIds, pushedToolCallIdsRef, setPushedToolCallIds] = useStateAndRef(/* @__PURE__ */ new Set());
   const [_isFirstToolInGroup, isFirstToolInGroupRef, setIsFirstToolInGroup] = useStateAndRef(true);
   const { startNewPrompt, getPromptCount } = useSessionStats();
   const logger = useLogger(config);
-  const gitService = (0, import_react97.useMemo)(() => {
+  const gitService = (0, import_react99.useMemo)(() => {
     if (!config.getProjectRoot()) {
       return;
     }
     return new GitService(config.getProjectRoot(), config.storage);
   }, [config]);
-  (0, import_react97.useEffect)(() => {
+  (0, import_react99.useEffect)(() => {
     const handleRetryAttempt = (payload) => {
       if (turnCancelledRef.current || !isRespondingRef.current) {
         return;
@@ -27171,6 +27813,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     lastToolOutputTime
   ] = useToolScheduler(
     async (completedToolCallsFromScheduler) => {
+      pendingToolCallRequestsRef.current = [];
       if (completedToolCallsFromScheduler.length > 0) {
         const toolsToPush = completedToolCallsFromScheduler.filter(
           (tc) => !pushedToolCallIdsRef.current.has(tc.request.callId)
@@ -27205,15 +27848,25 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
         }
         setToolCallsForDisplay([]);
         try {
-          const currentModel = config.getGeminiClient().getCurrentSequenceModel() ?? config.getModel();
-          config.getGeminiClient().getChat().recordCompletedToolCalls(
-            currentModel,
-            completedToolCallsFromScheduler
-          );
-          await recordToolCallInteractions(
-            config,
-            completedToolCallsFromScheduler
+          const client = geminiClient ?? config.getGeminiClient();
+          const currentModel = client?.getCurrentSequenceModel?.() ?? config.getModel();
+          const normalizedCompletedCalls = completedToolCallsFromScheduler.map(
+            (tc) => {
+              if (tc.status === CoreToolCallStatus.Cancelled && (!tc.response?.responseParts || tc.response.responseParts.length === 0)) {
+                return {
+                  ...tc,
+                  response: createCancelledToolCall(
+                    tc.request,
+                    tc.tool,
+                    tc.invocation
+                  ).response
+                };
+              }
+              return tc;
+            }
           );
+          client?.getChat?.()?.recordCompletedToolCalls(currentModel, normalizedCompletedCalls);
+          await recordToolCallInteractions(config, normalizedCompletedCalls);
         } catch (error) {
           debugLogger.warn(
             `Error recording completed tool call information: ${error}`
@@ -27225,13 +27878,13 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     config,
     getPreferredEditor
   );
-  const activeBackgroundExecutionId = (0, import_react97.useMemo)(() => {
+  const activeBackgroundExecutionId = (0, import_react99.useMemo)(() => {
     const executingBackgroundableTool = toolCalls.find(
       isBackgroundableExecutingToolCall
     );
     return executingBackgroundableTool?.pid;
   }, [toolCalls]);
-  const onExec = (0, import_react97.useCallback)(
+  const onExec = (0, import_react99.useCallback)(
     async (done) => {
       setIsResponding(true);
       await done;
@@ -27262,11 +27915,11 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     terminalHeight,
     activeBackgroundExecutionId
   );
-  const streamingState = (0, import_react97.useMemo)(
+  const streamingState = (0, import_react99.useMemo)(
     () => calculateStreamingState(isResponding, toolCalls),
     [isResponding, toolCalls]
   );
-  (0, import_react97.useEffect)(() => {
+  (0, import_react99.useEffect)(() => {
     if (toolCalls.length > 0) {
       const isNewBatch = !toolCalls.some(
         (tc) => pushedToolCallIdsRef.current.has(tc.request.callId)
@@ -27286,7 +27939,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     setIsFirstToolInGroup,
     streamingState
   ]);
-  (0, import_react97.useEffect)(() => {
+  (0, import_react99.useEffect)(() => {
     const toolsToPush = [];
     for (let i = 0; i < toolCalls.length; i++) {
       const tc = toolCalls[i];
@@ -27386,7 +28039,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     backgroundTasks,
     settings.merged.ui?.compactToolOutput
   ]);
-  const pendingToolGroupItems = (0, import_react97.useMemo)(() => {
+  const pendingToolGroupItems = (0, import_react99.useMemo)(() => {
     const remainingTools = toolCalls.filter(
       (tc) => !pushedToolCallIds.has(tc.request.callId)
     );
@@ -27456,26 +28109,26 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     backgroundTasks,
     settings.merged.ui?.compactToolOutput
   ]);
-  const lastQueryRef = (0, import_react97.useRef)(null);
-  const lastPromptIdRef = (0, import_react97.useRef)(null);
-  const loopDetectedRef = (0, import_react97.useRef)(false);
-  const autoNudgeAttemptCountRef = (0, import_react97.useRef)(0);
+  const lastQueryRef = (0, import_react99.useRef)(null);
+  const lastPromptIdRef = (0, import_react99.useRef)(null);
+  const loopDetectedRef = (0, import_react99.useRef)(false);
+  const autoNudgeAttemptCountRef = (0, import_react99.useRef)(0);
   const MAX_AUTO_NUDGE_ATTEMPTS = 2;
-  const submitQueryRef = (0, import_react97.useRef)(null);
+  const submitQueryRef = (0, import_react99.useRef)(null);
   const [
     loopDetectionConfirmationRequest,
     setLoopDetectionConfirmationRequest
-  ] = (0, import_react97.useState)(null);
+  ] = (0, import_react99.useState)(null);
   const activePtyId = activeShellPtyId ?? activeBackgroundExecutionId ?? void 0;
-  const prevActiveShellPtyIdRef = (0, import_react97.useRef)(null);
-  (0, import_react97.useEffect)(() => {
+  const prevActiveShellPtyIdRef = (0, import_react99.useRef)(null);
+  (0, import_react99.useEffect)(() => {
     if (turnCancelledRef.current && prevActiveShellPtyIdRef.current !== null && activeShellPtyId === null) {
       addItem({ type: "info" /* INFO */, text: "Request cancelled." });
       setIsResponding(false);
     }
     prevActiveShellPtyIdRef.current = activeShellPtyId;
   }, [activeShellPtyId, addItem, setIsResponding]);
-  (0, import_react97.useEffect)(() => {
+  (0, import_react99.useEffect)(() => {
     if (config.getApprovalMode() === ApprovalMode.YOLO && streamingState === "idle" /* Idle */) {
       const lastUserMessageIndex = history.findLastIndex(
         (item) => item.type === "user" /* USER */
@@ -27489,12 +28142,12 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       }
     }
   }, [streamingState, config, history]);
-  (0, import_react97.useEffect)(() => {
+  (0, import_react99.useEffect)(() => {
     if (!isResponding) {
       setRetryStatus(null);
     }
   }, [isResponding]);
-  const maybeAddSuppressedToolErrorNote = (0, import_react97.useCallback)(
+  const maybeAddSuppressedToolErrorNote = (0, import_react99.useCallback)(
     (userMessageTimestamp) => {
       if (!isLowErrorVerbosity) {
         return;
@@ -27516,7 +28169,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     },
     [addItem, isLowErrorVerbosity]
   );
-  const maybeAddLowVerbosityFailureNote = (0, import_react97.useCallback)(
+  const maybeAddLowVerbosityFailureNote = (0, import_react99.useCallback)(
     (userMessageTimestamp) => {
       if (!isLowErrorVerbosity || config.getDebugMode()) {
         return;
@@ -27535,16 +28188,25 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     },
     [addItem, config, isLowErrorVerbosity]
   );
-  const cancelOngoingRequest = (0, import_react97.useCallback)(
-    (clearBuffer = true) => {
+  const cancelOngoingRequest = (0, import_react99.useCallback)(
+    async (clearBuffer = true) => {
       if (turnCancelledRef.current) {
         if (clearBuffer) {
           onCancelSubmit(false, true);
         }
+        if (cancellationStateRef.current === "cancelling" /* Cancelling */) {
+          try {
+            await cancelPromiseRef.current;
+          } catch (error) {
+            debugLogger.warn(
+              `Error awaiting schedulePromise on cancel: ${error}`
+            );
+          }
+        }
         return;
       }
-      const hasActiveTools = toolCalls.some(
-        (tc) => tc.status === CoreToolCallStatus.Executing || tc.status === CoreToolCallStatus.Scheduled || tc.status === CoreToolCallStatus.Validating
+      const hasActiveTools = pendingToolCallRequestsRef.current.length > 0 || toolCalls.some(
+        (tc) => tc.status === CoreToolCallStatus.Executing || tc.status === CoreToolCallStatus.Scheduled || tc.status === CoreToolCallStatus.Validating || tc.status === CoreToolCallStatus.AwaitingApproval
       );
       if (streamingState === "idle" /* Idle */ && !isRespondingRef.current && !hasActiveTools) {
         if (clearBuffer) {
@@ -27562,6 +28224,74 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       }
       abortControllerRef.current.abort();
       cancelAllToolCalls(abortControllerRef.current.signal);
+      try {
+        const client = geminiClient ?? config.getGeminiClient?.();
+        const chat = client?.getChat?.();
+        if (chat) {
+          const seenCallIds = /* @__PURE__ */ new Set();
+          const synthesizedCalls = [];
+          for (const tc of toolCalls) {
+            if (tc.request.isClientInitiated) {
+              continue;
+            }
+            const isAlreadySubmitted = (tc.status === CoreToolCallStatus.Success || tc.status === CoreToolCallStatus.Error || tc.status === CoreToolCallStatus.Cancelled) && tc.responseSubmittedToGemini;
+            if (isAlreadySubmitted) {
+              seenCallIds.add(tc.request.callId);
+              continue;
+            }
+            seenCallIds.add(tc.request.callId);
+            if ((tc.status === CoreToolCallStatus.Success || tc.status === CoreToolCallStatus.Error || tc.status === CoreToolCallStatus.Cancelled) && (tc.response?.responseParts?.length ?? 0) > 0) {
+              synthesizedCalls.push(tc);
+            } else {
+              synthesizedCalls.push(
+                createCancelledToolCall(
+                  tc.request,
+                  tc.tool,
+                  "invocation" in tc ? tc.invocation : void 0
+                )
+              );
+            }
+          }
+          for (const req of pendingToolCallRequestsRef.current) {
+            if (req.isClientInitiated || seenCallIds.has(req.callId)) {
+              continue;
+            }
+            seenCallIds.add(req.callId);
+            synthesizedCalls.push(createCancelledToolCall(req));
+          }
+          const clientHistory = client?.getHistory?.() ?? [];
+          const lastTurn = clientHistory.at(-1);
+          if (lastTurn?.role === "model" && Array.isArray(lastTurn.parts)) {
+            let index = 0;
+            for (const part of lastTurn.parts) {
+              const fc = part.functionCall;
+              if (fc?.name) {
+                const callId = fc.id ?? `${fc.name}-${Date.now()}-${index++}`;
+                if (!seenCallIds.has(callId)) {
+                  seenCallIds.add(callId);
+                  synthesizedCalls.push(
+                    createCancelledToolCall({
+                      callId,
+                      name: fc.name,
+                      args: fc.args ?? {},
+                      isClientInitiated: false,
+                      prompt_id: lastPromptIdRef.current ?? ""
+                    })
+                  );
+                }
+              }
+            }
+          }
+          if (synthesizedCalls.length > 0) {
+            const currentModel = client?.getCurrentSequenceModel?.() ?? config.getModel?.() ?? "";
+            chat.recordCompletedToolCalls(currentModel, synthesizedCalls);
+          }
+        }
+      } catch (error) {
+        debugLogger.warn(
+          `Error recording cancelled tool calls on abort: ${error}`
+        );
+      }
       if (pendingHistoryItemRef.current) {
         if (pendingHistoryItemRef.current.type === "tool_group" && pendingHistoryItemRef.current.tools.some(
           (t) => t.name === SHELL_COMMAND_NAME
@@ -27598,6 +28328,35 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       }
       onCancelSubmit(false, clearBuffer);
       setShellInputFocused(false);
+      const schedulePromise = activeSchedulePromiseRef.current;
+      if (schedulePromise) {
+        cancellationStateRef.current = "cancelling" /* Cancelling */;
+        const cancelTask = (async () => {
+          let timeoutId2;
+          try {
+            await Promise.race([
+              Promise.resolve(schedulePromise).catch(() => {
+              }),
+              new Promise((resolve3) => {
+                timeoutId2 = setTimeout(resolve3, 1e3);
+              })
+            ]);
+          } finally {
+            if (timeoutId2 !== void 0) {
+              clearTimeout(timeoutId2);
+            }
+            cancellationStateRef.current = "idle" /* Idle */;
+          }
+        })();
+        cancelPromiseRef.current = cancelTask;
+        try {
+          await cancelTask;
+        } catch (error) {
+          debugLogger.warn(
+            `Error awaiting schedulePromise on cancel: ${error}`
+          );
+        }
+      }
     },
     [
       streamingState,
@@ -27610,13 +28369,15 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       cancelAllToolCalls,
       toolCalls,
       activeShellPtyId,
-      setIsResponding
+      setIsResponding,
+      geminiClient,
+      config
     ]
   );
   useKeypress(
     (key) => {
       if (key.name === "escape" && !isShellFocused) {
-        cancelOngoingRequest(false);
+        void cancelOngoingRequest(false);
         return true;
       }
       return false;
@@ -27625,7 +28386,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       isActive: streamingState === "responding" /* Responding */ || streamingState === "waiting_for_confirmation" /* WaitingForConfirmation */
     }
   );
-  const prepareQueryForGemini = (0, import_react97.useCallback)(
+  const prepareQueryForGemini = (0, import_react99.useCallback)(
     async (query, userMessageTimestamp, abortSignal, prompt_id) => {
       if (turnCancelledRef.current) {
         return { queryToSend: null, shouldProceed: false };
@@ -27731,7 +28492,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       settings
     ]
   );
-  const handleContentEvent = (0, import_react97.useCallback)(
+  const handleContentEvent = (0, import_react99.useCallback)(
     (eventValue, currentGeminiMessageBuffer, userMessageTimestamp) => {
       setRetryStatus(null);
       if (turnCancelledRef.current) {
@@ -27772,7 +28533,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     },
     [addItem, pendingHistoryItemRef, setPendingHistoryItem]
   );
-  const handleThoughtEvent = (0, import_react97.useCallback)(
+  const handleThoughtEvent = (0, import_react99.useCallback)(
     (eventValue, _userMessageTimestamp) => {
       setThought(eventValue);
       if (getInlineThinkingMode(settings) === "full") {
@@ -27784,7 +28545,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     },
     [addItem, settings, setThought]
   );
-  const handleUserCancelledEvent = (0, import_react97.useCallback)(
+  const handleUserCancelledEvent = (0, import_react99.useCallback)(
     (userMessageTimestamp) => {
       if (turnCancelledRef.current) {
         return;
@@ -27819,7 +28580,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       setIsResponding
     ]
   );
-  const handleErrorEvent = (0, import_react97.useCallback)(
+  const handleErrorEvent = (0, import_react99.useCallback)(
     (eventValue, userMessageTimestamp) => {
       if (pendingHistoryItemRef.current) {
         addItem(pendingHistoryItemRef.current, userMessageTimestamp);
@@ -27852,7 +28613,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       maybeAddLowVerbosityFailureNote
     ]
   );
-  const handleInvalidStreamEvent = (0, import_react97.useCallback)(
+  const handleInvalidStreamEvent = (0, import_react99.useCallback)(
     (eventValue, userMessageTimestamp) => {
       if (pendingHistoryItemRef.current) {
         addItem(pendingHistoryItemRef.current, userMessageTimestamp);
@@ -27898,7 +28659,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       geminiClient
     ]
   );
-  const handleCitationEvent = (0, import_react97.useCallback)(
+  const handleCitationEvent = (0, import_react99.useCallback)(
     (text, userMessageTimestamp) => {
       if (!showCitations(settings)) {
         return;
@@ -27911,7 +28672,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     },
     [addItem, pendingHistoryItemRef, setPendingHistoryItem, settings]
   );
-  const handleFinishedEvent = (0, import_react97.useCallback)(
+  const handleFinishedEvent = (0, import_react99.useCallback)(
     (event, userMessageTimestamp) => {
       const finishReason = event.value.reason;
       if (!finishReason) {
@@ -27947,7 +28708,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     },
     [addItem]
   );
-  const handleChatCompressionEvent = (0, import_react97.useCallback)(
+  const handleChatCompressionEvent = (0, import_react99.useCallback)(
     (eventValue, userMessageTimestamp) => {
       if (pendingHistoryItemRef.current) {
         addItem(pendingHistoryItemRef.current, userMessageTimestamp);
@@ -27973,14 +28734,14 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     },
     [addItem, pendingHistoryItemRef, setPendingHistoryItem, config]
   );
-  const handleMaxSessionTurnsEvent = (0, import_react97.useCallback)(
+  const handleMaxSessionTurnsEvent = (0, import_react99.useCallback)(
     () => addItem({
       type: "info",
       text: `The session has reached the maximum number of turns: ${config.getMaxSessionTurns()}. Please update this limit in your setting.json file.`
     }),
     [addItem, config]
   );
-  const handleContextWindowWillOverflowEvent = (0, import_react97.useCallback)(
+  const handleContextWindowWillOverflowEvent = (0, import_react99.useCallback)(
     (estimatedRequestTokenCount, remainingTokenCount) => {
       onCancelSubmit(true);
       const limit = tokenLimit(config.getModel());
@@ -27996,7 +28757,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     },
     [addItem, onCancelSubmit, config]
   );
-  const handleChatModelEvent = (0, import_react97.useCallback)(
+  const handleChatModelEvent = (0, import_react99.useCallback)(
     (eventValue, userMessageTimestamp) => {
       if (!settings.merged.ui.showModelInfoInChat) {
         return;
@@ -28015,7 +28776,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     },
     [addItem, pendingHistoryItemRef, setPendingHistoryItem, settings]
   );
-  const handleAgentExecutionStoppedEvent = (0, import_react97.useCallback)(
+  const handleAgentExecutionStoppedEvent = (0, import_react99.useCallback)(
     (reason, userMessageTimestamp, systemMessage, contextCleared) => {
       if (pendingHistoryItemRef.current) {
         addItem(pendingHistoryItemRef.current, userMessageTimestamp);
@@ -28048,7 +28809,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       maybeAddLowVerbosityFailureNote
     ]
   );
-  const handleAgentExecutionBlockedEvent = (0, import_react97.useCallback)(
+  const handleAgentExecutionBlockedEvent = (0, import_react99.useCallback)(
     (reason, userMessageTimestamp, systemMessage, contextCleared) => {
       if (pendingHistoryItemRef.current) {
         addItem(pendingHistoryItemRef.current, userMessageTimestamp);
@@ -28079,7 +28840,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       maybeAddLowVerbosityFailureNote
     ]
   );
-  const processGeminiStreamEvents = (0, import_react97.useCallback)(
+  const processGeminiStreamEvents = (0, import_react99.useCallback)(
     async (stream, userMessageTimestamp, signal, isContinuation, prompt_id) => {
       let geminiMessageBuffer = "";
       const toolCallRequests = [];
@@ -28102,6 +28863,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
             break;
           case GeminiEventType.ToolCallRequest:
             toolCallRequests.push(event.value);
+            pendingToolCallRequestsRef.current.push(event.value);
             break;
           case GeminiEventType.UserCancelled:
             handleUserCancelledEvent(userMessageTimestamp);
@@ -28168,7 +28930,18 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
           addItem(pendingHistoryItemRef.current, userMessageTimestamp);
           setPendingHistoryItem(null);
         }
-        await scheduleToolCalls(toolCallRequests, signal);
+        const schedulePromise = Promise.resolve(
+          scheduleToolCalls(toolCallRequests, signal)
+        );
+        activeSchedulePromiseRef.current = schedulePromise;
+        try {
+          await schedulePromise;
+        } finally {
+          if (activeSchedulePromiseRef.current === schedulePromise) {
+            activeSchedulePromiseRef.current = null;
+          }
+          pendingToolCallRequestsRef.current = [];
+        }
       } else {
         const hasVisibleText = geminiMessageBuffer.trim().length > 0;
         if (isContinuation && !hasVisibleText && autoNudgeAttemptCountRef.current < MAX_AUTO_NUDGE_ATTEMPTS) {
@@ -28205,7 +28978,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       setThought
     ]
   );
-  const submitQuery = (0, import_react97.useCallback)(
+  const submitQuery = (0, import_react99.useCallback)(
     async (query, options, prompt_id) => runInDevTraceSpan(
       {
         operation: options?.isContinuation ? GeminiCliOperation.SystemPrompt : GeminiCliOperation.UserPrompt,
@@ -28219,6 +28992,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
         activeQueryIdRef.current = queryId;
         const userMessageTimestamp = Date.now();
         if (!options?.isContinuation) {
+          pendingToolCallRequestsRef.current = [];
           autoNudgeAttemptCountRef.current = 0;
           setModelSwitchedFromQuotaError(false);
           config.setQuotaErrorOccurred(false);
@@ -28370,7 +29144,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     ]
   );
   submitQueryRef.current = submitQuery;
-  const handleApprovalModeChange = (0, import_react97.useCallback)(
+  const handleApprovalModeChange = (0, import_react99.useCallback)(
     async (newApprovalMode) => {
       if (previousApprovalModeRef.current === ApprovalMode.PLAN && newApprovalMode !== ApprovalMode.PLAN && streamingState === "idle" /* Idle */) {
         if (geminiClient) {
@@ -28433,7 +29207,7 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
     },
     [config, toolCalls, geminiClient, streamingState, addItem, onDebugMessage]
   );
-  const handleCompletedTools = (0, import_react97.useCallback)(
+  const handleCompletedTools = (0, import_react99.useCallback)(
     async (completedToolCallsFromScheduler) => {
       const completedAndReadyToSubmitTools = completedToolCallsFromScheduler.filter(
         (tc) => {
@@ -28606,13 +29380,13 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
       toolCalls
     ]
   );
-  const pendingHistoryItems = (0, import_react97.useMemo)(
+  const pendingHistoryItems = (0, import_react99.useMemo)(
     () => [pendingHistoryItem, ...pendingToolGroupItems].filter(
       (i) => i !== void 0 && i !== null
     ),
     [pendingHistoryItem, pendingToolGroupItems]
   );
-  (0, import_react97.useEffect)(() => {
+  (0, import_react99.useEffect)(() => {
     const saveRestorableToolCalls = async () => {
       if (!config.getCheckpointingEnabled()) {
         return;
@@ -28681,475 +29455,6 @@ var useGeminiStream = (geminiClient, history, addItem, config, settings, onDebug
   };
 };
 
-// packages/cli/src/ui/hooks/useAgentStream.ts
-var import_react99 = __toESM(require_react(), 1);
-
-// packages/cli/src/ui/hooks/useTurnActivityMonitor.ts
-var import_react98 = __toESM(require_react(), 1);
-var useTurnActivityMonitor = (streamingState, activePtyId, pendingToolCalls = []) => {
-  const [operationStartTime, setOperationStartTime] = (0, import_react98.useState)(0);
-  const prevPtyIdRef = (0, import_react98.useRef)(void 0);
-  const prevStreamingStateRef = (0, import_react98.useRef)(void 0);
-  (0, import_react98.useEffect)(() => {
-    const isNowResponding = streamingState === "responding" /* Responding */;
-    const wasResponding = prevStreamingStateRef.current === "responding" /* Responding */;
-    const ptyChanged = activePtyId !== prevPtyIdRef.current;
-    if (isNowResponding && (!wasResponding || ptyChanged)) {
-      setOperationStartTime(Date.now());
-    } else if (!isNowResponding && wasResponding) {
-      setOperationStartTime(0);
-    }
-    prevPtyIdRef.current = activePtyId;
-    prevStreamingStateRef.current = streamingState;
-  }, [streamingState, activePtyId]);
-  const isRedirectionActive = (0, import_react98.useMemo)(
-    () => (
-      // Check active tool calls for run_shell_command
-      pendingToolCalls.some((tc) => {
-        if (tc.request.name !== "run_shell_command") return false;
-        const command = tc.request.args?.command || "";
-        return hasRedirection(command);
-      })
-    ),
-    [pendingToolCalls]
-  );
-  return {
-    operationStartTime,
-    isRedirectionActive
-  };
-};
-
-// packages/cli/src/ui/hooks/useAgentStream.ts
-var useAgentStream = ({
-  agent,
-  addItem,
-  onCancelSubmit,
-  isShellFocused,
-  logger
-}) => {
-  const [initError] = (0, import_react99.useState)(null);
-  const [retryStatus] = (0, import_react99.useState)(null);
-  const [streamingState, setStreamingState] = (0, import_react99.useState)(
-    "idle" /* Idle */
-  );
-  const [thought, setThought] = (0, import_react99.useState)(null);
-  const [lastOutputTime, setLastOutputTime] = (0, import_react99.useState)(Date.now());
-  const currentStreamIdRef = (0, import_react99.useRef)(null);
-  const userMessageTimestampRef = (0, import_react99.useRef)(0);
-  const geminiMessageBufferRef = (0, import_react99.useRef)("");
-  const [pendingHistoryItem, pendingHistoryItemRef, setPendingHistoryItem] = useStateAndRef(null);
-  const [trackedTools, , setTrackedTools] = useStateAndRef([]);
-  const [pushedToolCallIds, pushedToolCallIdsRef, setPushedToolCallIds] = useStateAndRef(/* @__PURE__ */ new Set());
-  const [_isFirstToolInGroup, isFirstToolInGroupRef, setIsFirstToolInGroup] = useStateAndRef(true);
-  const [_hasEmittedBoxInTurn, hasEmittedBoxInTurnRef, setHasEmittedBoxInTurn] = useStateAndRef(false);
-  const { startNewPrompt } = useSessionStats();
-  const activePtyId = void 0;
-  const backgroundTaskCount = 0;
-  const isBackgroundTaskVisible = false;
-  const toggleBackgroundTasks = (0, import_react99.useCallback)(() => {
-  }, []);
-  const backgroundCurrentExecution = void 0;
-  const backgroundTasks = (0, import_react99.useMemo)(() => /* @__PURE__ */ new Map(), []);
-  const dismissBackgroundTask = (0, import_react99.useCallback)(async (_pid) => {
-  }, []);
-  const pendingToolCalls = (0, import_react99.useMemo)(
-    () => trackedTools.map((t) => ({
-      request: {
-        name: t.originalRequestName || t.name,
-        args: { command: t.description },
-        callId: t.callId,
-        isClientInitiated: t.isClientInitiated ?? false,
-        prompt_id: ""
-      },
-      status: t.status
-    })),
-    [trackedTools]
-  );
-  const [loopDetectionConfirmationRequest] = (0, import_react99.useState)(null);
-  const flushPendingText = (0, import_react99.useCallback)(() => {
-    if (pendingHistoryItemRef.current) {
-      addItem(pendingHistoryItemRef.current, userMessageTimestampRef.current);
-      setPendingHistoryItem(null);
-      geminiMessageBufferRef.current = "";
-    }
-  }, [addItem, pendingHistoryItemRef, setPendingHistoryItem]);
-  const cancelOngoingRequest = (0, import_react99.useCallback)(
-    async (clearBuffer = true) => {
-      if (agent) {
-        await agent.abort();
-        setStreamingState("idle" /* Idle */);
-        onCancelSubmit(false, clearBuffer);
-      }
-    },
-    [agent, onCancelSubmit]
-  );
-  const handleApprovalModeChange = (0, import_react99.useCallback)(
-    async (newApprovalMode) => {
-      debugLogger.debug(`Approval mode changed to ${newApprovalMode} (stub)`);
-    },
-    []
-  );
-  const handleEvent = (0, import_react99.useCallback)(
-    (event) => {
-      setLastOutputTime(Date.now());
-      switch (event.type) {
-        case "agent_start":
-          setStreamingState("responding" /* Responding */);
-          break;
-        case "agent_end":
-          setStreamingState("idle" /* Idle */);
-          flushPendingText();
-          break;
-        case "message":
-          if (event.role === "agent") {
-            for (const part of event.content) {
-              if (part.type === "text") {
-                geminiMessageBufferRef.current += part.text;
-                const splitPoint = findLastSafeSplitPoint(
-                  geminiMessageBufferRef.current
-                );
-                if (splitPoint === geminiMessageBufferRef.current.length) {
-                  setPendingHistoryItem({
-                    type: "gemini",
-                    text: geminiMessageBufferRef.current
-                  });
-                } else {
-                  const before = geminiMessageBufferRef.current.substring(
-                    0,
-                    splitPoint
-                  );
-                  const after = geminiMessageBufferRef.current.substring(splitPoint);
-                  addItem(
-                    { type: "gemini", text: before },
-                    userMessageTimestampRef.current
-                  );
-                  geminiMessageBufferRef.current = after;
-                  setPendingHistoryItem({
-                    type: "gemini_content",
-                    text: after
-                  });
-                }
-              } else if (part.type === "thought") {
-                setThought(parseThought(part.thought));
-              }
-            }
-          }
-          break;
-        case "tool_request": {
-          flushPendingText();
-          const legacyState = event._meta?.legacyState;
-          const displayName = legacyState?.displayName ?? event.name;
-          const isOutputMarkdown = legacyState?.isOutputMarkdown ?? false;
-          const desc = legacyState?.description ?? "";
-          const fallbackKind = Kind.Other;
-          const newCall = {
-            callId: event.requestId,
-            name: displayName,
-            originalRequestName: event.name,
-            description: desc,
-            display: event.display,
-            status: CoreToolCallStatus.Scheduled,
-            isClientInitiated: false,
-            renderOutputAsMarkdown: isOutputMarkdown,
-            kind: legacyState?.kind ?? fallbackKind,
-            confirmationDetails: void 0,
-            resultDisplay: void 0
-          };
-          setTrackedTools((prev) => [...prev, newCall]);
-          break;
-        }
-        case "tool_update": {
-          setTrackedTools(
-            (prev) => prev.map((tc) => {
-              if (tc.callId !== event.requestId) return tc;
-              const legacyState = event._meta?.legacyState;
-              const evtStatus = legacyState?.status;
-              let status = tc.status;
-              if (evtStatus === "executing")
-                status = CoreToolCallStatus.Executing;
-              else if (evtStatus === "error") status = CoreToolCallStatus.Error;
-              else if (evtStatus === "success")
-                status = CoreToolCallStatus.Success;
-              const display = event.display?.result;
-              const liveOutput = displayContentToString(display) ?? tc.resultDisplay;
-              const progressMessage = legacyState?.progressMessage ?? tc.progressMessage;
-              const progress = legacyState?.progress ?? tc.progress;
-              const progressTotal = legacyState?.progressTotal ?? tc.progressTotal;
-              const ptyId = legacyState?.pid ?? tc.ptyId;
-              const description = legacyState?.description ?? tc.description;
-              return {
-                ...tc,
-                status,
-                display: event.display ? { ...tc.display, ...event.display } : tc.display,
-                resultDisplay: liveOutput,
-                progressMessage,
-                progress,
-                progressTotal,
-                ptyId,
-                description
-              };
-            })
-          );
-          break;
-        }
-        case "tool_response": {
-          setTrackedTools(
-            (prev) => prev.map((tc) => {
-              if (tc.callId !== event.requestId) return tc;
-              const legacyState = event._meta?.legacyState;
-              const outputFile = legacyState?.outputFile;
-              const display = event.display?.result;
-              const resultDisplay = displayContentToString(display) ?? tc.resultDisplay;
-              return {
-                ...tc,
-                status: event.isError ? CoreToolCallStatus.Error : CoreToolCallStatus.Success,
-                display: event.display ? { ...tc.display, ...event.display } : tc.display,
-                resultDisplay,
-                outputFile
-              };
-            })
-          );
-          break;
-        }
-        case "error": {
-          const message = event._meta?.["code"] === "AGENT_EXECUTION_BLOCKED" ? `Agent execution blocked: ${event.message}` : event.message;
-          addItem(
-            { type: "error" /* ERROR */, text: message },
-            userMessageTimestampRef.current
-          );
-          break;
-        }
-        case "initialize":
-        case "session_update":
-        case "elicitation_request":
-        case "elicitation_response":
-        case "usage":
-        case "custom":
-          break;
-        default:
-          debugLogger.error("Unknown agent event type:", event);
-          event;
-          break;
-      }
-    },
-    [
-      addItem,
-      flushPendingText,
-      setPendingHistoryItem,
-      setTrackedTools,
-      setStreamingState,
-      setThought,
-      setLastOutputTime
-    ]
-  );
-  (0, import_react99.useEffect)(() => {
-    const unsubscribe = agent?.subscribe(handleEvent);
-    return () => unsubscribe?.();
-  }, [agent, handleEvent]);
-  useKeypress(
-    (key) => {
-      if (key.name === "escape" && !isShellFocused) {
-        void cancelOngoingRequest(false);
-        return true;
-      }
-      return false;
-    },
-    {
-      isActive: streamingState === "responding" /* Responding */ || streamingState === "waiting_for_confirmation" /* WaitingForConfirmation */
-    }
-  );
-  const submitQuery = (0, import_react99.useCallback)(
-    async (query, options, _prompt_id) => {
-      if (!agent) return;
-      const timestamp = Date.now();
-      setLastOutputTime(timestamp);
-      userMessageTimestampRef.current = timestamp;
-      geminiMessageBufferRef.current = "";
-      if (!options?.isContinuation) {
-        if (typeof query === "string") {
-          addItem({ type: "user" /* USER */, text: query }, timestamp);
-          void logger?.logMessage(MessageSenderType.USER, query);
-        }
-        startNewPrompt();
-      }
-      const parts = geminiPartsToContentParts(
-        typeof query === "string" ? [{ text: query }] : query
-      );
-      try {
-        const { streamId } = await agent.send({
-          message: { content: parts }
-        });
-        currentStreamIdRef.current = streamId;
-      } catch (err) {
-        addItem(
-          { type: "error" /* ERROR */, text: getErrorMessage(err) },
-          timestamp
-        );
-      }
-    },
-    [agent, addItem, logger, startNewPrompt]
-  );
-  (0, import_react99.useEffect)(() => {
-    if (trackedTools.length > 0) {
-      const isNewBatch = !trackedTools.some(
-        (tc) => pushedToolCallIdsRef.current.has(tc.callId)
-      );
-      if (isNewBatch) {
-        setPushedToolCallIds(/* @__PURE__ */ new Set());
-        setIsFirstToolInGroup(true);
-      }
-    } else if (streamingState === "idle" /* Idle */) {
-      setPushedToolCallIds(/* @__PURE__ */ new Set());
-      setIsFirstToolInGroup(true);
-    }
-  }, [
-    trackedTools,
-    pushedToolCallIdsRef,
-    setPushedToolCallIds,
-    setIsFirstToolInGroup,
-    streamingState
-  ]);
-  (0, import_react99.useEffect)(() => {
-    if (trackedTools.length === 0) return;
-    const allTerminal = trackedTools.every(
-      (tc) => tc.status === "success" || tc.status === "error" || tc.status === "cancelled"
-    );
-    const toolsToPush = trackedTools.filter(
-      (tc) => !pushedToolCallIdsRef.current.has(tc.callId)
-    );
-    if (allTerminal && toolsToPush.length > 0) {
-      const newPushed = new Set(pushedToolCallIdsRef.current);
-      for (const tc of toolsToPush) {
-        newPushed.add(tc.callId);
-      }
-      const appearance = getToolGroupBorderAppearance(
-        { type: "tool_group", tools: trackedTools },
-        activePtyId,
-        !!isShellFocused,
-        [],
-        backgroundTasks
-      );
-      const hasBoxInBatch = toolsToPush.some(
-        (tc) => tc.display?.format !== "notice"
-      );
-      const shouldStartNewBlock = isFirstToolInGroupRef.current || !hasEmittedBoxInTurnRef.current && hasBoxInBatch;
-      const historyItem = {
-        type: "tool_display_group",
-        tools: toolsToPush.map((tc) => ({
-          name: tc.name,
-          description: tc.description,
-          ...tc.display,
-          status: tc.status,
-          originalRequestName: tc.originalRequestName
-        })),
-        borderTop: shouldStartNewBlock,
-        borderBottom: true,
-        ...appearance
-      };
-      addItem(historyItem);
-      setPushedToolCallIds(newPushed);
-      if (hasBoxInBatch) {
-        setHasEmittedBoxInTurn(true);
-      }
-      setIsFirstToolInGroup(false);
-    }
-  }, [
-    trackedTools,
-    pushedToolCallIdsRef,
-    isFirstToolInGroupRef,
-    hasEmittedBoxInTurnRef,
-    setPushedToolCallIds,
-    setIsFirstToolInGroup,
-    setHasEmittedBoxInTurn,
-    addItem,
-    activePtyId,
-    isShellFocused,
-    backgroundTasks
-  ]);
-  const pendingToolGroupItems = (0, import_react99.useMemo)(() => {
-    const remainingTools = trackedTools.filter(
-      (tc) => !pushedToolCallIdsRef.current.has(tc.callId)
-    );
-    const items = [];
-    const appearance = getToolGroupBorderAppearance(
-      { type: "tool_group", tools: trackedTools },
-      activePtyId,
-      !!isShellFocused,
-      [],
-      backgroundTasks
-    );
-    if (remainingTools.length > 0) {
-      const hasBoxInPending = remainingTools.some(
-        (tc) => tc.display?.format !== "notice"
-      );
-      const shouldStartNewBlock = pushedToolCallIds.size === 0 || !hasEmittedBoxInTurnRef.current && hasBoxInPending;
-      items.push({
-        type: "tool_display_group",
-        tools: remainingTools.map((tc) => ({
-          name: tc.name,
-          description: tc.description,
-          ...tc.display,
-          status: tc.status,
-          originalRequestName: tc.originalRequestName
-        })),
-        borderTop: shouldStartNewBlock,
-        borderBottom: false,
-        ...appearance
-      });
-    }
-    const allTerminal = trackedTools.length > 0 && trackedTools.every(
-      (tc) => tc.status === "success" || tc.status === "error" || tc.status === "cancelled"
-    );
-    const allPushed = trackedTools.length > 0 && trackedTools.every((tc) => pushedToolCallIds.has(tc.callId));
-    const anyVisibleInHistory = pushedToolCallIds.size > 0;
-    const anyVisibleInPending = remainingTools.length > 0;
-    if (trackedTools.length > 0 && !(allTerminal && allPushed) && (anyVisibleInHistory || anyVisibleInPending)) {
-      items.push({
-        type: "tool_display_group",
-        tools: [],
-        borderTop: false,
-        borderBottom: true,
-        ...appearance
-      });
-    }
-    return items;
-  }, [
-    trackedTools,
-    pushedToolCallIds,
-    pushedToolCallIdsRef,
-    hasEmittedBoxInTurnRef,
-    activePtyId,
-    isShellFocused,
-    backgroundTasks
-  ]);
-  const pendingHistoryItems = (0, import_react99.useMemo)(
-    () => [pendingHistoryItem, ...pendingToolGroupItems].filter(
-      (i) => i !== void 0 && i !== null
-    ),
-    [pendingHistoryItem, pendingToolGroupItems]
-  );
-  return {
-    streamingState,
-    submitQuery,
-    initError,
-    pendingHistoryItems,
-    thought,
-    cancelOngoingRequest,
-    pendingToolCalls,
-    handleApprovalModeChange,
-    activePtyId,
-    loopDetectionConfirmationRequest,
-    lastOutputTime,
-    backgroundTaskCount,
-    isBackgroundTaskVisible,
-    toggleBackgroundTasks,
-    backgroundCurrentExecution,
-    backgroundTasks,
-    retryStatus,
-    dismissBackgroundTask
-  };
-};
-
 // packages/cli/src/ui/hooks/vim.ts
 var import_react100 = __toESM(require_react(), 1);
 var DIGIT_MULTIPLIER = 10;
@@ -32663,6 +32968,49 @@ function useVisibilityToggle() {
 var import_jsx_runtime137 = __toESM(require_jsx_runtime(), 1);
 var SHELL_WIDTH_FRACTION = 0.89;
 var SHELL_HEIGHT_PADDING = 10;
+var ENTER_SYNCHRONIZED_OUTPUT = "\x1B[?2026h";
+var EXIT_SYNCHRONIZED_OUTPUT = "\x1B[?2026l";
+var RESIZE_DEBOUNCE_MS = 100;
+var RESIZE_CORK_SAFETY_TIMEOUT_MS = 1e3;
+function discardCorkedStdoutBuffer(stream) {
+  try {
+    const state = stream._writableState;
+    if (state && (state.corked ?? 0) > 0 && Array.isArray(state.buffered)) {
+      const startIndex = state.bufferedIndex ?? 0;
+      const entries = state.buffered.slice(startIndex);
+      let discardedLength = 0;
+      for (const entry of entries) {
+        if (entry?.chunk) {
+          if (typeof entry.chunk === "string") {
+            discardedLength += Buffer.byteLength(
+              entry.chunk,
+              entry.encoding ?? "utf8"
+            );
+          } else if ("length" in entry.chunk && typeof entry.chunk.length === "number") {
+            discardedLength += entry.chunk.length;
+          }
+        }
+      }
+      state.buffered.length = startIndex;
+      state.length = Math.max(0, (state.length ?? 0) - discardedLength);
+      if ("allBuffers" in state) state.allBuffers = true;
+      if ("allNoop" in state) state.allNoop = true;
+      for (const entry of entries) {
+        if (entry && typeof entry.callback === "function") {
+          entry.callback(null);
+        }
+      }
+    }
+  } catch (error) {
+    debugLogger.warn("Failed to discard corked stdout buffer safely:", error);
+  }
+}
+function refreshStdoutSize(stream) {
+  const resizableStream = stream;
+  if (typeof resizableStream._refreshSize === "function") {
+    resizableStream._refreshSize();
+  }
+}
 var AppContainer = (props) => {
   const isHelpDismissKey = useIsHelpDismissKey();
   const keyMatchers = useKeyMatchers();
@@ -32976,12 +33324,89 @@ var AppContainer = (props) => {
     addConfirmUpdateExtensionRequest,
     addItem: historyManager.addItem
   });
+  const isStdoutCorkedRef = (0, import_react119.useRef)(false);
+  const isRefreshingStaticRef = (0, import_react119.useRef)(false);
+  const resizeCorkSafetyTimerRef = (0, import_react119.useRef)(null);
+  const resizeDebounceTimerRef = (0, import_react119.useRef)(null);
+  const lastStdoutColumnsRef = (0, import_react119.useRef)(
+    stdout.columns ?? process12.stdout.columns ?? terminalWidth
+  );
+  const lastRefreshedColumnsRef = (0, import_react119.useRef)(terminalWidth);
+  const terminalWidthRef = (0, import_react119.useRef)(terminalWidth);
+  terminalWidthRef.current = terminalWidth;
+  const clearResizeCorkSafetyTimer = (0, import_react119.useCallback)(() => {
+    if (resizeCorkSafetyTimerRef.current) {
+      clearTimeout(resizeCorkSafetyTimerRef.current);
+      resizeCorkSafetyTimerRef.current = null;
+    }
+  }, []);
+  const clearResizeDebounceTimer = (0, import_react119.useCallback)(() => {
+    if (resizeDebounceTimerRef.current) {
+      clearTimeout(resizeDebounceTimerRef.current);
+      resizeDebounceTimerRef.current = null;
+    }
+  }, []);
+  const corkStdout = (0, import_react119.useCallback)(() => {
+    if (!isStdoutCorkedRef.current && typeof stdout.cork === "function") {
+      stdout.cork();
+      isStdoutCorkedRef.current = true;
+    }
+  }, [stdout]);
+  const uncorkStdout = (0, import_react119.useCallback)(() => {
+    clearResizeCorkSafetyTimer();
+    if (isStdoutCorkedRef.current && typeof stdout.uncork === "function") {
+      isStdoutCorkedRef.current = false;
+      stdout.uncork();
+    }
+  }, [stdout, clearResizeCorkSafetyTimer]);
   const refreshStatic = (0, import_react119.useCallback)(() => {
     if (!isAlternateBuffer && !config.getUseTerminalBuffer()) {
+      clearResizeDebounceTimer();
+      refreshStdoutSize(stdout);
+      if (typeof stdout.prependListener === "function" && stdout.columns !== void 0 && stdout.columns !== terminalWidthRef.current) {
+        corkStdout();
+        clearResizeCorkSafetyTimer();
+        resizeCorkSafetyTimerRef.current = setTimeout(() => {
+          discardCorkedStdoutBuffer(stdout);
+          uncorkStdout();
+        }, RESIZE_CORK_SAFETY_TIMEOUT_MS);
+        return;
+      }
+      clearResizeCorkSafetyTimer();
+      lastRefreshedColumnsRef.current = terminalWidthRef.current;
+      if (typeof stdout.cork === "function") {
+        corkStdout();
+        discardCorkedStdoutBuffer(stdout);
+        isRefreshingStaticRef.current = true;
+        stdout.write(ENTER_SYNCHRONIZED_OUTPUT);
+      }
       stdout.write(base_exports.clearTerminal);
       setHistoryRemountKey((prev) => prev + 1);
     }
-  }, [setHistoryRemountKey, isAlternateBuffer, stdout, config]);
+  }, [
+    setHistoryRemountKey,
+    isAlternateBuffer,
+    stdout,
+    config,
+    clearResizeDebounceTimer,
+    clearResizeCorkSafetyTimer,
+    corkStdout,
+    uncorkStdout
+  ]);
+  (0, import_react119.useLayoutEffect)(() => {
+    if (isRefreshingStaticRef.current) {
+      isRefreshingStaticRef.current = false;
+      refreshStdoutSize(stdout);
+      if (stdout.columns !== void 0 && stdout.columns !== lastRefreshedColumnsRef.current) {
+        discardCorkedStdoutBuffer(stdout);
+        stdout.write(EXIT_SYNCHRONIZED_OUTPUT);
+        uncorkStdout();
+        return;
+      }
+      stdout.write(EXIT_SYNCHRONIZED_OUTPUT);
+      uncorkStdout();
+    }
+  }, [historyRemountKey, stdout, uncorkStdout]);
   const shouldUseAlternateScreen = shouldEnterAlternateScreen(
     isAlternateBuffer,
     config.getScreenReader()
@@ -33226,6 +33651,28 @@ Logging in with Google... Restarting Gemini CLI to continue.
     toggleCleanUiDetailsVisible,
     revealCleanUiDetailsTemporarily
   } = useVisibilityToggle();
+  const cancelPromiseRef = (0, import_react119.useRef)(null);
+  const awaitCancelPromise = (0, import_react119.useCallback)(async () => {
+    if (!cancelPromiseRef.current) {
+      return;
+    }
+    let timeoutId2;
+    try {
+      await Promise.race([
+        cancelPromiseRef.current,
+        new Promise((resolve3) => {
+          timeoutId2 = setTimeout(resolve3, 1e3);
+        })
+      ]);
+    } catch (error) {
+      debugLogger.warn(`Error awaiting cancellation: ${error}`);
+    } finally {
+      if (timeoutId2 !== void 0) {
+        clearTimeout(timeoutId2);
+      }
+      cancelPromiseRef.current = null;
+    }
+  }, []);
   const slashCommandActions = (0, import_react119.useMemo)(
     () => ({
       openAuthDialog: () => setAuthState("updating" /* Updating */),
@@ -33242,6 +33689,7 @@ Logging in with Google... Restarting Gemini CLI to continue.
         closeThemeDialog();
         setQuittingMessages(messages);
         setTimeout(async () => {
+          await awaitCancelPromise();
           await runExitCleanup();
           process12.exit(0);
         }, 100);
@@ -33277,6 +33725,7 @@ Logging in with Google... Restarting Gemini CLI to continue.
       openVoiceModelDialog,
       openAgentConfigDialog,
       setQuittingMessages,
+      awaitCancelPromise,
       setDebugMessage,
       setShowPrivacyNotice,
       setCorgiMode,
@@ -33423,6 +33872,7 @@ Logging in with Google... Restarting Gemini CLI to continue.
     // eslint-disable-next-line react-hooks/rules-of-hooks
     useAgentStream({
       agent: streamAgent,
+      config,
       addItem: historyManager.addItem,
       onCancelSubmit,
       isShellFocused: embeddedShellFocused,
@@ -33777,15 +34227,18 @@ ${queuedText}` : queuedText;
   const [showFullTodos, setShowFullTodos] = (0, import_react119.useState)(false);
   const [renderMarkdown, setRenderMarkdown] = (0, import_react119.useState)(true);
   const handleExitRepeat = (0, import_react119.useCallback)(
-    (count) => {
+    async (count) => {
       if (count > 2) {
         recordExitFail(config);
       }
       if (count > 1) {
-        void handleSlashCommand("/quit", void 0, void 0, false);
+        if (cancelPromiseRef.current) {
+          await awaitCancelPromise();
+        }
+        await handleSlashCommand("/quit", void 0, void 0, false);
       }
     },
-    [config, handleSlashCommand]
+    [config, handleSlashCommand, awaitCancelPromise]
   );
   const { pressCount: ctrlCPressCount, handlePress: handleCtrlCPress } = useRepeatedKeyPress({
     windowMs: WARNING_PROMPT_DURATION_MS,
@@ -33813,6 +34266,7 @@ ${queuedText}` : queuedText;
     needsRestart: ideNeedsRestart,
     restartReason: ideTrustRestartReason
   } = useIdeTrustListener();
+  const prevWidthRef = (0, import_react119.useRef)(terminalWidth);
   useIncludeDirsTrust(config, isTrustedFolder, historyManager, setCustomDialog);
   const tabFocusTimeoutRef = (0, import_react119.useRef)(null);
   (0, import_react119.useEffect)(() => {
@@ -33862,6 +34316,64 @@ ${queuedText}` : queuedText;
       setShowIdeRestartPrompt(true);
     }
   }, [ideNeedsRestart]);
+  (0, import_react119.useEffect)(() => {
+    if (isAlternateBuffer || config.getUseTerminalBuffer() || typeof stdout.prependListener !== "function") {
+      return;
+    }
+    const handleResizeStart = () => {
+      const currentColumns = stdout.columns ?? process12.stdout.columns;
+      if (currentColumns !== void 0 && currentColumns !== lastStdoutColumnsRef.current) {
+        lastStdoutColumnsRef.current = currentColumns;
+        corkStdout();
+        clearResizeCorkSafetyTimer();
+        resizeCorkSafetyTimerRef.current = setTimeout(() => {
+          discardCorkedStdoutBuffer(stdout);
+          uncorkStdout();
+        }, RESIZE_CORK_SAFETY_TIMEOUT_MS);
+      }
+    };
+    stdout.prependListener("resize", handleResizeStart);
+    return () => {
+      stdout.off("resize", handleResizeStart);
+      clearResizeDebounceTimer();
+      if (isRefreshingStaticRef.current) {
+        isRefreshingStaticRef.current = false;
+        stdout.write(EXIT_SYNCHRONIZED_OUTPUT);
+      }
+      uncorkStdout();
+    };
+  }, [
+    stdout,
+    isAlternateBuffer,
+    config,
+    corkStdout,
+    uncorkStdout,
+    clearResizeDebounceTimer,
+    clearResizeCorkSafetyTimer
+  ]);
+  (0, import_react119.useEffect)(() => {
+    if (prevWidthRef.current === terminalWidth) {
+      return;
+    }
+    prevWidthRef.current = terminalWidth;
+    if (isAlternateBuffer || config.getUseTerminalBuffer()) {
+      clearResizeDebounceTimer();
+      return;
+    }
+    clearResizeDebounceTimer();
+    resizeDebounceTimerRef.current = setTimeout(() => {
+      refreshStatic();
+    }, RESIZE_DEBOUNCE_MS);
+    return () => {
+      clearResizeDebounceTimer();
+    };
+  }, [
+    terminalWidth,
+    refreshStatic,
+    clearResizeDebounceTimer,
+    isAlternateBuffer,
+    config
+  ]);
   (0, import_react119.useEffect)(() => {
     const unsubscribe = ideContextStore.subscribe(setIdeContextState);
     setIdeContextState(ideContextStore.get());
@@ -33916,7 +34428,10 @@ ${queuedText}` : queuedText;
         return true;
       }
       if (keyMatchers["basic.quit" /* QUIT */](key)) {
-        void cancelOngoingRequest?.();
+        const cancelPromise = cancelOngoingRequest?.();
+        if (cancelPromise) {
+          cancelPromiseRef.current = cancelPromise;
+        }
         handleCtrlCPress();
         return true;
       } else if (keyMatchers["basic.exit" /* EXIT */](key)) {
@@ -33983,7 +34498,7 @@ ${queuedText}` : queuedText;
       if (keyMatchers["app.showErrorDetails" /* SHOW_ERROR_DETAILS */](key)) {
         if (settings.merged.general.devtools) {
           void (async () => {
-            const { toggleDevToolsPanel } = await import("./devtoolsService-E3YLHACW.js");
+            const { toggleDevToolsPanel } = await import("./devtoolsService-WP2OPVPB.js");
             await toggleDevToolsPanel(
               config,
               showErrorDetails,