pi-minimal 0.2.3 → 0.3.1

package/CHANGELOG.md

@@ -10,6 +10,51 @@ 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
+- `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.
+
+### 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`.
+
 ## [0.2.3] - 2026-10-24
 
 ### Added

package/README.md

@@ -30,14 +30,14 @@ 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.
+- **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.
 - **Alignment** – chrome follows pi's `outputPad` setting. Pi's editor uses the separate `editorPaddingX` setting (default `0`); set `"editorPaddingX": 1` for a flush left edge with the transcript.
-- **Theme** – ships `minimal-dark`: neutral tool backgrounds, visible user-message tint, dimmer thinking text, violet headings (yellow is reserved for warnings), and faint code-block frames. Select it in `/settings` → Theme, or set `"theme": "minimal-dark"`.
+- **Theme** – ships `minimal-dark`: no background behind tool rows (failures excepted), a grey ladder whose readable tiers stay near 4.5:1, syntax colours kept off the status hues, visible user-message tint, dimmer thinking text, violet headings (yellow is reserved for warnings), and faint code-block frames. Select it in `/settings` → Theme, or set `"theme": "minimal-dark"`.
 
 ## Configuration
 

package/dist/codemode-rows.js

@@ -0,0 +1,109 @@
+import { firstLine, formatDuration, resultText, toolItem } from "./tool-rows.js";
+const KINDS = new Set(["bash", "read", "edit", "write", "grep", "find", "ls"]);
+const SCRIPT_HEADER = /^Script (?:completed|failed)\nWall time [\d.]+ seconds\nOutput:\n?/;
+/** Argument keys toolItem() reads, in the order it prefers them. */
+const ITEM_KEYS = ["command", "path", "file_path", "target_directory", "pattern"];
+export function nestedCalls(result) {
+    const calls = result?.details?.calls;
+    if (!Array.isArray(calls))
+        return [];
+    return calls.filter((call) => Boolean(call) && typeof call === "object");
+}
+/** Script output without pi-core's "Script completed / Wall time / Output:" header. */
+export function scriptOutput(result) {
+    return resultText(result).replace(SCRIPT_HEADER, "").trim();
+}
+/**
+ * Parse the host's argument preview. Complete JSON parses directly; a preview cut at 200 chars
+ * still yields the first string value of each known key, which is all a one-line row needs.
+ */
+export function parseArgs(args) {
+    if (!args)
+        return {};
+    try {
+        const value = JSON.parse(args);
+        return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    }
+    catch {
+        const out = {};
+        const pair = /"([A-Za-z_$][\w$]*)":(?:"((?:[^"\\]|\\.)*)"?|(-?\d+(?:\.\d+)?|true|false|null))/g;
+        for (const m of args.matchAll(pair)) {
+            if (m[1] in out)
+                continue;
+            if (m[2] !== undefined)
+                out[m[1]] = unescape(m[2]);
+            else if (m[3] !== undefined)
+                out[m[1]] = JSON.parse(m[3]);
+        }
+        return out;
+    }
+}
+function unescape(raw) {
+    // A cut can land inside an escape; drop a dangling backslash so JSON.parse accepts the rest.
+    const safe = raw.replace(/\\(u[0-9a-fA-F]{0,3})?$/, "");
+    try {
+        return JSON.parse(`"${safe}"`);
+    }
+    catch {
+        return safe;
+    }
+}
+function scalar(value) {
+    if (typeof value === "string")
+        return value.split("\n")[0]?.trim();
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return undefined;
+}
+/**
+ * The item column of a nested call. Built-in tools read exactly like their top-level rows
+ * (`bash` shows its command, `read` a short path). Other tools show up to three scalar
+ * arguments as `key=value`, strings unquoted, instead of raw JSON.
+ */
+export function nestedItem(call) {
+    const name = call.name ?? "tool";
+    const args = parseArgs(call.args);
+    if (KINDS.has(name)) {
+        const picked = {};
+        for (const key of ITEM_KEYS)
+            if (key in args)
+                picked[key] = args[key];
+        return toolItem(name, picked);
+    }
+    const parts = [];
+    for (const [key, value] of Object.entries(args)) {
+        const shown = scalar(value);
+        if (shown === undefined || shown === "")
+            continue;
+        parts.push(`${key}=${shown}`);
+        if (parts.length === 3)
+            break;
+    }
+    return parts.join(" ");
+}
+/** `3 calls · plan_tracker ×2, bash` — names in first-call order with repeat counts. */
+export function callSummary(calls) {
+    if (calls.length === 0)
+        return "script";
+    const counts = new Map();
+    for (const call of calls)
+        counts.set(call.name ?? "tool", (counts.get(call.name ?? "tool") ?? 0) + 1);
+    const names = [...counts].map(([name, n]) => (n > 1 ? `${name} ×${n}` : name)).join(", ");
+    return `${calls.length} call${calls.length === 1 ? "" : "s"} · ${names}`;
+}
+/** Right-hand outcome of the parent row, and the line shown under it when something failed. */
+export function codemodeOutcome(result, isError, durationMs) {
+    const calls = nestedCalls(result);
+    const output = scriptOutput(result);
+    const failedCalls = calls.filter((call) => call.status === "error");
+    const dur = formatDuration(durationMs);
+    const join = (...parts) => parts.filter(Boolean).join(" · ");
+    if (isError || failedCalls.length > 0) {
+        const label = failedCalls.length > 0 ? `${failedCalls.length} failed` : "failed";
+        const scriptError = /Script error:\s*(.*)/.exec(output)?.[1];
+        const errorLine = firstLine(failedCalls[0]?.error ?? "") ?? scriptError ?? firstLine(output);
+        return { text: join(label, dur), failed: true, errorLine };
+    }
+    const lines = output ? output.split("\n").filter((line) => line.length > 0).length : 0;
+    return { text: join(lines === 0 ? "ok" : `${lines} line${lines === 1 ? "" : "s"}`, dur), failed: false };
+}

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

@@ -1,6 +1,7 @@
-import { Container, truncateToWidth } from "@earendil-works/pi-tui";
+import { Container, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { rowIsRunning } from "./activity.js";
 import * as chrome from "./chrome.js";
+import { callSummary, codemodeOutcome, nestedCalls, nestedItem, scriptOutput } from "./codemode-rows.js";
 import { createLiveWatch } from "./live-watch.js";
 import { bashBody, formatDuration, formatOutcome, layoutRow, resultText, rowGlyph, toolItem, } from "./tool-rows.js";
 /** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
@@ -157,6 +158,245 @@ 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. */
+const NESTED_NAME_MAX = 14;
+function nestedGlyph(call, frame) {
+    if (call.status === "running")
+        return { glyph: rowGlyph("running", frame), color: "warning" };
+    if (call.status === "error")
+        return { glyph: "\u2717", color: "error" };
+    if (call.status === "cancelled")
+        return { glyph: "\u2298", color: "dim" };
+    return { glyph: "\u2713", color: "success" };
+}
+/** Lines of a `\u2502`-ruled block, dim and truncated, for script source or output on expand. */
+function ruledLines(text, width, theme, indent, label) {
+    const inner = Math.max(0, width - indent.length - 2);
+    const rule = theme.fg("borderMuted", "\u2502");
+    let lines = text.split("\n");
+    if (lines.length > EXPANDED_MAX_LINES)
+        lines = [...lines.slice(0, EXPANDED_MAX_LINES), `\u2026 ${lines.length - EXPANDED_MAX_LINES} more lines`];
+    const out = label ? [`${indent}${rule} ${theme.fg("dim", truncateToWidth(label, inner))}`] : [];
+    return out.concat(lines.map((line) => `${indent}${rule} ${theme.fg("dim", truncateToWidth(line, inner))}`));
+}
+/**
+ * codemode as a tool row: `\u2713 code  3 calls \u00b7 plan_tracker \u00d72, bash \u2026 54 lines \u00b7 1.2s`, then one
+ * child row per nested call. The script and its output appear only when expanded, undecorated,
+ * so syntax colours never compete with status colours in the transcript.
+ */
+export function codemodeRenderers() {
+    return {
+        renderShell: "self",
+        renderCall(args, theme, rawContext) {
+            const context = rawContext;
+            const code = typeof args?.code === "string" ? (args.code) : "";
+            context.state.code = code;
+            const id = context.toolCallId || "codemode";
+            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 state = context.state;
+                    const status = state.outcome?.errorLine !== undefined || context.isError ? "error" : rowIsRunning(context) ? "running" : "ok";
+                    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 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);
+                    if (shown.length < calls.length) {
+                        lines.push(`${childIndent}${theme.fg("dim", `\u2026 ${calls.length - shown.length} earlier calls`)}`);
+                    }
+                    const nameWidth = Math.min(NESTED_NAME_MAX, Math.max(0, ...shown.map((call) => (call.name ?? "tool").length)));
+                    for (const call of shown) {
+                        const { glyph, color } = nestedGlyph(call, frame);
+                        const name = truncateToWidth(call.name ?? "tool", nameWidth, "\u2026").padEnd(nameWidth);
+                        const dur = call.status === "error" ? `failed \u00b7 ${formatDuration(call.durationMs)}` : formatDuration(call.durationMs);
+                        const room = Math.max(8, width - childIndent.length);
+                        // Reuse the row grid with the name as the "verb" column, then fix the glyph slot.
+                        const prefixWidth = 2 + nameWidth + 1;
+                        const itemRoom = Math.max(0, room - prefixWidth - (dur ? visibleWidth(dur) + 2 : 0));
+                        const item = truncateToWidth(nestedItem(call), itemRoom, "\u2026");
+                        const gap = dur ? Math.max(2, room - prefixWidth - visibleWidth(item) - visibleWidth(dur)) : 0;
+                        lines.push(childIndent +
+                            theme.fg(color, glyph) +
+                            " " +
+                            theme.fg("dim", name) +
+                            " " +
+                            theme.fg(call.status === "error" ? "text" : "muted", item) +
+                            " ".repeat(gap) +
+                            theme.fg(call.status === "error" ? "error" : "dim", dur));
+                    }
+                    return lines;
+                },
+                invalidate() { },
+            };
+        },
+        renderResult(result, options, theme, rawContext) {
+            const context = rawContext;
+            const typed = result;
+            context.state.calls = nestedCalls(typed);
+            if (!context.isPartial) {
+                context.state.done = true;
+                context.state.running = false;
+                const outcome = codemodeOutcome(typed, Boolean(context.isError), context.durationMs);
+                context.state.outcome = { text: outcome.text, errorLine: outcome.failed ? (outcome.errorLine ?? "") : undefined };
+                context.state.output = scriptOutput(typed);
+                live.unwatch(context.toolCallId || "codemode");
+            }
+            // No invalidate here: the host runs renderCall and renderResult in one updateDisplay() and
+            // paints afterwards, so the call row's lazy render() already sees these calls. Calling
+            // invalidate() would re-enter updateDisplay() and recurse.
+            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 indent = " ".repeat(rowIndent() + 4);
+                const code = context.state.code ?? "";
+                const output = context.state.output ?? "";
+                container.addChild({
+                    render(width) {
+                        const lines = [];
+                        if (code)
+                            lines.push(...ruledLines(code.trimEnd(), width, theme, indent, `// script \u00b7 ${code.trimEnd().split("\n").length} lines`));
+                        if (output)
+                            lines.push(...ruledLines(output, width, theme, indent, "// output"));
+                        return lines;
+                    },
+                    invalidate() { },
+                });
+            }
+            return container;
+        },
+    };
+}
 /**
  * Attach the compact renderers to the built-in tools without re-registering them. Registered at
  * extension load so a resumed transcript draws its earlier tool calls the same way as new ones.
@@ -165,8 +405,14 @@ export function installToolRenderers(pi) {
     if (typeof pi.registerToolRenderer !== "function")
         return;
     pi.registerToolRenderer((toolName, next) => {
-        if (!isToolKind(toolName))
-            return next();
-        return compactRenderers(toolName);
+        if (toolName === "codemode")
+            return codemodeRenderers();
+        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;
 }