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

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [14.7.4] - 2026-05-07
+
+### Breaking Changes
+
+- Removed the dedicated `notebook` tool; `.ipynb` reads and edits now go through `read` and `edit`.
+
+### Changed
+
+- Changed diff previews to syntax-highlight contiguous context lines in the unchanged sections when file language can be detected
+- Changed `read` tool behavior for `.ipynb:raw` requests to return raw notebook content instead of converting via markit
+- Changed `.ipynb` edit and read handling to route through notebook serialization helpers
+- Changed `.ipynb` reads to return an editable cell text representation and apply edits back to notebook JSON while preserving cell metadata and outputs where possible.
+
+### Removed
+
+- Removed the `notebook.enabled` configuration option from tool settings
+
+### Fixed
+
+- Fixed hashline edit streaming preview collapsing to a header-only "opaque box" when a second `@PATH` section header arrived mid-stream — earlier completed sections now stay rendered while the trailing section is still being typed.
+
 ## [14.7.2] - 2026-05-06
 ### Breaking Changes
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.7.2",
+	"version": "14.7.4",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.7.2",
-		"@oh-my-pi/pi-agent-core": "14.7.2",
-		"@oh-my-pi/pi-ai": "14.7.2",
-		"@oh-my-pi/pi-natives": "14.7.2",
-		"@oh-my-pi/pi-tui": "14.7.2",
-		"@oh-my-pi/pi-utils": "14.7.2",
+		"@oh-my-pi/omp-stats": "14.7.4",
+		"@oh-my-pi/pi-agent-core": "14.7.4",
+		"@oh-my-pi/pi-ai": "14.7.4",
+		"@oh-my-pi/pi-natives": "14.7.4",
+		"@oh-my-pi/pi-tui": "14.7.4",
+		"@oh-my-pi/pi-utils": "14.7.4",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@types/turndown": "5.0.6",

package/src/cli/read-cli.ts

@@ -15,7 +15,6 @@ import { renderError } from "../tools/tool-errors";
 
 export interface ReadCommandArgs {
 	path: string;
-	timeout?: number;
 }
 
 export async function runReadCommand(cmd: ReadCommandArgs): Promise<void> {
@@ -38,7 +37,7 @@ export async function runReadCommand(cmd: ReadCommandArgs): Promise<void> {
 	const tool = wrapToolWithMetaNotice(new ReadTool(session));
 
 	try {
-		const result = await tool.execute("omp-read", { path: cmd.path, timeout: cmd.timeout });
+		const result = await tool.execute("omp-read", { path: cmd.path });
 
 		for (const block of result.content) {
 			if (block.type === "text") {

package/src/commands/read.ts

@@ -1,7 +1,7 @@
 /**
  * Show what the read tool will return for a given path.
  */
-import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { Args, Command } from "@oh-my-pi/pi-utils/cli";
 import { type ReadCommandArgs, runReadCommand } from "../cli/read-cli";
 import { initTheme } from "../modes/theme/theme";
 
@@ -15,10 +15,6 @@ export default class Read extends Command {
 		}),
 	};
 
-	static flags = {
-		timeout: Flags.integer({ description: "Request timeout in seconds (URLs only)" }),
-	};
-
 	static examples = [
 		"omp read src/foo.ts",
 		"omp read src/foo.ts:50-100",
@@ -29,10 +25,9 @@ export default class Read extends Command {
 	];
 
 	async run(): Promise<void> {
-		const { args, flags } = await this.parse(Read);
+		const { args } = await this.parse(Read);
 		const cmd: ReadCommandArgs = {
 			path: args.path ?? "",
-			timeout: flags.timeout,
 		};
 		await initTheme();
 		await runReadCommand(cmd);

package/src/config/settings-schema.ts

@@ -1756,11 +1756,6 @@ export const SETTINGS_SCHEMA = {
 	},
 
 	// Optional tools
-	"notebook.enabled": {
-		type: "boolean",
-		default: true,
-		ui: { tab: "tools", label: "Notebook", description: "Enable the notebook tool for notebook editing" },
-	},
 
 	"renderMermaid.enabled": {
 		type: "boolean",

package/src/edit/modes/hashline.ts

@@ -52,6 +52,7 @@ import {
 	HL_HASH_CAPTURE_RE_RAW,
 } from "../line-hash";
 import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "../normalize";
+import { readEditFileText, serializeEditFileText } from "../read-file";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
 
 // ───────────────────────────────────────────────────────────────────────────
@@ -1547,7 +1548,7 @@ export function applyHashlineEdits(
 // but no header, we synthesize one from the caller-supplied `path` option.
 // ───────────────────────────────────────────────────────────────────────────
 
-interface HashlineInputSection {
+export interface HashlineInputSection {
 	path: string;
 	diff: string;
 }
@@ -1588,7 +1589,7 @@ function stripLeadingBlankLines(input: string): string {
 	return lines.join("\n");
 }
 
-function containsRecognizableHashlineOperations(input: string): boolean {
+export function containsRecognizableHashlineOperations(input: string): boolean {
 	for (const rawLine of input.split("\n")) {
 		const line = stripTrailingCarriageReturn(rawLine);
 		if (/^[+<=-]\s+/.test(line) || line.startsWith(HL_EDIT_SEP)) return true;
@@ -1656,30 +1657,27 @@ export function splitHashlineInputs(input: string, options: SplitHashlineOptions
 // 13. Diff computation (for streaming preview)
 // ───────────────────────────────────────────────────────────────────────────
 
-async function readHashlineFileText(file: { text(): Promise<string> }, pathText: string): Promise<string> {
+async function readHashlineFileText(
+	_file: { text(): Promise<string> },
+	absolutePath: string,
+	pathText: string,
+): Promise<string> {
 	try {
-		return await file.text();
+		return await readEditFileText(absolutePath, pathText);
 	} catch (error) {
-		if (isEnoent(error)) throw new Error(`File not found: ${pathText}`);
 		const message = error instanceof Error ? error.message : String(error);
 		throw new Error(message || `Unable to read ${pathText}`);
 	}
 }
 
-export async function computeHashlineDiff(
-	input: { input: string; path?: string },
+export async function computeHashlineSectionDiff(
+	section: HashlineInputSection,
 	cwd: string,
 	options: HashlineApplyOptions = {},
 ): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
 	try {
-		const sections = splitHashlineInputs(input.input, { cwd, path: input.path });
-		if (sections.length !== 1) {
-			return { error: "Streaming diff preview supports exactly one hashline section." };
-		}
-		const [section] = sections;
-
 		const absolutePath = resolveToCwd(section.path, cwd);
-		const rawContent = await readHashlineFileText(Bun.file(absolutePath), section.path);
+		const rawContent = await readHashlineFileText(Bun.file(absolutePath), absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
 		const result = applyHashlineEdits(normalized, parseHashline(section.diff), options);
@@ -1690,6 +1688,23 @@ export async function computeHashlineDiff(
 	}
 }
 
+export async function computeHashlineDiff(
+	input: { input: string; path?: string },
+	cwd: string,
+	options: HashlineApplyOptions = {},
+): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
+	let sections: HashlineInputSection[];
+	try {
+		sections = splitHashlineInputs(input.input, { cwd, path: input.path });
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+	if (sections.length !== 1) {
+		return { error: "Streaming diff preview supports exactly one hashline section." };
+	}
+	return computeHashlineSectionDiff(sections[0], cwd, options);
+}
+
 // ───────────────────────────────────────────────────────────────────────────
 // 14. Execution
 // ───────────────────────────────────────────────────────────────────────────
@@ -1699,11 +1714,13 @@ interface ReadHashlineFileResult {
 	rawContent: string;
 }
 
-async function readHashlineFile(absolutePath: string): Promise<ReadHashlineFileResult> {
+async function readHashlineFile(absolutePath: string, pathText: string): Promise<ReadHashlineFileResult> {
 	try {
-		return { exists: true, rawContent: await Bun.file(absolutePath).text() };
+		return { exists: true, rawContent: await readEditFileText(absolutePath, pathText) };
 	} catch (error) {
 		if (isEnoent(error)) return { exists: false, rawContent: "" };
+		if (error instanceof Error && error.message === `File not found: ${pathText}`)
+			return { exists: false, rawContent: "" };
 		throw error;
 	}
 }
@@ -1746,7 +1763,7 @@ async function preflightHashlineSection(options: ExecuteHashlineSingleOptions &
 	const { edits } = parseHashlineWithWarnings(diff);
 	enforcePlanModeWrite(session, sectionPath, { op: "update" });
 
-	const source = await readHashlineFile(absolutePath);
+	const source = await readHashlineFile(absolutePath, sectionPath);
 	if (!source.exists && hasAnchorScopedEdit(edits)) throw new Error(`File not found: ${sectionPath}`);
 	if (source.exists) assertEditableFileContent(source.rawContent, sectionPath);
 
@@ -1773,7 +1790,7 @@ async function executeHashlineSection(
 	const { edits, warnings: parseWarnings } = parseHashlineWithWarnings(diff);
 	enforcePlanModeWrite(session, sourcePath, { op: "update" });
 
-	const source = await readHashlineFile(absolutePath);
+	const source = await readHashlineFile(absolutePath, sourcePath);
 	if (!source.exists && hasAnchorScopedEdit(edits)) throw new Error(`File not found: ${sourcePath}`);
 	if (source.exists) assertEditableFileContent(source.rawContent, sourcePath);
 
@@ -1789,7 +1806,11 @@ async function executeHashlineSection(
 		};
 	}
 
-	const finalContent = bom + restoreLineEndings(result.lines, originalEnding);
+	const finalContent = await serializeEditFileText(
+		absolutePath,
+		sourcePath,
+		bom + restoreLineEndings(result.lines, originalEnding),
+	);
 	const diagnostics = await writethrough(
 		absolutePath,
 		finalContent,

package/src/edit/modes/patch.ts

@@ -44,6 +44,7 @@ import {
 	restoreLineEndings,
 	stripBom,
 } from "../normalize";
+import { readEditFileText, serializeEditFileText } from "../read-file";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
 import {
 	type ContextLineResult,
@@ -104,13 +105,13 @@ export const defaultFileSystem: FileSystem = {
 		return Bun.file(path).exists();
 	},
 	async read(path: string): Promise<string> {
-		return Bun.file(path).text();
+		return readEditFileText(path, path);
 	},
 	async readBinary(path: string): Promise<Uint8Array> {
 		return fs.promises.readFile(path);
 	},
 	async write(path: string, content: string): Promise<void> {
-		await Bun.write(path, content);
+		await Bun.write(path, await serializeEditFileText(path, path, content));
 	},
 	async delete(path: string): Promise<void> {
 		await fs.promises.unlink(path);
@@ -999,7 +1000,7 @@ async function readExistingPatchFile(fileSystem: FileSystem, absolutePath: strin
 	try {
 		return await fileSystem.read(absolutePath);
 	} catch (error) {
-		if (isEnoent(error)) {
+		if (isEnoent(error) || (error instanceof Error && error.message.startsWith("File not found:"))) {
 			throw new ApplyPatchError(`File not found: ${path}`);
 		}
 		throw error;
@@ -1637,7 +1638,7 @@ class LspFileSystem implements FileSystem {
 	}
 
 	async read(path: string): Promise<string> {
-		return this.#getFile(path).text();
+		return readEditFileText(path, path);
 	}
 
 	async readBinary(path: string): Promise<Uint8Array> {
@@ -1647,10 +1648,11 @@ class LspFileSystem implements FileSystem {
 
 	async write(path: string, content: string): Promise<void> {
 		const file = this.#getFile(path);
+		const finalContent = await serializeEditFileText(path, path, content);
 		const deferredForPath = this.deferredForPath;
 		const result = await this.writethrough(
 			path,
-			content,
+			finalContent,
 			this.signal,
 			file,
 			this.batchRequest,

package/src/edit/modes/replace.ts

@@ -21,7 +21,7 @@ import {
 	restoreLineEndings,
 	stripBom,
 } from "../normalize";
-import { readEditFileText } from "../read-file";
+import { readEditFileText, serializeEditFileText } from "../read-file";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
 
 export interface FuzzyMatch {
@@ -1065,7 +1065,11 @@ export async function executeReplaceSingle(
 		throw new Error(`Edits to ${path} resulted in no changes being made.`);
 	}
 
-	const finalContent = bom + restoreLineEndings(result.content, originalEnding);
+	const finalContent = await serializeEditFileText(
+		absolutePath,
+		path,
+		bom + restoreLineEndings(result.content, originalEnding),
+	);
 	const diagnostics = await writethrough(
 		absolutePath,
 		finalContent,

package/src/edit/notebook.ts

@@ -0,0 +1,222 @@
+import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+
+export type NotebookCellType = "code" | "markdown" | "raw";
+
+export interface NotebookCell {
+	cell_type: NotebookCellType;
+	source?: string | string[];
+	metadata?: Record<string, unknown>;
+	execution_count?: number | null;
+	outputs?: unknown[];
+	[key: string]: unknown;
+}
+
+export interface NotebookDocument {
+	cells: NotebookCell[];
+	metadata: Record<string, unknown>;
+	nbformat: number;
+	nbformat_minor: number;
+	[key: string]: unknown;
+}
+
+const CELL_MARKER_RE = /^# %% \[(code|markdown|raw)\](?: cell:(\d+))?$/;
+
+export function isNotebookPath(filePath: string): boolean {
+	return path.extname(filePath).toLowerCase() === ".ipynb";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isCellType(value: unknown): value is NotebookCellType {
+	return value === "code" || value === "markdown" || value === "raw";
+}
+
+function sourceToText(source: string | string[] | undefined): string {
+	if (source === undefined) return "";
+	if (typeof source === "string") return source;
+	return source.join("");
+}
+
+export function splitNotebookSource(content: string): string[] {
+	if (content.length === 0) return [];
+	return content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+}
+
+function cloneCell(cell: NotebookCell): NotebookCell {
+	return structuredClone(cell);
+}
+
+function createNotebookCell(cellType: NotebookCellType, source: string): NotebookCell {
+	const cell: NotebookCell = {
+		cell_type: cellType,
+		metadata: {},
+		source: splitNotebookSource(source),
+	};
+	if (cellType === "code") {
+		cell.execution_count = null;
+		cell.outputs = [];
+	}
+	return cell;
+}
+
+function createEmptyNotebook(): NotebookDocument {
+	return {
+		cells: [],
+		metadata: {},
+		nbformat: 4,
+		nbformat_minor: 5,
+	};
+}
+
+function validateNotebook(value: unknown, displayPath: string): NotebookDocument {
+	if (!isRecord(value)) {
+		throw new Error(`Invalid notebook structure (expected object): ${displayPath}`);
+	}
+	if (!Array.isArray(value.cells)) {
+		throw new Error(`Invalid notebook structure (missing cells array): ${displayPath}`);
+	}
+	for (let index = 0; index < value.cells.length; index++) {
+		const cell = value.cells[index];
+		if (!isRecord(cell) || !isCellType(cell.cell_type)) {
+			throw new Error(`Invalid notebook cell ${index} in ${displayPath}`);
+		}
+	}
+	return value as unknown as NotebookDocument;
+}
+
+export async function readNotebookDocument(absolutePath: string, displayPath: string): Promise<NotebookDocument> {
+	try {
+		return validateNotebook(await Bun.file(absolutePath).json(), displayPath);
+	} catch (error) {
+		if (isEnoent(error)) throw new Error(`File not found: ${displayPath}`);
+		if (error instanceof SyntaxError) throw new Error(`Invalid JSON in notebook: ${displayPath}`);
+		throw error;
+	}
+}
+
+export function notebookToEditableText(notebook: NotebookDocument): string {
+	return notebook.cells
+		.map((cell, index) => {
+			const source = sourceToText(cell.source);
+			return source.length > 0
+				? `# %% [${cell.cell_type}] cell:${index}\n${source}`
+				: `# %% [${cell.cell_type}] cell:${index}`;
+		})
+		.join("\n");
+}
+
+interface ParsedVirtualCell {
+	cellType: NotebookCellType;
+	cellIndex?: number;
+	source: string;
+}
+
+function parseVirtualCellMarker(line: string): { cellType: NotebookCellType; cellIndex?: number } | undefined {
+	const match = CELL_MARKER_RE.exec(line);
+	if (!match) return undefined;
+	const cellType = match[1] as NotebookCellType;
+	const cellIndexText = match[2];
+	return {
+		cellType,
+		cellIndex: cellIndexText === undefined ? undefined : Number.parseInt(cellIndexText, 10),
+	};
+}
+
+function linesToSourceText(lines: string[]): string {
+	if (lines.length === 0) return "";
+	return lines.join("\n");
+}
+
+function parseNotebookEditableText(text: string, displayPath: string): ParsedVirtualCell[] {
+	const lines = text.length === 0 ? [] : text.split("\n");
+	const cells: ParsedVirtualCell[] = [];
+	let current: { cellType: NotebookCellType; cellIndex?: number; lines: string[] } | undefined;
+
+	const flush = () => {
+		if (!current) return;
+		cells.push({
+			cellType: current.cellType,
+			cellIndex: current.cellIndex,
+			source: linesToSourceText(current.lines),
+		});
+	};
+
+	for (const line of lines) {
+		const marker = parseVirtualCellMarker(line);
+		if (marker) {
+			flush();
+			current = { ...marker, lines: [] };
+			continue;
+		}
+		if (!current) {
+			throw new Error(
+				`Invalid notebook editable representation for ${displayPath}: expected first line to be "# %% [code] cell:0", "# %% [markdown] cell:0", or "# %% [raw] cell:0".`,
+			);
+		}
+		current.lines.push(line);
+	}
+	flush();
+	return cells;
+}
+
+export function applyNotebookEditableText(
+	notebook: NotebookDocument,
+	text: string,
+	displayPath: string,
+): NotebookDocument {
+	const parsedCells = parseNotebookEditableText(text, displayPath);
+	const usedOriginalCells = new Set<number>();
+	const nextNotebook = structuredClone(notebook);
+	nextNotebook.cells = parsedCells.map(parsedCell => {
+		const originalIndex = parsedCell.cellIndex;
+		const originalCell =
+			originalIndex !== undefined &&
+			originalIndex >= 0 &&
+			originalIndex < notebook.cells.length &&
+			!usedOriginalCells.has(originalIndex)
+				? notebook.cells[originalIndex]
+				: undefined;
+		if (originalCell) {
+			usedOriginalCells.add(originalIndex!);
+			const cell = cloneCell(originalCell);
+			cell.cell_type = parsedCell.cellType;
+			cell.source = splitNotebookSource(parsedCell.source);
+			if (parsedCell.cellType === "code") {
+				cell.execution_count ??= null;
+				cell.outputs ??= [];
+			} else {
+				delete cell.execution_count;
+				delete cell.outputs;
+			}
+			return cell;
+		}
+		return createNotebookCell(parsedCell.cellType, parsedCell.source);
+	});
+	return nextNotebook;
+}
+
+export async function readEditableNotebookText(absolutePath: string, displayPath: string): Promise<string> {
+	return notebookToEditableText(await readNotebookDocument(absolutePath, displayPath));
+}
+
+export async function serializeEditedNotebookText(
+	absolutePath: string,
+	displayPath: string,
+	text: string,
+): Promise<string> {
+	let notebook: NotebookDocument;
+	try {
+		notebook = await readNotebookDocument(absolutePath, displayPath);
+	} catch (error) {
+		if (error instanceof Error && error.message === `File not found: ${displayPath}`) {
+			notebook = createEmptyNotebook();
+		} else {
+			throw error;
+		}
+	}
+	const nextNotebook = applyNotebookEditableText(notebook, text, displayPath);
+	return JSON.stringify(nextNotebook, null, 1);
+}

package/src/edit/read-file.ts

@@ -5,9 +5,11 @@
  * error referencing the display path.
  */
 import { isEnoent } from "@oh-my-pi/pi-utils";
+import { isNotebookPath, readEditableNotebookText, serializeEditedNotebookText } from "./notebook";
 
 export async function readEditFileText(absolutePath: string, path: string): Promise<string> {
 	try {
+		if (isNotebookPath(absolutePath)) return await readEditableNotebookText(absolutePath, path);
 		return await Bun.file(absolutePath).text();
 	} catch (error) {
 		if (isEnoent(error)) {
@@ -16,3 +18,8 @@ export async function readEditFileText(absolutePath: string, path: string): Prom
 		throw error;
 	}
 }
+
+export async function serializeEditFileText(absolutePath: string, path: string, content: string): Promise<string> {
+	if (isNotebookPath(absolutePath)) return serializeEditedNotebookText(absolutePath, path, content);
+	return content;
+}

package/src/edit/renderer.ts

@@ -251,11 +251,12 @@ function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, labe
 	const displayLines = lines.slice(-EDIT_STREAMING_PREVIEW_LINES);
 	const hidden = total - displayLines.length;
 	let text = "\n\n";
+	text += renderDiffColored(displayLines.join("\n"), { filePath: rawPath });
 	if (hidden > 0) {
-		text += uiTheme.fg("dim", `… (${hidden} earlier lines)\n`);
+		text += uiTheme.fg("dim", `\n… (${label} +${hidden} lines)`);
+	} else {
+		text += uiTheme.fg("dim", `\n(${label})`);
 	}
-	text += renderDiffColored(displayLines.join("\n"), { filePath: rawPath });
-	text += uiTheme.fg("dim", `\n… (${label})`);
 	return text;
 }
 

package/src/edit/streaming.ts

@@ -16,7 +16,13 @@ import type { Theme } from "../modes/theme/theme";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
 import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
-import { computeHashlineDiff } from "./modes/hashline";
+import {
+	computeHashlineDiff,
+	computeHashlineSectionDiff,
+	containsRecognizableHashlineOperations,
+	type HashlineInputSection,
+	splitHashlineInputs,
+} from "./modes/hashline";
 import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
 import type { ReplaceEditEntry } from "./modes/replace";
 
@@ -223,12 +229,48 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 	async computeDiffPreview(args, ctx) {
 		if (typeof args.input !== "string" || args.input.length === 0) return null;
 		ctx.signal.throwIfAborted();
-		const result = await computeHashlineDiff({ input: args.input, path: args.path }, ctx.cwd, {
-			autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
-		});
-		ctx.signal.throwIfAborted();
-		if ("error" in result && !args.path) return [{ path: "", error: result.error }];
-		return [toPerFilePreview(args.path ?? "", result)];
+
+		let sections: HashlineInputSection[];
+		try {
+			sections = splitHashlineInputs(args.input, { cwd: ctx.cwd, path: args.path });
+		} catch {
+			// Single-section fallback keeps the original error rendering for the
+			// "haven't typed `@PATH` yet" case.
+			const result = await computeHashlineDiff({ input: args.input, path: args.path }, ctx.cwd, {
+				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
+			});
+			ctx.signal.throwIfAborted();
+			if ("error" in result && !args.path) return [{ path: "", error: result.error }];
+			return [toPerFilePreview(args.path ?? "", result)];
+		}
+		if (sections.length === 0) return null;
+
+		// While the trailing section is still being typed (no operations yet)
+		// skip it so its empty/parse-error result doesn't replace previews of
+		// already-completed sections with an opaque header.
+		const lastIndex = sections.length - 1;
+		const trailingIncomplete =
+			sections.length > 1 && !containsRecognizableHashlineOperations(sections[lastIndex].diff);
+		const sectionsToProcess = trailingIncomplete ? sections.slice(0, -1) : sections;
+		const trailingProcessedIndex = sectionsToProcess.length - 1;
+
+		const previews: PerFileDiffPreview[] = [];
+		for (let i = 0; i < sectionsToProcess.length; i++) {
+			ctx.signal.throwIfAborted();
+			const section = sectionsToProcess[i];
+			const result = await computeHashlineSectionDiff(section, ctx.cwd, {
+				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
+			});
+			ctx.signal.throwIfAborted();
+			// In a multi-section preview, ignore parse/apply errors from the
+			// last section: it's still streaming and the partial op may not
+			// parse yet. Earlier sections are stable and stay rendered.
+			if (sectionsToProcess.length > 1 && i === trailingProcessedIndex && "error" in result) {
+				continue;
+			}
+			previews.push(toPerFilePreview(section.path, result));
+		}
+		return previews.length > 0 ? previews : null;
 	},
 	renderStreamingFallback() {
 		return "";