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

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+- Draw subagent rows with the same faint rail as every other collapsed
+  tool call. They used a bold `│` of their own, and failed subagent plans
+  painted the rail in the error color.
+- Stop the thinking spinner from forcing full transcript redraws. Changing
+  a line above the viewport makes the terminal clear and replay the whole
+  transcript, and the live label kept animating after answer text pushed it
+  out of view. The label now settles when the answer or a tool call starts,
+  so its duration is the real thinking time. With several thinking runs in
+  one message, earlier runs show a static `│ * Thought`, and the current
+  run animates only while it is the message's last line.
+- Never animate over a click-revealed thinking trace or answer Markdown
+  that happens to equal the label.
+- Keep `/toggle-info` replay from bringing back thinking that a message's
+  final update dropped.
+
 - 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

package/package.json

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

package/src/index.ts

@@ -24,8 +24,7 @@ import { isQuestionToolCall, renderQuestionBlock } from "./question-block.ts";
 import { sanitizeInline } from "./sanitize.ts";
 
 const OUTER_INSET = 2;
-const SUBAGENT_MARKER = "│";
-const GROUP_CALL_MARKER = "│";
+const TOOL_RAIL_MARKER = "│";
 // Collapsed rows anchor with a glyph instead of repeating the tool name;
 // tools that read as one family share a glyph, and unmapped tools fall back
 // to `*`. A single space separates the glyph from the call content: the
@@ -898,11 +897,23 @@ function codemodeCallLabel(row: ToolExecutionRow): string | undefined {
   return parts.length > 0 ? parts.join(" · ") : undefined;
 }
 
+// One anchor builder for every collapsed row: the faint rail, then the
+// row's bold glyph when it has one — `│ ● src/a.ts`, `│ $ npm test`. A
+// subagent row anchors on the rail alone and keeps its `│ subagent …`
+// reading instead of a glyph.
+function collapsedAnchor(
+  theme: ThemeLike,
+  color: string,
+  glyph: string | undefined,
+): string {
+  const rail = `${fgCollapsedRail(theme, TOOL_RAIL_MARKER)} `;
+  return glyph === undefined
+    ? rail
+    : `${rail}${fgCollapsed(theme, color, glyph, true)} `;
+}
+
 // 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.
+// takes, and the call text that follows it. Callers append the outcome tail.
 function collapsedSeam(
   row: ToolExecutionRow,
   width: number,
@@ -911,17 +922,12 @@ function collapsedSeam(
 ): { 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 glyph = isSubagent
+    ? undefined
+    : isBash
+      ? "$"
+      : (TOOL_CALL_GLYPHS.get(row.toolName ?? "") ?? "*");
+  const anchor = collapsedAnchor(theme, color, glyph);
   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
@@ -1209,7 +1215,7 @@ function renderSubagentPlan(
   const previewOf = (step: SubagentStep) =>
     fgCollapsed(theme, detailColor, ` ${subagentStepPreview(step.task)}`);
 
-  const marker = `${fgCollapsed(theme, color, SUBAGENT_MARKER, true)} `;
+  const marker = collapsedAnchor(theme, color, undefined);
   const budget = Math.max(1, width - visibleWidth(marker));
   const progress = subagentProgressText(row);
   const outcome = failed

package/src/thinking-block-merger.ts

@@ -210,12 +210,27 @@ function unitalicizeSettledThinking(row: AssistantMessageRow): void {
 // 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[] {
+function hiddenLabelNodes(
+  row: AssistantMessageRow,
+  plainLabel: string,
+): Array<{ node: TextLikeChild; trailing: boolean }> {
   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));
+  const labels: Array<{ node: TextLikeChild; trailing: boolean }> = [];
+  children.forEach((child, index) => {
+    const node = ((child as { child?: unknown } | undefined)?.child ??
+      child) as TextLikeChild | undefined;
+    if (
+      isMarkdownLike(node) ||
+      typeof node?.text !== "string" ||
+      typeof node.setText !== "function" ||
+      plainText(node.text) !== plainLabel
+    ) {
+      return;
+    }
+    labels.push({ node, trailing: index === children.length - 1 });
+  });
+  return labels;
 }
 
 // Duck-typed, not `instanceof`: a locally loaded extension can resolve its
@@ -257,8 +272,15 @@ function animateLiveLabel(node: TextLikeChild, startedAt: number): void {
   };
 }
 
+// Pi gives every thinking run in a message the same label. Only the last
+// run is the current one; earlier runs read as settled so a line above later
+// content never changes. The current run animates only when it is the
+// message's last line and no tool rows render below the message: changing
+// a line above the viewport makes pi-tui clear and replay the transcript.
+// Otherwise it holds one spinner frame until it settles.
 function restyleHiddenThinkingLabel(
   row: AssistantMessageRow,
+  message: AssistantMessageLike,
   liveSince?: number,
 ): void {
   if (
@@ -269,20 +291,28 @@ function restyleHiddenThinkingLabel(
   }
   const label = row.hiddenThinkingLabel;
   if (!stylesThinkingLabels()) return;
-  const styled = visibleThoughtLabel(label);
-  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" ||
-      plainText(textChild.text) !== plainLabel
-    ) {
-      continue;
+  const labels = hiddenLabelNodes(row, plainText(label));
+  const hasToolCalls =
+    Array.isArray(message.content) &&
+    message.content.some(
+      (block) => (block as { type?: unknown } | undefined)?.type === "toolCall",
+    );
+  labels.forEach(({ node, trailing }, index) => {
+    if (index < labels.length - 1) {
+      node.setText?.(visibleThoughtLabel(SETTLED_THOUGHT));
+      return;
     }
-    textChild.setText(styled);
-    if (liveSince !== undefined) animateLiveLabel(textChild, liveSince);
-  }
+    if (liveSince === undefined) {
+      node.setText?.(visibleThoughtLabel(label));
+    } else if (trailing && !hasToolCalls) {
+      node.setText?.(visibleThoughtLabel(label));
+      animateLiveLabel(node, liveSince);
+    } else {
+      node.setText?.(
+        visibleThoughtLabel(liveThinkingLabel(liveSince, liveSince)),
+      );
+    }
+  });
 }
 
 type ThinkingTiming = {
@@ -601,7 +631,7 @@ function installThinkingGroupingPatch():
             timing && timingLive(streaming, timing)
               ? timing.startedAt
               : undefined;
-          restyleHiddenThinkingLabel(this, liveSince);
+          restyleHiddenThinkingLabel(this, combined, liveSince);
         }
       } catch {
         // Keep Pi's native label styling if the row shape changes.