@pi-kaush/pi-tool-call-markers 0.3.12 → 0.3.14

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+- 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 `⠋ Thinking…` spinner is
+  unchanged.
+
 - 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

@@ -33,19 +33,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-call rail:
+A recognized `subagent` call renders as an unboxed plan in the shared tool aesthetic, using the same `│` tool-call rail:
 
 ```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 `↪ [<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.
+Single calls stay on one `│ [<emoji>] [<profile>][<agent>] <task preview>` row — no tool label. 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.
 
 ## Asked questions
 
@@ -98,10 +98,10 @@ When Pi exposes its per-row hidden-thinking and streaming fields, hidden reasoni
 
 ```text
 ⠋ Thinking…  →  ⠙ Thinking…  →  …
-+ Thought · 2.5s
+│ * 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 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`. The settled label borrows the collapsed tool-row anchor — a faint `│` rail and a bold `*` — so finished reasoning reads like the tool calls around it. 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.12",
+  "version": "0.3.14",
   "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,7 +24,7 @@ import { isQuestionToolCall, renderQuestionBlock } from "./question-block.ts";
 import { sanitizeInline } from "./sanitize.ts";
 
 const OUTER_INSET = 2;
-const SUBAGENT_MARKER = "↪";
+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
@@ -901,7 +901,7 @@ function codemodeCallLabel(row: ToolExecutionRow): string | undefined {
 // 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 …`
+// `│ $ npm test` — and subagent fallbacks keep their `│ subagent …`
 // reading instead of a glyph. Callers append the outcome tail.
 function collapsedSeam(
   row: ToolExecutionRow,
@@ -1173,10 +1173,10 @@ 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 identities (emoji, profile badge, name badge) in accent. Single calls
-// collapse to one row: `↪ <emoji> [<profile>][<name>] <task preview>`. Everything
+// 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,

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,34 @@ function labelStyle(
   return styledWith(token, theme);
 }
 
-// The settled label is the finalized "+ Thought" row; every other label is
-// the live spinner.
+// The settled label wears the collapsed tool-row anchor — faint rail, bold
+// glyph — so finished reasoning reads like the tool calls around it. Every
+// other label is the live spinner.
+const THOUGHT_RAIL = "│";
+const THOUGHT_GLYPH = "*";
+const THOUGHT_ANCHOR = `${THOUGHT_RAIL} ${THOUGHT_GLYPH}`;
+const SETTLED_THOUGHT = `${THOUGHT_ANCHOR} Thought`;
+
 function isSettledThoughtLabel(label: string): boolean {
-  return label.startsWith("+ Thought");
+  return label.startsWith(SETTLED_THOUGHT);
+}
+
+function styledSettledThought(raw: string, style: LabelStyle): string {
+  const rest = raw.slice(THOUGHT_ANCHOR.length);
+  return `${style.prefix}\x1b[2m${THOUGHT_RAIL}\x1b[22m \x1b[1m${THOUGHT_GLYPH}\x1b[22m${rest}${style.suffix}`;
 }
 
 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) return `${ITALIC_OFF}${raw}`;
+  return settled
+    ? styledSettledThought(raw, style)
+    : `${style.prefix}${raw}${style.suffix}`;
 }
 
 type AssistantMessageLike = {
@@ -351,9 +364,9 @@ function lifecycleLabel(
 
   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(