@pi-kaush/pi-tool-call-markers 0.3.4 → 0.3.6

package/src/index.ts

@@ -15,17 +15,38 @@ import {
   uninstallBashBlockPatch,
 } from "./bash-block.ts";
 import { runChatContainerHooks } from "./container-hooks.ts";
-import { installInfoVisibility } from "./info-visibility.ts";
-import { fgCollapsed, fgCollapsedRail } from "./muted.ts";
+import {
+  installInfoVisibility,
+  uninstallInfoVisibility,
+} from "./info-visibility.ts";
+import { fgCollapsed, fgCollapsedRail, paletteSample } from "./muted.ts";
 
 const OUTER_INSET = 2;
 const SUBAGENT_MARKER = "↪";
 const GROUP_CALL_MARKER = "│";
+// Collapsed rows anchor with a glyph instead of repeating the tool name;
+// tools that read as one family share a glyph, and unmapped tools fall back
+// to `*`. A single space separates the glyph from the call content: the
+// anchor is punctuation enough without a joining colon.
+const TOOL_CALL_GLYPHS: ReadonlyMap<string, string> = new Map([
+  ["read", "●"],
+  ["write", "+"],
+  ["edit", "±"],
+  ["grep", "○"],
+  ["ffgrep", "○"],
+  ["find", "○"],
+  ["fffind", "○"],
+  ["ls", "≡"],
+  ["web_search", "↗"],
+  ["fetch_content", "↗"],
+  ["get_search_content", "↗"],
+]);
 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");
 const ANSI_RE = /\u001b\[[0-9;]*m/g;
 const COLLAPSE_PARALLEL_ENV = "PI_TOOL_CALL_MARKERS_COLLAPSE_PARALLEL";
+const EXPANDED_TOOLS_ENV = "PI_ALWAYS_EXPANDED_TOOL_CALL_MARKERS";
 
 type ThemeLike = {
   bold(text: string): string;
@@ -70,12 +91,16 @@ type ToolExecutionRow = {
 
 type PresentationPatchState = {
   owners: number;
+  // Set at the final owner's shutdown. A wrapper that another extension has
+  // buried cannot be uninstalled, so it delegates instead of outliving its
+  // owner; a later install re-enables it.
+  disabled?: boolean;
   theme?: ThemeLike;
   collapseParallel: boolean;
+  expandedTools: ReadonlySet<string>;
   groupCache: WeakMap<ToolExecutionRow, GroupRenderCache>;
   collapsedCache: WeakMap<ToolExecutionRow, CollapsedRenderCache>;
   rowVersions: WeakMap<ToolExecutionRow, number>;
-  rowGroups: WeakMap<ToolExecutionRow, ToolExecutionRow[]>;
   originalRender: (width: number) => string[];
   originalUpdateDisplay: () => void;
   originalHandleMouse?: (this: ToolExecutionRow, event: unknown) => unknown;
@@ -94,9 +119,7 @@ type GroupingPatchState = {
 
 type GroupRenderCache = {
   lines: string[];
-  // Per-member click-routing accounting for the group block: the first
-  // member absorbs the leading blank and the tool-name header, later
-  // members carry their own line (plus edit diffs).
+  // The first member absorbs the leading blank; each member owns its line.
   heights: Array<{ component: ToolExecutionRow; height: number }>;
   members: ToolExecutionRow[];
   memberVersions: number[];
@@ -120,6 +143,19 @@ function envEnabled(name: string, defaultValue: boolean): boolean {
   return defaultValue;
 }
 
+// Comma-separated tool names, e.g. `edit,write`. Blank entries and padding
+// are ignored; an unset or empty variable yields no names.
+function envToolNames(name: string): ReadonlySet<string> {
+  const value = process.env[name]?.trim();
+  if (!value) return new Set();
+  return new Set(
+    value
+      .split(",")
+      .map((entry) => entry.trim())
+      .filter(Boolean),
+  );
+}
+
 function stripAnsi(text: string): string {
   return text.replace(ANSI_RE, "");
 }
@@ -153,22 +189,12 @@ 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>();
+// Render caches hold lines with resolved colors baked in, so they key on the
+// palette's values rather than the theme object: Pi swaps the colors behind a
+// stable Proxy, which made an identity key survive a theme switch. Probing is
+// a handful of map lookups per row per frame.
 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;
+  return paletteSample(theme);
 }
 
 type InsetLayout = {
@@ -432,10 +458,6 @@ function selfRenderedCallLabel(row: ToolExecutionRow): string {
   return title ?? token;
 }
 
-function selfRenderedSummary(row: ToolExecutionRow, width: number): string {
-  return fitSummary(selfRenderedCallLabel(row), width);
-}
-
 function isToolExecutionRow(
   component: unknown,
 ): component is ToolExecutionRow & ComponentLike {
@@ -497,6 +519,18 @@ function isCollapsibleSuccess(row: ToolExecutionRow): boolean {
   );
 }
 
+// Settled failures join groups like settled successes; the row's error
+// color carries the failure, so the group stays visually unbroken.
+function isCollapsibleFailure(row: ToolExecutionRow): boolean {
+  return (
+    row.expanded === false &&
+    row.isPartial === false &&
+    !!row.result &&
+    rowHasFailed(row) &&
+    !hasImageResult(row)
+  );
+}
+
 function hasToolSiblingInAssistantBatch(
   children: unknown[],
   index: number,
@@ -517,6 +551,16 @@ function hasToolSiblingInAssistantBatch(
   return false;
 }
 
+// A self-rendered tool opts out of the transcript by drawing no lines. The
+// singleton and grouped paths must agree on that, or grouping resurrects a
+// row the tool deliberately hid.
+function drawsNoRowLines(
+  row: ToolExecutionRow,
+  nativeLines: string[],
+): boolean {
+  return nativeLines.length === 0 && (row.imageComponents?.length ?? 0) === 0;
+}
+
 function isGroupableToolRow(
   row: ToolExecutionRow,
   children: unknown[],
@@ -525,7 +569,13 @@ function isGroupableToolRow(
   state: PresentationPatchState,
 ): boolean {
   if (row.toolName === "subagent") return false;
-  if (!isLiveRow(row) && !isCollapsibleSuccess(row)) return false;
+  if (drawsNoRowLines(row, renderAt(index))) return false;
+  if (
+    !isLiveRow(row) &&
+    !isCollapsibleSuccess(row) &&
+    !isCollapsibleFailure(row)
+  )
+    return false;
   return (
     state.collapseParallel ||
     !hasToolSiblingInAssistantBatch(children, index, renderAt)
@@ -612,15 +662,8 @@ function diffCounts(diff: string): { added: number; removed: number } {
 }
 
 // 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;
-
+// result.details.diff; collapsed rows show only its +a/-b stat, while the
+// full hunk returns with Ctrl+O.
 function editDiffText(row: ToolExecutionRow): string | undefined {
   if (row.toolName !== "edit") return undefined;
   if (!row.result || row.isPartial !== false || rowHasFailed(row))
@@ -636,43 +679,6 @@ function renderedEditDiffStat(row: ToolExecutionRow): string | undefined {
   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(fgCollapsed(theme, "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(
-      fgCollapsed(
-        theme,
-        "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
@@ -724,22 +730,6 @@ function renderedOutcome(
   return fgCollapsed(theme, "toolOutput", `→ ${summary}`);
 }
 
-function renderedGroupedOutcome(
-  row: ToolExecutionRow,
-  theme: ThemeLike,
-): string | undefined {
-  const outcome = renderedOutcome(row, theme);
-  if (outcome) return outcome;
-  if (isLiveRow(row)) {
-    const elapsed = liveElapsedText(row);
-    return theme.fg("warning", elapsed ? `… · ${elapsed}` : "…");
-  }
-  // Self-rendered tools have no per-tool outcome summary; keep the group's
-  // settled tail consistent with collapsed singletons.
-  if (row.getRenderShell?.() === "self") return renderedGenericOutcome(theme);
-  return undefined;
-}
-
 // A budget too small for the suffix keeps literal styled text instead, so a
 // one-column label never collapses into a bare ellipsis or loses its status.
 function truncateStyled(text: string, width: number, suffix = "…"): string {
@@ -810,11 +800,6 @@ function renderedCallSummary(
   width: number,
   theme: ThemeLike,
 ): string {
-  // Self-rendered call components change shape across the live/settled
-  // boundary (the adapter's call disappears once settled), so always build
-  // the summary from the stable args label instead of scraping the preview.
-  if (row.getRenderShell?.() === "self") return selfRenderedSummary(row, width);
-
   let component = row.callRendererComponent;
   if (!component && Array.isArray(row.contentBox?.children)) {
     component = row.contentBox.children[0] as ComponentLike | undefined;
@@ -865,39 +850,60 @@ function renderedCallSummary(
     : fgCollapsed(theme, "muted", "(no arguments)");
 }
 
-function styledCallLabel(
-  label: string,
-  theme: ThemeLike,
-  color = "muted",
-): string {
-  const plain = sanitizeInline(stripAnsi(label)).trim();
-  const match = /^(\S+)(.*)$/s.exec(plain);
-  if (!match) return fgCollapsed(theme, color, plain);
-  const rest = match[2] ?? "";
-  // The colon joins the bolded name to its content. Failed rows stay
-  // uniformly error-colored; settled rows use the collapsed mute — same
-  // color for the bolded name and the call content.
-  return (
-    fgCollapsed(theme, color, match[1] ?? "", true) +
-    (rest ? fgCollapsed(theme, color, `:${rest}`) : "")
-  );
-}
-
-function collapsedCallLabel(
+// The collapsed-row seam lives here and nowhere else: which anchor a row
+// takes, how that anchor is styled, and the call text that follows it.
+// Anchors always render bold and take no joining colon — `│ ● src/a.ts`,
+// `│ $ npm test` — and subagent fallbacks keep their `↪ subagent …`
+// reading instead of a glyph. Callers append the outcome tail.
+function collapsedSeam(
   row: ToolExecutionRow,
   width: number,
   theme: ThemeLike,
-  color = "muted",
-): string {
-  if (row.getRenderShell?.() === "self") {
-    return styledCallLabel(selfRenderedCallLabel(row), theme, color);
-  }
+  color: string,
+): { anchor: string; content: string } {
+  const isBash = row.toolName === "bash";
+  const isSubagent = row.toolName === "subagent";
+  const glyph = isBash
+    ? "$"
+    : (TOOL_CALL_GLYPHS.get(row.toolName ?? "") ?? "*");
+  const anchor = isSubagent
+    ? `${fgCollapsed(theme, color, SUBAGENT_MARKER, true)} `
+    : `${fgCollapsedRail(theme, GROUP_CALL_MARKER)} ${fgCollapsed(
+        theme,
+        color,
+        glyph,
+        true,
+      )} `;
+  const budget = Math.max(1, width - visibleWidth(anchor));
+  // Self-rendered rows build their own `tool {args}` label — Pi's call title
+  // is gone once settled — while ordinary rows scrape the rendered call
+  // line, which already drops its heading token.
+  const selfRendered = row.getRenderShell?.() === "self";
+  const source = selfRendered
+    ? selfRenderedCallLabel(row)
+    : renderedCallSummary(row, budget, theme);
+  const plain = sanitizeInline(stripAnsi(source)).trim();
+  // The anchor stands in for the label's leading token. Only self-rendered
+  // labels still carry it; a subagent fallback keeps `subagent` as its own
+  // heading, which the scrape dropped.
+  const text = isSubagent
+    ? `subagent${plain ? ` ${plain}` : ""}`
+    : selfRendered
+      ? dropCallToken(plain, row.toolName ?? "tool")
+      : plain;
+  return {
+    anchor,
+    content: fgCollapsed(theme, color, text || "(no arguments)"),
+  };
+}
 
-  const token = row.toolName === "bash" ? "$" : (row.toolName ?? "tool");
-  const summary = renderedCallSummary(row, Math.max(1, width), theme);
-  const plainSummary = stripAnsi(summary).trim();
-  const label = plainSummary ? `${token} ${plainSummary}` : token;
-  return styledCallLabel(label, theme, color);
+// Drops the leading token an anchor now stands for, with whichever separator
+// the label joined it with.
+function dropCallToken(plain: string, token: string): string {
+  if (!plain.startsWith(token)) return plain;
+  const rest = plain.slice(token.length);
+  if (!/^:?\s|^:$/.test(rest)) return plain;
+  return rest.replace(/^:?\s*/, "");
 }
 
 function collapsedOutcome(
@@ -924,30 +930,28 @@ function collapsedOutcome(
   return renderedOutcome(row, theme);
 }
 
-function collapsedHeadline(
+// One collapsed row — head and outcome tail — at the given width. Singleton
+// and grouped rows differ only in what surrounds the line.
+function collapsedRowLine(
   row: ToolExecutionRow,
   width: number,
   theme: ThemeLike,
 ): string {
   // 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 tone = rowHasFailed(row) ? "error" : "muted";
-  const marker =
-    row.toolName === "subagent"
-      ? `${fgCollapsed(theme, tone, SUBAGENT_MARKER)} `
-      : `${fgCollapsedRail(theme, tone, GROUP_CALL_MARKER)} `;
-  const budget = Math.max(1, width - visibleWidth(marker));
-  const label = collapsedCallLabel(row, budget, theme, tone);
+  // failed, not just its outcome tail. Only the row's anchor stays bold.
+  const color = rowHasFailed(row) ? "error" : "muted";
+  const seam = collapsedSeam(row, width, theme, color);
+  const budget = Math.max(1, width - visibleWidth(seam.anchor));
   const outcome = collapsedOutcome(row, budget, theme);
   // The truncation suffix inherits the row tone; pi-tui's truncation resets
   // around a plain suffix, which would render it in the terminal default
   // foreground instead of the row color.
-  const suffix = fgCollapsed(theme, tone, "…");
+  const suffix = fgCollapsed(theme, color, "…");
   return (
-    marker +
+    seam.anchor +
     (outcome
-      ? fitSummaryTail(label, outcome, budget, suffix)
-      : fitSummary(label, budget, suffix))
+      ? fitSummaryTail(seam.content, outcome, budget, suffix)
+      : fitSummary(seam.content, budget, suffix))
   );
 }
 
@@ -1247,78 +1251,19 @@ function renderCollapsedToolRow(
     row.toolName === "subagent"
       ? renderSubagentPlan(row, layout.contentWidth, theme)
       : undefined;
-  const body = plan ?? [collapsedHeadline(row, layout.contentWidth, theme)];
-  if (row.toolName === "edit") {
-    body.push(...renderedEditDiffLines(row, theme));
-  }
+  const body = plan ?? [collapsedRowLine(row, layout.contentWidth, theme)];
   body.push(...imageResultLines(row, layout.contentWidth, theme));
   return ["", ...insetLines(body, width)];
 }
 
-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 || fgCollapsed(theme, color, "(no arguments)");
-}
-
 function renderGroupedCallLines(
   rows: ToolExecutionRow[],
   width: number,
   theme: ThemeLike,
 ): Array<{ row: ToolExecutionRow; lines: string[] }> {
   const segments: Array<{ row: ToolExecutionRow; lines: string[] }> = [];
-  let previousToolName: string | undefined;
   for (const row of rows) {
-    const lines: string[] = [];
-    const toolName = row.toolName ?? "tool";
-    if (toolName !== previousToolName) {
-      // Keep the rail unbroken across subgroup spacing and put each bold
-      // tool name beside it. The separator belongs to the new row so
-      // click-routing heights stay aligned with the rendered lines.
-      if (previousToolName !== undefined) {
-        lines.push(fgCollapsedRail(theme, "muted", GROUP_CALL_MARKER));
-      }
-      lines.push(
-        `${fgCollapsedRail(theme, "muted", GROUP_CALL_MARKER)} ${fgCollapsed(theme, "toolTitle", toolName, true)}`,
-      );
-      previousToolName = toolName;
-    }
-
-    const color = rowHasFailed(row) ? "error" : "muted";
-    const prefix = `${fgCollapsedRail(theme, color, GROUP_CALL_MARKER)}    `;
-    const budget = Math.max(1, width - visibleWidth(prefix));
-    const label = groupedChildLabel(row, budget, theme, color);
-    const outcome = collapsedOutcome(row, budget, theme);
-    const suffix = fgCollapsed(theme, color, "…");
-    lines.push(
-      prefix +
-        (outcome
-          ? fitSummaryTail(label, outcome, budget, suffix)
-          : fitSummary(label, budget, suffix)),
-    );
-    if (row.toolName === "edit")
-      lines.push(...renderedEditDiffLines(row, theme));
-    segments.push({ row, lines });
+    segments.push({ row, lines: [collapsedRowLine(row, width, theme)] });
   }
   return segments;
 }
@@ -1387,8 +1332,7 @@ function renderGroupedToolRows(
       width,
     ),
   ];
-  // The leading blank and the first segment (tool-name header + call line)
-  // both belong to the first member; every later member owns its lines.
+  // The first member owns the leading blank; every member owns its call line.
   const heights = segments.map((segment, index) => ({
     component: segment.row,
     height: index === 0 ? segment.lines.length + 1 : segment.lines.length,
@@ -1479,7 +1423,6 @@ function renderContainerWithToolGroups(
       continue;
     }
 
-    for (const member of group) presentation.rowGroups.set(member, group);
     // Use a live member while any call is pending, then the first member once
     // settled. Either way, the grouped row keeps the same number of lines.
     const shellRow = group.find(isLiveRow) ?? child;
@@ -1600,6 +1543,7 @@ function installPresentationPatch(): PresentationPatchState | undefined {
     const existing = proto[PRESENTATION_PATCHED];
     if (existing) {
       existing.owners++;
+      existing.disabled = false;
       return existing;
     }
     const legacy = proto[LEGACY_PRESENTATION_PATCHED];
@@ -1616,16 +1560,20 @@ function installPresentationPatch(): PresentationPatchState | undefined {
     const state: PresentationPatchState = {
       owners: 1,
       collapseParallel: envEnabled(COLLAPSE_PARALLEL_ENV, true),
+      expandedTools: envToolNames(EXPANDED_TOOLS_ENV),
       groupCache: new WeakMap(),
       collapsedCache: new WeakMap(),
       rowVersions: new WeakMap(),
-      rowGroups: new WeakMap(),
       originalRender: proto.render,
       originalUpdateDisplay: proto.updateDisplay,
     };
-    const patchedUpdateDisplay = function updateDisplayWithCollapsedResult(
+    const patchedUpdateDisplay = function updateDisplayWithToolPresentation(
       this: ToolExecutionRow,
     ): void {
+      if (state.disabled) {
+        state.originalUpdateDisplay.call(this);
+        return;
+      }
       // 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.
@@ -1633,6 +1581,17 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       state.groupCache.delete(this);
       state.collapsedCache.delete(this);
       state.originalUpdateDisplay.call(this);
+      // Rows for an always-expanded tool skip the collapsed presentation.
+      // Forcing the flag here, before grouping decides whether the row is
+      // eligible, keeps Pi's native expanded block authoritative; it also
+      // re-expands the row after a global collapse.
+      if (
+        this.expanded === false &&
+        state.expandedTools.has(this.toolName ?? "") &&
+        typeof this.setExpanded === "function"
+      ) {
+        this.setExpanded(true);
+      }
     };
     // Pi 0.85 wraps settled tool results in a click-to-expand MouseRegion.
     // The custom collapsed row replaces those lines with a single summary, so
@@ -1647,6 +1606,9 @@ function installPresentationPatch(): PresentationPatchState | undefined {
         event: unknown,
       ): unknown {
         const mouseEvent = event as { type?: unknown; button?: unknown };
+        if (state.disabled) {
+          return state.originalHandleMouse?.call(this, event);
+        }
         if (
           state.theme &&
           this.expanded === false &&
@@ -1668,6 +1630,7 @@ function installPresentationPatch(): PresentationPatchState | undefined {
     ): string[] {
       const theme = state.theme;
       if (
+        state.disabled ||
         typeof this.expanded !== "boolean" ||
         typeof this.isPartial !== "boolean" ||
         this.expanded ||
@@ -1705,7 +1668,7 @@ function installPresentationPatch(): PresentationPatchState | undefined {
           return cached.lines;
         }
         const lines = state.originalRender.call(this, width);
-        if (lines.length === 0 && (this.imageComponents?.length ?? 0) === 0) {
+        if (drawsNoRowLines(this, lines)) {
           return lines;
         }
         try {
@@ -1726,7 +1689,7 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       // 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) {
+      if (drawsNoRowLines(this, lines)) {
         return lines;
       }
       try {
@@ -1763,6 +1726,7 @@ function uninstallPresentationPatch(
   if (!state || state.owners <= 0) return;
   state.owners--;
   if (state.owners > 0) return;
+  state.disabled = true;
   const proto =
     ToolExecutionComponent?.prototype as unknown as ToolExecutionRow & {
       [PRESENTATION_PATCHED]?: PresentationPatchState;
@@ -1813,17 +1777,12 @@ export default function (pi: ExtensionAPI) {
     ctx.ui.setToolsExpanded(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);
+    uninstallInfoVisibility();
   });
 }

package/src/info-visibility-state.ts

@@ -4,13 +4,13 @@
 // 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 };
+type InfoVisibilityState = { hidden: boolean; owners: number };
 
 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 });
+  return (root[STATE_KEY] ??= { hidden: false, owners: 0 });
 }
 
 export function infoVisibilityHidden(): boolean {
@@ -20,3 +20,17 @@ export function infoVisibilityHidden(): boolean {
 export function setInfoVisibilityHidden(hidden: boolean): void {
   infoVisibilityState().hidden = hidden;
 }
+
+// The filter hook lives in a process-global registry, so it is owned like the
+// prototype patches: it outlives every install that loaded this module and
+// disappears with the last one.
+export function retainInfoVisibilityOwner(): void {
+  infoVisibilityState().owners += 1;
+}
+
+// Returns the owners left after this release.
+export function releaseInfoVisibilityOwner(): number {
+  const state = infoVisibilityState();
+  state.owners = Math.max(0, state.owners - 1);
+  return state.owners;
+}

package/src/info-visibility.ts

@@ -6,6 +6,8 @@ import {
 import { chatContainerHooks } from "./container-hooks.ts";
 import {
   infoVisibilityHidden,
+  releaseInfoVisibilityOwner,
+  retainInfoVisibilityOwner,
   setInfoVisibilityHidden,
 } from "./info-visibility-state.ts";
 import { refreshThinkingVisibility } from "./thinking-block-merger.ts";
@@ -42,6 +44,7 @@ function infoFilterHook(
 }
 
 export function installInfoVisibility(pi: ExtensionAPI): void {
+  retainInfoVisibilityOwner();
   // The hook registry is process-global; dedupe by name so hot reloads swap
   // rather than stack.
   const hooks = chatContainerHooks();
@@ -67,8 +70,17 @@ export function installInfoVisibility(pi: ExtensionAPI): void {
     },
   });
 
-  // 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.
+  // Every session starts in the default collapsed-but-visible state.
   pi.on("session_start", () => setInfoVisibilityHidden(false));
 }
+
+// Released from the entrypoint's own shutdown handler, so a session still
+// tears down with one handler per install. The registry and the toggle are
+// process-global: while any owner remains, the hook stays; the last owner
+// removes it, so execution rows cannot keep disappearing from a transcript
+// this package no longer renders.
+export function uninstallInfoVisibility(): void {
+  if (releaseInfoVisibilityOwner() > 0) return;
+  chatContainerHooks().delete(infoFilterHook);
+  setInfoVisibilityHidden(false);
+}