@jaggerxtrm/pi-extensions 0.9.3 → 0.9.5

package/extensions/xtrm-ui/index.ts

@@ -1,13 +1,6 @@
 /**
- * XTRM UI Extension
- *
- * Wraps pi-dex functionality with XTRM-specific preferences:
- * - Uses pi-dex themes and header
- * - Disables pi-dex footer (let custom-footer handle it)
- * - Provides /xtrm-ui commands for theme/density switching
- *
- * This eliminates the race condition between pi-dex's footer and
- * XTRM's custom-footer extension.
+ * XTRM-owned Pi chrome, themes, and native/external tool rendering.
+ * custom-footer remains the sole footer owner.
  */
 
 import type {
@@ -19,7 +12,6 @@ import type {
   GrepToolDetails,
   LsToolDetails,
   ReadToolDetails,
-  ToolResultEvent,
 } from "@earendil-works/pi-coding-agent";
 import {
   CustomEditor,
@@ -32,7 +24,7 @@ import {
   createWriteTool,
 } from "@earendil-works/pi-coding-agent";
 import { Box, Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { existsSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import {
@@ -58,21 +50,16 @@ import {
 // Types
 // ============================================================================
 
-export type XtrmThemeName = "pidex-dark" | "pidex-light" | "pidex-dark-flattools" | "pidex-light-flattools";
+export type XtrmThemeName = "xtrm-dark" | "xtrm-light";
+export type XtrmResolvedThemeName = XtrmThemeName | "xtrm-dark-flattools" | "xtrm-light-flattools";
 export type XtrmDensity = "compact" | "comfortable";
-export type XtrmExternalToolChrome = "background" | "box";
 
 export interface XtrmUiPrefs {
   themeName: XtrmThemeName;
   density: XtrmDensity;
   showHeader: boolean;
-  compactTools: boolean;
-  showFooter: boolean; // Our key addition - when false, skip setFooter()
-  forceTheme: boolean; // When false, skip setTheme (allow external theme override)
-  toolRowBg: boolean; // Subtle background behind tool text rows (no padding)
-  compactExternalToolResults: boolean; // Compact extension tool results (disables full expand output)
-  externalToolChrome: XtrmExternalToolChrome; // Visual treatment for non-native tool rows
-  hideThinkingPlaceholder: boolean; // When false, hidden thinking blocks render no placeholder text
+  forceTheme: boolean;
+  toolRowBg: boolean;
 }
 
 // ============================================================================
@@ -82,24 +69,13 @@ export interface XtrmUiPrefs {
 export const XTRM_UI_PREFS_ENTRY = "xtrm-ui-prefs";
 
 export const DEFAULT_PREFS: XtrmUiPrefs = {
-  themeName: "pidex-dark",
+  themeName: "xtrm-dark",
   density: "compact",
   showHeader: true,
-  compactTools: true,
-  showFooter: false, // XTRM: disable pi-dex footer, use custom-footer
   forceTheme: true,
   toolRowBg: false,
-  compactExternalToolResults: true,
-  externalToolChrome: "background",
-  hideThinkingPlaceholder: false,
 };
 
-let activeExternalToolChrome: XtrmExternalToolChrome = DEFAULT_PREFS.externalToolChrome;
-
-function setActiveExternalToolChrome(chrome: XtrmExternalToolChrome): void {
-  activeExternalToolChrome = chrome;
-}
-
 
 // ============================================================================
 // Preferences
@@ -113,19 +89,18 @@ type MaybeCustomEntry = {
 
 function normalizePrefs(input: unknown): XtrmUiPrefs {
   if (!input || typeof input !== "object") return { ...DEFAULT_PREFS };
-  const source = input as Partial<XtrmUiPrefs>;
+  const source = input as Partial<XtrmUiPrefs> & { themeName?: unknown };
+  const themeName = source.themeName;
+  const lightTheme = themeName === "xtrm-light"
+    || themeName === "xtrm-light-flattools"
+    || themeName === "pidex-light"
+    || themeName === "pidex-light-flattools";
   return {
-    themeName: source.themeName === "pidex-light" || source.themeName === "pidex-light-flattools" ? "pidex-light" : "pidex-dark",
+    themeName: lightTheme ? "xtrm-light" : "xtrm-dark",
     density: source.density === "comfortable" ? "comfortable" : "compact",
     showHeader: source.showHeader ?? DEFAULT_PREFS.showHeader,
-    compactTools: source.compactTools ?? DEFAULT_PREFS.compactTools,
-    showFooter: source.showFooter ?? DEFAULT_PREFS.showFooter,
     forceTheme: source.forceTheme ?? DEFAULT_PREFS.forceTheme,
     toolRowBg: source.toolRowBg ?? DEFAULT_PREFS.toolRowBg,
-    compactExternalToolResults:
-      source.compactExternalToolResults ?? DEFAULT_PREFS.compactExternalToolResults,
-    externalToolChrome: source.externalToolChrome === "box" ? "box" : "background",
-    hideThinkingPlaceholder: source.hideThinkingPlaceholder ?? DEFAULT_PREFS.hideThinkingPlaceholder,
   };
 }
 
@@ -247,12 +222,14 @@ type PatchableToolExecutionComponent = {
   result?: { content?: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean };
   expanded?: boolean;
   hasRendererDefinition?: () => boolean;
+  __xtrmExternalStartedAt?: number;
+  __xtrmExternalDurationMs?: number;
 };
 
 type ExternalToolFrameKind = "serena" | "gitnexus" | "structured" | "process" | "external";
 
 const PATCHED_EXTERNAL_TOOL_FRAME = "__xtrmUiExternalToolFrame";
-const EXTERNAL_TOOL_FRAME_PATCH_VERSION = 12;
+const EXTERNAL_TOOL_FRAME_PATCH_VERSION = 17;
 const ANSI_PATTERN = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
 
 function stripAnsi(text: string): string {
@@ -272,16 +249,6 @@ function externalToolFrameKind(toolName: string | undefined): ExternalToolFrameK
   return "external";
 }
 
-function padVisible(text: string, width: number): string {
-  const visible = visibleWidth(text);
-  return text + " ".repeat(Math.max(0, width - visible));
-}
-
-function getXtrmOriginalText(details: unknown): string | undefined {
-  const record = asRecord(details);
-  return typeof record?.xtrmOriginalText === "string" ? record.xtrmOriginalText : undefined;
-}
-
 function getToolArgs(component: PatchableToolExecutionComponent): Record<string, unknown> {
   return component.args && typeof component.args === "object" && !Array.isArray(component.args)
     ? component.args as Record<string, unknown>
@@ -309,13 +276,10 @@ function summarizeExternalToolPending(toolName: string | undefined, input: Recor
 }
 
 function extractResultTextLines(component: PatchableToolExecutionComponent): string[] | undefined {
-  const originalText = component.expanded ? getXtrmOriginalText(component.result?.details) : undefined;
-  if (originalText) return originalText.split("\n");
-
   const text = component.result?.content?.find((content) => content.type === "text")?.text;
-  if (text) return text.split("\n");
-
-  return [summarizeExternalToolPending(component.toolName, getToolArgs(component))];
+  return text
+    ? text.split("\n")
+    : [summarizeExternalToolPending(component.toolName, getToolArgs(component))];
 }
 
 function trimRenderedToolLines(lines: string[]): string[] {
@@ -338,66 +302,83 @@ function externalToolBadgeColor(kind: ExternalToolFrameKind, text: string): stri
   return `\x1b[38;2;3;8;12m\x1b[48;2;${badgeR};${badgeG};${badgeB}m${text}\x1b[39m\x1b[49m`;
 }
 
-function highlightExternalToolBadge(kind: ExternalToolFrameKind, line: string): string {
-  const match = line.match(/^([•›]\s+)(\S+)/u);
-  if (!match?.[1] || !match[2]) return line;
-  return match[1] + externalToolBadgeColor(kind, match[2]) + line.slice(match[1].length + match[2].length);
-}
+export function highlightExternalToolBadge(kind: ExternalToolFrameKind, line: string): string {
+  const marked = line.match(/^([•›]\s+)(\S+)/u);
+  if (marked?.[1] && marked[2]) {
+    return marked[1] + externalToolBadgeColor(kind, marked[2]) + line.slice(marked[1].length + marked[2].length);
+  }
 
-function externalToolBorderColor(kind: ExternalToolFrameKind, text: string): string {
-  const colors: Record<ExternalToolFrameKind, [number, number, number]> = {
-    serena: [150, 210, 255],
-    gitnexus: [185, 168, 255],
-    structured: [205, 166, 255],
-    process: [145, 231, 255],
-    external: [168, 181, 199],
-  };
-  const [r, g, b] = colors[kind];
-  return `[38;2;${r};${g};${b}m${text}`;
+  const provider = line.match(/^(\[[A-Za-z][A-Za-z0-9 _-]{0,31}\])/u)?.[1];
+  return provider ? externalToolBadgeColor(kind, provider) + line.slice(provider.length) : line;
 }
 
-function collapsedExternalToolLines(contentLines: string[], expanded: boolean): string[] {
-  return expanded ? contentLines : [contentLines.join(" · ")];
+export function collapsedExternalToolLines(contentLines: string[], expanded: boolean): string[] {
+  if (expanded || contentLines.length <= 6) return contentLines;
+  return [
+    ...contentLines.slice(0, 6),
+    `... (${contentLines.length - 6} more lines, ctrl+o to expand)`,
+  ];
 }
 
-function renderExternalToolBackgroundLines(
+export function renderExternalToolBackgroundLines(
   contentLines: string[],
   width: number,
   kind: ExternalToolFrameKind,
   expanded: boolean,
+  toolName?: string,
+  durationMs?: number,
 ): string[] {
-  const availableWidth = Math.max(8, width);
-  const renderWidth = availableWidth;
-  const visibleLines = collapsedExternalToolLines(contentLines, expanded);
+  let displayLines = contentLines;
+  const raw = contentLines.length === 1 ? contentLines[0]?.trim() : undefined;
+  if (raw?.startsWith("{") || raw?.startsWith("[")) {
+    try {
+      displayLines = JSON.stringify(JSON.parse(raw), null, 2).split("\n");
+    } catch {
+      // Keep non-JSON output unchanged.
+    }
+  }
 
-  return visibleLines.map((rawLine) => {
-    const line = truncateToWidth(rawLine, Math.max(1, renderWidth));
+  const firstLine = displayLines[0] ?? "";
+  const action = kind === "gitnexus" && toolName?.startsWith("gitnexus_")
+    ? toolName.slice("gitnexus_".length)
+    : kind === "serena" ? toolName : undefined;
+  const providerHeader = /^\[[A-Za-z][A-Za-z0-9 _-]{0,31}\]/u.test(firstLine);
+
+  if (providerHeader && action && !firstLine.endsWith(` ${action}`)) {
+    displayLines = [`${firstLine} ${action}`, ...displayLines.slice(1)];
+  } else if (!/^(?:[•›]\s+|\[[A-Za-z][A-Za-z0-9 _-]{0,31}\])/u.test(firstLine)) {
+    const labels: Record<ExternalToolFrameKind, string> = {
+      serena: "Serena",
+      gitnexus: "GitNexus",
+      structured: "structured_return",
+      process: "process",
+      external: "external",
+    };
+    const label = kind === "external" && toolName ? normalizeToolLabel(toolName) : labels[kind];
+    displayLines = [`[${label}]${action ? ` ${action}` : ""}`, ...displayLines];
+  }
+
+  const header = displayLines[0] ?? "";
+  const payloadLines = displayLines.slice(1);
+  const visiblePayload = expanded ? payloadLines : payloadLines.slice(0, 6);
+  const shown = visiblePayload.length;
+  const total = payloadLines.length;
+  const lineSummary = !expanded && shown < total
+    ? `showing ${shown}/${total} lines (ctrl+o expand)`
+    : total > 0 ? formatLineLabel(total, "line") : undefined;
+  const footerMeta = joinMeta([
+    lineSummary,
+    formatDuration(durationMs),
+    formatPayloadSize(contentLines.join("\n")),
+  ]);
+  const renderWidth = Math.max(8, width);
+  const body = [header, ...visiblePayload].map((rawLine) => {
+    const line = truncateToWidth(rawLine, renderWidth);
     return highlightExternalToolBadge(kind, line);
   });
-}
-
-function renderExternalToolBoxLines(
-  contentLines: string[],
-  width: number,
-  kind: ExternalToolFrameKind,
-  expanded: boolean,
-): string[] {
-  const availableWidth = Math.max(8, width - 4);
-  const maxContentWidth = expanded ? availableWidth : Math.min(availableWidth, 34);
-  const visibleLines = collapsedExternalToolLines(contentLines, expanded);
-  const contentWidth = Math.max(
-    1,
-    Math.min(maxContentWidth, ...visibleLines.map((line) => visibleWidth(line))),
-  );
-  const innerWidth = contentWidth + 2;
-
-  const framed = [externalToolBorderColor(kind, `╭${"─".repeat(innerWidth)}╮`)];
-  for (const rawLine of visibleLines) {
-    const line = truncateToWidth(rawLine, contentWidth);
-    framed.push(`${externalToolBorderColor(kind, "│")} ${padVisible(line, contentWidth)} ${externalToolBorderColor(kind, "│")}`);
-  }
-  framed.push(externalToolBorderColor(kind, `╰${"─".repeat(innerWidth)}╯`));
-  return framed;
+  return footerMeta
+    ? [...body, `\x1b[2m${truncateToWidth(`└─ ${footerMeta}`, renderWidth)}\x1b[22m`]
+    : body;
 }
 
 function renderExternalToolLines(
@@ -405,13 +386,13 @@ function renderExternalToolLines(
   width: number,
   kind: ExternalToolFrameKind,
   expanded = false,
+  toolName?: string,
+  durationMs?: number,
 ): string[] {
   const contentLines = trimRenderedToolLines(lines).filter((line) => !isBlankRenderedLine(line));
-  if (contentLines.length === 0) return [];
-
-  return activeExternalToolChrome === "box"
-    ? renderExternalToolBoxLines(contentLines, width, kind, expanded)
-    : renderExternalToolBackgroundLines(contentLines, width, kind, expanded);
+  return contentLines.length > 0
+    ? renderExternalToolBackgroundLines(contentLines, width, kind, expanded, toolName, durationMs)
+    : [];
 }
 
 async function installExternalToolFramePatch(): Promise<void> {
@@ -421,7 +402,7 @@ async function installExternalToolFramePatch(): Promise<void> {
     ToolExecutionComponent?: ToolExecutionComponentCtor;
   };
   const proto = mod.ToolExecutionComponent?.prototype as
-    | (ToolExecutionComponentCtor["prototype"] & { [PATCHED_EXTERNAL_TOOL_FRAME]?: boolean })
+    | (ToolExecutionComponentCtor["prototype"] & { [PATCHED_EXTERNAL_TOOL_FRAME]?: number })
     | undefined;
   if (!proto?.render || proto[PATCHED_EXTERNAL_TOOL_FRAME] === EXTERNAL_TOOL_FRAME_PATCH_VERSION) return;
 
@@ -435,24 +416,33 @@ async function installExternalToolFramePatch(): Promise<void> {
   };
 
   proto.render = function patchedRender(this: PatchableToolExecutionComponent, width: number) {
-    const rendered = render.call(this, width);
     const kind = externalToolFrameKind(this.toolName);
+    if (kind) this.__xtrmExternalStartedAt ??= Date.now();
+    const rendered = render.call(this, width);
     if (!kind || rendered.length === 0) return rendered;
 
+    if (this.result && this.__xtrmExternalDurationMs == null) {
+      this.__xtrmExternalDurationMs = Date.now() - (this.__xtrmExternalStartedAt ?? Date.now());
+    }
     const firstContentIndex = rendered.findIndex((line) => !isBlankRenderedLine(line));
     const leading = firstContentIndex > 0 ? rendered.slice(0, firstContentIndex) : [];
     const content = extractResultTextLines(this) ?? rendered;
-    const styled = renderExternalToolLines(content, width, kind, Boolean(this.expanded));
+    const styled = renderExternalToolLines(
+      content,
+      width,
+      kind,
+      Boolean(this.expanded),
+      this.toolName,
+      this.__xtrmExternalDurationMs,
+    );
     return styled.length > 0 ? [...leading, ...styled] : rendered;
   };
 
   proto[PATCHED_EXTERNAL_TOOL_FRAME] = EXTERNAL_TOOL_FRAME_PATCH_VERSION;
 }
 
-function applyThinkingChrome(ctx: ExtensionContext, prefs: XtrmUiPrefs): void {
-  (ctx.ui as { setHiddenThinkingLabel?: (label?: string) => void }).setHiddenThinkingLabel?.(
-    prefs.hideThinkingPlaceholder ? undefined : "",
-  );
+function applyThinkingChrome(ctx: ExtensionContext): void {
+  (ctx.ui as { setHiddenThinkingLabel?: (label?: string) => void }).setHiddenThinkingLabel?.("");
 }
 
 // ============================================================================
@@ -464,10 +454,9 @@ function fitVisible(text: string, width: number): string {
   return truncated + " ".repeat(Math.max(0, width - visibleWidth(truncated)));
 }
 
-function resolveThemeForPrefs(prefs: XtrmUiPrefs): XtrmThemeName {
-  const base = prefs.themeName === "pidex-light" || prefs.themeName === "pidex-light-flattools" ? "pidex-light" : "pidex-dark";
-  if (!prefs.toolRowBg) return (base + "-flattools") as XtrmThemeName;
-  return base as XtrmThemeName;
+function resolveThemeForPrefs(prefs: XtrmUiPrefs): XtrmResolvedThemeName {
+  if (prefs.toolRowBg) return prefs.themeName;
+  return prefs.themeName === "xtrm-light" ? "xtrm-light-flattools" : "xtrm-dark-flattools";
 }
 
 function formatThinking(level: string): string {
@@ -477,108 +466,62 @@ function formatThinking(level: string): string {
 function applyXtrmChrome(
   ctx: ExtensionContext,
   prefs: XtrmUiPrefs,
-  getThinkingLevel: () => string
+  getThinkingLevel: () => string,
 ): void {
-  // Theme
-  ctx.ui.setTheme(resolveThemeForPrefs(prefs));
-
-  // Tool expansion
-  ctx.ui.setToolsExpanded(!prefs.compactTools);
+  if (prefs.forceTheme) {
+    ctx.ui.setTheme(resolveThemeForPrefs(prefs));
+  }
 
-  // Editor — density-aware input padding
+  ctx.ui.setToolsExpanded(false);
   ctx.ui.setEditorComponent((tui, theme, keybindings) => {
     const editor = new XtrmEditor(tui, theme, keybindings);
     editor.setPrefs(prefs);
     return editor;
   });
 
-  // Header (optional)
-  if (prefs.showHeader) {
-    ctx.ui.setHeader((_tui, theme) => ({
-      invalidate() {},
-      render(width: number): string[] {
-        const boxWidth = width >= 54 ? 50 : Math.max(24, width);
-        const model = ctx.model?.id ?? "no-model";
-        const thinking = getThinkingLevel();
-        const border = (text: string) => theme.fg("borderAccent", text);
-        const leftPad = "";
-
-        const top = leftPad + border(`╭${"─".repeat(Math.max(0, boxWidth - 2))}╮`);
-        const line1 =
-          leftPad +
-          border("│") +
-          fitVisible(
-            ` ${theme.fg("dim", ">_")} ${theme.bold("XTRM")} ${theme.fg("dim", `(v1.0.0)`)}`,
-            boxWidth - 2
-          ) +
-          border("│");
-        const gap = leftPad + border("│") + fitVisible("", boxWidth - 2) + border("│");
-        const line2 =
-          leftPad +
-          border("│") +
-          fitVisible(
-            ` ${theme.fg("dim", "model:".padEnd(11))}${model} ${thinking}${theme.fg("accent", "    /model")}${theme.fg("dim", " to change")}`,
-            boxWidth - 2
-          ) +
-          border("│");
-        const line3 =
-          leftPad +
-          border("│") +
-          fitVisible(
-            ` ${theme.fg("dim", "directory:".padEnd(11))}${basename(ctx.cwd)}`,
-            boxWidth - 2
-          ) +
-          border("│");
-        const bottom = leftPad + border(`╰${"─".repeat(Math.max(0, boxWidth - 2))}╯`);
-
-        return [top, line1, gap, line2, line3, bottom];
-      },
-    }));
-  } else {
+  if (!prefs.showHeader) {
     ctx.ui.setHeader(undefined);
+    return;
   }
 
-  // Footer - ONLY if showFooter is true (default false for XTRM)
-  // This is the key difference from pi-dex - we let custom-footer handle it
-  if (prefs.showFooter) {
-    ctx.ui.setFooter((tui, theme, footerData) => {
-      const unsubscribe = footerData.onBranchChange(() => tui.requestRender());
-      return {
-        dispose: unsubscribe,
-        invalidate() {},
-        render(width: number): string[] {
-          const modelId = ctx.model?.id ?? "no-model";
-          const thinking = getThinkingLevel();
-          const contextUsage = ctx.getContextUsage();
-          const leftPct = contextUsage?.percent != null ? `${100 - Math.round(contextUsage.percent)}% left` : undefined;
-          const line = theme.fg(
-            "dim",
-            [`${modelId} ${thinking}`, leftPct, basename(ctx.cwd)]
-              .filter(Boolean)
-              .join(" · ")
-          );
-          return [truncateToWidth(line, width)];
-        },
-      };
-    });
-  }
-  // If showFooter is false, we do NOT call setFooter - custom-footer will handle it
+  ctx.ui.setHeader((_tui, theme) => ({
+    invalidate() {},
+    render(width: number): string[] {
+      const boxWidth = width >= 54 ? 50 : Math.max(24, width);
+      const model = ctx.model?.id ?? "no-model";
+      const thinking = getThinkingLevel();
+      const border = (text: string) => theme.fg("borderAccent", text);
+      const top = border(`╭${"─".repeat(Math.max(0, boxWidth - 2))}╮`);
+      const line1 =
+        border("│") +
+        fitVisible(
+          ` ${theme.fg("dim", ">_")} ${theme.bold("XTRM")} ${theme.fg("dim", "(v1.0.0)")}`,
+          boxWidth - 2,
+        ) +
+        border("│");
+      const gap = border("│") + fitVisible("", boxWidth - 2) + border("│");
+      const line2 =
+        border("│") +
+        fitVisible(
+          ` ${theme.fg("dim", "model:".padEnd(11))}${model} ${thinking}${theme.fg("accent", "    /model")}${theme.fg("dim", " to change")}`,
+          boxWidth - 2,
+        ) +
+        border("│");
+      const line3 =
+        border("│") +
+        fitVisible(
+          ` ${theme.fg("dim", "directory:".padEnd(11))}${basename(ctx.cwd)}`,
+          boxWidth - 2,
+        ) +
+        border("│");
+      const bottom = border(`╰${"─".repeat(Math.max(0, boxWidth - 2))}╯`);
+
+      return [top, line1, gap, line2, line3, bottom];
+    },
+  }));
 }
 
 
-function writeExternalCompactFlag(enabled: boolean): void {
-  try {
-    const settingsPath = join(process.env.HOME ?? "", ".pi", "agent", "settings.json");
-    if (!settingsPath) return;
-    let settings: Record<string, unknown> = {};
-    if (existsSync(settingsPath)) {
-      try { settings = JSON.parse(readFileSync(settingsPath, "utf8")); } catch {}
-    }
-    settings.xtrmExternalCompact = enabled;
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
-  } catch {}
-}
-
 // ============================================================================
 // Tool Render Helpers
 // ============================================================================
@@ -642,8 +585,8 @@ function sendInfoMessage(pi: ExtensionAPI, title: string, content: string): void
 
 function parseThemeArg(arg: string): XtrmThemeName | undefined {
   const normalized = arg.trim().toLowerCase();
-  if (normalized === "dark" || normalized === "pidex-dark") return "pidex-dark";
-  if (normalized === "light" || normalized === "pidex-light") return "pidex-light";
+  if (normalized === "dark") return "xtrm-dark";
+  if (normalized === "light") return "xtrm-light";
   return undefined;
 }
 
@@ -654,14 +597,19 @@ function parseDensityArg(arg: string): XtrmDensity | undefined {
   return undefined;
 }
 
-function parseExternalToolChromeArg(arg: string): XtrmExternalToolChrome | undefined {
+function parseToggleArg(arg: string): boolean | undefined {
   const normalized = arg.trim().toLowerCase();
-  if (normalized === "background" || normalized === "bg" || normalized === "row") return "background";
-  if (normalized === "box" || normalized === "frame" || normalized === "border") return "box";
+  if (normalized === "on") return true;
+  if (normalized === "off") return false;
   return undefined;
 }
 
-function registerCommands(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs, setPrefs: (p: XtrmUiPrefs) => void, getThinkingLevel: () => string) {
+function registerCommands(
+  pi: ExtensionAPI,
+  getPrefs: () => XtrmUiPrefs,
+  setPrefs: (prefs: XtrmUiPrefs) => void,
+  getThinkingLevel: () => string,
+): void {
   pi.registerMessageRenderer("xtrm-ui-info", (message, _options, theme) => {
     const title = (message.details as { title?: string } | undefined)?.title ?? "XTRM UI";
     const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
@@ -673,41 +621,22 @@ function registerCommands(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs, setPref
   pi.registerCommand("xtrm-ui", {
     description: "Show XTRM UI status and active preferences",
     handler: async (args, ctx) => {
-      const trimmedArgs = args.trim();
-      if (trimmedArgs) {
-        const [subcommand, ...rest] = trimmedArgs.split(/\s+/u);
-        if (subcommand === "chrome" || subcommand === "external-chrome" || subcommand === "tool-chrome") {
-          const externalToolChrome = parseExternalToolChromeArg(rest.join(" "));
-          if (!externalToolChrome) {
-            ctx.ui.notify("Usage: /xtrm-ui chrome background|box", "warning");
-            return;
-          }
-          const prefs = { ...getPrefs(), externalToolChrome };
-          setPrefs(prefs);
-          persistPrefs(pi, prefs);
-          ctx.ui.notify(`External tool chrome set to ${externalToolChrome}.`, "info");
-          return;
-        }
-        ctx.ui.notify("Usage: /xtrm-ui [chrome background|box]", "warning");
+      if (args.trim()) {
+        ctx.ui.notify("Usage: /xtrm-ui", "warning");
         return;
       }
 
       const prefs = getPrefs();
       const contextUsage = ctx.getContextUsage();
-      const lines = [
+      sendInfoMessage(pi, "XTRM UI status", [
         `Theme: ${prefs.themeName}`,
-        `Force theme: ${prefs.forceTheme ? "on" : "off"}`,
         `Density: ${prefs.density}`,
-        `Compact tools: ${prefs.compactTools ? "on" : "off"}`,
         `Show header: ${prefs.showHeader ? "yes" : "no"}`,
-        `Show footer: ${prefs.showFooter ? "yes" : "no"} (custom-footer handles this)`,
+        `Force theme: ${prefs.forceTheme ? "on" : "off"}`,
         `Tool row background: ${prefs.toolRowBg ? "on" : "off"}`,
-        `Compact external tool results: ${prefs.compactExternalToolResults ? "on" : "off"}`,
-        `External tool chrome: ${prefs.externalToolChrome}`,
         `Model: ${ctx.model?.id ?? "none"}`,
         `Context: ${contextUsage?.tokens ?? "unknown"}/${contextUsage?.contextWindow ?? "unknown"}`,
-      ];
-      sendInfoMessage(pi, "XTRM UI status", lines.join("\\n"));
+      ].join("\n"));
     },
   });
 
@@ -732,7 +661,7 @@ function registerCommands(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs, setPref
   });
 
   pi.registerCommand("xtrm-ui-density", {
-    description: "Switch XTRM UI density: compact|comfortable",
+    description: "Switch editor density: compact|comfortable",
     getArgumentCompletions: (prefix) => {
       const values = ["compact", "comfortable"].filter((item) => item.startsWith(prefix));
       return values.length > 0 ? values.map((value) => ({ value, label: value })) : null;
@@ -743,10 +672,9 @@ function registerCommands(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs, setPref
         ctx.ui.notify("Usage: /xtrm-ui-density compact|comfortable", "warning");
         return;
       }
-      const prefs = { ...getPrefs(), density, compactExternalToolResults: density === "compact" };
+      const prefs = { ...getPrefs(), density };
       setPrefs(prefs);
       persistPrefs(pi, prefs);
-      writeExternalCompactFlag(prefs.compactExternalToolResults);
       applyXtrmChrome(ctx, prefs, getThinkingLevel);
       ctx.ui.notify(`XTRM UI density set to ${density}`, "info");
     },
@@ -759,7 +687,11 @@ function registerCommands(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs, setPref
       return values.length > 0 ? values.map((value) => ({ value, label: value })) : null;
     },
     handler: async (args, ctx) => {
-      const showHeader = args.trim().toLowerCase() === "on";
+      const showHeader = parseToggleArg(args);
+      if (showHeader === undefined) {
+        ctx.ui.notify("Usage: /xtrm-ui-header on|off", "warning");
+        return;
+      }
       const prefs = { ...getPrefs(), showHeader };
       setPrefs(prefs);
       persistPrefs(pi, prefs);
@@ -775,12 +707,11 @@ function registerCommands(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs, setPref
       return values.length > 0 ? values.map((value) => ({ value, label: value })) : null;
     },
     handler: async (args, ctx) => {
-      const normalized = args.trim().toLowerCase();
-      if (normalized !== "on" && normalized !== "off") {
+      const forceTheme = parseToggleArg(args);
+      if (forceTheme === undefined) {
         ctx.ui.notify("Usage: /xtrm-ui-forcetheme on|off", "warning");
         return;
       }
-      const forceTheme = normalized === "on";
       const prefs = { ...getPrefs(), forceTheme };
       setPrefs(prefs);
       persistPrefs(pi, prefs);
@@ -796,12 +727,11 @@ function registerCommands(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs, setPref
       return values.length > 0 ? values.map((value) => ({ value, label: value })) : null;
     },
     handler: async (args, ctx) => {
-      const normalized = args.trim().toLowerCase();
-      if (normalized !== "on" && normalized !== "off") {
+      const toolRowBg = parseToggleArg(args);
+      if (toolRowBg === undefined) {
         ctx.ui.notify("Usage: /xtrm-ui-rowbg on|off", "warning");
         return;
       }
-      const toolRowBg = normalized === "on";
       const prefs = { ...getPrefs(), toolRowBg };
       setPrefs(prefs);
       persistPrefs(pi, prefs);
@@ -810,49 +740,6 @@ function registerCommands(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs, setPref
     },
   });
 
-  pi.registerCommand("xtrm-ui-compact-tools", {
-    description: "Compact extension tool results: on|off (off keeps full Ctrl+O expand output)",
-    getArgumentCompletions: (prefix) => {
-      const values = ["on", "off"].filter((item) => item.startsWith(prefix));
-      return values.length > 0 ? values.map((value) => ({ value, label: value })) : null;
-    },
-    handler: async (args, ctx) => {
-      const normalized = args.trim().toLowerCase();
-      if (normalized !== "on" && normalized !== "off") {
-        ctx.ui.notify("Usage: /xtrm-ui-compact-tools on|off", "warning");
-        return;
-      }
-      const compactExternalToolResults = normalized === "on";
-      const prefs = { ...getPrefs(), compactExternalToolResults };
-      setPrefs(prefs);
-      persistPrefs(pi, prefs);
-      writeExternalCompactFlag(compactExternalToolResults);
-      ctx.ui.notify(
-        `Compact external tool results ${compactExternalToolResults ? "enabled" : "disabled"}.`,
-        "info",
-      );
-    },
-  });
-
-  pi.registerCommand("xtrm-ui-external-chrome", {
-    description: "Choose non-native tool chrome: background|box",
-    getArgumentCompletions: (prefix) => {
-      const values = ["background", "box"].filter((item) => item.startsWith(prefix));
-      return values.length > 0 ? values.map((value) => ({ value, label: value })) : null;
-    },
-    handler: async (args, ctx) => {
-      const externalToolChrome = parseExternalToolChromeArg(args);
-      if (!externalToolChrome) {
-        ctx.ui.notify("Usage: /xtrm-ui-external-chrome background|box", "warning");
-        return;
-      }
-      const prefs = { ...getPrefs(), externalToolChrome };
-      setPrefs(prefs);
-      persistPrefs(pi, prefs);
-      ctx.ui.notify(`External tool chrome set to ${externalToolChrome}.`, "info");
-    },
-  });
-
   pi.registerCommand("xtrm-ui-reset", {
     description: "Restore XTRM UI defaults",
     handler: async (_args, ctx) => {
@@ -866,25 +753,25 @@ function registerCommands(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs, setPref
 }
 
 // ============================================================================
-// Tool Renderers (ported from pi-dex tooling.ts)
+// XTRM Tool Renderers
 // ============================================================================
 
 type BuiltInTools = ReturnType<typeof createBuiltInTools>;
 
-type XtrmMeta<TArgs = Record<string, unknown>> = {
-  tool: string;
-  args: TArgs;
-  durationMs: number;
-};
-
 type XtrmWritePreview =
   | { kind: "created"; lineCount: number }
   | { kind: "updated"; diff: string; additions: number; removals: number }
   | { kind: "unchanged" };
 
-type DetailsWithXtrmMeta<TDetails, TArgs = Record<string, unknown>> = TDetails & {
-  xtrmMeta?: XtrmMeta<TArgs>;
-  xtrmWritePreview?: XtrmWritePreview;
+type XtrmToolRenderState = {
+  startedAt?: number;
+  writePreview?: XtrmWritePreview;
+};
+
+type XtrmToolRenderContext = {
+  executionStarted: boolean;
+  isPartial: boolean;
+  state: XtrmToolRenderState;
 };
 
 const toolCache = new Map<string, BuiltInTools>();
@@ -910,22 +797,6 @@ function getTools(cwd: string): BuiltInTools {
   return tools;
 }
 
-function withXtrmMeta<TDetails extends object, TArgs extends Record<string, unknown>>(
-  details: TDetails | undefined,
-  tool: string,
-  args: TArgs,
-  durationMs: number,
-): DetailsWithXtrmMeta<TDetails, TArgs> {
-  return { ...(details ?? ({} as TDetails)), xtrmMeta: { tool, args, durationMs } };
-}
-
-function getXtrmMeta<TDetails extends object, TArgs extends Record<string, unknown>>(
-  details: TDetails | undefined,
-): XtrmMeta<TArgs> | undefined {
-  if (!details || typeof details !== "object") return undefined;
-  return (details as DetailsWithXtrmMeta<TDetails, TArgs>).xtrmMeta;
-}
-
 function getTextContent(result: { content: Array<{ type: string; text?: string }> }): string {
   const item = result.content.find((content) => content.type === "text");
   return item?.text ?? "";
@@ -955,12 +826,17 @@ function createWritePreview(path: string, nextContent: string): XtrmWritePreview
   };
 }
 
-function renderPendingCall(toolName: string, args: Record<string, unknown>, theme: any): Text {
-  return new Text(renderToolSummary(theme, "pending", toolName, summarizeToolSubject(toolName, args), undefined), 0, 0);
+function appendToolFooter(theme: any, text: string, parts: Array<string | undefined>): string {
+  const meta = joinMeta(parts);
+  return meta ? `${text}\n${theme.fg("dim", `└─ ${meta}`)}` : text;
 }
 
-function stableToolSignature(toolName: string, args: Record<string, unknown>): string {
-  return `${toolName}:${JSON.stringify(args)}`;
+function renderPendingCall(toolName: string, args: Record<string, unknown>, theme: any): Text {
+  if (toolName === "bash") {
+    const command = shortenCommand(String(args.command ?? ""), 80);
+    return new Text(`${theme.fg("accent", TOOL_ROW_MARKER)} ${theme.fg("accent", "$")} ${theme.fg("accent", command)}`, 0, 0);
+  }
+  return new Text(renderToolSummary(theme, "pending", toolName, summarizeToolSubject(toolName, args), undefined), 0, 0);
 }
 
 function summarizeToolSubject(toolName: string, args: Record<string, unknown>): string | undefined {
@@ -1025,55 +901,10 @@ const SERENA_COMPACT_TOOLS = new Set([
   "serena_mcp_reset",
 ]);
 
-function parseJson(text: string): unknown | undefined {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return undefined;
-  }
-}
-
 function asRecord(value: unknown): Record<string, unknown> | undefined {
   return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
 }
 
-function countSearchMatches(payload: unknown): number | undefined {
-  const record = asRecord(payload);
-  if (!record) return undefined;
-  let total = 0;
-  for (const value of Object.values(record)) {
-    if (Array.isArray(value)) total += value.length;
-  }
-  return total > 0 ? total : undefined;
-}
-
-function countOverviewSymbols(payload: unknown): number {
-  if (Array.isArray(payload)) {
-    const nested = payload.reduce<number>((total, value) => total + countOverviewSymbols(value), 0);
-    return nested || payload.length;
-  }
-  const record = asRecord(payload);
-  if (!record) return 0;
-  return Object.values(record).reduce<number>((total, value) => total + countOverviewSymbols(value), 0);
-}
-
-function countLines(text: string): number {
-  if (!text) return 0;
-  return text.split("\n").length;
-}
-
-function countJsonItems(payload: unknown): number | undefined {
-  if (Array.isArray(payload)) return payload.length;
-  const record = asRecord(payload);
-  if (!record) return undefined;
-
-  let total = 0;
-  for (const value of Object.values(record)) {
-    if (Array.isArray(value)) total += value.length;
-  }
-  return total > 0 ? total : undefined;
-}
-
 function summarizeSerenaSubject(toolName: string, input: Record<string, unknown>): string | undefined {
   switch (toolName) {
     case "find_symbol":
@@ -1120,104 +951,8 @@ function summarizeSerenaSubject(toolName: string, input: Record<string, unknown>
   }
 }
 
-function summarizeSerenaToolResult(
-  toolName: string,
-  input: Record<string, unknown>,
-  text: string,
-  durationMs: number | undefined,
-): string {
-  const payload = parseJson(text);
-  const duration = formatDuration(durationMs);
-  const payloadSize = formatPayloadSize(text);
-  const subject = summarizeSerenaSubject(toolName, input);
-  const meta = (...parts: Array<string | undefined>) => {
-    const joined = joinCompactMeta([duration, payloadSize, ...parts]);
-    return joined ? ` · ${joined}` : "";
-  };
-
-  switch (toolName) {
-    case "find_symbol":
-    case "find_referencing_symbols":
-    case "jet_brains_find_symbol":
-    case "jet_brains_find_referencing_symbols": {
-      const count = countJsonItems(payload) ?? (text.match(/"name_path"\s*:/g)?.length ?? 0);
-      return `${TOOL_ROW_MARKER} serena ${toolName} ${subject ?? "symbol"}${meta(formatLineLabel(count, "result"))}`;
-    }
-    case "get_symbols_overview":
-    case "jet_brains_get_symbols_overview":
-    case "jet_brains_type_hierarchy": {
-      const count = Math.max(countOverviewSymbols(payload), text.match(/"name_path"\s*:/g)?.length ?? 0);
-      return `${TOOL_ROW_MARKER} serena ${toolName} ${subject ?? "file"}${meta(formatLineLabel(count, "symbol"))}`;
-    }
-    case "search_for_pattern": {
-      const count = countSearchMatches(payload) ?? (text.match(/^\s*>\s*\d+:/gm)?.length ?? 0);
-      return `${TOOL_ROW_MARKER} serena search ${subject ?? "pattern"}${meta(formatLineLabel(count, "match"))}`;
-    }
-    case "read_file": {
-      return `${TOOL_ROW_MARKER} serena read ${subject ?? "file"}${meta(formatLineLabel(countLines(text), "line"))}`;
-    }
-    case "list_dir": {
-      const count = countJsonItems(payload) ?? countLines(text);
-      return `${TOOL_ROW_MARKER} serena list_dir ${subject ?? "."}${meta(formatLineLabel(count, "entry"))}`;
-    }
-    case "find_file": {
-      const count = countJsonItems(payload) ?? countLines(text);
-      return `${TOOL_ROW_MARKER} serena find_file ${String(input.file_mask ?? "")}${meta(formatLineLabel(count, "match"))}`;
-    }
-    case "replace_symbol_body":
-    case "insert_after_symbol":
-    case "insert_before_symbol":
-    case "rename_symbol":
-    case "create_text_file":
-    case "replace_content":
-    case "replace_lines":
-    case "delete_lines":
-    case "insert_at_line":
-    case "write_memory":
-    case "delete_memory":
-    case "rename_memory":
-    case "edit_memory":
-    case "activate_project":
-    case "remove_project":
-    case "switch_modes":
-    case "restart_language_server":
-    case "onboarding":
-    case "serena_mcp_reset":
-      return `${TOOL_ROW_MARKER} serena ${toolName}${subject ? ` ${subject}` : ""}${meta()}`;
-    case "execute_shell_command": {
-      const count = countLines(text);
-      return `${TOOL_ROW_MARKER} serena shell ${subject ?? "command"}${meta(formatLineLabel(count, "line"))}`;
-    }
-    default: {
-      const count = countJsonItems(payload) ?? countLines(text);
-      return `${TOOL_ROW_MARKER} serena ${toolName}${subject ? ` ${subject}` : ""}${meta(formatLineLabel(count, "item"))}`;
-    }
-  }
-}
 
 
-function formatHierarchyText(text: string): string {
-  const lines = text.split("\n");
-  const out: string[] = [];
-  for (const raw of lines) {
-    const line = raw.trimEnd();
-    if (!line.trim()) {
-      out.push("");
-      continue;
-    }
-    if (line.startsWith("● ")) {
-      out.push(line);
-      continue;
-    }
-    if (/^(Read|Searched|Listed|Update\(|File must be read first|Now )/.test(line.trimStart())) {
-      out.push(`  └─ ${line.trimStart()}`);
-      continue;
-    }
-    out.push(line);
-  }
-  return out.join("\n");
-}
-
 function normalizeToolLabel(toolName: string): string {
   const gitnexusMap: Record<string, string> = {
     gitnexus_query: "gitnexus query",
@@ -1245,155 +980,13 @@ function normalizeToolLabel(toolName: string): string {
   return toolName;
 }
 
-function summarizeGenericToolResult(
-  toolName: string,
-  input: Record<string, unknown>,
-  text: string,
-  durationMs: number | undefined,
-): string {
-  const payload = parseJson(text);
-  const duration = formatDuration(durationMs);
-  const payloadSize = formatPayloadSize(text);
-  const subject = summarizeToolSubject(toolName, input) ?? summarizeSerenaSubject(toolName, input);
-  const count = countJsonItems(payload) ?? countLines(text);
-  const label = formatLineLabel(count, "line");
-  const joined = joinCompactMeta([duration, payloadSize, label]);
-  const normalized = normalizeToolLabel(toolName);
-  return `${TOOL_ROW_MARKER} ${normalized}${subject ? ` ${subject}` : ""}${joined ? ` · ${joined}` : ""}`;
-}
-
-function summarizeStructuredReturnToolResult(
-  input: Record<string, unknown>,
-  text: string,
-  details: unknown,
-  durationMs: number | undefined,
-): string {
-  const record = asRecord(details);
-  const command = shortenCommand(String(input.command ?? text.split("→")[0] ?? "command"), 52);
-  const resultText = text.includes("→") ? text.split("→").slice(1).join("→").trim() : text.trim();
-  const resultLines = resultText.split("\n").map((line) => line.trim()).filter(Boolean);
-  const summary = resultLines.find((line) => !line.startsWith("cwd:"));
-  const parser = typeof record?.parser === "string" ? record.parser : undefined;
-  const exitCode = typeof record?.exitCode === "number" ? `exit ${record.exitCode}` : undefined;
-  const resultMeta = joinCompactMeta([formatDuration(durationMs), formatPayloadSize(text)]);
-  const meta = joinMeta([summary ? shortenCommand(summary, 72) : undefined, parser, exitCode, resultMeta]);
-  return `${TOOL_ROW_MARKER} structured_return ${command}${meta ? ` · ${meta}` : ""}`;
-}
-
-function summarizeProcessToolResult(
-  input: Record<string, unknown>,
-  text: string,
-  details: unknown,
-  durationMs: number | undefined,
-): string {
-  const record = asRecord(details);
-  const action = String(record?.action ?? input.action ?? "action");
-  const duration = formatDuration(durationMs);
-  const payloadSize = formatPayloadSize(text);
-  const meta = (...parts: Array<string | undefined>) => {
-    const joined = joinCompactMeta([duration, payloadSize, ...parts]);
-    return joined ? ` · ${joined}` : "";
-  };
-
-  if (action === "start") {
-    const proc = asRecord(record?.process);
-    const name = String(proc?.name ?? input.name ?? "process");
-    const id = proc?.id ? String(proc.id) : undefined;
-    const pid = proc?.pid != null ? `pid ${String(proc.pid)}` : undefined;
-    return `${TOOL_ROW_MARKER} process start "${name}"${meta(id, pid)}`;
-  }
-
-  if (action === "list") {
-    const processes = Array.isArray(record?.processes) ? record.processes : [];
-    const running = processes.filter((item) => {
-      const proc = asRecord(item);
-      return proc?.status === "running" || proc?.status === "terminating";
-    }).length;
-    return `${TOOL_ROW_MARKER} process list${meta(`${processes.length} ${processes.length === 1 ? "process" : "processes"}`, `${running} running`)}`;
-  }
-
-  if (action === "output") {
-    const output = asRecord(record?.output);
-    const stdout = Array.isArray(output?.stdout) ? output.stdout.length : undefined;
-    const stderr = Array.isArray(output?.stderr) ? output.stderr.length : undefined;
-    return `${TOOL_ROW_MARKER} process output ${String(input.id ?? "process")}${meta(
-      stdout != null ? `${stdout} stdout` : undefined,
-      stderr != null ? `${stderr} stderr` : undefined,
-    )}`;
-  }
-
-  if (action === "logs") {
-    return `${TOOL_ROW_MARKER} process logs ${String(input.id ?? "process")}${meta("log paths")}`;
-  }
-
-  const message = typeof record?.message === "string" ? record.message : text.split("\n")[0];
-  return `${TOOL_ROW_MARKER} process ${action}${message ? ` · ${shortenCommand(message, 38)}` : ""}${meta()}`;
-}
-
-function summarizeExternalToolResult(
-  toolName: string,
-  input: Record<string, unknown>,
-  text: string,
-  details: unknown,
-  durationMs: number | undefined,
-): string {
-  if (SERENA_COMPACT_TOOLS.has(toolName)) {
-    return summarizeSerenaToolResult(toolName, input, text, durationMs);
-  }
-  if (toolName === "structured_return") {
-    return summarizeStructuredReturnToolResult(input, text, details, durationMs);
-  }
-  if (toolName === "process") {
-    return summarizeProcessToolResult(input, text, details, durationMs);
-  }
-  return summarizeGenericToolResult(toolName, input, text, durationMs);
-}
 
-function withXtrmToolDetails(details: unknown, sourceText: string, toolName: string): unknown {
-  const record = asRecord(details);
-  return {
-    ...(record ?? {}),
-    xtrmOriginalText: sourceText,
-    xtrmToolFrame: externalToolFrameKind(toolName),
-  };
-}
 
 const XTRM_BUILTIN_TOOLS = new Set(["bash", "read", "edit", "write", "find", "grep", "ls"]);
 
-// Tools whose RESULT PAYLOAD the model needs verbatim in context. In pi, a tool_result
-// hook's return value REPLACES the model-facing content (not just the TUI render), so
-// compacting these would replace the model-facing payload with "· N lines" / "· N results"
-// for every pi surface that loads xtrm-ui — interactive sessions (where the human can
-// expand the TUI row but the model cannot) and any headless pi run that doesn't pass
-// --no-extensions. Specialists are unaffected: they run with --no-extensions and never
-// load xtrm-ui (selectively re-attach only quality-gates / service-skills / pi-gitnexus /
-// pi-serena-tools). Mutation/no-payload tools are still summarized below, preserving
-// most of the token savings.
-const PAYLOAD_TOOLS = new Set<string>([
-  // Serena reads / inspection
-  "read_file",
-  "find_symbol",
-  "find_referencing_symbols",
-  "get_symbols_overview",
-  "search_for_pattern",
-  "find_file",
-  "list_dir",
-  "read_memory",
-  // JetBrains backend equivalents
-  "jet_brains_find_symbol",
-  "jet_brains_find_referencing_symbols",
-  "jet_brains_get_symbols_overview",
-  "jet_brains_type_hierarchy",
-  // GitNexus reads (same blindness risk)
-  "gitnexus_query",
-  "gitnexus_context",
-  "gitnexus_impact",
-  "gitnexus_detect_changes",
-]);
 
 function registerXtrmUiTools(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs): void {
-  const activeToolCalls = new Map<string, string>();
-
+  const tools = getTools(process.cwd());
   const toolRowText = (theme: any, text: string) =>
     new Text(
       text,
@@ -1401,110 +994,53 @@ function registerXtrmUiTools(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs): voi
       0,
       getPrefs().toolRowBg ? (line: string) => theme.bg("selectedBg", line) : undefined,
     );
-  const activeSignatureCounts = new Map<string, number>();
-  const toolCallStartTimes = new Map<string, number>();
-
-  const trackToolCallStart = (toolCallId: string, toolName: string, args: Record<string, unknown>) => {
-    const signature = stableToolSignature(toolName, args);
-    activeToolCalls.set(toolCallId, signature);
-    activeSignatureCounts.set(signature, (activeSignatureCounts.get(signature) ?? 0) + 1);
-    toolCallStartTimes.set(toolCallId, Date.now());
-  };
-
-  const trackToolCallEnd = (toolCallId: string) => {
-    const signature = activeToolCalls.get(toolCallId);
-    if (!signature) return;
-    activeToolCalls.delete(toolCallId);
-    const next = (activeSignatureCounts.get(signature) ?? 1) - 1;
-    if (next <= 0) activeSignatureCounts.delete(signature);
-    else activeSignatureCounts.set(signature, next);
-    toolCallStartTimes.delete(toolCallId);
+  const renderCall = (
+    toolName: string,
+    args: Record<string, unknown>,
+    theme: any,
+    context: XtrmToolRenderContext,
+  ) => {
+    context.state.startedAt ??= Date.now();
+    return context.isPartial && !context.executionStarted
+      ? renderPendingCall(toolName, args, theme)
+      : toolRowText(theme, "");
   };
-
-  const isToolCallActive = (toolName: string, args: Record<string, unknown>) =>
-    activeSignatureCounts.has(stableToolSignature(toolName, args));
-
-  const renderPendingCallIfActive = (toolName: string, args: Record<string, unknown>, theme: any) =>
-    isToolCallActive(toolName, args) ? renderPendingCall(toolName, args, theme) : toolRowText(theme, "");
-
-  pi.on("tool_call", async (event) => {
-    trackToolCallStart(event.toolCallId, event.toolName, event.input as Record<string, unknown>);
-  });
-
-  pi.on("tool_execution_end", async (event) => {
-    trackToolCallEnd(event.toolCallId);
-  });
-
-  pi.on("tool_result", async (event: ToolResultEvent, _ctx) => {
-    if (event.isError) return undefined;
-    if (XTRM_BUILTIN_TOOLS.has(event.toolName)) {
-      trackToolCallEnd(event.toolCallId);
-      return undefined;
-    }
-    // Never compact read/inspect tools: the hook return replaces model-facing content,
-    // so summarizing these would blind headless agents/specialists (no row to expand).
-    if (PAYLOAD_TOOLS.has(event.toolName)) return undefined;
-    if (!getPrefs().compactExternalToolResults) return undefined;
-
-    const text = getTextContent({ content: event.content as Array<{ type: string; text?: string }> });
-    const startedAt = toolCallStartTimes.get(event.toolCallId);
-    const durationMs = startedAt != null ? Date.now() - startedAt : undefined;
-
-    const fallbackText = "[non-text result]";
-    const sourceText = text.trim() ? text : fallbackText;
-
-    const safeInput =
-      event.input && typeof event.input === "object" && !Array.isArray(event.input)
-        ? (event.input as Record<string, unknown>)
-        : {};
-
-    const compactText = summarizeExternalToolResult(
-      event.toolName,
-      safeInput,
-      sourceText,
-      event.details,
-      durationMs,
-    );
-
-    return {
-      content: [{ type: "text", text: formatHierarchyText(compactText) }],
-      details: withXtrmToolDetails(event.details, sourceText, event.toolName),
-    };
-  });
+  const renderDuration = (context: XtrmToolRenderContext) =>
+    formatDuration(context.state.startedAt == null ? undefined : Date.now() - context.state.startedAt);
 
   pi.registerTool({
     name: "bash",
     label: "bash",
-    description: getTools(process.cwd()).bash.description,
-    parameters: getTools(process.cwd()).bash.parameters,
+    description: tools.bash.description,
+    parameters: tools.bash.parameters,
+    execute: tools.bash.execute,
     renderShell: "self",
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      const started = Date.now();
-      const result = await getTools(ctx.cwd).bash.execute(toolCallId, params, signal, onUpdate);
-      return { ...result, details: withXtrmMeta(result.details as BashToolDetails | undefined, "bash", params as Record<string, unknown>, Date.now() - started) };
-    },
-    renderCall: (args, theme) => renderPendingCallIfActive("bash", args as Record<string, unknown>, theme),
-    renderResult(result, { expanded, isPartial }, theme) {
-      const details = (result.details ?? {}) as DetailsWithXtrmMeta<BashToolDetails, Record<string, unknown>>;
-      const meta = getXtrmMeta<BashToolDetails, Record<string, unknown>>(details);
-      const command = shortenCommand(String(meta?.args.command ?? ""), 80);
+    renderCall: (args, theme, context) =>
+      renderCall("bash", args as Record<string, unknown>, theme, context),
+    renderResult(result, { expanded, isPartial }, theme, context) {
+      const details = (result.details ?? {}) as BashToolDetails;
+      const args = context.args as Record<string, unknown>;
+      const command = String(args.command ?? "");
       if (isPartial) {
-        return toolRowText(theme, `${theme.fg("accent", TOOL_ROW_MARKER)} ${theme.fg("toolTitle", "bash:")}${theme.fg("accent", command)}`);
+        return toolRowText(theme, `${theme.fg("accent", TOOL_ROW_MARKER)} ${theme.fg("accent", "$")} ${theme.fg("accent", command)}`);
       }
       const output = getTextContent(result as any);
       const outputLines = cleanOutputLines(output);
-      const exitMatch = output.match(/exit code:\s*(-?\d+)/i);
-      const exitCode = exitMatch ? Number.parseInt(exitMatch[1] ?? "0", 10) : 0;
-      const bullet = exitCode === 0 ? theme.fg("success", TOOL_ROW_MARKER) : theme.fg("error", TOOL_ROW_MARKER);
-      const summary = joinCompactMeta([
-        formatDuration(meta?.durationMs),
+      const statusColor = context.isError ? "error" : "success";
+      let text = `${theme.fg(statusColor, TOOL_ROW_MARKER)} ${theme.fg(statusColor, "$")} ${theme.fg(statusColor, command)}`;
+      const visibleLines = expanded ? outputLines : outputLines.slice(-4);
+      if (visibleLines.length > 0) {
+        text += "\n" + visibleLines.map((line) => `  ${theme.fg("toolOutput", line)}`).join("\n");
+      }
+      const lineSummary = !expanded && visibleLines.length < outputLines.length
+        ? `showing ${visibleLines.length}/${outputLines.length} lines (ctrl+o expand)`
+        : formatLineLabel(outputLines.length, "line");
+      text = appendToolFooter(theme, text, [
+        lineSummary,
+        renderDuration(context),
         formatPayloadSize(output),
-        formatLineLabel(outputLines.length, "line"),
         details.truncation?.truncated ? "truncated" : undefined,
       ]);
-      let text = `${bullet} ${theme.fg("toolTitle", "bash:")}${theme.fg("accent", command)}`;
-      if (summary) text += theme.fg("dim", ` · ${summary}`);
-      if (expanded && outputLines.length > 0) text += `\n${renderVerticalPreview(theme, outputLines, 10)}`;
       return toolRowText(theme, text);
     },
   });
@@ -1512,30 +1048,45 @@ function registerXtrmUiTools(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs): voi
   pi.registerTool({
     name: "read",
     label: "read",
-    description: getTools(process.cwd()).read.description,
-    parameters: getTools(process.cwd()).read.parameters,
+    description: tools.read.description,
+    parameters: tools.read.parameters,
+    execute: tools.read.execute,
     renderShell: "self",
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      const started = Date.now();
-      const result = await getTools(ctx.cwd).read.execute(toolCallId, params, signal, onUpdate);
-      return { ...result, details: withXtrmMeta(result.details as ReadToolDetails | undefined, "read", params as Record<string, unknown>, Date.now() - started) };
-    },
-    renderCall: (args, theme) => renderPendingCallIfActive("read", args as Record<string, unknown>, theme),
-    renderResult(result, { expanded, isPartial }, theme) {
+    renderCall: (args, theme, context) =>
+      renderCall("read", args as Record<string, unknown>, theme, context),
+    renderResult(result, { expanded, isPartial }, theme, context) {
       if (isPartial) return toolRowText(theme, renderToolSummary(theme, "pending", "read", "loading", undefined));
-      const details = (result.details ?? {}) as DetailsWithXtrmMeta<ReadToolDetails, Record<string, unknown>>;
-      const meta = getXtrmMeta<ReadToolDetails, Record<string, unknown>>(details);
-      const subjectBase = shortenPath(String(meta?.args.path ?? ""));
-      const range = lineRange(meta?.args.offset as number | undefined, meta?.args.limit as number | undefined);
+      const details = (result.details ?? {}) as ReadToolDetails;
+      const args = context.args as Record<string, unknown>;
+      const subjectBase = shortenPath(String(args.path ?? ""));
+      const range = lineRange(args.offset as number | undefined, args.limit as number | undefined);
       const subject = range ? `${subjectBase}:${range}` : subjectBase;
       const first = result.content[0];
       if (first?.type === "image") {
-        return toolRowText(theme, renderToolSummary(theme, "success", "read", subject, joinMeta(["image", formatDuration(meta?.durationMs)])));
+        const text = appendToolFooter(
+          theme,
+          renderToolSummary(theme, "success", "read", subject, undefined),
+          ["image", renderDuration(context)],
+        );
+        return toolRowText(theme, text);
       }
       const textContent = getTextContent(result as any);
       const lines = textContent.split("\n");
-      let text = renderToolSummary(theme, "success", "read", subject, joinMeta([formatLineLabel(lines.length, "line"), formatDuration(meta?.durationMs), details.truncation?.truncated ? `from ${details.truncation.totalLines}` : undefined]));
-      if (expanded && textContent.length > 0) text += `\n${renderOutputPreview(theme, previewLines(textContent, 14), 14)}`;
+      const totalLines = lines.length;
+      const showContent = expanded || totalLines <= 6;
+      let text = renderToolSummary(theme, context.isError ? "error" : "success", "read", subject, undefined);
+      if (showContent && totalLines > 0) {
+        text += "\n" + lines.map((line) => `  ${theme.fg("toolOutput", line)}`).join("\n");
+      }
+      const lineSummary = !showContent && totalLines > 0
+        ? `${formatLineLabel(totalLines, "line")} (ctrl+o expand)`
+        : formatLineLabel(totalLines, "line");
+      text = appendToolFooter(theme, text, [
+        lineSummary,
+        renderDuration(context),
+        formatPayloadSize(textContent),
+        details.truncation?.truncated ? `from ${details.truncation.totalLines}` : undefined,
+      ]);
       return toolRowText(theme, text);
     },
   });
@@ -1543,26 +1094,30 @@ function registerXtrmUiTools(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs): voi
   pi.registerTool({
     name: "edit",
     label: "edit",
-    description: getTools(process.cwd()).edit.description,
-    parameters: getTools(process.cwd()).edit.parameters,
+    description: tools.edit.description,
+    parameters: tools.edit.parameters,
+    execute: tools.edit.execute,
     renderShell: "self",
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      const started = Date.now();
-      const result = await getTools(ctx.cwd).edit.execute(toolCallId, params, signal, onUpdate);
-      return { ...result, details: withXtrmMeta(result.details as EditToolDetails | undefined, "edit", params as Record<string, unknown>, Date.now() - started) };
-    },
-    renderCall: (args, theme) => renderPendingCallIfActive("edit", args as Record<string, unknown>, theme),
-    renderResult(result, { expanded, isPartial }, theme) {
+    renderCall: (args, theme, context) =>
+      renderCall("edit", args as Record<string, unknown>, theme, context),
+    renderResult(result, { isPartial }, theme, context) {
       if (isPartial) return toolRowText(theme, renderToolSummary(theme, "pending", "edit", "applying", undefined));
-      const details = (result.details ?? {}) as DetailsWithXtrmMeta<EditToolDetails, Record<string, unknown>>;
-      const meta = getXtrmMeta<EditToolDetails, Record<string, unknown>>(details);
+      const details = (result.details ?? {}) as EditToolDetails;
+      const args = context.args as Record<string, unknown>;
+      const path = String(args.path ?? "");
       const textContent = getTextContent(result as any);
-      if (/^error/i.test(textContent.trim())) {
-        return toolRowText(theme, renderToolSummary(theme, "error", "edit", shortenPath(String(meta?.args.path ?? "")), textContent.split("\n")[0]));
+      if (context.isError) {
+        const text = appendToolFooter(
+          theme,
+          renderToolSummary(theme, "error", "edit", path, textContent.split("\n")[0]),
+          [renderDuration(context)],
+        );
+        return toolRowText(theme, text);
       }
       const stats = details.diff ? diffStats(details.diff) : { additions: 0, removals: 0 };
-      let text = renderToolSummary(theme, "success", "edit", shortenPath(String(meta?.args.path ?? "")), joinMeta([`+${stats.additions}`, `-${stats.removals}`, formatDuration(meta?.durationMs)]));
-      if (expanded && details.diff) text += `\n${renderRichDiffPreview(theme, details.diff, 18)}`;
+      let text = renderToolSummary(theme, "success", "edit", path, undefined);
+      if (details.diff) text += `\n${renderRichDiffPreview(theme, details.diff, 18)}`;
+      text = appendToolFooter(theme, text, [`+${stats.additions}`, `-${stats.removals}`, renderDuration(context)]);
       return toolRowText(theme, text);
     },
   });
@@ -1570,85 +1125,88 @@ function registerXtrmUiTools(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs): voi
   pi.registerTool({
     name: "write",
     label: "write",
-    description: getTools(process.cwd()).write.description,
-    parameters: getTools(process.cwd()).write.parameters,
+    description: tools.write.description,
+    parameters: tools.write.parameters,
+    execute: tools.write.execute,
     renderShell: "self",
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      const started = Date.now();
-      const args = params as Record<string, unknown>;
-      const path = String(args.path ?? "");
-      const content = String(args.content ?? "");
-      const preview = createWritePreview(path, content);
-      const result = await getTools(ctx.cwd).write.execute(toolCallId, params, signal, onUpdate);
-      const details = withXtrmMeta(result.details as Record<string, never> | undefined, "write", args, Date.now() - started);
-      return { ...result, details: { ...details, xtrmWritePreview: preview } };
+    renderCall(args, theme, context) {
+      const input = args as Record<string, unknown>;
+      const state = context.state as XtrmToolRenderState;
+      if (context.argsComplete && !state.writePreview) {
+        state.writePreview = createWritePreview(String(input.path ?? ""), String(input.content ?? ""));
+      }
+      return renderCall("write", input, theme, context);
     },
-    renderCall: (args, theme) => renderPendingCallIfActive("write", args as Record<string, unknown>, theme),
-    renderResult(result, { expanded, isPartial }, theme) {
+    renderResult(result, { expanded, isPartial }, theme, context) {
       if (isPartial) return toolRowText(theme, renderToolSummary(theme, "pending", "write", "writing", undefined));
-      const details = (result.details ?? {}) as DetailsWithXtrmMeta<Record<string, never>, Record<string, unknown>>;
-      const meta = getXtrmMeta<Record<string, never>, Record<string, unknown>>(details);
+      const args = context.args as Record<string, unknown>;
+      const path = String(args.path ?? "");
+      const content = String(args.content ?? "");
       const textContent = getTextContent(result as any);
-      if (/^error/i.test(textContent.trim())) {
-        return toolRowText(theme, renderToolSummary(theme, "error", "write", shortenPath(String(meta?.args.path ?? "")), textContent.split("\n")[0]));
+      if (context.isError) {
+        const text = appendToolFooter(
+          theme,
+          renderToolSummary(theme, "error", "write", path, textContent.split("\n")[0]),
+          [renderDuration(context)],
+        );
+        return toolRowText(theme, text);
       }
 
-      const subject = shortenPath(String(meta?.args.path ?? ""));
-      const preview = details.xtrmWritePreview;
-
+      const preview = (context.state as XtrmToolRenderState).writePreview;
       if (preview?.kind === "unchanged") {
-        return toolRowText(theme, renderToolSummary(theme, "success", "write", subject, joinMeta(["no changes", formatDuration(meta?.durationMs)])));
-      }
-
-      if (preview?.kind === "updated") {
-        let text = renderToolSummary(
+        const text = appendToolFooter(
           theme,
-          "success",
-          "write",
-          subject,
-          joinMeta([`+${preview.additions}`, `-${preview.removals}`, formatDuration(meta?.durationMs)]),
+          renderToolSummary(theme, "success", "write", path, undefined),
+          ["no changes", renderDuration(context)],
         );
-        if (expanded && preview.diff) text += `\n${renderRichDiffPreview(theme, preview.diff, 18)}`;
+        return toolRowText(theme, text);
+      }
+      if (preview?.kind === "updated") {
+        let text = renderToolSummary(theme, "success", "write", path, undefined);
+        if (preview.diff) text += `\n${renderRichDiffPreview(theme, preview.diff, 18)}`;
+        text = appendToolFooter(theme, text, [`+${preview.additions}`, `-${preview.removals}`, renderDuration(context)]);
         return toolRowText(theme, text);
       }
 
-      const lines = preview?.kind === "created"
-        ? preview.lineCount
-        : lineCount(String(meta?.args.content ?? ""));
-
-      return toolRowText(theme, renderToolSummary(
-          theme,
-          "success",
-          "write",
-          subject,
-          joinMeta([formatLineLabel(lines, "line"), formatDuration(meta?.durationMs)]),
-        ),
-        0,
-        0,
-      );
+      const lines = preview?.kind === "created" ? preview.lineCount : lineCount(content);
+      let text = renderToolSummary(theme, "success", "write", path, undefined);
+      const contentLines = content.split("\n");
+      const showContent = content && (expanded || contentLines.length <= 6);
+      if (showContent) {
+        text += "\n" + contentLines.map((line) => `  ${theme.fg("toolOutput", line)}`).join("\n");
+      }
+      text = appendToolFooter(theme, text, [
+        !showContent && lines > 0 ? `${formatLineLabel(lines, "line")} (ctrl+o expand)` : formatLineLabel(lines, "line"),
+        renderDuration(context),
+        formatPayloadSize(content),
+      ]);
+      return toolRowText(theme, text);
     },
   });
 
   pi.registerTool({
     name: "find",
     label: "find",
-    description: getTools(process.cwd()).find.description,
-    parameters: getTools(process.cwd()).find.parameters,
+    description: tools.find.description,
+    parameters: tools.find.parameters,
+    execute: tools.find.execute,
     renderShell: "self",
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      const started = Date.now();
-      const result = await getTools(ctx.cwd).find.execute(toolCallId, params, signal, onUpdate);
-      return { ...result, details: withXtrmMeta(result.details as FindToolDetails | undefined, "find", params as Record<string, unknown>, Date.now() - started) };
-    },
-    renderCall: (args, theme) => renderPendingCallIfActive("find", args as Record<string, unknown>, theme),
-    renderResult(result, { expanded, isPartial }, theme) {
+    renderCall: (args, theme, context) =>
+      renderCall("find", args as Record<string, unknown>, theme, context),
+    renderResult(result, { expanded, isPartial }, theme, context) {
       if (isPartial) return toolRowText(theme, renderToolSummary(theme, "pending", "find", "searching", undefined));
-      const details = (result.details ?? {}) as DetailsWithXtrmMeta<FindToolDetails, Record<string, unknown>>;
-      const meta = getXtrmMeta<FindToolDetails, Record<string, unknown>>(details);
+      const details = (result.details ?? {}) as FindToolDetails;
+      const args = context.args as Record<string, unknown>;
       const textContent = getTextContent(result as any);
       const count = summarizeCount(textContent);
-      let text = renderToolSummary(theme, "success", "find", String(meta?.args.pattern ?? ""), joinMeta([formatLineLabel(count, "match"), formatDuration(meta?.durationMs), details.resultLimitReached ? "limit reached" : undefined]));
+      let text = renderToolSummary(theme, context.isError ? "error" : "success", "find", String(args.pattern ?? ""), undefined);
       if (expanded && count > 0) text += `\n${renderOutputPreview(theme, previewLines(textContent, 10), 10)}`;
+      text = appendToolFooter(theme, text, [
+        !expanded && count > 0 ? `${formatLineLabel(count, "match")} (ctrl+o expand)` : formatLineLabel(count, "match"),
+        renderDuration(context),
+        formatPayloadSize(textContent),
+        details.resultLimitReached ? "limit reached" : undefined,
+      ]);
       return toolRowText(theme, text);
     },
   });
@@ -1656,23 +1214,26 @@ function registerXtrmUiTools(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs): voi
   pi.registerTool({
     name: "grep",
     label: "grep",
-    description: getTools(process.cwd()).grep.description,
-    parameters: getTools(process.cwd()).grep.parameters,
+    description: tools.grep.description,
+    parameters: tools.grep.parameters,
+    execute: tools.grep.execute,
     renderShell: "self",
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      const started = Date.now();
-      const result = await getTools(ctx.cwd).grep.execute(toolCallId, params, signal, onUpdate);
-      return { ...result, details: withXtrmMeta(result.details as GrepToolDetails | undefined, "grep", params as Record<string, unknown>, Date.now() - started) };
-    },
-    renderCall: (args, theme) => renderPendingCallIfActive("grep", args as Record<string, unknown>, theme),
-    renderResult(result, { expanded, isPartial }, theme) {
+    renderCall: (args, theme, context) =>
+      renderCall("grep", args as Record<string, unknown>, theme, context),
+    renderResult(result, { expanded, isPartial }, theme, context) {
       if (isPartial) return toolRowText(theme, renderToolSummary(theme, "pending", "grep", "searching", undefined));
-      const details = (result.details ?? {}) as DetailsWithXtrmMeta<GrepToolDetails, Record<string, unknown>>;
-      const meta = getXtrmMeta<GrepToolDetails, Record<string, unknown>>(details);
+      const details = (result.details ?? {}) as GrepToolDetails;
+      const args = context.args as Record<string, unknown>;
       const textContent = getTextContent(result as any);
       const count = countPrefixedItems(textContent, ["-- "]) || summarizeCount(textContent);
-      let text = renderToolSummary(theme, "success", "grep", String(meta?.args.pattern ?? ""), joinMeta([formatLineLabel(count, "match"), formatDuration(meta?.durationMs), details.matchLimitReached ? "limit reached" : undefined]));
+      let text = renderToolSummary(theme, context.isError ? "error" : "success", "grep", String(args.pattern ?? ""), undefined);
       if (expanded && textContent.length > 0) text += `\n${renderOutputPreview(theme, previewLines(textContent, 12), 12)}`;
+      text = appendToolFooter(theme, text, [
+        !expanded && count > 0 ? `${formatLineLabel(count, "match")} (ctrl+o expand)` : formatLineLabel(count, "match"),
+        renderDuration(context),
+        formatPayloadSize(textContent),
+        details.matchLimitReached ? "limit reached" : undefined,
+      ]);
       return toolRowText(theme, text);
     },
   });
@@ -1680,23 +1241,26 @@ function registerXtrmUiTools(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs): voi
   pi.registerTool({
     name: "ls",
     label: "ls",
-    description: getTools(process.cwd()).ls.description,
-    parameters: getTools(process.cwd()).ls.parameters,
+    description: tools.ls.description,
+    parameters: tools.ls.parameters,
+    execute: tools.ls.execute,
     renderShell: "self",
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      const started = Date.now();
-      const result = await getTools(ctx.cwd).ls.execute(toolCallId, params, signal, onUpdate);
-      return { ...result, details: withXtrmMeta(result.details as LsToolDetails | undefined, "ls", params as Record<string, unknown>, Date.now() - started) };
-    },
-    renderCall: (args, theme) => renderPendingCallIfActive("ls", args as Record<string, unknown>, theme),
-    renderResult(result, { expanded, isPartial }, theme) {
+    renderCall: (args, theme, context) =>
+      renderCall("ls", args as Record<string, unknown>, theme, context),
+    renderResult(result, { expanded, isPartial }, theme, context) {
       if (isPartial) return toolRowText(theme, renderToolSummary(theme, "pending", "ls", "listing", undefined));
-      const details = (result.details ?? {}) as DetailsWithXtrmMeta<LsToolDetails, Record<string, unknown>>;
-      const meta = getXtrmMeta<LsToolDetails, Record<string, unknown>>(details);
+      const details = (result.details ?? {}) as LsToolDetails;
+      const args = context.args as Record<string, unknown>;
       const textContent = getTextContent(result as any);
       const count = summarizeCount(textContent);
-      let text = renderToolSummary(theme, "success", "ls", shortenPath(String(meta?.args.path ?? ".")), joinMeta([formatLineLabel(count, "entry"), formatDuration(meta?.durationMs), details.entryLimitReached ? "limit reached" : undefined]));
+      let text = renderToolSummary(theme, context.isError ? "error" : "success", "ls", shortenPath(String(args.path ?? ".")), undefined);
       if (expanded && count > 0) text += `\n${renderOutputPreview(theme, previewLines(textContent, 12), 12)}`;
+      text = appendToolFooter(theme, text, [
+        !expanded && count > 0 ? `${formatLineLabel(count, "entry")} (ctrl+o expand)` : formatLineLabel(count, "entry"),
+        renderDuration(context),
+        formatPayloadSize(textContent),
+        details.entryLimitReached ? "limit reached" : undefined,
+      ]);
       return toolRowText(theme, text);
     },
   });
@@ -1706,22 +1270,16 @@ function registerXtrmUiTools(pi: ExtensionAPI, getPrefs: () => XtrmUiPrefs): voi
 // Main Extension
 // ============================================================================
 
-function isXtrmTheme(name: string | undefined): boolean {
-  return name === "pidex-dark" || name === "pidex-light";
-}
-
 export default function xtrmUiExtension(pi: ExtensionAPI): void {
   void installSilentHiddenThinkingPatch().catch(() => undefined);
   void installExternalToolFramePatch().catch(() => undefined);
 
   let prefs: XtrmUiPrefs = { ...DEFAULT_PREFS };
-  let previousThemeName: string | null = null;
   const extensionThemeDir = join(__dirname, "../../themes/xtrm-ui");
 
   const getPrefs = () => prefs;
-  const setPrefs = (p: XtrmUiPrefs) => {
-    prefs = p;
-    setActiveExternalToolChrome(p.externalToolChrome);
+  const setPrefs = (nextPrefs: XtrmUiPrefs) => {
+    prefs = nextPrefs;
   };
   const getThinkingLevel = () => formatThinking(pi.getThinkingLevel());
 
@@ -1730,7 +1288,7 @@ export default function xtrmUiExtension(pi: ExtensionAPI): void {
 
   const refresh = (ctx: ExtensionContext) => {
     applyXtrmChrome(ctx, prefs, getThinkingLevel);
-    applyThinkingChrome(ctx, prefs);
+    applyThinkingChrome(ctx);
   };
 
   pi.on("resources_discover", async () => ({
@@ -1739,27 +1297,14 @@ export default function xtrmUiExtension(pi: ExtensionAPI): void {
 
   pi.on("session_start", async (_event, ctx) => {
     setPrefs(loadPrefs(ctx.sessionManager.getEntries() as Array<MaybeCustomEntry>));
-    if (!previousThemeName && !isXtrmTheme(ctx.ui.theme.name)) {
-      previousThemeName = ctx.ui.theme.name ?? null;
-    }
     refresh(ctx);
-
-    setTimeout(() => {
-      ctx.ui.setTheme(resolveThemeForPrefs(prefs));
-    }, 0);
   });
 
   pi.on("session_switch", async (_event, ctx) => {
-    if (!previousThemeName && !isXtrmTheme(ctx.ui.theme.name)) {
-      previousThemeName = ctx.ui.theme.name ?? null;
-    }
     refresh(ctx);
   });
 
   pi.on("session_fork", async (_event, ctx) => {
-    if (!previousThemeName && !isXtrmTheme(ctx.ui.theme.name)) {
-      previousThemeName = ctx.ui.theme.name ?? null;
-    }
     refresh(ctx);
   });
 
@@ -1767,10 +1312,8 @@ export default function xtrmUiExtension(pi: ExtensionAPI): void {
     refresh(ctx);
   });
 
-  pi.on("session_shutdown", async (_event, ctx) => {
-    if (previousThemeName) {
-      ctx.ui.setTheme(previousThemeName);
-    }
+  pi.on("session_shutdown", async () => {
+    // No-op: no theme restoration on shutdown
   });
 
   pi.on("input", async (event) => {