@pi-kaush/pi-tool-call-markers 0.2.7 → 0.2.9

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+- Fix: preserve the visible text of hyperlink-wrapped paths in collapsed rows. Pi renders `read` call paths as OSC 8 hyperlinks (`ESC]8;;url ESC\ <path> ESC]8;; ESC\`); the previous greedy OSC strip consumed the path text along with the sequences, collapsing `% read: README.md:1-400` to `% read: :1-400`. OSC payloads now end at their first BEL/ST terminator, so `read`/`write`/`ls` rows show their filenames again.
+- Show settled `edit` changes inline: the call line gains a `+added/-removed` outcome stat, and the display diff from `result.details.diff` renders as a bounded block underneath (`+` lines in the added tone, `-` in the removed tone, context muted, `...` for folded regions; capped at 12 lines with a `+N more` tail). `Ctrl+O` still returns Pi's full native diff.
+- Render subagent plans with a `&` marker instead of `%`, so delegated calls read differently from ordinary tool rows (both the parsed plan shape and the generic fallback).
+- Render user-run `!` bash blocks (BashExecutionComponent) with the railed prompt shell previously owned by `pi-content-layout` — execution display now lives entirely in this package, while `pi-content-layout` keeps only the transcript surface (message insets, status rows, editor, user prompts). The bash-block inset mirrors that package's message inset.
 - Render every collapsed tool call as a `% tool: call → outcome` line with the tool name bolded — one marker per call, no bullets, no blank lines between sections; grouped blocks share only their leading blank row (supersedes the nested sub-heading layout).
 - Render subagent calls as an unboxed plan — `% subagent` heading with chain/parallel counts and numbered steps as they execute, agent names in accent with emojis scraped from the native plan component (args fallback) — replacing the accent-rail card; failed subagents follow the full-red failure tone.
 - Strip display sequences and control bytes (notably `\r` from progress writers like git) from collapsed-row text so command output cannot return the cursor to column 0 and overwrite the row.

package/README.md

@@ -21,21 +21,34 @@ Collapsed tool rows use semantic theme colors with no gear, background fill, box
 - **Quiet-turn grouping.** Sequential calls can join across an assistant row with no visible prose or thinking. Visible assistant content remains a boundary.
 - **MCP and self-rendered tools.** Their stable call labels, compact arguments, pending state, success, and first error line use the same collapsed shell. Native self-rendered details return when expanded.
 - **Images remain visible.** Image fallback text and terminal image components render below the corresponding marker with the same inset.
+- **User-run `!` bash blocks.** Execution display is owned here: user-typed commands trade Pi's green rules for the railed prompt shell (dark surface, status-colored rail) that submitted prompts use.
 - **Native expansion remains authoritative.** `Ctrl+O` restores Pi's full individual tool rendering, including complete results, custom renderers, and error details.
 
 ## Subagent plans
 
-A recognized `subagent` call renders as an unboxed plan in the shared tool aesthetic:
+A recognized `subagent` call renders as an unboxed plan in the shared tool aesthetic, marked with `&` instead of the ordinary `%` tool marker:
 
 ```text
-  % subagent chain (3 steps) [repo-review]
+  & subagent chain (3 steps) [repo-review]
     1. 🐝 bee [workhorse] Challenge the compatibility conclusion…
     2. 🐝 bee …
 ```
 
-Single calls stay on one `% subagent <agent> [profile] <task preview>` row; chain calls get a heading with the kind, count, and scope followed by numbered steps (parallel tasks list without numbers). Agent display names (emoji + name) are scraped from the native plan component with an args fallback, and render in `accent`; everything else stays muted, and failed subagents go full red. Subagents never join ordinary tool groups.
+Single calls stay on one `& subagent <agent> [profile] <task preview>` row; chain calls get a heading with the kind, count, and scope followed by numbered steps (parallel tasks list without numbers). Agent display names (emoji + name) are scraped from the native plan component with an args fallback, and render in `accent`; everything else stays muted, and failed subagents go full red. Subagents never join ordinary tool groups.
 
-Malformed, ambiguous, future, or too-narrow shapes fall back to the generic `% subagent …` collapsed row rather than dropping information, and `Ctrl+O` still exposes the native subagent renderer.
+Malformed, ambiguous, future, or too-narrow shapes fall back to the generic `& subagent …` collapsed row rather than dropping information, and `Ctrl+O` still exposes the native subagent renderer.
+
+## Edit diffs
+
+Settled `edit` calls keep their change visible without expanding: the call line gains a `+added/-removed` outcome stat, and the hunk renders as a bounded diff block underneath (`+` lines in the added tone, `-` in the removed tone, context muted, folded regions as `...`, capped at 12 lines with a count tail). The full native diff — line numbers, intra-line word highlights — still returns with `Ctrl+O`.
+
+Files and paths in collapsed rows are preserved as displayed by Pi: hyperlink-wrapped paths (Pi wraps `read` call paths in OSC 8 hyperlinks) keep their visible text when sanitized for one-line rows.
+
+## Scope boundary
+
+This package owns every **execution row** in the transcript: collapsed tool calls, tool grouping, subagent plans, thinking labels, and user-run `!` bash blocks (reshaped into the railed prompt shell). Transcript _surface_ layout — message insets, system-text and status-rule alignment, the editor surface, and the submitted-prompt shell for user messages — belongs to `@pi-kaush/pi-content-layout`, which never renders tool rows.
+
+One shared visual contract crosses the line: `!` blocks align with message text, so their inset mirrors `pi-content-layout`'s message `contentInset` (see `src/bash-block.ts`). Change indentation in both packages together.
 
 ## Bundled thinking-block extension
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-kaush/pi-tool-call-markers",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Compact and group Pi tool calls, with a bundled extension for adjacent thinking blocks.",
   "license": "MIT",
   "author": "Kaushik Gopal",

package/src/bash-block.ts

@@ -0,0 +1,289 @@
+import { BashExecutionComponent } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+type ThemeLike = {
+  bold(text: string): string;
+  fg(color: string, text: string): string;
+};
+
+const BASH_BLOCK_PATCHED = Symbol.for("kg.pi.bashBlock.v1");
+
+// The prompt surface uses a fixed near-black green tint instead of the
+// theme's selectedBg token so every user-input surface stays identical.
+const PROMPT_SURFACE_BG = "\x1b[48;2;7;19;18m"; // #071312
+const PROMPT_RAIL = "▎";
+
+// User-run bash blocks align with the message inset pi-content-layout
+// applies to transcript lines. Keep this in sync with that package's
+// contentInset (2 columns outside the rail for any width above 4); the
+// conversation surface has one shared visual contract even though the two
+// packages otherwise own disjoint components.
+function bashBlockInset(width: number): number {
+  return width > BASH_BLOCK_INSET * 2 ? BASH_BLOCK_INSET : 0;
+}
+const BASH_BLOCK_INSET = 2;
+
+const SGR_PATTERN = /\x1b\[([0-9;]*)m/g;
+const BACKGROUND_PATTERN =
+  /\x1b\[(?:4[0-8]|10[0-7]|48;5;\d{1,3}|48;2;\d{1,3};\d{1,3};\d{1,3})m/g;
+const DISPLAY_ANSI_PATTERN = /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+
+function semanticControlEnd(text: string, offset: number): number | undefined {
+  if (text[offset] !== "\x1b") return undefined;
+  const kind = text[offset + 1];
+  if (kind !== "]" && kind !== "_" && kind !== "P" && kind !== "^") {
+    return undefined;
+  }
+  for (let index = offset + 2; index < text.length; index++) {
+    if (text[index] === "\x07") return index + 1;
+    if (text[index] === "\x1b" && text[index + 1] === "\\") {
+      return index + 2;
+    }
+  }
+  return undefined;
+}
+
+function splitLeadingSemanticControls(line: string): {
+  controls: string;
+  content: string;
+} {
+  let offset = 0;
+  while (offset < line.length) {
+    const end = semanticControlEnd(line, offset);
+    if (end === undefined) break;
+    offset = end;
+  }
+  return { controls: line.slice(0, offset), content: line.slice(offset) };
+}
+
+function fitLine(line: string, width: number): string {
+  if (width <= 0) return "";
+  const clipped = truncateToWidth(line, width, "");
+  return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+
+function reapplyBackgroundAfterReset(
+  text: string,
+  backgroundAnsi: string,
+): string {
+  return text.replace(SGR_PATTERN, (sequence, rawParameters: string) => {
+    const parameters =
+      rawParameters === "" ? [0] : rawParameters.split(";").map(Number);
+    return parameters.includes(0) || parameters.includes(49)
+      ? `${sequence}${backgroundAnsi}`
+      : sequence;
+  });
+}
+
+function paintBackground(
+  line: string,
+  width: number,
+  backgroundAnsi: string,
+): string {
+  const fitted = fitLine(line, width);
+  // Mirrors Theme.bg: background, content, then a background-only reset.
+  return `${backgroundAnsi}${reapplyBackgroundAfterReset(fitted, backgroundAnsi)}\x1b[49m`;
+}
+
+function stripDisplayAnsi(text: string): string {
+  return text.replace(DISPLAY_ANSI_PATTERN, "");
+}
+
+function replaceBackground(text: string, backgroundAnsi: string): string {
+  return text.replace(BACKGROUND_PATTERN, backgroundAnsi);
+}
+
+// Renders lines inside a railed, dark-surfaced block (the submitted-prompt
+// shell): optional leading semantic controls stay outside the inset, the rail
+// is recolored, and content backgrounds are normalized to the prompt surface.
+function renderRailedBlockLines(
+  lines: string[],
+  width: number,
+  theme: ThemeLike,
+  inset: number,
+  railColor: string,
+): string[] {
+  const blockWidth = width - inset * 2;
+  if (inset === 0 || blockWidth <= visibleWidth(PROMPT_RAIL)) {
+    return lines.map((line) => fitLine(line, width));
+  }
+  const bodyWidth = blockWidth - visibleWidth(PROMPT_RAIL);
+  const margin = " ".repeat(inset);
+  return lines.map((line) => {
+    const { controls, content } = splitLeadingSemanticControls(line);
+    const recolored = replaceBackground(content, PROMPT_SURFACE_BG);
+    const rail = theme.fg(railColor, PROMPT_RAIL);
+    // One extra leading space inside the body, so submitted text sits two
+    // columns right of the rail instead of one.
+    const body = paintBackground(
+      ` ${fitLine(recolored, Math.max(1, bodyWidth - 1))}`,
+      bodyWidth,
+      PROMPT_SURFACE_BG,
+    );
+    return `${controls}${margin}${rail}${body}${margin}`;
+  });
+}
+
+const RULE_LINE_RE = /^─+$/;
+
+function isRuleLine(line: string | undefined): line is string {
+  return line !== undefined && RULE_LINE_RE.test(stripDisplayAnsi(line).trim());
+}
+
+// `!!` commands draw their rules dim instead of bashMode green, but the
+// component does not store that flag, so sniff the top rule's color to keep
+// the rail consistent with the framing it replaces.
+function sniffsDimRule(rule: string, theme: ThemeLike): boolean {
+  const prefixOf = (colored: string) => colored.slice(0, colored.indexOf("─"));
+  const dimPrefix = prefixOf(theme.fg("dim", "─"));
+  return (
+    dimPrefix.length > 0 &&
+    dimPrefix !== prefixOf(theme.fg("bashMode", "─")) &&
+    rule.startsWith(dimPrefix)
+  );
+}
+
+// Rail tone for a user bash block: failures read red and cancellations
+// yellow, matching the block's status text; anything else keeps the green
+// the rules used (dim for `!!` commands).
+function bashBlockRailColor(
+  status: string | undefined,
+  topRule: string | undefined,
+  theme: ThemeLike,
+): string {
+  if (status === "error") return "error";
+  if (status === "cancelled") return "warning";
+  if (topRule !== undefined && sniffsDimRule(topRule, theme)) return "dim";
+  return "bashMode";
+}
+
+// Reshapes BashExecutionComponent output into the submitted-prompt shell: the
+// leading spacer stays outside the block, the top/bottom rules are dropped,
+// and the remaining lines get one blank padded row at each end plus the rail
+// and dark surface.
+function renderBashBlockLines(
+  lines: string[],
+  width: number,
+  theme: ThemeLike,
+  status: string | undefined,
+  inset = bashBlockInset(width),
+): string[] {
+  const [spacer, ...rest] = lines;
+  const topRule = isRuleLine(rest[0]) ? rest[0] : undefined;
+  const inner = topRule !== undefined ? rest.slice(1) : rest.slice();
+  if (isRuleLine(inner[inner.length - 1])) inner.pop();
+  const railColor = bashBlockRailColor(status, topRule, theme);
+  const block = renderRailedBlockLines(
+    ["", ...inner, ""],
+    width,
+    theme,
+    inset,
+    railColor,
+  );
+  return [fitLine(spacer ?? "", width), ...block];
+}
+
+type BashRow = { status?: unknown };
+
+type BashBlockPatchState = {
+  theme?: ThemeLike;
+  cache: WeakMap<object, { width: number; src: string[]; lines: string[] }>;
+  originalRender: (width: number) => string[];
+  patchedRender?: (width: number) => string[];
+};
+
+// User-typed `!` commands are execution rows, so their presentation belongs
+// here with every other collapsed execution display; pi-content-layout stops
+// at the message surface. Pi's BashExecutionComponent already draws the
+// command, rules, and status; this patch reshapes that output into the
+// railed prompt shell and recolors the rail from the exit outcome.
+// TODO: Replace prototype patching with a public Pi rendering API when available.
+function installBashBlockPatch(): BashBlockPatchState | undefined {
+  try {
+    const proto = BashExecutionComponent?.prototype as unknown as BashRow & {
+      [BASH_BLOCK_PATCHED]?: BashBlockPatchState;
+      render?: (width: number) => string[];
+    };
+    if (!proto || typeof proto.render !== "function") return undefined;
+
+    const existing = proto[BASH_BLOCK_PATCHED];
+    if (existing) return existing;
+
+    const state: BashBlockPatchState = {
+      cache: new WeakMap(),
+      originalRender: proto.render,
+    };
+    const patchedRender = function renderWithBashBlockShell(
+      this: BashRow,
+      width: number,
+    ): string[] {
+      const theme = state.theme;
+      if (!theme) return state.originalRender.call(this, width);
+      const inset = bashBlockInset(width);
+      const bodyWidth = width - inset * 2 - visibleWidth(PROMPT_RAIL);
+      if (inset === 0 || bodyWidth < 8) {
+        return state.originalRender.call(this, width);
+      }
+      const lines = state.originalRender.call(this, Math.max(1, bodyWidth));
+      const entry = state.cache.get(this);
+      if (
+        entry &&
+        entry.width === width &&
+        entry.src.length === lines.length &&
+        entry.src.every((line, index) => line === lines[index])
+      ) {
+        return entry.lines;
+      }
+      const status = this.status;
+      const decorated = renderBashBlockLines(
+        lines,
+        width,
+        theme,
+        typeof status === "string" ? status : undefined,
+        inset,
+      );
+      state.cache.set(this, { width, src: lines, lines: decorated });
+      return decorated;
+    };
+
+    try {
+      state.patchedRender = patchedRender;
+      proto.render = patchedRender;
+      Object.defineProperty(proto, BASH_BLOCK_PATCHED, {
+        configurable: true,
+        value: state,
+      });
+    } catch {
+      proto.render = state.originalRender;
+      return undefined;
+    }
+    return state;
+  } catch {
+    // Pi internals can change across versions; fail silently.
+    return undefined;
+  }
+}
+
+function uninstallBashBlockPatch(state: BashBlockPatchState | undefined): void {
+  if (!state) return;
+  const proto = BashExecutionComponent?.prototype as unknown as BashRow & {
+    [BASH_BLOCK_PATCHED]?: BashBlockPatchState;
+    render?: (width: number) => string[];
+  };
+  if (
+    proto[BASH_BLOCK_PATCHED] !== state ||
+    proto.render !== state.patchedRender
+  ) {
+    return;
+  }
+  proto.render = state.originalRender;
+  delete proto[BASH_BLOCK_PATCHED];
+}
+
+export {
+  PROMPT_RAIL,
+  PROMPT_SURFACE_BG,
+  installBashBlockPatch,
+  uninstallBashBlockPatch,
+};
+export type { BashBlockPatchState };

package/src/index.ts

@@ -10,10 +10,15 @@ import {
   visibleWidth,
   wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
+import {
+  installBashBlockPatch,
+  uninstallBashBlockPatch,
+} from "./bash-block.ts";
 import { runChatContainerHooks } from "./container-hooks.ts";
 
 const OUTER_INSET = 2;
 const GROUP_MARKER = "%";
+const SUBAGENT_MARKER = "&";
 const PRESENTATION_PATCHED = Symbol.for("kg.pi.toolPresentation.v3");
 const LEGACY_PRESENTATION_PATCHED = Symbol.for("kg.pi.toolPresentation.v2");
 const GROUPING_PATCHED = Symbol.for("kg.pi.toolGrouping.v1");
@@ -61,6 +66,7 @@ type PresentationPatchState = {
   theme?: ThemeLike;
   collapseParallel: boolean;
   groupCache: WeakMap<ToolExecutionRow, GroupRenderCache>;
+  collapsedCache: WeakMap<ToolExecutionRow, CollapsedRenderCache>;
   rowVersions: WeakMap<ToolExecutionRow, number>;
   rowGroups: WeakMap<ToolExecutionRow, ToolExecutionRow[]>;
   rowSignatures: WeakMap<ToolExecutionRow, string>;
@@ -85,6 +91,14 @@ type GroupRenderCache = {
   width: number;
 };
 
+type CollapsedRenderCache = {
+  lines: string[];
+  signature: string;
+  version: number;
+  themeSample: string;
+  width: number;
+};
+
 function envEnabled(name: string, defaultValue: boolean): boolean {
   const value = process.env[name]?.trim().toLowerCase();
   if (!value) return defaultValue;
@@ -104,9 +118,13 @@ function stripAnsi(text: string): string {
 // and overwrite the row's own marker.
 const INLINE_CONTROL_RE = /[\x00-\x08\x0b-\x1f\x7f]/g;
 // OSC first: the two-byte alternative would otherwise consume `\x1b]` and
-// leave the hyperlink payload behind as visible text.
+// leave the hyperlink payload behind as visible text. OSC sequences (OSC 8
+// hyperlinks, titles) end at their first BEL/ST terminator; a payload match
+// must stop there too, because the visible text sits BETWEEN two OSC
+// sequences — Pi wraps read paths as `ESC]8;;url ESC\ <path> ESC]8;; ESC\`,
+// and a greedy `[^\x07]*` would swallow that path along with the sequences.
 const DISPLAY_ANSI_RE =
-  /\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/g;
+  /\x1b(?:\][^\x07\x1b]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/g;
 
 function sanitizeInline(text: string): string {
   return text.replace(DISPLAY_ANSI_RE, "").replace(INLINE_CONTROL_RE, " ");
@@ -116,6 +134,33 @@ function hasVisibleContent(line: string): boolean {
   return stripAnsi(line).trim().length > 0;
 }
 
+// State-transition fingerprint used by both the updateDisplay version bump
+// and the settled-row render cache. It deliberately covers only shape
+// transitions (partial/expanded/result/error): while a row is partial its
+// content streams and it is never cached, and once settled the rendered
+// content is fully determined by this fingerprint + width + theme.
+function rowSignatureOf(row: ToolExecutionRow): string {
+  return `${row.isPartial}|${row.expanded}|${row.result ? 1 : 0}|${row.result?.isError ? 1 : 0}`;
+}
+
+// Theme samples are five theme.fg calls; computing them per row per frame
+// would reintroduce the per-keystroke cost the render caches remove, so
+// cache by theme object identity (a theme switch swaps the object).
+const themeSamples = new WeakMap<ThemeLike, string>();
+function themeSampleFor(theme: ThemeLike): string {
+  let sample = themeSamples.get(theme);
+  if (!sample) {
+    sample =
+      theme.fg("toolTitle", "x") +
+      theme.fg("muted", "x") +
+      theme.fg("dim", "x") +
+      theme.fg("warning", "x") +
+      theme.fg("error", "x");
+    themeSamples.set(theme, sample);
+  }
+  return sample;
+}
+
 type InsetLayout = {
   contentWidth: number;
   left: number;
@@ -556,6 +601,64 @@ function diffCounts(diff: string): { added: number; removed: number } {
   return { added, removed };
 }
 
+// Pi's edit tool (renderShell "self") stores its display diff in
+// result.details.diff — lines like `+27 <content>`, `-27 <content>`,
+// ` 28 <context>`, plus `...` for folded regions. Self-rendered rows
+// normally keep only their one-line call label; edits additionally show
+// the change as a bounded diff block under the summary and a +a/-b stat in
+// the outcome tail, so the hunk stays visible without Ctrl+O while
+// expanded rows keep Pi's native rendering.
+const EDIT_DIFF_LINE_RE = /^([+\-\s])(\s*\d*)(.*)$/;
+const MAX_EDIT_DIFF_LINES = 12;
+
+function editDiffText(row: ToolExecutionRow): string | undefined {
+  if (row.toolName !== "edit") return undefined;
+  if (!row.result || row.isPartial !== false || rowHasFailed(row))
+    return undefined;
+  const diff = row.result.details?.diff;
+  return typeof diff === "string" && diff.length > 0 ? diff : undefined;
+}
+
+function renderedEditDiffStat(row: ToolExecutionRow): string | undefined {
+  const diff = editDiffText(row);
+  if (diff === undefined) return undefined;
+  const { added, removed } = diffCounts(diff);
+  return added + removed === 0 ? "applied" : `+${added}/-${removed}`;
+}
+
+function renderedEditDiffLines(
+  row: ToolExecutionRow,
+  theme: ThemeLike,
+): string[] {
+  const diff = editDiffText(row);
+  if (diff === undefined) return [];
+  const raw = diff.split("\n");
+  if (raw[raw.length - 1] === "") raw.pop();
+  const lines: string[] = [];
+  for (const line of raw.slice(0, MAX_EDIT_DIFF_LINES)) {
+    const clean = sanitizeInline(line).trimEnd();
+    if (clean.trim() === "...") {
+      lines.push(theme.fg("muted", "  ..."));
+      continue;
+    }
+    const match = EDIT_DIFF_LINE_RE.exec(clean);
+    if (!match) continue;
+    const color =
+      match[1] === "+"
+        ? "toolDiffAdded"
+        : match[1] === "-"
+          ? "toolDiffRemoved"
+          : "toolDiffContext";
+    lines.push(theme.fg(color, `  ${match[1]}${match[2]}${match[3]}`));
+  }
+  if (raw.length > MAX_EDIT_DIFF_LINES) {
+    lines.push(
+      theme.fg("muted", `  ... +${raw.length - MAX_EDIT_DIFF_LINES} more`),
+    );
+  }
+  return lines;
+}
+
 function outcomeSummary(row: ToolExecutionRow): string | undefined {
   // Self-rendered tools own their result framing; the built-in heuristics
   // (line counts, diff stats) describe default-shell rows only, so their
@@ -796,7 +899,11 @@ function collapsedOutcome(
     const elapsed = liveElapsedText(row);
     return theme.fg("warning", elapsed ? `… · ${elapsed}` : "…");
   }
-  if (row.getRenderShell?.() === "self") return renderedGenericOutcome(theme);
+  if (row.getRenderShell?.() === "self") {
+    const editStat = renderedEditDiffStat(row);
+    if (editStat) return theme.fg("muted", `→ ${editStat}`);
+    return renderedGenericOutcome(theme);
+  }
   return renderedOutcome(row, theme);
 }
 
@@ -808,7 +915,10 @@ function collapsedHeadline(
   // Failed rows render entirely in error so the row reads as the one that
   // failed, not just its outcome tail. Only the tool name is bold.
   const color = rowHasFailed(row) ? "error" : "muted";
-  const marker = `${theme.fg(color, GROUP_MARKER)} `;
+  const marker = `${theme.fg(
+    color,
+    row.toolName === "subagent" ? SUBAGENT_MARKER : GROUP_MARKER,
+  )} `;
   const budget = Math.max(1, width - visibleWidth(marker));
   const label = collapsedCallLabel(row, budget, theme, color);
   const outcome = collapsedOutcome(row, budget, theme);
@@ -971,7 +1081,7 @@ function renderSubagentPlan(
       `${step.profile ? ` [${sanitizeInline(step.profile)}]` : ""} ${subagentStepPreview(step.task)}`,
     );
 
-  const marker = `${theme.fg(color, theme.bold(GROUP_MARKER))} `;
+  const marker = `${theme.fg(color, theme.bold(SUBAGENT_MARKER))} `;
   const budget = Math.max(1, width - visibleWidth(marker));
   const outcome = failed
     ? collapsedOutcome(row, budget, theme)
@@ -1066,6 +1176,9 @@ function renderCollapsedToolRow(
       ? renderSubagentPlan(row, layout.contentWidth, theme)
       : undefined;
   const body = plan ?? [collapsedHeadline(row, layout.contentWidth, theme)];
+  if (row.toolName === "edit") {
+    body.push(...renderedEditDiffLines(row, theme));
+  }
   body.push(...imageResultLines(row, layout.contentWidth, theme));
   return ["", ...insetLines(body, width)];
 }
@@ -1077,8 +1190,12 @@ function groupedCallComponent(
   return {
     render(width: number): string[] {
       // Every member renders like a singleton — `% tool: call → outcome` per
-      // line with the tool name bolded — no bullets or internal blanks.
-      return rows.map((row) => collapsedHeadline(row, width, theme));
+      // line with the tool name bolded — no bullets or internal blanks;
+      // settled edits keep their change visible with a bounded diff block.
+      return rows.flatMap((row) => [
+        collapsedHeadline(row, width, theme),
+        ...(row.toolName === "edit" ? renderedEditDiffLines(row, theme) : []),
+      ]);
     },
     invalidate() {},
   };
@@ -1115,12 +1232,7 @@ function renderGroupedToolRows(
 ): string[] {
   const theme = state.theme;
   if (!theme) return state.originalRender.call(row, width);
-  const themeSample =
-    theme.fg("toolTitle", "x") +
-    theme.fg("muted", "x") +
-    theme.fg("dim", "x") +
-    theme.fg("warning", "x") +
-    theme.fg("error", "x");
+  const themeSample = themeSampleFor(theme);
   const cached = state.groupCache.get(row);
   const hasLiveMembers = rows.some(isLiveRow);
   if (
@@ -1330,6 +1442,7 @@ function installPresentationPatch(): PresentationPatchState | undefined {
     const state: PresentationPatchState = {
       collapseParallel: envEnabled(COLLAPSE_PARALLEL_ENV, true),
       groupCache: new WeakMap(),
+      collapsedCache: new WeakMap(),
       rowVersions: new WeakMap(),
       rowGroups: new WeakMap(),
       rowSignatures: new WeakMap(),
@@ -1342,7 +1455,7 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       // Group members always bump so their leader's cache refreshes; other
       // rows only bump on state transitions, so bash's per-second invalidate
       // ticks and resize invalidations stop busting caches.
-      const signature = `${this.isPartial}|${this.expanded}|${this.result ? 1 : 0}|${this.result?.isError ? 1 : 0}`;
+      const signature = rowSignatureOf(this);
       if (
         state.rowGroups.has(this) ||
         state.rowSignatures.get(this) !== signature
@@ -1357,18 +1470,72 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       this: ToolExecutionRow,
       width: number,
     ): string[] {
-      const lines = state.originalRender.call(this, width);
+      const theme = state.theme;
       if (
         typeof this.expanded !== "boolean" ||
         typeof this.isPartial !== "boolean" ||
         this.expanded ||
-        !state.theme ||
-        (lines.length === 0 && (this.imageComponents?.length ?? 0) === 0)
+        !theme
       ) {
+        return state.originalRender.call(this, width);
+      }
+
+      // ================================================================
+      // Settled-row render cache — PLEASE DO NOT REMOVE THIS FAST PATH.
+      // ================================================================
+      // Pi's TUI re-renders the whole transcript on every keystroke, and
+      // the collapsed-row decoration below rebuilds strings for every row
+      // it touches. On a long session (~1,000 messages, hundreds of tool
+      // rows) that measured at ~80 ms per keystroke — visible input lag.
+      //
+      // Settled rows (not partial, not expanded) have fully static render
+      // output, so their collapsed lines are cached keyed by width +
+      // rowSignatureOf + rowVersions + theme sample. updateDisplay bumps
+      // rowVersions on every real state transition, and partial rows
+      // bypass the cache entirely because their content streams. This
+      // mirrors the existing groupCache discipline; keep them in sync.
+      // ================================================================
+      if (!this.isPartial) {
+        const signature = rowSignatureOf(this);
+        const version = state.rowVersions.get(this) ?? 0;
+        const themeSample = themeSampleFor(theme);
+        const cached = state.collapsedCache.get(this);
+        if (
+          cached &&
+          cached.width === width &&
+          cached.signature === signature &&
+          cached.version === version &&
+          cached.themeSample === themeSample
+        ) {
+          return cached.lines;
+        }
+        const lines = state.originalRender.call(this, width);
+        if (lines.length === 0 && (this.imageComponents?.length ?? 0) === 0) {
+          return lines;
+        }
+        try {
+          const collapsed = renderCollapsedToolRow(this, width, theme);
+          state.collapsedCache.set(this, {
+            lines: collapsed,
+            signature,
+            version,
+            themeSample,
+            width,
+          });
+          return collapsed;
+        } catch {
+          return lines;
+        }
+      }
+
+      // Partial (streaming) rows keep the collapsed presentation but are
+      // never cached: their content changes with every streamed chunk.
+      const lines = state.originalRender.call(this, width);
+      if (lines.length === 0 && (this.imageComponents?.length ?? 0) === 0) {
         return lines;
       }
       try {
-        return renderCollapsedToolRow(this, width, state.theme);
+        return renderCollapsedToolRow(this, width, theme);
       } catch {
         return lines;
       }
@@ -1420,14 +1587,17 @@ function uninstallPresentationPatch(
 export default function (pi: ExtensionAPI) {
   const patch = installPresentationPatch();
   const grouping = patch ? installGroupingPatch(patch) : undefined;
+  const bashPatch = installBashBlockPatch();
 
   pi.on("session_start", (_event, ctx) => {
     if (patch) patch.theme = ctx.ui.theme;
+    if (bashPatch) bashPatch.theme = ctx.ui.theme;
     ctx.ui.setToolsExpanded(false);
   });
 
   pi.on("session_shutdown", () => {
     uninstallGroupingPatch(grouping);
     uninstallPresentationPatch(patch);
+    uninstallBashBlockPatch(bashPatch);
   });
 }

package/src/thinking-block-merger.ts

@@ -5,6 +5,176 @@ const THINKING_GROUPING_PATCHED = Symbol.for("kg.pi.thinkingGrouping.v1");
 const PI_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 const SPINNER_INTERVAL_MS = 80;
 
+// Visual experiment for the settled "+ Thought" label. "inherit" keeps Pi's
+// native styling (italic + thinkingText); "gray" sits halfway between the
+// muted and text theme colors. The env var overrides the default so the
+// variants can be compared without editing code or republishing.
+const THOUGHT_LABEL_COLOR_ENV = "PI_TOOL_CALL_MARKERS_THOUGHT_COLOR";
+type ThoughtLabelColor = "inherit" | "orange" | "gray";
+const DEFAULT_THOUGHT_LABEL_COLOR: ThoughtLabelColor = "orange";
+// cobalt2's orange token (#ffb86c).
+const THOUGHT_LABEL_ORANGE = { r: 255, g: 184, b: 108 };
+
+function thoughtLabelColorChoice(): ThoughtLabelColor {
+  const raw = process.env[THOUGHT_LABEL_COLOR_ENV];
+  return raw === "inherit" || raw === "orange" || raw === "gray"
+    ? raw
+    : DEFAULT_THOUGHT_LABEL_COLOR;
+}
+
+const CUBE_VALUES = [0, 95, 135, 175, 215, 255];
+const BASIC_ANSI_RGB: Array<[number, string] | undefined> = [
+  [0, "#000000"],
+  [1, "#800000"],
+  [2, "#008000"],
+  [3, "#808000"],
+  [4, "#000080"],
+  [5, "#800080"],
+  [6, "#008080"],
+  [7, "#c0c0c0"],
+  [8, "#808080"],
+  [9, "#ff0000"],
+  [10, "#00ff00"],
+  [11, "#ffff00"],
+  [12, "#0000ff"],
+  [13, "#ff00ff"],
+  [14, "#00ffff"],
+  [15, "#ffffff"],
+];
+
+type Rgb = { r: number; g: number; b: number };
+
+type ThemeDetail = {
+  fg(color: string, text: string): string;
+  getFgAnsi?(color: string): string;
+  getColorMode?(): "truecolor" | "256color" | string;
+};
+
+let activeTheme: ThemeDetail | undefined;
+
+function hexToRgb(hex: string): Rgb | undefined {
+  const match = /^#([0-9a-f]{6})$/i.exec(hex.trim());
+  if (!match) return undefined;
+  const value = parseInt(match[1]!, 16);
+  return { r: value >> 16, g: (value >> 8) & 255, b: value & 255 };
+}
+
+// Mirrors Pi's own mapping so a named color can round-trip through a
+// 256-color terminal (e.g. when COLORFGBG forces 256color mode).
+function ansi256ToRgb(index: number): Rgb | undefined {
+  if (index < 16) {
+    const hex = BASIC_ANSI_RGB[index]?.[1];
+    return hex ? hexToRgb(hex) : undefined;
+  }
+  if (index < 232) {
+    const cube = index - 16;
+    const channel = (n: number) => (n === 0 ? 0 : 55 + n * 40);
+    return {
+      r: channel(Math.floor(cube / 36)),
+      g: channel(Math.floor((cube % 36) / 6)),
+      b: channel(cube % 6),
+    };
+  }
+  const gray = 8 + (index - 232) * 10;
+  return { r: gray, g: gray, b: gray };
+}
+
+function rgbToAnsi256({ r, g, b }: Rgb): number {
+  const nearest = (value: number) =>
+    CUBE_VALUES.reduce(
+      (best, candidate) =>
+        Math.abs(candidate - value) < Math.abs(best - value) ? candidate : best,
+      0,
+    );
+  const cubeR = nearest(r);
+  const cubeG = nearest(g);
+  const cubeB = nearest(b);
+  const cubeDistance =
+    (r - cubeR) ** 2 * 0.299 +
+    (g - cubeG) ** 2 * 0.587 +
+    (b - cubeB) ** 2 * 0.114;
+  const luminance = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+  const grayStep = Math.max(0, Math.min(23, Math.round((luminance - 8) / 10)));
+  const grayValue = 8 + grayStep * 10;
+  const grayDistance = (luminance - grayValue) ** 2;
+  const spread = Math.max(r, g, b) - Math.min(r, g, b);
+  if (spread < 10 && grayDistance < cubeDistance) return 232 + grayStep;
+  return (
+    16 +
+    36 * CUBE_VALUES.indexOf(cubeR) +
+    6 * CUBE_VALUES.indexOf(cubeG) +
+    CUBE_VALUES.indexOf(cubeB)
+  );
+}
+
+function parseAnsiFgRgb(ansi: string): Rgb | undefined {
+  if (/^\x1b\[39m$/.test(ansi)) return undefined;
+  const truecolor = /^\x1b\[38;2;(\d+);(\d+);(\d+)m$/.exec(ansi);
+  if (truecolor) {
+    return {
+      r: Number(truecolor[1]),
+      g: Number(truecolor[2]),
+      b: Number(truecolor[3]),
+    };
+  }
+  const indexed = /^\x1b\[38;5;(\d+)m$/.exec(ansi);
+  if (indexed) return ansi256ToRgb(Number(indexed[1]));
+  const basic = /^\x1b\[(9[0-7]|3[0-7])m$/.exec(ansi);
+  if (basic) {
+    const code = Number(basic[1]);
+    return ansi256ToRgb(code >= 90 ? code - 90 + 8 : code - 30);
+  }
+  return undefined;
+}
+
+function fgRgbAnsi({ r, g, b }: Rgb): string {
+  if (activeTheme?.getColorMode?.() === "256color") {
+    return `\x1b[38;5;${rgbToAnsi256({ r, g, b })}m`;
+  }
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+function midpointRgb(a: Rgb, b: Rgb): Rgb {
+  return {
+    r: Math.round((a.r + b.r) / 2),
+    g: Math.round((a.g + b.g) / 2),
+    b: Math.round((a.b + b.b) / 2),
+  };
+}
+
+let thoughtLabelPrefix = "";
+let thoughtLabelSuffix = "";
+
+function updateThoughtLabelStyle(): void {
+  thoughtLabelPrefix = "";
+  thoughtLabelSuffix = "";
+  const choice = thoughtLabelColorChoice();
+  if (choice === "inherit" || !activeTheme) return;
+
+  let rgb: Rgb | undefined;
+  if (choice === "orange") {
+    rgb = THOUGHT_LABEL_ORANGE;
+  } else if (activeTheme.getFgAnsi) {
+    const muted = parseAnsiFgRgb(activeTheme.getFgAnsi("muted"));
+    const text = parseAnsiFgRgb(activeTheme.getFgAnsi("text"));
+    if (muted && text) rgb = midpointRgb(muted, text);
+  }
+  if (!rgb) return;
+
+  // The styled label replaces Pi's italicized Text node wholesale (see
+  // restyleHiddenThinkingLabel). The leading italic-off still matters: the
+  // TUI's diff renderer can skip bytes shared with the previously drawn
+  // italic line, leaving the terminal in italic state otherwise.
+  thoughtLabelPrefix = `\x1b[23m${fgRgbAnsi(rgb)}`;
+  thoughtLabelSuffix = "\x1b[39m";
+}
+
+export function visibleThoughtLabel(label: string): string {
+  if (!thoughtLabelPrefix) return label;
+  const raw = label.replace(/\x1b\[[0-9;]*m/g, "");
+  return `${thoughtLabelPrefix}${raw}${thoughtLabelSuffix}`;
+}
+
 type AssistantMessageLike = {
   content?: unknown[];
 };
@@ -12,9 +182,46 @@ type AssistantMessageLike = {
 type AssistantMessageRow = {
   hiddenThinkingLabel?: unknown;
   hideThinkingBlock?: unknown;
+  contentContainer?: { children?: unknown[] };
   updateContent(message: AssistantMessageLike, ...args: unknown[]): void;
 };
 
+type TextLikeChild = {
+  text?: unknown;
+  setText?(text: string): void;
+};
+
+// Pi renders the hidden-thinking label as an italic Text node built from the
+// plain label field. Embedding style codes in the field itself is not
+// enough: the TUI diff renderer reuses the byte prefix shared with the
+// previous (italic) frame, so an in-line italic reset may never reach the
+// terminal. Swap the node's text for a self-contained styled version after
+// each native render pass instead.
+function restyleHiddenThinkingLabel(row: AssistantMessageRow): void {
+  if (!thoughtLabelPrefix) return;
+  if (
+    row.hideThinkingBlock !== true ||
+    typeof row.hiddenThinkingLabel !== "string"
+  ) {
+    return;
+  }
+  const label = row.hiddenThinkingLabel;
+  const children = row.contentContainer?.children;
+  if (!Array.isArray(children)) return;
+  const styled = visibleThoughtLabel(label);
+  for (const child of children) {
+    const textChild = child as TextLikeChild | undefined;
+    if (
+      typeof textChild?.text !== "string" ||
+      typeof textChild.setText !== "function" ||
+      !textChild.text.includes(label)
+    ) {
+      continue;
+    }
+    textChild.setText(styled);
+  }
+}
+
 type ThinkingTiming = {
   finishedAt?: number;
   startedAt: number;
@@ -186,6 +393,11 @@ function installThinkingGroupingPatch():
         // Preserve Pi's native label if its private row shape changes.
       }
       Reflect.apply(state.originalUpdateContent, this, [combined, ...args]);
+      try {
+        restyleHiddenThinkingLabel(this);
+      } catch {
+        // Keep Pi's native label styling if the row shape changes.
+      }
     };
 
     state.patchedUpdateContent = patchedUpdateContent;
@@ -224,5 +436,15 @@ function uninstallThinkingGroupingPatch(
 
 export default function (pi: ExtensionAPI) {
   const patch = installThinkingGroupingPatch();
-  pi.on("session_shutdown", () => uninstallThinkingGroupingPatch(patch));
+  pi.on("session_start", (_event, ctx) => {
+    if (ctx.mode !== "tui") return;
+    activeTheme = ctx.ui.theme as unknown as ThemeDetail;
+    updateThoughtLabelStyle();
+  });
+  pi.on("session_shutdown", () => {
+    activeTheme = undefined;
+    thoughtLabelPrefix = "";
+    thoughtLabelSuffix = "";
+    uninstallThinkingGroupingPatch(patch);
+  });
 }