@oh-my-pi/pi-coding-agent 14.7.3 → 14.7.4

package/src/tools/fetch.ts

@@ -1220,13 +1220,13 @@ function cacheReadUrlEntry(session: ToolSession, requestedUrl: string, raw: bool
 
 async function buildReadUrlCacheEntry(
 	session: ToolSession,
-	params: { path: string; timeout?: number; raw?: boolean },
+	params: { path: string; raw?: boolean },
 	signal?: AbortSignal,
 	options?: { ensureArtifact?: boolean },
 ): Promise<ReadUrlCacheEntry> {
-	const { path: url, timeout: rawTimeout = 20, raw = false } = params;
+	const { path: url, raw = false } = params;
 
-	const effectiveTimeout = clampTimeout("fetch", rawTimeout);
+	const effectiveTimeout = clampTimeout("fetch", 30);
 
 	if (signal?.aborted) {
 		throw new ToolAbortError();
@@ -1254,7 +1254,7 @@ async function buildReadUrlCacheEntry(
 
 export async function loadReadUrlCacheEntry(
 	session: ToolSession,
-	params: { path: string; timeout?: number; raw?: boolean },
+	params: { path: string; raw?: boolean },
 	signal?: AbortSignal,
 	options?: { ensureArtifact?: boolean; preferCached?: boolean },
 ): Promise<ReadUrlCacheEntry> {
@@ -1291,7 +1291,7 @@ function buildUrlReadOutput(result: FetchRenderResult, content: string): string
 
 export async function executeReadUrl(
 	session: ToolSession,
-	params: { path: string; timeout?: number; raw?: boolean },
+	params: { path: string; raw?: boolean },
 	signal?: AbortSignal,
 ): Promise<AgentToolResult<ReadUrlToolDetails>> {
 	let cacheEntry = await loadReadUrlCacheEntry(session, params, signal, { preferCached: true });
@@ -1345,7 +1345,7 @@ function countNonEmptyLines(text: string): number {
 
 /** Render URL read call (URL preview) */
 export function renderReadUrlCall(
-	args: { path?: string; url?: string; timeout?: number; raw?: boolean },
+	args: { path?: string; url?: string; raw?: boolean },
 	_options: RenderResultOptions,
 	uiTheme: Theme = theme,
 ): Component {
@@ -1355,7 +1355,6 @@ export function renderReadUrlCall(
 	const description = `${domain}${path ? ` ${path}` : ""}`.trim();
 	const meta: string[] = [];
 	if (args.raw) meta.push("raw");
-	if (args.timeout !== undefined) meta.push(`timeout:${args.timeout}s`);
 	const text = renderStatusLine({ icon: "pending", title: "Read", description, meta }, uiTheme);
 	return new Text(text, 0, 0);
 }

package/src/tools/index.ts

@@ -37,7 +37,6 @@ import { HindsightRetainTool } from "./hindsight-retain";
 import { InspectImageTool } from "./inspect-image";
 import { IrcTool } from "./irc";
 import { JobTool } from "./job";
-import { NotebookTool } from "./notebook";
 import { wrapToolWithMetaNotice } from "./output-meta";
 import { ReadTool } from "./read";
 import { RecipeTool } from "./recipe";
@@ -80,7 +79,6 @@ export * from "./image-gen";
 export * from "./inspect-image";
 export * from "./irc";
 export * from "./job";
-export * from "./notebook";
 export * from "./read";
 export * from "./recipe";
 export * from "./render-mermaid";
@@ -271,7 +269,6 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	find: s => new FindTool(s),
 	search: s => new SearchTool(s),
 	lsp: LspTool.createIf,
-	notebook: s => new NotebookTool(s),
 	inspect_image: s => new InspectImageTool(s),
 	browser: s => new BrowserTool(s),
 	checkpoint: CheckpointTool.createIf,
@@ -430,7 +427,6 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "ast_grep") return session.settings.get("astGrep.enabled");
 		if (name === "ast_edit") return session.settings.get("astEdit.enabled");
 		if (name === "render_mermaid") return session.settings.get("renderMermaid.enabled");
-		if (name === "notebook") return session.settings.get("notebook.enabled");
 		if (name === "inspect_image") return session.settings.get("inspect_image.enabled");
 		if (name === "web_search") return session.settings.get("web_search.enabled");
 		// search_tool_bm25 is allowed when either legacy mcp.discoveryMode or new tools.discoveryMode is active.

package/src/tools/read.ts

@@ -9,6 +9,7 @@ import { Text } from "@oh-my-pi/pi-tui";
 import { getRemoteDir, prompt, readImageMetadata, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { formatHashLine, formatHashLines, formatLineHash, HL_BODY_SEP } from "../edit/line-hash";
+import { isNotebookPath, readEditableNotebookText } from "../edit/notebook";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { parseInternalUrl } from "../internal-urls/parse";
 import type { InternalUrl } from "../internal-urls/types";
@@ -418,7 +419,6 @@ const readSchema = Type.Object({
 		description: 'path or url; append :<sel> for line ranges or raw mode (e.g. "src/foo.ts:50-100")',
 		examples: ["src/foo.ts", "src/foo.ts:50-100", "https://example.com:L1-L40"],
 	}),
-	timeout: Type.Optional(Type.Number({ description: "timeout in seconds", default: 20 })),
 });
 
 export type ReadToolInput = Static<typeof readSchema>;
@@ -1084,7 +1084,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		_onUpdate?: AgentToolUpdateCallback<ReadToolDetails>,
 		_toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<ReadToolDetails>> {
-		let { path: readPath, timeout } = params;
+		let { path: readPath } = params;
 		if (readPath.startsWith("file://")) {
 			readPath = expandPath(readPath);
 		}
@@ -1098,7 +1098,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			if (parsedUrlTarget.offset !== undefined || parsedUrlTarget.limit !== undefined) {
 				const cached = await loadReadUrlCacheEntry(
 					this.session,
-					{ path: parsedUrlTarget.path, timeout, raw: parsedUrlTarget.raw },
+					{ path: parsedUrlTarget.path, raw: parsedUrlTarget.raw },
 					signal,
 					{
 						ensureArtifact: true,
@@ -1111,7 +1111,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					entityLabel: "URL output",
 				});
 			}
-			return executeReadUrl(this.session, { path: parsedUrlTarget.path, timeout, raw: parsedUrlTarget.raw }, signal);
+			return executeReadUrl(this.session, { path: parsedUrlTarget.path, raw: parsedUrlTarget.raw }, signal);
 		}
 
 		// Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://, mcp://)
@@ -1196,7 +1196,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		const ext = path.extname(absolutePath).toLowerCase();
 		const _hasEditTool = this.session.hasEditTool ?? true;
 		const _language = getLanguageFromPath(absolutePath);
-		const shouldConvertWithMarkit = CONVERTIBLE_EXTENSIONS.has(ext) || (ext === ".ipynb" && parsed.kind === "raw");
+		const shouldConvertWithMarkit = CONVERTIBLE_EXTENSIONS.has(ext);
 		// Read the file based on type
 		let content: Array<TextContent | ImageContent> | undefined;
 		let details: ReadToolDetails = {};
@@ -1263,8 +1263,20 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					throw error;
 				}
 			}
+		} else if (isNotebookPath(absolutePath) && parsed.kind !== "raw") {
+			const { offset, limit } = selToOffsetLimit(parsed);
+			return this.#buildInMemoryTextResult(
+				await readEditableNotebookText(absolutePath, localReadPath),
+				offset,
+				limit,
+				{
+					details: { resolvedPath: absolutePath },
+					sourcePath: absolutePath,
+					entityLabel: "notebook",
+				},
+			);
 		} else if (shouldConvertWithMarkit) {
-			// Convert document or notebook via markit.
+			// Convert document via markit.
 			const result = await convertFileWithMarkit(absolutePath, signal);
 			if (result.ok) {
 				// Apply truncation to converted content
@@ -1556,7 +1568,6 @@ interface ReadRenderArgs {
 	path?: string;
 	file_path?: string;
 	sel?: string;
-	timeout?: number;
 	// Legacy fields from old schema — tolerated for in-flight tool calls during transition
 	offset?: number;
 	limit?: number;

package/src/tools/renderers.ts

@@ -22,7 +22,6 @@ import { findToolRenderer } from "./find";
 import { githubToolRenderer } from "./gh-renderer";
 import { inspectImageToolRenderer } from "./inspect-image-renderer";
 import { jobToolRenderer } from "./job";
-import { notebookToolRenderer } from "./notebook";
 import { readToolRenderer } from "./read";
 import { recipeToolRenderer } from "./recipe/render";
 import { resolveToolRenderer } from "./resolve";
@@ -60,7 +59,6 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	find: findToolRenderer as ToolRenderer,
 	search: searchToolRenderer as ToolRenderer,
 	lsp: lspToolRenderer as ToolRenderer,
-	notebook: notebookToolRenderer as ToolRenderer,
 	inspect_image: inspectImageToolRenderer as ToolRenderer,
 	read: readToolRenderer as ToolRenderer,
 	job: jobToolRenderer as ToolRenderer,

package/src/tools/write.ts

@@ -9,7 +9,7 @@ import { type Static, Type } from "@sinclair/typebox";
 import { stripHashlinePrefixes } from "../edit";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { createLspWritethrough, type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "../lsp";
-import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
+import { getLanguageFromPath, highlightCode, type Theme } from "../modes/theme/theme";
 import writeDescription from "../prompts/tools/write.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
@@ -168,6 +168,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 	readonly concurrency = "exclusive";
 	readonly loadMode = "discoverable";
 	readonly summary = "Write content to a file (creates or overwrites)";
+	readonly intent = (args: Partial<WriteToolInput>) => (args.path ? `writing ${args.path}` : "writing");
 
 	readonly #writethrough: WritethroughCallback;
 
@@ -523,52 +524,67 @@ function countLines(text: string): number {
 	return text.split("\n").length;
 }
 
-function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
-	const icon = uiTheme.getLangIcon(language);
-	if (lineCount !== null) {
-		return uiTheme.fg("dim", `${icon} ${lineCount} lines`);
-	}
-	return uiTheme.fg("dim", `${icon}`);
+function formatLineCountSuffix(lineCount: number, uiTheme: Theme): string {
+	if (lineCount <= 0) return "";
+	return uiTheme.fg("dim", ` · ${lineCount} line${lineCount === 1 ? "" : "s"}`);
 }
 
 function normalizeDisplayText(text: string): string {
 	return text.replace(/\r/g, "");
 }
 
-function formatStreamingContent(content: string, uiTheme: Theme): string {
+function formatStreamingContent(content: string, language: string | undefined, uiTheme: Theme): string {
 	if (!content) return "";
 	const lines = normalizeDisplayText(content).split("\n");
-	const displayLines = lines.slice(-WRITE_STREAMING_PREVIEW_LINES);
-	const hidden = lines.length - displayLines.length;
+	const totalLines = lines.length;
+	const startIndex = Math.max(0, totalLines - WRITE_STREAMING_PREVIEW_LINES);
+	const visibleLines = lines.slice(startIndex);
+	const hidden = startIndex;
+	const highlighted = highlightCode(visibleLines.join("\n"), language);
+	const lineNumberWidth = String(totalLines).length;
 
 	let text = "\n\n";
 	if (hidden > 0) {
-		text += uiTheme.fg("dim", `… (${hidden} earlier lines)\n`);
+		text += `${uiTheme.fg("dim", `… (${hidden} earlier line${hidden === 1 ? "" : "s"})`)}\n`;
 	}
-	for (const line of displayLines) {
-		text += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), 80))}\n`;
+	for (let i = 0; i < highlighted.length; i++) {
+		const lineNum = startIndex + i + 1;
+		const gutter = uiTheme.fg("dim", `${String(lineNum).padStart(lineNumberWidth, " ")}│`);
+		const body = replaceTabs(highlighted[i] ?? "");
+		text += ` ${gutter}${body}\n`;
 	}
 	text += uiTheme.fg("dim", `… (streaming)`);
 	return text;
 }
 
-function renderContentPreview(content: string, expanded: boolean, uiTheme: Theme): string {
+function renderContentPreview(
+	content: string,
+	expanded: boolean,
+	language: string | undefined,
+	uiTheme: Theme,
+): string {
 	if (!content) return "";
-	const lines = normalizeDisplayText(content).split("\n");
-	const maxLines = expanded ? lines.length : Math.min(lines.length, WRITE_PREVIEW_LINES);
-	const displayLines = expanded ? lines : lines.slice(-maxLines);
-	const hidden = lines.length - displayLines.length;
+	const rawLines = normalizeDisplayText(content).split("\n");
+	const totalLines = rawLines.length;
+	const maxLines = expanded ? totalLines : Math.min(totalLines, WRITE_PREVIEW_LINES);
+	const visibleLines = rawLines.slice(0, maxLines);
+	const highlighted = highlightCode(visibleLines.join("\n"), language);
+	const lineNumberWidth = String(maxLines).length;
+	const hidden = totalLines - maxLines;
 
 	let text = "\n\n";
-	for (const line of displayLines) {
-		text += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), 80))}\n`;
+	for (let i = 0; i < highlighted.length; i++) {
+		const lineNum = i + 1;
+		const gutter = uiTheme.fg("dim", `${String(lineNum).padStart(lineNumberWidth, " ")}│`);
+		const body = replaceTabs(highlighted[i] ?? "");
+		text += ` ${gutter}${body}\n`;
 	}
 	if (!expanded && hidden > 0) {
 		const hint = formatExpandHint(uiTheme, expanded, hidden > 0);
 		const moreLine = `${formatMoreItems(hidden, "line")}${hint ? ` ${hint}` : ""}`;
 		text += uiTheme.fg("dim", moreLine);
 	}
-	return text;
+	return text.trimEnd();
 }
 
 export const writeToolRenderer = {
@@ -588,7 +604,7 @@ export const writeToolRenderer = {
 		}
 
 		// Show streaming preview of content (tail)
-		text += formatStreamingContent(args.content, uiTheme);
+		text += formatStreamingContent(args.content, lang, uiTheme);
 
 		return new Text(text, 0, 0);
 	},
@@ -606,17 +622,17 @@ export const writeToolRenderer = {
 		const langIcon = uiTheme.fg("muted", uiTheme.getLangIcon(lang));
 		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
 		const lineCount = countLines(fileContent);
+		const lineSuffix = formatLineCountSuffix(lineCount, uiTheme);
 
 		// Build header with status icon
 		const header = renderStatusLine(
 			{
 				icon: "success",
 				title: "Write",
-				description: `${langIcon} ${pathDisplay}`,
+				description: `${langIcon} ${pathDisplay}${lineSuffix}`,
 			},
 			uiTheme,
 		);
-		const metadataLine = formatMetadataLine(lineCount, lang ?? "text", uiTheme);
 		const diagnostics = result.details?.diagnostics;
 
 		let cached: RenderCache | undefined;
@@ -628,8 +644,7 @@ export const writeToolRenderer = {
 				if (cached?.key === key) return cached.lines;
 
 				let text = header;
-				text += `\n${metadataLine}`;
-				text += renderContentPreview(fileContent, expanded, uiTheme);
+				text += renderContentPreview(fileContent, expanded, lang, uiTheme);
 
 				if (diagnostics) {
 					const diagText = formatDiagnostics(diagnostics, expanded, uiTheme, fp =>

package/src/tools/notebook.ts

@@ -1,286 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
-import type { Component } from "@oh-my-pi/pi-tui";
-import { Text } from "@oh-my-pi/pi-tui";
-import { isEnoent, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme } from "../modes/theme/theme";
-import type { ToolSession } from "../sdk";
-import { Hasher, type RenderCache, renderCodeCell, renderStatusLine } from "../tui";
-import { resolveToCwd } from "./path-utils";
-import { formatCount, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
-
-const notebookSchema = Type.Object({
-	action: StringEnum(["edit", "insert", "delete"], {
-		description: "cell action",
-		examples: ["edit", "insert", "delete"],
-	}),
-	notebook_path: Type.String({ description: "notebook path", examples: ["analysis.ipynb"] }),
-	cell_index: Type.Number({ description: "cell index", examples: [0, 1] }),
-	content: Type.Optional(Type.String({ description: "new cell content" })),
-	cell_type: Type.Optional(
-		StringEnum(["code", "markdown"], {
-			description: "cell type",
-			examples: ["code", "markdown"],
-		}),
-	),
-});
-
-export interface NotebookToolDetails {
-	/** Action performed */
-	action: "edit" | "insert" | "delete";
-	/** Cell index operated on */
-	cellIndex: number;
-	/** Cell type */
-	cellType?: string;
-	/** Total cell count after operation */
-	totalCells: number;
-	/** Cell content lines after operation (or removed content for delete) */
-	cellSource?: string[];
-}
-
-interface NotebookCell {
-	cell_type: "code" | "markdown" | "raw";
-	source: string[];
-	metadata: Record<string, unknown>;
-	execution_count?: number | null;
-	outputs?: unknown[];
-}
-
-interface Notebook {
-	cells: NotebookCell[];
-	metadata: Record<string, unknown>;
-	nbformat: number;
-	nbformat_minor: number;
-}
-
-function splitIntoLines(content: string): string[] {
-	return content.split("\n").map((line, i, arr) => (i < arr.length - 1 ? `${line}\n` : line));
-}
-
-type NotebookParams = Static<typeof notebookSchema>;
-
-export class NotebookTool implements AgentTool<typeof notebookSchema, NotebookToolDetails> {
-	readonly name = "notebook";
-	readonly label = "Notebook";
-	readonly loadMode = "discoverable";
-	readonly summary = "Read and execute Jupyter notebooks";
-	readonly description = "Edit, insert, or delete cells in Jupyter notebooks (.ipynb). cell_index is 0-based.";
-	readonly parameters = notebookSchema;
-	readonly strict = true;
-	readonly concurrency = "exclusive";
-
-	constructor(private readonly session: ToolSession) {}
-
-	async execute(
-		_toolCallId: string,
-		params: NotebookParams,
-		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<NotebookToolDetails>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<NotebookToolDetails>> {
-		const { action, notebook_path, cell_index, content, cell_type } = params;
-		const absolutePath = resolveToCwd(notebook_path, this.session.cwd);
-
-		return untilAborted(signal, async () => {
-			// Read and parse notebook
-			let notebook: Notebook;
-			try {
-				notebook = await Bun.file(absolutePath).json();
-			} catch (err) {
-				if (isEnoent(err)) throw new Error(`Notebook not found: ${notebook_path}`);
-				throw new Error(`Invalid JSON in notebook: ${notebook_path}`);
-			}
-
-			// Validate notebook structure
-			if (!notebook.cells || !Array.isArray(notebook.cells)) {
-				throw new Error(`Invalid notebook structure (missing cells array): ${notebook_path}`);
-			}
-
-			const cellCount = notebook.cells.length;
-
-			// Validate cell_index based on action
-			if (action === "insert") {
-				if (cell_index < 0 || cell_index > cellCount) {
-					throw new Error(`Cell index ${cell_index} out of range for insert (0-${cellCount}) in ${notebook_path}`);
-				}
-			} else {
-				if (cell_index < 0 || cell_index >= cellCount) {
-					throw new Error(`Cell index ${cell_index} out of range (0-${cellCount - 1}) in ${notebook_path}`);
-				}
-			}
-
-			// Validate content for edit/insert
-			if ((action === "edit" || action === "insert") && content === undefined) {
-				throw new Error(`Content is required for ${action} action`);
-			}
-
-			// Perform the action
-			let resultMessage: string;
-			let finalCellType: string | undefined;
-			let cellSource: string[] | undefined;
-
-			switch (action) {
-				case "edit": {
-					const sourceLines = splitIntoLines(content!);
-					notebook.cells[cell_index].source = sourceLines;
-					finalCellType = notebook.cells[cell_index].cell_type;
-					cellSource = sourceLines;
-					resultMessage = `Replaced cell ${cell_index} (${finalCellType})`;
-					break;
-				}
-				case "insert": {
-					const sourceLines = splitIntoLines(content!);
-					const newCellType = (cell_type as "code" | "markdown") || "code";
-					const newCell: NotebookCell = {
-						cell_type: newCellType,
-						source: sourceLines,
-						metadata: {},
-					};
-					if (newCellType === "code") {
-						newCell.execution_count = null;
-						newCell.outputs = [];
-					}
-					notebook.cells.splice(cell_index, 0, newCell);
-					finalCellType = newCellType;
-					cellSource = sourceLines;
-					resultMessage = `Inserted ${newCellType} cell at position ${cell_index}`;
-					break;
-				}
-				case "delete": {
-					const removedCell = notebook.cells[cell_index];
-					finalCellType = removedCell.cell_type;
-					cellSource = removedCell.source;
-					notebook.cells.splice(cell_index, 1);
-					resultMessage = `Deleted cell ${cell_index} (${finalCellType})`;
-					break;
-				}
-				default: {
-					throw new Error(`Invalid action: ${action}`);
-				}
-			}
-
-			// Write back with single-space indentation
-			await Bun.write(absolutePath, JSON.stringify(notebook, null, 1));
-
-			const newCellCount = notebook.cells.length;
-			return {
-				content: [
-					{
-						type: "text",
-						text: `${resultMessage}. Notebook now has ${newCellCount} cells.`,
-					},
-				],
-				details: {
-					action: action as "edit" | "insert" | "delete",
-					cellIndex: cell_index,
-					cellType: finalCellType,
-					totalCells: newCellCount,
-					cellSource,
-				},
-			};
-		});
-	}
-}
-
-// =============================================================================
-// TUI Renderer
-// =============================================================================
-
-interface NotebookRenderArgs {
-	action: string;
-	notebookPath?: string;
-	notebook_path?: string;
-	cellNumber?: number;
-	cell_index?: number;
-	cellType?: string;
-	cell_type?: string;
-	content?: string;
-}
-
-const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
-
-export const notebookToolRenderer = {
-	renderCall(args: NotebookRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const meta: string[] = [];
-		const notebookPath = args.notebookPath ?? args.notebook_path;
-		const cellNumber = args.cellNumber ?? args.cell_index;
-		const cellType = args.cellType ?? args.cell_type;
-		meta.push(`in ${notebookPath || "?"}`);
-		if (cellNumber !== undefined) meta.push(`cell:${cellNumber}`);
-		if (cellType) meta.push(`type:${cellType}`);
-
-		const text = renderStatusLine(
-			{ icon: "pending", title: "Notebook", description: args.action || "?", meta },
-			uiTheme,
-		);
-		return new Text(text, 0, 0);
-	},
-
-	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: NotebookToolDetails },
-		options: RenderResultOptions,
-		uiTheme: Theme,
-		args?: NotebookRenderArgs,
-	): Component {
-		const content = result.content?.[0];
-		if (content?.type === "text" && content.text?.startsWith("Error:")) {
-			const notebookPath = args?.notebookPath ?? args?.notebook_path ?? "?";
-			const header = renderStatusLine({ icon: "error", title: "Notebook", description: notebookPath }, uiTheme);
-			return new Text([header, formatErrorMessage(content.text, uiTheme)].join("\n"), 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 actionLabel = action === "insert" ? "Inserted" : action === "delete" ? "Deleted" : "Edited";
-		const cellLabel = cellType || "cell";
-		const summaryParts = [`${actionLabel} ${cellLabel} ${cellIndex ?? "?"}`];
-		if (lineCount > 0) summaryParts.push(formatCount("line", lineCount));
-		if (totalCells !== undefined) summaryParts.push(`${totalCells} total`);
-
-		const outputLines = summaryParts.map(part => uiTheme.fg("dim", part));
-		const codeText = cellSource.join("");
-		const language = cellType === "markdown" ? "markdown" : undefined;
-
-		const notebookPath = args?.notebookPath ?? args?.notebook_path;
-		const notebookLabel = notebookPath ? `${actionLabel} ${notebookPath}` : "Notebook";
-		let cached: RenderCache | undefined;
-
-		return {
-			render: (width: number): string[] => {
-				// REACTIVE: read mutable options at render time
-				const { expanded } = options;
-				const key = new Hasher().bool(expanded).u32(width).digest();
-				if (cached?.key === key) return cached.lines;
-
-				const lines = renderCodeCell(
-					{
-						code: codeText,
-						language,
-						title: notebookLabel,
-						status: "complete",
-						output: outputLines.join("\n"),
-						codeMaxLines: expanded ? Number.POSITIVE_INFINITY : COLLAPSED_TEXT_LIMIT,
-						expanded,
-						width,
-					},
-					uiTheme,
-				);
-
-				cached = { key, lines };
-				return lines;
-			},
-			invalidate: () => {
-				cached = undefined;
-			},
-		};
-	},
-	mergeCallAndResult: true,
-};