pi-compact-tools 0.13.2 → 0.14.0

package/README.md

@@ -1,8 +1,8 @@
 # pi-compact-tools
 
-Compact, expandable tool rows for Pi in its own compact style or Claude Code's, with a silent mode and a GitHub Dark theme. Works with custom tools from other packages.
+Tool rows for Pi in three styles: **Claude**, **Codex**, and **Compact**. Pick the look you know from Claude Code or Codex CLI, or Pi's own compact rows, and switch any time with `/compact-tools`. Includes a silent mode and a GitHub Dark theme, and works with custom tools from other packages.
 
-![The compact style, then the Claude style, each switched to silent mode mid-run and back](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/overview.gif)
+![One conversation drawn in the Compact style, switched to the Claude style, then the Codex style, then silent mode](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/overview.gif)
 
 ## Install
 
@@ -10,46 +10,67 @@ Compact, expandable tool rows for Pi in its own compact style or Claude Code's,
 pi install npm:pi-compact-tools
 ```
 
-Restart Pi or run `/reload`. For the bundled theme, set `"theme": "github-dark-pro"` in `~/.pi/agent/settings.json`.
+Restart Pi or run `/reload`, then run `/compact-tools` to choose a style. To try it for one session without installing: `pi -e npm:pi-compact-tools`.
 
-## Usage
+Requires Node.js 22.19+ and Pi 0.85.1+. It changes only how tool calls are drawn, not what they run or what the model sees.
 
-Pick a style. Silent mode works on top of either.
+## Styles
 
-| | Setting | Shows | How |
-|---|---|---|---|
-| **Compact** | Style | every tool call as its own compact, expandable row | `"style": "compact"` (default) |
-| **Claude** | Style | reads and searches folded into one line, like Claude Code | `"style": "claude"` |
-| **Silent** | Mode | only your prompts and the answers | `Ctrl+'` or `/silent` |
+| Style | Looks like | Set with |
+|---|---|---|
+| **Claude** | Claude Code: reads and searches fold into one line, `⎿` results | `/compact-tools claude` |
+| **Codex** | Codex CLI: `• Explored` groups, `• Ran` with the last output lines | `/compact-tools codex` |
+| **Compact** | one expandable row per call, with its status and time (default) | `/compact-tools compact` |
 
-Set `"style"` in the config below, then `/reload`. `"style": "off"` restores Pi's own rows.
+Silent mode (`Ctrl+'` or `/silent`) works on top of any style. `/compact-tools off` restores Pi's own rows.
 
-### Style: Compact
+### Claude
+
+![Claude style: reads and searches folded into one line, then Bash and Update rows](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/claude-style.gif)
+
+- Reads, searches, and listings fold into one line: `Searched for 2 patterns, read 3 files`.
+- `Bash`, `Update`, `Write`, and custom tools keep their own rows with `⎿` results and short previews.
+- Matched against Claude Code 2.1.288 in a live terminal.
+
+### Codex
+
+![Codex style: an Explored group, Ran rows with their last output lines, and an Edited diff](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/codex-style.gif)
+
+- Reads, searches, and listings fold into `• Explored`: `Read a.ts, b.ts`, `Search TODO in src`.
+- Commands read `Ran` or `Failed (exit 2)` with their last three output lines; opened, `$ cmd`, all its output, and `✓ • 1.23s`.
+- Edits preview their changed lines; custom tools read `• Called name`.
+- Matched against Codex CLI 0.160.0 in a live terminal.
+
+### Compact
 
 ![Compact style: searches, reads, a test run, and an edit with its diff, each call with its status](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif)
 
-- Each call: what it ran, then its status, duration, and line count.
+- One row per call: what it ran, its status, duration, and line count.
 - Edits show a highlighted diff with `(+3 -1)`; reads and writes show numbered code.
 
-### Style: Claude
+A command that writes or runs something, such as `tee`, `xargs`, or `find -delete`, always keeps its own row; only calls that just look around are folded into a group.
 
-![Claude style: reads and searches folded into one line, then Bash and Update rows](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/claude-style.gif)
+### Silent mode
 
-- Reads, searches, and listings fold into one line: `Searched for 2 patterns, read 3 files`.
-- `Bash`, `Update`, `Write`, and custom tools keep their own rows with short previews.
+![Silent mode switched on mid-run: the rows fold into a moving light, the answer stays, and every row comes back when it is off](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/silent-mode.gif)
 
-### Mode: Silent
+Only your prompts and the answers. Toggle with `Ctrl+'` or `/silent`; `"mode": "silent"` starts sessions with it on.
 
-![Silent mode switched on mid-run: the rows fold into a moving light, the answer stays, and every row comes back when it is off](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/silent-mode.gif)
+## Commands
 
-Shows only your prompts and the answers, in either style.
+```text
+/compact-tools                 # choose a style and where to save it
+/compact-tools codex           # switch style, at once, even while tools run
+/compact-tools claude project  # save for this trusted project
+/compact-tools off             # restore Pi's own rows (reloads Pi)
+/compact-tools status          # effective style, mode, and config paths
+```
 
-- Toggle with `Ctrl+'` or `/silent`. Tool rows and thinking fold into a moving light while the agent works.
-- Turn it off and every row comes back. `"mode": "silent"` starts sessions with it on.
+Without a scope, the style is saved where it is decided: in the trusted project if its settings choose a style, otherwise globally. Switching between Claude, Codex, and Compact redraws every row at once, even while tools run. Turning rows `off` or back on reloads Pi, so it waits until the response finishes. Your other settings are kept.
 
 ## Configuration
 
-Optional, in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.json`:
+Optional, in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.json` (trusted projects only; they override global settings field by field). Add `"$schema": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/schemas/compact-tools.schema.json"` for editor validation.
 
 ```json
 {
@@ -62,8 +83,9 @@ Optional, in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.js
 }
 ```
 
-- `tools`: built-ins to compact. Also `grep`, `find`, `ls`, `powershell`.
-- `auto_compact`: `true` starts a row collapsed; `false` shows up to `previewLines` rows. Custom tool names work too.
+- `style`: `claude`, `codex`, `compact`, or `off`.
+- `tools`: built-ins drawn in the style. Also `grep`, `find`, `ls`, `powershell`.
+- `auto_compact`: `true` starts a Compact row collapsed; `false` shows up to `previewLines` rows. Custom tool names work too.
 - `custom_tools`: rows for tools from other packages. `exclude` keeps a tool's own look.
 
 ## Controls
@@ -83,7 +105,7 @@ Development dependencies are pinned to Pi 1.0.0; the peer minimum remains Pi 0.8
 
 For a local before/after performance comparison, run `npx tsx tests/benchmark.ts <clean-baseline-directory>` with the same host dependencies in both directories. Measurements are informational, not timing-sensitive test assertions.
 
-Renders are pinned in `tests/golden/render.json`. After an intended change to the output, record it with `UPDATE_GOLDEN=1 npm test` and review the diff. Before publishing, add the version's notes to `release-notes.json` (`[]` for none).
+Renders are pinned in `tests/golden/`. After an intended change to the output, record it with `UPDATE_GOLDEN=1 npm test` and review the diff. The Claude and Codex styles are checked against references captured from the real tools in `tests/fixtures/`. The README's GIFs are recorded with `scripts/record-demos.sh` (needs `vhs` and `ffmpeg`). Before publishing, add the version's notes to `release-notes.json` (`[]` for none).
 
 ## License
 

package/extensions/compact-tools-claude.ts

@@ -4,10 +4,10 @@ import { normalizeLineEndings } from "./compact-tools-core.ts";
 import {
 	countEditChanges,
 	formatResultLineSummary,
-	shellSegments,
 	summarizeCustomArguments,
 	summarizeFailure,
 } from "./compact-tools-invocation.ts";
+import { isHarmlessRedirect, parseShell, writesOrRuns } from "./compact-tools-shell.ts";
 import type { ToolArgs } from "./compact-tools-types.ts";
 
 /**
@@ -20,6 +20,18 @@ export const CLAUDE_WRITE_ROWS = 10;
 /** Lines of context Claude Code keeps around each change in an edit's diff. */
 export const CLAUDE_DIFF_CONTEXT_LINES = 3;
 
+/**
+ * Claude Code 2.1.288's chrome: `⏺ Bash(…)`, then `  ⎿  ` with the "⎿" under the
+ * tool's name and the result two columns after it. Pi draws every row one column
+ * in, with its own smaller "⦁" dot, so each prefix keeps that geometry one column
+ * further right.
+ */
+export const CLAUDE_RESULT_PREFIX = "   ⎿  ";
+/** Lines after the first under "⎿", and everything drawn beneath the result. */
+export const CLAUDE_INDENT = "      ";
+/** Where a wrapped call line continues: under the tool's name. */
+export const CLAUDE_TITLE_INDENT = "   ";
+
 /** Claude Code's names for the tools Pi shares with it. */
 const LABELS: Readonly<Record<string, string>> = {
 	read: "Read",
@@ -118,38 +130,20 @@ const NEUTRAL_COMMANDS = new Set(["echo", "printf", "true", "false", ":"]);
 
 export type LookKind = "search" | "read" | "list";
 
-/** Split one shell step at its unquoted pipes. */
-function pipeStages(segment: string): string[] {
-	const stages: string[] = [];
-	let current = "";
-	let quote: string | undefined;
-	for (let index = 0; index < segment.length; index++) {
-		const character = segment[index]!;
-		if (quote) {
-			if (character === quote) quote = undefined;
-		} else if (character === "'" || character === '"' || character === "`") {
-			quote = character;
-		} else if (character === "|" && segment[index + 1] !== "|") {
-			stages.push(current);
-			current = "";
-			continue;
-		}
-		current += character;
-	}
-	stages.push(current);
-	return stages.map((stage) => stage.trim()).filter(Boolean);
-}
-
 /**
  * How a shell command looks around, if that is all it does: `rg x | head` searches,
- * `cat a.ts` reads, `ls src` lists. Anything that runs something else is undefined.
+ * `cat a.ts` reads, `ls src` lists. Anything that runs something else, writes a
+ * file, or redirects anywhere but /dev/null is undefined, so a group never hides it.
  */
 export function classifyShellCommand(command: string): LookKind | undefined {
+	const parsed = parseShell(normalizeLineEndings(command));
+	if (!parsed || parsed.opaque) return undefined;
 	let search = false;
 	let read = false;
 	let list = false;
-	for (const stage of shellSegments(normalizeLineEndings(command)).flatMap(pipeStages)) {
-		const program = stage.split(/\s+/u)[0];
+	for (const { words, redirects } of parsed.commands) {
+		if (!redirects.every(isHarmlessRedirect) || writesOrRuns(words)) return undefined;
+		const program = words[0];
 		if (!program || NEUTRAL_COMMANDS.has(program)) continue;
 		if (SEARCH_COMMANDS.has(program)) search = true;
 		else if (READ_COMMANDS.has(program)) read = true;

package/extensions/compact-tools-codex-rows.ts

@@ -0,0 +1,465 @@
+import type { AgentToolResult, Theme } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
+import {
+	CODEX_BULLET,
+	CODEX_COMMAND_INDENT,
+	CODEX_INDENT,
+	CODEX_MARGIN,
+	CODEX_PREVIEW_ROWS,
+	CODEX_RESULT_PREFIX,
+	CODEX_TAB,
+	codexDisclosure,
+	codexPath,
+	formatCodexDuration,
+	isEmptyOutput,
+	openExplorations,
+	paintSegments,
+	shellOutcome,
+	tailLines,
+	textLines,
+	wrapSegments,
+	type Segment,
+	type ThemeColor,
+} from "./compact-tools-codex.ts";
+import { normalizeLineEndings, type RowStatus } from "./compact-tools-core.ts";
+import { countEditChanges, getEditDiff, getEditPatch, splitReadFooter } from "./compact-tools-invocation.ts";
+import { parseCodeDiff, renderCodexDiff, type CodeDiffLine } from "./compact-tools-layout.ts";
+import type { RowState, ToolArgs } from "./compact-tools-types.ts";
+
+/** How a row is drawn: a file tool's result is code, a shell's is output, a custom tool's is its author's. */
+export type CodexRowKind = "file" | "shell" | "custom";
+
+/** Lines drawn from state read as they are drawn, laid out again only when that state or the width changes. */
+class LiveLines implements Component {
+	private cache: { key: string; width: number; lines: string[] } | undefined;
+
+	constructor(private readonly key: (width: number) => string, private readonly draw: (width: number) => string[]) {}
+
+	render(width: number): string[] {
+		const key = this.key(width);
+		if (!this.cache || this.cache.key !== key || this.cache.width !== width) this.cache = { key, width, lines: withinWidth(this.draw(width), width) };
+		return this.cache.lines;
+	}
+
+	invalidate(): void {
+		this.cache = undefined;
+	}
+}
+
+/** One row cut to the width with "…", in the style of what it cuts when that is given. */
+const clip = (line: string, width: number, ellipsis = "…") => truncateToWidth(line, Math.max(1, width), ellipsis);
+
+/** Whatever a row lays out, a pane too narrow for its chrome still never draws past its edge. */
+function withinWidth(lines: string[], width: number): string[] {
+	return lines.map((line) => visibleWidth(line) > width ? clip(line, width) : line);
+}
+
+function commandOf(args: ToolArgs): string {
+	return typeof args.command === "string" ? normalizeLineEndings(stripTerminalSequences(args.command)).trim() : "";
+}
+
+const SHELL_OPERATORS = ["&&", "||", ">>", ">&", "&>", "|", ";", "&", ">", "<", "(", ")"];
+/** Operators that send a command's output somewhere rather than start another command. */
+const REDIRECTIONS = new Set([">", ">>", ">&", "&>", "<", ")"]);
+
+/**
+ * A command's lines with the shell's colors, as Codex highlights what it ran: the
+ * program each command runs, its flags, strings, variables, and the operators
+ * between them, in the theme's syntax colors. It is tokenized here rather than by
+ * the host's highlighter, whose grammar changes between Pi versions.
+ */
+export function highlightCommand(command: string, theme: Theme): string[] {
+	return commandSegments(command).map((line) => paintSegments(line, theme));
+}
+
+/** The pieces of a command, line by line, each with the syntax color it is painted in. */
+function commandSegments(command: string): Segment[][] {
+	const lines: Segment[][] = [[]];
+	const add = (color: ThemeColor | undefined, token: string) => {
+		token.split("\n").forEach((part, index) => {
+			if (index > 0) lines.push([]);
+			if (part) lines[lines.length - 1]!.push({ text: part, color });
+		});
+	};
+	let commandStart = true;
+	let index = 0;
+	while (index < command.length) {
+		const rest = command.slice(index);
+		const space = rest.match(/^[ \t]+/u)?.[0];
+		if (space) {
+			add(undefined, space);
+			index += space.length;
+			continue;
+		}
+		if (rest[0] === "\n") {
+			add(undefined, "\n");
+			commandStart = true;
+			index++;
+			continue;
+		}
+		if (rest[0] === "#") {
+			const comment = rest.match(/^#[^\n]*/u)![0];
+			add("syntaxComment", comment);
+			index += comment.length;
+			continue;
+		}
+		const operator = SHELL_OPERATORS.find((candidate) => rest.startsWith(candidate));
+		if (operator) {
+			add("syntaxOperator", operator);
+			if (!REDIRECTIONS.has(operator)) commandStart = true;
+			index += operator.length;
+			continue;
+		}
+		if (rest[0] === "'" || rest[0] === "\"") {
+			const quote = rest[0];
+			let end = 1;
+			while (end < rest.length && rest[end] !== quote) end += quote === "\"" && rest[end] === "\\" ? 2 : 1;
+			const string = rest.slice(0, Math.min(end + 1, rest.length));
+			add("syntaxString", string);
+			commandStart = false;
+			index += string.length;
+			continue;
+		}
+		if (rest[0] === "$") {
+			const variable = rest.match(/^\$(?:\{[^}]*\}?|[A-Za-z_][A-Za-z0-9_]*|[0-9#?@*$!-])?/u)![0];
+			add("syntaxVariable", variable);
+			commandStart = false;
+			index += variable.length;
+			continue;
+		}
+		const word = rest.match(/^[^\s'"$#&|;<>()]+/u)?.[0] ?? rest[0]!;
+		const assignment = commandStart && /^[A-Za-z_][A-Za-z0-9_]*=/u.test(word);
+		add(commandStart && !assignment ? "syntaxFunction" : word.startsWith("-") ? "syntaxKeyword"
+			: /^\d+$/u.test(word) ? "syntaxNumber" : undefined, word);
+		if (!assignment) commandStart = false;
+		index += word.length;
+	}
+	return lines;
+}
+
+/** Lines wrapped under a prefix, the first row after `first` and every later one after `rest`. */
+function prefixedRows(lines: readonly Segment[][], first: string, rest: string, width: number, theme: Theme): string[] {
+	const available = Math.max(1, width - Math.max(visibleWidth(first), visibleWidth(rest)));
+	return lines.flatMap((line) => wrapSegments(line, available, available))
+		.map((row, index) => (index === 0 ? first : rest) + paintSegments(row, theme));
+}
+
+function durationOf(state: RowState): string | undefined {
+	return state.startedAt !== undefined && state.endedAt !== undefined ? formatCodexDuration(state.endedAt - state.startedAt) : undefined;
+}
+
+/** What each status reads as at the head of a row. */
+const VERBS: Record<"shell" | "custom" | "edit" | "write", Record<"running" | "success" | "error", string>> = {
+	shell: { running: "Running", success: "Ran", error: "Failed" },
+	custom: { running: "Calling", success: "Called", error: "Failed" },
+	edit: { running: "Editing", success: "Edited", error: "Failed to edit" },
+	write: { running: "Writing", success: "Wrote", error: "Failed to write" },
+};
+
+const settled = (status: RowStatus) => status === "success" || status === "error" ? status : "running";
+
+/** An exploration tool's verb and what it looked at, as a lone row names them. */
+function lookTitle(name: string, args: ToolArgs, theme: Theme): { verb: string; target: string } {
+	const path = codexPath(args);
+	if (name === "read") return { verb: "Read", target: path };
+	if (name === "ls") return { verb: "List", target: path || "." };
+	const pattern = typeof args.pattern === "string" ? normalizeLineEndings(args.pattern).split("\n")[0]!.trim() : "";
+	return { verb: "Search", target: path ? `${pattern}${theme.fg("dim", " in ")}${path}` : pattern };
+}
+
+function changeCount(theme: Theme, added: number, removed: number): string {
+	return `(${theme.fg("toolDiffAdded", `+${added}`)} ${theme.fg("toolDiffRemoved", `-${removed}`)})`;
+}
+
+function writeLineCount(args: ToolArgs): number {
+	const content = typeof args.content === "string" ? normalizeLineEndings(args.content) : "";
+	return content ? content.replace(/\n$/u, "").split("\n").length : 0;
+}
+
+/** A custom tool's call as Codex writes an MCP call it opened: `name({"query":"x"})`. */
+function invocation(name: string, args: ToolArgs): Segment[] {
+	let json = "";
+	try {
+		json = JSON.stringify(args) ?? "";
+	} catch {
+		json = "";
+	}
+	return [{ text: name, color: "accent" }, { text: "(" }, { text: json === "{}" ? "" : json, color: "dim" }, { text: ")" }];
+}
+
+/** Where a custom tool's opened header starts its invocation: beside the verb when it fits, else beneath it. */
+function invocationInline(verb: string, call: readonly Segment[], width: number): boolean {
+	return visibleWidth(call.map((segment) => segment.text).join("")) <= width - visibleWidth(`${CODEX_MARGIN}${CODEX_BULLET} ${verb} `);
+}
+
+/**
+ * The head of a Codex row, drawn from the row's state each time it is painted: the
+ * verb follows the call from running to its outcome, and an edit's counts and a
+ * command's exit code arrive with the result.
+ */
+export function renderCodexCall(
+	name: string,
+	kind: CodexRowKind,
+	args: ToolArgs,
+	theme: Theme,
+	state: RowState,
+	status: () => RowStatus,
+	indicator: () => string,
+	toolCallId: string,
+): Component {
+	const expanded = state.expanded === true;
+	const command = kind === "shell" ? commandOf(args) : "";
+	const segments = kind === "shell" ? commandSegments(command) : [];
+	let current: RowStatus = "pending";
+	let dot = "";
+	// Opened, a command reads as its transcript; one with nothing left out keeps its preview, as in Codex.
+	const opened = (width: number) => expanded && kind === "shell" && (openExplorations.has(toolCallId)
+		|| (state.codex?.opens?.(width) ?? headerCut(command, VERBS.shell.running, width)));
+	return new LiveLines((width) => {
+		dot = indicator();
+		current = status();
+		const outcome = state.codex;
+		return `${dot}|${current}|${outcome?.exitCode ?? ""}|${outcome?.changes?.added ?? ""}/${outcome?.changes?.removed ?? ""}|${opened(width)}`;
+	}, (width) => {
+		const phase = settled(current);
+		const bullet = phase === "success" ? theme.bold(theme.fg("success", CODEX_BULLET))
+			: phase === "error" ? theme.bold(theme.fg("error", CODEX_BULLET)) : dot;
+		const head = (verb: string, rest: string) => `${CODEX_MARGIN}${bullet} ${theme.bold(verb)}${rest ? ` ${rest}` : ""}`;
+		if (kind === "shell") {
+			if (opened(width)) {
+				const prompt = theme.fg("bashMode", "$ ");
+				const first = width - visibleWidth(CODEX_MARGIN + "$ ");
+				const rest = Math.max(1, width - visibleWidth(CODEX_COMMAND_INDENT));
+				return segments.flatMap((line, index) => wrapSegments(line, index === 0 ? first : rest, rest)
+					.map((row, position) => index === 0 && position === 0 ? `${CODEX_MARGIN}${prompt}${paintSegments(row, theme)}` : `${CODEX_COMMAND_INDENT}${paintSegments(row, theme)}`));
+			}
+			const exitCode = state.codex?.exitCode;
+			const verb = phase === "error" && exitCode !== undefined ? `Failed (exit ${exitCode})` : VERBS.shell[phase];
+			// Painted as it is drawn, so a theme switched since the row was made colors it too.
+			return [clip(head(verb, paintSegments(segments[0] ?? [], theme) + (segments.length > 1 ? " …" : "")), width)];
+		}
+		if (kind === "custom") {
+			const verb = VERBS.custom[phase];
+			if (!expanded) return [clip(head(verb, theme.fg("accent", name)), width)];
+			const call = invocation(name, args);
+			if (invocationInline(verb, call, width)) return [head(verb, paintSegments(call, theme))];
+			return [head(verb, ""), ...prefixedRows([call], theme.fg("dim", CODEX_RESULT_PREFIX), CODEX_INDENT, width, theme)];
+		}
+		const path = codexPath(args);
+		if (name === "edit" || name === "write") {
+			const verbs = VERBS[name];
+			if (phase === "error") return [clip(`${CODEX_MARGIN}${theme.fg("error", theme.bold(`✘ ${verbs.error}${path ? ` ${path}` : ""}`))}`, width)];
+			if (phase === "running") return [clip(head(verbs.running, path), width)];
+			const changes = name === "write" ? { added: writeLineCount(args), removed: 0 } : state.codex?.changes ?? { added: 0, removed: 0 };
+			return [clip(`${CODEX_MARGIN}${theme.fg("dim", CODEX_BULLET)} ${theme.bold(verbs.success)} ${path} ${changeCount(theme, changes.added, changes.removed)}`, width)];
+		}
+		const { verb, target } = lookTitle(name, args, theme);
+		return [clip(head(verb, target), width)];
+	});
+}
+
+type ResultInput = {
+	name: string;
+	kind: CodexRowKind;
+	args: ToolArgs;
+	result: AgentToolResult<unknown>;
+	output: string;
+	theme: Theme;
+	state: RowState;
+	isError: boolean;
+	isPartial: boolean;
+	expanded: boolean;
+	toolCallId: string;
+	author?: (expanded: boolean) => Component | undefined;
+};
+
+/**
+ * `✓ • 1.23s`, or `✗ (2) • 1.23s`: how an opened call ended, and how long it took.
+ * A row restored from the session was never timed here, so it shows only how it ended.
+ */
+function outcomeLine(theme: Theme, isError: boolean, exitCode: number | undefined, duration: string | undefined): string {
+	const mark = isError
+		? theme.bold(theme.fg("error", "✗")) + (exitCode !== undefined ? ` (${exitCode})` : "")
+		: theme.bold(theme.fg("success", "✓"));
+	return `${CODEX_MARGIN}${mark}${duration ? theme.fg("dim", ` • ${duration}`) : ""}`;
+}
+
+/** The last rows of output under `└`, each cut to the row, dim as Codex previews them. */
+function previewRows(lines: readonly string[], theme: Theme, width: number): string[] {
+	return lines.map((line, index) => clip(theme.fg("dim", (index === 0 ? CODEX_RESULT_PREFIX : CODEX_INDENT) + line), width, theme.fg("dim", "…")));
+}
+
+/**
+ * How many lines a collapsed preview leaves out: every line before the last three,
+ * and any of those three too wide to show whole.
+ */
+function hiddenLines(lines: readonly string[], width: number): number {
+	const shown = lines.slice(Math.max(0, lines.length - CODEX_PREVIEW_ROWS));
+	return Math.max(0, lines.length - CODEX_PREVIEW_ROWS)
+		+ shown.filter((line) => visibleWidth(line) + visibleWidth(CODEX_INDENT) > width).length;
+}
+
+function outputLines(text: string): string[] {
+	return normalizeLineEndings(stripTerminalSequences(text)).replace(/\n+$/u, "").split("\n").map((line) => line.replace(/\t/gu, CODEX_TAB));
+}
+
+/** An opened call's output: whole, undimmed, wrapped from the margin. */
+function fullOutput(text: string, theme: Theme, width: number): string[] {
+	if (isEmptyOutput(text)) return [];
+	return prefixedRows(outputLines(text).map((line) => line ? [{ text: line, color: "toolOutput" as const }] : []), CODEX_MARGIN, CODEX_MARGIN, width, theme);
+}
+
+function dimDisclosure(theme: Theme, width: number, expanded: boolean, hidden?: number): string {
+	return clip(theme.fg("dim", codexDisclosure(width, expanded, hidden)), width, theme.fg("dim", "…"));
+}
+
+/** A command, or a lone read, search, or listing: the tail of its output, or all of it opened. */
+/** The verb a command's collapsed head reads with. */
+function shellVerb(isPartial: boolean, isError: boolean, exitCode: number | undefined): string {
+	if (isPartial) return VERBS.shell.running;
+	if (!isError) return VERBS.shell.success;
+	return exitCode !== undefined ? `Failed (exit ${exitCode})` : VERBS.shell.error;
+}
+
+/** Whether a command's collapsed head hides part of it: a second line, or a first line too wide for the row. */
+function headerCut(command: string, verb: string, width: number): boolean {
+	const lines = command.split("\n");
+	return lines.length > 1 || visibleWidth(`${CODEX_MARGIN}${CODEX_BULLET} ${verb} ${lines[0] ?? ""}`) > width;
+}
+
+/** What a call's output and the text it shows come to: a command's exit code apart, a read's notice apart. */
+function outputOf(input: ResultInput) {
+	const { name, kind, isError } = input;
+	const outcome = kind === "shell" && isError ? shellOutcome(input.output) : { output: input.output, exitCode: undefined };
+	const read = name === "read" && !isError ? splitReadFooter(outcome.output) : undefined;
+	return { exitCode: outcome.exitCode, text: read?.body ?? outcome.output, footer: read?.footer };
+}
+
+/**
+ * What a collapsed command or lone read leaves out at a width: the lines it hides,
+ * "generic" when only its head is cut, and undefined when it shows everything, in
+ * which case Codex offers no control and does not open it.
+ */
+function collapsedDetails(input: ResultInput, width: number): number | "generic" | undefined {
+	const { exitCode, text, footer } = outputOf(input);
+	const hidden = isEmptyOutput(text) ? 0 : hiddenLines(outputLines(text), width);
+	if (hidden > 0) return hidden;
+	// A read cut short says so only once opened.
+	if (footer) return "generic";
+	const command = input.kind === "shell" ? commandOf(input.args) : "";
+	return input.kind === "shell" && headerCut(command, shellVerb(input.isPartial, input.isError, exitCode), width) ? "generic" : undefined;
+}
+
+function outputResult(input: ResultInput, width: number): string[] {
+	const { theme, state, isError, isPartial } = input;
+	const { exitCode, text, footer } = outputOf(input);
+	const empty = isEmptyOutput(text);
+	const details = collapsedDetails(input, width);
+	if (opens(input, width)) {
+		// Codex has no file view: what a read returned shows as a command's output does, notice and all.
+		const rows = fullOutput(footer ? `${text}\n\n${footer}` : text, theme, width);
+		const ended = isPartial ? [] : [outcomeLine(theme, isError, exitCode, durationOf(state))];
+		return [...rows, ...ended, dimDisclosure(theme, width, true)];
+	}
+	const rows = empty ? (isPartial ? [] : previewRows(["(no output)"], theme, width))
+		: previewRows(tailLines(outputLines(text).join("\n")), theme, width);
+	if (details === undefined) return rows;
+	return [...rows, dimDisclosure(theme, width, false, details === "generic" ? undefined : details)];
+}
+
+/** Whether a command or lone read draws opened: always within an opened exploration, else only when it has more to show. */
+function opens(input: ResultInput, width: number): boolean {
+	return input.expanded && (openExplorations.has(input.toolCallId) || collapsedDetails(input, width) !== undefined);
+}
+
+/** A failed edit or write: why, under `└`, three rows of it until opened. */
+function failureResult(input: ResultInput, width: number): string[] {
+	const { theme, expanded } = input;
+	const reason = input.output.trim() || "(error details unavailable)";
+	const rows = prefixedRows(textLines(reason, "dim"), theme.fg("dim", CODEX_RESULT_PREFIX), CODEX_INDENT, width, theme);
+	if (expanded) return [...rows, dimDisclosure(theme, width, true)];
+	return [...rows.slice(0, CODEX_PREVIEW_ROWS).map((row) => clip(row, width, theme.fg("dim", "…"))), dimDisclosure(theme, width, false)];
+}
+
+/** Changed lines only, as Codex previews a patch: context dropped, one `⋮` between hunks. */
+function changesOnly(lines: readonly CodeDiffLine[]): CodeDiffLine[] {
+	const kept: CodeDiffLine[] = [];
+	for (const line of lines) {
+		if (line.kind === "context") continue;
+		if (line.kind === "separator" && (kept.length === 0 || kept.at(-1)!.kind === "separator")) continue;
+		kept.push(line);
+	}
+	while (kept.at(-1)?.kind === "separator") kept.pop();
+	return kept;
+}
+
+/** An edit's diff or a write's new lines, the first changed rows until opened, every hunk once opened. */
+function patchResult(input: ResultInput, width: number, lines: readonly CodeDiffLine[]): string[] {
+	const { theme, expanded, args } = input;
+	const shown = expanded ? lines : changesOnly(lines);
+	const rows = renderCodexDiff(shown, codexPath(args), theme, CODEX_INDENT, expanded ? undefined : CODEX_PREVIEW_ROWS)?.render(width) ?? [];
+	return [...rows, dimDisclosure(theme, width, expanded)];
+}
+
+/** A custom tool's result as Codex shows an MCP call's: the last lines, then all of it, or its author's view. */
+function customResult(input: ResultInput, width: number): string[] {
+	const { name, args, theme, isError, isPartial, expanded, author } = input;
+	const text = isEmptyOutput(input.output) ? "" : input.output.trimEnd();
+	if (isPartial) return text ? previewRows(tailLines(text), theme, width) : [];
+	if (expanded) {
+		const inline = invocationInline(VERBS.custom[isError ? "error" : "success"], invocation(name, args), width);
+		const first = inline ? theme.fg("dim", CODEX_RESULT_PREFIX) : CODEX_INDENT;
+		let rows: string[] = [];
+		let component: Component | undefined;
+		if (author && !isError) {
+			try {
+				component = author(true);
+			} catch {
+				// A failing third-party renderer degrades to the plain text result.
+			}
+		}
+		if (component) {
+			// The author's view hangs from "└" like any result, without the blank lines it may open with.
+			const lines = component.render(Math.max(1, width - visibleWidth(CODEX_INDENT)));
+			const start = lines.findIndex((line) => stripTerminalSequences(line).trim() !== "");
+			rows = (start < 0 ? [] : lines.slice(start)).map((line, index) => (index === 0 ? first : CODEX_INDENT) + line);
+		} else if (text || isError) rows = prefixedRows(textLines(outputLines(isError ? `Error: ${text}` : text).join("\n"), "dim"), first, CODEX_INDENT, width, theme);
+		return [...rows, dimDisclosure(theme, width, true)];
+	}
+	let lines = text ? tailLines(text) : [];
+	if (isError && outputLines(text).length <= CODEX_PREVIEW_ROWS) lines = lines.length ? [`Error: ${lines[0]}`, ...lines.slice(1)] : ["Error: "];
+	return [...previewRows(lines, theme, width), dimDisclosure(theme, width, false)];
+}
+
+/** Everything a Codex row draws beneath its head. */
+export function renderCodexResult(input: ResultInput): Component {
+	const { name, kind, result, state, isError, isPartial, args } = input;
+	if (kind === "shell" && isError && !isPartial) state.codex = { ...state.codex, exitCode: shellOutcome(input.output).exitCode };
+	let draw: (width: number) => string[];
+	if (kind === "custom") {
+		draw = (width) => customResult(input, width);
+	} else if (name === "edit" || name === "write") {
+		if (isPartial) return new LiveLines(() => "", () => []);
+		if (isError) {
+			draw = (width) => failureResult(input, width);
+		} else if (name === "edit") {
+			state.codex = { ...state.codex, changes: countEditChanges(result) ?? { added: 0, removed: 0 } };
+			const lines = parseCodeDiff(getEditPatch(result), getEditDiff(result), CODEX_TAB);
+			draw = (width) => patchResult(input, width, lines);
+		} else {
+			const content = typeof args.content === "string" ? normalizeLineEndings(args.content).replace(/\n$/u, "") : "";
+			const lines = content ? content.split("\n").map((line, index): CodeDiffLine => ({ kind: "add", lineNumber: index + 1, content: line.replace(/\t/gu, CODEX_TAB), hunk: 0 })) : [];
+			draw = (width) => patchResult(input, width, lines);
+		}
+	} else {
+		draw = (width) => outputResult(input, width);
+		state.codex = { ...state.codex, opens: (width) => opens(input, width) };
+	}
+	// In an opened exploration the group's one "− Show less" closes it, so the call leaves out its own.
+	const grouped = () => openExplorations.has(input.toolCallId);
+	return new LiveLines(() => (grouped() ? "grouped" : ""), (width) => {
+		const lines = draw(width);
+		if (grouped() && lines.at(-1) === dimDisclosure(input.theme, width, true)) lines.pop();
+		return lines;
+	});
+}