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

package/src/prompts/tools/browser.md

@@ -1,18 +1,18 @@
 Drives a real Chromium tab with full puppeteer access via JS execution.
 
 <instruction>
-- For fetching static web content (articles, docs, issues/PRs, JSON, PDFs, feeds), prefer the `read` tool with a URL — reader-mode text without spinning up a browser. Use this tool when you need JS execution, authentication, or interactive actions.
+- For static web content (articles, docs, issues/PRs, JSON, PDFs, feeds), prefer the `read` tool with a URL — reader-mode text without spinning up a browser. Use this tool when you need JS execution, authentication, or interactive actions.
 - Three actions only:
   - `open` — acquire (or reuse) a named tab. `name` defaults to `"main"`. Optional `url` navigates after the tab is ready. Optional `viewport` sets dimensions. Optional `dialogs: "accept" | "dismiss"` auto-handles `alert`/`confirm`/`beforeunload` so navigation/clicks don't hang (default: leave dialogs unhandled — page hangs until caller wires `page.on('dialog', …)`).
   - `close` — release a tab by `name`, or every tab with `all: true`. For spawned-app browsers, set `kill: true` to terminate the process tree (default leaves it running).
-  - `run` — execute JS against an existing tab. The `code` is the body of an async function with `page`, `browser`, `tab`, `display`, `assert`, `wait` in scope. The function's return value is JSON-stringified into the tool result; multiple `display(value)` calls accumulate text/images.
+  - `run` — execute JS against an existing tab. `code` is the body of an async function with `page`, `browser`, `tab`, `display`, `assert`, `wait` in scope. The function's return value is JSON-stringified into the tool result; multiple `display(value)` calls accumulate text/images.
 - Tabs survive across `run` calls and across in-process subagents. Open once, reuse many times.
 - Browser kinds, selected by the `app` field on `open`:
   - default (no `app`) → headless Chromium with stealth patches.
   - `app.path` → spawn an absolute binary (Electron/CDP). If a running instance already exposes a CDP port, it is reused; otherwise stale instances are killed and a fresh one is spawned. No stealth patches — never tamper with a real desktop app.
   - `app.cdp_url` → connect to an existing CDP endpoint (e.g. `http://127.0.0.1:9222`).
   - `app.target` (with `path`/`cdp_url`) — substring matched against url+title to pick a BrowserWindow when the app exposes several.
-- Inside `run`, `tab` exposes high-level helpers; reach for `page` (raw puppeteer Page) when you need anything they don't cover. Available helpers:
+- Inside `run`, `tab` exposes high-level helpers; reach for `page` (raw puppeteer Page) when you need anything they don't cover.
   - `tab.goto(url, { waitUntil? })` — clears the element cache and navigates.
   - `tab.observe({ includeAll?, viewportOnly? })` — accessibility snapshot. Returns `{ url, title, viewport, scroll, elements: [{ id, role, name, value, states, … }] }`. Element ids are stable until the next observe/goto.
   - `tab.id(n)` — resolves an element id from the most recent observe to a real `ElementHandle` you can `.click()`, `.type()`, etc.
@@ -66,5 +66,5 @@ Drives a real Chromium tab with full puppeteer access via JS execution.
 </examples>
 
 <output>
-Per call: any `display(value)` outputs (text/images) followed by the JSON-stringified return value of the `code` function. `run` always produces at least a status line.
+- Per call: any `display(value)` outputs (text/images) followed by the JSON-stringified return value of the `code` function. `run` always produces at least a status line.
 </output>

package/src/prompts/tools/debug.md

@@ -1,4 +1,5 @@
-Provides debugger access through the Debug Adapter Protocol (DAP). Use this to launch or attach debuggers, set breakpoints, step through execution, inspect threads/stack/variables, evaluate expressions, capture program output, and interrupt hung programs.
+Provides debugger access through the Debug Adapter Protocol (DAP).
+Use for launching or attaching debuggers, setting breakpoints, stepping through execution, inspecting threads/stack/variables, evaluating expressions, capturing output, and interrupting hung programs.
 
 <instruction>
 - Prefer over bash for program state, breakpoints, stepping, thread inspection, or interrupting a running process.
@@ -23,6 +24,7 @@ Provides debugger access through the Debug Adapter Protocol (DAP). Use this to l
 3. `debug(action: "continue")`
 4. If the program appears hung: `debug(action: "pause")`
 5. Inspect state with `threads`, `stack_trace`, `scopes`, and `variables`
+
 # Raw debugger command through repl
 `debug(action: "evaluate", expression: "info registers", context: "repl")`
 </examples>

package/src/prompts/tools/eval.md

@@ -1,27 +1,31 @@
-Run code in a persistent kernel, using a series of codeblocks acting as cells.
+Run code in a persistent kernel using codeblock cells.
 
 <instruction>
-Each cell is introduced by a header line of the form:
+Cell header format:
 
 ```
 ===== <info> =====
 ```
 
-where each side is at least 5 equal signs. Everything between one header and the next (or end of input) is the cell's code, verbatim. The info is space-separated tokens, all optional, in any order:
-- **Language**: {{#if py}}`py` for Python{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`js` / `ts` for JavaScript{{/if}}.{{#ifAll py js}} Omitted → inherit the previous cell's language (the first cell defaults to Python, falling back to JavaScript when Python is unavailable).{{else}} Omitted → inherit the previous cell's language.{{/ifAll}}
+At least 5 equal signs on each side. Content between one header and the next (or end of input) is the cell's code, verbatim.
+- **Language**: {{#if py}}`py` for Python{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`js` / `ts` for JavaScript{{/if}}.{{#ifAll py js}} Omitted → inherit previous cell's language (first cell defaults to Python, falls back to JavaScript).{{else}} Omitted → inherit previous cell's language.{{/ifAll}}
 - **Title shorthand**: `py:"…"`, `js:"…"`, `ts:"…"` set the language and the cell title together.
 - **Attributes**:
   - `id:"…"` — cell title (when language is unchanged or already set).
-  - `t:<duration>` — per-cell timeout. Duration is digits with optional `ms` / `s` / `m` units (e.g. `t:500ms`, `t:15s`, `t:2m`). Default 30s.
-  - `rst` — wipe **this cell's own language kernel** before running.{{#ifAll py js}} Other languages are untouched.{{/ifAll}}
+  - `t:<duration>` — per-cell timeout. Digits with optional `ms` / `s` / `m` units (e.g., `t:500ms`, `t:15s`, `t:2m`). Default 30s.
+  - `rst` — wipe this cell's own language kernel before running.{{#ifAll py js}} Other languages are untouched.{{/ifAll}}
 
-**Work incrementally:** one logical step per cell (imports, define, test, use). Pass multiple small cells in one call. Define small reusable functions you can debug individually. You **MUST** put workflow explanations in the assistant message or cell title — never inside cell code.
+**Work incrementally:**
+- One logical step per cell (imports, define, test, use).
+- Pass multiple small cells in one call.
+- Define small reusable functions for individual debugging.
+- Put workflow explanations in the assistant message or cell title — never inside cell code.
 
 **On failure:** errors identify the failing cell (e.g., "Cell 3 failed"). Resubmit only the fixed cell (or fixed cell + remaining cells).
 </instruction>
 
 <prelude>
-{{#ifAll py js}}The same helpers are available in both runtimes with the same positional argument order. Python takes the trailing options as keyword args; JavaScript takes the same options as a trailing object literal. JavaScript helpers are async and `await`able; Python helpers run synchronously.{{else}}{{#if py}}Helpers run synchronously. Trailing options are passed as keyword arguments.{{/if}}{{#if js}}Helpers are async and `await`able. Trailing options are passed as a final object literal.{{/if}}{{/ifAll}}
+{{#ifAll py js}}Same helpers in both runtimes with the same positional argument order. Python: trailing options as keyword args. JavaScript: trailing options as a trailing object literal. JavaScript helpers are async and `await`able; Python helpers run synchronously.{{else}}{{#if py}}Helpers run synchronously. Trailing options are keyword arguments.{{/if}}{{#if js}}Helpers are async and `await`able. Trailing options are a final object literal.{{/if}}{{/ifAll}}
 ```
 display(value) → None
     Render a value in the current cell output.
@@ -49,7 +53,7 @@ output(*ids, format?="raw", query?=None, offset?=None, limit?=None) → str | di
 {{/if}}</prelude>
 
 <output>
-Cells render like a Jupyter notebook. Pass any value to `display(value)`; non-presentable data is rendered as an interactive JSON tree, and presentable values (figures, images, dataframes, etc.) render with their native representation.
+Cells render like a Jupyter notebook. `display(value)` renders non-presentable data as an interactive JSON tree. Presentable values (figures, images, dataframes, etc.) use their native representation.
 </output>
 
 <caution>

package/src/prompts/tools/hashline.md

@@ -4,7 +4,7 @@ A patch contains one or more file sections. The first non-blank line of every ed
 Operations reference lines in the file by their line number and hash, called "Anchors", e.g. `5th`, `123ab`.
 You **MUST** copy them verbatim from the latest output for the file you're editing.
 
-This format is purely textual. The tool has NO awareness of language, indentation, brackets, fences, or table widths. You are responsible for emitting valid syntax in your replacements/insertions.
+Purely textual format. The tool has NO awareness of language, indentation, brackets, fences, or table widths. Emit valid syntax in replacements/insertions.
 
 <ops>
 @PATH            header: subsequent ops apply to PATH
@@ -89,7 +89,7 @@ This format is purely textual. The tool has NO awareness of language, indentatio
 + {{hrefr 1}}
 {{hsep}}const DEBUG = false;
 
-If your replacement payload would render with even one unchanged line in the diff, you have the wrong op or the wrong range. Stop and rewrite as `+`/`<`/`-` plus a narrower `=`.
+If your replacement payload would render with even one unchanged line in the diff, you have the wrong op or range. Stop and rewrite as `+`/`<`/`-` plus a narrower `=`.
 </anti-pattern>
 
 <critical>
@@ -98,4 +98,6 @@ If your replacement payload would render with even one unchanged line in the dif
 - Do not write unified diff syntax (`@@`, `-OLD`, `+NEW`).
 - `= A..B` deletes the range; payload is what's written. If a payload edge line already exists immediately outside `A..B`, widen the range to cover it — otherwise it duplicates.
 - Multiple ops in one patch are cheap. Prefer two narrow ops over one wide `=`.
+  - Before choosing a `= A..B` range, mentally delete lines A through B. If that would split an unclosed bracket, paren, brace, or string/template from a line above A, or orphan a closing delimiter that belongs to an opener inside the range, you are bisecting a syntactic construct. Widen the range to a self-contained boundary, or use `+`/`-` instead.
+  - `= A..B` removes the range as a unit; the lines immediately outside it remain. If those outside lines form a wrapper (`try {`, `catch`, `if`, `else`, loop delimiters) you do not intend to delete, your payload is inserted inside that wrapper. Make sure the payload remains valid and preserves required behavior like error handling. If you need to change the wrapper itself, include it in the range and reproduce it.
 </critical>

package/src/prompts/tools/image-gen.md

@@ -1,4 +1,4 @@
-Generates or edits images using the configured image provider.
+Generates or edits images.
 
 <instructions>
 - You **MUST** provide a single detailed `subject` prompt for image generation or editing.

package/src/prompts/tools/read.md

@@ -7,7 +7,6 @@ The `read` tool is multi-purpose and more capable than it looks — inspects fil
 
 ## Parameters
 - `path` — file path or URL (required). Append `:<sel>` for line ranges or raw mode (for example `src/foo.ts:50-200` or `src/foo.ts:raw`).
-- `timeout` — seconds, for URLs only
 
 ## Selectors
 
@@ -33,7 +32,7 @@ The `read` tool is multi-purpose and more capable than it looks — inspects fil
 
 # Inspection
 
-Extracts text from PDF, Word, PowerPoint, Excel, RTF, EPUB, and Jupyter notebook files. Can inspect images.
+Extracts text from PDF, Word, PowerPoint, Excel, RTF, EPUB, and Jupyter notebook files. Notebooks are shown as editable `# %% [type] cell:N` text; edits to that text are applied back to the underlying `.ipynb` JSON while preserving notebook metadata where possible. Can inspect images.
 
 # Directories & Archives
 

package/src/prompts/tools/reflect.md

@@ -1,5 +1,5 @@
-Generate a synthesised answer by reasoning over long-term memory. Unlike `recall` (which returns raw entries), `reflect` blends relevant memories into a single coherent response.
+Generate a synthesised answer by reasoning over long-term memory. Unlike `recall`, `reflect` blends relevant memories into a coherent response.
 
-Use for open-ended questions that span many stored facts: "What do you know about this user?", "Summarize project decisions.", "What are my preferences for X?"
+Use for open-ended questions spanning many stored facts: "What do you know about this user?", "Summarize project decisions.", "What are my preferences for X?"
 
-Provide an optional `context` to focus the synthesis on a specific angle or sub-topic.
+Optional `context` parameter focuses the synthesis on a specific angle or sub-topic.

package/src/prompts/tools/render-mermaid.md

@@ -5,5 +5,5 @@ Parameters:
 - `config` (optional): JSON render configuration (spacing and layout options).
 Behavior:
 - Returns ASCII diagram text.
-- Saves full ASCII output to an artifact URL (`artifact://<id>`) when artifact storage is available.
-- Returns an error when the Mermaid input is invalid or rendering fails.
+- Saves full output to `artifact://<id>` when storage is available.
+- Returns error when Mermaid input is invalid or rendering fails.

package/src/prompts/tools/resolve.md

@@ -4,5 +4,5 @@ Resolves a pending preview action by either applying or discarding it.
   - `"discard"` rejects the pending changes.
 - `reason` is required and must explain why you chose to apply or discard.
 
-This tool is only valid when a pending action exists (typically after a preview step).
-If no pending action exists, the call fails with an error.
+Only valid when a pending action exists (typically after a preview step).
+Call fails with an error when no pending action exists.

package/src/prompts/tools/retain.md

@@ -1,5 +1,6 @@
 Store one or more facts in long-term memory for future sessions.
 
-Use for durable, reusable knowledge: user preferences, project decisions, architectural choices, and anything that would improve future responses if recalled. Ephemeral task state does not belong here.
+Use for durable, reusable knowledge: user preferences, project decisions, architectural choices, anything that improves future responses.
+Ephemeral task state does not belong here.
 
-Each item must be specific and self-contained — include who, what, when, and why. Batch related facts in a single call; they are deduplicated and consolidated together.
+Each item **MUST** be specific and self-contained — include who, what, when, and why. Batch related facts in a single call; they are deduplicated and consolidated.

package/src/prompts/tools/rewind.md

@@ -1,6 +1,6 @@
-Ends an active checkpoint and rewinds context back to that checkpoint, replacing intermediate exploration with your report.
+End an active checkpoint. Rewind context to it, replacing intermediate exploration with your report.
 
-Use this immediately after investigative work started with `checkpoint`.
+Call immediately after `checkpoint`-started investigative work.
 
 Requirements:
 - `report` is **REQUIRED** and must be concise, factual, and actionable.

package/src/prompts/tools/search-tool-bm25.md

@@ -1,7 +1,6 @@
 Search hidden tool metadata to discover and activate tools.
 
-Use this tool when you need a capability that is not currently available in your active tool set. It searches all discoverable tools — including MCP tools and built-in tools that are hidden to save tokens.
-
+Activate hidden tools (MCP and built-in) when you need a capability not in your active tool set.
 {{#if hasDiscoverableMCPServers}}Discoverable MCP servers in this session: {{#list discoverableMCPServerSummaries join=", "}}{{this}}{{/list}}.{{/if}}
 {{#if discoverableMCPToolCount}}Total discoverable tools available: {{discoverableMCPToolCount}}.{{/if}}
 Input:
@@ -16,7 +15,7 @@ Behavior:
 - Newly activated tools become available before the next model call in the same overall turn
 
 Notes:
-- If you are unsure, start with `limit` between 5 and 10 to see a broader set of tools.
+Start with `limit` 5–10 if unsure.
 - `query` is matched against tool metadata fields:
   - `name`
   - `label`
@@ -25,7 +24,7 @@ Notes:
   - `description` / `summary`
   - input schema property keys (`schema_keys`)
 
-This is not repository search, file search, or code search. Use it only for tool discovery.
+Not for repository/file/code search. Tool discovery only.
 
 Returns JSON with:
 - `query`

package/src/prompts/tools/task.md

@@ -5,7 +5,7 @@ Launches subagents to parallelize workflows.
 - Use `job` (with `poll`) to wait. **MUST NOT** poll `read jobs://` in a loop.
 {{/if}}
 
-Subagents have no access to your conversation history. Every fact, file path, and decision they need **MUST** be explicit in {{#if contextEnabled}}`context` or `assignment`{{else}}each `assignment`{{/if}}.
+Subagents have no conversation history. Every fact, file path, and decision they need **MUST** be explicit in {{#if contextEnabled}}`context` or `assignment`{{else}}each `assignment`{{/if}}.
 
 <parameters>
 - `agent`: agent type for all tasks

package/src/slash-commands/builtin-registry.ts

@@ -119,8 +119,10 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 		name: "loop",
 		description:
 			"Toggle loop mode. While enabled, the next prompt you send re-submits after every yield. Esc cancels the current iteration; /loop again to disable.",
-		handle: async (_command, runtime) => {
-			await runtime.ctx.handleLoopCommand();
+		inlineHint: "[count|duration]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			await runtime.ctx.handleLoopCommand(command.args);
 			runtime.ctx.editor.setText("");
 		},
 	},

package/src/task/commands.ts

@@ -9,8 +9,12 @@ import { type SlashCommand, slashCommandCapability } from "../capability/slash-c
 import { loadCapability } from "../discovery";
 // Embed command markdown files at build time
 import initMd from "../prompts/agents/init.md" with { type: "text" };
+import orchestrateMd from "../prompts/commands/orchestrate.md" with { type: "text" };
 
-const EMBEDDED_COMMANDS: { name: string; content: string }[] = [{ name: "init.md", content: prompt.render(initMd) }];
+const EMBEDDED_COMMANDS: { name: string; content: string }[] = [
+	{ name: "init.md", content: prompt.render(initMd) },
+	{ name: "orchestrate.md", content: prompt.render(orchestrateMd) },
+];
 
 export const EMBEDDED_COMMAND_TEMPLATES: ReadonlyArray<{ name: string; content: string }> = EMBEDDED_COMMANDS;
 

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 =>