@pi-kaush/pi-tool-call-markers 0.3.5 → 0.3.7

package/CHANGELOG.md

@@ -2,6 +2,86 @@
 
 ## Unreleased
 
+- Render an asked question as a user-input moment instead of a raw tool row.
+  `ask_user_question` used to collapse to `│ * {"questions":…`, which is a tool
+  call marker doing the work of a prompt. An asked question now takes the
+  submitted-prompt shell: `▎ > <question>` followed by `▎ User: <answer>`, one
+  pair per question, with multi-select labels joined, a decline reading
+  `User declined to answer questions`, and a live row showing
+  `awaiting your answer…`. Recognition is shape-first off
+  `details.answers`, so another author's question tool renders the same without
+  a change here; the tool name is the fallback for calls that never answered.
+  The block reuses pi-content-layout's submitted-prompt geometry — rail,
+  surface, inset, one-column left and two-column right body padding, and
+  background padding rows — and italicizes the question while the answer stays
+  upright. Question blocks never join a tool group, and `Ctrl+O` still restores
+  Pi's native expanded rendering.
+
+- Make the railed shell's body padding explicit: `renderRailedBlockLines` takes
+  a `{ left, right }` padding, so the submitted-prompt shape (1/2) and the
+  existing `!`-block shape (1/0) come from one code path instead of the body
+  width being hardcoded.
+
+- Extract the railed prompt shell into `src/prompt-shell.ts`. User `!` blocks
+  and asked-question blocks share one implementation of the inset, rail,
+  surface background, and background repaint instead of two.
+
+- 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,13 +15,13 @@ Restart Pi or run `/reload`.
 Collapsed tool rows use semantic theme colors with no gear, background fill, box padding, or filled blank rows:
 
 ```text
-  │ ●: src/a.ts                         42 lines
-  │ ●: src/b.ts                         18 lines
-  │ $: 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.** Every collapsed call anchors on a glyph instead of its tool name: `●` read, `+` write, `±` edit, `○` local search, `≡` ls, `↗` web search and fetch, and `$` bash; unmapped tools fall back to `*`. Grouped rows flow directly across tool types.
+- **`│` 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, 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.
@@ -47,6 +47,27 @@ While a subagent runs, the plan headline's tail shows live progress from the str
 
 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
+
+A call that asks the user something is a user-input moment, not an execution row, so it renders in the submitted-prompt shell instead of the tool-call rail:
+
+```text
+  ▎
+  ▎ > Which call-site shape should `notifications:` use?
+  ▎ User: Nested within subagent (Recommended)
+  ▎ > Which tier should the flag read at runtime?
+  ▎ User: Client only, Client and server
+  ▎
+```
+
+The block reuses `pi-content-layout`'s submitted-prompt geometry — the same rail, surface, inset, one-column left padding, two-column right padding, and background padding rows — so an asked question and a submitted prompt are the same shape in the transcript.
+
+- **Shape-first recognition.** Any tool whose result carries an `answers` array of `{ question, answer | selected }` entries renders as a question block, so another author's question tool works without a change here. The tool name (`ask_user_question` and close variants) is the fallback for a call that failed before answering.
+- **Answers, not options.** Each question shows its answer: an option label, typed custom text, or multi-select labels joined with commas. A question left blank reads `User: (no answer)`, a decline reads `User declined to answer questions`, and a validation failure keeps Pi's native failure row.
+- **Quoted questions.** The question is the model's text read inside a user-input shell, so it renders italic under a `>` marker and the answer stays upright: the answer is the user's own words. A theme without italics renders the question plainly.
+- **Prompt-shell tones.** The rail uses `borderAccent` and the body paints on `userMessageBg`, with the question in `text`, the `User:` label in `muted`, the answer in `userMessageText`, and a live row's `awaiting your answer…` in `warning`.
+- **No grouping.** Question blocks never join an adjacent tool group and carry no tool glyph. `Ctrl+O` still restores Pi's native expanded rendering.
+
 ## Edit diffs
 
 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).
@@ -55,9 +76,9 @@ Files and paths in collapsed rows are preserved as displayed by Pi: hyperlink-wr
 
 ## Scope boundary
 
-This package owns every **execution row** in the transcript: collapsed tool calls, tool grouping, subagent plans, thinking labels, and user-run `!` bash blocks (reshaped into the railed prompt shell). Transcript _surface_ layout — message insets, system-text and status-rule alignment, the editor surface, and the submitted-prompt shell for user messages — belongs to `@pi-kaush/pi-content-layout`, which never renders tool rows.
+This package owns every **execution row** in the transcript: collapsed tool calls, tool grouping, subagent plans, asked-question blocks, thinking labels, and user-run `!` bash blocks (reshaped into the railed prompt shell). Transcript _surface_ layout — message insets, system-text and status-rule alignment, the editor surface, and the submitted-prompt shell for user messages — belongs to `@pi-kaush/pi-content-layout`, which never renders tool rows.
 
-One shared visual contract crosses the line: `!` blocks align with message text, so their inset mirrors `pi-content-layout`'s message `contentInset` (see `src/bash-block.ts`). Change indentation in both packages together.
+One shared visual contract crosses the line: `!` blocks and asked-question blocks align with message text, so their inset mirrors `pi-content-layout`'s message `contentInset` (see `src/prompt-shell.ts`, which owns the railed shell both use). Change indentation in both packages together.
 
 ## Hiding info entirely: /toggle-info
 
@@ -78,7 +99,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
 
@@ -131,10 +154,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.5",
+  "version": "0.3.7",
   "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,141 +1,21 @@
 import { BashExecutionComponent } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-
-type ThemeLike = {
-  bold(text: string): string;
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { paletteSample } from "./muted.ts";
+import {
+  PROMPT_RAIL,
+  fitLine,
+  promptBlockInset,
+  renderRailedBlockLines,
+  stripDisplayAnsi,
+  type PromptShellTheme,
+} from "./prompt-shell.ts";
+
+type ThemeLike = PromptShellTheme & {
   fg(color: string, text: string): string;
-  getBgAnsi?(color: string): string;
 };
 
 const BASH_BLOCK_PATCHED = Symbol.for("kg.pi.bashBlock.v1");
 
-// The prompt surface paints with the theme's userMessageBg token, matching
-// pi-content-layout's surfaces. userMessageBg is a required pi theme token;
-// the legacy hex remains only as a fallback for theme lookalikes without
-// getBgAnsi.
-const PROMPT_SURFACE_BG_FALLBACK = "\x1b[48;2;7;19;18m"; // #071312
-
-function promptSurfaceBg(theme: ThemeLike): string {
-  try {
-    return theme.getBgAnsi?.("userMessageBg") ?? PROMPT_SURFACE_BG_FALLBACK;
-  } catch {
-    return PROMPT_SURFACE_BG_FALLBACK;
-  }
-}
-const PROMPT_RAIL = "▎";
-
-// User-run bash blocks align with the message inset pi-content-layout
-// applies to transcript lines. Keep this in sync with that package's
-// contentInset (2 columns outside the rail for any width above 4); the
-// conversation surface has one shared visual contract even though the two
-// packages otherwise own disjoint components.
-function bashBlockInset(width: number): number {
-  return width > BASH_BLOCK_INSET * 2 ? BASH_BLOCK_INSET : 0;
-}
-const BASH_BLOCK_INSET = 2;
-
-const SGR_PATTERN = /\x1b\[([0-9;]*)m/g;
-const BACKGROUND_PATTERN =
-  /\x1b\[(?:4[0-8]|10[0-7]|48;5;\d{1,3}|48;2;\d{1,3};\d{1,3};\d{1,3})m/g;
-const DISPLAY_ANSI_PATTERN = /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
-
-function semanticControlEnd(text: string, offset: number): number | undefined {
-  if (text[offset] !== "\x1b") return undefined;
-  const kind = text[offset + 1];
-  if (kind !== "]" && kind !== "_" && kind !== "P" && kind !== "^") {
-    return undefined;
-  }
-  for (let index = offset + 2; index < text.length; index++) {
-    if (text[index] === "\x07") return index + 1;
-    if (text[index] === "\x1b" && text[index + 1] === "\\") {
-      return index + 2;
-    }
-  }
-  return undefined;
-}
-
-function splitLeadingSemanticControls(line: string): {
-  controls: string;
-  content: string;
-} {
-  let offset = 0;
-  while (offset < line.length) {
-    const end = semanticControlEnd(line, offset);
-    if (end === undefined) break;
-    offset = end;
-  }
-  return { controls: line.slice(0, offset), content: line.slice(offset) };
-}
-
-function fitLine(line: string, width: number): string {
-  if (width <= 0) return "";
-  const clipped = truncateToWidth(line, width, "");
-  return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
-}
-
-function reapplyBackgroundAfterReset(
-  text: string,
-  backgroundAnsi: string,
-): string {
-  return text.replace(SGR_PATTERN, (sequence, rawParameters: string) => {
-    const parameters =
-      rawParameters === "" ? [0] : rawParameters.split(";").map(Number);
-    return parameters.includes(0) || parameters.includes(49)
-      ? `${sequence}${backgroundAnsi}`
-      : sequence;
-  });
-}
-
-function paintBackground(
-  line: string,
-  width: number,
-  backgroundAnsi: string,
-): string {
-  const fitted = fitLine(line, width);
-  // Mirrors Theme.bg: background, content, then a background-only reset.
-  return `${backgroundAnsi}${reapplyBackgroundAfterReset(fitted, backgroundAnsi)}\x1b[49m`;
-}
-
-function stripDisplayAnsi(text: string): string {
-  return text.replace(DISPLAY_ANSI_PATTERN, "");
-}
-
-function replaceBackground(text: string, backgroundAnsi: string): string {
-  return text.replace(BACKGROUND_PATTERN, backgroundAnsi);
-}
-
-// Renders lines inside a railed, dark-surfaced block (the submitted-prompt
-// shell): optional leading semantic controls stay outside the inset, the rail
-// is recolored, and content backgrounds are normalized to the prompt surface.
-function renderRailedBlockLines(
-  lines: string[],
-  width: number,
-  theme: ThemeLike,
-  inset: number,
-  railColor: string,
-): string[] {
-  const blockWidth = width - inset * 2;
-  if (inset === 0 || blockWidth <= visibleWidth(PROMPT_RAIL)) {
-    return lines.map((line) => fitLine(line, width));
-  }
-  const bodyWidth = blockWidth - visibleWidth(PROMPT_RAIL);
-  const margin = " ".repeat(inset);
-  const surfaceBg = promptSurfaceBg(theme);
-  return lines.map((line) => {
-    const { controls, content } = splitLeadingSemanticControls(line);
-    const recolored = replaceBackground(content, surfaceBg);
-    const rail = theme.fg(railColor, PROMPT_RAIL);
-    // One extra leading space inside the body, so submitted text sits two
-    // columns right of the rail instead of one.
-    const body = paintBackground(
-      ` ${fitLine(recolored, Math.max(1, bodyWidth - 1))}`,
-      bodyWidth,
-      surfaceBg,
-    );
-    return `${controls}${margin}${rail}${body}${margin}`;
-  });
-}
-
 const RULE_LINE_RE = /^─+$/;
 
 function isRuleLine(line: string | undefined): line is string {
@@ -178,7 +58,7 @@ function renderBashBlockLines(
   width: number,
   theme: ThemeLike,
   status: string | undefined,
-  inset = bashBlockInset(width),
+  inset = promptBlockInset(width),
 ): string[] {
   const [spacer, ...rest] = lines;
   const topRule = isRuleLine(rest[0]) ? rest[0] : undefined;
@@ -199,8 +79,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[];
 };
@@ -222,6 +109,7 @@ function installBashBlockPatch(): BashBlockPatchState | undefined {
     const existing = proto[BASH_BLOCK_PATCHED];
     if (existing) {
       existing.owners++;
+      existing.disabled = false;
       return existing;
     }
 
@@ -235,17 +123,24 @@ function installBashBlockPatch(): BashBlockPatchState | undefined {
       width: number,
     ): string[] {
       const theme = state.theme;
-      if (!theme) return state.originalRender.call(this, width);
-      const inset = bashBlockInset(width);
+      if (state.disabled || !theme) {
+        return state.originalRender.call(this, width);
+      }
+      const inset = promptBlockInset(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 +154,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 +180,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);
       }
     }
   }