@oh-my-pi/pi-coding-agent 14.9.9 → 15.0.1

package/src/slash-commands/types.ts

@@ -0,0 +1,126 @@
+import type { Settings } from "../config/settings";
+import type { InteractiveModeContext } from "../modes/types";
+import type { AgentSession } from "../session/agent-session";
+import type { SessionManager } from "../session/session-manager";
+
+/** Declarative subcommand definition for commands like /mcp. */
+export interface SubcommandDef {
+	name: string;
+	description: string;
+	/** Usage hint shown as dim ghost text, e.g. "<name> [--scope project|user]". */
+	usage?: string;
+}
+
+/** Declarative builtin slash command metadata used by autocomplete and help UI. */
+export interface BuiltinSlashCommand {
+	name: string;
+	description: string;
+	/** Subcommands for dropdown completion (e.g. /mcp add, /mcp list). */
+	subcommands?: SubcommandDef[];
+	/** Static inline hint when command takes a simple argument (no subcommands). */
+	inlineHint?: string;
+}
+
+/** Parsed slash-command text after stripping the leading "/". */
+export interface ParsedSlashCommand {
+	name: string;
+	args: string;
+	text: string;
+}
+
+/**
+ * Result returned by a slash-command handler.
+ *
+ * - `void` / `undefined` — command was handled and consumed; no further input.
+ * - `{ consumed: true }` — explicit equivalent of the above (ACP shape).
+ * - `{ prompt: string }` — command handled, pass `prompt` through as the new
+ *   user input (e.g. `/force <tool> <prompt>` keeps `<prompt>` as the message).
+ */
+export type SlashCommandResult = undefined | { consumed: true } | { prompt: string };
+
+/**
+ * Runtime visible to slash-command handlers that run in text/ACP mode.
+ *
+ * Both the TUI dispatcher (when invoking a `handle` via its adapter) and the
+ * ACP dispatcher pass this shape. Implementations MUST NOT depend on TUI-only
+ * state (editor, selectors, status line).
+ */
+export interface SlashCommandRuntime {
+	session: AgentSession;
+	sessionManager: SessionManager;
+	settings: Settings;
+	cwd: string;
+	/** Emit text to the operator. TUI maps to `ctx.showStatus`, ACP to `sessionUpdate`. */
+	output: (text: string) => Promise<void> | void;
+	/** Re-advertise the available command list (no-op outside ACP). */
+	refreshCommands: () => Promise<void> | void;
+	/**
+	 * Reload plugin state (caches, slash command registry, project registries)
+	 * and re-emit available commands. Used by `/reload-plugins`, `/move`, and
+	 * `/marketplace`/`/plugins` mutations so the session sees a consistent view
+	 * after plugin or project-scope changes.
+	 */
+	reloadPlugins: () => Promise<void>;
+	notifyTitleChanged?: () => Promise<void> | void;
+	notifyConfigChanged?: () => Promise<void> | void;
+}
+
+/**
+ * Runtime visible to TUI-only handlers (`handleTui`). Carries the interactive
+ * mode context plus the background-detach hook. Intentionally narrower than
+ * `SlashCommandRuntime` so existing callers can keep building it from just
+ * `{ ctx, handleBackgroundCommand }`; when the TUI dispatcher needs to invoke
+ * a `handle` (no `handleTui` override), it synthesizes a `SlashCommandRuntime`
+ * from `ctx`.
+ */
+export interface TuiSlashCommandRuntime {
+	ctx: InteractiveModeContext;
+	handleBackgroundCommand: () => void;
+}
+
+/** Unified slash-command spec consumed by both TUI and ACP dispatchers. */
+export interface SlashCommandSpec extends BuiltinSlashCommand {
+	aliases?: string[];
+	/** When false, the dispatcher refuses to handle invocations that include arguments. */
+	allowArgs?: boolean;
+	/**
+	 * ACP-specific override for `description`. Used by `ACP_BUILTIN_SLASH_COMMANDS`
+	 * when building `available_commands_update` payloads so the client receives
+	 * mode-appropriate copy (e.g. `/dump` advertises "Return full transcript as
+	 * plain text" in ACP rather than the TUI's clipboard-centric copy).
+	 */
+	acpDescription?: string;
+	/**
+	 * ACP-specific override for the advertised input hint. `subcommands`-only
+	 * specs that historically advertised `<subcommand>` / `[on|off|status]` /
+	 * `info|delete` to ACP clients carry the hint here so the unification does
+	 * not silently drop it from `available_commands_update`.
+	 */
+	acpInputHint?: string;
+	/**
+	 * Text/ACP-mode handler. The same body is invoked from the ACP dispatcher
+	 * and, via the TUI adapter, when no `handleTui` override is provided.
+	 */
+	handle?: (
+		command: ParsedSlashCommand,
+		runtime: SlashCommandRuntime,
+	) => Promise<SlashCommandResult> | SlashCommandResult;
+	/**
+	 * TUI-only handler that supersedes `handle` when both are present. Use for
+	 * selectors, wizards, dashboards, and anything else that requires
+	 * `InteractiveModeContext`.
+	 */
+	handleTui?: (
+		command: ParsedSlashCommand,
+		runtime: TuiSlashCommandRuntime,
+	) => Promise<SlashCommandResult> | SlashCommandResult;
+}
+
+/**
+ * @deprecated Use `SlashCommandRuntime` directly. Retained as an alias so
+ * downstream code that imported the ACP-specific name keeps compiling.
+ */
+export type AcpBuiltinCommandRuntime = SlashCommandRuntime;
+
+/** Result returned by `executeAcpBuiltinSlashCommand`. */
+export type AcpBuiltinSlashCommandResult = false | { consumed: true } | { prompt: string };

package/src/ssh/ssh-executor.ts

@@ -1,5 +1,7 @@
 import { logger, ptree } from "@oh-my-pi/pi-utils";
+import { Settings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
+import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../tools/output-meta";
 import { buildRemoteCommand, ensureConnection, ensureHostInfo, type SSHConnectionTarget } from "./connection-manager";
 import { hasSshfs, mountRemote } from "./sshfs-mount";
 
@@ -83,10 +85,13 @@ export async function executeSSH(
 		stderr: "full",
 	});
 
+	const settings = await Settings.init();
 	const sink = new OutputSink({
 		onChunk: options?.onChunk,
 		artifactPath: options?.artifactPath,
 		artifactId: options?.artifactId,
+		headBytes: resolveOutputSinkHeadBytes(settings),
+		maxColumns: resolveOutputMaxColumns(settings),
 	});
 
 	const streams = [child.stdout.pipeTo(sink.createInput())];

package/src/system-prompt.ts

@@ -530,9 +530,11 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		description: tools?.get(name)?.description ?? "",
 	}));
 
-	// Filter skills to only include those with read tool.
+	// Filter skills for the rendered system prompt:
+	// - require the `read` tool so the model can actually fetch skill content;
+	// - drop skills with frontmatter `hide: true` (still loadable via skill:// and /skill:<name>).
 	const hasRead = tools?.has("read");
-	const filteredSkills = hasRead ? skills : [];
+	const filteredSkills = hasRead ? skills.filter(skill => skill.hide !== true) : [];
 
 	const effectiveSystemPromptCustomization = dedupePromptSource(systemPromptCustomization, [
 		resolvedCustomPrompt,

package/src/task/executor.ts

@@ -379,21 +379,29 @@ function firstNumberField(record: Record<string, unknown>, keys: string[]): numb
 }
 
 /**
- * Normalize usage objects from different event formats.
+ * Tokens for progress display: input + output + cacheWrite per turn.
+ *
+ * Deliberately excludes cacheRead. With prompt caching, cacheRead in each turn
+ * equals the full cached context (potentially hundreds of KB), so summing it
+ * across all turns produces a cumulative total that is N×context_size — far
+ * larger than the context window and misleading as a "work done" metric.
+ * cacheWrite is kept because each byte is written once, not repeated per turn.
+ * The cost segment handles billing; dedicated cache_read/cache_write segments
+ * handle cache-specific monitoring.
  */
 function getUsageTokens(usage: unknown): number {
 	if (!usage || typeof usage !== "object") return 0;
 	const record = usage as Record<string, unknown>;
 
-	const totalTokens = firstNumberField(record, ["totalTokens", "total_tokens"]);
-	if (totalTokens !== undefined && totalTokens > 0) return totalTokens;
-
 	const input = firstNumberField(record, ["input", "input_tokens", "inputTokens"]) ?? 0;
 	const output = firstNumberField(record, ["output", "output_tokens", "outputTokens"]) ?? 0;
-	const cacheRead = firstNumberField(record, ["cacheRead", "cache_read", "cacheReadTokens"]) ?? 0;
 	const cacheWrite = firstNumberField(record, ["cacheWrite", "cache_write", "cacheWriteTokens"]) ?? 0;
-
-	return input + output + cacheRead + cacheWrite;
+	const computed = input + output + cacheWrite;
+	if (computed > 0) return computed;
+	// Fallback for providers that only surface a pre-summed total without individual
+	// field breakdown. This total includes cacheRead, but returning it is still better
+	// than silently showing 0 for those providers.
+	return firstNumberField(record, ["totalTokens", "total_tokens"]) ?? 0;
 }
 
 /**
@@ -497,6 +505,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		recentOutput: [],
 		toolCount: 0,
 		tokens: 0,
+		cost: 0,
 		durationMs: 0,
 		modelOverride,
 	};
@@ -892,6 +901,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 							accumulatedUsage.cost.cacheRead += getNumberField(costRecord, "cacheRead") ?? 0;
 							accumulatedUsage.cost.cacheWrite += getNumberField(costRecord, "cacheWrite") ?? 0;
 							accumulatedUsage.cost.total += getNumberField(costRecord, "total") ?? 0;
+							progress.cost = accumulatedUsage.cost.total;
 						}
 					}
 					// Accumulate tokens for progress display
@@ -947,10 +957,17 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 		try {
 			checkAbort();
-			const authStorage = options.authStorage ?? (await discoverAuthStorage());
-			checkAbort();
+			// Pin authStorage to modelRegistry.authStorage — mirrors the createAgentSession invariant.
 			const registryFromParent = options.modelRegistry !== undefined;
-			const modelRegistry = options.modelRegistry ?? new ModelRegistry(authStorage);
+			const modelRegistry =
+				options.modelRegistry ?? new ModelRegistry(options.authStorage ?? (await discoverAuthStorage()));
+			const authStorage = modelRegistry.authStorage;
+			if (options.authStorage && options.authStorage !== authStorage) {
+				throw new Error(
+					"options.authStorage and options.modelRegistry.authStorage must be the same instance when both are provided",
+				);
+			}
+			checkAbort();
 			if (!registryFromParent) {
 				await modelRegistry.refresh();
 			} else {

package/src/task/index.ts

@@ -306,6 +306,7 @@ export class TaskTool implements AgentTool<TSchema, TaskToolDetails, Theme> {
 				recentOutput: [],
 				toolCount: 0,
 				tokens: 0,
+				cost: 0,
 				durationMs: 0,
 			});
 		}
@@ -390,6 +391,7 @@ export class TaskTool implements AgentTool<TSchema, TaskToolDetails, Theme> {
 										: "failed";
 								progress.durationMs = singleResult?.durationMs ?? Math.max(0, Date.now() - startedAt);
 								progress.tokens = singleResult?.tokens ?? 0;
+								progress.cost = singleResult?.usage?.cost.total ?? 0;
 								progress.extractedToolData = singleResult?.extractedToolData;
 							}
 							completedJobs += 1;
@@ -483,11 +485,27 @@ export class TaskTool implements AgentTool<TSchema, TaskToolDetails, Theme> {
 				? ` Failed to schedule ${failedSchedules.length} task${failedSchedules.length === 1 ? "" : "s"}.`
 				: "";
 
+		const ircEnabled = this.session.settings.get("irc.enabled") === true;
+		const taskIdByItemId = new Map<string, string>();
+		for (let i = 0; i < taskItems.length; i++) {
+			taskIdByItemId.set(taskItems[i].id, uniqueIds[i]);
+		}
+		const startedListing = startedJobs
+			.map(({ taskId }) => {
+				const id = taskIdByItemId.get(taskId) ?? taskId;
+				const desc = progressByTaskId.get(taskId)?.description;
+				return desc ? `- \`${id}\` — ${desc}` : `- \`${id}\``;
+			})
+			.join("\n");
+		const coordinationHint = ircEnabled
+			? ` DM these ids via \`irc\` to coordinate while they run; reach for \`job\` only to inspect (\`list\`), wait (\`poll\`), or cancel a stuck task.`
+			: ` Use \`job\` to inspect (\`list\`), wait (\`poll\`), or cancel a stuck task by id.`;
+
 		return {
 			content: [
 				{
 					type: "text",
-					text: `Started ${startedJobs.length} background task job${startedJobs.length === 1 ? "" : "s"} using ${params.agent}.${scheduleFailureSummary} Results will be delivered when complete.`,
+					text: `Started ${startedJobs.length} background task job${startedJobs.length === 1 ? "" : "s"} using ${params.agent}.${scheduleFailureSummary} Results will be delivered when complete.\n${startedListing}\n${coordinationHint}`,
 				},
 			],
 			details: {
@@ -815,6 +833,7 @@ export class TaskTool implements AgentTool<TSchema, TaskToolDetails, Theme> {
 					recentOutput: [],
 					toolCount: 0,
 					tokens: 0,
+					cost: 0,
 					durationMs: 0,
 					modelOverride,
 					description: taskItem.description,

package/src/task/render.ts

@@ -50,6 +50,24 @@ function getStatusIcon(status: AgentProgress["status"], theme: Theme, spinnerFra
 	}
 }
 
+/** Append tool-count, token, and cost stats to a status line string. */
+function appendAgentStats(
+	line: string,
+	opts: { toolCount?: number; tokens: number; cost: number },
+	theme: Theme,
+): string {
+	if (opts.toolCount) {
+		line += `${theme.sep.dot}${theme.fg("dim", `${opts.toolCount} tools`)}`;
+	}
+	if (opts.tokens > 0) {
+		line += `${theme.sep.dot}${theme.fg("dim", `${formatNumber(opts.tokens)} tokens`)}`;
+	}
+	if (opts.cost > 0) {
+		line += `${theme.sep.dot}${theme.fg("statusLineCost", `$${opts.cost.toFixed(2)}`)}`;
+	}
+	return line;
+}
+
 function formatFindingSummary(findings: ReportFindingDetails[], theme: Theme): string {
 	if (findings.length === 0) return theme.fg("dim", "Findings: none");
 
@@ -526,19 +544,9 @@ function renderAgentProgress(
 			const taskPreview = truncateToWidth(progress.assignment ?? progress.task, 40);
 			statusLine += ` ${theme.fg("muted", taskPreview)}`;
 		}
-		if (progress.toolCount > 0) {
-			statusLine += `${theme.sep.dot}${theme.fg("dim", `${progress.toolCount} tools`)}`;
-		}
-		if (progress.tokens > 0) {
-			statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatNumber(progress.tokens)} tokens`)}`;
-		}
+		statusLine = appendAgentStats(statusLine, progress, theme);
 	} else if (progress.status === "completed") {
-		if (progress.toolCount > 0) {
-			statusLine += `${theme.sep.dot}${theme.fg("dim", `${progress.toolCount} tools`)}`;
-		}
-		if (progress.tokens > 0) {
-			statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatNumber(progress.tokens)} tokens`)}`;
-		}
+		statusLine = appendAgentStats(statusLine, progress, theme);
 	}
 
 	lines.push(statusLine);
@@ -661,8 +669,10 @@ function renderReviewResult(
 				lines.push(`${continuePrefix}  ${theme.fg("dim", replaceTabs(line))}`);
 			}
 		} else {
-			// Preview: first sentence or ~100 chars
-			const preview = truncateToWidth(`${summary.explanation.split(/[.!?]/)[0]}.`, 100);
+			// Preview: first sentence or ~100 chars (flatten tabs/newlines first)
+			const flat = replaceTabs(summary.explanation).replace(/[\r\n]+/g, " ");
+			const firstSentence = flat.split(/[.!?]/)[0].trim();
+			const preview = truncateToWidth(`${firstSentence}.`, 100);
 			lines.push(`${continuePrefix}${theme.fg("dim", preview)}`);
 		}
 	}
@@ -701,7 +711,8 @@ function renderFindings(
 		const findingContinue = isLastFinding ? "   " : `${theme.tree.vertical}  `;
 
 		const { color } = getPriorityInfo(finding.priority);
-		const titleText = finding.title?.replace(/^\[P\d\]\s*/, "") ?? "Untitled";
+		const rawTitle = finding.title?.replace(/^\[P\d\]\s*/, "") ?? "Untitled";
+		const titleText = replaceTabs(rawTitle).replace(/[\r\n]+/g, " ");
 		const loc = `${path.basename(finding.file_path || "<unknown>")}:${finding.line_start}`;
 
 		lines.push(
@@ -765,9 +776,7 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 		iconColor,
 		theme,
 	)}`;
-	if (result.tokens > 0) {
-		statusLine += `${theme.sep.dot}${theme.fg("dim", `${formatNumber(result.tokens)} tokens`)}`;
-	}
+	statusLine = appendAgentStats(statusLine, { tokens: result.tokens, cost: result.usage?.cost.total ?? 0 }, theme);
 	statusLine += `${theme.sep.dot}${theme.fg("dim", formatDuration(result.durationMs))}`;
 
 	if (result.truncated) {

package/src/task/types.ts

@@ -217,7 +217,10 @@ export interface AgentProgress {
 	recentTools: Array<{ tool: string; args: string; endMs: number }>;
 	recentOutput: string[];
 	toolCount: number;
+	/** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
 	tokens: number;
+	/** Cumulative billing cost in USD, accumulated incrementally from message_end events. */
+	cost: number;
 	durationMs: number;
 	modelOverride?: string | string[];
 	/** Data extracted by registered subprocess tool handlers (keyed by tool name) */
@@ -239,6 +242,7 @@ export interface SingleResult {
 	stderr: string;
 	truncated: boolean;
 	durationMs: number;
+	/** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
 	tokens: number;
 	modelOverride?: string | string[];
 	error?: string;

package/src/tools/ast-edit.ts

@@ -7,33 +7,27 @@ import { $envpos, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { computeLineHash, HL_BODY_SEP } from "../hashline/hash";
-import { InternalUrlRouter } from "../internal-urls";
 import type { Theme } from "../modes/theme/theme";
 import astEditDescription from "../prompts/tools/ast-edit.md" with { type: "text" };
-import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
+import { Ellipsis, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
 import { createFileRecorder, formatResultPath } from "./file-recorder";
 import { formatGroupedFiles } from "./grouped-file-output";
 import type { OutputMeta } from "./output-meta";
+import { resolveToolSearchScope } from "./path-utils";
 import {
-	formatPathRelativeToCwd,
-	hasGlobPathChars,
-	normalizePathLikeInput,
-	parseSearchPath,
-	partitionExistingPaths,
-	resolveExplicitSearchPaths,
-	resolveToCwd,
-} from "./path-utils";
-import {
+	appendParseErrorsBulletList,
+	createCachedComponent,
 	dedupeParseErrors,
 	formatCodeFrameLine,
 	formatCount,
 	formatEmptyMessage,
 	formatErrorMessage,
 	formatParseErrors,
-	PARSE_ERRORS_LIMIT,
+	formatParseErrorsCountLabel,
 	PREVIEW_LIMITS,
+	splitGroupsByBlankLine,
 } from "./render-utils";
 import { queueResolveHandler } from "./resolve";
 import { ToolError } from "./tool-errors";
@@ -205,63 +199,12 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			const normalizedRewrites = Object.fromEntries(ops);
 			const maxFiles = $envpos("PI_MAX_AST_FILES", 1000);
 
-			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
-			let searchPath: string;
-			let scopePath: string;
-			let globFilter: string | undefined;
-			let multiTargets: Array<{ basePath: string; glob?: string }> | undefined;
-			const rawPaths = params.paths.map(normalizePathLikeInput);
-			if (rawPaths.some(rawPath => rawPath.length === 0)) {
-				throw new ToolError("`paths` must contain non-empty paths or globs");
-			}
-			const internalRouter = InternalUrlRouter.instance();
-			const resolvedPathInputs: string[] = [];
-			for (const rawPath of rawPaths) {
-				if (!internalRouter.canHandle(rawPath)) {
-					resolvedPathInputs.push(rawPath);
-					continue;
-				}
-				if (hasGlobPathChars(rawPath)) {
-					throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPath}`);
-				}
-				const resource = await internalRouter.resolve(rawPath);
-				if (!resource.sourcePath) {
-					throw new ToolError(`Cannot rewrite internal URL without backing file: ${rawPath}`);
-				}
-				resolvedPathInputs.push(resource.sourcePath);
-			}
-			let effectivePathInputs = resolvedPathInputs;
-			if (resolvedPathInputs.length > 1) {
-				const partition = await partitionExistingPaths(resolvedPathInputs, this.session.cwd, parseSearchPath);
-				if (partition.valid.length === 0) {
-					throw new ToolError(`Path not found: ${partition.missing.join(", ")}`);
-				}
-				effectivePathInputs = partition.valid;
-			}
-			if (effectivePathInputs.length === 1) {
-				const parsedPath = parseSearchPath(effectivePathInputs[0] ?? ".");
-				searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
-				globFilter = parsedPath.glob;
-				scopePath = formatScopePath(searchPath);
-			} else {
-				const multiSearchPath = await resolveExplicitSearchPaths(effectivePathInputs, this.session.cwd, globFilter);
-				if (!multiSearchPath) {
-					throw new ToolError("`paths` must contain at least one path or glob");
-				}
-				searchPath = multiSearchPath.basePath;
-				globFilter = multiSearchPath.targets ? undefined : multiSearchPath.glob;
-				multiTargets = multiSearchPath.targets;
-				scopePath = multiSearchPath.scopePath;
-			}
-			const resolvedSearchPath = searchPath;
-			scopePath = scopePath ?? formatScopePath(resolvedSearchPath);
-			let isDirectory: boolean;
-			try {
-				const stat = await Bun.file(resolvedSearchPath).stat();
-				isDirectory = stat.isDirectory();
-			} catch {
-				throw new ToolError(`Path not found: ${scopePath}`);
-			}
+			const scope = await resolveToolSearchScope({
+				rawPaths: params.paths,
+				cwd: this.session.cwd,
+				internalUrlAction: "rewrite",
+			});
+			const { searchPath: resolvedSearchPath, scopePath, isDirectory, multiTargets, globFilter } = scope;
 
 			const result = await runAstEditOnce(multiTargets, resolvedSearchPath, globFilter, {
 				rewrites: normalizedRewrites,
@@ -502,15 +445,7 @@ export const astEditToolRenderer = {
 			if (filesSearched > 0) meta.push(`searched ${filesSearched}`);
 			const header = renderStatusLine({ icon: "warning", title: "AST Edit", description, meta }, uiTheme);
 			const lines = [header, formatEmptyMessage("No replacements made", uiTheme)];
-			if (details?.parseErrors?.length) {
-				const capped = details.parseErrors.slice(0, PARSE_ERRORS_LIMIT);
-				for (const err of capped) {
-					lines.push(uiTheme.fg("warning", `  - ${err}`));
-				}
-				if (details.parseErrors.length > PARSE_ERRORS_LIMIT) {
-					lines.push(uiTheme.fg("dim", `  … ${details.parseErrors.length - PARSE_ERRORS_LIMIT} more`));
-				}
-			}
+			appendParseErrorsBulletList(lines, details?.parseErrors, uiTheme);
 			return new Text(lines.join("\n"), 0, 0);
 		}
 
@@ -523,28 +458,7 @@ export const astEditToolRenderer = {
 		const description = rewriteCount === 1 ? args?.ops?.[0]?.pat : undefined;
 
 		const textContent = result.details?.displayContent ?? result.content?.find(c => c.type === "text")?.text ?? "";
-		const rawLines = textContent.split("\n");
-		const hasSeparators = rawLines.some(line => line.trim().length === 0);
-		const allGroups: string[][] = [];
-		if (hasSeparators) {
-			let current: string[] = [];
-			for (const line of rawLines) {
-				if (line.trim().length === 0) {
-					if (current.length > 0) {
-						allGroups.push(current);
-						current = [];
-					}
-					continue;
-				}
-				current.push(line);
-			}
-			if (current.length > 0) allGroups.push(current);
-		} else {
-			const nonEmpty = rawLines.filter(line => line.trim().length > 0);
-			if (nonEmpty.length > 0) {
-				allGroups.push(nonEmpty);
-			}
-		}
+		const allGroups = splitGroupsByBlankLine(textContent.split("\n"));
 		const changeGroups = allGroups.filter(
 			group => !group[0]?.startsWith("Safety cap reached") && !group[0]?.startsWith("Parse issues:"),
 		);
@@ -560,23 +474,15 @@ export const astEditToolRenderer = {
 			extraLines.push(uiTheme.fg("warning", "limit reached; narrow path"));
 		}
 		if (details?.parseErrors?.length) {
-			const total = details.parseErrors.length;
-			const label =
-				total > PARSE_ERRORS_LIMIT
-					? `${PARSE_ERRORS_LIMIT} / ${total} parse issues`
-					: `${total} parse issue${total !== 1 ? "s" : ""}`;
-			extraLines.push(uiTheme.fg("warning", label));
+			extraLines.push(uiTheme.fg("warning", formatParseErrorsCountLabel(details.parseErrors)));
 		}
-		let cached: RenderCache | undefined;
-		return {
-			render(width: number): string[] {
-				const { expanded } = options;
-				const key = new Hasher().bool(expanded).u32(width).digest();
-				if (cached?.key === key) return cached.lines;
+		return createCachedComponent(
+			() => options.expanded,
+			width => {
 				const changeLines = renderTreeList(
 					{
 						items: changeGroups,
-						expanded,
+						expanded: options.expanded,
 						maxCollapsed: changeGroups.length,
 						maxCollapsedLines: COLLAPSED_CHANGE_LIMIT,
 						itemType: "change",
@@ -591,14 +497,9 @@ export const astEditToolRenderer = {
 					},
 					uiTheme,
 				);
-				const rendered = [header, ...changeLines, ...extraLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
-				cached = { key, lines: rendered };
-				return rendered;
+				return [header, ...changeLines, ...extraLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
 			},
-			invalidate() {
-				cached = undefined;
-			},
-		};
+		);
 	},
 	mergeCallAndResult: true,
 };