@protolabsai/proto 0.26.9 → 0.26.13

package/cli.js

@@ -171128,7 +171128,7 @@ __export(geminiContentGenerator_exports, {
   createGeminiContentGenerator: () => createGeminiContentGenerator
 });
 function createGeminiContentGenerator(config2, gcConfig) {
-  const version2 = "0.26.9";
+  const version2 = "0.26.13";
   const userAgent2 = config2.userAgent || `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -183136,7 +183136,21 @@ var require_xterm_headless = __commonJS({
 });
 
 // packages/core/dist/src/utils/terminalSerializer.js
-function serializeTerminalToObject(terminal, scrollOffset = 0) {
+function serializeTerminalToText(terminal) {
+  const buffer = terminal.buffer.active;
+  const lines = [];
+  for (let i4 = 0; i4 < buffer.length; i4++) {
+    const line = buffer.getLine(i4);
+    const lineContent = line ? line.translateToString(true) : "";
+    if (line?.isWrapped && lines.length > 0) {
+      lines[lines.length - 1] += lineContent;
+      continue;
+    }
+    lines.push(lineContent);
+  }
+  return lines.join("\n").trimEnd();
+}
+function serializeTerminalToObject(terminal, scrollOffset = 0, options2 = {}) {
   const buffer = terminal.buffer.active;
   const defaultFg = "";
   const defaultBg = "";
@@ -183189,7 +183203,11 @@ function serializeTerminalToObject(terminal, scrollOffset = 0) {
       };
       currentLine.push(token2);
     }
-    result.push(currentLine);
+    if (options2.unwrapWrappedLines && line.isWrapped && result.length > 0) {
+      appendAnsiLineTokens(result[result.length - 1], currentLine);
+    } else {
+      result.push(currentLine);
+    }
   }
   return result;
 }
@@ -183205,11 +183223,23 @@ function convertColorToHex(color, colorMode, defaultColor) {
   }
   return defaultColor;
 }
-var Attribute, ColorMode, Cell, ANSI_COLORS;
+var canMergeAnsiTokens, appendAnsiLineTokens, Attribute, ColorMode, Cell, ANSI_COLORS;
 var init_terminalSerializer = __esm({
   "packages/core/dist/src/utils/terminalSerializer.js"() {
     "use strict";
     init_esbuild_shims();
+    canMergeAnsiTokens = /* @__PURE__ */ __name((left3, right3) => left3.bold === right3.bold && left3.italic === right3.italic && left3.underline === right3.underline && left3.dim === right3.dim && left3.inverse === right3.inverse && left3.fg === right3.fg && left3.bg === right3.bg, "canMergeAnsiTokens");
+    appendAnsiLineTokens = /* @__PURE__ */ __name((target, source2) => {
+      for (const token2 of source2) {
+        const previous = target[target.length - 1];
+        if (previous && canMergeAnsiTokens(previous, token2)) {
+          previous.text += token2.text;
+        } else {
+          target.push({ ...token2 });
+        }
+      }
+    }, "appendAnsiLineTokens");
+    __name(serializeTerminalToText, "serializeTerminalToText");
     (function(Attribute2) {
       Attribute2[Attribute2["inverse"] = 1] = "inverse";
       Attribute2[Attribute2["bold"] = 2] = "bold";
@@ -183626,7 +183656,7 @@ function applyPowerShellUtf8Prefix(command2, shell2) {
   }
   return command2;
 }
-var import_headless, Terminal, SIGKILL_TIMEOUT_MS, WINDOWS_PATH_DELIMITER, cachedWindowsPathFingerprint, cachedMergedWindowsPath, getErrnoCode, getErrorMessage2, isExpectedPtyReadExitError, isExpectedPtyExitRaceError, getFullBufferText, replayTerminalOutput, windowsStrategy, posixStrategy, getCleanupStrategy, ShellExecutionService;
+var import_headless, Terminal, SIGKILL_TIMEOUT_MS, WINDOWS_PATH_DELIMITER, cachedWindowsPathFingerprint, cachedMergedWindowsPath, getErrnoCode, getErrorMessage2, isExpectedPtyReadExitError, isExpectedPtyExitRaceError, replayTerminalOutput, getLastNonEmptyAnsiLineIndex, trimTrailingEmptyAnsiLines, areAnsiOutputsEqual, createPlainAnsiLine, serializePlainViewportToAnsiOutput, windowsStrategy, posixStrategy, getCleanupStrategy, ShellExecutionService;
 var init_shellExecutionService = __esm({
   "packages/core/dist/src/services/shellExecutionService.js"() {
     "use strict";
@@ -183669,16 +183699,6 @@ var init_shellExecutionService = __esm({
       const message = getErrorMessage2(error40);
       return message.includes("ioctl(2) failed, EBADF") || message.includes("Cannot resize a pty that has already exited");
     }, "isExpectedPtyExitRaceError");
-    getFullBufferText = /* @__PURE__ */ __name((terminal) => {
-      const buffer = terminal.buffer.active;
-      const lines = [];
-      for (let i4 = 0; i4 < buffer.length; i4++) {
-        const line = buffer.getLine(i4);
-        const lineContent = line ? line.translateToString(true) : "";
-        lines.push(lineContent);
-      }
-      return lines.join("\n").trimEnd();
-    }, "getFullBufferText");
     replayTerminalOutput = /* @__PURE__ */ __name(async (output, cols, rows) => {
       const replayTerminal = new Terminal({
         allowProposedApi: true,
@@ -183690,8 +183710,59 @@ var init_shellExecutionService = __esm({
       await new Promise((resolve38) => {
         replayTerminal.write(output, () => resolve38());
       });
-      return getFullBufferText(replayTerminal);
+      return serializeTerminalToText(replayTerminal);
     }, "replayTerminalOutput");
+    getLastNonEmptyAnsiLineIndex = /* @__PURE__ */ __name((output) => {
+      for (let i4 = output.length - 1; i4 >= 0; i4--) {
+        const line = output[i4];
+        if (line.map((segment) => segment.text).join("").trim().length > 0) {
+          return i4;
+        }
+      }
+      return -1;
+    }, "getLastNonEmptyAnsiLineIndex");
+    trimTrailingEmptyAnsiLines = /* @__PURE__ */ __name((output) => output.slice(0, getLastNonEmptyAnsiLineIndex(output) + 1), "trimTrailingEmptyAnsiLines");
+    areAnsiOutputsEqual = /* @__PURE__ */ __name((left3, right3) => {
+      if (!left3 || left3.length !== right3.length) {
+        return false;
+      }
+      return left3.every((leftLine, lineIndex) => {
+        const rightLine = right3[lineIndex];
+        if (leftLine.length !== rightLine.length) {
+          return false;
+        }
+        return leftLine.every((leftToken, tokenIndex) => {
+          const rightToken = rightLine[tokenIndex];
+          return leftToken.text === rightToken.text && leftToken.bold === rightToken.bold && leftToken.italic === rightToken.italic && leftToken.underline === rightToken.underline && leftToken.dim === rightToken.dim && leftToken.inverse === rightToken.inverse && leftToken.fg === rightToken.fg && leftToken.bg === rightToken.bg;
+        });
+      });
+    }, "areAnsiOutputsEqual");
+    createPlainAnsiLine = /* @__PURE__ */ __name((text) => [
+      {
+        text,
+        bold: false,
+        italic: false,
+        underline: false,
+        dim: false,
+        inverse: false,
+        fg: "",
+        bg: ""
+      }
+    ], "createPlainAnsiLine");
+    serializePlainViewportToAnsiOutput = /* @__PURE__ */ __name((terminal, unwrapWrappedLines = false) => {
+      const buffer = terminal.buffer.active;
+      const lines = [];
+      for (let y2 = 0; y2 < terminal.rows; y2++) {
+        const line = buffer.getLine(buffer.viewportY + y2);
+        const lineContent = line ? line.translateToString(true) : "";
+        if (unwrapWrappedLines && line?.isWrapped && lines.length > 0) {
+          lines[lines.length - 1][0].text += lineContent;
+        } else {
+          lines.push(createPlainAnsiLine(lineContent));
+        }
+      }
+      return lines;
+    }, "serializePlainViewportToAnsiOutput");
     windowsStrategy = {
       killPty: /* @__PURE__ */ __name((_pid, pty) => {
         pty.ptyProcess.kill();
@@ -183954,7 +184025,7 @@ var init_shellExecutionService = __esm({
             this.activePtys.set(ptyProcess.pid, { ptyProcess, headlessTerminal });
             let processingChain = Promise.resolve();
             let decoder = null;
-            let output = null;
+            let outputComparison = null;
             const outputChunks = [];
             const error40 = null;
             let exited = false;
@@ -183972,7 +184043,7 @@ var init_shellExecutionService = __esm({
               }
               if (!shellExecutionConfig.disableDynamicLineTrimming) {
                 if (!hasStartedOutput) {
-                  const bufferText = getFullBufferText(headlessTerminal);
+                  const bufferText = serializeTerminalToText(headlessTerminal);
                   if (bufferText.trim().length === 0) {
                     return;
                   }
@@ -183980,41 +184051,20 @@ var init_shellExecutionService = __esm({
                 }
               }
               let newOutput;
+              let newOutputComparison;
               if (shellExecutionConfig.showColor) {
                 newOutput = serializeTerminalToObject(headlessTerminal);
+                newOutputComparison = serializeTerminalToObject(headlessTerminal, 0, { unwrapWrappedLines: true });
               } else {
-                const buffer = headlessTerminal.buffer.active;
-                const lines = [];
-                for (let y2 = 0; y2 < headlessTerminal.rows; y2++) {
-                  const line = buffer.getLine(buffer.viewportY + y2);
-                  const lineContent = line ? line.translateToString(true) : "";
-                  lines.push([
-                    {
-                      text: lineContent,
-                      bold: false,
-                      italic: false,
-                      underline: false,
-                      dim: false,
-                      inverse: false,
-                      fg: "",
-                      bg: ""
-                    }
-                  ]);
-                }
-                newOutput = lines;
+                newOutput = serializePlainViewportToAnsiOutput(headlessTerminal);
+                newOutputComparison = serializePlainViewportToAnsiOutput(headlessTerminal, true);
               }
-              let lastNonEmptyLine = -1;
-              for (let i4 = newOutput.length - 1; i4 >= 0; i4--) {
-                const line = newOutput[i4];
-                if (line.map((segment) => segment.text).join("").trim().length > 0) {
-                  lastNonEmptyLine = i4;
-                  break;
-                }
-              }
-              const trimmedOutput = newOutput.slice(0, lastNonEmptyLine + 1);
+              const trimmedOutput = trimTrailingEmptyAnsiLines(newOutput);
+              const trimmedOutputComparison = trimTrailingEmptyAnsiLines(newOutputComparison);
               const finalOutput = shellExecutionConfig.disableDynamicLineTrimming ? newOutput : trimmedOutput;
-              if (JSON.stringify(output) !== JSON.stringify(finalOutput)) {
-                output = finalOutput;
+              const finalOutputComparison = shellExecutionConfig.disableDynamicLineTrimming ? newOutputComparison : trimmedOutputComparison;
+              if (!areAnsiOutputsEqual(outputComparison, finalOutputComparison)) {
+                outputComparison = finalOutputComparison;
                 onOutputEvent({
                   type: "data",
                   chunk: finalOutput
@@ -184115,11 +184165,11 @@ var init_shellExecutionService = __esm({
                     const decodedOutput = new TextDecoder2(finalEncoding).decode(finalBuffer);
                     fullOutput = await replayTerminalOutput(decodedOutput, cols, rows);
                   } else {
-                    fullOutput = getFullBufferText(headlessTerminal);
+                    fullOutput = serializeTerminalToText(headlessTerminal);
                   }
                 } catch {
                   try {
-                    fullOutput = getFullBufferText(headlessTerminal);
+                    fullOutput = serializeTerminalToText(headlessTerminal);
                   } catch {
                   }
                 }
@@ -208042,14 +208092,14 @@ function statusTask(customArgs) {
     }
   };
 }
-function versionResponse(major2 = 0, minor = 0, patch = 0, agent = "", installed = true) {
+function versionResponse(major2 = 0, minor = 0, patch = 0, agent = "", installed2 = true) {
   return Object.defineProperty(
     {
       major: major2,
       minor,
       patch,
       agent,
-      installed
+      installed: installed2
     },
     "toString",
     {
@@ -264132,8 +264182,8 @@ var require_src37 = __commonJS({
   "node_modules/sisteransi/src/index.js"(exports2, module2) {
     "use strict";
     init_esbuild_shims();
-    var ESC4 = "\x1B";
-    var CSI = `${ESC4}[`;
+    var ESC5 = "\x1B";
+    var CSI = `${ESC5}[`;
     var beep2 = "\x07";
     var cursor = {
       to(x3, y2) {
@@ -264157,8 +264207,8 @@ var require_src37 = __commonJS({
       left: `${CSI}G`,
       hide: `${CSI}?25l`,
       show: `${CSI}?25h`,
-      save: `${ESC4}7`,
-      restore: `${ESC4}8`
+      save: `${ESC5}7`,
+      restore: `${ESC5}8`
     };
     var scroll = {
       up: /* @__PURE__ */ __name((count = 1) => `${CSI}S`.repeat(count), "up"),
@@ -269807,7 +269857,7 @@ var init_extensionManager = __esm({
               }
             }
             const newExtensionName = newExtensionConfig.name;
-            const previous = this.getLoadedExtensions().find((installed) => installed.name === newExtensionName);
+            const previous = this.getLoadedExtensions().find((installed2) => installed2.name === newExtensionName);
             if (isUpdate && !previous) {
               throw new Error(`Extension "${newExtensionName}" was not already installed, cannot update it.`);
             } else if (!isUpdate && previous) {
@@ -269926,7 +269976,7 @@ var init_extensionManager = __esm({
         const currentDir = cwd6 ?? this.workspaceDir;
         const telemetryConfig = getTelemetryConfig(currentDir, this.telemetrySettings);
         const installedExtensions = this.getLoadedExtensions();
-        const extension = installedExtensions.find((installed) => installed.config.name.toLowerCase() === extensionIdentifier.toLowerCase() || installed.installMetadata?.source.toLowerCase() === extensionIdentifier.toLowerCase());
+        const extension = installedExtensions.find((installed2) => installed2.config.name.toLowerCase() === extensionIdentifier.toLowerCase() || installed2.installMetadata?.source.toLowerCase() === extensionIdentifier.toLowerCase());
         if (!extension) {
           throw new Error(`Extension not found.`);
         }
@@ -282605,8 +282655,8 @@ async function ensureIt2Installed() {
     { cmd: "pip", args: ["install", "--user", "it2"] }
   ];
   for (const installer of installers) {
-    const installed = await tryInstallIt2(installer.cmd, installer.args);
-    if (installed && isIt2Available())
+    const installed2 = await tryInstallIt2(installer.cmd, installer.args);
+    if (installed2 && isIt2Available())
       return;
   }
   throw new Error('it2 is not installed. Install it2 via "uv tool install it2", "pipx install it2", or "pip install --user it2".');
@@ -290139,6 +290189,7 @@ __export(dist_exports, {
   scanMemoryHeaders: () => scanMemoryHeaders,
   serializeMemoryFile: () => serializeMemoryFile,
   serializeTerminalToObject: () => serializeTerminalToObject,
+  serializeTerminalToText: () => serializeTerminalToText,
   sessionScopeLock: () => sessionScopeLock,
   setDebugLogSession: () => setDebugLogSession,
   setGeminiMdFilename: () => setGeminiMdFilename,
@@ -330034,156 +330085,277 @@ var init_en3 = __esm({
       // Loading Phrases
       // ============================================================================
       WITTY_LOADING_PHRASES: [
-        "The server is checking its reflection",
-        "Waiting for the database to finish its thought",
-        "The code is looking for its other sock",
-        "The API went to the bathroom",
-        "The server is pretending to be asleep",
+        // Dry / office-passive-aggressive
+        "Checking its reflection",
         "Asking the cache if it's lying",
-        "The function is stalling for time",
-        "The database is avoiding eye contact",
-        "Waiting for the loop to get to the point",
-        "The server is checking its phone",
-        "The code is second-guessing everything",
-        "The API is making excuses",
-        "The server forgot what it was doing",
-        "The function is clearing its throat",
-        "Waiting for the process to stop rambling",
-        "The database is choosing its words carefully",
-        "The server is pretending to be busy",
-        "The code is checking if you're still watching",
-        "The API is running late, as usual",
-        "The server is looking for a pen that works",
-        "The function is trying to remember where it left off",
-        "The database is having an existential moment",
-        "Waiting for the code to get its story straight",
-        "The server is looking for its glasses",
-        "The API is stuck on hold",
-        "The function is checking the weather first",
-        "The database is reorganizing before it can start",
-        "The server is waiting for someone else to go first",
-        "The code is making sure it locked the door",
-        "The API is just... one more minute",
-        "Asking the server if it's mad at me",
-        "Waiting for the database to finish its cigarette",
+        "Stalling for time",
+        "Pretending the request never happened",
         "The pixels are discussing amongst themselves",
-        "Giving the code a minute to collect its thoughts",
-        "Letting the algorithm finish chewing",
-        "The server is finding its reading glasses",
-        "Asking the cache what it remembers",
-        "The API is looking for its car keys",
-        "Waiting for the function to get off the phone",
         "The data is stuck in traffic",
-        "Checking if the server left a note",
-        "The code is rereading the same paragraph",
-        "Asking the database to repeat itself",
-        "The server is deciding what to wear",
-        "Waiting for the loop to get the point",
-        "The request got distracted",
-        "The server is pretending it didn't hear you",
-        "Checking the back of the warehouse",
-        "The code is having second thoughts",
-        "Waiting for the process to finish its story",
-        "The API went to get milk",
-        "The server is double-checking its work",
         "Loading the thing behind the thing",
-        "The database is reorganizing its junk drawer",
-        "Asking the cache if it's sure",
-        "The code is trying to remember your name",
-        "Waiting for the server to put its pants on",
-        "The function is gathering evidence",
-        "The API is reading the instructions",
-        "The server is looking for the light switch",
-        "The server is rewinding the VHS tape",
+        "Checking the back of the warehouse",
+        "The request got distracted",
+        "Buffering the buffer",
+        "Drafting a response",
+        "Looking busy",
+        "Considering its options",
+        "Reading the room",
+        "Writing a passive-aggressive memo",
+        "The migration is procrastinating",
+        "The query is workshopping a comeback",
+        "Tabbing over to a different conversation",
+        "The cursor is having a moment",
+        "Drafting an apology",
+        "Stretching first",
+        "Three more minutes, promise",
+        "Backing into the conversation slowly",
+        "The thread is composing itself",
+        "The lock file has a hard time",
+        "Rewording the schema",
+        "Quietly hoping nobody asked",
+        "Finding its mark",
+        "The pointer pointed at a different pointer",
+        "The linter is taking it personally",
+        "The compiler is judging your style choices",
+        "The build feels underappreciated",
+        "Needing a minute",
+        "Third coffee of the run",
+        "Screening its calls",
+        "Not ready to talk yet",
+        "In a meeting",
+        "Putting on its shoes",
+        "Reorganizing the junk drawer",
+        "Reading the same paragraph again",
+        "Identity crisis in the hash table",
+        "The replica is gaslighting the leader",
+        "The promise is unfulfilled",
+        "Working from home today",
+        "The mutex is being clingy",
+        "Looking for a pen that works",
+        "Pretending to be asleep",
+        "Avoiding eye contact",
+        "Forgot what we were doing",
+        "Checking notifications",
+        // Retro / 90s-2000s tech nostalgia
+        "Rewinding the VHS tape",
         "Waiting for the modem to finish screaming",
-        "The database is paging someone",
-        "Blowing on the cartridge and trying again",
-        "The API is waiting for dial-up to connect",
-        "The server left its Tamagotchi at home",
-        "Checking if the cord is plugged into the phone jack",
-        "The code is recording over someone's wedding",
+        "Blowing on the cartridge",
+        "Dial-up is connecting",
+        "Tamagotchi died, hold on",
+        "Recording over someone's wedding tape",
         "Waiting for the CD to stop skipping",
-        "The function burned itself onto a CD-R",
-        "The database is fast-forwarding through the commercials",
-        "The server is adjusting the rabbit ears",
-        "The API is stuck in the credits",
-        "Tracking down which disc the file is on",
-        "The code is in a chat room somewhere",
-        "The server is setting the VCR timer",
-        "Waiting for the floppy disk to stop grinding",
-        "The database is selecting its AIM away message",
-        "The function is asking Jeeves",
-        "The server is reading the liner notes",
-        "The API pressed B too many times",
-        "The code is trying to remember its ICQ number",
-        "Waiting for the answering machine to beep",
-        "The database is untangling its landline cord",
-        "The server is loading the next track",
-        "The function is stuck in a Portal of Time",
-        "The API is checking its pager",
-        "The code is looking for the right jewel case",
-        "The server is making a mix tape first",
-        "Waiting for Y2K to sort itself out",
-        "The server will be back",
+        "Fast-forwarding through the commercials",
+        "Adjusting the rabbit ears",
+        "Stuck in the credits",
+        "Which disc was this on again",
+        "Setting the VCR timer",
+        "The floppy disk is grinding",
+        "Picking an AIM away message",
+        "Asking Jeeves",
+        "Reading the liner notes",
+        "Pressed B too many times",
+        "Trying to remember the ICQ number",
+        "Beep \u2014 leave a message",
+        "Untangling the landline cord",
+        "Loading the next track",
+        "Checking the pager",
+        "Looking for the right jewel case",
+        "Making a mix tape first",
+        "Y2K is sorting itself out",
+        "Defragmenting the disk",
+        "Asking SmarterChild",
+        "Stuck on the loading screen",
+        "The Zune is buffering",
+        "Hold on, MapQuest is printing",
+        // Movies / TV
         "Show me the data",
-        "The code can't handle the truth",
-        "The API is in the pipe, five by five",
+        "Can't handle the truth",
+        "In the pipe, five by five",
         "You're gonna need a bigger server",
-        "The function has a bad feeling about this",
-        "The database doesn't remember asking you a damn thing",
-        "Waiting for the server to say hello to my little friend",
-        "The code is going to make you an offer you can't refuse",
-        "The API is too old for this shit",
-        "The server is walking here",
-        "The function is on a mission from God",
-        "Just when the code thought it was out",
-        "The database can do this all day",
-        "The server is in a world of pain",
-        "The API sleeps with the fishes",
-        "The code is Keyser S\xF6ze",
-        "Waiting for the function to get busy living",
-        "The database is not a smart man, but it knows what love is",
-        "The server sees dead processes",
-        "The API is going to need you to go ahead and come in on Saturday",
-        "The code is on a boat",
-        "The function is shocked, shocked",
-        "The database is making fetch happen",
-        "The server is so fetch",
-        "The API is streets ahead",
-        "The code is the one who knocks",
-        "Waiting for the function to phone home",
-        "The database is big, it's heavy, it's wood",
-        "The server forgot about Dre",
-        "The server is never gonna give you up",
-        "The API is living on a prayer",
-        "The code wants to know what love is",
-        "The database is walking on sunshine",
-        "The function is a Material Girl",
-        "The server just called to say I love you",
-        "The API is waiting for tonight",
-        "The code is gonna party like it's 1999",
-        "The database hit me baby one more time",
-        "The server says bye bye bye",
-        "The function is too sexy for this code",
-        "The API is thinking about you and me and you and me",
-        "The code is trapped under ice cream",
-        "The database is turning Japanese",
-        "The server is walking like an Egyptian",
-        "The function is addicted to love",
-        "The API wants you to know what it's like",
-        "The code is running down a dream",
-        "The database is living la vida loca",
-        "The server is smooth like butter",
-        "The function believes it can fly",
-        "The API is gonna be the one that saves you",
-        "The code is not your stepping stone",
-        "The database is hungry like the wolf",
-        "The server is livin' on the edge",
-        "The function can't feel its face",
-        "The API doesn't want no scrubs",
-        "The code is floating down the Liffey",
-        "The database is losing its religion",
-        "The server is under pressure"
+        "Has a bad feeling about this",
+        "Doesn't remember asking you a damn thing",
+        "Saying hello to my little friend",
+        "Drafting an offer you can't refuse",
+        "Too old for this",
+        "I'm walking here",
+        "On a mission from God",
+        "Just when it thought it was out",
+        "We can do this all day",
+        "A world of pain",
+        "Sleeps with the fishes",
+        "Keyser S\xF6ze",
+        "Get busy living, or get busy parsing",
+        "It's not a smart database, but it knows what love is",
+        "I see dead processes",
+        "Coming in on Saturday",
+        "I'm on a boat",
+        "Shocked, shocked",
+        "Making fetch happen",
+        "So fetch",
+        "Streets ahead",
+        "The one who knocks",
+        "Phone home",
+        "It's heavy, it's wood",
+        "Forgot about Dre",
+        "Why so serious",
+        "To infinity, and slightly past",
+        "There is no spoon",
+        "They're heeere",
+        "Hasta la vista, baby",
+        "Run, Forrest, run",
+        // Songs
+        "Never gonna give you up",
+        "Living on a prayer",
+        "Wants to know what love is",
+        "Walking on sunshine",
+        "A material girl in a material world",
+        "Just called to say I love you",
+        "Waiting for tonight",
+        "Partying like it's 1999",
+        "Hit me baby one more time",
+        "Bye bye bye",
+        "Too sexy for this code",
+        "Trapped under ice",
+        "Turning Japanese",
+        "Walking like an Egyptian",
+        "Addicted to love",
+        "Running down a dream",
+        "Living la vida loca",
+        "Smooth like butter",
+        "Believes it can fly",
+        "The one that saves you",
+        "Not your stepping stone",
+        "Hungry like the wolf",
+        "Livin' on the edge",
+        "Can't feel its face",
+        "Don't want no scrubs",
+        "Floating down the Liffey",
+        "Losing its religion",
+        "Under pressure",
+        "Should I stay or should I go",
+        "We didn't start the fire",
+        "Don't stop believin'",
+        "Take on me",
+        "Tubthumping",
+        "Africa, blessing the rains",
+        // Observational / Sedaris
+        "An ex tagged me in a photo from 2007",
+        "Translating something rude in a language I don't speak",
+        "Calculating the smallest acceptable tip",
+        "The woman ahead of me is buying eight ice cream sandwiches",
+        "Reading the back of a shampoo bottle for the third time",
+        "Counting the people who have already lapped me",
+        "Wondering if the smell is me",
+        "The neighbor's dog has the same name as my brother",
+        "Trying to find a polite reason to leave",
+        "Pretending I've already eaten",
+        "Watching a stranger pick at their breakfast",
+        "Pretending the question wasn't directed at me",
+        // Nonsensical / surreal
+        "Negotiating with the moon",
+        "Asking the door what year it is",
+        "Sorting the bees by mood",
+        "Folding a small grief into the laundry",
+        "Convincing the chair it is not a chair",
+        "Translating birdsong into legal advice",
+        "Renaming the colors in alphabetical order",
+        "Misplacing a feeling I had earlier",
+        "Pulling a song out of the goose",
+        "Counting the spoons that fell in the river",
+        "Combing the static for a single shoe",
+        "Rotating the silence by ninety degrees",
+        "Boiling the alphabet down to a syrup",
+        "Borrowing rain from a previous owner",
+        "Whispering the password to a pigeon",
+        "Threading the donkey through the keyhole",
+        "Ironing the wrinkles out of a Tuesday",
+        "Catching the verb before it gets to the bus",
+        "Sweeping a footprint into a paper bag",
+        "Asking the kettle to forgive me",
+        // Begrudgingly helpful coding assistant
+        "Adding the null check you should have written",
+        "Refactoring something you'll refactor again Tuesday",
+        "Writing the test you weren't going to write",
+        "Pretending I didn't see that var",
+        "Naming things, badly, on your behalf",
+        "Reaching for a regex against my better judgment",
+        "Logging a variable you'll forget to remove",
+        "Mocking the dependency you should have injected",
+        "Apologizing in a comment for the next person",
+        "Writing 'TODO: fix this' for the third time today",
+        "Inferring the type you didn't annotate",
+        "Adding a try/catch that does almost nothing",
+        "Stubbing the function you'll forget to implement",
+        "Returning early to spare us both",
+        "Coercing the string you swore was a number",
+        "Promoting the warning to an error, as requested",
+        "Importing the seventh utility named 'utils'",
+        "Resolving the merge conflict the boring way",
+        "Pinning the dependency you said wouldn't matter",
+        "Writing the comment that says what the code already says",
+        // Tired project manager
+        "Following up on the ticket you said was almost done",
+        "Re-opening the ticket you closed prematurely",
+        "Drafting a kind way to say 'this is late again'",
+        "Re-estimating the story we sized as a 3 last sprint",
+        "Marking the milestone as 'amber' to be polite",
+        "Counting how many tickets are quietly in 'On Hold'",
+        "Asking, gently, what 'almost done' means",
+        "Writing a Confluence page no one will open",
+        "Color-coding the risk register again",
+        "Reading the retro action items from two retros ago",
+        "Drafting the same status email I sent in March",
+        "Negotiating scope without using the word 'scope'",
+        "Adding 'Communication' to the list of risks",
+        "Translating 'I'm on it' into a date",
+        "Filing the same risk that got filed last quarter",
+        "Drafting a follow-up to a follow-up",
+        "Closing tickets to make the burndown look right",
+        "Scheduling a fifteen-minute sync that will run forty",
+        "Reformatting the Gantt chart for legibility",
+        "Updating 'On Track' to 'On Track*'",
+        // Designer-engineer drowning in design tokens, trying to please GTM
+        "Adding `--brand-primary-500-darker-still` for the campaign",
+        "Looking up which token replaced `gray-600`",
+        "Renaming `bg-card` to `surface-elevated-default`",
+        "Adjusting the hero h1 by half a rem, again",
+        "Apologizing to a/b test variant C",
+        "Inventing a token to match a Figma fill nobody published",
+        "Asking GTM what 'a little more energy' means",
+        "Auditing for the seventh shade of off-white",
+        "Versioning `button-primary` to `button-primary-v3`",
+        "Migrating from semantic tokens to semantic tokens",
+        "Sourcing the brand purple no one can find",
+        "Patching the design system at 4:51pm",
+        "Mapping the Figma variable that maps to nothing",
+        "Unblocking the campaign with a one-off override",
+        "Translating 'punchier' into a kerning value",
+        "Re-exporting tokens to JSON, JS, CSS, and Sass",
+        "Convincing GTM that 'pop' is not a CSS property",
+        "Drafting the reply to 'can we make it more vibrant'",
+        "Showing GTM the same hex code from three angles",
+        "Promising the launch banner respects dark mode",
+        // CTO hiding tech debt with toxic positivity
+        "Celebrating the resilience of our pre-2019 codebase",
+        "Onboarding the third 'temporary' migration script",
+        "Reframing the database hotspot as a 'core competency'",
+        "Excited to revisit our auth strategy",
+        "Doubling down on our trusted singletons",
+        "Spinning up another postmortem with great learnings",
+        "Calling our jQuery integration 'mature'",
+        "Unifying our two billing systems by adding a third",
+        "Aligning on a path forward we already aligned on",
+        "Reframing 'flaky' as 'human-in-the-loop friendly'",
+        "Loving the optionality this technical decision created",
+        "Welcoming an exciting new opportunity to refactor",
+        "Praising the elegance of our YAML-as-code",
+        "Branding the legacy service as 'foundational'",
+        "Inspired by the team's commitment to deferred elegance",
+        "Embracing the resilience of bash scripts as orchestration",
+        "Sharing my excitement about our technical debt journey",
+        "Grateful for the chance to fix the same outage again",
+        "Leaning into our culture of 'ship and iterate'",
+        "Recognizing the heroes who keep the war room calm"
       ],
       // ============================================================================
       // Extension Settings Input
@@ -416205,7 +416377,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.26.9";
+  return "0.26.13";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -423977,7 +424149,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "925483692";
+var GIT_COMMIT_INFO = "1cbd798c9";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -460637,6 +460809,52 @@ var RESERVED_LINE_COUNT = 5;
 var STATUS_INDICATOR_WIDTH = 3;
 var MIN_LINES_SHOWN = 2;
 var MAXIMUM_RESULT_DISPLAY_CHARACTERS = 1e6;
+function sliceTextForMaxHeight(text, maxHeight, maxWidth) {
+  if (maxHeight === void 0) {
+    return { text, hiddenLinesCount: 0 };
+  }
+  const targetMaxHeight = Math.max(Math.round(maxHeight), MINIMUM_MAX_HEIGHT);
+  const visibleContentHeight = targetMaxHeight - 1;
+  const visualWidth = Math.max(1, Math.floor(maxWidth));
+  const visibleLines = [];
+  let visualLineCount = 0;
+  let currentLine = "";
+  let currentLineWidth = 0;
+  const appendVisibleLine = /* @__PURE__ */ __name((line) => {
+    visualLineCount += 1;
+    visibleLines.push(line);
+    if (visibleLines.length > visibleContentHeight) {
+      visibleLines.shift();
+    }
+  }, "appendVisibleLine");
+  const flushCurrentLine = /* @__PURE__ */ __name(() => {
+    appendVisibleLine(currentLine);
+    currentLine = "";
+    currentLineWidth = 0;
+  }, "flushCurrentLine");
+  for (const char of toCodePoints(text)) {
+    if (char === "\n") {
+      flushCurrentLine();
+      continue;
+    }
+    const charWidth = Math.max(getCachedStringWidth(char), 1);
+    if (currentLineWidth > 0 && currentLineWidth + charWidth > visualWidth) {
+      flushCurrentLine();
+    }
+    currentLine += char;
+    currentLineWidth += charWidth;
+  }
+  flushCurrentLine();
+  if (visualLineCount <= targetMaxHeight) {
+    return { text, hiddenLinesCount: 0 };
+  }
+  const hiddenLinesCount = visualLineCount - visibleContentHeight;
+  return {
+    text: visibleLines.join("\n"),
+    hiddenLinesCount
+  };
+}
+__name(sliceTextForMaxHeight, "sliceTextForMaxHeight");
 var useResultDisplayRenderer = /* @__PURE__ */ __name((resultDisplay) => import_react64.default.useMemo(() => {
   if (!resultDisplay) {
     return { type: "none" };
@@ -460724,7 +460942,20 @@ var StringResultRenderer = /* @__PURE__ */ __name(({ data, renderAsMarkdown, ava
       }
     ) });
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(MaxSizedBox, { maxHeight: availableHeight, maxWidth: childWidth, children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(Box_default, { children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(Text3, { wrap: "wrap", color: theme.text.primary, children: displayData }) }) });
+  const sliced = sliceTextForMaxHeight(
+    displayData,
+    availableHeight,
+    childWidth
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+    MaxSizedBox,
+    {
+      maxHeight: availableHeight,
+      maxWidth: childWidth,
+      additionalHiddenLinesCount: sliced.hiddenLinesCount,
+      children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(Box_default, { children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(Text3, { wrap: "wrap", color: theme.text.primary, children: sliced.text }) })
+    }
+  );
 }, "StringResultRenderer");
 var DiffResultRenderer = /* @__PURE__ */ __name(({ data, availableHeight, childWidth, settings: settings2 }) => /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
   DiffRenderer,
@@ -479778,6 +480009,7 @@ function checkImageFormatsSupport(parts2) {
 }
 __name(checkImageFormatsSupport, "checkImageFormatsSupport");
 var EDIT_TOOL_NAMES = /* @__PURE__ */ new Set(["replace", "write_file"]);
+var STREAM_UPDATE_THROTTLE_MS = 60;
 function showCitations(settings2) {
   const enabled = settings2?.merged?.ui?.showCitations;
   if (enabled !== void 0) {
@@ -479789,6 +480021,7 @@ __name(showCitations, "showCitations");
 var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, config2, settings2, onDebugMessage, handleSlashCommand2, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onEditorClose, onCancelSubmit, setShellInputFocused, terminalWidth, terminalHeight, drainQueuedMessages) => {
   const [initError, setInitError] = (0, import_react148.useState)(null);
   const abortControllerRef = (0, import_react148.useRef)(null);
+  const flushBufferedStreamEventsRef = (0, import_react148.useRef)(/* @__PURE__ */ new Set());
   const turnCancelledRef = (0, import_react148.useRef)(false);
   const queryGuardRef = (0, import_react148.useRef)(new QueryGuard());
   const lastPromptRef = (0, import_react148.useRef)(null);
@@ -479986,6 +480219,9 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
     if (turnCancelledRef.current) {
       return;
     }
+    for (const flushBufferedStreamEvents of flushBufferedStreamEventsRef.current) {
+      flushBufferedStreamEvents();
+    }
     turnCancelledRef.current = true;
     queryGuardRef.current.forceEnd();
     abortControllerRef.current?.abort();
@@ -480429,81 +480665,158 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       let geminiMessageBuffer = "";
       let thoughtBuffer = "";
       const toolCallRequests = [];
-      for await (const event of stream2) {
-        switch (event.type) {
-          case GeminiEventType.Thought:
-            if (event.value.subject) {
-              setThought(event.value);
-            } else {
-              thoughtBuffer = handleThoughtEvent(
-                event.value,
-                thoughtBuffer,
-                userMessageTimestamp
-              );
+      const bufferedEvents = [];
+      let flushTimer = null;
+      const discardBufferedStreamEvents = /* @__PURE__ */ __name(() => {
+        if (flushTimer) {
+          clearTimeout(flushTimer);
+          flushTimer = null;
+        }
+        bufferedEvents.length = 0;
+      }, "discardBufferedStreamEvents");
+      const flushBufferedStreamEvents = /* @__PURE__ */ __name(() => {
+        if (flushTimer) {
+          clearTimeout(flushTimer);
+          flushTimer = null;
+        }
+        if (bufferedEvents.length === 0) {
+          return;
+        }
+        while (bufferedEvents.length > 0) {
+          const nextEvent = bufferedEvents.shift();
+          if (nextEvent.kind === "content") {
+            let mergedContent = nextEvent.value;
+            while (bufferedEvents[0]?.kind === "content") {
+              const queuedContent = bufferedEvents.shift();
+              if (queuedContent?.kind !== "content") {
+                break;
+              }
+              mergedContent += queuedContent.value;
             }
-            break;
-          case GeminiEventType.Content:
             geminiMessageBuffer = handleContentEvent(
-              event.value,
+              mergedContent,
               geminiMessageBuffer,
               userMessageTimestamp
             );
-            break;
-          case GeminiEventType.ToolCallRequest:
-            toolCallRequests.push(event.value);
-            break;
-          case GeminiEventType.UserCancelled:
-            handleUserCancelledEvent(userMessageTimestamp);
-            break;
-          case GeminiEventType.Error:
-            handleErrorEvent(event.value, userMessageTimestamp);
-            break;
-          case GeminiEventType.ChatCompressed:
-            handleChatCompressionEvent(event.value, userMessageTimestamp);
-            break;
-          case GeminiEventType.ToolCallConfirmation:
-          case GeminiEventType.ToolCallResponse:
-            break;
-          case GeminiEventType.MaxSessionTurns:
-            handleMaxSessionTurnsEvent();
-            break;
-          case GeminiEventType.SessionTokenLimitExceeded:
-            handleSessionTokenLimitExceededEvent(event.value);
-            break;
-          case GeminiEventType.Finished:
-            handleFinishedEvent(
-              event,
-              userMessageTimestamp
-            );
-            break;
-          case GeminiEventType.Citation:
-            handleCitationEvent(event.value, userMessageTimestamp);
-            break;
-          case GeminiEventType.LoopDetected:
-            loopDetectedRef.current = true;
-            break;
-          case GeminiEventType.Retry:
-            if (pendingHistoryItemRef.current) {
-              setPendingHistoryItem(null);
+            continue;
+          }
+          let mergedThought = nextEvent.value;
+          while (bufferedEvents[0]?.kind === "thought") {
+            const queuedThought = bufferedEvents.shift();
+            if (queuedThought?.kind !== "thought") {
+              break;
             }
-            if (event.retryInfo) {
-              startRetryCountdown(event.retryInfo);
-            } else {
-              clearRetryCountdown();
+            mergedThought = {
+              subject: queuedThought.value.subject || mergedThought.subject,
+              description: `${mergedThought.description ?? ""}${queuedThought.value.description ?? ""}`
+            };
+          }
+          thoughtBuffer = handleThoughtEvent(
+            mergedThought,
+            thoughtBuffer,
+            userMessageTimestamp
+          );
+        }
+      }, "flushBufferedStreamEvents");
+      const scheduleBufferedStreamFlush = /* @__PURE__ */ __name(() => {
+        if (flushTimer) {
+          return;
+        }
+        flushTimer = setTimeout(() => {
+          flushBufferedStreamEvents();
+        }, STREAM_UPDATE_THROTTLE_MS);
+      }, "scheduleBufferedStreamFlush");
+      flushBufferedStreamEventsRef.current.add(flushBufferedStreamEvents);
+      try {
+        for await (const event of stream2) {
+          switch (event.type) {
+            case GeminiEventType.Thought:
+              if (event.value.subject) {
+                flushBufferedStreamEvents();
+                setThought(event.value);
+              } else {
+                bufferedEvents.push({ kind: "thought", value: event.value });
+                scheduleBufferedStreamFlush();
+              }
+              break;
+            case GeminiEventType.Content:
+              bufferedEvents.push({ kind: "content", value: event.value });
+              scheduleBufferedStreamFlush();
+              break;
+            case GeminiEventType.ToolCallRequest:
+              flushBufferedStreamEvents();
+              toolCallRequests.push(event.value);
+              break;
+            case GeminiEventType.UserCancelled:
+              flushBufferedStreamEvents();
+              handleUserCancelledEvent(userMessageTimestamp);
+              break;
+            case GeminiEventType.Error:
+              flushBufferedStreamEvents();
+              handleErrorEvent(event.value, userMessageTimestamp);
+              break;
+            case GeminiEventType.ChatCompressed:
+              flushBufferedStreamEvents();
+              handleChatCompressionEvent(event.value, userMessageTimestamp);
+              break;
+            case GeminiEventType.ToolCallConfirmation:
+            case GeminiEventType.ToolCallResponse:
+              flushBufferedStreamEvents();
+              break;
+            case GeminiEventType.MaxSessionTurns:
+              flushBufferedStreamEvents();
+              handleMaxSessionTurnsEvent();
+              break;
+            case GeminiEventType.SessionTokenLimitExceeded:
+              flushBufferedStreamEvents();
+              handleSessionTokenLimitExceededEvent(event.value);
+              break;
+            case GeminiEventType.Finished:
+              flushBufferedStreamEvents();
+              handleFinishedEvent(
+                event,
+                userMessageTimestamp
+              );
+              break;
+            case GeminiEventType.Citation:
+              flushBufferedStreamEvents();
+              handleCitationEvent(event.value, userMessageTimestamp);
+              break;
+            case GeminiEventType.LoopDetected:
+              flushBufferedStreamEvents();
+              loopDetectedRef.current = true;
+              break;
+            case GeminiEventType.Retry:
+              discardBufferedStreamEvents();
+              if (pendingHistoryItemRef.current) {
+                setPendingHistoryItem(null);
+              }
+              geminiMessageBuffer = "";
+              thoughtBuffer = "";
+              if (event.retryInfo) {
+                startRetryCountdown(event.retryInfo);
+              } else {
+                clearRetryCountdown();
+              }
+              break;
+            case GeminiEventType.HookSystemMessage:
+              flushBufferedStreamEvents();
+              geminiMessageBuffer = handleContentEvent(
+                event.value + "\n",
+                geminiMessageBuffer,
+                userMessageTimestamp
+              );
+              break;
+            default: {
+              const unreachable = event;
+              return unreachable;
             }
-            break;
-          case GeminiEventType.HookSystemMessage:
-            geminiMessageBuffer = handleContentEvent(
-              event.value + "\n",
-              geminiMessageBuffer,
-              userMessageTimestamp
-            );
-            break;
-          default: {
-            const unreachable = event;
-            return unreachable;
           }
         }
+      } finally {
+        flushBufferedStreamEvents();
+        discardBufferedStreamEvents();
+        flushBufferedStreamEventsRef.current.delete(flushBufferedStreamEvents);
       }
       if (toolCallRequests.length > 0) {
         scheduleToolCalls(toolCallRequests, signal);
@@ -491700,7 +492013,7 @@ var QwenAgent = class {
   async initialize(args2) {
     this.clientCapabilities = args2.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version2 = "0.26.9";
+    const version2 = "0.26.13";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -492084,6 +492397,205 @@ var QwenAgent = class {
   }
 };
 
+// packages/cli/src/ui/utils/terminalRedrawOptimizer.ts
+init_esbuild_shims();
+var ESC4 = "\x1B[";
+var ERASE_LINE = `${ESC4}2K`;
+var CURSOR_UP_ONE = `${ESC4}1A`;
+var CURSOR_DOWN_ONE = `${ESC4}1B`;
+var CURSOR_LEFT = `${ESC4}G`;
+var MULTILINE_ERASE_LINES_PATTERN = new RegExp(
+  `(?:${escapeRegExp(ERASE_LINE + CURSOR_UP_ONE)})+${escapeRegExp(
+    ERASE_LINE + CURSOR_LEFT
+  )}`,
+  "g"
+);
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+function countOccurrences2(value, search) {
+  let count = 0;
+  let index = 0;
+  while ((index = value.indexOf(search, index)) !== -1) {
+    count++;
+    index += search.length;
+  }
+  return count;
+}
+__name(countOccurrences2, "countOccurrences");
+var terminalRedrawStats = {
+  stdoutWriteCount: 0,
+  stdoutBytes: 0,
+  clearTerminalCount: 0,
+  eraseLinesOptimizedCount: 0
+};
+function getChunkByteLength(chunk, encodingOrCallback) {
+  if (typeof chunk === "string") {
+    const encoding = typeof encodingOrCallback === "string" ? encodingOrCallback : void 0;
+    return Buffer.byteLength(chunk, encoding);
+  }
+  return chunk.byteLength;
+}
+__name(getChunkByteLength, "getChunkByteLength");
+function optimizeMultilineEraseLinesWithCount(output) {
+  let optimizedSequenceCount = 0;
+  const optimizedOutput = output.replace(
+    MULTILINE_ERASE_LINES_PATTERN,
+    (sequence) => {
+      const lineCount = countOccurrences2(sequence, ERASE_LINE);
+      const cursorUpCount = lineCount - 1;
+      if (cursorUpCount <= 1) {
+        return sequence;
+      }
+      optimizedSequenceCount += 1;
+      let boundedErase = `${ESC4}${cursorUpCount}A`;
+      for (let line = 0; line < lineCount; line++) {
+        boundedErase += ERASE_LINE;
+        if (line < lineCount - 1) {
+          boundedErase += CURSOR_DOWN_ONE;
+        }
+      }
+      return `${boundedErase}${ESC4}${cursorUpCount}A${CURSOR_LEFT}`;
+    }
+  );
+  return { output: optimizedOutput, optimizedSequenceCount };
+}
+__name(optimizeMultilineEraseLinesWithCount, "optimizeMultilineEraseLinesWithCount");
+function installTerminalRedrawOptimizer(stdout3) {
+  if (process.env["PROTO_LEGACY_ERASE_LINES"] === "1") {
+    return () => {
+    };
+  }
+  const originalWrite = stdout3.write;
+  const optimizedWrite = /* @__PURE__ */ __name(function(chunk, encodingOrCallback, callback) {
+    const optimizedResult = typeof chunk === "string" ? optimizeMultilineEraseLinesWithCount(chunk) : void 0;
+    const optimizedChunk = optimizedResult?.output ?? chunk;
+    if (typeof optimizedChunk === "string" || optimizedChunk instanceof Uint8Array || Buffer.isBuffer(optimizedChunk)) {
+      terminalRedrawStats.stdoutWriteCount += 1;
+      terminalRedrawStats.stdoutBytes += getChunkByteLength(
+        optimizedChunk,
+        encodingOrCallback
+      );
+      if (typeof optimizedChunk === "string") {
+        terminalRedrawStats.clearTerminalCount += countOccurrences2(
+          optimizedChunk,
+          base_exports.clearTerminal
+        );
+      }
+    }
+    if (optimizedResult) {
+      terminalRedrawStats.eraseLinesOptimizedCount += optimizedResult.optimizedSequenceCount;
+    }
+    return originalWrite.call(
+      this,
+      optimizedChunk,
+      encodingOrCallback,
+      callback
+    );
+  }, "optimizedWrite");
+  stdout3.write = optimizedWrite;
+  return () => {
+    if (stdout3.write === optimizedWrite) {
+      stdout3.write = originalWrite;
+    }
+  };
+}
+__name(installTerminalRedrawOptimizer, "installTerminalRedrawOptimizer");
+
+// packages/cli/src/ui/utils/synchronizedOutput.ts
+init_esbuild_shims();
+var BEGIN_SYNCHRONIZED_UPDATE = "\x1B[?2026h";
+var END_SYNCHRONIZED_UPDATE = "\x1B[?2026l";
+var synchronizedOutputStats = {
+  synchronizedOutputFrameCount: 0,
+  synchronizedOutputBeginCount: 0,
+  synchronizedOutputEndCount: 0
+};
+var installed = false;
+function terminalSupportsSynchronizedOutput(env5 = process.env) {
+  if (env5["PROTO_DISABLE_SYNCHRONIZED_OUTPUT"] === "1" || env5["PROTO_SYNCHRONIZED_OUTPUT"] === "0") {
+    return false;
+  }
+  if (env5["PROTO_FORCE_SYNCHRONIZED_OUTPUT"] === "1" || env5["PROTO_SYNCHRONIZED_OUTPUT"] === "1") {
+    return true;
+  }
+  if (env5["TMUX"] || env5["SSH_TTY"] || env5["SSH_CLIENT"]) {
+    return false;
+  }
+  const termProgram = env5["TERM_PROGRAM"];
+  if (termProgram === "WezTerm" || termProgram === "iTerm.app" || termProgram === "ghostty") {
+    return true;
+  }
+  if (env5["ALACRITTY_WINDOW_ID"]) {
+    return true;
+  }
+  const term = env5["TERM"];
+  if (env5["KITTY_WINDOW_ID"] || term?.includes("kitty")) {
+    return true;
+  }
+  if (term?.startsWith("alacritty")) {
+    return true;
+  }
+  if (env5["GHOSTTY_RESOURCES_DIR"]) {
+    return true;
+  }
+  return false;
+}
+__name(terminalSupportsSynchronizedOutput, "terminalSupportsSynchronizedOutput");
+function installSynchronizedOutput(stdout3 = process.stdout, env5 = process.env) {
+  if (installed || !stdout3.isTTY || !terminalSupportsSynchronizedOutput(env5)) {
+    return () => {
+    };
+  }
+  const originalWrite = stdout3.write;
+  let inFrame = false;
+  const writeControlSequence = /* @__PURE__ */ __name((sequence) => {
+    originalWrite.call(stdout3, sequence);
+  }, "writeControlSequence");
+  const endFrame = /* @__PURE__ */ __name(() => {
+    if (!inFrame) {
+      return;
+    }
+    inFrame = false;
+    synchronizedOutputStats.synchronizedOutputEndCount += 1;
+    writeControlSequence(END_SYNCHRONIZED_UPDATE);
+  }, "endFrame");
+  const patchedWrite = /* @__PURE__ */ __name(function(chunk, encodingOrCallback, callback) {
+    if (!inFrame) {
+      inFrame = true;
+      synchronizedOutputStats.synchronizedOutputFrameCount += 1;
+      synchronizedOutputStats.synchronizedOutputBeginCount += 1;
+      writeControlSequence(BEGIN_SYNCHRONIZED_UPDATE);
+      queueMicrotask(endFrame);
+    }
+    return originalWrite.call(
+      this,
+      chunk,
+      encodingOrCallback,
+      callback
+    );
+  }, "patchedWrite");
+  const exitHandler = /* @__PURE__ */ __name(() => {
+    try {
+      endFrame();
+    } catch {
+    }
+  }, "exitHandler");
+  stdout3.write = patchedWrite;
+  installed = true;
+  process.once("exit", exitHandler);
+  return () => {
+    if (stdout3.write === patchedWrite) {
+      endFrame();
+      stdout3.write = originalWrite;
+    }
+    process.removeListener("exit", exitHandler);
+    installed = false;
+  };
+}
+__name(installSynchronizedOutput, "installSynchronizedOutput");
+
 // packages/cli/src/gemini.tsx
 var import_jsx_runtime141 = __toESM(require_jsx_runtime(), 1);
 var debugLogger160 = createDebugLogger("STARTUP");
@@ -492147,6 +492659,10 @@ ${reason.stack}` : ""}`;
 __name(setupUnhandledRejectionHandler, "setupUnhandledRejectionHandler");
 async function startInteractiveUI(config2, settings2, startupWarnings, workspaceRoot = process.cwd(), initializationResult) {
   const version2 = await getCliVersion();
+  const restoreTerminalRedrawOptimizer = process.stdout.isTTY && !config2.getScreenReader() ? installTerminalRedrawOptimizer(process.stdout) : () => {
+  };
+  const restoreSynchronizedOutput = process.stdout.isTTY && !config2.getScreenReader() ? installSynchronizedOutput(process.stdout) : () => {
+  };
   const AppWrapper = /* @__PURE__ */ __name(() => {
     const kittyProtocolStatus = useKittyKeyboardProtocol();
     const nodeMajorVersion = parseInt(process.versions.node.split(".")[0], 10);
@@ -492186,7 +492702,11 @@ async function startInteractiveUI(config2, settings2, startupWarnings, workspace
       debugLogger160.warn(`Update check failed: ${err2}`);
     });
   }
-  registerCleanup(() => instance2.unmount());
+  registerCleanup(() => {
+    instance2.unmount();
+    restoreSynchronizedOutput();
+    restoreTerminalRedrawOptimizer();
+  });
 }
 __name(startInteractiveUI, "startInteractiveUI");
 async function main() {