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

package/CHANGELOG.md

@@ -2,6 +2,62 @@
 
 ## Unreleased
 
+- Read colors from the live palette instead of caching them against the
+  theme object. Pi swaps the palette behind a stable theme Proxy, so every
+  identity-keyed cache survived a theme switch: collapsed rows, the `+ Thought`
+  label, and user `!` blocks kept the old colors until their content changed.
+  Probes are map lookups, so the render caches now key on the resolved colors
+  (`paletteSample`, including the bash-block line cache) and the label
+  resolves its style per call.
+
+- Stop grouping from resurrecting a tool that opted out of the transcript. A
+  self-rendered tool that draws no lines stays hidden whether it renders alone
+  or beside another call: the singleton and grouped paths share one
+  draws-nothing rule.
+
+- Go inert at the final owner's shutdown. Every prototype wrapper — tool
+  presentation, container grouping, user bash blocks, thinking — delegates to
+  the original when another extension's wrapper has buried it and removal is
+  impossible, so collapsed rows and restyled labels cannot outlive their owner.
+  A later install re-enables the same wrappers.
+
+- Roll back a container hook that mutates the child list and then throws.
+  Its edit used to stick, dropping those rows from every later render. Both
+  copies of the shared hook contract changed together.
+
+- Own and release `/toggle-info` with the rest of the extension: the
+  process-global filter hook and the hidden flag now leave with the last owner
+  instead of filtering a transcript this package no longer renders.
+
+- Track thinking rows for the `/toggle-info` replay instead of every assistant
+  row, capped at 400 entries, so a long session or an abandoned branch cannot
+  pin every message the transcript ever showed.
+
+- Delete state nothing reads (the row→group map) and the duplicate
+  `session_start` handler that applied the collapsed default twice.
+
+- Drop the colon after every collapsed-row anchor: glyph rows read
+  `│ ● src/a.ts` and bash rows `│ $ npm test`. The anchor runs bold with a
+  single space before the call text, so the anchor alone separates the two.
+  The whole seam — glyph map, `$` prompt, subagent fallback heading, and the
+  tool-token drop — now lives in one function that both the singleton and
+  grouped render paths call, and self-rendered labels no longer leak their
+  tool name into the row under themes that tag instead of color.
+
+- Drop the italics Pi puts on thinking. The hidden `+ Thought` label renders
+  plain in every theme — the live spinner keeps its level tint, the settled
+  row its muted tone, and a theme that resolves no color still loses the
+  italics — and the visible trace stays italic only while it streams, then
+  renders as ordinary transcript text once the row settles. The live/settled
+  rule is shared with the label, so un-flagged row rebuilds (resize, theme
+  switch) keep a live trace italic and a finished one plain.
+  `PI_TOOL_CALL_MARKERS_THOUGHT_COLOR=inherit` remains the only opt-out that
+  keeps Pi's native italic styling.
+
+- Fail open when a theme rejects a thinking token. Pi's Theme throws on
+  tokens it does not know, so the label probe now falls back to the plain
+  treatment instead of throwing out of the row's update pass.
+
 - Restore Pi 0.85's click-to-expand under the custom collapsed rows. Pi routes
   mouse clicks by per-child rendered line heights, and the grouping render
   bypassed the native render that refreshes that cache, so clicks on anything

package/README.md

@@ -15,13 +15,13 @@ Restart Pi or run `/reload`.
 Collapsed tool rows use semantic theme colors with no gear, background fill, box padding, or filled blank rows:
 
 ```text
-  │ ●: src/a.ts                         42 lines
-  │ ●: src/b.ts                         18 lines
-  │ $: npm test → done
+  │ ● src/a.ts                         42 lines
+  │ ● src/b.ts                         18 lines
+  │ $ npm test → done
 ```
 
 - **Two-column outer inset.** Tool markers and image output align with an inset conversation surface. Very narrow terminals reduce the decoration before useful content.
-- **`│` tool-call rail.** Every collapsed call anchors on a glyph instead of its tool name: `●` read, `+` write, `±` edit, `○` local search, `≡` ls, `↗` web search and fetch, and `$` bash; unmapped tools fall back to `*`. Grouped rows flow directly across tool types.
+- **`│` tool-call rail.** Every collapsed call anchors on a bold glyph instead of its tool name — `●` read, `+` write, `±` edit, `○` local search, `≡` ls, `↗` web search and fetch, and `$` bash; unmapped tools fall back to `*` — with a single space between the anchor and the call text, no joining colon. Grouped rows flow directly across tool types.
 - **Semantic, low-contrast status.** The anchor and the call content share the collapsed mute, pending state is warning-colored, and failures remain error-colored. Ordinary tool states have no background.
 - **Width-safe outcome tails.** Long summaries truncate before useful tails such as `→ done`, `→ 42 lines`, `→ +2/-1`, or a `bash` duration.
 - **Stable running groups.** Adjacent calls group as they appear, including settled failures, which stay error-colored inside the group. Pending state and elapsed `bash` time settle into the final outcome without changing the row count.
@@ -78,7 +78,9 @@ When Pi exposes its per-row hidden-thinking and streaming fields, hidden reasoni
 + Thought · 2.5s
 ```
 
-The live label samples Pi's native braille spinner sequence from the content updates Pi already renders; it does not add a timer. The adapter stores the first local streaming timestamp per assistant row in a `WeakMap`. A restored message or an older runtime with no streaming argument uses `+ Thought`. Visible-thinking mode remains native. There is no interval, timeout, render request, model call, or network work.
+The live label samples Pi's native braille spinner sequence from the content updates Pi already renders; it does not add a timer. The adapter stores the first local streaming timestamp per assistant row in a `WeakMap`. A restored message or an older runtime with no streaming argument uses `+ Thought`. There is no interval, timeout, render request, model call, or network work.
+
+Pi renders thinking labels and traces italic. This package drops those italics: both labels read as plain collapsed rows (the live spinner keeps its thinking-level tint, the settled row the muted tone, and a theme that resolves no color still loses the italics), and a visible trace stays italic only while it streams, then settles into ordinary transcript text. `PI_TOOL_CALL_MARKERS_THOUGHT_COLOR=inherit` is the opt-out that keeps Pi's native italic `thinkingText` styling.
 
 ## Local development
 
@@ -131,10 +133,14 @@ Pi has no public hook for native tool rows, transcript grouping, or per-message
 
 - `ToolExecutionComponent` for collapsed presentation;
 - `Container` for adjacent grouping; and
-- `AssistantMessageComponent.updateContent` for display-only thinking merging and lifecycle labels.
+- `AssistantMessageComponent.updateContent` for display-only thinking merging, lifecycle labels, and the settled trace's italics.
 
 Each adapter feature-detects the fields and methods it needs, keeps the original method, uses an idempotency symbol, catches cosmetic failures, and restores the original on `session_shutdown` when it still owns the patch. Unsupported shapes fail open to Pi's native rendering. The thinking adapter continues adjacent merging even when the private label shape is unavailable.
 
+Teardown is owner-counted and inert: when another extension's wrapper sits above one of these, removal is impossible, so the buried wrapper delegates to the original instead of leaving collapsed rows or restyled labels behind after its owner shuts down. A later install re-enables it. The shared chat-container hook contract applies the same fail-open rule to hooks: a hook that throws after editing the child list has its edit rolled back, so a failed hook cannot drop rows from the transcript.
+
+Colors are read live from the theme, so a mid-session theme switch repaints collapsed rows, labels, and `!` blocks; cached render output keys on the resolved palette rather than on the theme object, which Pi keeps stable across a switch.
+
 Expanded tools always use Pi's native renderer. The collapsed tool shell owns its two-column inset directly; transcript layout extensions should leave tool rows unchanged, preventing load-order-dependent double padding.
 
 > TODO: migrate these adapters to public Pi transcript and tool-rendering APIs when available.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-kaush/pi-tool-call-markers",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "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

@@ -1,5 +1,6 @@
 import { BashExecutionComponent } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { paletteSample } from "./muted.ts";
 
 type ThemeLike = {
   bold(text: string): string;
@@ -199,8 +200,15 @@ type BashRow = { status?: unknown };
 
 type BashBlockPatchState = {
   owners: number;
+  // Set at the final owner's shutdown. A wrapper 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;
-  cache: WeakMap<object, { width: number; src: string[]; lines: string[] }>;
+  cache: WeakMap<
+    object,
+    { width: number; src: string[]; lines: string[]; palette: string }
+  >;
   originalRender: (width: number) => string[];
   patchedRender?: (width: number) => string[];
 };
@@ -213,6 +221,7 @@ type BashBlockPatchState = {
 // TODO: Replace prototype patching with a public Pi rendering API when available.
 function installBashBlockPatch(): BashBlockPatchState | undefined {
   try {
+    console.error("BB new state");
     const proto = BashExecutionComponent?.prototype as unknown as BashRow & {
       [BASH_BLOCK_PATCHED]?: BashBlockPatchState;
       render?: (width: number) => string[];
@@ -222,6 +231,8 @@ function installBashBlockPatch(): BashBlockPatchState | undefined {
     const existing = proto[BASH_BLOCK_PATCHED];
     if (existing) {
       existing.owners++;
+      console.error("BB reuse owners", existing.owners);
+      existing.disabled = false;
       return existing;
     }
 
@@ -235,17 +246,24 @@ function installBashBlockPatch(): BashBlockPatchState | undefined {
       width: number,
     ): string[] {
       const theme = state.theme;
-      if (!theme) return state.originalRender.call(this, width);
+      if (state.disabled || !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));
+      // Decorated lines carry resolved colors, so the cache keys on the
+      // palette too: Pi swaps the colors behind a stable theme Proxy, which a
+      // theme-identity check would never notice.
+      const palette = paletteSample(theme);
       const entry = state.cache.get(this);
       if (
         entry &&
         entry.width === width &&
+        entry.palette === palette &&
         entry.src.length === lines.length &&
         entry.src.every((line, index) => line === lines[index])
       ) {
@@ -259,7 +277,7 @@ function installBashBlockPatch(): BashBlockPatchState | undefined {
         typeof status === "string" ? status : undefined,
         inset,
       );
-      state.cache.set(this, { width, src: lines, lines: decorated });
+      state.cache.set(this, { width, src: lines, lines: decorated, palette });
       return decorated;
     };
 
@@ -285,6 +303,7 @@ function uninstallBashBlockPatch(state: BashBlockPatchState | undefined): void {
   if (!state || state.owners <= 0) return;
   state.owners--;
   if (state.owners > 0) return;
+  state.disabled = true;
   const proto = BashExecutionComponent?.prototype as unknown as BashRow & {
     [BASH_BLOCK_PATCHED]?: BashBlockPatchState;
     render?: (width: number) => string[];

package/src/container-hooks.ts

@@ -37,11 +37,17 @@ export function runChatContainerHooks(
   const restores: Array<() => void> = [];
   if (Array.isArray(children)) {
     for (const hook of chatContainerHooks()) {
+      // A hook rewrites `children` and hands back its own undo. Snapshot first:
+      // a hook that throws after splicing rows out would otherwise leave them
+      // missing from every later render, with nothing left to restore them.
+      const before = [...children];
       try {
         const restore = hook(container, children, width);
         if (typeof restore === "function") restores.push(restore);
       } catch {
         // Hooks are cosmetic; one failing hook must not break rendering.
+        children.length = 0;
+        children.push(...before);
       }
     }
   }

package/src/index.ts

@@ -15,15 +15,19 @@ 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 `*`.
+// 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", "+"],
@@ -87,13 +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;
@@ -182,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 = {
@@ -461,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 {
@@ -558,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[],
@@ -566,6 +569,7 @@ function isGroupableToolRow(
   state: PresentationPatchState,
 ): boolean {
   if (row.toolName === "subagent") return false;
+  if (drawsNoRowLines(row, renderAt(index))) return false;
   if (
     !isLiveRow(row) &&
     !isCollapsibleSuccess(row) &&
@@ -796,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;
@@ -851,56 +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);
-  }
-
-  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);
+  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)"),
+  };
 }
 
-// Collapsed rows anchor their call text with a glyph instead of repeating
-// the tool name, grouped or not. Bash carries `$:` inside its own label and
-// the subagent fallback keeps its `↪ subagent` heading, so neither takes a
-// glyph.
-function collapsedCallMarker(
-  row: ToolExecutionRow,
-  theme: ThemeLike,
-  color: string,
-): string {
-  if (row.toolName === "bash" || row.toolName === "subagent") return "";
-  return fgCollapsed(
-    theme,
-    color,
-    `${TOOL_CALL_GLYPHS.get(row.toolName ?? "") ?? "*"}: `,
-  );
+// 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(
@@ -927,31 +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 row's anchor stays bold.
-  const tone = rowHasFailed(row) ? "error" : "muted";
-  const marker =
-    row.toolName === "subagent"
-      ? `${fgCollapsed(theme, tone, SUBAGENT_MARKER)} `
-      : `${fgCollapsedRail(theme, GROUP_CALL_MARKER)} `;
-  const glyph = collapsedCallMarker(row, theme, tone);
-  const budget = Math.max(1, width - visibleWidth(marker));
-  const label = glyph + collapsedChildLabel(row, budget, theme, tone);
+  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))
   );
 }
 
@@ -1251,40 +1251,11 @@ function renderCollapsedToolRow(
     row.toolName === "subagent"
       ? renderSubagentPlan(row, layout.contentWidth, theme)
       : undefined;
-  const body = plan ?? [collapsedHeadline(row, layout.contentWidth, theme)];
+  const body = plan ?? [collapsedRowLine(row, layout.contentWidth, theme)];
   body.push(...imageResultLines(row, layout.contentWidth, theme));
   return ["", ...insetLines(body, width)];
 }
 
-// Drops the call label's tool-name token: the row's glyph anchors the call
-// instead. The `↪` subagent fallback keeps its own heading.
-function collapsedChildLabel(
-  row: ToolExecutionRow,
-  width: number,
-  theme: ThemeLike,
-  color: string = "muted",
-): string {
-  const label = collapsedCallLabel(row, width, theme, color);
-  if (row.toolName === "subagent") return label;
-  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,
@@ -1292,26 +1263,7 @@ function renderGroupedCallLines(
 ): Array<{ row: ToolExecutionRow; lines: string[] }> {
   const segments: Array<{ row: ToolExecutionRow; lines: string[] }> = [];
   for (const row of rows) {
-    const lines: string[] = [];
-
-    const color = rowHasFailed(row) ? "error" : "muted";
-    const prefix = `${fgCollapsedRail(theme, GROUP_CALL_MARKER)} `;
-    const marker = collapsedCallMarker(row, theme, color);
-    const budget = Math.max(
-      1,
-      width - visibleWidth(prefix) - visibleWidth(marker),
-    );
-    const label = collapsedChildLabel(row, budget, theme, color);
-    const outcome = collapsedOutcome(row, budget, theme);
-    const suffix = fgCollapsed(theme, color, "…");
-    lines.push(
-      prefix +
-        marker +
-        (outcome
-          ? fitSummaryTail(label, outcome, budget, suffix)
-          : fitSummary(label, budget, suffix)),
-    );
-    segments.push({ row, lines });
+    segments.push({ row, lines: [collapsedRowLine(row, width, theme)] });
   }
   return segments;
 }
@@ -1471,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;
@@ -1592,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];
@@ -1612,13 +1564,16 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       groupCache: new WeakMap(),
       collapsedCache: new WeakMap(),
       rowVersions: new WeakMap(),
-      rowGroups: new WeakMap(),
       originalRender: proto.render,
       originalUpdateDisplay: proto.updateDisplay,
     };
     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.
@@ -1651,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 &&
@@ -1672,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 ||
@@ -1709,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 {
@@ -1730,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 {
@@ -1767,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;
@@ -1817,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);
+}

package/src/muted.ts

@@ -19,27 +19,36 @@ type CollapsedTheme = {
   getFgAnsi?(color: string): string;
 };
 
-// Resolved per theme object (Pi's Theme throws on unknown tokens; themes
-// without getFgAnsi have no overrides), alongside index.ts's other
-// theme-identity-keyed caches.
-const ansiCache = new WeakMap<object, Map<string, string | null>>();
-
+// Probed live, never cached: Pi swaps the colors behind a stable theme
+// Proxy, so a value cached against the theme object outlives a theme switch.
+// A probe is one map lookup, and the Theme throws on tokens it does not know
+// (themes without getFgAnsi have no overrides at all).
 function tokenAnsi(theme: CollapsedTheme, token: string): string | null {
-  let cache = ansiCache.get(theme);
-  if (!cache) {
-    cache = new Map();
-    ansiCache.set(theme, cache);
-  }
-  if (cache.has(token)) return cache.get(token)!;
-  let ansi: string | null = null;
   try {
     const resolved = theme.getFgAnsi?.(token);
-    if (typeof resolved === "string") ansi = resolved;
+    return typeof resolved === "string" ? resolved : null;
   } catch {
-    ansi = null;
+    return null;
   }
-  cache.set(token, ansi);
-  return ansi;
+}
+
+// The tokens this package resolves from a palette.
+const PALETTE_TOKENS = [
+  TOOL_OVERRIDE_TOKEN,
+  THINKING_OVERRIDE_TOKEN,
+  DEFAULT_TOKEN,
+  "muted",
+  "toolOutput",
+  "accent",
+  "warning",
+  "error",
+] as const;
+
+// Revision key for rendered output that bakes resolved colors in. Compares
+// the colors themselves, so a mid-session theme switch is visible to every
+// cache that keys on it.
+export function paletteSample(theme: CollapsedTheme): string {
+  return PALETTE_TOKENS.map((token) => tokenAnsi(theme, token) ?? "").join(",");
 }
 
 // Override token when defined, else the theme's syntaxComment color, else

package/src/thinking-block-merger.ts

@@ -49,56 +49,60 @@ type ThemeDetail = {
 // styles current across mid-session theme switches, which fire no event.
 let themeProvider: (() => ThemeDetail | undefined) | undefined;
 let activeLevel: (() => string) | undefined;
-// Theme object the current label styles were computed from.
-let stylesTheme: ThemeDetail | undefined;
+// Pi builds both thinking labels italic. The default treatment replaces that
+// with a plain row: italic-off always leads — the TUI diff renderer can skip
+// bytes shared with the previous italic frame, which would leave the terminal
+// italic — plus the resolved color when the theme supplies one. The `inherit`
+// variant is the only choice that keeps Pi's native italic styling.
+const ITALIC_OFF = "\x1b[23m";
 
 type LabelStyle = { prefix: string; suffix: string };
-let liveLabelStyle: LabelStyle | undefined;
-let settledLabelStyle: LabelStyle | undefined;
+
+// The package styles labels only inside a session it can read the theme from.
+// `inherit` is the other native case: it keeps Pi's italic labels.
+function stylesThinkingLabels(): boolean {
+  return themeProvider !== undefined && thoughtLabelColorChoice() !== "inherit";
+}
 
 function styledWith(
   token: string,
-  theme: ThemeDetail | undefined = themeProvider?.(),
+  theme: ThemeDetail | undefined,
 ): LabelStyle | undefined {
-  const ansi = theme?.getFgAnsi?.(token);
+  // Pi's Theme throws on a token it does not know, so probe the way muted.ts
+  // does: an unresolvable color costs the label its tint, never the row.
+  let ansi: string | undefined;
+  try {
+    const resolved = theme?.getFgAnsi?.(token);
+    if (typeof resolved === "string") ansi = resolved;
+  } catch {
+    ansi = undefined;
+  }
   if (!ansi) return undefined;
-  // 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.
-  return { prefix: `\x1b[23m${ansi}`, suffix: "\x1b[39m" };
+  return { prefix: `${ITALIC_OFF}${ansi}`, suffix: "\x1b[39m" };
 }
 
 // The theme's collapsedThinkingCall override when defined, else its comment
 // color, else the muted token.
-function settledMutedStyle(
-  theme: ThemeDetail | undefined,
-): LabelStyle | undefined {
-  const ansi = theme ? collapsedThinkingAnsi(theme) : null;
-  if (ansi) return { prefix: `\x1b[23m${ansi}`, suffix: "\x1b[39m" };
+function settledMutedStyle(theme: ThemeDetail): LabelStyle | undefined {
+  const ansi = collapsedThinkingAnsi(theme);
+  if (ansi) return { prefix: `${ITALIC_OFF}${ansi}`, suffix: "\x1b[39m" };
   return styledWith("muted", theme);
 }
-function updateThoughtLabelStyle(): void {
-  liveLabelStyle = undefined;
-  settledLabelStyle = undefined;
-  const theme = themeProvider?.();
-  stylesTheme = theme;
-  const choice = thoughtLabelColorChoice();
-  if (choice === "inherit" || !theme) return;
 
+// Resolved per label, never cached: Pi swaps the colors behind a stable theme
+// Proxy, so a cached style would survive a theme switch and repaint the
+// transcript in the old palette.
+function labelStyle(
+  settled: boolean,
+  theme: ThemeDetail,
+): LabelStyle | undefined {
+  const choice = thoughtLabelColorChoice();
+  if (settled && choice !== "mdheading") return settledMutedStyle(theme);
   const token =
     choice === "mdheading"
       ? "mdHeading"
       : (LEVEL_TOKEN[activeLevel?.() ?? "off"] ?? "thinkingOff");
-  liveLabelStyle = styledWith(token, theme);
-  settledLabelStyle =
-    choice === "mdheading" ? liveLabelStyle : settledMutedStyle(theme);
-}
-
-// Recompute label styles whenever the theme object has swapped (theme switch
-// or /reload); those transitions fire no extension event.
-function ensureLabelStyles(): void {
-  if (themeProvider?.() !== stylesTheme) updateThoughtLabelStyle();
+  return styledWith(token, theme);
 }
 
 // The settled label is the finalized "+ Thought" row; every other label is
@@ -108,13 +112,14 @@ function isSettledThoughtLabel(label: string): boolean {
 }
 
 export function visibleThoughtLabel(label: string): string {
-  ensureLabelStyles();
-  const style = isSettledThoughtLabel(label)
-    ? settledLabelStyle
-    : liveLabelStyle;
-  if (!style) return label;
+  if (!stylesThinkingLabels()) return label;
   const raw = label.replace(/\x1b\[[0-9;]*m/g, "");
-  return `${style.prefix}${raw}${style.suffix}`;
+  const theme = themeProvider?.();
+  const style = theme
+    ? labelStyle(isSettledThoughtLabel(label), theme)
+    : undefined;
+  // A theme that cannot resolve a color still drops Pi's italics.
+  return style ? `${style.prefix}${raw}${style.suffix}` : `${ITALIC_OFF}${raw}`;
 }
 
 type AssistantMessageLike = {
@@ -133,6 +138,28 @@ type TextLikeChild = {
   setText?(text: string): void;
 };
 
+type MarkdownLikeChild = {
+  defaultTextStyle?: { italic?: boolean };
+  invalidate?(): void;
+};
+
+// Pi renders a visible thinking trace as italic markdown. Italic is the live
+// cue — a settled trace drops it and reads as ordinary transcript text — and
+// the italic default style is what identifies the trace: Pi passes it for
+// thinking content and for nothing else. Callers gate on the row actually
+// carrying thinking, so no other italic block is touched.
+function unitalicizeSettledThinking(row: AssistantMessageRow): void {
+  const children = row.contentContainer?.children;
+  if (!Array.isArray(children)) return;
+  for (const child of children) {
+    const markdown = child as MarkdownLikeChild | undefined;
+    const style = markdown?.defaultTextStyle;
+    if (style?.italic !== true) continue;
+    style.italic = false;
+    markdown?.invalidate?.();
+  }
+}
+
 // 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
@@ -149,7 +176,7 @@ function restyleHiddenThinkingLabel(row: AssistantMessageRow): void {
   const label = row.hiddenThinkingLabel;
   const children = row.contentContainer?.children;
   if (!Array.isArray(children)) return;
-  if (!liveLabelStyle && !settledLabelStyle) return;
+  if (!stylesThinkingLabels()) return;
   const styled = visibleThoughtLabel(label);
   for (const child of children) {
     const textChild = child as TextLikeChild | undefined;
@@ -171,6 +198,10 @@ type ThinkingTiming = {
 
 type ThinkingGroupingPatchState = {
   owners: number;
+  // Set at the final owner's shutdown. A wrapper another extension has buried
+  // cannot be uninstalled, so it delegates instead of outliving its owner; a
+  // later install re-enables it.
+  disabled?: boolean;
   originalUpdateContent: (
     message: AssistantMessageLike,
     ...args: unknown[]
@@ -180,14 +211,39 @@ type ThinkingGroupingPatchState = {
     ...args: unknown[]
   ) => void;
   timings: WeakMap<AssistantMessageRow, ThinkingTiming>;
-  // Last update per row, so /toggle-info can replay rows without waiting for
-  // new content. Cleared on session start; rows are session-lived anyway.
+  // Last update per tracked row, so /toggle-info can replay rows without
+  // waiting for new content. Only rows that carry thinking change under the
+  // toggle, and the map is capped so a long session or an abandoned branch
+  // cannot pin every message the transcript ever showed.
   rows: Map<
     AssistantMessageRow,
     { message: AssistantMessageLike; args: unknown[] }
   >;
 };
 
+const MAX_REPLAY_ROWS = 400;
+
+// Bookkeeping only, so it fails open: a message whose content shape throws
+// must not take the row's update pass down with it.
+function trackReplayRow(
+  state: ThinkingGroupingPatchState,
+  row: AssistantMessageRow,
+  message: AssistantMessageLike,
+  args: unknown[],
+): void {
+  try {
+    if (!hasThinkingContent(message)) return;
+    state.rows.set(row, { message, args });
+    while (state.rows.size > MAX_REPLAY_ROWS) {
+      const oldest = state.rows.keys().next().value;
+      if (oldest === undefined) return;
+      state.rows.delete(oldest);
+    }
+  } catch {
+    // The row keeps its native rendering; only /toggle-info replay misses it.
+  }
+}
+
 type ThinkingContentLike = {
   type: "thinking";
   thinking: string;
@@ -246,30 +302,40 @@ function thinkingSpinner(startedAt: number, now: number): string {
   return PI_SPINNER_FRAMES[frame % PI_SPINNER_FRAMES.length]!;
 }
 
+// A row is live while it streams, and stays live through un-flagged rebuilds
+// (resize, theme switch, /reload) until an explicit final update arrives.
+// Rows that never carry the flag — restored history, older runtimes — count
+// as settled.
+function thinkingStillLive(
+  streaming: boolean | undefined,
+  timing: ThinkingTiming | undefined,
+): boolean {
+  if (streaming === true) return true;
+  return (
+    streaming === undefined &&
+    timing !== undefined &&
+    timing.finishedAt === undefined
+  );
+}
+
 function lifecycleLabel(
   row: AssistantMessageRow,
   streaming: boolean | undefined,
   timings: WeakMap<AssistantMessageRow, ThinkingTiming>,
 ): string {
   const now = Date.now();
-  let current = timings.get(row);
-  if (streaming === true) {
-    if (!current || current.finishedAt !== undefined) {
-      current = { startedAt: now };
-      timings.set(row, current);
-    }
+  const previous = timings.get(row);
+  if (thinkingStillLive(streaming, previous)) {
+    const current =
+      previous && previous.finishedAt === undefined
+        ? previous
+        : { startedAt: now };
+    timings.set(row, current);
     return `${thinkingSpinner(current.startedAt, now)} Thinking…`;
   }
 
-  if (streaming === undefined && current?.finishedAt === undefined && current) {
-    // Pi can rebuild a live row on resize/theme changes without forwarding
-    // the optional streaming flag. Keep its active label until an explicit
-    // final update arrives.
-    return `${thinkingSpinner(current.startedAt, now)} Thinking…`;
-  }
-
-  if (streaming === false && current?.finishedAt === undefined) {
-    if (current) current.finishedAt = now;
+  if (streaming === false && previous && previous.finishedAt === undefined) {
+    previous.finishedAt = now;
   }
 
   const settled = timings.get(row);
@@ -353,6 +419,7 @@ function installThinkingGroupingPatch():
     if (existing) {
       existing.owners++;
       existing.rows ??= new Map();
+      existing.disabled = false;
       return existing;
     }
 
@@ -367,9 +434,14 @@ function installThinkingGroupingPatch():
       message: AssistantMessageLike,
       ...args: unknown[]
     ): void {
-      // Grouping and labels are cosmetic. Each fails open independently, and
+      // Grouping and styling are cosmetic. Each fails open independently, and
       // the original renderer is still called exactly once with every arg.
-      state.rows.set(this, { message, args });
+      if (state.disabled) {
+        Reflect.apply(state.originalUpdateContent, this, [message, ...args]);
+        return;
+      }
+      trackReplayRow(state, this, message, args);
+      const streaming = typeof args[0] === "boolean" ? args[0] : undefined;
       let combined = message;
       try {
         // Pi builds the hidden label and the visible block only when thinking
@@ -381,7 +453,6 @@ function installThinkingGroupingPatch():
         // Preserve the original message intact.
       }
       try {
-        const streaming = typeof args[0] === "boolean" ? args[0] : undefined;
         applyHiddenThinkingLabel(this, combined, streaming, state.timings);
       } catch {
         // Preserve Pi's native label if its private row shape changes.
@@ -392,6 +463,16 @@ function installThinkingGroupingPatch():
       } catch {
         // Keep Pi's native label styling if the row shape changes.
       }
+      try {
+        if (
+          hasThinkingContent(combined) &&
+          !thinkingStillLive(streaming, state.timings.get(this))
+        ) {
+          unitalicizeSettledThinking(this);
+        }
+      } catch {
+        // Keep Pi's native italic trace if the row shape changes.
+      }
     };
 
     state.patchedUpdateContent = patchedUpdateContent;
@@ -412,6 +493,7 @@ function uninstallThinkingGroupingPatch(
   if (!state || state.owners <= 0) return false;
   state.owners--;
   if (state.owners > 0) return false;
+  state.disabled = true;
   const proto =
     AssistantMessageComponent?.prototype as unknown as AssistantMessageRow & {
       [THINKING_GROUPING_PATCHED]?: ThinkingGroupingPatchState;
@@ -453,17 +535,12 @@ export default function (pi: ExtensionAPI) {
         return "off";
       }
     };
-    updateThoughtLabelStyle();
   });
-  pi.on("thinking_level_select", () => updateThoughtLabelStyle());
   pi.on("session_shutdown", () => {
     if (released) return;
     released = true;
     if (patch && !uninstallThinkingGroupingPatch(patch)) return;
     themeProvider = undefined;
     activeLevel = undefined;
-    stylesTheme = undefined;
-    liveLabelStyle = undefined;
-    settledLabelStyle = undefined;
   });
 }