pi-minimal 0.2.3 → 0.3.1

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.2.3",
+  "version": "0.3.1",
   "license": "MIT",
   "type": "module",
   "private": false,

package/release-notes.md

@@ -1,31 +1,31 @@
 ### Added
-- Versioned, session-scoped footer activity contribution API. Companion extensions
-  can publish bounded activity rows after existing hints and tracker summaries
-  without replacing the footer. No visible change without a contributor.
-- Icon-first activity rows with pi-minimal's spinner/check/failure colors,
-  plain/static modes, overflow handling, optional elapsed time/token metrics,
-  and optional task links with independent task-state badges.
-- Snapshot validation, immutable metadata, exclusive slot ownership, stale-update
-  protection, and integration documentation.
-- Independent plan-summary contribution slot with violet slanted progress segments
-  and exact accepted/total counts, rendered below the input. One blank row
-  separates nonempty footer groups; activity rows stay compact. The summary is
-  display-only and does not add task storage or infer acceptance from agent runs.
-- Release checks for matching manifest/lockfile versions and a dated changelog entry.
+- 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.
 
-### Fixed
-- Dispose activity subscriptions and animation timers across footer replacement
-  and shutdown; prevent delayed settle callbacks from reinstalling stale chrome.
-- Synchronize the previously stale lockfile package version with the manifest.
+### 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.
 
 ## What's Changed
-* feat: add cooperative footer activity contributions by @raviy06 in https://github.com/raviy06/pi-minimal/pull/14
+* 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.2...v0.2.3
+**Full Changelog**: https://github.com/raviy06/pi-minimal/compare/v0.3.0...v0.3.1
 
 ---
 **Install / upgrade**
 ```bash
-pi install npm:pi-minimal@0.2.3   # or: pi update --extensions
+pi install npm:pi-minimal@0.3.1   # or: pi update --extensions
 ```

package/src/codemode-rows.ts

@@ -0,0 +1,121 @@
+import { firstLine, formatDuration, resultText, toolItem, type ToolKind, type ToolResultLike } from "./tool-rows.js"
+
+/** Mirrors pi-core's `CodemodeNestedCall`; every field is optional so older hosts degrade quietly. */
+export type NestedCall = {
+	id?: string
+	name?: string
+	/** Compact JSON of the arguments, truncated by the host at 200 chars (may not parse). */
+	args?: string
+	status?: "running" | "ok" | "error" | "cancelled"
+	durationMs?: number
+	error?: string
+	cost?: number
+}
+
+const KINDS: ReadonlySet<string> = new Set<ToolKind>(["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"] as const
+
+export function nestedCalls(result: ToolResultLike | undefined): NestedCall[] {
+	const calls = (result?.details as { calls?: unknown } | undefined)?.calls
+	if (!Array.isArray(calls)) return []
+	return calls.filter((call): call is NestedCall => Boolean(call) && typeof call === "object")
+}
+
+/** Script output without pi-core's "Script completed / Wall time / Output:" header. */
+export function scriptOutput(result: ToolResultLike | undefined): string {
+	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: string | undefined): Record<string, unknown> {
+	if (!args) return {}
+	try {
+		const value = JSON.parse(args) as unknown
+		return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {}
+	} catch {
+		const out: Record<string, unknown> = {}
+		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: string): string {
+	// 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}"`) as string
+	} catch {
+		return safe
+	}
+}
+
+function scalar(value: unknown): string | undefined {
+	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: NestedCall): string {
+	const name = call.name ?? "tool"
+	const args = parseArgs(call.args)
+	if (KINDS.has(name)) {
+		const picked: Record<string, unknown> = {}
+		for (const key of ITEM_KEYS) if (key in args) picked[key] = args[key]
+		return toolItem(name as ToolKind, picked)
+	}
+	const parts: string[] = []
+	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: readonly NestedCall[]): string {
+	if (calls.length === 0) return "script"
+	const counts = new Map<string, number>()
+	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}`
+}
+
+export type CodemodeOutcome = { text: string; failed: boolean; errorLine?: string }
+
+/** Right-hand outcome of the parent row, and the line shown under it when something failed. */
+export function codemodeOutcome(
+	result: ToolResultLike | undefined,
+	isError: boolean,
+	durationMs: number | undefined,
+): CodemodeOutcome {
+	const calls = nestedCalls(result)
+	const output = scriptOutput(result)
+	const failedCalls = calls.filter((call) => call.status === "error")
+	const dur = formatDuration(durationMs)
+	const join = (...parts: string[]) => 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/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

@@ -1,10 +1,10 @@
 import type { ExtensionAPI, Theme, ToolRenderers } from "@earendil-works/pi-coding-agent"
-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, type NestedCall } from "./codemode-rows.js"
 import { createLiveWatch } from "./live-watch.js"
 import {
-
   bashBody,
   formatDuration,
   formatOutcome,
@@ -203,6 +203,246 @@ 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. */
+const NESTED_NAME_MAX = 14
+
+type CodemodeState = RowState & { calls?: NestedCall[]; output?: string; code?: string }
+
+function nestedGlyph(call: NestedCall, frame: 0 | 1): { glyph: string; color: "error" | "warning" | "success" | "dim" } {
+	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: string, width: number, theme: Theme, indent: string, label?: string): string[] {
+	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(): ToolRenderers {
+	return {
+		renderShell: "self",
+		renderCall(args, theme, rawContext) {
+			const context = rawContext as RenderContext & { state: CodemodeState }
+			const code = typeof (args as { code?: unknown })?.code === "string" ? ((args as { code: string }).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: number): string[] {
+					const state = context.state
+					const status: RowStatus = 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 as RenderContext & { state: CodemodeState }
+			const typed = result as ToolResultLike
+			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 as RenderOptions).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: number): string[] {
+						const lines: string[] = []
+						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.
@@ -210,7 +450,11 @@ export function compactRenderers(kind: ToolKind): ToolRenderers {
 export function installToolRenderers(pi: ExtensionAPI): void {
   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) }
   })
 }