aemeathcli 1.0.12 → 1.1.0

package/dist/{App-JQ622M66.js → App-NT6MRKQJ.js}

@@ -11,39 +11,18 @@ import { DEFAULT_CONFIG, PACKAGE_VERSION } from './chunk-2Y7TR6BS.js';
 import './chunk-IR5HLBMH.js';
 import './chunk-D275MCIH.js';
 import React11, { useRef, useState, useCallback, useEffect, useMemo, startTransition } from 'react';
-import { Box, Text, render, useInput } from 'ink';
+import { Box, Text, render, useInput, useStdout } from 'ink';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { randomUUID } from 'crypto';
 
 // src/ui/theme.ts
 var BRAND_COLOR = "#F0C5DA";
 var colors = {
-  text: {
-    primary: "#F9F5F5",
-    secondary: "#d3acb3",
-    muted: "#9e8085",
-    accent: "#F0C5DA",
-    response: "#F9F5F5"
-  },
-  border: {
-    dim: "#6b5459",
-    active: "#d3acb3"},
-  syntax: {
-    keyword: "#F0C5DA",
-    string: "#EDD6DC"},
-  status: {
-    success: "#F0C5DA",
-    error: "#f87171",
-    warning: "#EDD6DC",
-    info: "#F0C5DA",
-    active: "#F0C5DA"
-  },
-  role: {
-    user: "#F0C5DA",
-    assistant: "#F9F5F5",
-    system: "#EDD6DC",
-    tool: "#d3acb3"
-  }
+  text: { primary: "#F9F5F5", secondary: "#d3acb3", muted: "#9e8085", accent: "#F0C5DA", response: "#F9F5F5" },
+  border: { dim: "#6b5459", active: "#d3acb3"},
+  syntax: { keyword: "#F0C5DA", string: "#EDD6DC"},
+  status: { success: "#F0C5DA", error: "#f87171", warning: "#EDD6DC", info: "#F0C5DA", active: "#F0C5DA" },
+  role: { user: "#F0C5DA", assistant: "#F9F5F5", system: "#EDD6DC", tool: "#d3acb3" }
 };
 function parseBlocks(raw) {
   const blocks = [];
@@ -180,12 +159,24 @@ function InlineMarkdown({
     }
     const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/);
     if (linkMatch) {
+      const linkLabel = linkMatch[1] ?? "";
+      const linkUrl = linkMatch[2] ?? "";
+      const isLocalPath = linkUrl.startsWith("/") || linkUrl.startsWith("./") || linkUrl.startsWith("../");
+      const displayText = isLocalPath ? linkUrl : linkLabel;
       segments.push(
-        /* @__PURE__ */ jsx(Text, { color: colors.status.info, underline: true, children: linkMatch[1] }, key++)
+        /* @__PURE__ */ jsx(Text, { color: colors.status.info, underline: true, children: displayText }, key++)
       );
       remaining = remaining.slice(linkMatch[0].length);
       continue;
     }
+    const bareUrlMatch = remaining.match(/^(https?:\/\/[^\s)>\]]+)/);
+    if (bareUrlMatch) {
+      segments.push(
+        /* @__PURE__ */ jsx(Text, { color: colors.status.info, underline: true, children: bareUrlMatch[1] }, key++)
+      );
+      remaining = remaining.slice(bareUrlMatch[0].length);
+      continue;
+    }
     const nextSpecial = remaining.search(/[[*`~]/);
     if (nextSpecial === -1) {
       segments.push(/* @__PURE__ */ jsx(Text, { children: remaining }, key++));
@@ -367,6 +358,96 @@ function useAnimationTick(intervalMs, enabled = true) {
   }, [enabled, intervalMs]);
   return tick;
 }
+
+// src/ui/shimmer.ts
+var DEFAULT_PERIOD_MS = 2e3;
+var BAND_WIDTH = 10;
+var MAX_INTENSITY = 0.9;
+var trueColorCached;
+function supportsTrueColor() {
+  if (trueColorCached === void 0) {
+    const ct = process.env["COLORTERM"] ?? "";
+    trueColorCached = ct === "truecolor" || ct === "24bit";
+  }
+  return trueColorCached;
+}
+function parseHex(hex) {
+  let raw = hex.startsWith("#") ? hex.slice(1) : hex;
+  if (raw.length === 3) {
+    const c0 = raw[0] ?? "f";
+    const c1 = raw[1] ?? "f";
+    const c2 = raw[2] ?? "f";
+    raw = c0 + c0 + c1 + c1 + c2 + c2;
+  }
+  if (raw.length !== 6) return [255, 255, 255];
+  const n = parseInt(raw, 16);
+  if (Number.isNaN(n)) return [255, 255, 255];
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function toHex(r, g, b) {
+  const c = (v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
+  return "#" + c(r) + c(g) + c(b);
+}
+function blendChannel(base, intensity) {
+  return base + (255 - base) * intensity;
+}
+function shimmerIntensity(charIndex, totalLength, periodMs = DEFAULT_PERIOD_MS) {
+  const totalWidth = totalLength + BAND_WIDTH;
+  const progress = Date.now() % periodMs / periodMs;
+  const bandCenter = progress * totalWidth;
+  const distance = Math.abs(charIndex - bandCenter) / (totalWidth / 2);
+  return Math.max(0, Math.cos(distance * (Math.PI / 2))) * MAX_INTENSITY;
+}
+function shimmerText(text, baseColor) {
+  const len = text.length;
+  const trueColor = supportsTrueColor();
+  const [br, bg, bb] = parseHex(baseColor);
+  const result = [];
+  for (let i = 0; i < len; i++) {
+    const intensity = shimmerIntensity(i, len);
+    if (trueColor) {
+      const color = toHex(
+        blendChannel(br, intensity),
+        blendChannel(bg, intensity),
+        blendChannel(bb, intensity)
+      );
+      const ch = text[i] ?? " ";
+      result.push({ char: ch, intensity, color, bold: false, dim: false });
+    } else {
+      const bold = intensity > 0.6;
+      const dim = intensity <= 0.1;
+      const ch = text[i] ?? " ";
+      result.push({ char: ch, intensity, color: baseColor, bold, dim });
+    }
+  }
+  return result;
+}
+function shimmerToInkSpans(text, baseColor) {
+  const chars = shimmerText(text, baseColor);
+  if (chars.length === 0) return [];
+  const spans = [];
+  const first = chars[0];
+  if (first === void 0) return [];
+  let curText = first.char;
+  let curColor = first.color;
+  let curBold = first.bold;
+  let curDim = first.dim;
+  for (let i = 1; i < chars.length; i++) {
+    const ch = chars[i];
+    if (ch === void 0) continue;
+    if (ch.color === curColor && ch.bold === curBold && ch.dim === curDim) {
+      curText += ch.char;
+    } else {
+      spans.push({ text: curText, color: curColor, bold: curBold, dim: curDim });
+      curText = ch.char;
+      curColor = ch.color;
+      curBold = ch.bold;
+      curDim = ch.dim;
+    }
+  }
+  spans.push({ text: curText, color: curColor, bold: curBold, dim: curDim });
+  return spans;
+}
 var SPINNER_VARIANTS = {
   dots: {
     frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
@@ -389,11 +470,13 @@ var SPINNER_VARIANTS = {
     interval: 120
   }
 };
+var SHIMMER_INTERVAL_MS = 32;
 function GradientSpinner({
   label,
   labelColor = "#888888",
   variant = "dots",
-  speed
+  speed,
+  shimmer = false
 }) {
   const spinnerDef = SPINNER_VARIANTS[variant] ?? SPINNER_VARIANTS["dots"];
   if (!spinnerDef) {
@@ -401,10 +484,27 @@ function GradientSpinner({
   }
   const interval = speed ?? spinnerDef.interval;
   const tick = useAnimationTick(interval);
+  useAnimationTick(SHIMMER_INTERVAL_MS, shimmer && label !== void 0 && label.length > 0);
   const frame = tick % spinnerDef.frames.length;
+  const shimmerSpans = useMemo(() => {
+    if (!shimmer || !label) return null;
+    return shimmerToInkSpans(label, labelColor);
+  }, [shimmer, label, labelColor, tick]);
   return /* @__PURE__ */ jsxs(Text, { children: [
     /* @__PURE__ */ jsx(Text, { color: BRAND_COLOR, children: spinnerDef.frames[frame] }),
-    label ? /* @__PURE__ */ jsxs(Text, { color: labelColor, children: [
+    label ? shimmerSpans ? /* @__PURE__ */ jsxs(Text, { children: [
+      " ",
+      shimmerSpans.map((span, i) => /* @__PURE__ */ jsx(
+        Text,
+        {
+          color: span.color,
+          bold: span.bold,
+          dimColor: span.dim,
+          children: span.text
+        },
+        i
+      ))
+    ] }) : /* @__PURE__ */ jsxs(Text, { color: labelColor, children: [
       " ",
       label
     ] }) : null
@@ -428,31 +528,62 @@ function StatusIcon({
 }
 function formatDuration(ms) {
   if (ms < 1e3) return `${ms}ms`;
-  return `${(ms / 1e3).toFixed(1)}s`;
+  const totalSec = Math.floor(ms / 1e3);
+  if (totalSec < 60) {
+    const frac = ms % 1e3;
+    return frac >= 100 ? `${(ms / 1e3).toFixed(1)}s` : `${totalSec}s`;
+  }
+  const minutes = Math.floor(totalSec / 60);
+  const seconds = totalSec % 60;
+  if (minutes < 60) {
+    return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainMin = minutes % 60;
+  return seconds > 0 ? `${hours}h ${remainMin}m ${seconds}s` : `${hours}h ${remainMin}m`;
 }
+var TOOL_ICONS = {
+  read: "\u{1F4C4}",
+  write: "\u270F\uFE0F",
+  edit: "\u{1F4DD}",
+  glob: "\u{1F50D}",
+  grep: "\u{1F50E}",
+  bash: "\u26A1",
+  web_search: "\u{1F310}",
+  webSearch: "\u{1F310}",
+  web_fetch: "\u{1F4E1}",
+  webFetch: "\u{1F4E1}"
+};
 function getToolIcon(name) {
-  switch (name) {
-    case "read":
-      return "\u{1F4C4}";
-    case "write":
-      return "\u270F\uFE0F";
-    case "edit":
-      return "\u{1F4DD}";
-    case "glob":
-      return "\u{1F50D}";
-    case "grep":
-      return "\u{1F50E}";
-    case "bash":
-      return "\u26A1";
-    case "web_search":
-    case "webSearch":
-      return "\u{1F310}";
-    case "web_fetch":
-    case "webFetch":
-      return "\u{1F4E1}";
-    default:
-      return "\u2699";
+  return TOOL_ICONS[name] ?? "\u2699";
+}
+var HEAD_LINES = 5;
+var TAIL_LINES = 2;
+function formatOutputLines(raw) {
+  const allLines = raw.split("\n");
+  if (allLines.length > 0 && allLines[allLines.length - 1] === "") {
+    allLines.pop();
+  }
+  const total = allLines.length;
+  if (total <= HEAD_LINES + TAIL_LINES) {
+    return allLines.map((line, i) => {
+      const prefix = i === 0 ? "  \u2514 " : "    ";
+      return `${prefix}${line}`;
+    });
   }
+  const head = allLines.slice(0, HEAD_LINES);
+  const tail = allLines.slice(total - TAIL_LINES);
+  const omitted = total - HEAD_LINES - TAIL_LINES;
+  const result = [];
+  head.forEach((line, i) => {
+    const prefix = i === 0 ? "  \u2514 " : "    ";
+    result.push(`${prefix}${line}`);
+  });
+  result.push(`    \u2026 +${omitted} lines`);
+  tail.forEach((line) => {
+    result.push(`    ${line}`);
+  });
+  return result;
 }
 function ToolCallDisplay({
   toolName,
@@ -463,7 +594,6 @@ function ToolCallDisplay({
   duration,
   isCollapsed = true
 }) {
-  const borderColor = status === "error" ? colors.status.error : status === "executing" ? colors.status.active : colors.border.dim;
   const icon = getToolIcon(toolName);
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginY: 0, children: [
     /* @__PURE__ */ jsxs(Box, { children: [
@@ -485,28 +615,16 @@ function ToolCallDisplay({
         ")"
       ] }) : null
     ] }),
-    !isCollapsed && output ? /* @__PURE__ */ jsx(
-      Box,
+    !isCollapsed && output ? /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: formatOutputLines(output).map((line, i) => /* @__PURE__ */ jsx(
+      Text,
       {
-        flexDirection: "column",
-        marginLeft: 2,
-        borderStyle: "single",
-        borderLeft: true,
-        borderRight: false,
-        borderTop: false,
-        borderBottom: false,
-        borderColor,
-        paddingLeft: 1,
-        children: /* @__PURE__ */ jsx(
-          Text,
-          {
-            wrap: "wrap",
-            color: isError ? colors.status.error : colors.text.secondary,
-            children: output.length > 2e3 ? output.slice(0, 2e3) + "\n\u2026 (truncated)" : output
-          }
-        )
-      }
-    ) : null
+        wrap: "truncate",
+        dimColor: true,
+        color: isError ? colors.status.error : colors.text.secondary,
+        children: line
+      },
+      i
+    )) }) : null
   ] });
 }
 function getRoleColor(role) {
@@ -966,6 +1084,10 @@ function InputBar({
   const isAutocompleteActiveRef = useRef(false);
   const previousHistoryIndexRef = useRef(void 0);
   const historyCacheRef = useRef({});
+  const lastInputTimeRef = useRef(0);
+  const pasteBufferRef = useRef("");
+  const pasteTimeoutRef = useRef(null);
+  const isPastingRef = useRef(false);
   const setInputWithCursor = useCallback(
     (nextInput, cursorPosition = "end") => {
       const nextCursor = cursorPosition === "start" ? 0 : cursorPosition === "end" ? codePointLength(nextInput) : clampCursorOffset(nextInput, cursorPosition);
@@ -1032,6 +1154,17 @@ function InputBar({
       });
     }
   }, [initialHistory]);
+  useEffect(() => {
+    process.stdout.write("\x1B[?2004h");
+    return () => {
+      process.stdout.write("\x1B[?2004l");
+    };
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (pasteTimeoutRef.current) clearTimeout(pasteTimeoutRef.current);
+    };
+  }, []);
   useEffect(() => {
     inputRef.current = input;
     cursorOffsetRef.current = cursorOffset;
@@ -1178,6 +1311,24 @@ function InputBar({
     }
     if (key.ctrl && inputChar === "l") return;
     if (!key.ctrl && !key.meta && inputChar) {
+      const now = Date.now();
+      const timeSinceLastInput = now - lastInputTimeRef.current;
+      lastInputTimeRef.current = now;
+      if (timeSinceLastInput < 5) {
+        isPastingRef.current = true;
+        pasteBufferRef.current += inputChar;
+        if (pasteTimeoutRef.current) clearTimeout(pasteTimeoutRef.current);
+        pasteTimeoutRef.current = setTimeout(() => {
+          const pasteText = pasteBufferRef.current;
+          pasteBufferRef.current = "";
+          isPastingRef.current = false;
+          if (pasteText) {
+            const result2 = insertTextAtCursor(inputRef.current, cursorOffsetRef.current, pasteText);
+            setInputWithCursor(result2.text, result2.cursorOffset);
+          }
+        }, 10);
+        return;
+      }
       const result = insertTextAtCursor(currentInput, currentCursorOffset, inputChar);
       setInputWithCursor(result.text, result.cursorOffset);
     }
@@ -1238,6 +1389,12 @@ function StatusBar({
   gitBranch,
   gitChanges
 }) {
+  const { stdout } = useStdout();
+  const width = stdout.columns ?? 120;
+  const showRole = width > 100 && !!role;
+  const showGit = width > 60 && !!gitBranch;
+  const showTokens = width > 45;
+  const showCost = width > 45;
   return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: colors.border.dim, paddingX: 1, children: [
     /* @__PURE__ */ jsxs(Text, { color: BRAND_COLOR, bold: true, children: [
       "\u25C6",
@@ -1246,18 +1403,22 @@ function StatusBar({
     /* @__PURE__ */ jsx(Text, { color: colors.status.active, bold: true, children: "Aemeath Agent Swarm" }),
     /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
     /* @__PURE__ */ jsx(Text, { color: colors.status.warning, bold: true, children: shortModelLabel(model) }),
-    role ? /* @__PURE__ */ jsxs(Fragment, { children: [
+    showRole ? /* @__PURE__ */ jsxs(Fragment, { children: [
       /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
       /* @__PURE__ */ jsx(Text, { color: colors.role.tool, children: role })
     ] }) : null,
-    /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
-    /* @__PURE__ */ jsxs(Text, { color: colors.text.secondary, children: [
-      tokenCount,
-      " tok"
-    ] }),
-    /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
-    /* @__PURE__ */ jsx(Text, { color: colors.status.success, children: cost }),
-    gitBranch ? /* @__PURE__ */ jsxs(Fragment, { children: [
+    showTokens ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
+      /* @__PURE__ */ jsxs(Text, { color: colors.text.secondary, children: [
+        tokenCount,
+        " tok"
+      ] })
+    ] }) : null,
+    showCost ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
+      /* @__PURE__ */ jsx(Text, { color: colors.status.success, children: cost })
+    ] }) : null,
+    showGit ? /* @__PURE__ */ jsxs(Fragment, { children: [
       /* @__PURE__ */ jsx(Text, { color: colors.text.muted, children: SEP }),
       /* @__PURE__ */ jsxs(Text, { color: colors.status.info, children: [
         "\u2387",
@@ -1278,26 +1439,49 @@ var THINKING_PHRASES = [
   "Evaluating"
 ];
 var PHRASE_CYCLE_MS = 2500;
+function formatElapsed(ms) {
+  const totalSecs = Math.floor(ms / 1e3);
+  if (totalSecs < 1) return "0s";
+  if (totalSecs < 60) return `${totalSecs}s`;
+  const mins = Math.floor(totalSecs / 60);
+  const secs = totalSecs % 60;
+  if (mins < 60) return `${mins}m ${String(secs).padStart(2, "0")}s`;
+  const hrs = Math.floor(mins / 60);
+  const remMins = mins % 60;
+  return `${hrs}h ${String(remMins).padStart(2, "0")}m ${String(secs).padStart(2, "0")}s`;
+}
 function ThinkingIndicator({
   activity,
   isStreaming,
   modelName,
-  startTime
+  startTime,
+  isPaused = false,
+  details,
+  maxDetailLines = 3
 }) {
   const tick = useAnimationTick(1e3);
-  const elapsed = startTime === void 0 ? 0 : Math.max(0, Date.now() - startTime);
+  const pausedAccumRef = useRef(0);
+  const pauseStartRef = useRef(void 0);
+  if (isPaused && pauseStartRef.current === void 0) {
+    pauseStartRef.current = Date.now();
+  } else if (!isPaused && pauseStartRef.current !== void 0) {
+    pausedAccumRef.current += Date.now() - pauseStartRef.current;
+    pauseStartRef.current = void 0;
+  }
+  const now = isPaused ? pauseStartRef.current ?? Date.now() : Date.now();
+  const rawElapsed = startTime === void 0 ? 0 : Math.max(0, now - startTime);
+  const elapsed = Math.max(0, rawElapsed - pausedAccumRef.current);
   const phraseIndex = Math.floor(elapsed / PHRASE_CYCLE_MS) % THINKING_PHRASES.length;
   const elapsedStr = useMemo(() => {
-    const secs = Math.floor(elapsed / 1e3);
-    if (secs < 1) return "";
-    if (secs < 60) return `${secs}s`;
-    const mins = Math.floor(secs / 60);
-    return `${mins}m${secs % 60}s`;
+    if (elapsed < 1e3) return "";
+    return formatElapsed(elapsed);
   }, [elapsed]);
   const dotCount = tick % 4;
   const dots = ".".repeat(dotCount);
   const phrase = THINKING_PHRASES[phraseIndex] ?? "Thinking";
-  const displayText = activity ? activity : isStreaming ? "Streaming response" : `${phrase}${dots}`;
+  const displayText = isPaused ? "Rate limited \u2014 waiting" : activity ? activity : isStreaming ? "Streaming response" : `${phrase}${dots}`;
+  const visibleDetails = details ? details.slice(0, maxDetailLines) : void 0;
+  const hiddenDetailCount = details ? Math.max(0, details.length - maxDetailLines) : 0;
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
     modelName ? /* @__PURE__ */ jsxs(Box, { children: [
       /* @__PURE__ */ jsxs(Text, { color: colors.role.assistant, bold: true, children: [
@@ -1310,21 +1494,35 @@ function ThinkingIndicator({
       /* @__PURE__ */ jsx(
         GradientSpinner,
         {
-          variant: activity ? "braille" : "dots",
+          variant: isPaused ? "pulse" : activity ? "braille" : "dots",
           label: displayText,
-          labelColor: activity ? colors.text.secondary : colors.text.muted
+          labelColor: isPaused ? colors.status.warning : activity ? colors.text.secondary : colors.text.muted
         }
       ),
       elapsedStr ? /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, children: [
-        " (",
+        " ",
+        "(",
         elapsedStr,
-        ")"
-      ] }) : null
+        " ",
+        "\u2022",
+        " esc to interrupt)"
+      ] }) : /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, children: [
+        " ",
+        "(esc to interrupt)"
+      ] })
     ] }),
-    /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, dimColor: true, children: [
-      "  ",
-      "esc to cancel"
-    ] }) })
+    visibleDetails && visibleDetails.length > 0 ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [
+      visibleDetails.map((detail, i) => /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, dimColor: true, wrap: "truncate", children: [
+        "  \u2514 ",
+        detail
+      ] }, i)),
+      hiddenDetailCount > 0 ? /* @__PURE__ */ jsxs(Text, { color: colors.text.muted, dimColor: true, children: [
+        "    ",
+        "(+",
+        hiddenDetailCount,
+        " more)"
+      ] }) : null
+    ] }) : null
   ] });
 }
 var MASCOT_LINES = [
@@ -1764,6 +1962,111 @@ function useModel(config, initialModel, initialRole) {
     router
   };
 }
+
+// src/ui/streaming-controller.ts
+var StreamingController = class {
+  buffer;
+  committed;
+  lineCounter;
+  headerEmitted;
+  /** Index into `committed` marking where the last drain ended. */
+  drainCursor;
+  constructor() {
+    this.buffer = "";
+    this.committed = [];
+    this.lineCounter = 0;
+    this.headerEmitted = false;
+    this.drainCursor = 0;
+  }
+  /**
+   * Feed a text chunk into the controller.
+   *
+   * Lines terminated by `\n` are committed immediately.
+   * Any trailing text without a newline stays in the buffer.
+   *
+   * @returns Newly committed lines from this chunk.
+   */
+  push(chunk) {
+    this.buffer += chunk;
+    const newLines = [];
+    let newlineIdx = this.buffer.indexOf("\n");
+    while (newlineIdx !== -1) {
+      const lineText = this.buffer.slice(0, newlineIdx);
+      this.buffer = this.buffer.slice(newlineIdx + 1);
+      this.lineCounter += 1;
+      const committed = {
+        text: lineText,
+        lineNumber: this.lineCounter
+      };
+      this.committed.push(committed);
+      newLines.push(committed);
+      newlineIdx = this.buffer.indexOf("\n");
+    }
+    if (newLines.length > 0) {
+      this.headerEmitted = true;
+    }
+    return newLines;
+  }
+  /**
+   * Flush the remaining buffer as a final committed line.
+   *
+   * Call this when the stream ends to commit any trailing
+   * partial line that never received a terminating newline.
+   *
+   * @returns The flushed line, or `null` if the buffer was empty.
+   */
+  flush() {
+    if (this.buffer.length === 0) {
+      return null;
+    }
+    this.lineCounter += 1;
+    const committed = {
+      text: this.buffer,
+      lineNumber: this.lineCounter
+    };
+    this.committed.push(committed);
+    this.buffer = "";
+    this.headerEmitted = true;
+    return committed;
+  }
+  /** Get an immutable snapshot of the current controller state. */
+  getState() {
+    return {
+      committedLines: [...this.committed],
+      pendingLine: this.buffer,
+      hasEmittedHeader: this.headerEmitted,
+      totalLines: this.lineCounter
+    };
+  }
+  /** Get only the pending (incomplete) line text. */
+  getPendingLine() {
+    return this.buffer;
+  }
+  /** Reset the controller to its initial state. */
+  reset() {
+    this.buffer = "";
+    this.committed = [];
+    this.lineCounter = 0;
+    this.headerEmitted = false;
+    this.drainCursor = 0;
+  }
+  /**
+   * Get committed lines since the last call to this method.
+   *
+   * Useful for incremental rendering — each call returns only
+   * the lines that were committed after the previous drain.
+   */
+  drainNewLines() {
+    const newLines = this.committed.slice(this.drainCursor);
+    this.drainCursor = this.committed.length;
+    return newLines;
+  }
+};
+function createStreamingController() {
+  return new StreamingController();
+}
+
+// src/ui/hooks/useStream.ts
 function formatToolActivity(toolCall) {
   const args = toolCall.arguments;
   switch (toolCall.name) {
@@ -1809,25 +2112,32 @@ function useStream() {
   const [state, setState] = useState({
     isStreaming: false,
     content: "",
+    pendingLine: "",
     usage: void 0,
     error: void 0,
     activity: void 0,
     toolCalls: [],
-    startTime: void 0
+    startTime: void 0,
+    isPaused: false
   });
   const cancelRef = useRef(false);
+  const streamingCtrlRef = useRef(null);
   const isCancelled = () => cancelRef.current;
   const startStream = useCallback(
     async (stream) => {
       cancelRef.current = false;
+      const ctrl = createStreamingController();
+      streamingCtrlRef.current = ctrl;
       setState({
         isStreaming: true,
         content: "",
+        pendingLine: "",
         usage: void 0,
         error: void 0,
         activity: void 0,
         toolCalls: [],
-        startTime: Date.now()
+        startTime: Date.now(),
+        isPaused: false
       });
       try {
         for await (const chunk of stream) {
@@ -1836,9 +2146,12 @@ function useStream() {
             case "text":
               if (chunk.content !== void 0) {
                 const text = chunk.content;
+                ctrl.push(text);
+                const ctrlState = ctrl.getState();
                 setState((prev) => ({
                   ...prev,
-                  content: prev.content + text,
+                  content: ctrlState.committedLines.map((l) => l.text).join("\n"),
+                  pendingLine: ctrlState.pendingLine,
                   activity: void 0
                 }));
               }
@@ -1894,12 +2207,17 @@ function useStream() {
                 )
               }));
               return;
-            case "done":
+            case "done": {
+              ctrl.flush();
+              const finalState = ctrl.getState();
               setState((prev) => ({
                 ...prev,
                 isStreaming: false,
+                content: finalState.committedLines.map((l) => l.text).join("\n"),
+                pendingLine: "",
                 usage: chunk.usage ?? prev.usage,
                 activity: void 0,
+                isPaused: false,
                 toolCalls: prev.toolCalls.map(
                   (tc) => tc.status === "executing" ? {
                     ...tc,
@@ -1909,12 +2227,18 @@ function useStream() {
                 )
               }));
               return;
+            }
           }
         }
+        ctrl.flush();
+        const endState = ctrl.getState();
         setState((prev) => ({
           ...prev,
           isStreaming: false,
+          content: endState.committedLines.map((l) => l.text).join("\n"),
+          pendingLine: "",
           activity: void 0,
+          isPaused: false,
           toolCalls: prev.toolCalls.map(
             (tc) => tc.status === "executing" ? {
               ...tc,
@@ -1928,7 +2252,8 @@ function useStream() {
           ...prev,
           isStreaming: false,
           error: error instanceof Error ? error.message : String(error),
-          activity: void 0
+          activity: void 0,
+          isPaused: false
         }));
       }
     },
@@ -1936,28 +2261,52 @@ function useStream() {
   );
   const cancelStream = useCallback(() => {
     cancelRef.current = true;
-    setState((prev) => ({
-      ...prev,
-      isStreaming: false,
-      toolCalls: prev.toolCalls.map(
-        (tc) => tc.status === "executing" ? {
-          ...tc,
-          status: "cancelled",
-          endTime: Date.now()
-        } : tc
-      )
-    }));
+    const ctrl = streamingCtrlRef.current;
+    if (ctrl) {
+      ctrl.flush();
+      const finalState = ctrl.getState();
+      setState((prev) => ({
+        ...prev,
+        isStreaming: false,
+        content: finalState.committedLines.map((l) => l.text).join("\n"),
+        pendingLine: "",
+        isPaused: false,
+        toolCalls: prev.toolCalls.map(
+          (tc) => tc.status === "executing" ? {
+            ...tc,
+            status: "cancelled",
+            endTime: Date.now()
+          } : tc
+        )
+      }));
+    } else {
+      setState((prev) => ({
+        ...prev,
+        isStreaming: false,
+        isPaused: false,
+        toolCalls: prev.toolCalls.map(
+          (tc) => tc.status === "executing" ? {
+            ...tc,
+            status: "cancelled",
+            endTime: Date.now()
+          } : tc
+        )
+      }));
+    }
   }, []);
   const reset = useCallback(() => {
     cancelRef.current = true;
+    streamingCtrlRef.current = null;
     setState({
       isStreaming: false,
       content: "",
+      pendingLine: "",
       usage: void 0,
       error: void 0,
       activity: void 0,
       toolCalls: [],
-      startTime: void 0
+      startTime: void 0,
+      isPaused: false
     });
   }, []);
   return { state, startStream, cancelStream, reset };
@@ -4427,5 +4776,5 @@ async function runFirstRunSetup() {
 }
 
 export { runFirstRunSetup, startChatSession };
-//# sourceMappingURL=App-JQ622M66.js.map
-//# sourceMappingURL=App-JQ622M66.js.map
+//# sourceMappingURL=App-NT6MRKQJ.js.map
+//# sourceMappingURL=App-NT6MRKQJ.js.map