@oh-my-pi/pi-coding-agent 6.9.0 → 7.0.0

package/src/core/tools/python.ts

@@ -2,10 +2,10 @@ import { relative, resolve, sep } from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { Text, truncateToWidth } from "@oh-my-pi/pi-tui";
+import { Text, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import { type Static, Type } from "@sinclair/typebox";
 import { truncateToVisualLines } from "../../modes/interactive/components/visual-truncate";
-import type { Theme } from "../../modes/interactive/theme/theme";
+import { highlightCode, type Theme } from "../../modes/interactive/theme/theme";
 import pythonDescription from "../../prompts/tools/python.md" with { type: "text" };
 import type { RenderResultOptions } from "../custom-tools/types";
 import { renderPromptTemplate } from "../prompt-templates";
@@ -39,15 +39,26 @@ function groupPreludeHelpers(helpers: PreludeHelper[]): PreludeCategory[] {
 }
 
 export const pythonSchema = Type.Object({
-	code: Type.String({ description: "Python code to execute" }),
-	timeoutMs: Type.Optional(Type.Number({ description: "Timeout in milliseconds (default: 30000)" })),
-	workdir: Type.Optional(
-		Type.String({ description: "Working directory for the command (default: current directory)" }),
+	cells: Type.Array(
+		Type.Object({
+			code: Type.String({
+				description:
+					"Python code for this cell. Keep it focused (imports, helper, test, use). No narrative text—put explanations in the assistant message or in the cell title.",
+			}),
+			title: Type.Optional(
+				Type.String({ description: "Short label for the cell (e.g., 'imports', 'parse helper')." }),
+			),
+		}),
+		{
+			description:
+				"Python cells to execute sequentially. Each cell runs in the same kernel—imports and variables persist. Keep cells small: one logical step each (import, define, test, use). If a cell fails, fix only that cell; earlier cells' state remains.",
+		},
 	),
+	timeoutMs: Type.Optional(Type.Number({ description: "Timeout in milliseconds (default: 30000)" })),
+	cwd: Type.Optional(Type.String({ description: "Working directory for the command (default: current directory)" })),
 	reset: Type.Optional(Type.Boolean({ description: "Restart the kernel before executing this code" })),
 });
-
-export type PythonToolParams = { code: string; timeout?: number; workdir?: string; reset?: boolean };
+export type PythonToolParams = Static<typeof pythonSchema>;
 
 export type PythonToolResult = {
 	content: Array<{ type: "text"; text: string }>;
@@ -56,7 +67,19 @@ export type PythonToolResult = {
 
 export type PythonProxyExecutor = (params: PythonToolParams, signal?: AbortSignal) => Promise<PythonToolResult>;
 
+export interface PythonCellResult {
+	index: number;
+	title?: string;
+	code: string;
+	output: string;
+	status: "pending" | "running" | "complete" | "error";
+	durationMs?: number;
+	exitCode?: number;
+	statusEvents?: PythonStatusEvent[];
+}
+
 export interface PythonToolDetails {
+	cells?: PythonCellResult[];
 	truncation?: TruncationResult;
 	fullOutputPath?: string;
 	fullOutput?: string;
@@ -151,7 +174,7 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 			throw new Error("Python tool requires a session when not using proxy executor");
 		}
 
-		const { code, timeoutMs = 30000, workdir, reset } = params;
+		const { cells, timeoutMs = 30000, cwd, reset } = params;
 		const controller = new AbortController();
 		const onAbort = () => controller.abort();
 		signal?.addEventListener("abort", onAbort, { once: true });
@@ -161,7 +184,7 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 				throw new Error("Aborted");
 			}
 
-			const commandCwd = workdir ? resolveToCwd(workdir, this.session.cwd) : this.session.cwd;
+			const commandCwd = cwd ? resolveToCwd(cwd, this.session.cwd) : this.session.cwd;
 			let cwdStat: Awaited<ReturnType<Bun.BunFile["stat"]>>;
 			try {
 				cwdStat = await Bun.file(commandCwd).stat();
@@ -177,89 +200,185 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 			let tailBytes = 0;
 			const jsonOutputs: unknown[] = [];
 			const images: ImageContent[] = [];
+			const statusEvents: PythonStatusEvent[] = [];
+
+			const cellResults: PythonCellResult[] = cells.map((cell, index) => ({
+				index,
+				title: cell.title,
+				code: cell.code,
+				output: "",
+				status: "pending",
+			}));
+			const cellOutputs: string[] = [];
+			let lastFullOutputPath: string | undefined;
+
+			const appendTail = (text: string) => {
+				if (!text) return;
+				const chunkBytes = Buffer.byteLength(text, "utf-8");
+				tailChunks.push({ text, bytes: chunkBytes });
+				tailBytes += chunkBytes;
+				while (tailBytes > maxTailBytes && tailChunks.length > 1) {
+					const removed = tailChunks.shift();
+					if (removed) {
+						tailBytes -= removed.bytes;
+					}
+				}
+			};
+
+			const buildUpdateDetails = (truncation?: TruncationResult): PythonToolDetails => {
+				const details: PythonToolDetails = {
+					cells: cellResults.map((cell) => ({
+						...cell,
+						statusEvents: cell.statusEvents ? [...cell.statusEvents] : undefined,
+					})),
+				};
+				if (truncation) {
+					details.truncation = truncation;
+				}
+				if (lastFullOutputPath) {
+					details.fullOutputPath = lastFullOutputPath;
+				}
+				if (jsonOutputs.length > 0) {
+					details.jsonOutputs = jsonOutputs;
+				}
+				if (images.length > 0) {
+					details.images = images;
+				}
+				if (statusEvents.length > 0) {
+					details.statusEvents = statusEvents;
+				}
+				return details;
+			};
+
+			const pushUpdate = () => {
+				if (!onUpdate) return;
+				const tailText = tailChunks.map((entry) => entry.text).join("");
+				const truncation = truncateTail(tailText);
+				onUpdate({
+					content: [{ type: "text", text: truncation.content || "" }],
+					details: buildUpdateDetails(truncation.truncated ? truncation : undefined),
+				});
+			};
 
 			const sessionFile = this.session.getSessionFile?.() ?? undefined;
-			const sessionId = sessionFile ? `session:${sessionFile}:workdir:${commandCwd}` : `cwd:${commandCwd}`;
-			const executorOptions: PythonExecutorOptions = {
+			const sessionId = sessionFile ? `session:${sessionFile}:cwd:${commandCwd}` : `cwd:${commandCwd}`;
+			const baseExecutorOptions: Omit<PythonExecutorOptions, "reset"> = {
 				cwd: commandCwd,
 				timeoutMs,
 				signal: controller.signal,
 				sessionId,
 				kernelMode: this.session.settings?.getPythonKernelMode?.() ?? "session",
 				useSharedGateway: this.session.settings?.getPythonSharedGateway?.() ?? true,
-				reset,
-				onChunk: (chunk) => {
-					const chunkBytes = Buffer.byteLength(chunk, "utf-8");
-					tailChunks.push({ text: chunk, bytes: chunkBytes });
-					tailBytes += chunkBytes;
-					while (tailBytes > maxTailBytes && tailChunks.length > 1) {
-						const removed = tailChunks.shift();
-						if (removed) {
-							tailBytes -= removed.bytes;
-						}
+				sessionFile: sessionFile ?? undefined,
+			};
+
+			for (let i = 0; i < cells.length; i++) {
+				const cell = cells[i];
+				const isFirstCell = i === 0;
+				const cellResult = cellResults[i];
+				cellResult.status = "running";
+				cellResult.output = "";
+				cellResult.statusEvents = undefined;
+				cellResult.exitCode = undefined;
+				cellResult.durationMs = undefined;
+				pushUpdate();
+
+				const executorOptions: PythonExecutorOptions = {
+					...baseExecutorOptions,
+					reset: isFirstCell ? reset : false,
+				};
+
+				const startTime = Date.now();
+				const result = await executePython(cell.code, executorOptions);
+				const durationMs = Date.now() - startTime;
+
+				const cellStatusEvents: PythonStatusEvent[] = [];
+				for (const output of result.displayOutputs) {
+					if (output.type === "json") {
+						jsonOutputs.push(output.data);
 					}
-					if (onUpdate) {
-						const tailText = tailChunks.map((entry) => entry.text).join("");
-						const truncation = truncateTail(tailText);
-						onUpdate({
-							content: [{ type: "text", text: truncation.content || "" }],
-							details: truncation.truncated ? { truncation } : undefined,
-						});
+					if (output.type === "image") {
+						images.push({ type: "image", data: output.data, mimeType: output.mimeType });
 					}
-				},
-			};
+					if (output.type === "status") {
+						statusEvents.push(output.event);
+						cellStatusEvents.push(output.event);
+					}
+				}
 
-			const result = await executePython(code, executorOptions);
+				if (result.fullOutputPath) {
+					lastFullOutputPath = result.fullOutputPath;
+				}
 
-			const statusEvents: PythonStatusEvent[] = [];
-			for (const output of result.displayOutputs) {
-				if (output.type === "json") {
-					jsonOutputs.push(output.data);
+				const cellOutput = result.output.trim();
+				cellResult.output = cellOutput;
+				cellResult.exitCode = result.exitCode;
+				cellResult.durationMs = durationMs;
+				cellResult.statusEvents = cellStatusEvents.length > 0 ? cellStatusEvents : undefined;
+
+				let combinedCellOutput = "";
+				if (cells.length > 1) {
+					const cellHeader = `[${i + 1}/${cells.length}]`;
+					const cellTitle = cell.title ? ` ${cell.title}` : "";
+					if (cellOutput) {
+						combinedCellOutput = `${cellHeader}${cellTitle}\n${cellOutput}`;
+					} else {
+						combinedCellOutput = `${cellHeader}${cellTitle} (ok)`;
+					}
+					cellOutputs.push(combinedCellOutput);
+				} else if (cellOutput) {
+					combinedCellOutput = cellOutput;
+					cellOutputs.push(combinedCellOutput);
 				}
-				if (output.type === "image") {
-					images.push({ type: "image", data: output.data, mimeType: output.mimeType });
+
+				if (combinedCellOutput) {
+					const prefix = cellOutputs.length > 1 ? "\n\n" : "";
+					appendTail(`${prefix}${combinedCellOutput}`);
 				}
-				if (output.type === "status") {
-					statusEvents.push(output.event);
+
+				if (result.cancelled) {
+					cellResult.status = "error";
+					pushUpdate();
+					const errorMsg = result.output || "Command aborted";
+					throw new Error(cells.length > 1 ? `Cell ${i + 1} aborted: ${errorMsg}` : errorMsg);
+				}
+
+				if (result.exitCode !== 0 && result.exitCode !== undefined) {
+					cellResult.status = "error";
+					pushUpdate();
+					const combinedOutput = cellOutputs.join("\n\n");
+					throw new Error(
+						cells.length > 1
+							? `${combinedOutput}\n\nCell ${i + 1} failed (exit code ${result.exitCode}). Earlier cells succeeded—their state persists. Fix only cell ${i + 1}.`
+							: `${combinedOutput}\n\nCommand exited with code ${result.exitCode}`,
+					);
 				}
-			}
 
-			if (result.cancelled) {
-				throw new Error(result.output || "Command aborted");
+				cellResult.status = "complete";
+				pushUpdate();
 			}
 
-			const truncation = truncateTail(result.output);
+			const combinedOutput = cellOutputs.join("\n\n");
+			const truncation = truncateTail(combinedOutput);
 			let outputText =
 				truncation.content || (jsonOutputs.length > 0 || images.length > 0 ? "(no text output)" : "(no output)");
-			let details: PythonToolDetails | undefined;
+
+			const details: PythonToolDetails = {
+				cells: cellResults,
+				fullOutputPath: lastFullOutputPath,
+				jsonOutputs: jsonOutputs.length > 0 ? jsonOutputs : undefined,
+				images: images.length > 0 ? images : undefined,
+				statusEvents: statusEvents.length > 0 ? statusEvents : undefined,
+			};
 
 			if (truncation.truncated) {
-				details = {
-					truncation,
-					fullOutputPath: result.fullOutputPath,
-					jsonOutputs: jsonOutputs,
-					images,
-					statusEvents: statusEvents.length > 0 ? statusEvents : undefined,
-				};
+				details.truncation = truncation;
 				outputText += formatTailTruncationNotice(truncation, {
-					fullOutputPath: result.fullOutputPath,
-					originalContent: result.output,
+					fullOutputPath: lastFullOutputPath,
+					originalContent: combinedOutput,
 				});
 			}
 
-			if (!details && (jsonOutputs.length > 0 || images.length > 0 || statusEvents.length > 0)) {
-				details = {
-					jsonOutputs: jsonOutputs.length > 0 ? jsonOutputs : undefined,
-					images: images.length > 0 ? images : undefined,
-					statusEvents: statusEvents.length > 0 ? statusEvents : undefined,
-				};
-			}
-
-			if (result.exitCode !== 0 && result.exitCode !== undefined) {
-				outputText += `\n\nCommand exited with code ${result.exitCode}`;
-				throw new Error(outputText);
-			}
-
 			return { content: [{ type: "text", text: outputText }], details };
 		} finally {
 			signal?.removeEventListener("abort", onAbort);
@@ -268,9 +387,9 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 }
 
 interface PythonRenderArgs {
-	code?: string;
+	cells?: Array<{ code: string; title?: string }>;
 	timeout?: number;
-	workdir?: string;
+	cwd?: string;
 }
 
 interface PythonRenderContext {
@@ -600,13 +719,175 @@ function renderStatusEvents(events: PythonStatusEvent[], theme: Theme, expanded:
 	return lines;
 }
 
+function applyCellBackground(line: string, width: number, bgFn?: (text: string) => string): string {
+	if (!bgFn) return line;
+	if (width <= 0) return bgFn(line);
+	const paddingNeeded = Math.max(0, width - visibleWidth(line));
+	const padded = line + " ".repeat(paddingNeeded);
+	return bgFn(padded);
+}
+
+function highlightPythonCode(code?: string): string[] {
+	return highlightCode(code ?? "", "python");
+}
+
+function formatCellStatus(cell: PythonCellResult, ui: ToolUIKit, spinnerFrame?: number): string | undefined {
+	switch (cell.status) {
+		case "pending":
+			return `${ui.statusIcon("pending")} ${ui.theme.fg("muted", "pending")}`;
+		case "running":
+			return `${ui.statusIcon("running", spinnerFrame)} ${ui.theme.fg("muted", "running")}`;
+		case "complete":
+			return ui.statusIcon("success");
+		case "error":
+			return ui.statusIcon("error");
+	}
+}
+
+function formatCellHeader(
+	cell: PythonCellResult,
+	index: number,
+	total: number,
+	ui: ToolUIKit,
+	spinnerFrame?: number,
+	workdirLabel?: string,
+): string {
+	const indexLabel = ui.theme.fg("accent", `[${index + 1}/${total}]`);
+	const title = cell.title ? ` ${cell.title}` : "";
+	const metaParts: string[] = [];
+	if (workdirLabel) {
+		metaParts.push(ui.theme.fg("dim", workdirLabel));
+	}
+	if (cell.durationMs !== undefined) {
+		metaParts.push(ui.theme.fg("dim", `(${ui.formatDuration(cell.durationMs)})`));
+	}
+	const statusLabel = formatCellStatus(cell, ui, spinnerFrame);
+	if (statusLabel) {
+		metaParts.push(statusLabel);
+	}
+	const meta = metaParts.length > 0 ? ` ${metaParts.join(ui.theme.fg("dim", ui.theme.sep.dot))}` : "";
+	return `${indexLabel}${title}${meta}`;
+}
+
+function formatCellOutputLines(
+	cell: PythonCellResult,
+	expanded: boolean,
+	previewLines: number,
+	theme: Theme,
+): { lines: string[]; hiddenCount: number } {
+	const rawLines = cell.output ? cell.output.split("\n") : [];
+	const displayLines = expanded ? rawLines : rawLines.slice(-previewLines);
+	const hiddenCount = rawLines.length - displayLines.length;
+	const outputLines = displayLines.map((line) => theme.fg("toolOutput", line));
+
+	if (outputLines.length === 0) {
+		return { lines: [], hiddenCount: 0 };
+	}
+
+	return { lines: outputLines, hiddenCount };
+}
+
+function renderCellBlock(
+	cell: PythonCellResult,
+	index: number,
+	total: number,
+	ui: ToolUIKit,
+	options: {
+		expanded: boolean;
+		previewLines: number;
+		spinnerFrame?: number;
+		showOutput: boolean;
+		workdirLabel?: string;
+		width: number;
+		bgFn?: (text: string) => string;
+	},
+): string[] {
+	const { expanded, previewLines, spinnerFrame, showOutput, workdirLabel, width, bgFn } = options;
+	const h = ui.theme.boxSharp.horizontal;
+	const v = ui.theme.boxSharp.vertical;
+	const cap = h.repeat(3);
+	const border = (text: string) => ui.theme.fg("dim", text);
+	const lineWidth = Math.max(0, width);
+
+	const buildBarLine = (leftChar: string, label?: string): string => {
+		const left = border(`${leftChar}${cap}`);
+		if (lineWidth <= 0) return left;
+		const rawLabel = label ? ` ${label} ` : " ";
+		const maxLabelWidth = Math.max(0, lineWidth - visibleWidth(left));
+		const trimmedLabel = truncateToWidth(rawLabel, maxLabelWidth, ui.theme.format.ellipsis);
+		const fillCount = Math.max(0, lineWidth - visibleWidth(left + trimmedLabel));
+		return `${left}${trimmedLabel}${border(h.repeat(fillCount))}`;
+	};
+
+	const lines: string[] = [];
+	lines.push(
+		applyCellBackground(
+			buildBarLine(ui.theme.boxSharp.topLeft, formatCellHeader(cell, index, total, ui, spinnerFrame, workdirLabel)),
+			lineWidth,
+			bgFn,
+		),
+	);
+
+	const codePrefix = border(`${v} `);
+	const codeWidth = Math.max(0, lineWidth - visibleWidth(codePrefix));
+	const codeLines = highlightPythonCode(cell.code);
+	for (const line of codeLines) {
+		const text = truncateToWidth(line, codeWidth, ui.theme.format.ellipsis);
+		lines.push(applyCellBackground(`${codePrefix}${text}`, lineWidth, bgFn));
+	}
+
+	const statusLines = renderStatusEvents(cell.statusEvents ?? [], ui.theme, expanded);
+	const outputContent = formatCellOutputLines(cell, expanded, previewLines, ui.theme);
+	const hasOutput = outputContent.lines.length > 0;
+	const hasStatus = statusLines.length > 0;
+	const showOutputSection = showOutput && (hasOutput || hasStatus);
+
+	if (showOutputSection) {
+		lines.push(
+			applyCellBackground(
+				buildBarLine(ui.theme.boxSharp.teeRight, ui.theme.fg("toolTitle", "Output")),
+				lineWidth,
+				bgFn,
+			),
+		);
+
+		for (const line of outputContent.lines) {
+			const text = truncateToWidth(line, codeWidth, ui.theme.format.ellipsis);
+			lines.push(applyCellBackground(`${codePrefix}${text}`, lineWidth, bgFn));
+		}
+		if (!expanded && outputContent.hiddenCount > 0) {
+			const hint = ui.theme.fg(
+				"dim",
+				`${ui.theme.format.ellipsis} ${outputContent.hiddenCount} more lines (ctrl+o to expand)`,
+			);
+			lines.push(
+				applyCellBackground(
+					`${codePrefix}${truncateToWidth(hint, codeWidth, ui.theme.format.ellipsis)}`,
+					lineWidth,
+					bgFn,
+				),
+			);
+		}
+
+		for (const line of statusLines) {
+			const text = truncateToWidth(line, codeWidth, ui.theme.format.ellipsis);
+			lines.push(applyCellBackground(`${codePrefix}${text}`, lineWidth, bgFn));
+		}
+	}
+
+	const bottomLeft = border(`${ui.theme.boxSharp.bottomLeft}${cap}`);
+	const bottomFillCount = Math.max(0, lineWidth - visibleWidth(bottomLeft));
+	const bottomLine = `${bottomLeft}${border(h.repeat(bottomFillCount))}`;
+	lines.push(applyCellBackground(bottomLine, lineWidth, bgFn));
+	return lines;
+}
+
 export const pythonToolRenderer = {
 	renderCall(args: PythonRenderArgs, uiTheme: Theme): Component {
 		const ui = new ToolUIKit(uiTheme);
-		const code = args.code || uiTheme.format.ellipsis;
-		const prompt = uiTheme.fg("accent", ">>>");
+		const cells = args.cells ?? [];
 		const cwd = process.cwd();
-		let displayWorkdir = args.workdir;
+		let displayWorkdir = args.cwd;
 
 		if (displayWorkdir) {
 			const resolvedCwd = resolve(cwd);
@@ -622,11 +903,44 @@ export const pythonToolRenderer = {
 			}
 		}
 
-		const cmdText = displayWorkdir
-			? `${prompt} ${uiTheme.fg("dim", `cd ${displayWorkdir} &&`)} ${code}`
-			: `${prompt} ${code}`;
-		const text = ui.title(cmdText);
-		return new Text(text, 0, 0);
+		const workdirLabel = displayWorkdir ? `cd ${displayWorkdir}` : undefined;
+		if (cells.length === 0) {
+			const prompt = uiTheme.fg("accent", ">>>");
+			const prefix = workdirLabel ? `${uiTheme.fg("dim", `${workdirLabel} && `)}` : "";
+			const text = ui.title(`${prompt} ${prefix}${uiTheme.format.ellipsis}`);
+			return new Text(text, 0, 0);
+		}
+
+		return {
+			render: (width: number): string[] => {
+				const lines: string[] = [];
+				for (let i = 0; i < cells.length; i++) {
+					const cell = cells[i];
+					const cellResult: PythonCellResult = {
+						index: i,
+						title: cell.title,
+						code: cell.code,
+						output: "",
+						status: "pending",
+					};
+					lines.push(
+						...renderCellBlock(cellResult, i, cells.length, ui, {
+							expanded: true,
+							previewLines: PYTHON_DEFAULT_PREVIEW_LINES,
+							showOutput: false,
+							workdirLabel: i === 0 ? workdirLabel : undefined,
+							width,
+							bgFn: (text: string) => uiTheme.bg("toolPendingBg", text),
+						}),
+					);
+					if (i < cells.length - 1) {
+						lines.push("");
+					}
+				}
+				return lines;
+			},
+			invalidate: () => {},
+		};
 	},
 
 	renderResult(
@@ -642,7 +956,6 @@ export const pythonToolRenderer = {
 		const previewLines = renderContext?.previewLines ?? PYTHON_DEFAULT_PREVIEW_LINES;
 		const output = renderContext?.output ?? (result.content?.find((c) => c.type === "text")?.text ?? "").trim();
 		const fullOutput = details?.fullOutput;
-		const displayOutput = expanded ? (fullOutput ?? output) : output;
 		const showingFullOutput = expanded && fullOutput !== undefined;
 
 		const jsonOutputs = details?.jsonOutputs ?? [];
@@ -652,12 +965,6 @@ export const pythonToolRenderer = {
 			return [header, ...treeLines];
 		});
 
-		// Render status events
-		const statusEvents = details?.statusEvents ?? [];
-		const statusLines = renderStatusEvents(statusEvents, uiTheme, expanded);
-
-		const combinedOutput = [displayOutput, ...jsonLines].filter(Boolean).join("\n");
-
 		const truncation = details?.truncation;
 		const fullOutputPath = details?.fullOutputPath;
 		const timeoutSeconds = renderContext?.timeout;
@@ -685,12 +992,63 @@ export const pythonToolRenderer = {
 			}
 		}
 
+		const cellResults = details?.cells;
+		if (cellResults && cellResults.length > 0) {
+			return {
+				render: (width: number): string[] => {
+					const lines: string[] = [];
+					for (let i = 0; i < cellResults.length; i++) {
+						const cell = cellResults[i];
+						const showOutput = cell.status !== "pending";
+						const bgColor =
+							cell.status === "error"
+								? "toolErrorBg"
+								: cell.status === "complete"
+									? "toolSuccessBg"
+									: "toolPendingBg";
+						lines.push(
+							...renderCellBlock(cell, i, cellResults.length, ui, {
+								expanded,
+								previewLines,
+								spinnerFrame: options.spinnerFrame,
+								showOutput,
+								width,
+								bgFn: (text: string) => uiTheme.bg(bgColor, text),
+							}),
+						);
+						if (i < cellResults.length - 1) {
+							lines.push("");
+						}
+					}
+					if (jsonLines.length > 0) {
+						if (lines.length > 0) {
+							lines.push("");
+						}
+						lines.push(...jsonLines);
+					}
+					if (timeoutLine) {
+						lines.push(timeoutLine);
+					}
+					if (warningLine) {
+						lines.push(warningLine);
+					}
+					return lines;
+				},
+				invalidate: () => {},
+			};
+		}
+
+		const displayOutput = expanded ? (fullOutput ?? output) : output;
+		const combinedOutput = [displayOutput, ...jsonLines].filter(Boolean).join("\n");
+
+		const statusEvents = details?.statusEvents ?? [];
+		const statusLines = renderStatusEvents(statusEvents, uiTheme, expanded);
+
 		if (!combinedOutput && statusLines.length === 0) {
 			const lines = [timeoutLine, warningLine].filter(Boolean) as string[];
 			return new Text(lines.join("\n"), 0, 0);
 		}
 
-		// If only status events (no text output), show them directly
 		if (!combinedOutput && statusLines.length > 0) {
 			const lines = [...statusLines, timeoutLine, warningLine].filter(Boolean) as string[];
 			return new Text(lines.join("\n"), 0, 0);
@@ -733,7 +1091,6 @@ export const pythonToolRenderer = {
 					outputLines.push(truncateToWidth(skippedLine, width, uiTheme.fg("dim", uiTheme.format.ellipsis)));
 				}
 				outputLines.push(...cachedLines);
-				// Add status events below the output
 				for (const statusLine of statusLines) {
 					outputLines.push(truncateToWidth(statusLine, width, uiTheme.fg("dim", uiTheme.format.ellipsis)));
 				}
@@ -752,4 +1109,6 @@ export const pythonToolRenderer = {
 			},
 		};
 	},
+	mergeCallAndResult: true,
+	inline: true,
 };

package/src/core/tools/read.ts

@@ -223,11 +223,11 @@ async function listCandidateFiles(
 	const { stdout, stderr, exitCode } = await runFd(fdPath, args, signal);
 	const output = stdout.trim();
 
-	if (exitCode !== 0 && !output) {
-		return { files: [], truncated: false, error: stderr.trim() || `fd exited with code ${exitCode ?? -1}` };
-	}
-
 	if (!output) {
+		// fd exit codes: 0 = found, 1 = no matches, other = error
+		if (exitCode !== 0 && exitCode !== 1) {
+			return { files: [], truncated: false, error: stderr.trim() || `fd failed (exit ${exitCode})` };
+		}
 		return { files: [], truncated: false };
 	}