@pi-kaush/pi-tool-call-markers 0.3.4 → 0.3.6

package/CHANGELOG.md

@@ -2,6 +2,62 @@
 
 ## Unreleased
 
+- Read colors from the live palette instead of caching them against the
+  theme object. Pi swaps the palette behind a stable theme Proxy, so every
+  identity-keyed cache survived a theme switch: collapsed rows, the `+ Thought`
+  label, and user `!` blocks kept the old colors until their content changed.
+  Probes are map lookups, so the render caches now key on the resolved colors
+  (`paletteSample`, including the bash-block line cache) and the label
+  resolves its style per call.
+
+- Stop grouping from resurrecting a tool that opted out of the transcript. A
+  self-rendered tool that draws no lines stays hidden whether it renders alone
+  or beside another call: the singleton and grouped paths share one
+  draws-nothing rule.
+
+- Go inert at the final owner's shutdown. Every prototype wrapper — tool
+  presentation, container grouping, user bash blocks, thinking — delegates to
+  the original when another extension's wrapper has buried it and removal is
+  impossible, so collapsed rows and restyled labels cannot outlive their owner.
+  A later install re-enables the same wrappers.
+
+- Roll back a container hook that mutates the child list and then throws.
+  Its edit used to stick, dropping those rows from every later render. Both
+  copies of the shared hook contract changed together.
+
+- Own and release `/toggle-info` with the rest of the extension: the
+  process-global filter hook and the hidden flag now leave with the last owner
+  instead of filtering a transcript this package no longer renders.
+
+- Track thinking rows for the `/toggle-info` replay instead of every assistant
+  row, capped at 400 entries, so a long session or an abandoned branch cannot
+  pin every message the transcript ever showed.
+
+- Delete state nothing reads (the row→group map) and the duplicate
+  `session_start` handler that applied the collapsed default twice.
+
+- Drop the colon after every collapsed-row anchor: glyph rows read
+  `│ ● src/a.ts` and bash rows `│ $ npm test`. The anchor runs bold with a
+  single space before the call text, so the anchor alone separates the two.
+  The whole seam — glyph map, `$` prompt, subagent fallback heading, and the
+  tool-token drop — now lives in one function that both the singleton and
+  grouped render paths call, and self-rendered labels no longer leak their
+  tool name into the row under themes that tag instead of color.
+
+- Drop the italics Pi puts on thinking. The hidden `+ Thought` label renders
+  plain in every theme — the live spinner keeps its level tint, the settled
+  row its muted tone, and a theme that resolves no color still loses the
+  italics — and the visible trace stays italic only while it streams, then
+  renders as ordinary transcript text once the row settles. The live/settled
+  rule is shared with the label, so un-flagged row rebuilds (resize, theme
+  switch) keep a live trace italic and a finished one plain.
+  `PI_TOOL_CALL_MARKERS_THOUGHT_COLOR=inherit` remains the only opt-out that
+  keeps Pi's native italic styling.
+
+- Fail open when a theme rejects a thinking token. Pi's Theme throws on
+  tokens it does not know, so the label probe now falls back to the plain
+  treatment instead of throwing out of the row's update pass.
+
 - Restore Pi 0.85's click-to-expand under the custom collapsed rows. Pi routes
   mouse clicks by per-child rendered line heights, and the grouping render
   bypassed the native render that refreshes that cache, so clicks on anything

package/README.md

@@ -15,19 +15,16 @@ Restart Pi or run `/reload`.
 Collapsed tool rows use semantic theme colors with no gear, background fill, box padding, or filled blank rows:
 
 ```text
-  │ Read
-  │    src/a.ts                         42 lines
-  │    src/b.ts                         18 lines
-  │
-  │ Bash
-  │    $: npm test → done
+  │ ● src/a.ts                         42 lines
+  │ ● src/b.ts                         18 lines
+  │ $ npm test → done
 ```
 
 - **Two-column outer inset.** Tool markers and image output align with an inset conversation surface. Very narrow terminals reduce the decoration before useful content.
-- **`│` tool-call rail.** Single calls use a rail beside the summary. Multi-call groups extend it through bold tool-name headings, indented call summaries, and separators between tool types.
-- **Semantic, low-contrast status.** Tool names are emphasized, summaries and settled metadata are muted, pending state is warning-colored, and failures remain error-colored. Ordinary tool states have no background.
+- **`│` tool-call rail.** Every collapsed call anchors on a bold glyph instead of its tool name — `●` read, `+` write, `±` edit, `○` local search, `≡` ls, `↗` web search and fetch, and `$` bash; unmapped tools fall back to `*` — with a single space between the anchor and the call text, no joining colon. Grouped rows flow directly across tool types.
+- **Semantic, low-contrast status.** The anchor and the call content share the collapsed mute, pending state is warning-colored, and failures remain error-colored. Ordinary tool states have no background.
 - **Width-safe outcome tails.** Long summaries truncate before useful tails such as `→ done`, `→ 42 lines`, `→ +2/-1`, or a `bash` duration.
-- **Stable running groups.** Adjacent calls group as they appear. Pending state and elapsed `bash` time settle into the final outcome without changing the row count.
+- **Stable running groups.** Adjacent calls group as they appear, including settled failures, which stay error-colored inside the group. Pending state and elapsed `bash` time settle into the final outcome without changing the row count.
 - **Quiet-turn grouping.** Sequential calls can join across an assistant row with no visible prose or thinking. Visible assistant content remains a boundary.
 - **MCP and self-rendered tools.** Their stable call labels, compact arguments, pending state, success, and first error line use the same collapsed shell. Native self-rendered details return when expanded.
 - **Images remain visible.** Image fallback text and terminal image components render below the corresponding marker with the same inset.
@@ -36,7 +33,7 @@ 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-call rail:
 
 ```text
   ↪ subagent chain (3 steps) [repo-review]
@@ -52,7 +49,7 @@ Malformed, ambiguous, future, or too-narrow shapes fall back to the generic `↪
 
 ## Edit diffs
 
-Settled `edit` calls keep their change visible without expanding: the call line gains a `+added/-removed` outcome stat, and the hunk renders as a bounded diff block underneath (`+` lines in the added tone, `-` in the removed tone, context muted, folded regions as `...`, capped at 12 lines with a count tail). The full native diff — line numbers, intra-line word highlights — still returns with `Ctrl+O`.
+Settled `edit` calls collapse like every other row: the call line keeps its path and a `+added/-removed` outcome stat, and the hunk itself stays out of the collapsed row. `Ctrl+O` restores Pi's full native diff, including line numbers and intra-line word highlights. To keep edits expanded without pressing `Ctrl+O`, list `edit` in `PI_ALWAYS_EXPANDED_TOOL_CALL_MARKERS` (see Configuration).
 
 Files and paths in collapsed rows are preserved as displayed by Pi: hyperlink-wrapped paths (Pi wraps `read` call paths in OSC 8 hyperlinks) keep their visible text when sanitized for one-line rows.
 
@@ -81,7 +78,9 @@ When Pi exposes its per-row hidden-thinking and streaming fields, hidden reasoni
 + 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`. Visible-thinking mode remains native. 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`. 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.
 
 ## Local development
 
@@ -102,9 +101,18 @@ pi
 
 `0`, `false`, `no`, and `off` disable parallel grouping. `1`, `true`, `yes`, and `on` enable it. The value is read when the extension loads.
 
+To render chosen tools as Pi's native expanded block by default — full result and diff without `Ctrl+O` — list their names:
+
+```fish
+set -lx PI_ALWAYS_EXPANDED_TOOL_CALL_MARKERS edit,write
+pi
+```
+
+Names are comma-separated and matched exactly. Listed rows never join a group, and the list stays authoritative: collapsing the transcript with `Ctrl+O` re-expands them. 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.
+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 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:
 
@@ -125,10 +133,14 @@ Pi has no public hook for native tool rows, transcript grouping, or per-message
 
 - `ToolExecutionComponent` for collapsed presentation;
 - `Container` for adjacent grouping; and
-- `AssistantMessageComponent.updateContent` for display-only thinking merging and lifecycle labels.
+- `AssistantMessageComponent.updateContent` for display-only thinking merging, lifecycle labels, and the settled trace's italics.
 
 Each adapter feature-detects the fields and methods it needs, keeps the original method, uses an idempotency symbol, catches cosmetic failures, and restores the original on `session_shutdown` when it still owns the patch. Unsupported shapes fail open to Pi's native rendering. The thinking adapter continues adjacent merging even when the private label shape is unavailable.
 
+Teardown is owner-counted and inert: when another extension's wrapper sits above one of these, removal is impossible, so the buried wrapper delegates to the original instead of leaving collapsed rows or restyled labels behind after its owner shuts down. A later install re-enables it. The shared chat-container hook contract applies the same fail-open rule to hooks: a hook that throws after editing the child list has its edit rolled back, so a failed hook cannot drop rows from the transcript.
+
+Colors are read live from the theme, so a mid-session theme switch repaints collapsed rows, labels, and `!` blocks; cached render output keys on the resolved palette rather than on the theme object, which Pi keeps stable across a switch.
+
 Expanded tools always use Pi's native renderer. The collapsed tool shell owns its two-column inset directly; transcript layout extensions should leave tool rows unchanged, preventing load-order-dependent double padding.
 
 > TODO: migrate these adapters to public Pi transcript and tool-rendering APIs when available.

package/package.json

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

package/src/bash-block.ts

@@ -1,5 +1,6 @@
 import { BashExecutionComponent } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { paletteSample } from "./muted.ts";
 
 type ThemeLike = {
   bold(text: string): string;
@@ -199,8 +200,15 @@ type BashRow = { status?: unknown };
 
 type BashBlockPatchState = {
   owners: number;
+  // Set at the final owner's shutdown. A wrapper another extension has buried
+  // cannot be uninstalled, so it delegates instead of outliving its owner; a
+  // later install re-enables it.
+  disabled?: boolean;
   theme?: ThemeLike;
-  cache: WeakMap<object, { width: number; src: string[]; lines: string[] }>;
+  cache: WeakMap<
+    object,
+    { width: number; src: string[]; lines: string[]; palette: string }
+  >;
   originalRender: (width: number) => string[];
   patchedRender?: (width: number) => string[];
 };
@@ -213,6 +221,7 @@ type BashBlockPatchState = {
 // TODO: Replace prototype patching with a public Pi rendering API when available.
 function installBashBlockPatch(): BashBlockPatchState | undefined {
   try {
+    console.error("BB new state");
     const proto = BashExecutionComponent?.prototype as unknown as BashRow & {
       [BASH_BLOCK_PATCHED]?: BashBlockPatchState;
       render?: (width: number) => string[];
@@ -222,6 +231,8 @@ function installBashBlockPatch(): BashBlockPatchState | undefined {
     const existing = proto[BASH_BLOCK_PATCHED];
     if (existing) {
       existing.owners++;
+      console.error("BB reuse owners", existing.owners);
+      existing.disabled = false;
       return existing;
     }
 
@@ -235,17 +246,24 @@ function installBashBlockPatch(): BashBlockPatchState | undefined {
       width: number,
     ): string[] {
       const theme = state.theme;
-      if (!theme) return state.originalRender.call(this, width);
+      if (state.disabled || !theme) {
+        return state.originalRender.call(this, width);
+      }
       const inset = bashBlockInset(width);
       const bodyWidth = width - inset * 2 - visibleWidth(PROMPT_RAIL);
       if (inset === 0 || bodyWidth < 8) {
         return state.originalRender.call(this, width);
       }
       const lines = state.originalRender.call(this, Math.max(1, bodyWidth));
+      // Decorated lines carry resolved colors, so the cache keys on the
+      // palette too: Pi swaps the colors behind a stable theme Proxy, which a
+      // theme-identity check would never notice.
+      const palette = paletteSample(theme);
       const entry = state.cache.get(this);
       if (
         entry &&
         entry.width === width &&
+        entry.palette === palette &&
         entry.src.length === lines.length &&
         entry.src.every((line, index) => line === lines[index])
       ) {
@@ -259,7 +277,7 @@ function installBashBlockPatch(): BashBlockPatchState | undefined {
         typeof status === "string" ? status : undefined,
         inset,
       );
-      state.cache.set(this, { width, src: lines, lines: decorated });
+      state.cache.set(this, { width, src: lines, lines: decorated, palette });
       return decorated;
     };
 
@@ -285,6 +303,7 @@ function uninstallBashBlockPatch(state: BashBlockPatchState | undefined): void {
   if (!state || state.owners <= 0) return;
   state.owners--;
   if (state.owners > 0) return;
+  state.disabled = true;
   const proto = BashExecutionComponent?.prototype as unknown as BashRow & {
     [BASH_BLOCK_PATCHED]?: BashBlockPatchState;
     render?: (width: number) => string[];

package/src/container-hooks.ts

@@ -37,11 +37,17 @@ export function runChatContainerHooks(
   const restores: Array<() => void> = [];
   if (Array.isArray(children)) {
     for (const hook of chatContainerHooks()) {
+      // A hook rewrites `children` and hands back its own undo. Snapshot first:
+      // a hook that throws after splicing rows out would otherwise leave them
+      // missing from every later render, with nothing left to restore them.
+      const before = [...children];
       try {
         const restore = hook(container, children, width);
         if (typeof restore === "function") restores.push(restore);
       } catch {
         // Hooks are cosmetic; one failing hook must not break rendering.
+        children.length = 0;
+        children.push(...before);
       }
     }
   }