pi-minimal 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -10,6 +10,28 @@ Releases are cut automatically: when the `version` in `package.json` changes on
 
 ## [Unreleased]
 
+## [0.3.1] - 2026-10-25
+
+### Added
+- Compact rows for tools that bring no renderer of their own, such as most MCP tools and
+  `subagents_enable`: `✓ mcp   re_mcp · query_prometheus query=… step=1m   12 lines · 1.4s`.
+  The verb is `mcp`, `agent` (subagent tools) or `tool`; up to three scalar arguments show as
+  `key=value`; a short single-line result shows verbatim, otherwise a line count. Failures show
+  their first line underneath; `ctrl+o` shows the full result. Tools that draw themselves
+  (the `subagent` live view, pi-gauntlet's trackers) keep their own renderer.
+
+### Changed
+- Bash rows drop `cd <session cwd> && ` and shorten other `cd <dir> && ` prefixes to the
+  directory name (`pi-subagents › sed -n …`), so the part that differs between rows is visible
+  and the outcome column stays put. Multi-line commands such as heredocs say how many lines follow
+  (`python3 - <<'EOF' · +4 lines`).
+- The thinking gutter `┊` now runs down every line of a thinking paragraph, including lines the
+  terminal wraps: paragraphs are pre-wrapped to the content width the host renders at (re-done on
+  resize). Previously only the first line of each paragraph had it, so wrapped thinking sat flush
+  with prose. Inline code stays whole; lists, quotes and fenced code are untouched.
+- The task tracker line is a segmented bar coloured by status (`Tasks ▰▰▰▰▱ 4/5`) instead of a
+  run of check marks; past 12 tasks it scales to 10 segments.
+
 ## [0.3.0] - 2026-10-25
 
 ### Added

package/README.md

@@ -30,9 +30,9 @@ Do not load this package beside the live `grok-chrome` extension. Disable or rem
 
 ## What it changes
 
-- **Tool rows** – every built-in tool call (`bash`, `read`, `edit`, `write`, `grep`, `find`, `ls`) renders as one line: status glyph (`◐` running, `✓` ok, `✗` failed), verb, item, and a right-aligned outcome (`34 lines · 1.0s`, `exit 1`, `+3 −1`, `4 matches`). Failed rows show the first line of output underneath; `ctrl+o` expands full output in a `│`-ruled block. `codemode` renders the same way, as a `code` row with one child row per nested tool call; `ctrl+o` shows the script and its output.
+- **Tool rows** – every built-in tool call (`bash`, `read`, `edit`, `write`, `grep`, `find`, `ls`) renders as one line: status glyph (`◐` running, `✓` ok, `✗` failed), verb, item, and a right-aligned outcome (`34 lines · 1.0s`, `exit 1`, `+3 −1`, `4 matches`). Failed rows show the first line of output underneath; `ctrl+o` expands full output in a `│`-ruled block. `codemode` renders the same way, as a `code` row with one child row per nested tool call; `ctrl+o` shows the script and its output. Tools without a renderer of their own (most MCP tools) get the same one-line row; tools that draw themselves keep their look. Bash rows drop a leading `cd <session cwd> &&` and shorten other `cd` prefixes to the directory name.
 - **Turn rule** – after each agent run a dim `── 15:51 · 12s · 4 tools ──` separator is appended (stored as a custom entry; never sent to the model).
-- **Thinking gutter** – thinking paragraphs are prefixed with `┊` so they read as secondary.
+- **Thinking gutter** – every line of a thinking paragraph, wrapped lines included, starts with `┊`, so thinking reads as a column beside prose.
 - **Status line** – one line above the editor: model · thinking level · context meter (amber at 70 %, red at 90 %) · cwd · `⎇ branch ±dirty` · Herdr siblings.
 - **Footer** – key hints appear only when the agent is idle and the editor is empty; `/compact` is suggested under context pressure.
 - **Code blocks** – fenced code renders as a closed box with the language as its title, keeping syntax highlighting, instead of literal ``` lines; long lines wrap inside the box.

package/dist/index.js

@@ -8,6 +8,7 @@ import { installCwd } from "./cwd.js";
 import { listSiblings, parseAgentList, parseTabList } from "./herdr.js";
 import { hideGauntletWidgets } from "./tracker.js";
 import { installToolRenderers, stopLiveWatch } from "./tools.js";
+import { setSessionCwd } from "./tool-rows.js";
 import { applyReclaim, reclaimPolicy } from "./reclaim.js";
 import { installWorkingStatus } from "./working-status.js";
 import { installTurnRule } from "./turn-rule.js";
@@ -170,6 +171,7 @@ export default function piMinimalExtension(pi) {
         });
         hideWidgets = config.hideGauntletWidgets;
         currentCwd = ctx.cwd;
+        setSessionCwd(ctx.cwd);
         try {
             const settings = SettingsManager.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted() });
             setChromeMargin(settings.getOutputPad());

package/dist/tool-rows.js

@@ -8,9 +8,42 @@ export function shortName(path) {
         return path || "";
     return parts.slice(-2).join("/");
 }
+let sessionCwd;
+let homeDir = process.env.HOME;
+/** The session cwd, so `cd <cwd> && \u2026` can be dropped from bash rows. */
+export function setSessionCwd(cwd, home = process.env.HOME) {
+    sessionCwd = cwd;
+    homeDir = home;
+}
+const CD_PREFIX = /^cd\s+("[^"]+"|'[^']+'|\S+)\s*&&\s*/;
+function expandHome(path) {
+    const unquoted = path.replace(/^(["'])(.*)\1$/, "$2").replace(/\/+$/, "");
+    if (homeDir && (unquoted === "~" || unquoted.startsWith("~/")))
+        return homeDir + unquoted.slice(1);
+    return unquoted;
+}
+/**
+ * The item column of a bash row. Long agent commands usually start with `cd <repo> && `, which
+ * pushes the part that differs between rows off the screen: drop it when it is the session cwd,
+ * otherwise shorten it to the directory name (`pi-subagents \u203a sed -n \u2026`). Multi-line
+ * commands (heredocs, scripts) say how many lines follow instead of ending at `<<'EOF'`.
+ */
+export function bashItem(command) {
+    const lines = command.replace(/\r/g, "").trim().split("\n");
+    let first = lines[0]?.trim() ?? "";
+    const cd = CD_PREFIX.exec(first);
+    if (cd && first.length > cd[0].length) {
+        const target = expandHome(cd[1]);
+        const rest = first.slice(cd[0].length);
+        const cwd = sessionCwd?.replace(/\/+$/, "");
+        first = cwd && target === cwd ? rest : `${target.split("/").filter(Boolean).at(-1) ?? target} \u203a ${rest}`;
+    }
+    const more = lines.slice(1).filter((line) => line.trim()).length;
+    return more > 0 ? `${first} \u00b7 +${more} line${more === 1 ? "" : "s"}` : first;
+}
 export function toolItem(kind, args) {
     if (kind === "bash") {
-        const command = typeof args?.command === "string" ? args.command.split("\n")[0]?.trim() ?? "" : "";
+        const command = typeof args?.command === "string" ? bashItem(args.command) : "";
         return command || "bash";
     }
     if (kind === "grep" || kind === "find") {

package/dist/tools.js

@@ -158,6 +158,122 @@ export function compactRenderers(kind) {
         },
     };
 }
+/** One `glyph verb item … outcome` line in the tool-row grid, shared by every self-rendered row. */
+function rowLine(theme, width, status, frame, verb, item, right) {
+    const inner = Math.max(8, width - rowIndent());
+    const row = layoutRow(inner, verb, item, right);
+    const rightColor = status === "running" ? "warning" : status === "error" ? "error" : "dim";
+    return (" ".repeat(rowIndent()) +
+        theme.fg(statusColor(status), rowGlyph(status, frame)) +
+        " " +
+        theme.fg("dim", row.verb) +
+        " " +
+        theme.fg(status === "error" ? "text" : "muted", row.item) +
+        " ".repeat(row.gap) +
+        theme.fg(rightColor, row.outcome));
+}
+/** Longest first result line shown verbatim as an outcome; longer results show a line count. */
+const OUTCOME_TEXT_MAX = 24;
+/** `mcp` for MCP tools, `agent` for subagent tools, `tool` for anything else. */
+export function genericVerb(toolName) {
+    if (toolName.startsWith("mcp__"))
+        return "mcp";
+    if (/subagent/.test(toolName))
+        return "agent";
+    return "tool";
+}
+/** `server · tool key=value …` for MCP tools, `name key=value …` for the rest. */
+export function genericItem(toolName, args) {
+    let json;
+    try {
+        json = JSON.stringify(args ?? {}) ?? "";
+    }
+    catch {
+        json = "";
+    }
+    const params = nestedItem({ name: toolName, args: json });
+    const mcp = /^mcp__(.+?)__(.+)$/.exec(toolName);
+    const label = mcp ? `${mcp[1]} \u00b7 ${mcp[2]}` : toolName;
+    return params ? `${label} ${params}` : label;
+}
+export function genericOutcome(result, isError, durationMs) {
+    const text = resultText(result);
+    const dur = formatDuration(durationMs);
+    const join = (...parts) => parts.filter(Boolean).join(" \u00b7 ");
+    const lines = text.split("\n").filter((line) => line.trim().length > 0);
+    if (isError)
+        return { text: join("failed", dur), errorLine: lines[0]?.trim() ?? "" };
+    if (lines.length === 0)
+        return { text: join("ok", dur) };
+    const first = lines[0].trim();
+    if (lines.length === 1 && visibleWidth(first) <= OUTCOME_TEXT_MAX)
+        return { text: join(first, dur) };
+    return { text: join(`${lines.length} line${lines.length === 1 ? "" : "s"}`, dur) };
+}
+/**
+ * A one-line row for tools that bring no renderer of their own (most MCP tools,
+ * `subagents_enable`): `\u2713 mcp   re_mcp \u00b7 query_prometheus query=\u2026   12 lines \u00b7 1.4s`.
+ * Without it they fall through to pi-core's default: bold name, JSON arguments, a text preview.
+ */
+export function genericRenderers(toolName) {
+    const verb = genericVerb(toolName);
+    return {
+        renderShell: "self",
+        renderCall(args, theme, rawContext) {
+            const context = rawContext;
+            const id = context.toolCallId || toolName;
+            const item = genericItem(toolName, args);
+            const running = rowIsRunning(context);
+            context.state.running = running;
+            if (running) {
+                context.state.startedAt ??= Date.now();
+                live.watch(id, context.invalidate);
+            }
+            else
+                live.unwatch(id);
+            return {
+                render(width) {
+                    const status = rowStatus(context);
+                    const frame = status === "running" && live.has(id) ? live.frame : 0;
+                    const right = status === "running"
+                        ? context.state.startedAt
+                            ? formatDuration(Date.now() - context.state.startedAt)
+                            : ""
+                        : (context.state.outcome?.text ?? "");
+                    return [rowLine(theme, width, status, frame, verb, item, right)];
+                },
+                invalidate() { },
+            };
+        },
+        renderResult(result, options, theme, rawContext) {
+            const context = rawContext;
+            const typed = result;
+            if (!context.isPartial) {
+                context.state.done = true;
+                context.state.running = false;
+                context.state.outcome = genericOutcome(typed, Boolean(context.isError), context.durationMs);
+                live.unwatch(context.toolCallId || toolName);
+            }
+            const container = new Container();
+            const expanded = Boolean(options.expanded);
+            const errorLine = context.state.outcome?.errorLine;
+            if (errorLine && !expanded)
+                container.addChild(errorLineBlock(errorLine, theme));
+            if (expanded) {
+                const text = resultText(typed);
+                if (text) {
+                    const indent = " ".repeat(rowIndent() + 2);
+                    container.addChild({ render: (width) => ruledLines(text, width, theme, indent), invalidate() { } });
+                }
+            }
+            return container;
+        },
+    };
+}
+/** True when a tool definition draws its own call or result. */
+function hasOwnRenderer(definition) {
+    return typeof definition?.renderCall === "function" || typeof definition?.renderResult === "function";
+}
 /** Max nested calls shown under a collapsed codemode row; the rest are counted. */
 const NESTED_PREVIEW = 8;
 /** Width of the nested tool-name column. */
@@ -209,19 +325,7 @@ export function codemodeRenderers() {
                     const frame = status === "running" && live.has(id) ? live.frame : 0;
                     const calls = state.calls ?? [];
                     const right = status === "running" ? (state.startedAt ? formatDuration(Date.now() - state.startedAt) : "") : (state.outcome?.text ?? "");
-                    const inner = Math.max(8, width - rowIndent());
-                    const row = layoutRow(inner, "code", callSummary(calls), right);
-                    const rightColor = status === "running" ? "warning" : status === "error" ? "error" : "dim";
-                    const lines = [
-                        " ".repeat(rowIndent()) +
-                            theme.fg(statusColor(status), rowGlyph(status, frame)) +
-                            " " +
-                            theme.fg("dim", row.verb) +
-                            " " +
-                            theme.fg(status === "error" ? "text" : "muted", row.item) +
-                            " ".repeat(row.gap) +
-                            theme.fg(rightColor, row.outcome),
-                    ];
+                    const lines = [rowLine(theme, width, status, frame, "code", callSummary(calls), right)];
                     const expanded = Boolean(context.expanded);
                     const shown = expanded ? calls : calls.slice(-NESTED_PREVIEW);
                     const childIndent = " ".repeat(rowIndent() + 4);
@@ -303,8 +407,12 @@ export function installToolRenderers(pi) {
     pi.registerToolRenderer((toolName, next) => {
         if (toolName === "codemode")
             return codemodeRenderers();
-        if (!isToolKind(toolName))
-            return next();
-        return compactRenderers(toolName);
+        if (isToolKind(toolName))
+            return compactRenderers(toolName);
+        // Tools that draw themselves (subagent's live view, gauntlet's trackers) keep their look.
+        const definition = next();
+        if (hasOwnRenderer(definition))
+            return definition;
+        return { ...definition, ...genericRenderers(toolName) };
     });
 }

package/dist/tracker.js

@@ -40,20 +40,24 @@ export function formatTrackerLines(ctx, theme) {
     }
     if (tasks && tasks.length > 0) {
         const done = tasks.filter((t) => t.status === "complete").length;
-        const icons = tasks
-            .map((t) => {
-            if (t.status === "complete")
-                return theme.fg("success", "✓");
-            if (t.status === "in_progress")
-                return theme.fg("warning", "→");
-            if (t.status === "failed")
-                return theme.fg("error", "✗");
-            return theme.fg("dim", "○");
-        })
-            .join("");
+        // One segment per task, coloured by status, so the list reads as a single bar instead of a
+        // row of check marks. Past 12 tasks the bar is scaled to 10 segments (status order kept).
+        const segment = (status) => {
+            if (status === "complete")
+                return theme.fg("success", "▰");
+            if (status === "in_progress")
+                return theme.fg("warning", "▰");
+            if (status === "failed")
+                return theme.fg("error", "▰");
+            return theme.fg("dim", "▱");
+        };
+        const shown = tasks.length <= 12
+            ? tasks.map((t) => t.status)
+            : Array.from({ length: 10 }, (_, i) => tasks[Math.floor((i * tasks.length) / 10)]?.status);
+        const icons = shown.map(segment).join("");
         const current = tasks.find((t) => t.status === "in_progress") ?? tasks.find((t) => t.status === "pending");
         const name = current ? theme.fg("text", ` ${current.name}`) : "";
-        lines.push(`${theme.fg("muted", "Tasks")} ${icons} ${theme.fg("dim", `(${done}/${tasks.length})`)}${name}`);
+        lines.push(`${theme.fg("muted", "Tasks")} ${icons} ${theme.fg("dim", `${done}/${tasks.length}`)}${name}`);
     }
     return lines;
 }

package/dist/transcript.js

@@ -1,23 +1,77 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
 export const THINKING_GUTTER = "┊ ";
 const FENCE = /^\s*(```|~~~)/;
 const BLOCK_START = /^\s*(#{1,6}\s|[-*+]\s|\d+[.)]\s|>|\||```|~~~|---\s*$|\*\*\*\s*$|___\s*$)/;
+/** Below this width wrapping would only make thinking harder to read; prefix source lines instead. */
+const MIN_WRAP_WIDTH = 20;
+/** An inline code span stays whole; everything else splits on spaces. */
+const TOKEN = /`[^`]*`|[^\s`]+|`/g;
+function stripGutter(line) {
+    return line.startsWith(THINKING_GUTTER) ? line.slice(THINKING_GUTTER.length) : line;
+}
+/** Split a word wider than `room` into `room`-wide pieces (URLs, long paths). */
+function splitWide(word, room) {
+    if (word.startsWith("`") || visibleWidth(word) <= room)
+        return [word];
+    const pieces = [];
+    let piece = "";
+    for (const char of word) {
+        if (visibleWidth(piece + char) > room) {
+            pieces.push(piece);
+            piece = "";
+        }
+        piece += char;
+    }
+    if (piece)
+        pieces.push(piece);
+    return pieces;
+}
+/**
+ * Greedy word wrap at `room` cells. Markdown markers (`*`, backticks) count toward the width
+ * but are removed when rendered, so lines can only come out shorter than `room`, never wider.
+ */
+export function wrapLine(line, room) {
+    const words = (line.match(TOKEN) ?? []).flatMap((word) => splitWide(word, room));
+    if (words.length === 0)
+        return [""];
+    const out = [];
+    let current = "";
+    for (const word of words) {
+        if (!current)
+            current = word;
+        else if (visibleWidth(current) + 1 + visibleWidth(word) <= room)
+            current += ` ${word}`;
+        else {
+            out.push(current);
+            current = word;
+        }
+    }
+    out.push(current);
+    return out;
+}
 /**
- * Prefix the first line of every plain paragraph in thinking Markdown with a gutter glyph.
- * Lines that start a Markdown block (heading, list, quote, table, fence, rule) are left alone so
- * they keep parsing, and nothing inside a fenced code block is touched.
+ * Put the thinking gutter on every rendered line of every plain paragraph, so thinking reads as a
+ * column beside prose rather than a bullet on its first line. With `width` (the content width the
+ * host will render at) paragraph lines are pre-wrapped to `width - 2` so wrapped lines carry the
+ * gutter too; pi-tui keeps single newlines as line breaks. Without a usable width only source
+ * lines are prefixed.
+ *
+ * Block syntax (heading, list, quote, table, fence, rule) is left untouched so it still parses,
+ * including a list or quote that interrupts a paragraph, and nothing inside fenced code changes.
  */
-export function gutterThinking(markdown) {
+export function gutterThinking(markdown, width) {
     if (!markdown)
         return markdown;
-    const lines = markdown.split("\n");
+    const room = width !== undefined && width >= MIN_WRAP_WIDTH ? width - visibleWidth(THINKING_GUTTER) : undefined;
     const out = [];
     let inFence = false;
-    let atParagraphStart = true;
-    for (const line of lines) {
+    /** "para": inside a plain paragraph; "block": inside block syntax until the next blank line. */
+    let mode = "none";
+    for (const line of markdown.split("\n")) {
         if (FENCE.test(line)) {
             inFence = !inFence;
             out.push(line);
-            atParagraphStart = !inFence;
+            mode = "none";
             continue;
         }
         if (inFence) {
@@ -26,16 +80,21 @@ export function gutterThinking(markdown) {
         }
         if (line.trim() === "") {
             out.push(line);
-            atParagraphStart = true;
+            mode = "none";
             continue;
         }
-        if (atParagraphStart && !BLOCK_START.test(line) && !line.startsWith(THINKING_GUTTER)) {
-            out.push(`${THINKING_GUTTER}${line}`);
-        }
-        else {
+        const body = stripGutter(line);
+        if (mode === "block" || BLOCK_START.test(body)) {
             out.push(line);
+            mode = "block";
+            continue;
         }
-        atParagraphStart = false;
+        mode = "para";
+        if (room === undefined)
+            out.push(`${THINKING_GUTTER}${body}`);
+        else
+            for (const piece of wrapLine(body, room))
+                out.push(`${THINKING_GUTTER}${piece}`);
     }
     return out.join("\n");
 }
@@ -45,6 +104,6 @@ export function installTranscript(pi) {
     pi.registerMarkdownTransformer((markdown, context) => {
         if (context.messageType !== "assistant-thinking")
             return markdown;
-        return gutterThinking(markdown);
+        return gutterThinking(markdown, context.availableWidth);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-minimal",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "license": "MIT",
   "type": "module",
   "private": false,

package/release-notes.md

@@ -1,32 +1,31 @@
 ### Added
-- `codemode` renders as a tool row: `✓ code  3 calls · plan_tracker ×2, bash … 54 lines · 1.2s`,
-  with one child row per nested call. Built-in tools inside a script read exactly like their
-  top-level rows (`bash` shows its command); other tools show up to three scalar arguments as
-  `key=value` instead of raw JSON. Children update live while the script runs. The script source
-  and output appear only on `ctrl+o`, in plain dim text, so syntax colours no longer compete with
-  status colours. A failed nested call or script error shows its first line under the row, like
-  `bash`. Previously codemode fell through to pi-core's default panel: a background slab with the
-  highlighted script, JSON arguments, an output preview and a `Took …` timer.
+- Compact rows for tools that bring no renderer of their own, such as most MCP tools and
+  `subagents_enable`: `✓ mcp   re_mcp · query_prometheus query=… step=1m   12 lines · 1.4s`.
+  The verb is `mcp`, `agent` (subagent tools) or `tool`; up to three scalar arguments show as
+  `key=value`; a short single-line result shows verbatim, otherwise a line count. Failures show
+  their first line underneath; `ctrl+o` shows the full result. Tools that draw themselves
+  (the `subagent` live view, pi-gauntlet's trackers) keep their own renderer.
 
 ### Changed
-- `minimal-dark` contrast: `dim` (verbs, outcomes, tool output) L 48 % → 56 % and `thinkingText`
-  52 % → 58 %, estimated ~3.1:1 → ~4.4:1 and ~3.7:1 → ~4.8:1 on the background. They were within
-  4 % of each other and below WCAG's 4.5:1 text target. `faint` 34 % → 36 %.
-- `minimal-dark` keeps syntax colours off the status hues: `syntaxFunction` was warning-yellow
-  (now lavender) and `syntaxNumber` was success-green (now teal), so code no longer looks like a
-  spinner or a check mark.
-- `minimal-dark` draws no background behind pending/successful tool output (`toolPendingBg`,
-  `toolSuccessBg` → `bg`). Tools pi-minimal does not restyle yet (`subagent`, MCP tools) lose
-  their slab; failures keep `toolErrorBg`.
+- Bash rows drop `cd <session cwd> && ` and shorten other `cd <dir> && ` prefixes to the
+  directory name (`pi-subagents › sed -n …`), so the part that differs between rows is visible
+  and the outcome column stays put. Multi-line commands such as heredocs say how many lines follow
+  (`python3 - <<'EOF' · +4 lines`).
+- The thinking gutter `┊` now runs down every line of a thinking paragraph, including lines the
+  terminal wraps: paragraphs are pre-wrapped to the content width the host renders at (re-done on
+  resize). Previously only the first line of each paragraph had it, so wrapped thinking sat flush
+  with prose. Inline code stays whole; lists, quotes and fenced code are untouched.
+- The task tracker line is a segmented bar coloured by status (`Tasks ▰▰▰▰▱ 4/5`) instead of a
+  run of check marks; past 12 tasks it scales to 10 segments.
 
 ## What's Changed
-* feat: render codemode as a tool row; raise minimal-dark contrast (0.3.0) by @raviy06 in https://github.com/raviy06/pi-minimal/pull/15
+* feat: compact rows for renderer-less tools, shorter bash items, task bar, wrapped thinking gutter (0.3.1) by @raviy06 in https://github.com/raviy06/pi-minimal/pull/17
 
 
-**Full Changelog**: https://github.com/raviy06/pi-minimal/compare/v0.2.3...v0.3.0
+**Full Changelog**: https://github.com/raviy06/pi-minimal/compare/v0.3.0...v0.3.1
 
 ---
 **Install / upgrade**
 ```bash
-pi install npm:pi-minimal@0.3.0   # or: pi update --extensions
+pi install npm:pi-minimal@0.3.1   # or: pi update --extensions
 ```

package/src/index.ts

@@ -8,6 +8,7 @@ import { installCwd } from "./cwd.js"
 import { listSiblings, parseAgentList, parseTabList, type Sibling } from "./herdr.js"
 import { hideGauntletWidgets } from "./tracker.js"
 import { installToolRenderers, stopLiveWatch } from "./tools.js"
+import { setSessionCwd } from "./tool-rows.js"
 import { applyReclaim, reclaimPolicy, type ReclaimReason } from "./reclaim.js"
 import { installWorkingStatus } from "./working-status.js"
 import { installTurnRule } from "./turn-rule.js"
@@ -167,6 +168,7 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
     })
     hideWidgets = config.hideGauntletWidgets
     currentCwd = ctx.cwd
+    setSessionCwd(ctx.cwd)
     try {
       const settings = SettingsManager.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted() })
       setChromeMargin(settings.getOutputPad())

package/src/tool-rows.ts

@@ -31,9 +31,46 @@ export function shortName(path: string): string {
   return parts.slice(-2).join("/")
 }
 
+let sessionCwd: string | undefined
+let homeDir: string | undefined = process.env.HOME
+
+/** The session cwd, so `cd <cwd> && \u2026` can be dropped from bash rows. */
+export function setSessionCwd(cwd: string | undefined, home = process.env.HOME): void {
+  sessionCwd = cwd
+  homeDir = home
+}
+
+const CD_PREFIX = /^cd\s+("[^"]+"|'[^']+'|\S+)\s*&&\s*/
+
+function expandHome(path: string): string {
+  const unquoted = path.replace(/^(["'])(.*)\1$/, "$2").replace(/\/+$/, "")
+  if (homeDir && (unquoted === "~" || unquoted.startsWith("~/"))) return homeDir + unquoted.slice(1)
+  return unquoted
+}
+
+/**
+ * The item column of a bash row. Long agent commands usually start with `cd <repo> && `, which
+ * pushes the part that differs between rows off the screen: drop it when it is the session cwd,
+ * otherwise shorten it to the directory name (`pi-subagents \u203a sed -n \u2026`). Multi-line
+ * commands (heredocs, scripts) say how many lines follow instead of ending at `<<'EOF'`.
+ */
+export function bashItem(command: string): string {
+  const lines = command.replace(/\r/g, "").trim().split("\n")
+  let first = lines[0]?.trim() ?? ""
+  const cd = CD_PREFIX.exec(first)
+  if (cd && first.length > cd[0].length) {
+    const target = expandHome(cd[1])
+    const rest = first.slice(cd[0].length)
+    const cwd = sessionCwd?.replace(/\/+$/, "")
+    first = cwd && target === cwd ? rest : `${target.split("/").filter(Boolean).at(-1) ?? target} \u203a ${rest}`
+  }
+  const more = lines.slice(1).filter((line) => line.trim()).length
+  return more > 0 ? `${first} \u00b7 +${more} line${more === 1 ? "" : "s"}` : first
+}
+
 export function toolItem(kind: ToolKind, args: ToolArgs | undefined): string {
   if (kind === "bash") {
-    const command = typeof args?.command === "string" ? args.command.split("\n")[0]?.trim() ?? "" : ""
+    const command = typeof args?.command === "string" ? bashItem(args.command) : ""
     return command || "bash"
   }
   if (kind === "grep" || kind === "find") {

package/src/tools.ts

@@ -5,7 +5,6 @@ import * as chrome from "./chrome.js"
 import { callSummary, codemodeOutcome, nestedCalls, nestedItem, scriptOutput, type NestedCall } from "./codemode-rows.js"
 import { createLiveWatch } from "./live-watch.js"
 import {
-
   bashBody,
   formatDuration,
   formatOutcome,
@@ -204,6 +203,123 @@ export function compactRenderers(kind: ToolKind): ToolRenderers {
   }
 }
 
+/** One `glyph verb item … outcome` line in the tool-row grid, shared by every self-rendered row. */
+function rowLine(theme: Theme, width: number, status: RowStatus, frame: 0 | 1, verb: string, item: string, right: string): string {
+	const inner = Math.max(8, width - rowIndent())
+	const row = layoutRow(inner, verb, item, right)
+	const rightColor = status === "running" ? "warning" : status === "error" ? "error" : "dim"
+	return (
+		" ".repeat(rowIndent()) +
+		theme.fg(statusColor(status), rowGlyph(status, frame)) +
+		" " +
+		theme.fg("dim", row.verb) +
+		" " +
+		theme.fg(status === "error" ? "text" : "muted", row.item) +
+		" ".repeat(row.gap) +
+		theme.fg(rightColor, row.outcome)
+	)
+}
+
+/** Longest first result line shown verbatim as an outcome; longer results show a line count. */
+const OUTCOME_TEXT_MAX = 24
+
+/** `mcp` for MCP tools, `agent` for subagent tools, `tool` for anything else. */
+export function genericVerb(toolName: string): string {
+	if (toolName.startsWith("mcp__")) return "mcp"
+	if (/subagent/.test(toolName)) return "agent"
+	return "tool"
+}
+
+/** `server · tool key=value …` for MCP tools, `name key=value …` for the rest. */
+export function genericItem(toolName: string, args: unknown): string {
+	let json: string
+	try {
+		json = JSON.stringify(args ?? {}) ?? ""
+	} catch {
+		json = ""
+	}
+	const params = nestedItem({ name: toolName, args: json })
+	const mcp = /^mcp__(.+?)__(.+)$/.exec(toolName)
+	const label = mcp ? `${mcp[1]} \u00b7 ${mcp[2]}` : toolName
+	return params ? `${label} ${params}` : label
+}
+
+export function genericOutcome(result: ToolResultLike | undefined, isError: boolean, durationMs: number | undefined): Outcome {
+	const text = resultText(result)
+	const dur = formatDuration(durationMs)
+	const join = (...parts: string[]) => parts.filter(Boolean).join(" \u00b7 ")
+	const lines = text.split("\n").filter((line) => line.trim().length > 0)
+	if (isError) return { text: join("failed", dur), errorLine: lines[0]?.trim() ?? "" }
+	if (lines.length === 0) return { text: join("ok", dur) }
+	const first = lines[0].trim()
+	if (lines.length === 1 && visibleWidth(first) <= OUTCOME_TEXT_MAX) return { text: join(first, dur) }
+	return { text: join(`${lines.length} line${lines.length === 1 ? "" : "s"}`, dur) }
+}
+
+/**
+ * A one-line row for tools that bring no renderer of their own (most MCP tools,
+ * `subagents_enable`): `\u2713 mcp   re_mcp \u00b7 query_prometheus query=\u2026   12 lines \u00b7 1.4s`.
+ * Without it they fall through to pi-core's default: bold name, JSON arguments, a text preview.
+ */
+export function genericRenderers(toolName: string): ToolRenderers {
+	const verb = genericVerb(toolName)
+	return {
+		renderShell: "self",
+		renderCall(args, theme, rawContext) {
+			const context = rawContext as RenderContext
+			const id = context.toolCallId || toolName
+			const item = genericItem(toolName, args)
+			const running = rowIsRunning(context)
+			context.state.running = running
+			if (running) {
+				context.state.startedAt ??= Date.now()
+				live.watch(id, context.invalidate)
+			} else live.unwatch(id)
+			return {
+				render(width: number): string[] {
+					const status = rowStatus(context)
+					const frame = status === "running" && live.has(id) ? live.frame : 0
+					const right =
+						status === "running"
+							? context.state.startedAt
+								? formatDuration(Date.now() - context.state.startedAt)
+								: ""
+							: (context.state.outcome?.text ?? "")
+					return [rowLine(theme, width, status, frame, verb, item, right)]
+				},
+				invalidate() {},
+			}
+		},
+		renderResult(result, options, theme, rawContext) {
+			const context = rawContext as RenderContext
+			const typed = result as ToolResultLike
+			if (!context.isPartial) {
+				context.state.done = true
+				context.state.running = false
+				context.state.outcome = genericOutcome(typed, Boolean(context.isError), context.durationMs)
+				live.unwatch(context.toolCallId || toolName)
+			}
+			const container = new Container()
+			const expanded = Boolean((options as RenderOptions).expanded)
+			const errorLine = context.state.outcome?.errorLine
+			if (errorLine && !expanded) container.addChild(errorLineBlock(errorLine, theme)!)
+			if (expanded) {
+				const text = resultText(typed)
+				if (text) {
+					const indent = " ".repeat(rowIndent() + 2)
+					container.addChild({ render: (width: number) => ruledLines(text, width, theme, indent), invalidate() {} })
+				}
+			}
+			return container
+		},
+	}
+}
+
+/** True when a tool definition draws its own call or result. */
+function hasOwnRenderer(definition: ToolRenderers | undefined): boolean {
+	return typeof definition?.renderCall === "function" || typeof definition?.renderResult === "function"
+}
+
 /** Max nested calls shown under a collapsed codemode row; the rest are counted. */
 const NESTED_PREVIEW = 8
 /** Width of the nested tool-name column. */
@@ -255,19 +371,7 @@ export function codemodeRenderers(): ToolRenderers {
 					const calls = state.calls ?? []
 					const right =
 						status === "running" ? (state.startedAt ? formatDuration(Date.now() - state.startedAt) : "") : (state.outcome?.text ?? "")
-					const inner = Math.max(8, width - rowIndent())
-					const row = layoutRow(inner, "code", callSummary(calls), right)
-					const rightColor = status === "running" ? "warning" : status === "error" ? "error" : "dim"
-					const lines = [
-						" ".repeat(rowIndent()) +
-							theme.fg(statusColor(status), rowGlyph(status, frame)) +
-							" " +
-							theme.fg("dim", row.verb) +
-							" " +
-							theme.fg(status === "error" ? "text" : "muted", row.item) +
-							" ".repeat(row.gap) +
-							theme.fg(rightColor, row.outcome),
-					]
+					const lines = [rowLine(theme, width, status, frame, "code", callSummary(calls), right)]
 					const expanded = Boolean(context.expanded)
 					const shown = expanded ? calls : calls.slice(-NESTED_PREVIEW)
 					const childIndent = " ".repeat(rowIndent() + 4)
@@ -347,7 +451,10 @@ export function installToolRenderers(pi: ExtensionAPI): void {
   if (typeof pi.registerToolRenderer !== "function") return
   pi.registerToolRenderer((toolName, next) => {
     if (toolName === "codemode") return codemodeRenderers()
-    if (!isToolKind(toolName)) return next()
-    return compactRenderers(toolName)
+    if (isToolKind(toolName)) return compactRenderers(toolName)
+    // Tools that draw themselves (subagent's live view, gauntlet's trackers) keep their look.
+    const definition = next()
+    if (hasOwnRenderer(definition)) return definition
+    return { ...definition, ...genericRenderers(toolName) }
   })
 }

package/src/tracker.ts

@@ -67,19 +67,24 @@ export function formatTrackerLines(
   }
   if (tasks && tasks.length > 0) {
     const done = tasks.filter((t) => t.status === "complete").length
-    const icons = tasks
-      .map((t) => {
-        if (t.status === "complete") return theme.fg("success", "✓")
-        if (t.status === "in_progress") return theme.fg("warning", "→")
-        if (t.status === "failed") return theme.fg("error", "✗")
-        return theme.fg("dim", "○")
-      })
-      .join("")
+    // One segment per task, coloured by status, so the list reads as a single bar instead of a
+    // row of check marks. Past 12 tasks the bar is scaled to 10 segments (status order kept).
+    const segment = (status: string | undefined) => {
+      if (status === "complete") return theme.fg("success", "▰")
+      if (status === "in_progress") return theme.fg("warning", "▰")
+      if (status === "failed") return theme.fg("error", "▰")
+      return theme.fg("dim", "▱")
+    }
+    const shown =
+      tasks.length <= 12
+        ? tasks.map((t) => t.status)
+        : Array.from({ length: 10 }, (_, i) => tasks[Math.floor((i * tasks.length) / 10)]?.status)
+    const icons = shown.map(segment).join("")
     const current =
       tasks.find((t) => t.status === "in_progress") ?? tasks.find((t) => t.status === "pending")
     const name = current ? theme.fg("text", ` ${current.name}`) : ""
     lines.push(
-      `${theme.fg("muted", "Tasks")} ${icons} ${theme.fg("dim", `(${done}/${tasks.length})`)}${name}`,
+      `${theme.fg("muted", "Tasks")} ${icons} ${theme.fg("dim", `${done}/${tasks.length}`)}${name}`,
     )
   }
   return lines

package/src/transcript.ts

@@ -1,51 +1,106 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { visibleWidth } from "@earendil-works/pi-tui"
 
 export const THINKING_GUTTER = "┊ "
 
 const FENCE = /^\s*(```|~~~)/
 const BLOCK_START = /^\s*(#{1,6}\s|[-*+]\s|\d+[.)]\s|>|\||```|~~~|---\s*$|\*\*\*\s*$|___\s*$)/
+/** Below this width wrapping would only make thinking harder to read; prefix source lines instead. */
+const MIN_WRAP_WIDTH = 20
+/** An inline code span stays whole; everything else splits on spaces. */
+const TOKEN = /`[^`]*`|[^\s`]+|`/g
+
+function stripGutter(line: string): string {
+	return line.startsWith(THINKING_GUTTER) ? line.slice(THINKING_GUTTER.length) : line
+}
+
+/** Split a word wider than `room` into `room`-wide pieces (URLs, long paths). */
+function splitWide(word: string, room: number): string[] {
+	if (word.startsWith("`") || visibleWidth(word) <= room) return [word]
+	const pieces: string[] = []
+	let piece = ""
+	for (const char of word) {
+		if (visibleWidth(piece + char) > room) {
+			pieces.push(piece)
+			piece = ""
+		}
+		piece += char
+	}
+	if (piece) pieces.push(piece)
+	return pieces
+}
+
+/**
+ * Greedy word wrap at `room` cells. Markdown markers (`*`, backticks) count toward the width
+ * but are removed when rendered, so lines can only come out shorter than `room`, never wider.
+ */
+export function wrapLine(line: string, room: number): string[] {
+	const words = (line.match(TOKEN) ?? []).flatMap((word) => splitWide(word, room))
+	if (words.length === 0) return [""]
+	const out: string[] = []
+	let current = ""
+	for (const word of words) {
+		if (!current) current = word
+		else if (visibleWidth(current) + 1 + visibleWidth(word) <= room) current += ` ${word}`
+		else {
+			out.push(current)
+			current = word
+		}
+	}
+	out.push(current)
+	return out
+}
 
 /**
- * Prefix the first line of every plain paragraph in thinking Markdown with a gutter glyph.
- * Lines that start a Markdown block (heading, list, quote, table, fence, rule) are left alone so
- * they keep parsing, and nothing inside a fenced code block is touched.
+ * Put the thinking gutter on every rendered line of every plain paragraph, so thinking reads as a
+ * column beside prose rather than a bullet on its first line. With `width` (the content width the
+ * host will render at) paragraph lines are pre-wrapped to `width - 2` so wrapped lines carry the
+ * gutter too; pi-tui keeps single newlines as line breaks. Without a usable width only source
+ * lines are prefixed.
+ *
+ * Block syntax (heading, list, quote, table, fence, rule) is left untouched so it still parses,
+ * including a list or quote that interrupts a paragraph, and nothing inside fenced code changes.
  */
-export function gutterThinking(markdown: string): string {
-  if (!markdown) return markdown
-  const lines = markdown.split("\n")
-  const out: string[] = []
-  let inFence = false
-  let atParagraphStart = true
-  for (const line of lines) {
-    if (FENCE.test(line)) {
-      inFence = !inFence
-      out.push(line)
-      atParagraphStart = !inFence
-      continue
-    }
-    if (inFence) {
-      out.push(line)
-      continue
-    }
-    if (line.trim() === "") {
-      out.push(line)
-      atParagraphStart = true
-      continue
-    }
-    if (atParagraphStart && !BLOCK_START.test(line) && !line.startsWith(THINKING_GUTTER)) {
-      out.push(`${THINKING_GUTTER}${line}`)
-    } else {
-      out.push(line)
-    }
-    atParagraphStart = false
-  }
-  return out.join("\n")
+export function gutterThinking(markdown: string, width?: number): string {
+	if (!markdown) return markdown
+	const room = width !== undefined && width >= MIN_WRAP_WIDTH ? width - visibleWidth(THINKING_GUTTER) : undefined
+	const out: string[] = []
+	let inFence = false
+	/** "para": inside a plain paragraph; "block": inside block syntax until the next blank line. */
+	let mode: "none" | "para" | "block" = "none"
+	for (const line of markdown.split("\n")) {
+		if (FENCE.test(line)) {
+			inFence = !inFence
+			out.push(line)
+			mode = "none"
+			continue
+		}
+		if (inFence) {
+			out.push(line)
+			continue
+		}
+		if (line.trim() === "") {
+			out.push(line)
+			mode = "none"
+			continue
+		}
+		const body = stripGutter(line)
+		if (mode === "block" || BLOCK_START.test(body)) {
+			out.push(line)
+			mode = "block"
+			continue
+		}
+		mode = "para"
+		if (room === undefined) out.push(`${THINKING_GUTTER}${body}`)
+		else for (const piece of wrapLine(body, room)) out.push(`${THINKING_GUTTER}${piece}`)
+	}
+	return out.join("\n")
 }
 
 export function installTranscript(pi: ExtensionAPI): void {
-  if (typeof pi.registerMarkdownTransformer !== "function") return
-  pi.registerMarkdownTransformer((markdown, context) => {
-    if (context.messageType !== "assistant-thinking") return markdown
-    return gutterThinking(markdown)
-  })
+	if (typeof pi.registerMarkdownTransformer !== "function") return
+	pi.registerMarkdownTransformer((markdown, context) => {
+		if (context.messageType !== "assistant-thinking") return markdown
+		return gutterThinking(markdown, context.availableWidth)
+	})
 }

package/test/codemode-rows.test.ts

@@ -21,7 +21,7 @@ test("parseArgs reads complete JSON and recovers keys from a preview cut at 200
 })
 
 test("nestedItem reads built-ins like their top-level rows and others as key=value", () => {
-	assert.equal(nestedItem({ name: "bash", args: '{"command":"git status\\ngit diff","timeout":10}' }), "git status")
+	assert.equal(nestedItem({ name: "bash", args: '{"command":"git status\\ngit diff","timeout":10}' }), "git status · +1 line")
 	assert.equal(nestedItem({ name: "read", args: '{"path":"/a/b/c/file.ts"}' }), "c/file.ts")
 	assert.equal(
 		nestedItem({ name: "plan_tracker", args: '{"action":"update","index":6,"status":"complete"}' }),

package/test/package.test.ts

@@ -1,23 +0,0 @@
-import assert from "node:assert/strict"
-import test from "node:test"
-import { readFileSync } from "node:fs"
-
-test("package manifest exposes the committed extension", () => {
-	const pkg = JSON.parse(readFileSync("package.json", "utf8"))
-	assert.equal(pkg.name, "pi-minimal")
-	assert.equal(pkg.version, "0.3.0")
-	const lock = JSON.parse(readFileSync("package-lock.json", "utf8"))
-	assert.equal(lock.version, pkg.version, "lockfile root version matches package")
-	assert.equal(lock.packages[""].version, pkg.version, "lockfile package version matches package")
-	assert.ok(readFileSync("CHANGELOG.md", "utf8").includes(`## [${pkg.version}] - `), "version has a dated release entry")
-	assert.equal(pkg.license, "MIT")
-	assert.equal(pkg.type, "module")
-	assert.deepEqual(pkg.engines, { node: ">=22.19.0" })
-	assert.deepEqual(pkg.keywords, ["pi-package"])
-	assert.deepEqual(pkg.repository, { type: "git", url: "git+https://github.com/raviy06/pi-minimal.git" })
-	assert.deepEqual(pkg.pi, { extensions: ["./dist/index.js"], themes: ["./themes/minimal-dark.json"] })
-	assert.deepEqual(pkg.peerDependencies, {
-		"@earendil-works/pi-coding-agent": "*",
-		"@earendil-works/pi-tui": "*",
-	})
-})

package/test/tool-rows.test.ts

@@ -8,6 +8,7 @@ import {
 	formatOutcome,
 	layoutRow,
 	rowGlyph,
+	setSessionCwd,
 	shortName,
 	toolItem,
 } from "../src/tool-rows.js"
@@ -15,7 +16,7 @@ import {
 const text = (s: string) => ({ content: [{ type: "text", text: s }] })
 
 test("toolItem picks the first command line for bash and a two-segment path otherwise", () => {
-	assert.equal(toolItem("bash", { command: "git status\ngit diff" }), "git status")
+	assert.equal(toolItem("bash", { command: "git status" }), "git status")
 	assert.equal(toolItem("read", { path: "/a/b/c/file.ts" }), "c/file.ts")
 	assert.equal(toolItem("grep", { pattern: "foo" }), "foo")
 	assert.equal(toolItem("ls", {}), "ls")
@@ -107,3 +108,18 @@ test("layoutRow drops the outcome when the row is too narrow", () => {
 	assert.equal(row.outcome, "")
 	assert.equal(row.gap, 0)
 })
+
+test("bash items drop cd into the session cwd, shorten other cd targets, and count extra lines", () => {
+	setSessionCwd("/Users/me/repo", "/Users/me")
+	try {
+		assert.equal(toolItem("bash", { command: "cd /Users/me/repo && npm test" }), "npm test")
+		assert.equal(toolItem("bash", { command: "cd ~/repo/ && npm test" }), "npm test")
+		assert.equal(toolItem("bash", { command: "cd ~/Dev/src/github.com/raviy06/pi-subagents && sed -n 1,2p a.ts" }), "pi-subagents › sed -n 1,2p a.ts")
+		assert.equal(toolItem("bash", { command: 'cd "/tmp/with space" && ls' }), "with space › ls")
+		assert.equal(toolItem("bash", { command: "cd /tmp" }), "cd /tmp", "a bare cd stays as written")
+		assert.equal(toolItem("bash", { command: "cd ~/repo && python3 - <<'EOF'\nprint(1)\n\nprint(2)\nEOF" }), "python3 - <<'EOF' · +3 lines")
+		assert.equal(toolItem("bash", { command: "git status\ngit diff" }), "git status · +1 line")
+	} finally {
+		setSessionCwd(undefined)
+	}
+})

package/test/tools.test.ts

@@ -1,7 +1,17 @@
 import assert from "node:assert/strict"
 import test from "node:test"
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
-import { codemodeRenderers, compactRenderers, installToolRenderers, isToolKind, stopLiveWatch } from "../src/tools.js"
+import {
+	codemodeRenderers,
+	compactRenderers,
+	genericItem,
+	genericOutcome,
+	genericRenderers,
+	genericVerb,
+	installToolRenderers,
+	isToolKind,
+	stopLiveWatch,
+} from "../src/tools.js"
 
 test("isToolKind recognises the built-in tools only", () => {
 	for (const name of ["bash", "read", "edit", "write", "grep", "find", "ls"]) assert.equal(isToolKind(name), true)
@@ -19,7 +29,12 @@ test("installToolRenderers registers a resolver at load time that only claims bu
 	installToolRenderers(pi)
 	assert.ok(resolver, "resolver registered synchronously, before session_start")
 	const fallback = { renderShell: "default" }
-	assert.equal(resolver!("mcp__foo__bar", () => fallback), fallback)
+	const own = { renderCall() {}, renderResult() {} }
+	assert.equal(resolver!("subagent", () => own), own, "tools with their own renderer keep it")
+	const generic = resolver!("mcp__foo__bar", () => fallback) as { renderShell?: string; renderCall?: unknown }
+	assert.equal(generic.renderShell, "self", "renderer-less tools get the compact row")
+	assert.equal(typeof generic.renderCall, "function")
+	assert.equal((resolver!("mcp__foo__bar", () => undefined) as { renderShell?: string }).renderShell, "self")
 	const codemode = resolver!("codemode", () => fallback) as { renderShell?: string }
 	assert.equal(codemode.renderShell, "self")
 	const mine = resolver!("bash", () => fallback) as { renderShell?: string }
@@ -90,7 +105,7 @@ test("codemode renders one parent row plus one child row per nested call, no scr
 	assert.equal(lines.length, 3)
 	assert.match(lines[0], /✓ code\s+2 calls · plan_tracker, bash\s+2 lines · 1.2s$/)
 	assert.match(lines[1], /✓ plan_tracker action=update index=6 status=complete\s+0.3s$/)
-	assert.match(lines[2], /✓ bash\s+cd ~\/r && sed -n 1,2p a.md\s+0.6s$/)
+	assert.match(lines[2], /✓ bash\s+r › sed -n 1,2p a.md\s+0.6s$/)
 	assert.ok(lines.every((line) => !line.includes("await")), "script hidden when collapsed")
 	assert.deepEqual(body.render(100), [])
 	for (const line of lines) assert.ok(line.length <= 100)
@@ -123,3 +138,41 @@ test("codemode shows nested calls live while the script is still running", () =>
 	assert.equal((context.state as { done?: boolean }).done, undefined)
 	stopLiveWatch()
 })
+
+test("generic rows label MCP and agent tools and read arguments as key=value", () => {
+	assert.equal(genericVerb("mcp__re_mcp__query_prometheus"), "mcp")
+	assert.equal(genericVerb("subagents_enable"), "agent")
+	assert.equal(genericVerb("todo"), "tool")
+	assert.equal(genericItem("mcp__re_mcp__query_prometheus", { query: "sum(rate(x[5m]))", limit: 5 }), "re_mcp · query_prometheus query=sum(rate(x[5m])) limit=5")
+	assert.equal(genericItem("subagents_enable", {}), "subagents_enable")
+	assert.equal(genericItem("todo", { action: "add", text: "line one\nline two" }), "todo action=add text=line one")
+})
+
+test("generic outcomes show a short first line verbatim, otherwise a line count", () => {
+	const text = (s: string) => ({ content: [{ type: "text", text: s }] })
+	assert.deepEqual(genericOutcome(text("Updated (9/9 done)"), false, 300), { text: "Updated (9/9 done) · 0.3s" })
+	assert.deepEqual(genericOutcome(text("Enabled: subagent. If your tool list includes subagent, call it now."), false, 0), { text: "1 line · 0s" })
+	assert.deepEqual(genericOutcome(text("a\nb\n"), false, 1400), { text: "2 lines · 1.4s" })
+	assert.deepEqual(genericOutcome(text(""), false, undefined), { text: "ok" })
+	assert.deepEqual(genericOutcome(text("\nboom\nmore"), true, 100), { text: "failed · 0.1s", errorLine: "boom" })
+})
+
+test("generic renderer draws one row, an error line on failure, and output on expand", () => {
+	const r = genericRenderers("mcp__re_mcp__query_prometheus")
+	const make = (extra: Record<string, unknown> = {}) => ({ toolCallId: "g1", invalidate() {}, state: {}, isPartial: false, isError: false, durationMs: 1400, ...extra })
+	const args = { query: "up" }
+	let context = make()
+	r.renderResult!({ content: [{ type: "text", text: "a\nb\nc" }] } as never, { expanded: false, isPartial: false } as never, plainTheme, context as never)
+	const [line, ...rest] = r.renderCall!(args as never, plainTheme, context as never).render(90)
+	assert.match(line, /✓ mcp\s+re_mcp · query_prometheus query=up\s+3 lines · 1.4s$/)
+	assert.equal(rest.length, 0)
+
+	context = make({ isError: true })
+	const failed = r.renderResult!({ content: [{ type: "text", text: "401 unauthorized" }] } as never, { expanded: false, isPartial: false } as never, plainTheme, context as never)
+	assert.match(r.renderCall!(args as never, plainTheme, context as never).render(90)[0], /✗ mcp .*failed · 1.4s$/)
+	assert.match(failed.render(90).join(""), /│ 401 unauthorized/)
+
+	context = make({ expanded: true })
+	const open = r.renderResult!({ content: [{ type: "text", text: "a\nb" }] } as never, { expanded: true, isPartial: false } as never, plainTheme, context as never)
+	assert.deepEqual(open.render(90).map((l) => l.trim()), ["│ a", "│ b"])
+})

package/test/tracker.test.ts

@@ -102,3 +102,21 @@ test("hideGauntletWidgets clears phase_tracker and plan_tracker", () => {
 		["plan_tracker", undefined],
 	])
 })
+
+test("task line is a segmented bar coloured by status, scaled past 12 tasks", () => {
+	const colour = { fg: (name: string, s: string) => `<${name}>${s}` }
+	const tasks = [
+		{ name: "a", status: "complete" },
+		{ name: "b", status: "failed" },
+		{ name: "c", status: "in_progress" },
+		{ name: "d", status: "pending" },
+	] as never
+	const [line] = formatTrackerLines(ctxFrom({ tasks }), colour)
+	assert.ok(line.includes("<success>▰<error>▰<warning>▰<dim>▱"), line)
+	assert.ok(line.includes("1/4"), line)
+	assert.ok(!line.includes("✓"), "no check-mark run")
+	const many = Array.from({ length: 40 }, (_, i) => ({ name: `t${i}`, status: i < 20 ? "complete" : "pending" })) as never
+	const [scaled] = formatTrackerLines(ctxFrom({ tasks: many }), theme)
+	assert.equal((scaled.match(/[▰▱]/g) ?? []).length, 10)
+	assert.ok(scaled.includes("▰▰▰▰▰▱▱▱▱▱"), scaled)
+})

package/test/transcript.test.ts

@@ -1,10 +1,12 @@
 import assert from "node:assert/strict"
 import test from "node:test"
-import { gutterThinking } from "../src/transcript.js"
+import { stripVTControlCharacters } from "node:util"
+import { Markdown, visibleWidth } from "@earendil-works/pi-tui"
+import { gutterThinking, wrapLine } from "../src/transcript.js"
 
-test("gutterThinking prefixes paragraph starts only", () => {
+test("gutterThinking prefixes every line of a plain paragraph", () => {
 	const input = "First thought\ncontinues here.\n\nSecond thought."
-	assert.equal(gutterThinking(input), "┊ First thought\ncontinues here.\n\n┊ Second thought.")
+	assert.equal(gutterThinking(input), "┊ First thought\n┊ continues here.\n\n┊ Second thought.")
 })
 
 test("gutterThinking leaves block syntax and fenced code alone", () => {
@@ -15,8 +17,53 @@ test("gutterThinking leaves block syntax and fenced code alone", () => {
 	)
 })
 
+test("a list or quote interrupting a paragraph keeps its syntax", () => {
+	assert.equal(gutterThinking("Plan:\n- one\n- two\n\nDone."), "┊ Plan:\n- one\n- two\n\n┊ Done.")
+	assert.equal(gutterThinking("Note\n> quoted\nlazy line"), "┊ Note\n> quoted\nlazy line")
+})
+
 test("gutterThinking is idempotent and handles empty input", () => {
 	assert.equal(gutterThinking(""), "")
 	const once = gutterThinking("a\n\nb")
 	assert.equal(gutterThinking(once), once)
+	const wrapped = gutterThinking("one two three four five six seven eight nine ten eleven", 24)
+	assert.equal(gutterThinking(wrapped, 24), wrapped)
+})
+
+test("with a width, paragraphs are pre-wrapped so wrapped lines carry the gutter", () => {
+	const out = gutterThinking("alpha beta gamma delta epsilon zeta eta theta iota kappa", 24)
+	assert.deepEqual(out.split("\n"), ["┊ alpha beta gamma delta", "┊ epsilon zeta eta theta", "┊ iota kappa"])
+	for (const line of out.split("\n")) assert.ok(visibleWidth(line) <= 24, line)
+})
+
+test("narrow or unknown widths fall back to prefixing source lines", () => {
+	const long = "alpha beta gamma delta epsilon zeta eta theta"
+	assert.equal(gutterThinking(long, 10), `┊ ${long}`)
+	assert.equal(gutterThinking(long), `┊ ${long}`)
+})
+
+test("wrapLine keeps inline code whole and splits over-wide words", () => {
+	assert.deepEqual(wrapLine("use `ctx.ui.confirm here` now", 12), ["use", "`ctx.ui.confirm here`", "now"])
+	assert.deepEqual(wrapLine("see https://example.com/a/very/long/path", 12), ["see", "https://exam", "ple.com/a/ve", "ry/long/path"])
+	assert.deepEqual(wrapLine("", 12), [""])
+})
+
+test("rendered through pi-tui Markdown, every line has the gutter and fits the width", () => {
+	const theme = new Proxy({}, { get: () => (s: string) => s }) as never
+	const thinking =
+		"There's an existing **/subagents** admin TUI with field editing, including `override removal`. " +
+		"I should check what it covers so the roster feature doesn't duplicate it — maybe I can hook into it instead, " +
+		"like adding model/fallback editing there.\n\nThen the `/roster` command."
+	for (const width of [40, 80, 120]) {
+		const md = new Markdown(thinking, 0, 0, theme, { color: (s: string) => s, italic: true }, {
+			transform: (text: string, available: number) => gutterThinking(text, available),
+		} as never)
+		const lines = md.render(width).map((line) => stripVTControlCharacters(line).trimEnd())
+		const content = lines.filter((line) => line.length > 0)
+		assert.ok(content.length >= 3, `width ${width}: ${JSON.stringify(lines)}`)
+		for (const line of content) {
+			assert.ok(line.startsWith("┊ "), `width ${width}: ${JSON.stringify(line)}`)
+			assert.ok(visibleWidth(line) <= width, `width ${width}: ${line}`)
+		}
+	}
 })