@pi-kaush/pi-tool-call-markers 0.3.13 → 0.3.15

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+- Fix assistant replies vanishing behind the thinking label. The label
+  restyle matched any text node containing the label, so a reply that quoted
+  `Thinking...` or `│ * Thought` was replaced by the label until Ctrl+T. Only
+  Pi's thinking-run label nodes are restyled now, on an exact match, and only
+  on rows that carry thinking.
+- Keep the live thinking spinner moving between thinking deltas. The frame is
+  read from the clock on each redraw that Pi's working indicator already
+  drives, instead of only when new thinking text arrives.
+
+- Anchor the settled thinking label like a collapsed tool call:
+  `│ * Thought · 2.5s` instead of `+ Thought · 2.5s`. The faint rail and
+  bold glyph match the tool rows around it, so a turn that alternates
+  thinking and calls reads as one column. The live label takes the same
+  anchor, `│ ⠋ Thinking…`, with the spinner in the glyph slot, so settling
+  swaps only the glyph, the words, and the tint instead of shifting the text
+  two columns and drawing a rail in.
+
 - Paint collapsed rows with the theme's `dim` token instead of
   `syntaxComment`. Pi's generated `system` theme solves `syntaxComment` to
   the same contrast as `muted` and `toolOutput`, so collapsed tool calls

package/README.md

@@ -97,11 +97,11 @@ The second package entrypoint, `src/thinking-block-merger.ts`, combines only dir
 When Pi exposes its per-row hidden-thinking and streaming fields, hidden reasoning uses these native-themed labels:
 
 ```text
-⠋ Thinking…  →  ⠙ Thinking…  →  …
-+ Thought · 2.5s
+│ ⠋ Thinking…  →  │ ⠙ Thinking…  →  …
+│ * 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`. There is no interval, timeout, render request, model call, or network work.
+The live label samples Pi's native braille spinner sequence from the clock each time the TUI draws it, so it steps with the redraws Pi's working indicator already drives instead of freezing between bursty thinking deltas. It does not add a timer; with the working indicator hidden, the spinner advances on each content update. 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`. Both labels borrow the collapsed tool-row anchor — a faint `│` rail and a bold glyph — so reasoning reads like the tool calls around it. The spinner holds the glyph slot and settles into `*` in place: the rail and the label text keep their columns, and the rail keeps the settled tone throughout. 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.
 
@@ -135,7 +135,7 @@ Names are comma-separated and matched exactly. Listed rows never join a group, a
 
 ### Collapsed-row colors
 
-Collapsed rows (tool calls, `+ Thought`, subagents) default to the theme's `dim` color — it ships with every Pi theme and sits below `muted`, including in the generated `system` theme — with the row's anchor and the call content sharing it. Failures stay error-colored and live spinners keep their existing tints.
+Collapsed rows (tool calls, `│ * Thought`, subagents) default to the theme's `dim` color — it ships with every Pi theme and sits below `muted`, including in the generated `system` theme — with the row's anchor 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:
 

package/package.json

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

package/src/muted.ts

@@ -1,6 +1,6 @@
 // Collapsed-row color policy.
 //
-// Collapsed blocks (tool calls, settled "+ Thought" labels, subagent rows)
+// Collapsed blocks (tool calls, settled "│ * Thought" labels, subagent rows)
 // default to the theme's `dim` token — it ships with every Pi theme and sits
 // below `muted` — instead of the louder muted/toolTitle/toolOutput split.
 // Pi's generated `system` theme solves `syntaxComment` to the same contrast

package/src/thinking-block-merger.ts

@@ -10,7 +10,7 @@ const SPINNER_INTERVAL_MS = 80;
 // 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
+// "│ * 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
@@ -105,21 +105,45 @@ function labelStyle(
   return styledWith(token, theme);
 }
 
-// The settled label is the finalized "+ Thought" row; every other label is
-// the live spinner.
+// Both labels wear the collapsed tool-row anchor — faint rail, bold glyph —
+// so reasoning reads like the tool calls around it. The live spinner holds
+// the glyph slot and settles into `*` in place: the rail and the label text
+// keep their columns, and only the glyph, the words, and the tint change.
+const THOUGHT_RAIL = "│";
+const THOUGHT_GLYPH = "*";
+const SETTLED_THOUGHT = `${THOUGHT_RAIL} ${THOUGHT_GLYPH} Thought`;
+const ANCHORED_LABEL_RE = /^│ (\S) (.*)$/su;
+
 function isSettledThoughtLabel(label: string): boolean {
-  return label.startsWith("+ Thought");
+  return label.startsWith(SETTLED_THOUGHT);
+}
+
+// The rail keeps the settled collapsed tone in both states, like a pending
+// tool row's rail, so settling never repaints it.
+function styledAnchoredLabel(
+  raw: string,
+  style: LabelStyle,
+  theme: ThemeDetail,
+): string {
+  const match = ANCHORED_LABEL_RE.exec(raw);
+  if (!match) return `${style.prefix}${raw}${style.suffix}`;
+  const rail = settledMutedStyle(theme) ?? style;
+  const railText = `\x1b[2m${THOUGHT_RAIL}\x1b[22m`;
+  const body = ` \x1b[1m${match[1]}\x1b[22m ${match[2]}${style.suffix}`;
+  return rail.prefix === style.prefix
+    ? `${style.prefix}${railText}${body}`
+    : `${rail.prefix}${railText}${rail.suffix}${style.prefix}${body}`;
 }
 
 export function visibleThoughtLabel(label: string): string {
   if (!stylesThinkingLabels()) return label;
   const raw = label.replace(/\x1b\[[0-9;]*m/g, "");
   const theme = themeProvider?.();
-  const style = theme
-    ? labelStyle(isSettledThoughtLabel(label), theme)
-    : undefined;
+  const settled = isSettledThoughtLabel(raw);
+  const style = theme ? labelStyle(settled, theme) : undefined;
   // A theme that cannot resolve a color still drops Pi's italics.
-  return style ? `${style.prefix}${raw}${style.suffix}` : `${ITALIC_OFF}${raw}`;
+  if (!style || !theme) return `${ITALIC_OFF}${raw}`;
+  return styledAnchoredLabel(raw, style, theme);
 }
 
 type AssistantMessageLike = {
@@ -136,6 +160,7 @@ type AssistantMessageRow = {
 type TextLikeChild = {
   text?: unknown;
   setText?(text: string): void;
+  render?(width: number): string[];
 };
 
 type MarkdownLikeChild = {
@@ -179,7 +204,63 @@ function unitalicizeSettledThinking(row: AssistantMessageRow): void {
 // previous (italic) frame, so an in-line italic reset may never reach the
 // terminal. Swap the node's text for a self-contained styled version after
 // each native render pass instead.
-function restyleHiddenThinkingLabel(row: AssistantMessageRow): void {
+//
+// Only label nodes qualify. Answer prose and a click-revealed trace are
+// Markdown nodes that also carry `text` and `setText`, so Markdown never
+// matches, and a candidate's plain text must equal the label exactly. Pi 1.0
+// wraps each thinking run in a MouseRegion; each child is judged on its own,
+// unwrapped when it has a wrapped inner.
+function hiddenLabelNodes(row: AssistantMessageRow): unknown[] {
+  const children = row.contentContainer?.children;
+  if (!Array.isArray(children)) return [];
+  return children
+    .map((child) => (child as { child?: unknown } | undefined)?.child ?? child)
+    .filter((node) => !isMarkdownLike(node));
+}
+
+// Duck-typed, not `instanceof`: a locally loaded extension can resolve its
+// own pi-tui copy, so class identity is not shared with Pi's. pi-tui's
+// Markdown declares `theme` and `defaultTextStyle` fields; Text has neither.
+function isMarkdownLike(node: unknown): boolean {
+  return (
+    !!node &&
+    typeof node === "object" &&
+    ("defaultTextStyle" in node || "theme" in node)
+  );
+}
+
+function plainText(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// A live label re-reads the clock whenever the TUI draws it, so the spinner
+// steps with the redraws Pi's working indicator already drives instead of
+// freezing between bursty thinking deltas. Pi rebuilds the label node on
+// every content update, so the override dies with the node; no timer is
+// added, and with no redraws the spinner still advances on each delta.
+function animateLiveLabel(node: TextLikeChild, startedAt: number): void {
+  const render = node.render;
+  if (typeof render !== "function") return;
+  node.render = function renderLiveThinkingLabel(
+    this: TextLikeChild,
+    width: number,
+  ): string[] {
+    try {
+      const styled = visibleThoughtLabel(
+        liveThinkingLabel(startedAt, Date.now()),
+      );
+      if (this.text !== styled) this.setText?.(styled);
+    } catch {
+      // Keep the last frame if styling fails mid-render.
+    }
+    return Reflect.apply(render, this, [width]) as string[];
+  };
+}
+
+function restyleHiddenThinkingLabel(
+  row: AssistantMessageRow,
+  liveSince?: number,
+): void {
   if (
     row.hideThinkingBlock !== true ||
     typeof row.hiddenThinkingLabel !== "string"
@@ -189,16 +270,18 @@ function restyleHiddenThinkingLabel(row: AssistantMessageRow): void {
   const label = row.hiddenThinkingLabel;
   if (!stylesThinkingLabels()) return;
   const styled = visibleThoughtLabel(label);
-  for (const child of contentNodes(row)) {
+  const plainLabel = plainText(label);
+  for (const child of hiddenLabelNodes(row)) {
     const textChild = child as TextLikeChild | undefined;
     if (
       typeof textChild?.text !== "string" ||
       typeof textChild.setText !== "function" ||
-      !textChild.text.includes(label)
+      plainText(textChild.text) !== plainLabel
     ) {
       continue;
     }
     textChild.setText(styled);
+    if (liveSince !== undefined) animateLiveLabel(textChild, liveSince);
   }
 }
 
@@ -243,7 +326,9 @@ function trackReplayRow(
   args: unknown[],
 ): void {
   try {
-    if (!hasThinkingContent(message)) return;
+    // A tracked row keeps tracking even when its final content drops
+    // thinking, so a replay never resurrects an earlier streaming snapshot.
+    if (!hasThinkingContent(message) && !state.rows.has(row)) return;
     state.rows.set(row, { message, args });
     while (state.rows.size > MAX_REPLAY_ROWS) {
       const oldest = state.rows.keys().next().value;
@@ -308,6 +393,10 @@ function formatThoughtDuration(startedAt: number, finishedAt: number): string {
   return `${(Math.max(0, finishedAt - startedAt) / 1000).toFixed(1)}s`;
 }
 
+function liveThinkingLabel(startedAt: number, now: number): string {
+  return `${THOUGHT_RAIL} ${thinkingSpinner(startedAt, now)} Thinking…`;
+}
+
 function thinkingSpinner(startedAt: number, now: number): string {
   const frame = Math.floor(Math.max(0, now - startedAt) / SPINNER_INTERVAL_MS);
   return PI_SPINNER_FRAMES[frame % PI_SPINNER_FRAMES.length]!;
@@ -329,31 +418,67 @@ function thinkingStillLive(
   );
 }
 
+// Thinking ends when the answer starts: visible text or a tool call after
+// the last thinking block. Settling there keeps the duration honest and
+// keeps a live label as the transcript's last line, so its spinner never
+// changes a line scrolled above the viewport (which forces a full replay).
+function answerStarted(message: AssistantMessageLike): boolean {
+  const content = Array.isArray(message.content) ? message.content : [];
+  let lastThinking = -1;
+  content.forEach((block, index) => {
+    if (isThinkingContent(block)) lastThinking = index;
+  });
+  return content.slice(lastThinking + 1).some((block) => {
+    const b = block as { type?: unknown; text?: unknown } | undefined;
+    return (
+      b?.type === "toolCall" ||
+      (b?.type === "text" && typeof b.text === "string" && b.text.trim() !== "")
+    );
+  });
+}
+
+function timingLive(
+  streaming: boolean | undefined,
+  timing: ThinkingTiming | undefined,
+): boolean {
+  return (
+    streaming !== false &&
+    timing !== undefined &&
+    timing.finishedAt === undefined
+  );
+}
+
 function lifecycleLabel(
   row: AssistantMessageRow,
+  message: AssistantMessageLike,
   streaming: boolean | undefined,
   timings: WeakMap<AssistantMessageRow, ThinkingTiming>,
 ): string {
   const now = Date.now();
   const previous = timings.get(row);
-  if (thinkingStillLive(streaming, previous)) {
+  const answering = answerStarted(message);
+  if (!answering && thinkingStillLive(streaming, previous)) {
     const current =
       previous && previous.finishedAt === undefined
         ? previous
         : { startedAt: now };
     timings.set(row, current);
-    return `${thinkingSpinner(current.startedAt, now)} Thinking…`;
+    return liveThinkingLabel(current.startedAt, now);
   }
 
-  if (streaming === false && previous && previous.finishedAt === undefined) {
+  if (
+    (streaming === false || answering) &&
+    previous &&
+    previous.finishedAt === undefined
+  ) {
     previous.finishedAt = now;
   }
 
   const settled = timings.get(row);
   if (settled?.finishedAt !== undefined) {
-    return `+ Thought · ${formatThoughtDuration(settled.startedAt, settled.finishedAt)}`;
+    return `${SETTLED_THOUGHT} · ${formatThoughtDuration(settled.startedAt, settled.finishedAt)}`;
   }
-  return "+ Thought";
+  return SETTLED_THOUGHT;
 }
 
 function stripThinkingBlocks(
@@ -398,7 +523,7 @@ function applyHiddenThinkingLabel(
 ): void {
   // Record the component's first streaming update even when the provider has
   // not emitted a non-empty thinking block yet.
-  const label = lifecycleLabel(row, streaming, timings);
+  const label = lifecycleLabel(row, message, streaming, timings);
   if (!hasThinkingContent(message)) return;
   if (
     row.hideThinkingBlock !== true ||
@@ -470,14 +595,21 @@ function installThinkingGroupingPatch():
       }
       Reflect.apply(state.originalUpdateContent, this, [combined, ...args]);
       try {
-        restyleHiddenThinkingLabel(this);
+        if (hasThinkingContent(combined)) {
+          const timing = state.timings.get(this);
+          const liveSince =
+            timing && timingLive(streaming, timing)
+              ? timing.startedAt
+              : undefined;
+          restyleHiddenThinkingLabel(this, liveSince);
+        }
       } catch {
         // Keep Pi's native label styling if the row shape changes.
       }
       try {
         if (
           hasThinkingContent(combined) &&
-          !thinkingStillLive(streaming, state.timings.get(this))
+          !timingLive(streaming, state.timings.get(this))
         ) {
           unitalicizeSettledThinking(this);
         }