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

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+- Color collapsed rows (tool calls, `+ Thought`, subagents) from the
+  theme's `syntaxComment` token — which ships with every theme — instead of
+  the louder muted/toolTitle/toolOutput split. The bolded tool name and the
+  call content share the single tone, so collapsed blocks read as one
+  muted unit under any theme without per-theme tuning. Failures stay
+  error-colored and live spinners keep their thinking-level tint.
+- Add optional `collapsedToolCall` and `collapsedThinkingCall` theme color
+  tokens to override each collapsed kind independently; themes without
+  them are unchanged.
+- Fix settled "+ Thought" labels keeping stale colors after a mid-session
+  theme switch: label styles now recompute whenever the theme object
+  changes instead of only on session start and thinking-level selects.
 - Add `/toggle-info`: hide tool calls and thinking entirely, or restore them
   collapsed. Execution rows (including user-run `!` blocks) are lifted out of
   the render pass via the shared chat-container hook; thinking blocks are
@@ -13,10 +25,11 @@
 - Adopt Pi's native content-color split in collapsed rows: tool names ride
   `toolTitle` and call content/outcomes ride `toolOutput` (structural
   chrome stays muted; failed rows stay uniformly error).
-- Tint the collapsed "+ Thought" label with the session's active
-  thinking-level token (thinkingOff…thinkingMax), re-tinting on
+- Quiet the settled "+ Thought" label to the muted tone collapsed tool
+  calls use; only the live "⠋ Thinking…" spinner keeps the session's active
+  thinking-level tint (thinkingOff…thinkingMax), re-tinting on
   thinking_level_select; the expanded thinking block is untouched. The
-  PI_TOOL_CALL_MARKERS_THOUGHT_COLOR values are now `level` (default),
+  PI_TOOL_CALL_MARKERS_THOUGHT_COLOR values are `level` (default),
   `mdheading`, and `inherit`; the midpoint `gray` variant and its RGB
   color math are gone.
 - Paint user-run `!` bash block surfaces with the theme's

package/README.md

@@ -2,6 +2,14 @@
 
 Give Pi's collapsed tool calls a quiet, width-safe transcript shell while preserving native details under `Ctrl+O`. The package also includes a display-only thinking-block adapter.
 
+### Install
+
+```fish
+pi install npm:@pi-kaush/pi-tool-call-markers
+```
+
+Restart Pi or run `/reload`.
+
 ## What it changes
 
 Collapsed tool rows use semantic theme colors with no gear, background fill, box padding, or filled blank rows:
@@ -73,15 +81,9 @@ When Pi exposes its per-row hidden-thinking and streaming fields, hidden reasoni
 
 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.
 
-## Install
-
-```bash
-pi install npm:@pi-kaush/pi-tool-call-markers
-```
-
-For local development:
+## Local development
 
-```bash
+```fish
 pi \
   -e ./extensions/pi-tool-call-markers/src/index.ts \
   -e ./extensions/pi-tool-call-markers/src/thinking-block-merger.ts
@@ -98,6 +100,21 @@ pi
 
 `0`, `false`, `no`, and `off` disable parallel grouping. `1`, `true`, `yes`, and `on` enable it. The value is read when the extension loads.
 
+### Collapsed-row colors
+
+Collapsed rows (tool calls, `+ Thought`, subagents) default to the theme's `syntaxComment` color — it ships with every Pi theme and reads as a muted tone — with the bolded tool name and the call content sharing it. Failures stay error-colored and live spinners keep their existing tints.
+
+A theme can override each collapsed kind independently with optional color tokens:
+
+```json
+{
+  "colors": {
+    "collapsedToolCall": "#6272a4",
+    "collapsedThinkingCall": "#6272a4"
+  }
+}
+```
+
 ## Compatibility and fallback policy
 
 **Compatible Pi version:** `@earendil-works/pi-coding-agent` and `@earendil-works/pi-tui` `>=0.80.6`.

package/package.json

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

package/src/index.ts

@@ -16,6 +16,7 @@ import {
 } from "./bash-block.ts";
 import { runChatContainerHooks } from "./container-hooks.ts";
 import { installInfoVisibility } from "./info-visibility.ts";
+import { fgCollapsed } from "./muted.ts";
 
 const OUTER_INSET = 2;
 const GROUP_MARKER = "%";
@@ -29,6 +30,8 @@ const COLLAPSE_PARALLEL_ENV = "PI_TOOL_CALL_MARKERS_COLLAPSE_PARALLEL";
 type ThemeLike = {
   bold(text: string): string;
   fg(color: string, text: string): string;
+  getFgAnsi?(color: string): string;
+  getColorMode?(): "truecolor" | "256color" | string;
 };
 
 type ComponentLike = {
@@ -252,7 +255,7 @@ function capFailureTail(tail: string, cap: number, theme: ThemeLike): string {
 }
 
 function renderedGenericOutcome(theme: ThemeLike): string {
-  return theme.fg("toolOutput", "→ done");
+  return fgCollapsed(theme, "toolOutput", "→ done");
 }
 
 // The MCP adapter stashes its call's first line in renderer state before
@@ -637,7 +640,7 @@ function renderedEditDiffLines(
   for (const line of raw.slice(0, MAX_EDIT_DIFF_LINES)) {
     const clean = sanitizeInline(line).trimEnd();
     if (clean.trim() === "...") {
-      lines.push(theme.fg("muted", "  ..."));
+      lines.push(fgCollapsed(theme, "muted", "  ..."));
       continue;
     }
     const match = EDIT_DIFF_LINE_RE.exec(clean);
@@ -652,7 +655,11 @@ function renderedEditDiffLines(
   }
   if (raw.length > MAX_EDIT_DIFF_LINES) {
     lines.push(
-      theme.fg("muted", `  ... +${raw.length - MAX_EDIT_DIFF_LINES} more`),
+      fgCollapsed(
+        theme,
+        "muted",
+        `  ... +${raw.length - MAX_EDIT_DIFF_LINES} more`,
+      ),
     );
   }
   return lines;
@@ -706,7 +713,7 @@ function renderedOutcome(
 ): string | undefined {
   const summary = outcomeSummary(row);
   if (!summary) return undefined;
-  return theme.fg("toolOutput", `→ ${summary}`);
+  return fgCollapsed(theme, "toolOutput", `→ ${summary}`);
 }
 
 function renderedGroupedOutcome(
@@ -835,10 +842,10 @@ function renderedCallSummary(
           .map(trimRenderedLine)
           .filter(hasVisibleContent);
         if (visibleLines.length > rendered.length)
-          continuations.push(theme.fg("muted", "…"));
+          continuations.push(fgCollapsed(theme, "muted", "…"));
         const compact = [firstSummary, ...continuations]
           .filter(hasVisibleContent)
-          .join(theme.fg("muted", " · "));
+          .join(fgCollapsed(theme, "muted", " · "));
         if (hasVisibleContent(compact)) return compact;
       }
     }
@@ -846,8 +853,8 @@ function renderedCallSummary(
 
   const fallback = compactArgs(row.args);
   return fallback
-    ? theme.fg("toolOutput", fallback)
-    : theme.fg("muted", "(no arguments)");
+    ? fgCollapsed(theme, "toolOutput", fallback)
+    : fgCollapsed(theme, "muted", "(no arguments)");
 }
 
 function styledCallLabel(
@@ -857,15 +864,14 @@ function styledCallLabel(
 ): string {
   const plain = sanitizeInline(stripAnsi(label)).trim();
   const match = /^(\S+)(.*)$/s.exec(plain);
-  if (!match) return theme.fg(color, plain);
+  if (!match) return fgCollapsed(theme, 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;
+  // 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 (
-    theme.fg(nameColor, theme.bold(match[1] ?? "")) +
-    (rest ? theme.fg(restColor, `:${rest}`) : "")
+    fgCollapsed(theme, color, match[1] ?? "", true) +
+    (rest ? fgCollapsed(theme, color, `:${rest}`) : "")
   );
 }
 
@@ -904,7 +910,7 @@ function collapsedOutcome(
   }
   if (row.getRenderShell?.() === "self") {
     const editStat = renderedEditDiffStat(row);
-    if (editStat) return theme.fg("toolOutput", `→ ${editStat}`);
+    if (editStat) return fgCollapsed(theme, "toolOutput", `→ ${editStat}`);
     return renderedGenericOutcome(theme);
   }
   return renderedOutcome(row, theme);
@@ -917,18 +923,19 @@ function collapsedHeadline(
 ): 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 color = rowHasFailed(row) ? "error" : "muted";
-  const marker = `${theme.fg(
-    color,
+  const tone = rowHasFailed(row) ? "error" : "muted";
+  const marker = `${fgCollapsed(
+    theme,
+    tone,
     row.toolName === "subagent" ? SUBAGENT_MARKER : GROUP_MARKER,
   )} `;
   const budget = Math.max(1, width - visibleWidth(marker));
-  const label = collapsedCallLabel(row, budget, theme, color);
+  const label = collapsedCallLabel(row, budget, theme, tone);
   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 = theme.fg(color, "…");
+  const suffix = fgCollapsed(theme, tone, "…");
   return (
     marker +
     (outcome
@@ -1099,20 +1106,25 @@ function renderSubagentPlan(
   const failed = rowHasFailed(row);
   const color = failed ? "error" : "muted";
   const nameColor = failed ? "error" : "accent";
-  const suffix = theme.fg(color, "…");
+  const suffix = fgCollapsed(theme, color, "…");
   const displayNames = scrapeSubagentDisplayNames(row);
   // Agent/profile/task values are model-supplied; sanitize them like every
   // other collapsed-row text so control bytes cannot reach the terminal.
   const displayOf = (agent: string) =>
-    theme.fg(nameColor, displayNames.get(agent) ?? sanitizeInline(agent));
+    fgCollapsed(
+      theme,
+      nameColor,
+      displayNames.get(agent) ?? sanitizeInline(agent),
+    );
   const detailColor = failed ? "error" : "toolOutput";
   const detailOf = (step: SubagentStep) =>
-    theme.fg(
+    fgCollapsed(
+      theme,
       detailColor,
       `${step.profile ? ` [${sanitizeInline(step.profile)}]` : ""} ${subagentStepPreview(step.task)}`,
     );
 
-  const marker = `${theme.fg(color, theme.bold(SUBAGENT_MARKER))} `;
+  const marker = `${fgCollapsed(theme, color, SUBAGENT_MARKER, true)} `;
   const budget = Math.max(1, width - visibleWidth(marker));
   const progress = subagentProgressText(row);
   const outcome = failed
@@ -1120,7 +1132,11 @@ function renderSubagentPlan(
     : isLiveRow(row)
       ? theme.fg("warning", progress ? `→ ${progress}` : "…")
       : row.result
-        ? theme.fg("toolOutput", progress ? `→ ${progress}` : "→ done")
+        ? fgCollapsed(
+            theme,
+            "toolOutput",
+            progress ? `→ ${progress}` : "→ done",
+          )
         : theme.fg("warning", "…");
   const headline = (label: string) =>
     marker +
@@ -1132,7 +1148,7 @@ function renderSubagentPlan(
     const step = plan.steps[0]!;
     return [
       headline(
-        theme.fg(failed ? "error" : "toolTitle", theme.bold("subagent")) +
+        fgCollapsed(theme, failed ? "error" : "toolTitle", "subagent", true) +
           " " +
           displayOf(step.agent) +
           detailOf(step),
@@ -1146,22 +1162,24 @@ function renderSubagentPlan(
       : `parallel (${plan.steps.length} tasks)`;
   const lines = [
     headline(
-      theme.fg(failed ? "error" : "toolTitle", theme.bold("subagent")) +
+      fgCollapsed(theme, failed ? "error" : "toolTitle", "subagent", true) +
         " " +
-        theme.fg(failed ? "error" : "toolOutput", kindLabel) +
-        theme.fg(failed ? "error" : "toolOutput", ` [${plan.scope}]`),
+        fgCollapsed(theme, failed ? "error" : "toolOutput", kindLabel) +
+        fgCollapsed(theme, failed ? "error" : "toolOutput", ` [${plan.scope}]`),
     ),
   ];
   const shown = plan.steps.slice(0, 3);
   for (let index = 0; index < shown.length; index++) {
     const step = shown[index]!;
     const number =
-      plan.kind === "chain" ? `${theme.fg(color, `${index + 1}.`)} ` : "";
+      plan.kind === "chain"
+        ? `${fgCollapsed(theme, color, `${index + 1}.`)} `
+        : "";
     lines.push(`  ${number}${displayOf(step.agent)}${detailOf(step)}`);
   }
   if (plan.steps.length > shown.length) {
     lines.push(
-      `  ${theme.fg(color, `... +${plan.steps.length - shown.length} more`)}`,
+      `  ${fgCollapsed(theme, color, `... +${plan.steps.length - shown.length} more`)}`,
     );
   }
   return lines;
@@ -1182,7 +1200,7 @@ function imageResultLines(
       .join("\n");
     lines.push(
       ...wrapTextWithAnsi(
-        theme.fg("toolOutput", sanitized),
+        fgCollapsed(theme, "toolOutput", sanitized),
         Math.max(1, width),
       ),
     );
@@ -1238,7 +1256,7 @@ function groupedChildLabel(
     Math.max(0, visibleWidth(label) - prefixWidth),
     true,
   );
-  return child || theme.fg(color, "(no arguments)");
+  return child || fgCollapsed(theme, color, "(no arguments)");
 }
 
 function renderGroupedCallLines(
@@ -1252,17 +1270,17 @@ function renderGroupedCallLines(
     const toolName = row.toolName ?? "tool";
     if (toolName !== previousToolName) {
       lines.push(
-        `${theme.fg("muted", GROUP_MARKER)} ${theme.fg("toolTitle", theme.bold(toolName))}`,
+        `${fgCollapsed(theme, "muted", GROUP_MARKER)} ${fgCollapsed(theme, "toolTitle", toolName, true)}`,
       );
       previousToolName = toolName;
     }
 
     const color = rowHasFailed(row) ? "error" : "muted";
-    const prefix = `  ${theme.fg(color, "•")} `;
+    const prefix = `  ${fgCollapsed(theme, 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, "…");
+    const suffix = fgCollapsed(theme, color, "…");
     lines.push(
       prefix +
         (outcome
@@ -1660,6 +1678,14 @@ function uninstallPresentationPatch(
   delete proto[PRESENTATION_PATCHED];
 }
 
+// TODO(compaction cards): native/failed compaction cards in the transcript
+// are currently rendered by the pi-verbatim-compaction extension. Its
+// src/chat-log.ts is deliberately self-contained (public Pi imports only), so
+// porting here is: drop in that file, registerEntryRenderer(COMPACTION_LOG_TYPE),
+// and wire pi.on("session_compact") / pi.on("session_compact_failed") filtered
+// to fromExtension === false. Do this only if pi-verbatim-compaction is
+// removed or native cards should exist without it; while both are installed,
+// rendering here too would double-render every native compaction.
 export default function (pi: ExtensionAPI) {
   const patch = installPresentationPatch();
   const grouping = patch ? installGroupingPatch(patch) : undefined;
@@ -1673,6 +1699,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;

package/src/muted.ts

@@ -0,0 +1,80 @@
+// Collapsed-row color policy.
+//
+// Collapsed blocks (tool calls, settled "+ Thought" labels, subagent rows)
+// default to the theme's `syntaxComment` token — it ships with every Pi
+// theme and reads as a muted tone — instead of the louder
+// muted/toolTitle/toolOutput split. A theme can override each collapsed
+// kind independently with a `collapsedToolCall` or `collapsedThinkingCall`
+// color token.
+//
+// Failures always fall back to the historical tokens.
+
+const TOOL_OVERRIDE_TOKEN = "collapsedToolCall";
+const THINKING_OVERRIDE_TOKEN = "collapsedThinkingCall";
+const DEFAULT_TOKEN = "syntaxComment";
+
+type CollapsedTheme = {
+  fg(color: string, text: string): string;
+  bold?(text: string): string;
+  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>>();
+
+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;
+  } catch {
+    ansi = null;
+  }
+  cache.set(token, ansi);
+  return ansi;
+}
+
+// Override token when defined, else the theme's syntaxComment color, else
+// null (caller falls back to the historical tokens).
+function collapsedAnsi(
+  theme: CollapsedTheme,
+  overrideToken: string,
+): string | null {
+  return tokenAnsi(theme, overrideToken) ?? tokenAnsi(theme, DEFAULT_TOKEN);
+}
+
+export function collapsedToolAnsi(theme: CollapsedTheme): string | null {
+  return collapsedAnsi(theme, TOOL_OVERRIDE_TOKEN);
+}
+
+export function collapsedThinkingAnsi(theme: CollapsedTheme): string | null {
+  return collapsedAnsi(theme, THINKING_OVERRIDE_TOKEN);
+}
+
+// One styling entry point for collapsed-row text. `color` is the historical
+// token role ("muted", "toolOutput", "toolTitle", "accent", "error"); error
+// keeps its semantic color in all paths.
+export function fgCollapsed(
+  theme: CollapsedTheme,
+  color: string,
+  text: string,
+  bold = false,
+): string {
+  if (color !== "error") {
+    const ansi = collapsedToolAnsi(theme);
+    if (ansi) {
+      return bold
+        ? `${ansi}\x1b[1m${text}\x1b[22m\x1b[39m`
+        : `${ansi}${text}\x1b[39m`;
+    }
+  }
+  return theme.fg(color, bold && theme.bold ? theme.bold(text) : text);
+}

package/src/thinking-block-merger.ts

@@ -1,18 +1,22 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { AssistantMessageComponent } from "@earendil-works/pi-coding-agent";
 import { infoVisibilityHidden } from "./info-visibility-state.ts";
+import { collapsedThinkingAnsi } from "./muted.ts";
 
 const THINKING_GROUPING_PATCHED = Symbol.for("kg.pi.thinkingGrouping.v2");
 const PI_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 const SPINNER_INTERVAL_MS = 80;
 
-// Visual experiment for the settled "+ Thought" label. "inherit" keeps Pi's
-// native styling (italic + thinkingText); "mdheading" rides the theme's
-// mdHeading token; the default tints the label with the session's active
-// thinking-level color (thinkingOff…thinkingMax), so the collapsed label
-// quietly advertises the level Pi is reasoning at. Only the collapsed label
-// is restyled — the expanded thinking block keeps Pi's thinkingText. The env
-// var overrides the default so variants can be compared without republishing.
+// Visual treatment for the collapsed thinking label. The live "Thinking…"
+// spinner tints with the session's active thinking-level color
+// (thinkingOff…thinkingMax), so progress reads as activity; the settled
+// "+ Thought" row drops to the muted token collapsed tool calls use, so
+// finished reasoning stops advertising the level. "inherit" keeps Pi's
+// native styling (italic + thinkingText) for both states, and "mdheading"
+// rides the theme's mdHeading token for both. The env var overrides the
+// default so variants can be compared without republishing. Only the
+// collapsed label is restyled — the expanded thinking block keeps Pi's
+// thinkingText.
 const THOUGHT_LABEL_COLOR_ENV = "PI_TOOL_CALL_MARKERS_THOUGHT_COLOR";
 type ThoughtLabelColor = "inherit" | "level" | "mdheading";
 const DEFAULT_THOUGHT_LABEL_COLOR: ThoughtLabelColor = "level";
@@ -41,38 +45,76 @@ type ThemeDetail = {
   getColorMode?(): "truecolor" | "256color" | string;
 };
 
-let activeTheme: ThemeDetail | undefined;
+// Live reference into the UI context: reading .theme per check keeps label
+// 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;
+
+type LabelStyle = { prefix: string; suffix: string };
+let liveLabelStyle: LabelStyle | undefined;
+let settledLabelStyle: LabelStyle | undefined;
+
+function styledWith(
+  token: string,
+  theme: ThemeDetail | undefined = themeProvider?.(),
+): LabelStyle | undefined {
+  const ansi = theme?.getFgAnsi?.(token);
+  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" };
+}
 
-let thoughtLabelPrefix = "";
-let thoughtLabelSuffix = "";
-
+// 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" };
+  return styledWith("muted", theme);
+}
 function updateThoughtLabelStyle(): void {
-  thoughtLabelPrefix = "";
-  thoughtLabelSuffix = "";
+  liveLabelStyle = undefined;
+  settledLabelStyle = undefined;
+  const theme = themeProvider?.();
+  stylesTheme = theme;
   const choice = thoughtLabelColorChoice();
-  if (choice === "inherit" || !activeTheme) return;
+  if (choice === "inherit" || !theme) return;
 
-  let ansi: string | undefined;
   const token =
     choice === "mdheading"
       ? "mdHeading"
       : (LEVEL_TOKEN[activeLevel?.() ?? "off"] ?? "thinkingOff");
-  ansi = activeTheme.getFgAnsi?.(token);
-  if (!ansi) return;
+  liveLabelStyle = styledWith(token, theme);
+  settledLabelStyle =
+    choice === "mdheading" ? liveLabelStyle : settledMutedStyle(theme);
+}
 
-  // The styled label replaces Pi's italicized Text node wholesale (see
-  // restyleHiddenThinkingLabel). The leading italic-off still matters: the
-  // TUI's diff renderer can skip bytes shared with the previously drawn
-  // italic line, leaving the terminal in italic state otherwise.
-  thoughtLabelPrefix = `\x1b[23m${ansi}`;
-  thoughtLabelSuffix = "\x1b[39m";
+// 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();
+}
+
+// The settled label is the finalized "+ Thought" row; every other label is
+// the live spinner.
+function isSettledThoughtLabel(label: string): boolean {
+  return label.startsWith("+ Thought");
 }
 
 export function visibleThoughtLabel(label: string): string {
-  if (!thoughtLabelPrefix) return label;
+  ensureLabelStyles();
+  const style = isSettledThoughtLabel(label)
+    ? settledLabelStyle
+    : liveLabelStyle;
+  if (!style) return label;
   const raw = label.replace(/\x1b\[[0-9;]*m/g, "");
-  return `${thoughtLabelPrefix}${raw}${thoughtLabelSuffix}`;
+  return `${style.prefix}${raw}${style.suffix}`;
 }
 
 type AssistantMessageLike = {
@@ -98,7 +140,6 @@ type TextLikeChild = {
 // terminal. Swap the node's text for a self-contained styled version after
 // each native render pass instead.
 function restyleHiddenThinkingLabel(row: AssistantMessageRow): void {
-  if (!thoughtLabelPrefix) return;
   if (
     row.hideThinkingBlock !== true ||
     typeof row.hiddenThinkingLabel !== "string"
@@ -108,6 +149,7 @@ function restyleHiddenThinkingLabel(row: AssistantMessageRow): void {
   const label = row.hiddenThinkingLabel;
   const children = row.contentContainer?.children;
   if (!Array.isArray(children)) return;
+  if (!liveLabelStyle && !settledLabelStyle) return;
   const styled = visibleThoughtLabel(label);
   for (const child of children) {
     const textChild = child as TextLikeChild | undefined;
@@ -402,7 +444,8 @@ export default function (pi: ExtensionAPI) {
     } catch {
       // Best effort; stale rows would only linger until the process exits.
     }
-    activeTheme = ctx.ui.theme as unknown as ThemeDetail;
+    const uiCtx = ctx;
+    themeProvider = () => uiCtx.ui?.theme as unknown as ThemeDetail;
     activeLevel = () => {
       try {
         return pi.getThinkingLevel();
@@ -417,9 +460,10 @@ export default function (pi: ExtensionAPI) {
     if (released) return;
     released = true;
     if (patch && !uninstallThinkingGroupingPatch(patch)) return;
-    activeTheme = undefined;
+    themeProvider = undefined;
     activeLevel = undefined;
-    thoughtLabelPrefix = "";
-    thoughtLabelSuffix = "";
+    stylesTheme = undefined;
+    liveLabelStyle = undefined;
+    settledLabelStyle = undefined;
   });
 }