pi-minimal 0.2.3 → 0.3.0

package/CHANGELOG.md

@@ -10,6 +10,29 @@ Releases are cut automatically: when the `version` in `package.json` changes on
 
 ## [Unreleased]
 
+## [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.
 - **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.
 - **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/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,141 @@ export function compactRenderers(kind) {
         },
     };
 }
+/** 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 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 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,6 +301,8 @@ export function installToolRenderers(pi) {
     if (typeof pi.registerToolRenderer !== "function")
         return;
     pi.registerToolRenderer((toolName, next) => {
+        if (toolName === "codemode")
+            return codemodeRenderers();
         if (!isToolKind(toolName))
             return next();
         return compactRenderers(toolName);

package/package.json

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

package/release-notes.md

@@ -1,31 +1,32 @@
 ### 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.
+- `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.
 
-### 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
+- `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`.
 
 ## What's Changed
-* feat: add cooperative footer activity contributions by @raviy06 in https://github.com/raviy06/pi-minimal/pull/14
+* 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
 
 
-**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.2.3...v0.3.0
 
 ---
 **Install / upgrade**
 ```bash
-pi install npm:pi-minimal@0.2.3   # or: pi update --extensions
+pi install npm:pi-minimal@0.3.0   # 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/tools.ts

@@ -1,7 +1,8 @@
 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 {
 
@@ -203,6 +204,141 @@ export function compactRenderers(kind: ToolKind): ToolRenderers {
   }
 }
 
+/** 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 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 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,6 +346,7 @@ export function compactRenderers(kind: ToolKind): ToolRenderers {
 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)
   })

package/test/codemode-rows.test.ts

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { callSummary, codemodeOutcome, nestedCalls, nestedItem, parseArgs, scriptOutput } from "../src/codemode-rows.js"
+
+const result = (text: string, calls: unknown[] = []) => ({
+	content: [
+		{ type: "text", text: "Script completed\nWall time 1.2 seconds\nOutput:\n" },
+		{ type: "text", text },
+	],
+	details: { calls },
+})
+
+test("parseArgs reads complete JSON and recovers keys from a preview cut at 200 chars", () => {
+	assert.deepEqual(parseArgs('{"action":"update","index":6}'), { action: "update", index: 6 })
+	const cut = '{"command":"cd ~/repo && sed -n 168,180p docs/a.md && echo \\"===\\" && rg -n x docs/b.md | sed -n 1,30p && ech...'
+	assert.equal(parseArgs(cut).command, 'cd ~/repo && sed -n 168,180p docs/a.md && echo "===" && rg -n x docs/b.md | sed -n 1,30p && ech...')
+	assert.deepEqual(parseArgs(""), {})
+	assert.deepEqual(parseArgs("[1,2]"), {})
+	// A cut inside an escape must not throw.
+	assert.equal(typeof parseArgs('{"command":"echo \\').command, "string")
+})
+
+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: "read", args: '{"path":"/a/b/c/file.ts"}' }), "c/file.ts")
+	assert.equal(
+		nestedItem({ name: "plan_tracker", args: '{"action":"update","index":6,"status":"complete"}' }),
+		"action=update index=6 status=complete",
+	)
+	assert.equal(nestedItem({ name: "mcp__x__q", args: '{"query":"a","nested":{"b":1},"limit":5,"extra":1,"more":2}' }), "query=a limit=5 extra=1")
+	assert.equal(nestedItem({ name: "subagents_enable", args: "{}" }), "")
+})
+
+test("callSummary names tools in first-call order with repeat counts", () => {
+	assert.equal(callSummary([]), "script")
+	assert.equal(callSummary([{ name: "bash" }]), "1 call · bash")
+	assert.equal(
+		callSummary([{ name: "plan_tracker" }, { name: "plan_tracker" }, { name: "bash" }]),
+		"3 calls · plan_tracker ×2, bash",
+	)
+})
+
+test("scriptOutput drops pi-core's script header; nestedCalls tolerates missing details", () => {
+	assert.equal(scriptOutput(result("hello\n")), "hello")
+	assert.deepEqual(nestedCalls({ content: [] }), [])
+	assert.deepEqual(nestedCalls({ content: [], details: { calls: [null, { name: "bash" }] } }), [{ name: "bash" }])
+})
+
+test("codemodeOutcome counts output lines and surfaces the first failure", () => {
+	assert.deepEqual(codemodeOutcome(result("a\nb\n\nc"), false, 1200), { text: "3 lines · 1.2s", failed: false })
+	assert.deepEqual(codemodeOutcome(result(""), false, 300), { text: "ok · 0.3s", failed: false })
+	const failed = codemodeOutcome(
+		result("TEST_EXIT=1", [{ name: "bash", status: "ok" }, { name: "bash", status: "error", error: "\nboom: exit 2\nmore" }]),
+		false,
+		274_000,
+	)
+	assert.deepEqual(failed, { text: "1 failed · 4m 34s", failed: true, errorLine: "boom: exit 2" })
+	const scriptError = codemodeOutcome(result("partial\nScript error: ReferenceError: x is not defined"), true, 50)
+	assert.equal(scriptError.failed, true)
+	assert.equal(scriptError.errorLine, "ReferenceError: x is not defined")
+})

package/test/package.test.ts

@@ -5,7 +5,7 @@ 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.2.3")
+	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")

package/test/theme.test.ts

@@ -43,3 +43,31 @@ test("minimal-dark frames code quietly and neutralises tool backgrounds", () =>
 	assert.equal(theme.colors.toolSuccessBg, theme.colors.toolPendingBg)
 	assert.notEqual(theme.colors.mdHeading, theme.colors.warning)
 })
+
+const lightness = (value: string) => {
+	const resolved = value in theme.vars ? theme.vars[value] : value
+	const m = /okhsl\(\s*[\d.]+\s+[\d.]+%\s+([\d.]+)%\s*\)/.exec(resolved)
+	assert.ok(m, `okhsl literal for ${value}`)
+	return Number(m![1]) / 100
+}
+
+test("minimal-dark keeps a readable grey ladder: text > muted > thinking > dim > faint", () => {
+	const ladder = [theme.vars.text, theme.vars.muted, theme.colors.thinkingText, theme.vars.dim, theme.vars.faint].map(lightness)
+	for (let i = 1; i < ladder.length; i++) assert.ok(ladder[i] < ladder[i - 1], `step ${i}: ${ladder.join(" > ")}`)
+	// Readable tiers stay at or above L .56 (~4.4:1 on bg L .11, estimating Y ≈ L³).
+	assert.ok(lightness(theme.vars.dim) >= 0.56)
+	assert.ok(lightness(theme.colors.thinkingText) >= 0.56)
+})
+
+test("minimal-dark keeps status hues out of syntax colours", () => {
+	const status = new Set([theme.colors.success, theme.colors.warning, theme.colors.error])
+	for (const role of ["syntaxFunction", "syntaxNumber", "syntaxString", "syntaxVariable"]) {
+		assert.ok(!status.has(theme.colors[role]), `${role} reuses a status colour`)
+	}
+})
+
+test("minimal-dark draws no slab behind tool rows; only failures get a background", () => {
+	assert.equal(theme.colors.toolSuccessBg, "bg")
+	assert.equal(theme.colors.toolPendingBg, "bg")
+	assert.notEqual(theme.colors.toolErrorBg, "bg")
+})

package/test/tools.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict"
 import test from "node:test"
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
-import { compactRenderers, installToolRenderers, isToolKind } from "../src/tools.js"
+import { codemodeRenderers, compactRenderers, 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 +19,9 @@ 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!("codemode", () => fallback), fallback)
+	assert.equal(resolver!("mcp__foo__bar", () => fallback), fallback)
+	const codemode = resolver!("codemode", () => fallback) as { renderShell?: string }
+	assert.equal(codemode.renderShell, "self")
 	const mine = resolver!("bash", () => fallback) as { renderShell?: string }
 	assert.equal(mine.renderShell, "self")
 	assert.equal(typeof (mine as { renderCall?: unknown }).renderCall, "function")
@@ -53,3 +55,71 @@ test("compactRenderers render a one-line row with the outcome once the result la
 	const [line] = row.render(60)
 	assert.match(line, /✓ bash\s+ls\s+2 lines · 1.2s$/)
 })
+
+function codemodeContext(extra: Record<string, unknown> = {}) {
+	return {
+		args: { code: "await tools.bash({command:'ls'})\ntext(1)" },
+		toolCallId: "c1",
+		invalidate() {},
+		state: {} as Record<string, unknown>,
+		isPartial: false,
+		isError: false,
+		durationMs: 1200,
+		...extra,
+	}
+}
+
+const plainTheme = { fg: (_c: string, s: string) => s } as never
+const codemodeResult = (calls: unknown[], output = "a\nb") => ({
+	content: [
+		{ type: "text", text: "Script completed\nWall time 1.2 seconds\nOutput:\n" },
+		{ type: "text", text: output },
+	],
+	details: { calls },
+})
+
+test("codemode renders one parent row plus one child row per nested call, no script", () => {
+	const r = codemodeRenderers()
+	const context = codemodeContext()
+	const calls = [
+		{ name: "plan_tracker", args: '{"action":"update","index":6,"status":"complete"}', status: "ok", durationMs: 309 },
+		{ name: "bash", args: '{"command":"cd ~/r && sed -n 1,2p a.md"}', status: "ok", durationMs: 636 },
+	]
+	const body = r.renderResult!(codemodeResult(calls) as never, { expanded: false, isPartial: false } as never, plainTheme, context as never)
+	const lines = r.renderCall!(context.args as never, plainTheme, context as never).render(100)
+	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.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)
+})
+
+test("codemode shows the first failure under the row, and script + output when expanded", () => {
+	const r = codemodeRenderers()
+	const context = codemodeContext({ durationMs: 274_000 })
+	const calls = [{ name: "bash", args: '{"command":"npm test"}', status: "error", durationMs: 274_000, error: "fail 2" }]
+	const collapsed = r.renderResult!(codemodeResult(calls, "TEST_EXIT=1") as never, { expanded: false, isPartial: false } as never, plainTheme, context as never)
+	const [row, child] = r.renderCall!(context.args as never, plainTheme, context as never).render(100)
+	assert.match(row, /✗ code\s+1 call · bash\s+1 failed · 4m 34s$/)
+	assert.match(child, /✗ bash npm test\s+failed · 4m 34s$/)
+	assert.match(collapsed.render(100).join("\n"), /│ fail 2/)
+
+	const open = r.renderResult!(codemodeResult(calls, "TEST_EXIT=1") as never, { expanded: true, isPartial: false } as never, plainTheme, { ...context, expanded: true } as never)
+	const text = open.render(100).join("\n")
+	assert.match(text, /\/\/ script · 2 lines/)
+	assert.match(text, /await tools.bash/)
+	assert.match(text, /\/\/ output\n.*TEST_EXIT=1/)
+})
+
+test("codemode shows nested calls live while the script is still running", () => {
+	const r = codemodeRenderers()
+	const context = codemodeContext({ isPartial: true, durationMs: undefined })
+	r.renderResult!(codemodeResult([{ name: "bash", args: '{"command":"sleep 5"}', status: "running" }], "") as never, { expanded: false, isPartial: true } as never, plainTheme, context as never)
+	const lines = r.renderCall!(context.args as never, plainTheme, context as never).render(80)
+	assert.match(lines[0], /^\s+[◐◓] code\s+1 call · bash/)
+	assert.match(lines[1], /[◐◓] bash sleep 5/)
+	assert.equal((context.state as { done?: boolean }).done, undefined)
+	stopLiveWatch()
+})

package/themes/minimal-dark.json

@@ -7,8 +7,8 @@
 		"panel": "okhsl(230 5% 17%)",
 		"text": "okhsl(234 3% 90%)",
 		"muted": "okhsl(229 6% 64%)",
-		"dim": "okhsl(229 7% 48%)",
-		"faint": "okhsl(230 6% 34%)",
+		"dim": "okhsl(229 7% 56%)",
+		"faint": "okhsl(230 6% 36%)",
 		"violet": "okhsl(295 50% 67%)",
 		"violetSoft": "okhsl(295 45% 74%)",
 		"blue": "okhsl(232 54% 67%)",
@@ -29,7 +29,7 @@
 		"muted": "muted",
 		"dim": "dim",
 		"text": "text",
-		"thinkingText": "okhsl(229 6% 52%)",
+		"thinkingText": "okhsl(229 6% 58%)",
 		"selectedBg": "userBg",
 		"scrollbarTrack": "faint",
 		"scrollbarThumb": "dim",
@@ -40,8 +40,8 @@
 		"customMessageBg": "okhsl(295 30% 20%)",
 		"customMessageText": "muted",
 		"customMessageLabel": "violet",
-		"toolPendingBg": "panel",
-		"toolSuccessBg": "panel",
+		"toolPendingBg": "bg",
+		"toolSuccessBg": "bg",
 		"toolErrorBg": "errorBg",
 		"toolTitle": "text",
 		"toolOutput": "dim",
@@ -60,10 +60,10 @@
 		"toolDiffContext": "dim",
 		"syntaxComment": "dim",
 		"syntaxKeyword": "blue",
-		"syntaxFunction": "yellow",
+		"syntaxFunction": "okhsl(265 45% 76%)",
 		"syntaxVariable": "okhsl(202 58% 70%)",
 		"syntaxString": "okhsl(52 67% 70%)",
-		"syntaxNumber": "green",
+		"syntaxNumber": "okhsl(180 40% 68%)",
 		"syntaxType": "violet",
 		"syntaxOperator": "muted",
 		"syntaxPunctuation": "muted",