@pi-kaush/pi-tool-call-markers 0.2.8 → 0.2.10

package/src/index.ts

@@ -10,10 +10,16 @@ import {
   visibleWidth,
   wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
+import {
+  installBashBlockPatch,
+  uninstallBashBlockPatch,
+} from "./bash-block.ts";
 import { runChatContainerHooks } from "./container-hooks.ts";
+import { installInfoVisibility } from "./info-visibility.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");
@@ -58,13 +64,13 @@ type ToolExecutionRow = {
 };
 
 type PresentationPatchState = {
+  owners: number;
   theme?: ThemeLike;
   collapseParallel: boolean;
   groupCache: WeakMap<ToolExecutionRow, GroupRenderCache>;
   collapsedCache: WeakMap<ToolExecutionRow, CollapsedRenderCache>;
   rowVersions: WeakMap<ToolExecutionRow, number>;
   rowGroups: WeakMap<ToolExecutionRow, ToolExecutionRow[]>;
-  rowSignatures: WeakMap<ToolExecutionRow, string>;
   originalRender: (width: number) => string[];
   originalUpdateDisplay: () => void;
   patchedRender?: (width: number) => string[];
@@ -72,6 +78,7 @@ type PresentationPatchState = {
 };
 
 type GroupingPatchState = {
+  owners: number;
   presentation: PresentationPatchState;
   originalRender: (width: number) => string[];
   patchedRender?: (width: number) => string[];
@@ -106,16 +113,19 @@ function stripAnsi(text: string): string {
   return text.replace(ANSI_RE, "");
 }
 
-// Command output can carry cursor-moving control bytes (git progress writes
-// \r) and raw terminal sequences. Collapsed rows are single-line, so result
-// and scraped text is stripped of display sequences and control bytes before
-// it can reach a row; a bare \r would otherwise return the cursor to column 0
-// and overwrite the row's own marker.
-const INLINE_CONTROL_RE = /[\x00-\x08\x0b-\x1f\x7f]/g;
+// Command output can carry cursor-moving control bytes, raw terminal
+// sequences, line feeds, and tabs. Collapsed rows are single-line, so result
+// and scraped text is stripped of display sequences and all C0 controls before
+// it can reach a row; otherwise control bytes could split or overwrite it.
+const INLINE_CONTROL_RE = /[\x00-\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, " ");
@@ -125,11 +135,9 @@ 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.
+// Shape fingerprint used in settled-row cache keys. It protects against
+// direct state mutation followed by render without updateDisplay; real
+// component display updates invalidate the cache through rowVersions.
 function rowSignatureOf(row: ToolExecutionRow): string {
   return `${row.isPartial}|${row.expanded}|${row.result ? 1 : 0}|${row.result?.isError ? 1 : 0}`;
 }
@@ -244,7 +252,7 @@ function capFailureTail(tail: string, cap: number, theme: ThemeLike): string {
 }
 
 function renderedGenericOutcome(theme: ThemeLike): string {
-  return theme.fg("muted", "→ done");
+  return theme.fg("toolOutput", "→ done");
 }
 
 // The MCP adapter stashes its call's first line in renderer state before
@@ -592,6 +600,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
@@ -640,7 +706,7 @@ function renderedOutcome(
 ): string | undefined {
   const summary = outcomeSummary(row);
   if (!summary) return undefined;
-  return theme.fg("muted", `→ ${summary}`);
+  return theme.fg("toolOutput", `→ ${summary}`);
 }
 
 function renderedGroupedOutcome(
@@ -780,7 +846,7 @@ function renderedCallSummary(
 
   const fallback = compactArgs(row.args);
   return fallback
-    ? theme.fg("muted", fallback)
+    ? theme.fg("toolOutput", fallback)
     : theme.fg("muted", "(no arguments)");
 }
 
@@ -793,9 +859,13 @@ function styledCallLabel(
   const match = /^(\S+)(.*)$/s.exec(plain);
   if (!match) return theme.fg(color, plain);
   const rest = match[2] ?? "";
+  // Failed rows stay uniformly error-colored; settled rows use Pi's native
+  // split — toolTitle for the name, toolOutput for the call content.
+  const nameColor = color === "muted" ? "toolTitle" : color;
+  const restColor = color === "muted" ? "toolOutput" : color;
   return (
-    theme.fg(color, theme.bold(match[1] ?? "")) +
-    (rest ? theme.fg(color, `:${rest}`) : "")
+    theme.fg(nameColor, theme.bold(match[1] ?? "")) +
+    (rest ? theme.fg(restColor, `:${rest}`) : "")
   );
 }
 
@@ -832,7 +902,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("toolOutput", `→ ${editStat}`);
+    return renderedGenericOutcome(theme);
+  }
   return renderedOutcome(row, theme);
 }
 
@@ -844,7 +918,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);
@@ -980,6 +1057,33 @@ function subagentStepPreview(task: string): string {
   return clean.length > 40 ? `${clean.slice(0, 40)}...` : clean;
 }
 
+// Partial and final subagent results both carry per-task usage in details
+// (the subagent extension streams makeDetails snapshots through onUpdate), so
+// this works live and settled. Surface the smallest useful progress — total
+// turns, and the model when every task resolved to the same one.
+function subagentProgressText(row: ToolExecutionRow): string | undefined {
+  const results = row.result?.details?.results;
+  if (!Array.isArray(results) || results.length === 0) return undefined;
+  let turns = 0;
+  const models = new Set<string>();
+  for (const result of results) {
+    if (!isRecord(result)) continue;
+    const usage = result.usage;
+    const turnCount = isRecord(usage) ? usage.turns : undefined;
+    if (typeof turnCount === "number" && Number.isFinite(turnCount)) {
+      turns += turnCount;
+    }
+    const model = result.model ?? result.requestedModel;
+    if (typeof model === "string" && model.trim().length > 0) {
+      models.add(model.trim());
+    }
+  }
+  const parts: string[] = [];
+  if (turns > 0) parts.push(`${turns} turn${turns === 1 ? "" : "s"}`);
+  if (models.size === 1) parts.push(sanitizeInline([...models][0]!));
+  return parts.length > 0 ? parts.join(" · ") : undefined;
+}
+
 // Subagents render as an ordinary unboxed tool block: a `%` heading with the
 // plan kind/count/scope, then the numbered chain steps or parallel tasks with
 // agent names in accent. Everything else stays muted (or error on failure),
@@ -1001,20 +1105,22 @@ function renderSubagentPlan(
   // other collapsed-row text so control bytes cannot reach the terminal.
   const displayOf = (agent: string) =>
     theme.fg(nameColor, displayNames.get(agent) ?? sanitizeInline(agent));
+  const detailColor = failed ? "error" : "toolOutput";
   const detailOf = (step: SubagentStep) =>
     theme.fg(
-      color,
+      detailColor,
       `${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 progress = subagentProgressText(row);
   const outcome = failed
     ? collapsedOutcome(row, budget, theme)
     : isLiveRow(row)
-      ? collapsedOutcome(row, budget, theme)
+      ? theme.fg("warning", progress ? `→ ${progress}` : "…")
       : row.result
-        ? renderedGenericOutcome(theme)
+        ? theme.fg("toolOutput", progress ? `→ ${progress}` : "→ done")
         : theme.fg("warning", "…");
   const headline = (label: string) =>
     marker +
@@ -1026,7 +1132,7 @@ function renderSubagentPlan(
     const step = plan.steps[0]!;
     return [
       headline(
-        theme.fg(color, theme.bold("subagent")) +
+        theme.fg(failed ? "error" : "toolTitle", theme.bold("subagent")) +
           " " +
           displayOf(step.agent) +
           detailOf(step),
@@ -1040,10 +1146,10 @@ function renderSubagentPlan(
       : `parallel (${plan.steps.length} tasks)`;
   const lines = [
     headline(
-      theme.fg(color, theme.bold("subagent")) +
+      theme.fg(failed ? "error" : "toolTitle", theme.bold("subagent")) +
         " " +
-        theme.fg(color, kindLabel) +
-        theme.fg(color, ` [${plan.scope}]`),
+        theme.fg(failed ? "error" : "toolOutput", kindLabel) +
+        theme.fg(failed ? "error" : "toolOutput", ` [${plan.scope}]`),
     ),
   ];
   const shown = plan.steps.slice(0, 3);
@@ -1102,22 +1208,71 @@ 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)];
 }
 
-function groupedCallComponent(
+function groupedChildLabel(
+  row: ToolExecutionRow,
+  width: number,
+  theme: ThemeLike,
+  color: string = "muted",
+): string {
+  const label = collapsedCallLabel(row, width, theme, color);
+  const plain = stripAnsi(label);
+  const toolName = row.toolName ?? "tool";
+  let prefix = "";
+  if (plain === toolName) {
+    prefix = toolName;
+  } else if (plain.startsWith(`${toolName}:`)) {
+    const whitespace = /^\s*/.exec(plain.slice(toolName.length + 1))?.[0] ?? "";
+    prefix = `${toolName}:${whitespace}`;
+  }
+  const prefixWidth = visibleWidth(prefix);
+  const child = sliceByColumn(
+    label,
+    prefixWidth,
+    Math.max(0, visibleWidth(label) - prefixWidth),
+    true,
+  );
+  return child || theme.fg(color, "(no arguments)");
+}
+
+function renderGroupedCallLines(
   rows: ToolExecutionRow[],
+  width: number,
   theme: ThemeLike,
-): ComponentLike {
-  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));
-    },
-    invalidate() {},
-  };
+): string[] {
+  const lines: string[] = [];
+  let previousToolName: string | undefined;
+  for (const row of rows) {
+    const toolName = row.toolName ?? "tool";
+    if (toolName !== previousToolName) {
+      lines.push(
+        `${theme.fg("muted", GROUP_MARKER)} ${theme.fg("toolTitle", theme.bold(toolName))}`,
+      );
+      previousToolName = toolName;
+    }
+
+    const color = rowHasFailed(row) ? "error" : "muted";
+    const prefix = `  ${theme.fg(color, "•")} `;
+    const budget = Math.max(1, width - visibleWidth(prefix));
+    const label = groupedChildLabel(row, budget, theme, color);
+    const outcome = collapsedOutcome(row, budget, theme);
+    const suffix = theme.fg(color, "…");
+    lines.push(
+      prefix +
+        (outcome
+          ? fitSummaryTail(label, outcome, budget, suffix)
+          : fitSummary(label, budget, suffix)),
+    );
+    if (row.toolName === "edit")
+      lines.push(...renderedEditDiffLines(row, theme));
+  }
+  return lines;
 }
 
 function sameMembers(
@@ -1166,8 +1321,8 @@ function renderGroupedToolRows(
   }
 
   const layout = insetLayout(width);
-  const summary = groupedCallComponent(rows, theme);
-  const lines = ["", ...insetLines(summary.render(layout.contentWidth), width)];
+  const body = renderGroupedCallLines(rows, layout.contentWidth, theme);
+  const lines = ["", ...insetLines(body, width)];
   if (hasLiveMembers) {
     state.groupCache.delete(row);
   } else {
@@ -1266,12 +1421,14 @@ function installGroupingPatch(
 
     const existing = proto[GROUPING_PATCHED];
     if (existing) {
+      existing.owners++;
       existing.presentation = presentation;
       existing.disabled = false;
       return existing;
     }
 
     const state: GroupingPatchState = {
+      owners: 1,
       presentation,
       originalRender: proto.render,
     };
@@ -1319,10 +1476,12 @@ function installGroupingPatch(
 }
 
 function uninstallGroupingPatch(state: GroupingPatchState | undefined): void {
-  if (!state) return;
+  if (!state || state.owners <= 0) return;
+  state.owners--;
+  if (state.owners > 0) return;
   // Even when another extension's wrapper sits on top of ours, grouping must
-  // not outlive its owner: the wrapper delegates once disabled, and a later
-  // reinstall re-enables it.
+  // not outlive its final owner: the wrapper delegates once disabled, and a
+  // later reinstall re-enables it.
   state.disabled = true;
   const proto = Container?.prototype as unknown as ComponentContainer & {
     [GROUPING_PATCHED]?: GroupingPatchState;
@@ -1346,7 +1505,10 @@ function installPresentationPatch(): PresentationPatchState | undefined {
     if (!proto) return undefined;
 
     const existing = proto[PRESENTATION_PATCHED];
-    if (existing) return existing;
+    if (existing) {
+      existing.owners++;
+      return existing;
+    }
     const legacy = proto[LEGACY_PRESENTATION_PATCHED];
     if (legacy) {
       proto.render = legacy.originalRender;
@@ -1359,30 +1521,24 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       return undefined;
 
     const state: PresentationPatchState = {
+      owners: 1,
       collapseParallel: envEnabled(COLLAPSE_PARALLEL_ENV, true),
       groupCache: new WeakMap(),
       collapsedCache: new WeakMap(),
       rowVersions: new WeakMap(),
       rowGroups: new WeakMap(),
-      rowSignatures: new WeakMap(),
       originalRender: proto.render,
       originalUpdateDisplay: proto.updateDisplay,
     };
     const patchedUpdateDisplay = function updateDisplayWithCollapsedResult(
       this: ToolExecutionRow,
     ): void {
-      // 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 = rowSignatureOf(this);
-      if (
-        state.rowGroups.has(this) ||
-        state.rowSignatures.get(this) !== signature
-      ) {
-        state.rowSignatures.set(this, signature);
-        state.rowVersions.set(this, (state.rowVersions.get(this) ?? 0) + 1);
-        state.groupCache.delete(this);
-      }
+      // Transcript rerenders reuse settled caches, but a real component
+      // display update can change args, results, renderer output, or images
+      // without changing the row's shape signature.
+      state.rowVersions.set(this, (state.rowVersions.get(this) ?? 0) + 1);
+      state.groupCache.delete(this);
+      state.collapsedCache.delete(this);
       state.originalUpdateDisplay.call(this);
     };
     const patchedRender = function renderWithToolPresentation(
@@ -1407,12 +1563,11 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       // 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.
+      // Settled rows (not partial, not expanded) have static output between
+      // component display updates, so their collapsed lines are cached keyed
+      // by width + rowSignatureOf + rowVersions + theme sample. Every real
+      // updateDisplay call bumps rowVersions and clears both caches; partial
+      // rows bypass the cache because their content streams.
       // ================================================================
       if (!this.isPartial) {
         const signature = rowSignatureOf(this);
@@ -1484,7 +1639,9 @@ function installPresentationPatch(): PresentationPatchState | undefined {
 function uninstallPresentationPatch(
   state: PresentationPatchState | undefined,
 ): void {
-  if (!state) return;
+  if (!state || state.owners <= 0) return;
+  state.owners--;
+  if (state.owners > 0) return;
   const proto =
     ToolExecutionComponent?.prototype as unknown as ToolExecutionRow & {
       [PRESENTATION_PATCHED]?: PresentationPatchState;
@@ -1506,14 +1663,21 @@ function uninstallPresentationPatch(
 export default function (pi: ExtensionAPI) {
   const patch = installPresentationPatch();
   const grouping = patch ? installGroupingPatch(patch) : undefined;
+  const bashPatch = installBashBlockPatch();
+  installInfoVisibility(pi);
+  let released = false;
 
   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", () => {
+    if (released) return;
+    released = true;
     uninstallGroupingPatch(grouping);
     uninstallPresentationPatch(patch);
+    uninstallBashBlockPatch(bashPatch);
   });
 }

package/src/info-visibility-state.ts

@@ -0,0 +1,22 @@
+// Shared toggle state for /toggle-info. Pi loads extension entrypoints through
+// jiti with moduleCache disabled, so each entrypoint's relative-import chain
+// gets its OWN module instances — a plain module-level boolean here would be
+// duplicated between the main entrypoint (the /toggle-info command) and the
+// thinking-block-merger entrypoint (the strip). globalThis keeps it singular.
+
+type InfoVisibilityState = { hidden: boolean };
+
+const STATE_KEY = Symbol.for("kg.pi.toolCallMarkers.infoVisibility.v1");
+
+function infoVisibilityState(): InfoVisibilityState {
+  const root = globalThis as Record<symbol, InfoVisibilityState | undefined>;
+  return (root[STATE_KEY] ??= { hidden: false });
+}
+
+export function infoVisibilityHidden(): boolean {
+  return infoVisibilityState().hidden;
+}
+
+export function setInfoVisibilityHidden(hidden: boolean): void {
+  infoVisibilityState().hidden = hidden;
+}

package/src/info-visibility.ts

@@ -0,0 +1,74 @@
+import {
+  BashExecutionComponent,
+  type ExtensionAPI,
+  ToolExecutionComponent,
+} from "@earendil-works/pi-coding-agent";
+import { chatContainerHooks } from "./container-hooks.ts";
+import {
+  infoVisibilityHidden,
+  setInfoVisibilityHidden,
+} from "./info-visibility-state.ts";
+import { refreshThinkingVisibility } from "./thinking-block-merger.ts";
+
+function isExecutionRow(child: unknown): boolean {
+  return (
+    child instanceof ToolExecutionComponent ||
+    child instanceof BashExecutionComponent
+  );
+}
+
+// Chat-container hook: while hidden, tool and user-bash rows are lifted out of
+// the child list for the render pass and restored afterwards, so grouping and
+// insets run on prose only. Nested invocations are naturally idempotent: a
+// second pass finds nothing left to remove.
+function infoFilterHook(
+  _container: object,
+  children: unknown[],
+): (() => void) | undefined {
+  if (!infoVisibilityHidden()) return undefined;
+  const removed: Array<[number, unknown]> = [];
+  for (let index = children.length - 1; index >= 0; index--) {
+    if (isExecutionRow(children[index])) {
+      removed.push([index, children[index]!]);
+      children.splice(index, 1);
+    }
+  }
+  if (removed.length === 0) return undefined;
+  return () => {
+    for (const [index, child] of removed.reverse()) {
+      children.splice(index, 0, child);
+    }
+  };
+}
+
+export function installInfoVisibility(pi: ExtensionAPI): void {
+  // The hook registry is process-global; dedupe by name so hot reloads swap
+  // rather than stack.
+  const hooks = chatContainerHooks();
+  for (const hook of [...hooks]) {
+    if (hook.name === infoFilterHook.name) hooks.delete(hook);
+  }
+  hooks.add(infoFilterHook);
+
+  pi.registerCommand("toggle-info", {
+    description: "Hide tool calls and thinking, or restore them collapsed",
+    handler: async (_args, ctx) => {
+      const hidden = !infoVisibilityHidden();
+      setInfoVisibilityHidden(hidden);
+      // Thinking labels/blocks only rebuild on content updates, so replay the
+      // last update per assistant row to apply the new state immediately.
+      refreshThinkingVisibility();
+      ctx.ui.notify(
+        hidden
+          ? "Tool calls and thinking hidden — /toggle-info restores them"
+          : "Tool calls and thinking visible",
+        "info",
+      );
+    },
+  });
+
+  // Every session starts in the default collapsed-but-visible state. No
+  // shutdown reset: extra shutdown handlers would sit between this package's
+  // owner-counted patch releases.
+  pi.on("session_start", () => setInfoVisibilityHidden(false));
+}