pi-my-compact-ui 0.3.0 → 0.4.0

package/dist/index.js

@@ -0,0 +1,2464 @@
+// src/guards.ts
+import { Container as Container2, Spacer as Spacer2, Markdown as Markdown2, Text } from "@earendil-works/pi-tui";
+import { AssistantMessageComponent as AssistantMessageComponent2, ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
+
+// src/tool-group.ts
+import { Container, Markdown, visibleWidth as visibleWidth2, truncateToWidth as truncateToWidth3 } from "@earendil-works/pi-tui";
+
+// src/state.ts
+function createRuntimeState() {
+  return {
+    currentTheme: null,
+    activeThinking: null,
+    activeThinkingIndex: null,
+    activeThinkingBlocks: /* @__PURE__ */ new Map(),
+    unattachedThinking: [],
+    thinkingEntrySeq: 0,
+    handledTextIndexes: /* @__PURE__ */ new Set(),
+    sealedThinkingIndexes: /* @__PURE__ */ new Set(),
+    pendingTextSeal: false,
+    pendingTextOrdinal: null,
+    lastActiveGroup: null,
+    lastSealedThinkingEntry: null,
+    lastReportedReasoningTokens: 0,
+    lastStreamingComp: null,
+    lastChatContainer: null,
+    toolStarts: /* @__PURE__ */ new Map(),
+    toolDurations: /* @__PURE__ */ new Map(),
+    turnStartMs: 0,
+    preparingByIndex: /* @__PURE__ */ new Map(),
+    activeModalHandle: null,
+    activeModalComponent: null,
+    activeModalCloseFn: null,
+    activeUIContext: null,
+    activeSelectorHandle: null,
+    activeSelectorComponent: null,
+    activeSelectorCloseFn: null,
+    animTimer: null,
+    capturedTui: null,
+    groups: /* @__PURE__ */ new Set(),
+    assistantContentContainers: /* @__PURE__ */ new WeakSet(),
+    assistantContentStates: /* @__PURE__ */ new WeakMap(),
+    groupAnchors: /* @__PURE__ */ new WeakMap()
+  };
+}
+var runtime = createRuntimeState();
+
+// src/constants.ts
+var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_MS = 100;
+var THINKING_SPINNER = {
+  rawFrames: ["\xB7", "\u2022", "\u25CF", "\u2022"],
+  intervalMs: 140,
+  colorKeys: ["dim", "muted", "accent", "muted"]
+};
+var GROUP_PADDING_X = 1;
+var GROUP_PADDING_RIGHT = 2;
+var spinnerStart = Date.now();
+var PARENT_KEY = /* @__PURE__ */ Symbol.for("compact-ui.group-parent");
+var PATCH_KEY = /* @__PURE__ */ Symbol.for("compact-ui.group-patch");
+var MARKDOWN_RENDER_PATCH_KEY = /* @__PURE__ */ Symbol.for("compact-ui.markdown-render-patch");
+var COMPACTION_STYLE_PATCH_KEY = /* @__PURE__ */ Symbol.for("compact-ui.compaction-style-patch");
+var ASSISTANT_THINKING_PATCH_KEY = /* @__PURE__ */ Symbol.for("compact-ui.assistant-thinking-patch");
+var IS_STREAMING_COMP = /* @__PURE__ */ Symbol.for("compact-ui.is-streaming-comp");
+var GROUP_MOUNT = /* @__PURE__ */ Symbol.for("compact-ui.group-mount");
+var TOOL_RENDER_PATCH_KEY = /* @__PURE__ */ Symbol.for("compact-ui.tool-render-patch");
+var LIVE_ASSISTANT_KEY = /* @__PURE__ */ Symbol.for("compact-ui.live-assistant");
+var CODE_BLOCK_PADDING_X = 1;
+
+// src/helpers.ts
+import { homedir } from "os";
+import { isKeyRelease, parseKey, matchesKey } from "@earendil-works/pi-tui";
+function shortenPath(path) {
+  const home = homedir();
+  return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+function oneLine(value, max) {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (typeof max === "number" && text.length > max) {
+    return max <= 3 ? "...".slice(0, max) : `${text.slice(0, max - 3)}...`;
+  }
+  return text;
+}
+function estimateTextTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function formatTokenK(tokens) {
+  if (tokens <= 0) return "0.0K";
+  if (tokens < 100) return "<0.1K";
+  const value = tokens / 1e3;
+  return value < 100 ? `${value.toFixed(1)}K` : `${Math.round(value)}K`;
+}
+function thinkingTokenLabel(entry) {
+  const tokens = Math.max(0, Math.round(Number(entry?.tokens) || 0));
+  if (tokens < 1e3) {
+    return `(${tokens}t)`;
+  }
+  const k = tokens / 1e3;
+  const formatted = k < 100 ? k.toFixed(1) : Math.round(k).toString();
+  return `(${formatted}k)`;
+}
+function toolSummary(name, args) {
+  switch (name) {
+    case "bash":
+    case "powershell":
+      return { name, content: oneLine(args?.command || "...") };
+    case "read":
+      return { name: "read", content: shortenPath(args?.path || "...") };
+    case "write":
+    case "edit":
+      return { name, content: shortenPath(args?.path || "...") };
+    case "find":
+      return { name: "find", content: `${oneLine(args?.pattern || "")} in ${shortenPath(args?.path || ".")}` };
+    case "grep":
+      return { name: "grep", content: `${oneLine(args?.pattern || "")} in ${shortenPath(args?.path || ".")}` };
+    case "ls":
+      return { name: "ls", content: shortenPath(args?.path || ".") };
+    case "web_search":
+      return { name: "web_search", content: oneLine(args?.query || "...") };
+    case "subagent":
+      return { name: "subagent", content: oneLine(args?.agent || args?.task || "...") };
+    default: {
+      const preferred = args?.path ?? args?.query ?? args?.name ?? args?.description ?? args?.url;
+      return { name, content: oneLine(preferred ?? "...") };
+    }
+  }
+}
+function toolStatus(tool) {
+  if (tool?.result?.isError) return "error";
+  if (tool?.isPartial === true || tool?.executionStarted && !tool?.result) return "pending";
+  return tool?.result ? "success" : "pending";
+}
+function streamingToolArgs(block) {
+  const args = block?.arguments && typeof block.arguments === "object" ? block.arguments : {};
+  if (Object.keys(args).length > 0) return args;
+  const partial = String(block?.partialJson || block?.partialArgs || "").trim();
+  if (!partial) return args;
+  const name = String(block?.name || "");
+  if (name === "bash" || name === "powershell") return { command: partial };
+  if (name === "read" || name === "write" || name === "edit" || name === "ls") return { path: partial };
+  return { query: partial };
+}
+function locateStreamingToolCall(content, streamEvent) {
+  const index = Number(streamEvent?.contentIndex);
+  if (Number.isInteger(index) && content[index]?.type === "toolCall") {
+    return { index, block: content[index] };
+  }
+  const fromEvent = streamEvent?.toolCall;
+  if (fromEvent && (fromEvent.type === "toolCall" || fromEvent.name)) {
+    const found = content.findIndex(
+      (item) => item?.type === "toolCall" && fromEvent.id && item.id === fromEvent.id
+    );
+    if (found >= 0) return { index: found, block: content[found] };
+    return { index: Number.isInteger(index) ? index : content.length, block: fromEvent };
+  }
+  return void 0;
+}
+function toolResultText(tool) {
+  return (tool?.result?.content ?? []).filter((c) => c.type === "text").map((c) => String(c.text)).join("\n").trim();
+}
+function formatWorkedTime(elapsedMs) {
+  const totalSec = Math.max(1, Math.round(elapsedMs / 1e3));
+  const hours = Math.floor(totalSec / 3600);
+  const minutes = Math.floor(totalSec % 3600 / 60);
+  const seconds = totalSec % 60;
+  if (hours > 0) return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+  if (minutes > 0) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+  return `${seconds}s`;
+}
+function isCtrlI(data) {
+  if (isKeyRelease(data)) {
+    return false;
+  }
+  return data !== "	" && (parseKey(data) === "ctrl+i" || matchesKey(data, "ctrl+i"));
+}
+
+// src/assistant-patches.ts
+import { Spacer, truncateToWidth as truncateToWidth2 } from "@earendil-works/pi-tui";
+import { AssistantMessageComponent } from "@earendil-works/pi-coding-agent";
+
+// src/markdown.ts
+import { truncateToWidth, visibleWidth, stripTerminalSequences, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+function isCompactCodeBlockOpen(visible) {
+  return visible === "\u250C\u2500" || visible.startsWith("\u250C\u2500 ");
+}
+function isCompactCodeBlockClose(visible) {
+  return visible === "\u2514\u2500";
+}
+function getCompactMarkdownTheme() {
+  const base = getMarkdownTheme();
+  let insideCodeBlock = false;
+  const theme = {
+    ...base,
+    codeBlockIndent: "",
+    codeBlockBorder(text) {
+      const opening = !insideCodeBlock;
+      insideCodeBlock = !insideCodeBlock;
+      const language = opening ? text.replace(/^```/, "").trim() : "";
+      if (opening) {
+        theme.codeBlockIndent = "";
+      }
+      const border = opening ? `\u250C\u2500${language ? ` ${language}` : ""}` : "\u2514\u2500";
+      return base.codeBlockBorder(border);
+    }
+  };
+  return theme;
+}
+function renderCodeBlockBackgroundRow(content, width) {
+  const safeWidth = Math.max(1, width);
+  const horizontalPadding = Math.min(CODE_BLOCK_PADDING_X, Math.floor((safeWidth - 1) / 2));
+  const innerWidth = Math.max(1, safeWidth - horizontalPadding * 2);
+  const clipped = truncateToWidth(content, innerWidth, "...");
+  const rightFill = " ".repeat(Math.max(0, innerWidth - visibleWidth(clipped)));
+  const row = `${" ".repeat(horizontalPadding)}${clipped}${rightFill}${" ".repeat(horizontalPadding)}`;
+  return runtime.currentTheme?.bg?.("toolPendingBg", row) ?? row;
+}
+function normalizeCompactCodeBlockLines(lines, width, paddingX = 0) {
+  const safeWidth = Math.max(1, width);
+  const horizontalPadding = Math.max(0, Math.floor(paddingX));
+  const leftPadding = " ".repeat(horizontalPadding);
+  const contentWidth = Math.max(1, safeWidth - horizontalPadding * 2);
+  const continuationWidth = contentWidth;
+  const normalized = [];
+  let codeBlockMode = "none";
+  for (const originalLine of lines) {
+    const withoutLeftPadding = leftPadding.length > 0 && originalLine.startsWith(leftPadding) ? originalLine.slice(leftPadding.length) : originalLine;
+    const content = withoutLeftPadding.trimEnd();
+    const visible = stripTerminalSequences(content).trimStart();
+    if (isCompactCodeBlockOpen(visible)) {
+      codeBlockMode = "background";
+      const language = visible.replace(/^┌─/, "").trim();
+      if (language) {
+        const label = runtime.currentTheme?.fg?.("muted", language) ?? language;
+        normalized.push(`${leftPadding}${renderCodeBlockBackgroundRow(label, contentWidth)}`);
+      }
+      continue;
+    }
+    if (isCompactCodeBlockClose(visible)) {
+      codeBlockMode = "none";
+      continue;
+    }
+    if (codeBlockMode === "background") {
+      const codeWidth = Math.max(1, continuationWidth - CODE_BLOCK_PADDING_X * 2);
+      const wrappedRows = wrapTextWithAnsi(content, codeWidth);
+      for (const wrapped of wrappedRows.length > 0 ? wrappedRows : [""]) {
+        normalized.push(`${leftPadding}${renderCodeBlockBackgroundRow(wrapped, contentWidth)}`);
+      }
+      continue;
+    }
+    normalized.push(truncateToWidth(originalLine, safeWidth, "..."));
+  }
+  return normalized;
+}
+function installVisibleAssistantMarkdownRendering(component) {
+  const markdown = component;
+  if (markdown[MARKDOWN_RENDER_PATCH_KEY]) return;
+  markdown.theme = getCompactMarkdownTheme();
+  const originalRender = markdown.render.bind(markdown);
+  markdown.render = (width) => normalizeCompactCodeBlockLines(originalRender(width), width, Number(markdown.paddingX) || 0);
+  markdown[MARKDOWN_RENDER_PATCH_KEY] = { originalRender };
+  markdown.invalidate();
+}
+
+// src/assistant-patches.ts
+function thinkingAlreadyShown(text) {
+  const norm = text.trim();
+  if (!norm) return true;
+  if (runtime.activeThinking && runtime.activeThinking.text.trim() === norm) return true;
+  for (const entry of runtime.unattachedThinking) {
+    if (entry.text.trim() === norm) return true;
+  }
+  for (const group of runtime.groups) {
+    for (const entry of group.entries) {
+      if (entry.kind === "thinking" && entry.text.trim() === norm) return true;
+    }
+  }
+  return false;
+}
+function stageHistoricalThinking(state, ordinal, texts, message) {
+  if (state.anchors.has(ordinal)) return;
+  const fresh = texts.filter((text, index) => text.trim() && texts.indexOf(text) === index && !thinkingAlreadyShown(text));
+  if (fresh.length === 0) return;
+  const group = new ToolGroupComponent();
+  group.anchored = true;
+  group.sealed = true;
+  const reasoningTokens = Number(message?.usage?.reasoning);
+  const tokensExact = Number.isFinite(reasoningTokens) && reasoningTokens > 0;
+  for (const text of fresh) {
+    const entry = {
+      kind: "thinking",
+      id: runtime.thinkingEntrySeq++,
+      text,
+      tokens: tokensExact ? reasoningTokens : estimateTextTokens(text),
+      tokensExact,
+      active: false,
+      owner: group
+    };
+    group.entries.push(entry);
+  }
+  if (!group.hasVisibleEntries()) return;
+  state.anchors.set(ordinal, group);
+  runtime.groups.add(group);
+}
+function ensureHistoricalThinkingAnchors(contentContainer, message) {
+  const content = Array.isArray(message?.content) ? message.content : void 0;
+  if (!content || content.length === 0) return;
+  const state = getAssistantContentState(contentContainer);
+  let currentThinkingBlocks = [];
+  let textOrdinal = 0;
+  for (const item of content) {
+    if (item?.type === "thinking") {
+      const text = String(item.thinking ?? "").trim();
+      if (text) currentThinkingBlocks.push(text);
+    } else if (item?.type === "text" && String(item.text ?? "").trim()) {
+      stageHistoricalThinking(state, textOrdinal, currentThinkingBlocks, message);
+      currentThinkingBlocks = [];
+      textOrdinal++;
+    }
+  }
+  const hasToolCalls = content.some((item) => item?.type === "toolCall");
+  if (!hasToolCalls && textOrdinal === 0 && currentThinkingBlocks.length > 0) {
+    stageHistoricalThinking(state, 0, currentThinkingBlocks, message);
+  }
+}
+function installNativeThinkingSuppression(prototype = AssistantMessageComponent.prototype) {
+  if (!prototype || typeof prototype.updateContent !== "function") return;
+  const previous = prototype[ASSISTANT_THINKING_PATCH_KEY];
+  const originalUpdateContent = previous && prototype.updateContent === previous.installedUpdateContent ? previous.originalUpdateContent : prototype.updateContent;
+  const installedUpdateContent = function(message, isStreaming) {
+    const contentContainer = this.contentContainer;
+    if (contentContainer) {
+      runtime.assistantContentContainers.add(contentContainer);
+    }
+    if (isStreaming === true) {
+      this[LIVE_ASSISTANT_KEY] = true;
+    }
+    const isLive = Boolean(this[LIVE_ASSISTANT_KEY]) || isStreaming === true || this[IS_STREAMING_COMP] === true || this === runtime.lastStreamingComp;
+    const content = Array.isArray(message?.content) ? message.content : void 0;
+    const hasToolCalls = Boolean(content?.some((item) => item?.type === "toolCall"));
+    const hasText = Boolean(content?.some((item) => item?.type === "text" && String(item?.text ?? "").trim()));
+    if (!isLive && contentContainer && message?.content) {
+      ensureHistoricalThinkingAnchors(contentContainer, message);
+    }
+    if (!content?.some((item) => item?.type === "thinking")) {
+      originalUpdateContent.call(this, message, isStreaming);
+      return;
+    }
+    originalUpdateContent.call(
+      this,
+      {
+        ...message,
+        content: content.filter((item) => item?.type !== "thinking")
+      },
+      isStreaming
+    );
+    if (!isLive && !hasToolCalls && !hasText && contentContainer) {
+      const state = getAssistantContentState(contentContainer);
+      const group = state.anchors.get(0);
+      if (group && group.hasVisibleEntries() && !contentContainer.children.includes(group)) {
+        detachGroup(group, contentContainer);
+        contentContainer.addChild(new Spacer(1));
+        contentContainer.addChild(group);
+        contentContainer.addChild(new Spacer(1));
+        noteGroupMount(contentContainer, group);
+      }
+    }
+  };
+  prototype.updateContent = installedUpdateContent;
+  if (typeof prototype.setHideThinkingBlock === "function") {
+    const originalSetHideThinkingBlock = prototype.setHideThinkingBlock;
+    prototype.setHideThinkingBlock = function(_hide) {
+      this.hiddenThinkingLabel = "";
+      originalSetHideThinkingBlock.call(this, true);
+    };
+  }
+  if (typeof prototype.setHiddenThinkingLabel === "function") {
+    const originalSetHiddenThinkingLabel = prototype.setHiddenThinkingLabel;
+    prototype.setHiddenThinkingLabel = function(_label) {
+      this.hiddenThinkingLabel = "";
+      originalSetHiddenThinkingLabel.call(this, "");
+    };
+  }
+  prototype[ASSISTANT_THINKING_PATCH_KEY] = {
+    originalUpdateContent,
+    installedUpdateContent
+  };
+}
+function ensureAssistantThinkingPatched(component) {
+  const prototype = Object.getPrototypeOf(component);
+  const already = Boolean(prototype?.[ASSISTANT_THINKING_PATCH_KEY]);
+  installNativeThinkingSuppression(prototype);
+  component.hideThinkingBlock = true;
+  component.hiddenThinkingLabel = "";
+  return already;
+}
+function getAssistantContentState(container) {
+  let state = runtime.assistantContentStates.get(container);
+  if (!state) {
+    state = { anchors: /* @__PURE__ */ new Map(), nextTextOrdinal: 0 };
+    runtime.assistantContentStates.set(container, state);
+  }
+  return state;
+}
+function removeGroupFromContainer(container, group) {
+  const children = container?.children;
+  if (!Array.isArray(children)) return;
+  const index = children.indexOf(group);
+  if (index >= 0) children.splice(index, 1);
+  if (group[GROUP_MOUNT] === container) delete group[GROUP_MOUNT];
+}
+function noteGroupMount(container, group) {
+  group[GROUP_MOUNT] = container;
+}
+function detachGroup(group, keep) {
+  const mounted = group[GROUP_MOUNT];
+  if (mounted && mounted !== keep) removeGroupFromContainer(mounted, group);
+  if (runtime.lastChatContainer && runtime.lastChatContainer !== keep) removeGroupFromContainer(runtime.lastChatContainer, group);
+  const anchor = runtime.groupAnchors.get(group);
+  if (anchor?.container && anchor.container !== keep) removeGroupFromContainer(anchor.container, group);
+}
+function removeComponentFromContainer(container, component) {
+  const children = container?.children;
+  if (!Array.isArray(children)) return;
+  const index = children.indexOf(component);
+  if (index >= 0) children.splice(index, 1);
+}
+var TurnDividerComponent = class {
+  timeLabel;
+  constructor(timeLabel) {
+    this.timeLabel = timeLabel;
+  }
+  render(width) {
+    const theme = runtime.currentTheme;
+    const fg = (color, text) => theme?.fg?.(color, text) ?? text;
+    const middle = `worked for ${this.timeLabel}`;
+    const avail = Math.max(6, width - middle.length - 2);
+    const left = Math.floor(avail / 2);
+    const right = avail - left;
+    const dash = (n) => "\u2500".repeat(Math.max(0, n));
+    const line = `${fg("dim", dash(left))} ${fg("muted", middle)} ${fg("dim", dash(right))}`;
+    return [truncateToWidth2(line, Math.max(1, width)), ""];
+  }
+  invalidate() {
+  }
+};
+function placeTurnDividerBeforeText(container, target, divider) {
+  const targetIndex = container.children.indexOf(target);
+  if (targetIndex < 0) return;
+  removeComponentFromContainer(container, divider);
+  container.children.splice(targetIndex, 0, divider);
+}
+function insertTurnDivider(elapsedMs) {
+  if (elapsedMs < 1e3) return;
+  let comp = runtime.lastStreamingComp;
+  if (!comp || !isAssistantMessage(comp)) {
+    if (!runtime.lastChatContainer) return;
+    const children = runtime.lastChatContainer?.children;
+    if (!Array.isArray(children)) return;
+    for (let i = children.length - 1; i >= 0; i--) {
+      if (isAssistantMessage(children[i])) {
+        comp = children[i];
+        break;
+      }
+    }
+  }
+  if (!comp) return;
+  const contentContainer = comp.contentContainer;
+  if (!isContainer(contentContainer)) return;
+  const markdowns = contentContainer.children.filter(isVisibleTextMarkdown);
+  if (markdowns.length === 0) return;
+  const final = markdowns[markdowns.length - 1];
+  const finalIndex = contentContainer.children.indexOf(final);
+  const hasPriorContent = contentContainer.children.slice(0, finalIndex).some((child) => isToolGroup(child) && child.hasVisibleEntries());
+  if (!hasPriorContent) return;
+  const state = getAssistantContentState(contentContainer);
+  if (state.finalDivider && contentContainer.children.includes(state.finalDivider.component)) return;
+  const ordinal = markdowns.length - 1;
+  const divider = new TurnDividerComponent(formatWorkedTime(elapsedMs));
+  state.finalDivider = { ordinal, component: divider };
+  placeTurnDividerBeforeText(contentContainer, final, divider);
+  contentContainer.invalidate?.();
+  runtime.capturedTui?.requestRender?.();
+}
+function isVisibleTextMarkdown(component) {
+  return isMarkdown(component) && !component.defaultTextStyle;
+}
+function placeAnchoredGroupBeforeText(container, target, group) {
+  detachGroup(group, container);
+  const targetIndex = container.children.indexOf(target);
+  if (targetIndex < 0) return;
+  let spacerStart = targetIndex;
+  while (spacerStart > 0 && isSpacer(container.children[spacerStart - 1])) spacerStart--;
+  if (targetIndex > spacerStart) {
+    container.children.splice(spacerStart, targetIndex - spacerStart);
+  }
+  group.anchored = true;
+  container.children.splice(spacerStart, 0, new Spacer(1), group, new Spacer(1));
+  noteGroupMount(container, group);
+}
+function insertAnchoredGroup(container, ordinal, group) {
+  if (!group.hasVisibleEntries()) return;
+  const markdowns = container.children.filter(isVisibleTextMarkdown);
+  const target = markdowns[ordinal];
+  if (!target) return;
+  removeGroupFromContainer(container, group);
+  placeAnchoredGroupBeforeText(container, target, group);
+}
+function installAssistantExpansion(component, contentContainer) {
+  component.setExpanded = (expanded) => {
+    const state = runtime.assistantContentStates.get(contentContainer);
+    if (!state) return;
+    for (const group of state.anchors.values()) group.setExpanded(expanded);
+    contentContainer.invalidate();
+  };
+}
+function anchorGroupBeforeCurrentText(group, ordinal) {
+  if (!runtime.lastStreamingComp || !runtime.lastChatContainer) return;
+  const contentContainer = runtime.lastStreamingComp.contentContainer;
+  if (!isContainer(contentContainer)) return;
+  removeGroupFromContainer(runtime.lastChatContainer, group);
+  const previousAnchor = runtime.groupAnchors.get(group);
+  if (previousAnchor) {
+    const previousState = runtime.assistantContentStates.get(previousAnchor.container);
+    if (previousState?.anchors.get(previousAnchor.ordinal) === group) {
+      previousState.anchors.delete(previousAnchor.ordinal);
+    }
+    removeGroupFromContainer(previousAnchor.container, group);
+  }
+  if (!group.hasVisibleEntries()) {
+    runtime.groups.delete(group);
+    return;
+  }
+  const state = getAssistantContentState(contentContainer);
+  const replaced = state.anchors.get(ordinal);
+  if (replaced && replaced !== group) {
+    removeGroupFromContainer(contentContainer, replaced);
+    replaced.anchored = false;
+    runtime.groupAnchors.delete(replaced);
+  }
+  state.anchors.set(ordinal, group);
+  runtime.groupAnchors.set(group, { container: contentContainer, ordinal });
+  insertAnchoredGroup(contentContainer, ordinal, group);
+  runtime.lastChatContainer.invalidate?.();
+  runtime.capturedTui?.requestRender?.();
+}
+function restoreAssistantAnchor(parent, component) {
+  if (!runtime.assistantContentContainers.has(parent) || !isVisibleTextMarkdown(component)) return;
+  installVisibleAssistantMarkdownRendering(component);
+  const state = getAssistantContentState(parent);
+  const ordinal = state.nextTextOrdinal++;
+  const group = state.anchors.get(ordinal);
+  if (group && group.hasVisibleEntries()) {
+    removeGroupFromContainer(parent, group);
+    placeAnchoredGroupBeforeText(parent, component, group);
+  }
+  const divider = state.finalDivider;
+  if (divider && divider.ordinal === ordinal) {
+    placeTurnDividerBeforeText(parent, component, divider.component);
+  }
+}
+function releaseAssistantAnchors(component) {
+  if (!isAssistantMessage(component)) return;
+  const contentContainer = component.contentContainer;
+  if (!isContainer(contentContainer)) return;
+  const state = runtime.assistantContentStates.get(contentContainer);
+  if (!state) return;
+  for (const group of state.anchors.values()) {
+    for (const tool of [...group.children]) delete tool[PARENT_KEY];
+    runtime.groupAnchors.delete(group);
+    runtime.groups.delete(group);
+  }
+  state.anchors.clear();
+  state.finalDivider = void 0;
+}
+function stripAssistantPhantomPadding(parent, component) {
+  if (isAssistantMessage(parent) && isContainer(component) && !isAssistantMessage(component)) {
+    runtime.assistantContentContainers.add(component);
+    getAssistantContentState(component);
+    installAssistantExpansion(parent, component);
+    return;
+  }
+  if (!runtime.assistantContentContainers.has(parent)) return;
+  if (!isNativeThinkingWidget(component)) return;
+  const index = parent.children.indexOf(component);
+  if (index >= 0) parent.children.splice(index, 1);
+  if (isSpacer(parent.children[index])) parent.children.splice(index, 1);
+  while (parent.children.length > 0 && parent.children.every((child) => isSpacer(child))) parent.children.pop();
+}
+function isNativeThinkingWidget(component) {
+  if (!component || isToolGroup(component)) return false;
+  if (component.constructor?.name === "MouseRegion" && component.child) {
+    return isNativeThinkingWidget(component.child);
+  }
+  if (isMarkdown(component) && component.defaultTextStyle) return true;
+  if (!isText(component)) return false;
+  const visible = String(component.text ?? "").replace(/\x1b\[[0-9;]*m/g, "").trim();
+  return visible === "" || visible === "Thinking..." || visible === "thinking" || visible === "thinking...";
+}
+
+// src/streaming-tools.ts
+function toolElapsed(tool) {
+  if (typeof tool?._elapsedDuration === "number") {
+    return tool._elapsedDuration.toFixed(1);
+  }
+  const knownDuration = runtime.toolDurations.get(tool.toolCallId);
+  if (knownDuration !== void 0) {
+    tool._elapsedDuration = knownDuration;
+    return knownDuration.toFixed(1);
+  }
+  if (tool?._groupEndAt !== void 0) {
+    const start2 = runtime.toolStarts.get(tool.toolCallId) ?? tool._groupEndAt;
+    const dur = Math.max(0, (tool._groupEndAt - start2) / 1e3);
+    tool._elapsedDuration = dur;
+    return dur.toFixed(1);
+  }
+  if (tool?.result) {
+    const resultTs = Number(tool.result?.timestamp);
+    const start2 = runtime.toolStarts.get(tool.toolCallId);
+    if (start2 && resultTs && resultTs >= start2) {
+      const dur = (resultTs - start2) / 1e3;
+      tool._elapsedDuration = dur;
+      return dur.toFixed(1);
+    }
+    tool._elapsedDuration = 0;
+    return "0.0";
+  }
+  const start = runtime.toolStarts.get(tool.toolCallId);
+  if (start !== void 0) {
+    return Math.max(0, (Date.now() - start) / 1e3).toFixed(1);
+  }
+  return "0.0";
+}
+function rememberToolStart(toolCallId) {
+  if (!toolCallId || runtime.toolStarts.has(toolCallId) || runtime.toolDurations.has(toolCallId)) return;
+  runtime.toolStarts.set(toolCallId, Date.now());
+}
+function loadSessionToolTimings(entries) {
+  if (!Array.isArray(entries)) return;
+  for (const entry of entries) {
+    if (entry?.type === "message" && entry.message) {
+      const msg = entry.message;
+      if (msg.role === "assistant" && Array.isArray(msg.content)) {
+        const startTime = Number(msg.timestamp) || (entry.timestamp ? new Date(entry.timestamp).getTime() : 0);
+        for (const block of msg.content) {
+          if (block.type === "toolCall" && block.id) {
+            if (startTime > 0) runtime.toolStarts.set(block.id, startTime);
+          }
+        }
+      } else if (msg.role === "toolResult" && msg.toolCallId) {
+        const endTime = Number(msg.timestamp) || (entry.timestamp ? new Date(entry.timestamp).getTime() : 0);
+        const startTime = runtime.toolStarts.get(msg.toolCallId);
+        if (startTime && endTime >= startTime) {
+          runtime.toolDurations.set(msg.toolCallId, (endTime - startTime) / 1e3);
+        }
+      }
+    }
+  }
+}
+function findGroupedTool(toolCallId, contentIndex) {
+  for (const group of runtime.groups) {
+    for (const entry of group.entries) {
+      if (entry.kind !== "tool") continue;
+      const tool = entry.tool;
+      if (toolCallId && tool?.toolCallId === toolCallId) return tool;
+      if (tool?._contentIndex === contentIndex) return tool;
+    }
+  }
+  return void 0;
+}
+function invalidateGroupedTool(tool) {
+  const group = tool?.owner ?? tool?.[PARENT_KEY];
+  if (isToolGroup(group)) {
+    if (!group.sealed) runtime.lastActiveGroup = group;
+    group.invalidate();
+  } else {
+    runtime.lastActiveGroup?.invalidate();
+  }
+  runtime.capturedTui?.requestRender?.();
+}
+function findOpenGroup() {
+  if (runtime.lastActiveGroup && !runtime.lastActiveGroup.sealed && runtime.groups.has(runtime.lastActiveGroup)) return runtime.lastActiveGroup;
+  for (const group of runtime.groups) {
+    if (!group.sealed) return group;
+  }
+  return null;
+}
+function placeGroupAfter(parent, after, group) {
+  const children = parent?.children;
+  if (!Array.isArray(children)) return;
+  detachGroup(group, parent);
+  const existing = children.indexOf(group);
+  if (existing >= 0) children.splice(existing, 1);
+  const afterIndex = after ? children.indexOf(after) : -1;
+  children.splice(afterIndex >= 0 ? afterIndex + 1 : children.length, 0, group);
+  noteGroupMount(parent, group);
+  runtime.lastActiveGroup = group;
+}
+function openToolGroup() {
+  const open = findOpenGroup();
+  if (open) {
+    if (runtime.lastChatContainer && runtime.lastStreamingComp) placeGroupAfter(runtime.lastChatContainer, runtime.lastStreamingComp, open);
+    return open;
+  }
+  if (!runtime.lastChatContainer || !runtime.lastStreamingComp) return null;
+  let group;
+  const parent = runtime.lastChatContainer;
+  const children = parent.children;
+  if (!Array.isArray(children)) return null;
+  const idx = children.indexOf(runtime.lastStreamingComp);
+  group = new ToolGroupComponent();
+  detachGroup(group);
+  children.splice(idx >= 0 ? idx + 1 : children.length, 0, group);
+  noteGroupMount(parent, group);
+  runtime.groups.add(group);
+  runtime.lastActiveGroup = group;
+  parent.invalidate?.();
+  return group;
+}
+function attachPreparingTool(tool) {
+  if (tool.owner) return;
+  const group = openToolGroup();
+  if (!group) return;
+  tool.owner = group;
+  group.entries.push({ kind: "tool", tool });
+  group.invalidate();
+  runtime.lastActiveGroup = group;
+}
+function detachPreparingTool(tool) {
+  const group = tool.owner;
+  if (group) {
+    const index = group.entries.findIndex((entry) => entry.kind === "tool" && entry.tool === tool);
+    if (index >= 0) group.entries.splice(index, 1);
+  }
+  tool.owner = null;
+}
+function takePreparingTool(real) {
+  const id = String(real?.toolCallId ?? "");
+  const name = String(real?.toolName ?? "");
+  if (id) {
+    for (const [index, candidate] of runtime.preparingByIndex) {
+      if (candidate.toolCallId === id) {
+        runtime.preparingByIndex.delete(index);
+        return candidate;
+      }
+    }
+  }
+  const matches = [...runtime.preparingByIndex.entries()].filter(([, candidate]) => candidate.toolName === name);
+  if (matches.length === 1) {
+    runtime.preparingByIndex.delete(matches[0][0]);
+    return matches[0][1];
+  }
+  return void 0;
+}
+function absorbPreparingTool(real) {
+  const preparing = takePreparingTool(real);
+  if (!preparing) return;
+  const id = String(real?.toolCallId ?? "");
+  const start = runtime.toolStarts.get(preparing.toolCallId);
+  if (start !== void 0 && id && !runtime.toolStarts.has(id)) runtime.toolStarts.set(id, start);
+  real._contentIndex = preparing._contentIndex;
+  if ((!real.args || Object.keys(real.args).length === 0) && preparing.args) real.args = preparing.args;
+  detachPreparingTool(preparing);
+}
+function clearPreparingTools() {
+  for (const tool of runtime.preparingByIndex.values()) detachPreparingTool(tool);
+  runtime.preparingByIndex.clear();
+}
+function noteStreamingToolCall(content, streamEvent) {
+  const located = locateStreamingToolCall(content, streamEvent);
+  if (!located) return;
+  const { index, block } = located;
+  const id = String(block.id || "");
+  const name = String(block.name || "tool");
+  const args = streamingToolArgs(block);
+  const existing = findGroupedTool(id, index);
+  if (existing && !existing._preparing) {
+    existing._contentIndex = index;
+    existing.args = args;
+    rememberToolStart(String(existing.toolCallId || id));
+    invalidateGroupedTool(existing);
+    return;
+  }
+  let preparing = runtime.preparingByIndex.get(index);
+  if (!preparing) {
+    preparing = {
+      toolName: name,
+      toolCallId: id || `preparing:${index}`,
+      args,
+      isPartial: true,
+      _preparing: true,
+      _contentIndex: index,
+      owner: null
+    };
+    runtime.preparingByIndex.set(index, preparing);
+    attachPreparingTool(preparing);
+  } else {
+    if (name && name !== "tool") preparing.toolName = name;
+    if (id && preparing.toolCallId !== id) {
+      const previous = preparing.toolCallId;
+      preparing.toolCallId = id;
+      const start = runtime.toolStarts.get(previous);
+      if (start !== void 0 && !runtime.toolStarts.has(id)) runtime.toolStarts.set(id, start);
+    }
+    preparing.args = args;
+    if (!preparing.owner) attachPreparingTool(preparing);
+  }
+  rememberToolStart(preparing.toolCallId);
+  invalidateGroupedTool(preparing);
+}
+
+// src/animation.ts
+function thinkingSpinnerFrame(now = Date.now()) {
+  const index = Math.floor((now - spinnerStart) / THINKING_SPINNER.intervalMs) % THINKING_SPINNER.rawFrames.length;
+  return {
+    frame: THINKING_SPINNER.rawFrames[index],
+    color: THINKING_SPINNER.colorKeys[index]
+  };
+}
+function disableMouseTracking() {
+  if (process.stdout.isTTY) {
+    process.stdout.write("\x1B[?1006l\x1B[?1004l\x1B[?1002l\x1B[?1000l");
+  }
+}
+process.on("exit", disableMouseTracking);
+function scheduleAnimation() {
+  if (runtime.animTimer) return;
+  runtime.animTimer = setTimeout(() => {
+    runtime.animTimer = null;
+    let any = false;
+    for (const g of runtime.groups) {
+      if (g.needsAnimation()) {
+        any = true;
+        break;
+      }
+    }
+    if (any && runtime.capturedTui) {
+      runtime.capturedTui.requestRender();
+    }
+  }, [...runtime.groups].some((group) => group.hasPending()) ? SPINNER_MS : THINKING_SPINNER.intervalMs);
+}
+
+// src/config.ts
+import { join } from "path";
+import { homedir as homedir2 } from "os";
+import { readFileSync, writeFileSync } from "fs";
+var CONFIG_PATH = join(homedir2(), ".pi", "agent", "compact-ui.json");
+var DEFAULT_CONFIG = { expandedToolLines: 5, expandedThinkingLines: 10, maxGroupEntries: 5 };
+var config = loadConfig(CONFIG_PATH);
+function saveConfig(values = config, path = CONFIG_PATH, write = writeFileSync) {
+  try {
+    write(path, JSON.stringify(values, null, 2) + "\n");
+  } catch {
+  }
+}
+function loadConfig(path, read = readFileSync) {
+  try {
+    return { ...DEFAULT_CONFIG, ...JSON.parse(read(path, "utf-8")) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+// src/tool-group.ts
+var ToolGroupComponent = class extends Container {
+  toolCallId = `compact-group-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+  toolName = "group";
+  /** Nested at a visible-text boundary rather than rendered at chat level. */
+  anchored = false;
+  _expanded = false;
+  get expanded() {
+    return this._expanded;
+  }
+  /** Sealed: this block was closed by real text output — no further entries. */
+  sealed = false;
+  /** Thinking runs and tool calls, in the exact order they streamed in. */
+  entries = [];
+  markdownPreviewCache = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
+  }
+  setExpanded(expanded) {
+    this._expanded = expanded;
+    for (const tool of this.children) tool.setExpanded?.(expanded);
+    this.invalidate();
+  }
+  addTool(tool) {
+    absorbPreparingTool(tool);
+    hideGroupedToolRender(tool);
+    if (!tool?.result && !runtime.toolDurations.has(tool?.toolCallId)) {
+      rememberToolStart(String(tool?.toolCallId ?? ""));
+    }
+    this.children.push(tool);
+    if (tool._groupedAt === void 0) tool._groupedAt = Date.now();
+    tool[PARENT_KEY] = this;
+    this.entries.push({ kind: "tool", tool });
+  }
+  /** Append a thinking run. Idempotent: a run belongs to exactly one group. */
+  addThinking(entry) {
+    if (entry.owner) return;
+    entry.owner = this;
+    this.entries.push(entry);
+  }
+  removeTool(tool) {
+    const index = this.children.indexOf(tool);
+    if (index >= 0) this.children.splice(index, 1);
+    const entryIndex = this.entries.findIndex((item) => item.kind === "tool" && item.tool === tool);
+    if (entryIndex >= 0) this.entries.splice(entryIndex, 1);
+    if (tool?.[PARENT_KEY] === this) delete tool[PARENT_KEY];
+  }
+  /** Return only entries that should be displayed (tools, or thinking with non-empty text). */
+  getVisibleEntries() {
+    return this.entries.filter((entry) => {
+      if (entry.kind === "tool") return true;
+      if (entry.kind === "thinking") {
+        return entry.text.trim().length > 0;
+      }
+      return false;
+    });
+  }
+  hasVisibleEntries() {
+    return this.getVisibleEntries().length > 0;
+  }
+  hasPending() {
+    return this.getVisibleEntries().some((entry) => entry.kind === "tool" && toolStatus(entry.tool) === "pending");
+  }
+  /** True while a thinking run in this group is still streaming. */
+  hasActiveThinking() {
+    return this.getVisibleEntries().some((entry) => entry.kind === "thinking" && entry.active);
+  }
+  /** True once any thinking run has been added to this group. */
+  hasThinking() {
+    return this.getVisibleEntries().some((entry) => entry.kind === "thinking");
+  }
+  /** True while this group should keep its spinner animating. */
+  needsAnimation() {
+    if (this.sealed) return false;
+    return this.hasVisibleEntries() && (this.hasPending() || this.hasActiveThinking());
+  }
+  invalidate() {
+    this.markdownPreviewCache.clear();
+    super.invalidate();
+  }
+  renderMarkdownPreview(cacheKey, source, width, maxLines, defaultTextStyle) {
+    const renderWidth = Math.max(1, width);
+    const lineLimit = Math.max(1, maxLines);
+    const cached = this.markdownPreviewCache.get(cacheKey);
+    if (cached && cached.source === source && cached.width === renderWidth && cached.maxLines === lineLimit) {
+      return cached;
+    }
+    const sourceRows = source.split("\n");
+    const sourceLineLimit = Math.max(lineLimit * 4, lineLimit + 20);
+    const sourceCharLimit = Math.max(4096, lineLimit * Math.max(40, renderWidth) * 4);
+    let markdownSource = sourceRows.slice(0, sourceLineLimit).join("\n");
+    let sourceTruncated = sourceRows.length > sourceLineLimit;
+    if (markdownSource.length > sourceCharLimit) {
+      markdownSource = markdownSource.slice(0, sourceCharLimit);
+      sourceTruncated = true;
+    }
+    const markdown = new Markdown(markdownSource, 0, 0, getCompactMarkdownTheme(), defaultTextStyle);
+    const rendered = normalizeCompactCodeBlockLines(markdown.render(renderWidth), renderWidth);
+    const preview = {
+      source,
+      width: renderWidth,
+      maxLines: lineLimit,
+      lines: rendered.slice(0, lineLimit),
+      truncated: sourceTruncated || rendered.length > lineLimit
+    };
+    this.markdownPreviewCache.set(cacheKey, preview);
+    return preview;
+  }
+  iconFor(tool, frame) {
+    const st = toolStatus(tool);
+    return st === "pending" ? frame : st === "error" ? "\u2717" : "\u2713";
+  }
+  colorFor(status) {
+    return status === "pending" ? "accent" : status === "error" ? "error" : "success";
+  }
+  // Tool name in bold accent, tool payload in dim, elapsed right-aligned to width.
+  toolRow(rail, tool, frame, width, isDim = false) {
+    const theme = runtime.currentTheme;
+    const fg = (color, text) => theme?.fg?.(color, text) ?? text;
+    const bold = theme?.bold ? theme.bold : (t) => t;
+    const st = toolStatus(tool);
+    const s = toolSummary(tool.toolName, tool.args);
+    const prefix = rail ? fg("dim", rail) : "";
+    const leftHeader = isDim ? `${prefix}${fg("dim", this.iconFor(tool, frame))} ${fg("dim", s.name)}` : `${prefix}${fg(this.colorFor(st), this.iconFor(tool, frame))} ${fg("toolTitle", bold(s.name))}`;
+    const right = fg(isDim ? "dim" : "muted", `(${toolElapsed(tool)}s)`);
+    const rightLen = visibleWidth2(right);
+    const headerLen = visibleWidth2(leftHeader);
+    if (s.content) {
+      const maxContentLen = width - headerLen - 1 - rightLen - 1;
+      if (maxContentLen > 3) {
+        const truncatedContent = truncateToWidth3(s.content, maxContentLen, fg("dim", "..."));
+        const left = `${leftHeader} ${fg("dim", truncatedContent)}`;
+        const gap2 = Math.max(1, width - visibleWidth2(left) - rightLen);
+        return `${left}${" ".repeat(gap2)}${right}`;
+      }
+    }
+    const gap = Math.max(1, width - headerLen - rightLen);
+    return `${leftHeader}${" ".repeat(gap)}${right}`;
+  }
+  // One row per thinking run. The spinner marks the run that is still streaming;
+  // the completion mark is written as soon as the run ends. Token label is right-aligned.
+  thinkingRow(rail, entry, width, showPreview = true, isDim = false) {
+    const theme = runtime.currentTheme;
+    const fg = (color, text) => theme?.fg?.(color, text) ?? text;
+    const spin = entry.active ? thinkingSpinnerFrame() : void 0;
+    const icon = spin?.frame ?? "\u2713";
+    const iconColor = isDim ? "dim" : spin?.color ?? "thinkingText";
+    const prefix = rail ? fg("dim", rail) : "";
+    const preview = showPreview ? entry.text.trim().replace(/[*_#`>]+/g, "") : "";
+    if (showPreview && !preview) {
+      const label = entry.active ? "thinking..." : "thinking";
+      const titleColor2 = isDim ? "dim" : "toolTitle";
+      return `${prefix}${fg(iconColor, icon)} ${fg(titleColor2, label)}`;
+    }
+    const titleColor = isDim ? "dim" : "toolTitle";
+    const leftHeader = `${prefix}${fg(iconColor, icon)} ${fg(titleColor, "thinking")}`;
+    const tokenLabel = thinkingTokenLabel(entry);
+    const right = fg(isDim ? "dim" : "muted", tokenLabel);
+    const rightLen = visibleWidth2(right);
+    const headerLen = visibleWidth2(leftHeader);
+    if (preview) {
+      const maxPreviewLen = width - headerLen - 1 - rightLen - 1;
+      if (maxPreviewLen > 3) {
+        const contentColor = isDim ? "dim" : "thinkingText";
+        const ellipsis = fg(contentColor, "...");
+        const truncated = truncateToWidth3(preview.replace(/\s+/g, " "), maxPreviewLen, ellipsis);
+        const left = `${leftHeader} ${fg(contentColor, truncated)}`;
+        const gap2 = Math.max(1, width - visibleWidth2(left) - rightLen);
+        return `${left}${" ".repeat(gap2)}${right}`;
+      }
+    }
+    const gap = Math.max(1, width - headerLen - rightLen);
+    return `${leftHeader}${" ".repeat(gap)}${right}`;
+  }
+  // Folded: header + one line per entry, in stream order (oldest first).
+  // When there is only 1 visible entry, do not show hierarchy (no header, no tree rail).
+  renderCollapsed(width, visible) {
+    const theme = runtime.currentTheme;
+    const fg = (color, text) => theme?.fg?.(color, text) ?? text;
+    const frame = SPINNER[Math.floor((Date.now() - spinnerStart) / SPINNER_MS) % SPINNER.length];
+    if (visible.length === 1) {
+      const entry = visible[0];
+      if (entry.kind === "tool") {
+        return [this.toolRow("", entry.tool, frame, width)];
+      }
+      return [this.thinkingRow("", entry, width)];
+    }
+    const lines = [];
+    const hasPendingTool = visible.some((e) => e.kind === "tool" && toolStatus(e.tool) === "pending");
+    const isThinking = !this.sealed && visible.some((e) => e.kind === "thinking" && e.active);
+    const hasTools = visible.some((e) => e.kind === "tool");
+    const hasThinking = visible.some((e) => e.kind === "thinking");
+    const openNoTools = !this.sealed && !hasTools;
+    const working = hasPendingTool || isThinking || openNoTools;
+    const state = hasPendingTool ? "tool calling..." : !hasTools ? working ? "thinking..." : "thinking" : isThinking ? "thinking..." : hasThinking ? "tools and thinking done" : "tools done";
+    const stateColor = hasPendingTool ? "accent" : hasTools && !isThinking ? "success" : "thinkingText";
+    const thinkingSpin = !hasPendingTool && working ? thinkingSpinnerFrame() : void 0;
+    const leftIcon = working ? thinkingSpin?.frame ?? frame : "\u2713";
+    const leftColor = thinkingSpin?.color ?? stateColor;
+    const maxEntries = config.maxGroupEntries ?? 5;
+    const hiddenCount = visible.length > maxEntries ? visible.length - maxEntries : 0;
+    const hiddenSuffix = hiddenCount > 0 ? ` ${fg("muted", `(${hiddenCount} hidden)`)}` : "";
+    lines.push(`${fg(leftColor, leftIcon)} ${fg(stateColor, state)}${hiddenSuffix}`);
+    const entriesToRender = hiddenCount > 0 ? visible.slice(hiddenCount) : visible;
+    const total = entriesToRender.length;
+    for (let index = 0; index < total; index++) {
+      const entry = entriesToRender[index];
+      const rail = index === total - 1 ? "\u2514  " : "\u2502  ";
+      const isDim = hiddenCount > 0 && index === 0;
+      lines.push(
+        entry.kind === "thinking" ? this.thinkingRow(rail, entry, width, true, isDim) : this.toolRow(rail, entry.tool, frame, width, isDim)
+      );
+    }
+    return lines;
+  }
+  // Expanded: per-tool detail + every thinking run, in stream order.
+  // When there is only 1 visible entry, do not show hierarchy (no header, no tree rail).
+  renderExpanded(width, visible) {
+    const theme = runtime.currentTheme;
+    const fg = (color, text) => theme?.fg?.(color, text) ?? text;
+    const frame = SPINNER[Math.floor((Date.now() - spinnerStart) / SPINNER_MS) % SPINNER.length];
+    const lines = [];
+    if (visible.length === 1) {
+      const entry = visible[0];
+      const sub = "  ";
+      if (entry.kind === "tool") {
+        const tool = entry.tool;
+        lines.push(this.toolRow("", tool, frame, width));
+        const result = toolResultText(tool);
+        if (result) {
+          const markdownWidth = Math.max(1, width - sub.length);
+          const preview = this.renderMarkdownPreview(
+            `tool:${tool.toolCallId ?? 0}`,
+            result,
+            markdownWidth,
+            config.expandedToolLines,
+            { color: (text) => runtime.currentTheme?.fg?.("toolOutput", text) ?? text }
+          );
+          for (const row of preview.lines) {
+            lines.push(`${fg("dim", sub)}${row}`);
+          }
+          if (preview.truncated) {
+            lines.push(`${fg("dim", sub)}${fg("muted", "...")}`);
+          }
+        }
+        return lines;
+      }
+      lines.push(this.thinkingRow("", entry, width, false));
+      const tText = entry.text.trim();
+      if (tText) {
+        const markdownWidth = Math.max(1, width - sub.length);
+        const preview = this.renderMarkdownPreview(
+          `thinking:${entry.id}`,
+          tText,
+          markdownWidth,
+          config.expandedThinkingLines,
+          { color: (text) => runtime.currentTheme?.fg?.("thinkingText", text) ?? text, italic: true }
+        );
+        for (const row of preview.lines) {
+          lines.push(`${fg("dim", sub)}${row}`);
+        }
+        if (preview.truncated) {
+          lines.push(`${fg("dim", sub)}${fg("muted", "...")}`);
+        }
+      }
+      return lines;
+    }
+    const hasPendingTool = visible.some((e) => e.kind === "tool" && toolStatus(e.tool) === "pending");
+    const isThinking = !this.sealed && visible.some((e) => e.kind === "thinking" && e.active);
+    const hasTools = visible.some((e) => e.kind === "tool");
+    const hasThinking = visible.some((e) => e.kind === "thinking");
+    const openNoTools = !this.sealed && !hasTools;
+    const working = hasPendingTool || isThinking || openNoTools;
+    const state = hasPendingTool ? "tool calling..." : !hasTools ? working ? "thinking..." : "thinking" : isThinking ? "thinking..." : hasThinking ? "tools and thinking done" : "tools done";
+    const stateColor = hasPendingTool ? "accent" : hasTools && !isThinking ? "success" : "thinkingText";
+    const thinkingSpin = !hasPendingTool && working ? thinkingSpinnerFrame() : void 0;
+    const leftIcon = working ? thinkingSpin?.frame ?? frame : "\u2713";
+    const leftColor = thinkingSpin?.color ?? stateColor;
+    lines.push(`${fg(leftColor, leftIcon)} ${fg(stateColor, state)}`);
+    const total = visible.length;
+    for (let index = 0; index < total; index++) {
+      const entry = visible[index];
+      const isLast = index === total - 1;
+      const rail = isLast ? "\u2514\u2500 " : "\u251C\u2500 ";
+      const sub = isLast ? "    " : "\u2502   ";
+      if (entry.kind === "tool") {
+        const tool = entry.tool;
+        lines.push(this.toolRow(rail, tool, frame, width));
+        const result = toolResultText(tool);
+        if (result) {
+          const markdownWidth = Math.max(1, width - sub.length);
+          const preview = this.renderMarkdownPreview(
+            `tool:${tool.toolCallId ?? index}`,
+            result,
+            markdownWidth,
+            config.expandedToolLines,
+            { color: (text) => runtime.currentTheme?.fg?.("toolOutput", text) ?? text }
+          );
+          for (const row of preview.lines) {
+            lines.push(`${fg("dim", sub)}${row}`);
+          }
+          if (preview.truncated) {
+            lines.push(`${fg("dim", sub)}${fg("muted", "...")}`);
+          }
+        }
+        continue;
+      }
+      lines.push(this.thinkingRow(rail, entry, width, false));
+      const tText = entry.text.trim();
+      if (tText) {
+        const markdownWidth = Math.max(1, width - sub.length);
+        const preview = this.renderMarkdownPreview(
+          `thinking:${entry.id}`,
+          tText,
+          markdownWidth,
+          config.expandedThinkingLines,
+          { color: (text) => runtime.currentTheme?.fg?.("thinkingText", text) ?? text, italic: true }
+        );
+        for (const row of preview.lines) {
+          lines.push(`${fg("dim", sub)}${row}`);
+        }
+        if (preview.truncated) {
+          lines.push(`${fg("dim", sub)}${fg("muted", "...")}`);
+        }
+      }
+    }
+    return lines;
+  }
+  render(width) {
+    const visible = this.getVisibleEntries();
+    if (visible.length === 0) return [];
+    if (this.needsAnimation()) scheduleAnimation();
+    const padding = " ".repeat(Math.min(GROUP_PADDING_X, Math.max(0, width - 1)));
+    const contentWidth = Math.max(1, width - padding.length - GROUP_PADDING_RIGHT);
+    const lines = this._expanded ? this.renderExpanded(contentWidth, visible) : this.renderCollapsed(contentWidth, visible);
+    if (lines.length === 0) return [];
+    const rendered = lines.map((line) => padding + truncateToWidth3(line, contentWidth, "..."));
+    return this.anchored ? rendered : ["", ...rendered];
+  }
+};
+
+// src/guards.ts
+function isContainer(val) {
+  return Boolean(
+    val && (val instanceof Container2 || val.constructor?.name === "Container" || Array.isArray(val.children) && typeof val.addChild === "function")
+  );
+}
+function isAssistantMessage(val) {
+  return Boolean(
+    val && (val instanceof AssistantMessageComponent2 || val.constructor?.name === "AssistantMessageComponent")
+  );
+}
+function isToolExecution(val) {
+  return Boolean(
+    val && (val instanceof ToolExecutionComponent || val.constructor?.name === "ToolExecutionComponent")
+  );
+}
+function isSpacer(val) {
+  return Boolean(val && (val instanceof Spacer2 || val.constructor?.name === "Spacer"));
+}
+function isMarkdown(val) {
+  return Boolean(val && (val instanceof Markdown2 || val.constructor?.name === "Markdown"));
+}
+function isText(val) {
+  return Boolean(val && (val instanceof Text || val.constructor?.name === "Text"));
+}
+function isToolGroup(val) {
+  return Boolean(val && (val instanceof ToolGroupComponent || val.constructor?.name === "ToolGroupComponent"));
+}
+function hideGroupedToolRender(tool) {
+  const prototype = tool ? Object.getPrototypeOf(tool) : void 0;
+  if (!prototype || typeof prototype.render !== "function" || prototype[TOOL_RENDER_PATCH_KEY]) return;
+  const original = prototype.render;
+  const installed = function(width) {
+    if (this?.[PARENT_KEY]) return [];
+    return original.call(this, width);
+  };
+  prototype.render = installed;
+  prototype[TOOL_RENDER_PATCH_KEY] = { original, installed };
+}
+
+// src/thinking.ts
+function updateActiveThinkingTokens(message) {
+  const entry = runtime.activeThinking;
+  if (!entry) return;
+  entry.text = [...runtime.activeThinkingBlocks.values()].filter((text) => text.trim()).join("\n\n");
+  const reported = Number(message?.usage?.reasoning);
+  if (Number.isFinite(reported) && reported > 0) {
+    entry.tokens = reported;
+    entry.tokensExact = true;
+    runtime.lastReportedReasoningTokens = reported;
+    return;
+  }
+  entry.tokens = estimateTextTokens(entry.text);
+  entry.tokensExact = false;
+}
+function createThinkingEntry() {
+  const entry = {
+    kind: "thinking",
+    id: runtime.thinkingEntrySeq++,
+    text: "",
+    tokens: 0,
+    tokensExact: false,
+    active: true,
+    owner: null
+  };
+  runtime.activeThinking = entry;
+  runtime.activeThinkingBlocks.clear();
+  runtime.unattachedThinking.push(entry);
+  return entry;
+}
+function finalizeActiveThinking() {
+  const entry = runtime.activeThinking;
+  if (!entry) return;
+  entry.active = false;
+  entry.owner?.invalidate();
+  if (runtime.activeThinkingIndex !== null) runtime.sealedThinkingIndexes.add(runtime.activeThinkingIndex);
+  runtime.lastSealedThinkingEntry = entry;
+  runtime.activeThinking = null;
+  runtime.activeThinkingIndex = null;
+  runtime.activeThinkingBlocks.clear();
+}
+function refreshSealedThinkingTokens(reportedReasoning) {
+  const reported = Number(reportedReasoning);
+  if (Number.isFinite(reported) && reported > 0) runtime.lastReportedReasoningTokens = reported;
+  const entry = runtime.lastSealedThinkingEntry;
+  if (!entry || entry.tokensExact) return;
+  if (!entry.text.trim()) return;
+  if (!(runtime.lastReportedReasoningTokens > 0)) return;
+  entry.tokens = runtime.lastReportedReasoningTokens;
+  entry.tokensExact = true;
+  entry.owner?.invalidate();
+  runtime.capturedTui?.requestRender?.();
+}
+
+// src/grouping.ts
+import { Container as Container3 } from "@earendil-works/pi-tui";
+import { AssistantMessageComponent as AssistantMessageComponent3 } from "@earendil-works/pi-coding-agent";
+function isGroupable(value) {
+  return isToolExecution(value);
+}
+function previousGroupable(children, start) {
+  for (let i = start; i >= 0; i--) {
+    const child = children[i];
+    if (isSpacer(child)) continue;
+    if (isAssistantMessage(child)) continue;
+    if (isToolGroup(child) && child.sealed) continue;
+    if (isToolGroup(child) || isGroupable(child)) return { child, index: i };
+  }
+  return void 0;
+}
+function assistantHasVisibleText(component) {
+  const content = component?.lastMessage?.content;
+  if (!Array.isArray(content)) return false;
+  return content.some((item) => item?.type === "text" && String(item.text ?? "").trim());
+}
+function absorbThinkingBeforeText(group, message) {
+  const content = message?.content;
+  if (!Array.isArray(content)) return;
+  for (const item of content) {
+    if (item?.type === "text" && String(item.text ?? "").trim()) break;
+    if (item?.type !== "thinking") continue;
+    const text = String(item.thinking ?? "").trim();
+    if (!text || thinkingAlreadyShown(text)) continue;
+    group.entries.push({
+      kind: "thinking",
+      id: runtime.thinkingEntrySeq++,
+      text,
+      tokens: estimateTextTokens(text),
+      tokensExact: false,
+      active: false,
+      owner: group
+    });
+  }
+}
+function sealOpenGroupAtAssistantText(assistant) {
+  const open = findOpenGroup();
+  if (!open) return;
+  absorbThinkingBeforeText(open, assistant.lastMessage);
+  open.sealed = true;
+  finalizeActiveThinking();
+  const contentContainer = assistant.contentContainer;
+  if (isContainer(contentContainer) && contentContainer.children.some(isVisibleTextMarkdown)) {
+    const previous = runtime.lastStreamingComp;
+    runtime.lastStreamingComp = assistant;
+    anchorGroupBeforeCurrentText(open, 0);
+    runtime.lastStreamingComp = previous ?? assistant;
+  }
+  open.invalidate();
+}
+function ensureThinkingGroup() {
+  if (runtime.unattachedThinking.length === 0) return;
+  let group = findOpenGroup();
+  if (group && runtime.lastChatContainer && runtime.lastStreamingComp) {
+    placeGroupAfter(runtime.lastChatContainer, runtime.lastStreamingComp, group);
+  }
+  if (!group) {
+    if (!runtime.lastChatContainer || !runtime.lastStreamingComp) return;
+    const parent = runtime.lastChatContainer;
+    const children = parent.children;
+    if (!Array.isArray(children)) return;
+    const idx = children.indexOf(runtime.lastStreamingComp);
+    group = new ToolGroupComponent();
+    detachGroup(group);
+    children.splice(idx >= 0 ? idx + 1 : children.length, 0, group);
+    noteGroupMount(parent, group);
+    runtime.groups.add(group);
+    runtime.lastActiveGroup = group;
+    parent.invalidate?.();
+  }
+  while (runtime.unattachedThinking.length > 0) group.addThinking(runtime.unattachedThinking.shift());
+  group.invalidate();
+  runtime.capturedTui?.requestRender?.();
+}
+function flushPendingTextSeal() {
+  if (!runtime.pendingTextSeal) return;
+  if (runtime.activeThinking || runtime.unattachedThinking.length > 0) ensureThinkingGroup();
+  if (runtime.lastActiveGroup && !runtime.lastActiveGroup.sealed) {
+    if (runtime.lastActiveGroup.hasVisibleEntries()) {
+      if (runtime.pendingTextOrdinal !== null) {
+        anchorGroupBeforeCurrentText(runtime.lastActiveGroup, runtime.pendingTextOrdinal);
+      }
+    } else {
+      if (runtime.lastChatContainer) removeGroupFromContainer(runtime.lastChatContainer, runtime.lastActiveGroup);
+      runtime.groups.delete(runtime.lastActiveGroup);
+    }
+    runtime.lastActiveGroup.sealed = true;
+    finalizeActiveThinking();
+    runtime.lastActiveGroup.invalidate();
+    runtime.pendingTextSeal = false;
+    runtime.pendingTextOrdinal = null;
+    return;
+  }
+  runtime.pendingTextSeal = false;
+  runtime.pendingTextOrdinal = null;
+}
+function getPrecedingAssistantThinking(children, beforeIndex) {
+  for (let i = beforeIndex; i >= 0; i--) {
+    const child = children[i];
+    if (isSpacer(child)) continue;
+    if (isAssistantMessage(child)) {
+      const content = child.lastMessage?.content;
+      if (!Array.isArray(content)) return [];
+      const texts = [];
+      for (const item of content) {
+        if (item?.type === "thinking") {
+          const t = String(item.thinking ?? "").trim();
+          if (t && !thinkingAlreadyShown(t)) texts.push(t);
+        }
+      }
+      return texts;
+    }
+    break;
+  }
+  return [];
+}
+function attachPrecedingThinkingToGroup(group, children, beforeIndex) {
+  const texts = getPrecedingAssistantThinking(children, beforeIndex);
+  if (texts.length === 0) return;
+  for (const text of texts) {
+    if (thinkingAlreadyShown(text)) continue;
+    const entry = {
+      kind: "thinking",
+      id: runtime.thinkingEntrySeq++,
+      text,
+      tokens: estimateTextTokens(text),
+      tokensExact: false,
+      active: false,
+      owner: group
+    };
+    group.entries.push(entry);
+  }
+}
+function joinOpenGroup(parent, index, component) {
+  if (!runtime.lastChatContainer || parent !== runtime.lastChatContainer) return false;
+  const open = findOpenGroup();
+  if (!open) return false;
+  const children = parent.children;
+  children.splice(index, 1);
+  if (runtime.lastStreamingComp && children.includes(runtime.lastStreamingComp)) {
+    placeGroupAfter(parent, runtime.lastStreamingComp, open);
+  } else if (!children.includes(open)) {
+    children.push(open);
+    noteGroupMount(parent, open);
+  }
+  attachPrecedingThinkingToGroup(open, children, children.indexOf(open) - 1);
+  open.addTool(component);
+  runtime.lastActiveGroup = open;
+  open.invalidate();
+  return true;
+}
+function maybeGroup(parent, component) {
+  if (!isGroupable(component) || isToolGroup(parent)) return;
+  const children = parent?.children;
+  if (!Array.isArray(children)) return;
+  const index = children.indexOf(component);
+  if (index < 0) return;
+  if (joinOpenGroup(parent, index, component)) return;
+  const prior = previousGroupable(children, index - 1);
+  if (isToolGroup(prior?.child) && !prior.child.sealed) {
+    attachPrecedingThinkingToGroup(prior.child, children, index - 1);
+    children.splice(index, 1);
+    prior.child.addTool(component);
+    runtime.lastActiveGroup = prior.child;
+    return;
+  }
+  if (prior && isGroupable(prior.child)) {
+    const group2 = new ToolGroupComponent();
+    attachPrecedingThinkingToGroup(group2, children, prior.index - 1);
+    group2.addTool(prior.child);
+    attachPrecedingThinkingToGroup(group2, children, index - 1);
+    group2.addTool(component);
+    parent.children[prior.index] = group2;
+    children.splice(index, 1);
+    noteGroupMount(parent, group2);
+    runtime.groups.add(group2);
+    runtime.lastActiveGroup = group2;
+    return;
+  }
+  const group = new ToolGroupComponent();
+  attachPrecedingThinkingToGroup(group, children, index - 1);
+  group.addTool(component);
+  parent.children[index] = group;
+  noteGroupMount(parent, group);
+  runtime.groups.add(group);
+  runtime.lastActiveGroup = group;
+}
+function installGrouping() {
+  const host = globalThis;
+  const prototypes = [Container3.prototype];
+  const agentContainerProto = Object.getPrototypeOf(AssistantMessageComponent3.prototype);
+  if (agentContainerProto && agentContainerProto !== Object.prototype && !prototypes.includes(agentContainerProto)) {
+    prototypes.push(agentContainerProto);
+  }
+  const patchKey = PATCH_KEY;
+  const previous = host[patchKey];
+  const stateMap = /* @__PURE__ */ new Map();
+  for (const prototype of prototypes) {
+    const prev = previous instanceof Map ? previous.get(prototype) : previous;
+    const original = {
+      addChild: prev && prototype.addChild === prev.installed.addChild ? prev.original.addChild : prototype.addChild,
+      removeChild: prev && prototype.removeChild === prev.installed.removeChild ? prev.original.removeChild : prototype.removeChild,
+      clear: prev && prototype.clear === prev.installed.clear ? prev.original.clear : prototype.clear
+    };
+    const state = {
+      active: true,
+      prototype,
+      original,
+      installed: void 0
+    };
+    state.installed = {
+      addChild: function(component) {
+        const result = state.original.addChild.call(this, component);
+        if (component && typeof component === "object") {
+          if (isAssistantMessage(component)) {
+            const assistant = component;
+            ensureAssistantThinkingPatched(assistant);
+            const streaming = assistant.isStreaming === true;
+            if (streaming) {
+              assistant[LIVE_ASSISTANT_KEY] = true;
+            }
+            runtime.lastChatContainer = this;
+            runtime.lastStreamingComp = assistant;
+            assistant[IS_STREAMING_COMP] = streaming;
+            if (assistantHasVisibleText(assistant)) {
+              sealOpenGroupAtAssistantText(assistant);
+            } else {
+              const open = findOpenGroup();
+              if (open) placeGroupAfter(this, assistant, open);
+            }
+            if (runtime.unattachedThinking.length > 0) ensureThinkingGroup();
+            flushPendingTextSeal();
+          }
+          maybeGroup(this, component);
+          stripAssistantPhantomPadding(this, component);
+          restoreAssistantAnchor(this, component);
+        }
+        return result;
+      },
+      removeChild: function(component) {
+        const group = component?.[PARENT_KEY];
+        if (isToolGroup(group) && group[PARENT_KEY] === this) {
+          group.removeTool(component);
+          if (group.children.length === 0 && group.entries.length === 0) runtime.groups.delete(group);
+          return;
+        }
+        releaseAssistantAnchors(component);
+        return state.original.removeChild.call(this, component);
+      },
+      clear: function() {
+        if (runtime.assistantContentContainers.has(this)) {
+          getAssistantContentState(this).nextTextOrdinal = 0;
+          return state.original.clear.call(this);
+        }
+        for (const child of [...this.children ?? []]) {
+          if (isToolGroup(child)) {
+            for (const tool of [...child.children]) delete tool[PARENT_KEY];
+            runtime.groups.delete(child);
+          }
+          releaseAssistantAnchors(child);
+        }
+        return state.original.clear.call(this);
+      }
+    };
+    prototype.addChild = state.installed.addChild;
+    prototype.removeChild = state.installed.removeChild;
+    prototype.clear = state.installed.clear;
+    stateMap.set(prototype, state);
+  }
+  host[patchKey] = stateMap;
+}
+
+// src/compaction.ts
+import { visibleWidth as visibleWidth3, truncateToWidth as truncateToWidth4 } from "@earendil-works/pi-tui";
+import { CompactionSummaryMessageComponent } from "@earendil-works/pi-coding-agent";
+var CompactionHeaderComponent = class {
+  constructor(tokensBefore) {
+    this.tokensBefore = tokensBefore;
+  }
+  tokensBefore;
+  render(width) {
+    const theme = runtime.currentTheme;
+    const fg = (color, text) => theme?.fg?.(color, text) ?? text;
+    const exactTokens = Math.max(0, this.tokensBefore).toLocaleString();
+    const icon = fg("success", "\u203A\u2039");
+    const title = fg("success", "Context compacted");
+    const detail = fg("muted", ` \u2022 ${exactTokens} tokens \u2192 summary`);
+    const full = `${icon} ${title}${detail}`;
+    if (visibleWidth3(full) <= width) return [full];
+    const compactTitle = fg("success", "Compacted");
+    const compactDetail = fg("muted", ` \u2022 ${formatTokenK(this.tokensBefore)} tok`);
+    return [truncateToWidth4(`${icon} ${compactTitle}${compactDetail}`, Math.max(1, width), "...")];
+  }
+  invalidate() {
+  }
+};
+function installCompactionSummaryRendering() {
+  const prototype = CompactionSummaryMessageComponent.prototype;
+  const previous = prototype[COMPACTION_STYLE_PATCH_KEY];
+  const previousInstalledUpdate = previous?.installedUpdateDisplay ?? previous?.installed;
+  const originalUpdateDisplay = previous && previousInstalledUpdate && prototype.updateDisplay === previousInstalledUpdate ? previous.originalUpdateDisplay ?? previous.original : prototype.updateDisplay;
+  const originalSetExpanded = previous?.installedSetExpanded && prototype.setExpanded === previous.installedSetExpanded ? previous.originalSetExpanded : prototype.setExpanded;
+  const installedUpdateDisplay = function() {
+    this.paddingX = GROUP_PADDING_X;
+    this.paddingY = 0;
+    this.setBgFn(void 0);
+    this.clear();
+    const tokensBefore = Number(this.message?.tokensBefore);
+    const safeTokens = Number.isFinite(tokensBefore) && tokensBefore > 0 ? tokensBefore : 0;
+    this.addChild(new CompactionHeaderComponent(safeTokens));
+  };
+  const installedSetExpanded = function(_expanded) {
+  };
+  prototype.updateDisplay = installedUpdateDisplay;
+  prototype.setExpanded = installedSetExpanded;
+  prototype[COMPACTION_STYLE_PATCH_KEY] = {
+    originalUpdateDisplay,
+    originalSetExpanded,
+    installedUpdateDisplay,
+    installedSetExpanded
+  };
+}
+
+// src/modals.ts
+import { matchesKey as matchesKey2, Key, wrapTextWithAnsi as wrapTextWithAnsi2, visibleWidth as visibleWidth4, truncateToWidth as truncateToWidth5 } from "@earendil-works/pi-tui";
+var DetailModalComponent = class {
+  entry;
+  scrollTop = 0;
+  followingEnd = true;
+  lastContentLineCount = 0;
+  lastInnerHeight = 10;
+  pollTimer = null;
+  constructor(entry) {
+    this.entry = entry;
+    this.startPollingIfNeeded();
+  }
+  isEntryActive() {
+    if (this.entry.kind === "thinking") {
+      return this.entry.active;
+    }
+    return toolStatus(this.entry.tool) === "pending";
+  }
+  startPollingIfNeeded() {
+    if (this.isEntryActive()) {
+      const interval = this.entry.kind === "thinking" ? THINKING_SPINNER.intervalMs : SPINNER_MS;
+      this.pollTimer = setInterval(() => {
+        runtime.capturedTui?.requestRender?.();
+        if (!this.isEntryActive() && this.pollTimer) {
+          clearInterval(this.pollTimer);
+          this.pollTimer = null;
+        }
+      }, interval);
+    }
+  }
+  dispose() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  invalidate() {
+  }
+  scrollBy(delta) {
+    this.scrollTo(this.scrollTop + delta);
+  }
+  scrollTo(newTop) {
+    const maxScroll = Math.max(0, this.lastContentLineCount - this.lastInnerHeight);
+    this.scrollTop = Math.max(0, Math.min(maxScroll, newTop));
+    if (this.scrollTop >= maxScroll) {
+      this.followingEnd = true;
+    } else {
+      this.followingEnd = false;
+    }
+    runtime.capturedTui?.requestRender?.();
+  }
+  scrollToEnd() {
+    this.followingEnd = true;
+    this.scrollTop = Math.max(0, this.lastContentLineCount - this.lastInnerHeight);
+    runtime.capturedTui?.requestRender?.();
+  }
+  handleInput(data) {
+    if (matchesKey2(data, Key.escape) || data === "q" || data === "Q") {
+      closeDetailModal();
+      return true;
+    }
+    if (matchesKey2(data, Key.up) || data === "k" || data === "K") {
+      this.scrollBy(-1);
+      return true;
+    }
+    if (matchesKey2(data, Key.down) || data === "j" || data === "J") {
+      this.scrollBy(1);
+      return true;
+    }
+    if (matchesKey2(data, Key.pageUp) || matchesKey2(data, Key.left)) {
+      this.scrollBy(-10);
+      return true;
+    }
+    if (matchesKey2(data, Key.pageDown) || matchesKey2(data, Key.right) || matchesKey2(data, Key.space)) {
+      this.scrollBy(10);
+      return true;
+    }
+    if (matchesKey2(data, Key.home)) {
+      this.scrollTo(0);
+      return true;
+    }
+    if (matchesKey2(data, Key.end)) {
+      this.scrollToEnd();
+      return true;
+    }
+    return false;
+  }
+  render(width) {
+    const theme = runtime.currentTheme;
+    const fg = (color, t) => theme?.fg?.(color, t) ?? t;
+    const bold = theme?.bold ? theme.bold : (t) => t;
+    const borderFg = (t) => fg("borderAccent", fg("border", t));
+    const frame = SPINNER[Math.floor((Date.now() - spinnerStart) / SPINNER_MS) % SPINNER.length];
+    const termHeight = runtime.capturedTui?.terminal?.rows ?? process.stdout?.rows ?? 24;
+    const maxInnerHeight = Math.max(5, Math.floor(termHeight * 0.8) - 2);
+    const innerWidth = Math.max(10, width - 4);
+    let title = "";
+    const contentLines = [];
+    if (this.entry.kind === "thinking") {
+      const spin = this.entry.active ? thinkingSpinnerFrame() : void 0;
+      const icon = spin?.frame ?? "\u2713";
+      const tokenStr = thinkingTokenLabel(this.entry);
+      title = `${fg(spin?.color ?? "thinkingText", icon)} ${fg("toolTitle", "Thinking")} ${fg("muted", tokenStr)}`;
+      const rawText = this.entry.text.trim();
+      if (!rawText) {
+        contentLines.push(fg("dim", "(thinking...)"));
+      } else {
+        for (const rawLine of rawText.split("\n")) {
+          const wrapped = wrapTextWithAnsi2(rawLine, innerWidth);
+          if (wrapped.length === 0) {
+            contentLines.push("");
+          } else {
+            for (const wl of wrapped) {
+              contentLines.push(fg("thinkingText", wl));
+            }
+          }
+        }
+      }
+    } else {
+      const tool = this.entry.tool;
+      const st = toolStatus(tool);
+      const icon = st === "pending" ? frame : st === "error" ? "\u2717" : "\u2713";
+      const color = st === "pending" ? "accent" : st === "error" ? "error" : "success";
+      const elapsed = `(${toolElapsed(tool)}s)`;
+      title = `${fg(color, icon)} ${fg("toolTitle", bold(tool.toolName))} ${fg("muted", elapsed)}`;
+      if (tool.toolName === "bash" || tool.toolName === "powershell") {
+        const cmd = tool.args?.command || "...";
+        for (const wl of wrapTextWithAnsi2(`$ ${cmd}`, innerWidth)) {
+          contentLines.push(fg("accent", wl));
+        }
+      } else if (tool.args?.path) {
+        contentLines.push(`${fg("dim", "Path:")} ${tool.args.path}`);
+      } else if (tool.args) {
+        try {
+          const jsonStr = JSON.stringify(tool.args, null, 2);
+          for (const l of jsonStr.split("\n")) {
+            for (const wl of wrapTextWithAnsi2(l, innerWidth)) {
+              contentLines.push(fg("dim", wl));
+            }
+          }
+        } catch {
+          contentLines.push(fg("dim", String(tool.args)));
+        }
+      }
+      const resultText = toolResultText(tool);
+      contentLines.push("");
+      contentLines.push(fg("dim", "\u2500\u2500 Output \u2500\u2500"));
+      if (resultText) {
+        for (const rawLine of resultText.split("\n")) {
+          const wrapped = wrapTextWithAnsi2(rawLine, innerWidth);
+          if (wrapped.length === 0) {
+            contentLines.push("");
+          } else {
+            for (const wl of wrapped) {
+              contentLines.push(fg("toolOutput", wl));
+            }
+          }
+        }
+      } else {
+        contentLines.push(fg("dim", st === "pending" ? "(running, waiting for output...)" : "(no output)"));
+      }
+    }
+    const totalLines = contentLines.length;
+    const innerHeight = Math.min(Math.max(totalLines, 5), maxInnerHeight);
+    this.lastContentLineCount = totalLines;
+    this.lastInnerHeight = innerHeight;
+    const maxScroll = Math.max(0, totalLines - innerHeight);
+    if (this.followingEnd) {
+      this.scrollTop = maxScroll;
+    } else {
+      this.scrollTop = Math.max(0, Math.min(maxScroll, this.scrollTop));
+    }
+    const closeHint = "[Esc to close]";
+    const visClose = visibleWidth4(closeHint);
+    const maxTitleWidth = Math.max(10, width - visClose - 12);
+    const clampedTitle = truncateToWidth5(title, maxTitleWidth, "...");
+    const visTitle = visibleWidth4(clampedTitle);
+    const fillerLen = Math.max(1, width - visTitle - visClose - 8);
+    const topBorder = borderFg("\u250C\u2500 ") + clampedTitle + borderFg(" " + "\u2500".repeat(fillerLen) + " ") + fg("muted", closeHint) + borderFg(" \u2500\u2510");
+    const result = [truncateToWidth5(topBorder, width)];
+    const slice = contentLines.slice(this.scrollTop, this.scrollTop + innerHeight);
+    while (slice.length < innerHeight) {
+      slice.push("");
+    }
+    const showScrollbar = totalLines > innerHeight;
+    const thumbY = showScrollbar && maxScroll > 0 ? Math.round(this.scrollTop / maxScroll * (innerHeight - 1)) : -1;
+    for (let i = 0; i < innerHeight; i++) {
+      const line = slice[i] ?? "";
+      const vis = visibleWidth4(line);
+      const truncated = vis > innerWidth ? truncateToWidth5(line, innerWidth, "...") : line;
+      const truncVis = visibleWidth4(truncated);
+      const pad = Math.max(0, innerWidth - truncVis);
+      const rightChar = showScrollbar && i === thumbY ? fg("scrollbarThumb", "\u2588") : borderFg("\u2502");
+      result.push(borderFg("\u2502 ") + truncated + " ".repeat(pad) + " " + rightChar);
+    }
+    const scrollInfo = totalLines > innerHeight ? ` [${this.scrollTop + 1}-${Math.min(totalLines, this.scrollTop + innerHeight)}/${totalLines}] ` : "";
+    const visInfo = visibleWidth4(scrollInfo);
+    const botFiller = Math.max(1, width - 2 - visInfo);
+    const botBorder = borderFg("\u2514" + "\u2500".repeat(botFiller)) + (scrollInfo ? fg("dim", scrollInfo) : "") + borderFg("\u2518");
+    result.push(truncateToWidth5(botBorder, width));
+    return result;
+  }
+};
+function openDetailModal(entry) {
+  closeDetailModal();
+  const modal = new DetailModalComponent(entry);
+  runtime.activeModalComponent = modal;
+  if (runtime.capturedTui) {
+    runtime.activeModalHandle = runtime.capturedTui.showOverlay(modal, {
+      anchor: "center",
+      width: "85%",
+      maxHeight: "80%"
+    });
+    runtime.capturedTui.requestRender();
+    return;
+  }
+  if (runtime.activeUIContext?.custom) {
+    runtime.activeUIContext.custom(
+      (tui, _theme, _keybindings, done) => {
+        runtime.capturedTui = tui;
+        runtime.activeModalCloseFn = done;
+        return modal;
+      },
+      {
+        overlay: true,
+        overlayOptions: { anchor: "center", width: "85%", maxHeight: "80%" },
+        onHandle: (handle) => {
+          runtime.activeModalHandle = handle;
+        }
+      }
+    );
+  }
+}
+function closeDetailModal() {
+  if (runtime.activeModalComponent) {
+    runtime.activeModalComponent.dispose();
+    runtime.activeModalComponent = null;
+  }
+  if (runtime.activeModalHandle) {
+    const handle = runtime.activeModalHandle;
+    runtime.activeModalHandle = null;
+    handle.hide();
+  }
+  if (runtime.activeModalCloseFn) {
+    const done = runtime.activeModalCloseFn;
+    runtime.activeModalCloseFn = null;
+    done();
+  }
+  runtime.capturedTui?.requestRender?.();
+}
+function getAllInspectableEntries() {
+  const results = [];
+  for (const g of runtime.groups) {
+    for (const entry of g.getVisibleEntries()) {
+      results.push(entry);
+    }
+  }
+  return results;
+}
+var InspectSelectorModal = class {
+  entries = [];
+  selectedIndex = 0;
+  scrollTop = 0;
+  visibleHeight = 10;
+  constructor() {
+    this.refreshEntries(true);
+  }
+  refreshEntries(isInitial = false) {
+    const wasAtEnd = isInitial || this.selectedIndex >= this.entries.length - 1;
+    this.entries = getAllInspectableEntries();
+    if (this.entries.length === 0) {
+      this.selectedIndex = 0;
+      this.scrollTop = 0;
+      return;
+    }
+    if (wasAtEnd) {
+      this.selectedIndex = this.entries.length - 1;
+    } else {
+      this.selectedIndex = Math.max(0, Math.min(this.selectedIndex, this.entries.length - 1));
+    }
+    this.adjustScroll();
+  }
+  adjustScroll() {
+    if (this.entries.length === 0) {
+      this.scrollTop = 0;
+      return;
+    }
+    if (this.selectedIndex < this.scrollTop) {
+      this.scrollTop = this.selectedIndex;
+    } else if (this.selectedIndex >= this.scrollTop + this.visibleHeight) {
+      this.scrollTop = this.selectedIndex - this.visibleHeight + 1;
+    }
+    const maxScroll = Math.max(0, this.entries.length - this.visibleHeight);
+    this.scrollTop = Math.max(0, Math.min(this.scrollTop, maxScroll));
+  }
+  handleInput(data) {
+    if (matchesKey2(data, Key.escape) || data === "q" || data === "Q") {
+      closeInspectSelectorModal();
+      return true;
+    }
+    if (matchesKey2(data, Key.enter) || data === "\r" || data === "\n") {
+      const selected = this.entries[this.selectedIndex];
+      if (selected) {
+        openDetailModal(selected);
+      }
+      return true;
+    }
+    if (matchesKey2(data, Key.up) || data === "k" || data === "K") {
+      if (this.entries.length > 0) {
+        this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+        this.adjustScroll();
+        runtime.capturedTui?.requestRender?.();
+      }
+      return true;
+    }
+    if (matchesKey2(data, Key.down) || data === "j" || data === "J") {
+      if (this.entries.length > 0) {
+        this.selectedIndex = Math.min(this.entries.length - 1, this.selectedIndex + 1);
+        this.adjustScroll();
+        runtime.capturedTui?.requestRender?.();
+      }
+      return true;
+    }
+    if (matchesKey2(data, Key.pageUp)) {
+      if (this.entries.length > 0) {
+        this.selectedIndex = Math.max(0, this.selectedIndex - this.visibleHeight);
+        this.adjustScroll();
+        runtime.capturedTui?.requestRender?.();
+      }
+      return true;
+    }
+    if (matchesKey2(data, Key.pageDown)) {
+      if (this.entries.length > 0) {
+        this.selectedIndex = Math.min(this.entries.length - 1, this.selectedIndex + this.visibleHeight);
+        this.adjustScroll();
+        runtime.capturedTui?.requestRender?.();
+      }
+      return true;
+    }
+    if (matchesKey2(data, Key.home)) {
+      if (this.entries.length > 0) {
+        this.selectedIndex = 0;
+        this.adjustScroll();
+        runtime.capturedTui?.requestRender?.();
+      }
+      return true;
+    }
+    if (matchesKey2(data, Key.end)) {
+      if (this.entries.length > 0) {
+        this.selectedIndex = this.entries.length - 1;
+        this.adjustScroll();
+        runtime.capturedTui?.requestRender?.();
+      }
+      return true;
+    }
+    return false;
+  }
+  render(width) {
+    const theme = runtime.currentTheme;
+    const fg = (color, t) => theme?.fg?.(color, t) ?? t;
+    const bold = theme?.bold ? theme.bold : (t) => t;
+    const borderFg = (t) => fg("borderAccent", fg("border", t));
+    const frame = SPINNER[Math.floor((Date.now() - spinnerStart) / SPINNER_MS) % SPINNER.length];
+    const termHeight = runtime.capturedTui?.terminal?.rows ?? process.stdout?.rows ?? 24;
+    const maxInnerHeight = Math.max(5, Math.floor(termHeight * 0.7) - 2);
+    const innerHeight = this.entries.length === 0 ? 5 : Math.min(this.entries.length, maxInnerHeight);
+    this.visibleHeight = innerHeight;
+    this.adjustScroll();
+    const innerWidth = Math.max(10, width - 4);
+    const lines = [];
+    const title = ` ${fg("accent", bold("Inspect"))} ${fg("dim", "(\u2191/\u2193 select \xB7 Enter view \xB7 Esc exit)")} `;
+    const visTitle = visibleWidth4(title);
+    const topFiller = Math.max(1, width - 2 - visTitle);
+    const topBorder = borderFg("\u250C" + "\u2500".repeat(topFiller)) + title + borderFg("\u2510");
+    lines.push(truncateToWidth5(topBorder, width));
+    if (this.entries.length === 0) {
+      const emptyMsg = "  (no tool calls or thinking entries)";
+      for (let i = 0; i < innerHeight; i++) {
+        const row = i === Math.floor(innerHeight / 2) ? fg("dim", emptyMsg) : "";
+        const pad = Math.max(0, innerWidth - visibleWidth4(row));
+        lines.push(borderFg("\u2502 ") + row + " ".repeat(pad) + borderFg(" \u2502"));
+      }
+    } else {
+      for (let i = 0; i < innerHeight; i++) {
+        const entryIdx = this.scrollTop + i;
+        const entry = this.entries[entryIdx];
+        if (!entry) {
+          lines.push(borderFg("\u2502 ") + " ".repeat(innerWidth) + borderFg(" \u2502"));
+          continue;
+        }
+        const isSelected = entryIdx === this.selectedIndex;
+        const prefix = isSelected ? fg("accent", bold("\u25B6 ")) : "  ";
+        let leftContent = "";
+        let rightStr = "";
+        if (entry.kind === "tool") {
+          const tool = entry.tool;
+          const st = toolStatus(tool);
+          const icon = st === "pending" ? frame : st === "error" ? "\u2717" : "\u2713";
+          const iconColor = st === "pending" ? "accent" : st === "error" ? "error" : "success";
+          const s = toolSummary(tool.toolName, tool.args);
+          const elapsed = `(${toolElapsed(tool)}s)`;
+          const toolLabel = fg("toolTitle", bold(s.name));
+          const contentText = fg("dim", s.content || "...");
+          leftContent = `${prefix}${fg(iconColor, icon)} ${toolLabel} ${contentText}`;
+          rightStr = fg("muted", elapsed);
+        } else {
+          const spin = entry.active ? thinkingSpinnerFrame() : void 0;
+          const icon = spin?.frame ?? "\u2713";
+          const tokenLabel = thinkingTokenLabel(entry);
+          const tText = entry.text.trim().replace(/[*_#`>]+/g, "").replace(/\s+/g, " ");
+          const thinkingLabel = fg("toolTitle", "thinking");
+          const contentText = fg("thinkingText", tText || "(thinking...)");
+          leftContent = `${prefix}${fg(spin?.color ?? "thinkingText", icon)} ${thinkingLabel} ${contentText}`;
+          rightStr = fg("muted", tokenLabel);
+        }
+        const maxLeft = Math.max(1, innerWidth - visibleWidth4(rightStr) - 1);
+        const ellipsis = entry.kind === "thinking" ? fg("thinkingText", "...") : fg("dim", "...");
+        const leftTrunc = truncateToWidth5(leftContent, maxLeft, ellipsis);
+        const gap = Math.max(1, innerWidth - visibleWidth4(leftTrunc) - visibleWidth4(rightStr));
+        let rowLine = `${leftTrunc}${" ".repeat(gap)}${rightStr}`;
+        const rowVis = visibleWidth4(rowLine);
+        if (rowVis < innerWidth) {
+          rowLine += " ".repeat(innerWidth - rowVis);
+        } else if (rowVis > innerWidth) {
+          rowLine = truncateToWidth5(rowLine, innerWidth);
+        }
+        if (isSelected) {
+          if (theme?.bg) {
+            rowLine = theme.bg("selectedBg", rowLine);
+          } else if (theme?.inverse) {
+            rowLine = theme.inverse(rowLine);
+          }
+        }
+        lines.push(borderFg("\u2502 ") + rowLine + borderFg(" \u2502"));
+      }
+    }
+    const countInfo = this.entries.length > 0 ? ` [${this.selectedIndex + 1}/${this.entries.length}] ` : "";
+    const visCount = visibleWidth4(countInfo);
+    const botFiller = Math.max(1, width - 2 - visCount);
+    const botBorder = borderFg("\u2514" + "\u2500".repeat(botFiller)) + (countInfo ? fg("dim", countInfo) : "") + borderFg("\u2518");
+    lines.push(truncateToWidth5(botBorder, width));
+    return lines;
+  }
+  dispose() {
+  }
+  invalidate() {
+  }
+};
+function openInspectSelectorModal() {
+  if (runtime.activeModalHandle) {
+    closeDetailModal();
+  }
+  closeInspectSelectorModal();
+  const modal = new InspectSelectorModal();
+  runtime.activeSelectorComponent = modal;
+  if (runtime.capturedTui) {
+    runtime.activeSelectorHandle = runtime.capturedTui.showOverlay(modal, {
+      anchor: "center",
+      width: "85%",
+      maxHeight: "70%"
+    });
+    runtime.capturedTui.requestRender();
+    return;
+  }
+  if (runtime.activeUIContext?.custom) {
+    runtime.activeUIContext.custom(
+      (tui, _theme, _keybindings, done) => {
+        runtime.capturedTui = tui;
+        runtime.activeSelectorCloseFn = done;
+        return modal;
+      },
+      {
+        overlay: true,
+        overlayOptions: { anchor: "center", width: "85%", maxHeight: "70%" },
+        onHandle: (handle) => {
+          runtime.activeSelectorHandle = handle;
+        }
+      }
+    );
+  }
+}
+function closeInspectSelectorModal() {
+  if (runtime.activeSelectorHandle) {
+    const handle = runtime.activeSelectorHandle;
+    runtime.activeSelectorHandle = null;
+    handle.hide();
+  }
+  if (runtime.activeSelectorCloseFn) {
+    const done = runtime.activeSelectorCloseFn;
+    runtime.activeSelectorCloseFn = null;
+    done();
+  }
+  if (runtime.activeSelectorComponent) {
+    runtime.activeSelectorComponent = null;
+  }
+  runtime.capturedTui?.requestRender?.();
+}
+
+// src/extension.ts
+import { isKeyRelease as isKeyRelease2, matchesKey as matchesKey4, Key as Key3 } from "@earendil-works/pi-tui";
+
+// src/settings.ts
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import { Key as Key2, SettingsList, matchesKey as matchesKey3, truncateToWidth as truncateToWidth6 } from "@earendil-works/pi-tui";
+var CONFIG_KEYS = [
+  {
+    id: "expandedToolLines",
+    label: "Expanded tool lines",
+    description: "Result lines shown per tool when expanded",
+    min: 1,
+    max: 50,
+    step: 1
+  },
+  {
+    id: "expandedThinkingLines",
+    label: "Expanded thinking lines",
+    description: "Thinking lines shown when expanded",
+    min: 1,
+    max: 100,
+    step: 1
+  },
+  {
+    id: "maxGroupEntries",
+    label: "Max collapsed entries",
+    description: "Maximum entries shown in collapsed group",
+    min: 1,
+    max: 30,
+    step: 1
+  }
+];
+function makeStepper(title, initial, meta, theme, done) {
+  let value = initial;
+  let cachedWidth;
+  let cachedLines;
+  const fg = (color, t) => theme?.fg?.(color, t) ?? t;
+  return {
+    render(width) {
+      if (cachedLines && cachedWidth === width) return cachedLines;
+      const barLen = Math.max(1, Math.min(width - 10, 40));
+      const ratio = (value - meta.min) / Math.max(1, meta.max - meta.min);
+      const filled = Math.round(ratio * barLen);
+      const bar = "\u2588".repeat(filled) + "\u2591".repeat(Math.max(0, barLen - filled));
+      const titleText = theme?.bold ? theme.bold(title) : title;
+      cachedLines = [
+        fg("accent", titleText),
+        "",
+        `  ${fg("accent", String(value))}`,
+        `  ${fg("muted", bar)}`,
+        "",
+        fg("dim", "  \u25C0 \u25B6 / \u2212 +  adjust    Enter  save    Esc  cancel")
+      ].map((line) => truncateToWidth6(line, Math.max(1, width)));
+      cachedWidth = width;
+      return cachedLines;
+    },
+    handleInput(data) {
+      if (matchesKey3(data, Key2.left) || matchesKey3(data, Key2.down) || data === "-" || data === "_") {
+        value = Math.max(meta.min, value - meta.step);
+      } else if (matchesKey3(data, Key2.right) || matchesKey3(data, Key2.up) || data === "+" || data === "=") {
+        value = Math.min(meta.max, value + meta.step);
+      } else if (matchesKey3(data, Key2.enter) || matchesKey3(data, Key2.space)) {
+        done(String(value));
+        return;
+      } else if (matchesKey3(data, Key2.escape)) {
+        done(void 0);
+        return;
+      }
+      cachedWidth = void 0;
+    },
+    invalidate() {
+      cachedWidth = void 0;
+    }
+  };
+}
+function registerConfigCommand(pi) {
+  pi.registerCommand("compact-ui-config", {
+    description: "Interactive compact-ui settings (arrows to select, Enter to adjust, Esc to close)",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify(
+          `compact: expandedToolLines=${config.expandedToolLines}, expandedThinkingLines=${config.expandedThinkingLines}`,
+          "info"
+        );
+        return;
+      }
+      const changed = await ctx.ui.custom((tui, theme, _keybindings, done) => {
+        let anyChanged = false;
+        const items = CONFIG_KEYS.map((meta) => ({
+          id: meta.id,
+          label: meta.label,
+          currentValue: String(config[meta.id]),
+          description: meta.description,
+          submenu: (currentValue, subDone) => makeStepper(meta.label, Number(currentValue), meta, theme, subDone)
+        }));
+        const settingsList = new SettingsList(
+          items,
+          Math.min(items.length, 15),
+          getSettingsListTheme(),
+          (id, newValue) => {
+            config[id] = Number(newValue);
+            saveConfig();
+            anyChanged = true;
+            for (const g of runtime.groups) g.invalidate();
+          },
+          () => done(anyChanged)
+        );
+        return {
+          render(width) {
+            return settingsList.render(width);
+          },
+          invalidate() {
+            settingsList.invalidate();
+          },
+          handleInput(data) {
+            settingsList.handleInput?.(data);
+            tui.requestRender();
+          }
+        };
+      });
+      if (changed) {
+        ctx.ui.notify("compact-ui settings saved", "info");
+      }
+    }
+  });
+}
+
+// src/extension.ts
+function extension_default(pi) {
+  installGrouping();
+  installNativeThinkingSuppression();
+  installCompactionSummaryRendering();
+  pi.registerCommand("compact-inspect", {
+    description: "Select a tool call or thinking entry to inspect details (Shortcut: Ctrl+I)",
+    handler: async () => {
+      openInspectSelectorModal();
+    }
+  });
+  pi.on("session_start", async (_event, ctx) => {
+    runtime.currentTheme = ctx.ui.theme;
+    runtime.activeUIContext = ctx.ui;
+    ctx.ui.setHiddenThinkingLabel("");
+    ctx.ui.onTerminalInput((data) => {
+      if (isKeyRelease2(data)) {
+        return runtime.activeModalHandle || runtime.activeSelectorHandle ? { consume: true } : void 0;
+      }
+      if (runtime.activeModalHandle) {
+        if (matchesKey4(data, Key3.escape) || data === "q" || data === "Q" || isCtrlI(data)) {
+          closeDetailModal();
+          return { consume: true };
+        }
+        return void 0;
+      }
+      if (runtime.activeSelectorHandle) {
+        if (matchesKey4(data, Key3.escape) || data === "q" || data === "Q" || isCtrlI(data)) {
+          closeInspectSelectorModal();
+          return { consume: true };
+        }
+        return void 0;
+      }
+      if (isCtrlI(data)) {
+        openInspectSelectorModal();
+        return { consume: true };
+      }
+      return void 0;
+    });
+    ctx.ui.setWidget("compact-anim", (tui) => {
+      runtime.capturedTui = tui;
+      return { render: () => [], invalidate() {
+      } };
+    });
+    installGrouping();
+    installNativeThinkingSuppression();
+    installCompactionSummaryRendering();
+    if (ctx?.sessionManager?.getEntries) {
+      loadSessionToolTimings(ctx.sessionManager.getEntries());
+    }
+    queueMicrotask(() => {
+      for (const g of runtime.groups) {
+        g.sealed = true;
+        for (const t of g.children) {
+          if (t.result && t._groupEndAt === void 0) {
+            t._groupEndAt = Date.now();
+          }
+        }
+        g.invalidate();
+      }
+      runtime.lastActiveGroup = null;
+      if (runtime.animTimer) {
+        clearTimeout(runtime.animTimer);
+        runtime.animTimer = null;
+      }
+      runtime.capturedTui?.requestRender?.();
+    });
+  });
+  pi.on("session_shutdown", async () => {
+    closeDetailModal();
+    closeInspectSelectorModal();
+  });
+  pi.on("tool_execution_start", async (event) => {
+    rememberToolStart(event.toolCallId);
+    runtime.lastActiveGroup?.invalidate();
+    runtime.activeSelectorComponent?.refreshEntries();
+    runtime.capturedTui?.requestRender?.();
+  });
+  pi.on("tool_execution_end", async (event) => {
+    const end = Date.now();
+    const start = runtime.toolStarts.get(event.toolCallId);
+    if (start !== void 0 && !runtime.toolDurations.has(event.toolCallId)) {
+      runtime.toolDurations.set(event.toolCallId, Math.max(0, (end - start) / 1e3));
+    }
+    for (const g of runtime.groups) {
+      for (const t of g.children) {
+        if (t.toolCallId === event.toolCallId) t._groupEndAt = end;
+      }
+    }
+    runtime.lastActiveGroup?.invalidate();
+    runtime.activeSelectorComponent?.refreshEntries();
+    runtime.capturedTui?.requestRender?.();
+  });
+  pi.on("message_start", async (event) => {
+    const role = event.message?.role;
+    if (role === "user" && runtime.lastActiveGroup && !runtime.lastActiveGroup.sealed) {
+      runtime.lastActiveGroup.sealed = true;
+      finalizeActiveThinking();
+      runtime.lastActiveGroup.invalidate();
+    }
+    if (role === "user") {
+      for (const g of [...runtime.groups]) {
+        if (!g.hasVisibleEntries()) {
+          if (runtime.lastChatContainer) removeGroupFromContainer(runtime.lastChatContainer, g);
+          runtime.groups.delete(g);
+        }
+      }
+      runtime.turnStartMs = Date.now();
+      runtime.activeThinking = null;
+      runtime.activeThinkingIndex = null;
+      runtime.activeThinkingBlocks.clear();
+      runtime.unattachedThinking.length = 0;
+      clearPreparingTools();
+      runtime.lastSealedThinkingEntry = null;
+      runtime.lastReportedReasoningTokens = 0;
+      runtime.handledTextIndexes.clear();
+      runtime.sealedThinkingIndexes.clear();
+      runtime.pendingTextSeal = false;
+      runtime.pendingTextOrdinal = null;
+      runtime.lastStreamingComp = null;
+    } else if (role === "assistant") {
+      finalizeActiveThinking();
+      runtime.handledTextIndexes.clear();
+      runtime.sealedThinkingIndexes.clear();
+      runtime.lastSealedThinkingEntry = null;
+      runtime.lastReportedReasoningTokens = 0;
+      runtime.pendingTextSeal = false;
+      runtime.pendingTextOrdinal = null;
+      runtime.lastStreamingComp = null;
+    }
+  });
+  pi.on("message_update", async (event) => {
+    const msg = event.message;
+    if (!msg || msg.role !== "assistant") return;
+    const content = Array.isArray(msg.content) ? msg.content : [];
+    const streamEvent = event.assistantMessageEvent;
+    const streamType = String(streamEvent?.type ?? "");
+    if (streamType.startsWith("thinking_")) {
+      const contentIndex = Number(streamEvent.contentIndex);
+      const hasIndex = Number.isInteger(contentIndex);
+      if (hasIndex && runtime.sealedThinkingIndexes.has(contentIndex)) return;
+      const startsRun = streamType === "thinking_start" || !runtime.activeThinking || hasIndex && runtime.activeThinkingIndex !== contentIndex;
+      if (startsRun) {
+        finalizeActiveThinking();
+        runtime.activeThinkingIndex = hasIndex ? contentIndex : null;
+        createThinkingEntry();
+      }
+      const block = hasIndex ? content[contentIndex] : void 0;
+      const blockText = block?.type === "thinking" ? String(block.thinking ?? "") : streamType === "thinking_end" ? String(streamEvent.content ?? "") : "";
+      if (hasIndex) runtime.activeThinkingBlocks.set(contentIndex, blockText);
+      updateActiveThinkingTokens(msg);
+      ensureThinkingGroup();
+      if (streamType === "thinking_end") finalizeActiveThinking();
+    } else if (streamType.startsWith("text_")) {
+      const contentIndex = Number(streamEvent.contentIndex);
+      const block = Number.isInteger(contentIndex) ? content[contentIndex] : void 0;
+      const text = block?.type === "text" ? String(block.text ?? "").trim() : "";
+      if (text.length > 0 && !runtime.handledTextIndexes.has(contentIndex)) {
+        if (runtime.activeThinking) updateActiveThinkingTokens(msg);
+        runtime.handledTextIndexes.add(contentIndex);
+        runtime.pendingTextSeal = true;
+        runtime.pendingTextOrdinal = content.slice(0, Number.isInteger(contentIndex) ? contentIndex + 1 : content.length).filter((item) => item?.type === "text" && String(item.text ?? "").trim()).length - 1;
+        flushPendingTextSeal();
+      }
+    } else if (streamType.startsWith("toolcall_")) {
+      if (runtime.activeThinking) updateActiveThinkingTokens(msg);
+      noteStreamingToolCall(content, streamEvent);
+    } else if (streamType === "done" || streamType === "error") {
+      if (runtime.activeThinking) updateActiveThinkingTokens(msg);
+      finalizeActiveThinking();
+      refreshSealedThinkingTokens(msg?.usage?.reasoning);
+    }
+    runtime.lastActiveGroup?.invalidate();
+    runtime.activeSelectorComponent?.refreshEntries();
+    runtime.capturedTui?.requestRender?.();
+  });
+  pi.on("agent_end", async () => {
+    clearPreparingTools();
+    if (runtime.lastActiveGroup && !runtime.lastActiveGroup.sealed) {
+      runtime.lastActiveGroup.sealed = true;
+      finalizeActiveThinking();
+      runtime.lastActiveGroup.invalidate();
+    }
+    for (const g of [...runtime.groups]) {
+      if (!g.hasVisibleEntries()) {
+        if (runtime.lastChatContainer) removeGroupFromContainer(runtime.lastChatContainer, g);
+        runtime.groups.delete(g);
+      }
+    }
+    refreshSealedThinkingTokens();
+    runtime.activeSelectorComponent?.refreshEntries();
+    runtime.capturedTui?.requestRender?.();
+    const elapsedMs = Date.now() - runtime.turnStartMs;
+    insertTurnDivider(elapsedMs);
+    runtime.activeThinking = null;
+    runtime.activeThinkingIndex = null;
+    runtime.activeThinkingBlocks.clear();
+    runtime.unattachedThinking.length = 0;
+    runtime.lastSealedThinkingEntry = null;
+    runtime.lastReportedReasoningTokens = 0;
+    runtime.handledTextIndexes.clear();
+    runtime.sealedThinkingIndexes.clear();
+    runtime.pendingTextSeal = false;
+    runtime.pendingTextOrdinal = null;
+  });
+  registerConfigCommand(pi);
+}
+export {
+  extension_default as default,
+  getCompactMarkdownTheme,
+  normalizeCompactCodeBlockLines
+};
+//# sourceMappingURL=index.js.map