@oh-my-pi/pi-coding-agent 3.20.1 → 3.21.0

package/src/core/tools/ls.ts

@@ -1,10 +1,24 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import nodePath from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
+import type { RenderResultOptions } from "../custom-tools/types";
 import { untilAborted } from "../utils";
 import { resolveToCwd } from "./path-utils";
-import { formatAge } from "./render-utils";
+import {
+	formatAge,
+	formatBytes,
+	formatCount,
+	formatEmptyMessage,
+	formatExpandHint,
+	formatMeta,
+	formatMoreItems,
+	formatTruncationSuffix,
+	PREVIEW_LIMITS,
+} from "./render-utils";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate";
 
 const lsSchema = Type.Object({
@@ -147,3 +161,122 @@ export function createLsTool(cwd: string): AgentTool<typeof lsSchema> {
 
 /** Default ls tool using process.cwd() - for backwards compatibility */
 export const lsTool = createLsTool(process.cwd());
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface LsRenderArgs {
+	path?: string;
+	limit?: number;
+}
+
+const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
+
+export const lsToolRenderer = {
+	renderCall(args: LsRenderArgs, uiTheme: Theme): Component {
+		const label = uiTheme.fg("toolTitle", uiTheme.bold("Ls"));
+		let text = `${label} ${uiTheme.fg("accent", args.path || ".")}`;
+
+		const meta: string[] = [];
+		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
+		text += formatMeta(meta, uiTheme);
+
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: LsToolDetails },
+		{ expanded }: RenderResultOptions,
+		uiTheme: Theme,
+	): Component {
+		const details = result.details;
+		const textContent = result.content?.find((c) => c.type === "text")?.text ?? "";
+
+		if (
+			(!textContent || textContent.trim() === "" || textContent.trim() === "(empty directory)") &&
+			(!details?.entries || details.entries.length === 0)
+		) {
+			return new Text(formatEmptyMessage("Empty directory", uiTheme), 0, 0);
+		}
+
+		let entries: string[] = details?.entries ? [...details.entries] : [];
+		if (entries.length === 0) {
+			const rawLines = textContent.split("\n").filter((l: string) => l.trim());
+			entries = rawLines.filter((line) => !/^\[.*\]$/.test(line.trim()));
+		}
+
+		if (entries.length === 0) {
+			return new Text(formatEmptyMessage("Empty directory", uiTheme), 0, 0);
+		}
+
+		let dirCount = details?.dirCount;
+		let fileCount = details?.fileCount;
+		if (dirCount === undefined || fileCount === undefined) {
+			dirCount = 0;
+			fileCount = 0;
+			for (const entry of entries) {
+				if (entry.endsWith("/")) {
+					dirCount += 1;
+				} else {
+					fileCount += 1;
+				}
+			}
+		}
+
+		const truncated = Boolean(details?.truncation?.truncated || details?.entryLimitReached);
+		const icon = truncated
+			? uiTheme.styledSymbol("status.warning", "warning")
+			: uiTheme.styledSymbol("status.success", "success");
+
+		const summaryText = [formatCount("dir", dirCount ?? 0), formatCount("file", fileCount ?? 0)].join(
+			uiTheme.sep.dot,
+		);
+		const maxEntries = expanded ? entries.length : Math.min(entries.length, COLLAPSED_LIST_LIMIT);
+		const hasMoreEntries = entries.length > maxEntries;
+		const expandHint = formatExpandHint(expanded, hasMoreEntries, uiTheme);
+
+		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(truncated, uiTheme)}${expandHint}`;
+
+		const truncationReasons: string[] = [];
+		if (details?.entryLimitReached) {
+			truncationReasons.push(`entry limit ${details.entryLimitReached}`);
+		}
+		if (details?.truncation?.truncated) {
+			truncationReasons.push(`output cap ${formatBytes(details.truncation.maxBytes)}`);
+		}
+
+		const hasTruncation = truncationReasons.length > 0;
+
+		for (let i = 0; i < maxEntries; i++) {
+			const entry = entries[i];
+			const isLast = i === maxEntries - 1 && !hasMoreEntries && !hasTruncation;
+			const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+			const isDir = entry.endsWith("/");
+			const entryPath = isDir ? entry.slice(0, -1) : entry;
+			const lang = isDir ? undefined : getLanguageFromPath(entryPath);
+			const entryIcon = isDir
+				? uiTheme.fg("accent", uiTheme.icon.folder)
+				: uiTheme.fg("muted", uiTheme.getLangIcon(lang));
+			const entryColor = isDir ? "accent" : "toolOutput";
+			text += `\n ${uiTheme.fg("dim", branch)} ${entryIcon} ${uiTheme.fg(entryColor, entry)}`;
+		}
+
+		if (hasMoreEntries) {
+			const moreEntriesBranch = hasTruncation ? uiTheme.tree.branch : uiTheme.tree.last;
+			text += `\n ${uiTheme.fg("dim", moreEntriesBranch)} ${uiTheme.fg(
+				"muted",
+				formatMoreItems(entries.length - maxEntries, "entry", uiTheme),
+			)}`;
+		}
+
+		if (hasTruncation) {
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+				"warning",
+				`truncated: ${truncationReasons.join(", ")}`,
+			)}`;
+		}
+
+		return new Text(text, 0, 0);
+	},
+};

package/src/core/tools/lsp/render.ts

@@ -242,7 +242,10 @@ function renderDiagnostics(
 				`[${item.severity}]`,
 			)}`;
 			if (item.message) {
-				output += `\n ${theme.fg("dim", detailPrefix)}${theme.fg("muted", truncate(item.message, TRUNCATE_LENGTHS.LINE, theme.format.ellipsis))}`;
+				output += `\n ${theme.fg("dim", detailPrefix)}${theme.fg(
+					"muted",
+					truncate(item.message, TRUNCATE_LENGTHS.LINE, theme.format.ellipsis),
+				)}`;
 			}
 		}
 		return new Text(output, 0, 0);
@@ -271,7 +274,10 @@ function renderDiagnostics(
 		output += `\n ${theme.fg("dim", branch)} ${theme.fg(severityColor, location)}${message}`;
 	}
 	if (remaining > 0) {
-		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", `${theme.format.ellipsis} ${remaining} more`)}`;
+		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
+			"muted",
+			`${theme.format.ellipsis} ${remaining} more`,
+		)}`;
 	}
 
 	return new Text(output, 0, 0);
@@ -436,10 +442,7 @@ function renderSymbols(symbolsMatch: RegExpMatchArray, lines: string[], expanded
 			const isLast = isLastSibling(i);
 			const branch = isLast ? theme.tree.last : theme.tree.branch;
 			const detailPrefix = isLast ? "   " : `${theme.tree.vertical}  `;
-			output += `\n${prefix}${theme.fg("dim", branch)} ${theme.fg("accent", sym.icon)} ${theme.fg(
-				"accent",
-				sym.name,
-			)}`;
+			output += `\n${prefix}${theme.fg("dim", branch)} ${theme.fg("accent", sym.icon)} ${theme.fg("accent", sym.name)}`;
 			output += `\n${prefix}${theme.fg("dim", detailPrefix)}${theme.fg("muted", `line ${sym.line}`)}`;
 		}
 		return new Text(output, 0, 0);
@@ -454,13 +457,16 @@ function renderSymbols(symbolsMatch: RegExpMatchArray, lines: string[], expanded
 		const sym = topLevel[i];
 		const isLast = i === topLevel.length - 1 && topLevelCount <= 3;
 		const branch = isLast ? theme.tree.last : theme.tree.branch;
-		output += `\n ${theme.fg("dim", branch)} ${theme.fg("accent", sym.icon)} ${theme.fg(
-			"accent",
-			sym.name,
-		)} ${theme.fg("muted", `line ${sym.line}`)}`;
+		output += `\n ${theme.fg("dim", branch)} ${theme.fg("accent", sym.icon)} ${theme.fg("accent", sym.name)} ${theme.fg(
+			"muted",
+			`line ${sym.line}`,
+		)}`;
 	}
 	if (topLevelCount > 3) {
-		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", `${theme.format.ellipsis} ${topLevelCount - 3} more`)}`;
+		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
+			"muted",
+			`${theme.format.ellipsis} ${topLevelCount - 3} more`,
+		)}`;
 	}
 
 	return new Text(output, 0, 0);
@@ -496,17 +502,26 @@ function renderGeneric(text: string, lines: string[], expanded: boolean, theme:
 
 	const firstLine = lines[0] || "No output";
 	const expandHint = formatExpandHint(false, lines.length > 1, theme);
-	let output = `${icon} ${theme.fg("dim", truncate(firstLine, TRUNCATE_LENGTHS.TITLE, theme.format.ellipsis))}${expandHint}`;
+	let output = `${icon} ${theme.fg(
+		"dim",
+		truncate(firstLine, TRUNCATE_LENGTHS.TITLE, theme.format.ellipsis),
+	)}${expandHint}`;
 
 	if (lines.length > 1) {
 		const previewLines = lines.slice(1, 4);
 		for (let i = 0; i < previewLines.length; i++) {
 			const isLast = i === previewLines.length - 1 && lines.length <= 4;
 			const branch = isLast ? theme.tree.last : theme.tree.branch;
-			output += `\n ${theme.fg("dim", branch)} ${theme.fg("dim", truncate(previewLines[i].trim(), TRUNCATE_LENGTHS.CONTENT, theme.format.ellipsis))}`;
+			output += `\n ${theme.fg("dim", branch)} ${theme.fg(
+				"dim",
+				truncate(previewLines[i].trim(), TRUNCATE_LENGTHS.CONTENT, theme.format.ellipsis),
+			)}`;
 		}
 		if (lines.length > 4) {
-			output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", formatMoreItems(lines.length - 4, "line", theme))}`;
+			output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
+				"muted",
+				formatMoreItems(lines.length - 4, "line", theme),
+			)}`;
 		}
 	}
 
@@ -550,3 +565,8 @@ function severityToColor(severity: string): "error" | "warning" | "accent" | "di
 			return "dim";
 	}
 }
+
+export const lspToolRenderer = {
+	renderCall,
+	renderResult,
+};

package/src/core/tools/notebook.ts

@@ -1,7 +1,19 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
+import type { Theme } from "../../modes/interactive/theme/theme";
+import type { RenderResultOptions } from "../custom-tools/types";
 import { untilAborted } from "../utils";
 import { resolveToCwd } from "./path-utils";
+import {
+	formatCount,
+	formatErrorMessage,
+	formatExpandHint,
+	formatMeta,
+	formatMoreItems,
+	PREVIEW_LIMITS,
+} from "./render-utils";
 
 const notebookSchema = Type.Object({
 	action: Type.Union([Type.Literal("edit"), Type.Literal("insert"), Type.Literal("delete")], {
@@ -180,3 +192,101 @@ export function createNotebookTool(cwd: string): AgentTool<typeof notebookSchema
 
 /** Default notebook tool using process.cwd() */
 export const notebookTool = createNotebookTool(process.cwd());
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface NotebookRenderArgs {
+	action: string;
+	notebookPath: string;
+	cellNumber?: number;
+	cellType?: string;
+	content?: string;
+}
+
+const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
+
+function normalizeCellLines(lines: string[]): string[] {
+	return lines.map((line) => (line.endsWith("\n") ? line.slice(0, -1) : line));
+}
+
+function renderCellPreview(lines: string[], expanded: boolean, uiTheme: Theme): string {
+	const normalized = normalizeCellLines(lines);
+	if (normalized.length === 0) {
+		return `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", "(empty cell)")}`;
+	}
+
+	const maxLines = expanded ? normalized.length : Math.min(normalized.length, COLLAPSED_TEXT_LIMIT);
+	let text = "";
+
+	for (let i = 0; i < maxLines; i++) {
+		const isLast = i === maxLines - 1 && (expanded || normalized.length <= maxLines);
+		const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+		const line = normalized[i];
+		text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("toolOutput", line)}`;
+	}
+
+	const remaining = normalized.length - maxLines;
+	if (remaining > 0) {
+		text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+			"muted",
+			formatMoreItems(remaining, "line", uiTheme),
+		)}`;
+	}
+
+	return text;
+}
+
+export const notebookToolRenderer = {
+	renderCall(args: NotebookRenderArgs, uiTheme: Theme): Component {
+		const label = uiTheme.fg("toolTitle", uiTheme.bold("Notebook"));
+		let text = `${label} ${uiTheme.fg("accent", args.action || "?")}`;
+
+		const meta: string[] = [];
+		meta.push(`in ${args.notebookPath || "?"}`);
+		if (args.cellNumber !== undefined) meta.push(`cell:${args.cellNumber}`);
+		if (args.cellType) meta.push(`type:${args.cellType}`);
+
+		text += formatMeta(meta, uiTheme);
+
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: NotebookToolDetails },
+		{ expanded }: RenderResultOptions,
+		uiTheme: Theme,
+	): Component {
+		const content = result.content?.[0];
+		if (content?.type === "text" && content.text?.startsWith("Error:")) {
+			return new Text(formatErrorMessage(content.text, uiTheme), 0, 0);
+		}
+
+		const details = result.details;
+		const action = details?.action ?? "edit";
+		const cellIndex = details?.cellIndex;
+		const cellType = details?.cellType;
+		const totalCells = details?.totalCells;
+		const cellSource = details?.cellSource;
+		const lineCount = cellSource?.length;
+		const canExpand = cellSource !== undefined && cellSource.length > COLLAPSED_TEXT_LIMIT;
+
+		const icon = uiTheme.styledSymbol("status.success", "success");
+		const actionLabel = action === "insert" ? "Inserted" : action === "delete" ? "Deleted" : "Edited";
+		const cellLabel = cellType || "cell";
+		const summaryParts = [`${actionLabel} ${cellLabel} at index ${cellIndex ?? "?"}`];
+		if (lineCount !== undefined) summaryParts.push(formatCount("line", lineCount));
+		if (totalCells !== undefined) summaryParts.push(`${totalCells} total`);
+		const summaryText = summaryParts.join(uiTheme.sep.dot);
+
+		const expandHint = formatExpandHint(expanded, canExpand, uiTheme);
+		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${expandHint}`;
+
+		if (cellSource) {
+			text += renderCellPreview(cellSource, expanded, uiTheme);
+		}
+
+		return new Text(text, 0, 0);
+	},
+};

package/src/core/tools/output.ts

@@ -6,11 +6,24 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
+import type { TextContent } from "@mariozechner/pi-ai";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { TextContent } from "@oh-my-pi/pi-ai";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
+import type { Theme } from "../../modes/interactive/theme/theme";
 import outputDescription from "../../prompts/tools/output.md" with { type: "text" };
+import type { RenderResultOptions } from "../custom-tools/types";
 import type { SessionContext } from "./index";
+import {
+	formatCount,
+	formatEmptyMessage,
+	formatExpandHint,
+	formatMeta,
+	formatMoreItems,
+	TRUNCATE_LENGTHS,
+	truncate,
+} from "./render-utils";
 import { getArtifactsDir } from "./task/artifacts";
 
 const outputSchema = Type.Object({
@@ -23,6 +36,18 @@ const outputSchema = Type.Object({
 			description: "Output format: raw (default), json (structured), stripped (no ANSI)",
 		}),
 	),
+	offset: Type.Optional(
+		Type.Number({
+			description: "Line number to start reading from (1-indexed)",
+			minimum: 1,
+		}),
+	),
+	limit: Type.Optional(
+		Type.Number({
+			description: "Maximum number of lines to read",
+			minimum: 1,
+		}),
+	),
 });
 
 /** Metadata for a single output file */
@@ -31,6 +56,12 @@ interface OutputProvenance {
 	index: number;
 }
 
+interface OutputRange {
+	startLine: number;
+	endLine: number;
+	totalLines: number;
+}
+
 interface OutputEntry {
 	id: string;
 	path: string;
@@ -38,6 +69,7 @@ interface OutputEntry {
 	charCount: number;
 	provenance?: OutputProvenance;
 	previewLines?: string[];
+	range?: OutputRange;
 }
 
 export interface OutputToolDetails {
@@ -99,7 +131,7 @@ export function createOutputTool(
 		parameters: outputSchema,
 		execute: async (
 			_toolCallId: string,
-			params: { ids: string[]; format?: "raw" | "json" | "stripped" },
+			params: { ids: string[]; format?: "raw" | "json" | "stripped"; offset?: number; limit?: number },
 		): Promise<{ content: TextContent[]; details: OutputToolDetails }> => {
 			const sessionFile = sessionContext?.getSessionFile();
 
@@ -131,15 +163,37 @@ export function createOutputTool(
 					continue;
 				}
 
-				const content = fs.readFileSync(outputPath, "utf-8");
-				outputContentById.set(id, content);
+				const rawContent = fs.readFileSync(outputPath, "utf-8");
+				const rawLines = rawContent.split("\n");
+				const totalLines = rawLines.length;
+				const totalChars = rawContent.length;
+
+				let selectedContent = rawContent;
+				let range: OutputRange | undefined;
+
+				if (params.offset !== undefined || params.limit !== undefined) {
+					const startLine = Math.max(1, params.offset ?? 1);
+					if (startLine > totalLines) {
+						throw new Error(
+							`Offset ${params.offset ?? startLine} is beyond end of output (${totalLines} lines) for ${id}`,
+						);
+					}
+					const effectiveLimit = params.limit ?? totalLines - startLine + 1;
+					const endLine = Math.min(totalLines, startLine + effectiveLimit - 1);
+					const selectedLines = rawLines.slice(startLine - 1, endLine);
+					selectedContent = selectedLines.join("\n");
+					range = { startLine, endLine, totalLines };
+				}
+
+				outputContentById.set(id, selectedContent);
 				outputs.push({
 					id,
 					path: outputPath,
-					lineCount: content.split("\n").length,
-					charCount: content.length,
+					lineCount: totalLines,
+					charCount: totalChars,
 					provenance: parseOutputProvenance(id),
-					previewLines: extractPreviewLines(content, 4),
+					previewLines: extractPreviewLines(selectedContent, 4),
+					range,
 				});
 			}
 
@@ -167,6 +221,7 @@ export function createOutputTool(
 					charCount: o.charCount,
 					provenance: o.provenance,
 					previewLines: o.previewLines,
+					range: o.range,
 					content: outputContentById.get(o.id) ?? "",
 				}));
 				contentText = JSON.stringify(jsonData, null, 2);
@@ -177,6 +232,10 @@ export function createOutputTool(
 					if (format === "stripped") {
 						content = stripAnsi(content);
 					}
+					if (o.range && o.range.endLine < o.range.totalLines) {
+						const nextOffset = o.range.endLine + 1;
+						content += `\n\n[Showing lines ${o.range.startLine}-${o.range.endLine} of ${o.range.totalLines}. Use offset=${nextOffset} to continue]`;
+					}
 					// Add header for multiple outputs
 					if (outputs.length > 1) {
 						return `=== ${o.id} (${o.lineCount} lines, ${formatBytes(o.charCount)}) ===\n${content}`;
@@ -196,3 +255,116 @@ export function createOutputTool(
 
 /** Default output tool using process.cwd() - for backwards compatibility */
 export const outputTool = createOutputTool(process.cwd());
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface OutputRenderArgs {
+	ids: string[];
+	format?: "raw" | "json" | "stripped";
+	offset?: number;
+	limit?: number;
+}
+
+type OutputEntryItem = OutputToolDetails["outputs"][number];
+
+function formatOutputMeta(entry: OutputEntryItem, uiTheme: Theme): string {
+	const metaParts: string[] = [];
+	if (entry.range) {
+		metaParts.push(`lines ${entry.range.startLine}-${entry.range.endLine} of ${entry.range.totalLines}`);
+	} else {
+		metaParts.push(formatCount("line", entry.lineCount));
+	}
+	metaParts.push(formatBytes(entry.charCount));
+	if (entry.provenance) {
+		metaParts.push(`agent ${entry.provenance.agent}(${entry.provenance.index})`);
+	}
+	return uiTheme.fg("dim", metaParts.join(uiTheme.sep.dot));
+}
+
+export const outputToolRenderer = {
+	renderCall(args: OutputRenderArgs, uiTheme: Theme): Component {
+		const ids = args.ids?.join(", ") ?? "?";
+		const label = uiTheme.fg("toolTitle", uiTheme.bold("Output"));
+		let text = `${label} ${uiTheme.fg("accent", ids)}`;
+
+		const meta: string[] = [];
+		if (args.format && args.format !== "raw") meta.push(`format:${args.format}`);
+		if (args.offset !== undefined) meta.push(`offset:${args.offset}`);
+		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
+		text += formatMeta(meta, uiTheme);
+
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: OutputToolDetails },
+		{ expanded }: RenderResultOptions,
+		uiTheme: Theme,
+	): Component {
+		const details = result.details;
+
+		if (details?.notFound?.length) {
+			const icon = uiTheme.styledSymbol("status.error", "error");
+			let text = `${icon} ${uiTheme.fg("error", `Error: Not found: ${details.notFound.join(", ")}`)}`;
+			if (details.availableIds?.length) {
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+					"muted",
+					`Available: ${details.availableIds.join(", ")}`,
+				)}`;
+			} else {
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+					"muted",
+					"No outputs available in current session",
+				)}`;
+			}
+			return new Text(text, 0, 0);
+		}
+
+		const outputs = details?.outputs ?? [];
+
+		if (outputs.length === 0) {
+			const textContent = result.content?.find((c) => c.type === "text")?.text;
+			return new Text(formatEmptyMessage(textContent || "No outputs", uiTheme), 0, 0);
+		}
+
+		const icon = uiTheme.styledSymbol("status.success", "success");
+		const summary = `read ${formatCount("output", outputs.length)}`;
+		const previewLimit = expanded ? 3 : 1;
+		const maxOutputs = expanded ? outputs.length : Math.min(outputs.length, 5);
+		const hasMoreOutputs = outputs.length > maxOutputs;
+		const hasMorePreview = outputs.some((o) => (o.previewLines?.length ?? 0) > previewLimit);
+		const expandHint = formatExpandHint(expanded, hasMoreOutputs || hasMorePreview, uiTheme);
+		let text = `${icon} ${uiTheme.fg("dim", summary)}${expandHint}`;
+
+		for (let i = 0; i < maxOutputs; i++) {
+			const o = outputs[i];
+			const isLast = i === maxOutputs - 1 && !hasMoreOutputs;
+			const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+			text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("accent", o.id)} ${formatOutputMeta(o, uiTheme)}`;
+
+			const previewLines = o.previewLines ?? [];
+			const shownPreview = previewLines.slice(0, previewLimit);
+			if (shownPreview.length > 0) {
+				const childPrefix = isLast ? "   " : ` ${uiTheme.fg("dim", uiTheme.tree.vertical)} `;
+				for (const line of shownPreview) {
+					const previewText = truncate(line, TRUNCATE_LENGTHS.CONTENT, uiTheme.format.ellipsis);
+					text += `\n${childPrefix}${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg(
+						"muted",
+						"preview:",
+					)} ${uiTheme.fg("toolOutput", previewText)}`;
+				}
+			}
+		}
+
+		if (hasMoreOutputs) {
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+				"muted",
+				formatMoreItems(outputs.length - maxOutputs, "output", uiTheme),
+			)}`;
+		}
+
+		return new Text(text, 0, 0);
+	},
+};