@pi-kaush/pi-tool-call-markers 0.2.11 → 0.3.1

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## Unreleased
 
+- Restyle subagent rows: the subagent marker is now `↪` (was `&`), and single
+  calls drop the `subagent` tool label — `↪ 🤖 [coder][c3po] Implement the…` —
+  with chain/parallel step lines reordered to emoji, profile badge, name badge
+  (`1. 🐝 [workhorse][bee] …`). Single-call headings are now scraped too, so
+  agent emojis appear on single rows, not just chain/parallel steps.
+
+- 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

package/README.md

@@ -34,19 +34,19 @@ Collapsed tool rows use semantic theme colors with no gear, background fill, box
 
 ## Subagent plans
 
-A recognized `subagent` call renders as an unboxed plan in the shared tool aesthetic, marked with `&` instead of the ordinary `%` tool marker:
+A recognized `subagent` call renders as an unboxed plan in the shared tool aesthetic, marked with `↪` instead of the ordinary `%` tool marker:
 
 ```text
-  & subagent chain (3 steps) [repo-review]
+  ↪ subagent chain (3 steps) [repo-review]
     1. 🐝 bee [workhorse] Challenge the compatibility conclusion…
     2. 🐝 bee …
 ```
 
-Single calls stay on one `& subagent <agent> [profile] <task preview>` row; chain calls get a heading with the kind, count, and scope followed by numbered steps (parallel tasks list without numbers). Agent display names (emoji + name) are scraped from the native plan component with an args fallback, and render in `accent`; everything else stays muted, and failed subagents go full red. Subagents never join ordinary tool groups.
+Single calls stay on one `↪ [<emoji>] [<profile>][<agent>] <task preview>` row — no tool label; the `↪` marker identifies it. Chain calls get a heading with the kind, count, and scope followed by numbered steps (parallel tasks list without numbers), with each step ordered emoji, profile badge, name badge. Agent display names (emoji + name) are scraped from the native plan component — including the single-call heading — with an args fallback, and render in `accent`; everything else stays muted, and failed subagents go full red. Subagents never join ordinary tool groups.
 
 While a subagent runs, the plan headline's tail shows live progress from the streamed result details — `→ 1 turn · provider/model` in the warning tone — and a settled call keeps the same `→ N turns · provider/model` summary in muted (turns aggregate across tasks; the model shows only when every task used the same one).
 
-Malformed, ambiguous, future, or too-narrow shapes fall back to the generic `& subagent …` collapsed row rather than dropping information, and `Ctrl+O` still exposes the native subagent renderer.
+Malformed, ambiguous, future, or too-narrow shapes fall back to the generic `↪ subagent …` collapsed row rather than dropping information, and `Ctrl+O` still exposes the native subagent renderer.
 
 ## Edit diffs
 
@@ -100,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.11",
+  "version": "0.3.1",
   "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,10 +16,11 @@ 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 = "%";
-const SUBAGENT_MARKER = "&";
+const SUBAGENT_MARKER = "↪";
 const PRESENTATION_PATCHED = Symbol.for("kg.pi.toolPresentation.v3");
 const LEGACY_PRESENTATION_PATCHED = Symbol.for("kg.pi.toolPresentation.v2");
 const GROUPING_PATCHED = Symbol.for("kg.pi.toolGrouping.v1");
@@ -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
@@ -1021,6 +1028,19 @@ function parseStepContent(content: string): {
   };
 }
 
+// Splits a scraped "emoji name" display into its emoji prefix and bare name;
+// plain names pass through with no emoji.
+function splitEmojiName(
+  displayName: string,
+  bareName: string,
+): { emoji: string; name: string } {
+  const tokens = displayName.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length > 1 && tokens[tokens.length - 1] === bareName) {
+    return { emoji: tokens.slice(0, -1).join(" "), name: bareName };
+  }
+  return { emoji: "", name: bareName };
+}
+
 // Agent display names (emoji + name) come from the subagent extension's own
 // call component when available; args only carry the bare agent name.
 function scrapeSubagentDisplayNames(
@@ -1035,10 +1055,16 @@ function scrapeSubagentDisplayNames(
   try {
     for (const raw of component.render(120)) {
       const line = sanitizeInline(stripAnsi(raw)).trim();
-      if (!line || /^subagent\b/.test(line)) continue;
-      const { displayName, bareName } = parseStepContent(
-        line.replace(/^\d+\.\s*/, ""),
-      );
+      if (!line) continue;
+      // Single calls carry the agent name on their "subagent <name>" heading
+      // line; stripping the heading word (and step numbers) lets both shapes
+      // flow through the same parse. Heading remainders without an emoji
+      // (e.g. "chain (2 steps)") degrade to displayName === bareName and are
+      // skipped by the guard below.
+      const content = line
+        .replace(/^subagent\b\s*/, "")
+        .replace(/^\d+\.\s*/, "");
+      const { displayName, bareName } = parseStepContent(content);
       if (displayName && bareName && displayName !== bareName) {
         names.set(bareName, displayName);
       }
@@ -1084,10 +1110,11 @@ function subagentProgressText(row: ToolExecutionRow): string | undefined {
   return parts.length > 0 ? parts.join(" · ") : undefined;
 }
 
-// Subagents render as an ordinary unboxed tool block: a `%` heading with the
+// Subagents render as an ordinary unboxed tool block: a `↪` heading with the
 // plan kind/count/scope, then the numbered chain steps or parallel tasks with
-// agent names in accent. Everything else stays muted (or error on failure),
-// matching the shared tool-row aesthetic.
+// agent identities (emoji, profile badge, name badge) in accent. Single calls
+// collapse to one row: `↪ <emoji> [<profile>][<name>] <task preview>`. Everything
+// else stays muted (or error on failure), matching the shared tool-row aesthetic.
 function renderSubagentPlan(
   row: ToolExecutionRow,
   width: number,
@@ -1099,20 +1126,27 @@ 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));
+  // Identity order: emoji, then the profile and agent-name badges.
+  const identityOf = (step: SubagentStep) => {
+    const displayName =
+      displayNames.get(step.agent) ?? sanitizeInline(step.agent);
+    const { emoji, name } = splitEmojiName(displayName, step.agent);
+    const accentPart = (text: string) => fgCollapsed(theme, nameColor, text);
+    const emojiPart = emoji ? `${accentPart(emoji)} ` : "";
+    const profilePart = step.profile
+      ? accentPart(`[${sanitizeInline(step.profile)}]`)
+      : "";
+    return `${emojiPart}${profilePart}${accentPart(`[${sanitizeInline(name)}]`)}`;
+  };
   const detailColor = failed ? "error" : "toolOutput";
-  const detailOf = (step: SubagentStep) =>
-    theme.fg(
-      detailColor,
-      `${step.profile ? ` [${sanitizeInline(step.profile)}]` : ""} ${subagentStepPreview(step.task)}`,
-    );
+  const previewOf = (step: SubagentStep) =>
+    fgCollapsed(theme, detailColor, ` ${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 +1154,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 +
@@ -1130,14 +1168,7 @@ function renderSubagentPlan(
 
   if (plan.kind === "single") {
     const step = plan.steps[0]!;
-    return [
-      headline(
-        theme.fg(failed ? "error" : "toolTitle", theme.bold("subagent")) +
-          " " +
-          displayOf(step.agent) +
-          detailOf(step),
-      ),
-    ];
+    return [headline(identityOf(step) + previewOf(step))];
   }
 
   const kindLabel =
@@ -1146,22 +1177,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}.`)} ` : "";
-    lines.push(`  ${number}${displayOf(step.agent)}${detailOf(step)}`);
+      plan.kind === "chain"
+        ? `${fgCollapsed(theme, color, `${index + 1}.`)} `
+        : "";
+    lines.push(`  ${number}${identityOf(step)}${previewOf(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 +1215,7 @@ function imageResultLines(
       .join("\n");
     lines.push(
       ...wrapTextWithAnsi(
-        theme.fg("toolOutput", sanitized),
+        fgCollapsed(theme, "toolOutput", sanitized),
         Math.max(1, width),
       ),
     );
@@ -1238,7 +1271,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 +1285,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
@@ -1681,6 +1714,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,6 +1,7 @@
 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 = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -44,15 +45,22 @@ 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): LabelStyle | undefined {
-  const ansi = activeTheme?.getFgAnsi?.(token);
+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
@@ -61,19 +69,36 @@ function styledWith(token: string): LabelStyle | undefined {
   return { prefix: `\x1b[23m${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" };
+  return styledWith("muted", theme);
+}
 function updateThoughtLabelStyle(): void {
   liveLabelStyle = undefined;
   settledLabelStyle = undefined;
+  const theme = themeProvider?.();
+  stylesTheme = theme;
   const choice = thoughtLabelColorChoice();
-  if (choice === "inherit" || !activeTheme) return;
+  if (choice === "inherit" || !theme) return;
 
   const token =
     choice === "mdheading"
       ? "mdHeading"
       : (LEVEL_TOKEN[activeLevel?.() ?? "off"] ?? "thinkingOff");
-  liveLabelStyle = styledWith(token);
+  liveLabelStyle = styledWith(token, theme);
   settledLabelStyle =
-    choice === "mdheading" ? liveLabelStyle : styledWith("muted");
+    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();
 }
 
 // The settled label is the finalized "+ Thought" row; every other label is
@@ -83,6 +108,7 @@ function isSettledThoughtLabel(label: string): boolean {
 }
 
 export function visibleThoughtLabel(label: string): string {
+  ensureLabelStyles();
   const style = isSettledThoughtLabel(label)
     ? settledLabelStyle
     : liveLabelStyle;
@@ -418,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();
@@ -433,8 +460,9 @@ export default function (pi: ExtensionAPI) {
     if (released) return;
     released = true;
     if (patch && !uninstallThinkingGroupingPatch(patch)) return;
-    activeTheme = undefined;
+    themeProvider = undefined;
     activeLevel = undefined;
+    stylesTheme = undefined;
     liveLabelStyle = undefined;
     settledLabelStyle = undefined;
   });