@gavin-hu/my-pi-agent 0.9.0 → 0.10.0

package/extensions/bytefly/block/component.ts

@@ -0,0 +1,282 @@
+/**
+ * The tool-block frame: a tool's own call line as the headline, then its body
+ * indented under it.
+ *
+ * The resolver sets `renderShell: "self"`, so Pi draws no background box and no
+ * padding; this frame supplies the indent and the width math. The inner
+ * component is the tool's existing renderer (or a generic fallback), so syntax
+ * highlighting, diffs, previews, and truncation notices are preserved — only the
+ * frame changes.
+ *
+ * The call block leads with its first non-blank line — the tool's own call line,
+ * which every built-in and package renderer already opens with the tool name —
+ * and the body follows at `BODY_INDENT` columns, with no separator line, so the
+ * block is compact. A body may carry a `rail`: a pre-painted glyph in the first
+ * indent column, occupying the two columns the plain indent uses. The headline is
+ * never railed. The result frame carries it for every tool; the call frame carries
+ * it too when the call body *is* the result (`edit`'s diff, `write`'s content),
+ * except for the lines of a call line that wrapped — those are the call, so the
+ * rail starts at the result.
+ *
+ * The tool name is the block's only accent. The shipped themes point
+ * `toolTitle` at the accent, so a primary subject — a path, URL, query, pattern
+ * — would otherwise spend the same colour; `recolorCallHeadline` demotes it to
+ * the body role on the call's first line, and a subject that wrapped onto the
+ * body (`edit <path>`) is demoted there too.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, stripTerminalSequences, truncateToWidth } from "@earendil-works/pi-tui";
+import { sanitizeLine } from "../../../lib/format.ts";
+import { BODY_INDENT, bodyLines, indentBlockLines } from "../../../lib/tui/indent.ts";
+import { paintPrefix } from "../../../lib/tui/tokens.ts";
+
+/** How one tool-block frame is drawn. */
+export interface ToolBlockOptions {
+	/**
+	 * Lead with the component's first non-blank line as the block's headline. Set
+	 * on the call, never on the result.
+	 */
+	headline?: boolean;
+	/**
+	 * Drop the component's own leading blank lines, so a self-shell `Box` (`edit`)
+	 * or a result's spacer never opens the block with a gap.
+	 */
+	trimLeading?: boolean;
+	/** The tool name, so a shell prompt in the headline becomes the tool name. */
+	toolName?: string;
+	/**
+	 * A pre-painted rail glyph for the body's first indent column, from
+	 * `../chrome.ts`. Set on every result frame, and on the call frame only for a
+	 * tool whose call body carries the result (`edit`, `write`); the headline is
+	 * never railed, and neither is a call line that wrapped onto the body.
+	 */
+	rail?: string;
+	/**
+	 * The active theme. A shell call's command and a call's primary subject are
+	 * repainted in the `label` role, so only the tool name spends the accent;
+	 * without it the line is left as Pi drew it.
+	 */
+	theme?: Theme;
+}
+
+/**
+ * Pi draws a shell call as `$ <command>` (or `> <command>` in PowerShell) rather
+ * than `bash <command>`. The tool name is the block's headline, so rewrite that
+ * leading prompt in place. The name keeps Pi's `toolTitle` styling (the accent
+ * in the shipped themes); the command is reopened in `label` and the bold run
+ * ended, so the name is the block's only accent.
+ */
+const SHELL_PROMPT = /^\s*[$>] /;
+/** The prompt and the space after it, so a themed rewrite can replace both. */
+const SHELL_PROMPT_SPAN = /[$>] /;
+
+/** Replace a shell call's leading prompt with the tool name. */
+export function headlineWithToolName(line: string, toolName: string, theme?: Theme): string {
+	if (!SHELL_PROMPT.test(stripTerminalSequences(line))) return line;
+	const name = sanitizeLine(toolName);
+	if (!theme) return line.replace(/[$>]/, name);
+	// `\u001b[22m` ends the name's bold run; the role's opening colours what
+	// follows, which Pi's own trailing reset then closes.
+	return line.replace(SHELL_PROMPT_SPAN, `${name} \u001b[22m${paintPrefix(theme, "label")}`);
+}
+
+/**
+ * Recolour a shell call's prompt on its whole (unwrapped) string.
+ *
+ * Pi renders `$ <command>` as one `toolTitle` run, which `Text` then wraps; a
+ * rewrite applied to the first *rendered* line would leave every wrapped
+ * fragment of the command in the accent. Applying it before the wrap keeps the
+ * name's accent and the command's `label` on every fragment, because the wrap
+ * re-emits whichever run it split. Returns `text` unchanged when its first line
+ * is not a shell prompt.
+ */
+export function recolorShellCall(text: string, toolName: string, theme: Theme): string {
+	const end = text.indexOf("\n");
+	const head = end === -1 ? text : text.slice(0, end);
+	if (!SHELL_PROMPT.test(stripTerminalSequences(head))) return text;
+	const rewritten = headlineWithToolName(head, toolName, theme);
+	return end === -1 ? rewritten : rewritten + text.slice(end);
+}
+
+/**
+ * Repaint every accent opening at or after `from` in the body role. A theme that
+ * paints no colour, or whose two roles coincide, is left alone.
+ */
+function demoteFrom(text: string, from: number, theme: Theme): string {
+	const accent = paintPrefix(theme, "accent");
+	const label = paintPrefix(theme, "label");
+	if (!accent || accent === label) return text;
+
+	let out = "";
+	let i = 0;
+	for (;;) {
+		const hit = text.indexOf(accent, i);
+		if (hit === -1) {
+			out += text.slice(i);
+			break;
+		}
+		out += text.slice(i, hit);
+		out += hit >= from ? label : accent;
+		i = hit + accent.length;
+	}
+	return out;
+}
+
+/**
+ * Demote every accent opening on a line to the body colour. Applied to a call's
+ * continuation lines — the wrapped tail of a subject, which is still the call.
+ */
+function demoteAccent(text: string, theme: Theme): string {
+	return demoteFrom(text, 0, theme);
+}
+
+/**
+ * Demote a call headline's primary subject from the accent to the body colour,
+ * so the tool name is the block's only accent.
+ *
+ * The name and the subject share the accent sequence in the shipped themes, so
+ * the name is told apart by position: the first accent opening at or after the
+ * tool name stays, and every later one on the first line is the subject. Only
+ * line one is touched — a multi-line call's continuation lines keep their own
+ * roles, except the wrapped tail of a bare headline (see `toolBlockLines`).
+ */
+export function recolorCallHeadline(text: string, toolName: string, theme: Theme): string {
+	const accent = paintPrefix(theme, "accent");
+	if (!accent || accent === paintPrefix(theme, "label")) return text;
+	const end = text.indexOf("\n");
+	const head = end === -1 ? text : text.slice(0, end);
+	if (!head.includes(accent)) return text;
+
+	// Everything after the tool name is its subject; without a name to anchor on
+	// (a renderer that does not open with it) demote the whole line.
+	const name = sanitizeLine(toolName);
+	const at = head.indexOf(name);
+	const from = at === -1 ? 0 : at + name.length;
+
+	const out = demoteFrom(head, from, theme);
+	return end === -1 ? out : out + text.slice(end);
+}
+
+/** A renderer component that carries a mutable string: Pi's own `Text`. */
+interface Rewritable {
+	text: string;
+	setText(text: string): void;
+}
+
+/**
+ * Whether a component exposes the `Text` shape. Pi's shell renderers return a
+ * `Text`, whose `text` field is private to the type but present at runtime.
+ */
+export function isRewritable(component: Component): component is Component & Rewritable {
+	const candidate = component as Partial<Rewritable>;
+	return typeof candidate.text === "string" && typeof candidate.setText === "function";
+}
+
+/**
+ * Whether a line has no visible text. Tested after stripping terminal sequences,
+ * so a line carrying only a background or the indent counts as blank.
+ */
+function isBlankLine(line: string): boolean {
+	return stripTerminalSequences(line).trim().length === 0;
+}
+
+/**
+ * Whether a call line degenerated to the tool name alone, so the rest of it —
+ * the path, the command — moved onto the body lines under it.
+ *
+ * Pi wraps the call line before the frame sees it, and a `edit <path>` pair is
+ * one long unbreakable token: once the path no longer fits, the wrapper drops the
+ * name onto its own line and hard-breaks the path below it. The bare name is the
+ * only reliable marker of that, and it matters because those lines are the call,
+ * not the result — a railed call body (`edit`, `write`) would otherwise draw the
+ * path as diff content.
+ */
+function isBareHeadline(body: readonly string[], toolName: string | undefined): boolean {
+	if (!toolName) return false;
+	const headline = body.find((line) => !isBlankLine(line));
+	return headline !== undefined && stripTerminalSequences(headline).trim() === sanitizeLine(toolName);
+}
+
+/**
+ * How many body lines after a bare headline are still the call: the leading run
+ * of non-blank lines, which ends where the result begins. Zero for a call whose
+ * headline carries its own subject.
+ */
+function callContinuationCount(body: readonly string[], toolName: string | undefined): number {
+	if (!isBareHeadline(body, toolName)) return 0;
+	let index = body.findIndex((line) => !isBlankLine(line)) + 1;
+	let count = 0;
+	while (index < body.length && !isBlankLine(body[index] ?? "")) {
+		count++;
+		index++;
+	}
+	return count;
+}
+
+/**
+ * Indent `inner` under the block's headline: the body at `outputPad + BODY_INDENT`,
+ * the headline (when asked for) at `outputPad`. `width` clips the headline again
+ * after its prompt is rewritten, so a longer tool name cannot overflow.
+ */
+export function toolBlockLines(
+	inner: Component | undefined,
+	width: number,
+	outputPad: number,
+	options: ToolBlockOptions = {},
+): string[] {
+	const w = Math.max(1, width);
+	const indent = (outputPad ?? 0) + BODY_INDENT;
+	const body = bodyLines(inner, w, indent);
+	const lines = indentBlockLines(body, w, {
+		indent,
+		rail: options.rail,
+		headline: options.headline,
+		trimLeading: options.trimLeading,
+		// A railed call body starts at the result, never at the tail of a wrapped
+		// call line.
+		railAfterCall: options.rail !== undefined && isBareHeadline(body, options.toolName),
+	});
+	if (options.headline && lines.length > 0) {
+		// The base renders at the reduced (indented) width, so drop the padding it
+		// added before the prompt rewrite can push the headline over the clip.
+		const headline = (lines[0] ?? "").trimEnd();
+		const named = options.toolName ? headlineWithToolName(headline, options.toolName, options.theme) : headline;
+		// A renderer that rebuilds its component after `renderCall` (`edit` moves its
+		// diff onto the box) drops the rewrite the resolver applied there, so the
+		// headline is demoted again here. It is a no-op for a call the resolver
+		// already recoloured before the wrap.
+		const recolored =
+			options.toolName && options.theme ? recolorCallHeadline(named, options.toolName, options.theme) : named;
+		lines[0] = truncateToWidth(recolored, w, "…");
+		// A call whose subject is one unbreakable token (`edit <path>`) wraps by
+		// dropping the name onto the headline and breaking the subject below it.
+		// Those continuation lines are still the call, so they lose the accent too
+		// — otherwise the path reads as a heading and the name stops being the
+		// block's only accent.
+		if (options.theme) {
+			const continuation = callContinuationCount(body, options.toolName);
+			for (let index = 1; index <= continuation && index < lines.length; index++) {
+				lines[index] = demoteAccent(lines[index] ?? "", options.theme);
+			}
+		}
+	}
+	return lines;
+}
+
+/** The frame Pi mounts in place of its background box for a tool row. */
+export class ToolBlock implements Component {
+	constructor(
+		private readonly inner: Component | undefined,
+		private readonly outputPad: number,
+		private readonly options: ToolBlockOptions = {},
+	) {}
+
+	invalidate(): void {
+		this.inner?.invalidate();
+	}
+
+	render(width: number): string[] {
+		return toolBlockLines(this.inner, Math.max(1, width), this.outputPad, this.options);
+	}
+}

package/extensions/bytefly/block/config.ts

@@ -0,0 +1,24 @@
+/**
+ * Tuning for the tool-block result rail.
+ *
+ * A tool result hangs from the transcript rail (`../chrome.ts`), painted by
+ * status. A finished or merely informational result keeps the neutral `faint`
+ * rail, so only a running or failed one spends colour. The two file-mutating
+ * tools (`edit`, `write`) carry their result on the call body, so that body is
+ * railed the same way.
+ */
+
+import type { TuiRole } from "../../../lib/tui/tokens.ts";
+import { RAIL_ROLES, type RailStatus } from "../chrome.ts";
+
+/** How a tool result reads at a glance; `warn` is the notice's rail. */
+export type BlockStatus = Exclude<RailStatus, "warn">;
+
+export const BLOCK_CONFIG = {
+	/**
+	 * A running result is active, so its rail takes the accent — the one colour a
+	 * tool result spends. A finished result stays neutral and an error keeps the
+	 * shared `bad` role, so the rail family still cannot drift.
+	 */
+	roles: { info: "accent", ok: RAIL_ROLES.ok, bad: RAIL_ROLES.bad } as Record<BlockStatus, TuiRole>,
+} as const;

package/extensions/bytefly/block/fallback.ts

@@ -0,0 +1,120 @@
+/**
+ * Generic call and result fallbacks for a tool with no renderer of its own.
+ *
+ * Pi's own fallback is only used when nothing resolves a renderer; because the
+ * resolver returns one for every tool, a tool like an MCP call with no renderer
+ * would otherwise be framed around nothing. These mirror how the built-ins read
+ * — a bare subject, then any options — so the block reads like the rest of the
+ * transcript instead of a raw argument dump, and every value is sanitized at the
+ * boundary.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { sanitizeLine, stripControlChars } from "../../../lib/format.ts";
+import { paint } from "../../../lib/tui/tokens.ts";
+
+/** Collapsed argument preview length, matching Pi's generic call header. */
+const COLLAPSED_ARGS_CHARS = 100;
+
+/** Result lines shown before the rest collapse into a note. */
+const FALLBACK_PREVIEW_LINES = 10;
+
+/** Split top-level arguments into key/value pairs, in insertion order. */
+function argumentEntries(args: unknown): Array<[string, unknown]> {
+	if (typeof args === "object" && args !== null && !Array.isArray(args)) {
+		return Object.entries(args as Record<string, unknown>);
+	}
+	return [["args", args]];
+}
+
+/**
+ * The argument shown bare after the tool name, the way a built-in names its
+ * subject (`read src/cli.ts:1-8`). Only a non-empty string qualifies, so an
+ * option never loses its key; one with spaces is quoted so it stays one value.
+ */
+function subjectValue(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const text = sanitizeLine(value);
+	if (!text) return undefined;
+	return /\s/.test(text) ? JSON.stringify(text) : text;
+}
+
+/**
+ * One option fragment: `key value`, a bare `key` for a true flag, or undefined
+ * when the value carries nothing (a false flag, null, or an empty string).
+ */
+function optionFragment(key: string, value: unknown): string | undefined {
+	if (value === undefined || value === null || value === false || value === "") return undefined;
+	const name = sanitizeLine(key);
+	if (value === true) return name;
+	if (typeof value === "string") return `${name} ${subjectValue(value) ?? ""}`.trimEnd();
+	if (typeof value === "number" || typeof value === "bigint") return `${name} ${value}`;
+	return `${name} ${sanitizeLine(JSON.stringify(value) ?? String(value))}`;
+}
+
+/**
+ * A call line for a tool with no renderer: the bold title, then its leading
+ * string argument (when there is one) and the remaining options in parentheses,
+ * matching the built-ins' `read <path>` / `ls <path> (limit 500)` grammar. The
+ * subject reads in the body colour — the tool name is the call's only accent —
+ * and the options stay faint.
+ */
+export function callFallback(toolName: string, args: unknown, theme: Theme, expanded: boolean): string {
+	const header = theme.fg("toolTitle", theme.bold(toolName));
+	if (args == null) return header;
+	const entries = argumentEntries(args);
+	if (entries.length === 0) return header;
+	if (expanded) {
+		const lines = entries.map(([key, value]) => {
+			const text = typeof value === "string" ? value : (JSON.stringify(value, null, 2) ?? String(value));
+			return `  ${sanitizeLine(key)}: ${stripControlChars(text).split("\n").join("\n    ")}`;
+		});
+		return `${header}\n${paint(theme, "meta", lines.join("\n"))}`;
+	}
+
+	let subject: string | undefined;
+	const options: string[] = [];
+	for (const [key, value] of entries) {
+		if (subject === undefined) {
+			const candidate = subjectValue(value);
+			if (candidate !== undefined) {
+				subject = candidate;
+				continue;
+			}
+		}
+		const option = optionFragment(key, value);
+		if (option !== undefined) options.push(option);
+	}
+
+	// With a subject the options read as a trailing aside; without one (a flag or
+	// no arguments at all) they stand on their own.
+	const body =
+		subject !== undefined ? `${subject}${options.length > 0 ? ` (${options.join(", ")})` : ""}` : options.join(" ");
+	if (!body) return header;
+	const preview = body.length > COLLAPSED_ARGS_CHARS ? `${body.slice(0, COLLAPSED_ARGS_CHARS - 3)}...` : body;
+	if (subject === undefined) return `${header} ${paint(theme, "faint", preview)}`;
+	// Colour the subject and the options apart, after the preview clip, so a
+	// clipped subject never strands an unterminated escape.
+	const subjectPart = preview.slice(0, Math.min(subject.length, preview.length));
+	const optionsPart = preview.slice(subjectPart.length);
+	return `${header} ${paint(theme, "label", subjectPart)}${optionsPart ? paint(theme, "faint", optionsPart) : ""}`;
+}
+
+/** A result preview for a tool with no renderer: its text, capped when collapsed. */
+export function resultFallback(
+	content: readonly { type: string; text?: string }[],
+	theme: Theme,
+	expanded: boolean,
+): string {
+	const text = content
+		.filter((block) => block.type === "text")
+		.map((block) => stripControlChars(block.text ?? ""))
+		.join("\n");
+	if (!text) return "";
+	const lines = text.split("\n");
+	const shown = expanded ? lines : lines.slice(0, FALLBACK_PREVIEW_LINES);
+	let output = theme.fg("toolOutput", shown.join("\n"));
+	const remaining = lines.length - shown.length;
+	if (remaining > 0) output += `\n${paint(theme, "meta", `... (${remaining} more lines)`)}`;
+	return output;
+}

package/extensions/bytefly/block/register.ts

@@ -0,0 +1,164 @@
+/**
+ * Registers bytefly's tool-block resolver.
+ *
+ * The resolver runs for every tool, built-ins included. It switches the row to
+ * `renderShell: "self"` — dropping Pi's filled status background — and frames
+ * the tool's own `renderCall` / `renderResult`, so the content is unchanged and
+ * only the framing is bytefly's. The call leads with its own first line as the
+ * headline; the body is indented directly under it. The body carries the
+ * transcript rail, painted by status. The result frame rails every tool; the
+ * call frame rails only the two file-mutating tools (`edit`, `write`), whose
+ * call body *is* the result (a diff, a written file). A tool with no renderer
+ * gets the same treatment around a generic fallback.
+ *
+ * The frame is added even for a tool that sets `renderShell: "self"` (`edit`):
+ * that only tells Pi not to draw its filled box, so its diff would otherwise sit
+ * at the wrong indent. The indent is bytefly's, not Pi's box, so nothing nests.
+ *
+ * Pi hands a renderer the component it returned last time as
+ * `context.lastComponent`, and every built-in renderer reuses it in place — it
+ * assumes that component is its own `Text` and calls `setText` on it. We return
+ * a `ToolBlock`, so passing it back would break the base renderer (it throws
+ * `text.setText is not a function`, and the row falls back to Pi's generic call
+ * line). The resolver therefore keeps each base renderer's own component in the
+ * row's shared `state` and hands *that* back, so the base updates in place while
+ * we wrap the result in a fresh frame.
+ *
+ * Because the frame takes over the row's `outputPad`, the base renderer is
+ * handed `outputPad: 0`. Pi's `edit` is a natively self-shell renderer and pads
+ * its own `Box` by `context.outputPad`; leaving the host value in place would
+ * add the pad twice and set the whole edit block a column deeper than every
+ * other block. The frame is the only place that applies the pad.
+ *
+ * The two tools that mutate a file (`edit`, `write`) carry their result on the
+ * call, so the call body is railed like a result. Pi's `edit` paints its own
+ * `Box` from a tool background role, so the frame hands it a theme whose `bg` is
+ * inert; otherwise the base would paint a band the rest of the transcript does
+ * not have. (`write` is a plain `Text` and paints nothing; the facade is a no-op
+ * there but shared.)
+ *
+ * Before framing, a shell call's `$ <command>` string is rewritten so the tool
+ * name keeps the accent and the command reads as the body (`recolorShellCall`),
+ * and a call's primary subject is demoted to the body colour
+ * (`recolorCallHeadline`), so the tool name is the block's only accent. Doing
+ * both on the string rather than the wrapped lines keeps a long command or
+ * subject in one role when it wraps; the frame repeats the subject rewrite for a
+ * component that is rebuilt after this point (`edit`).
+ */
+
+import type { ExtensionAPI, Theme, ThemeBg } from "@earendil-works/pi-coding-agent";
+import { type Component, Text } from "@earendil-works/pi-tui";
+import { createRailSource, railGlyph, type RailSource } from "../chrome.ts";
+import { createPadStore, type PadSource } from "../pad.ts";
+import { isRewritable, recolorCallHeadline, recolorShellCall, ToolBlock } from "./component.ts";
+import { BLOCK_CONFIG, type BlockStatus } from "./config.ts";
+import { callFallback, resultFallback } from "./fallback.ts";
+
+/** Per-row memory of the base renderer's own components, kept off Pi's state. */
+interface BlockMemory {
+	byteflyBaseCall?: Component;
+	byteflyBaseResult?: Component;
+}
+
+/** The tools whose call body carries the result: the two that mutate a file. */
+const RESULT_ON_CALL = new Set(["edit", "write"]);
+
+/** The painted rail glyph for a row's state: running spends the accent, a failure red. */
+function statusRail(theme: Theme, context: { isPartial: boolean; isError: boolean }, glyph: string): string {
+	const status: BlockStatus = context.isPartial ? "info" : context.isError ? "bad" : "ok";
+	return railGlyph(theme, BLOCK_CONFIG.roles[status], glyph);
+}
+
+/**
+ * A theme whose `bg` is inert. Pi's `edit` paints its own `Box` from a tool
+ * background role; the transcript has no bands, so the base must not paint one.
+ * Every other method is inherited unchanged.
+ */
+function withoutBackground(theme: Theme): Theme {
+	const suppressed = Object.create(theme) as Theme;
+	suppressed.bg = (_color: ThemeBg, text: string) => text;
+	return suppressed;
+}
+
+/**
+ * Call the base renderer, falling back to the frame's own line when it throws.
+ *
+ * A base can throw on a partial (still-streaming) argument. Catching it here
+ * keeps the frame in charge of the pad; letting it reach Pi would swap in Pi's
+ * generic call line, a column to the left, and the row would jump.
+ */
+function frameBase(render: () => Component | undefined, fallback: () => Component): Component {
+	try {
+		return render() ?? fallback();
+	} catch {
+		return fallback();
+	}
+}
+
+/** Register the resolver that frames every tool block with the bytefly indent. */
+export function registerToolBlocks(
+	pi: ExtensionAPI,
+	pad: PadSource = createPadStore(),
+	rail: RailSource = createRailSource(),
+): void {
+	pi.registerToolRenderer((toolName, next) => {
+		const base = next();
+		return {
+			renderShell: "self",
+			renderCall: (args, theme, context) => {
+				const memory = context.state as BlockMemory;
+				const resultOnCall = RESULT_ON_CALL.has(toolName);
+				const inner = frameBase(
+					() =>
+						base?.renderCall?.(args, resultOnCall ? withoutBackground(theme) : theme, {
+							...context,
+							outputPad: 0,
+							lastComponent: memory.byteflyBaseCall,
+						}),
+					() => new Text(callFallback(toolName, args, theme, context.expanded), 0, 0),
+				);
+				memory.byteflyBaseCall = inner;
+				// Split a shell call's roles before the frame wraps it: Pi renders
+				// `$ <cmd>` as one `toolTitle` run, so a rewrite after wrapping would
+				// only reach the first line and leave the wrapped command in the
+				// accent. `recolorShellCall` is a no-op for a call that is not a shell
+				// prompt. Then demote the subject (a path, URL, query, pattern) to the
+				// body colour, so the tool name is the call's only accent. Both run
+				// before the wrap for the same reason; the frame repeats the subject
+				// rewrite for a component that is rebuilt after this point (`edit`).
+				if (isRewritable(inner)) {
+					inner.setText(recolorCallHeadline(recolorShellCall(inner.text, toolName, theme), toolName, theme));
+				}
+				// The call's own first line is the block's headline; the frame drops the
+				// blank edges a self-shell `Box` (`edit`) pads itself with. A tool whose
+				// call body is its result (`edit`, `write`) rails that body.
+				return new ToolBlock(inner, pad.resolve(context.outputPad), {
+					headline: true,
+					trimLeading: true,
+					toolName,
+					theme,
+					rail: resultOnCall ? statusRail(theme, context, rail.resolve()) : undefined,
+				});
+			},
+			renderResult: (result, options, theme, context) => {
+				const memory = context.state as BlockMemory;
+				const resultOnCall = RESULT_ON_CALL.has(toolName);
+				const inner = frameBase(
+					() =>
+						base?.renderResult?.(result, options, resultOnCall ? withoutBackground(theme) : theme, {
+							...context,
+							outputPad: 0,
+							lastComponent: memory.byteflyBaseResult,
+						}),
+					() => new Text(resultFallback(result.content, theme, options.expanded), 0, 0),
+				);
+				memory.byteflyBaseResult = inner;
+				// A tool's own leading spacer would open the body with a gap, so drop it.
+				return new ToolBlock(inner, pad.resolve(context.outputPad), {
+					trimLeading: true,
+					rail: statusRail(theme, context, rail.resolve()),
+				});
+			},
+		};
+	});
+}