@oh-my-pi/pi-coding-agent 14.4.1 → 14.4.3

package/src/edit/modes/atom.ts

@@ -1,19 +1,20 @@
 /**
  *
  * Flat locator + verb edit mode backed by hashline anchors. Each entry carries
- * one shared `loc` selector plus one or more verbs (`pre`, `set`, `post`).
+ * one shared `loc` selector plus one or more verbs (`pre`, `splice`, `post`).
  * The runtime resolves those verbs into internal anchor-scoped edits and still
  * reuses hashline's staleness scheme (`computeLineHash`) verbatim.
  *
  * External shapes (one entry):
- *   { path, loc: "5th",      set:  ["..."] }
+ *   { path, loc: "5th",      splice:  ["..."] }
  *   { path, loc: "5th",      pre:  ["..."] }
  *   { path, loc: "5th",      post: ["..."] }
- *   { path, loc: "5th",      pre: [...], set: [...], post: [...] }
- *   { path, loc: "^",        pre:  [...] }                            // prepend to BOF
- *   { path, loc: "$",        post: [...] }                            // append to EOF
+ *   { path, loc: "5th",      pre: [...], splice: [...], post: [...] }
+ *   { path, loc: "$",        pre:  [...] }                            // prepend to file
+ *   { path, loc: "$",        post: [...] }                            // append to file
+ *   { path, loc: "$",        sed:  "s/foo/bar/" }                    // sed on every line
  *
- * `set: []` on a single-anchor locator deletes that line. `set:[""]` preserves
+ * `splice: []` on a single-anchor locator deletes that line. `splice:[""]` preserves
  * a blank line. Line ranges are not supported.
  * in the same entry.
  *
@@ -57,12 +58,11 @@ const textSchema = Type.Array(Type.String());
  */
 export const atomEditSchema = Type.Object(
 	{
-		path: Type.Optional(Type.String({ description: "file path override", examples: ["src/foo.ts"] })),
 		loc: Type.String({
-			description: 'edit location: "1ab", "^", "$", or path override like "a.ts:1ab"',
-			examples: ["1ab", "^", "$", "src/foo.ts:1ab"],
+			description: 'edit location: "1ab", "$", or path override like "a.ts:1ab"',
+			examples: ["1ab", "$", "src/foo.ts:1ab"],
 		}),
-		set: Type.Optional(textSchema),
+		splice: Type.Optional(textSchema),
 		pre: Type.Optional(textSchema),
 		post: Type.Optional(textSchema),
 		sed: Type.Optional(
@@ -91,13 +91,14 @@ export type AtomParams = Static<typeof atomEditParamsSchema>;
 // ═══════════════════════════════════════════════════════════════════════════
 
 export type AtomEdit =
-	| { op: "set"; pos: Anchor; lines: string[] }
+	| { op: "splice"; pos: Anchor; lines: string[] }
 	| { op: "pre"; pos: Anchor; lines: string[] }
 	| { op: "post"; pos: Anchor; lines: string[] }
 	| { op: "del"; pos: Anchor }
 	| { op: "append_file"; lines: string[] }
 	| { op: "prepend_file"; lines: string[] }
-	| { op: "sed"; pos: Anchor; spec: SedSpec; expression: string };
+	| { op: "sed"; pos: Anchor; spec: SedSpec; expression: string }
+	| { op: "sed_file"; spec: SedSpec; expression: string };
 
 export interface SedSpec {
 	pattern: string;
@@ -111,9 +112,9 @@ export interface SedSpec {
 // Param guards
 // ═══════════════════════════════════════════════════════════════════════════
 
-const ATOM_VERB_KEYS = ["set", "pre", "post", "sed"] as const;
-type AtomOptionalKey = "path" | "loc" | (typeof ATOM_VERB_KEYS)[number];
-const ATOM_OPTIONAL_KEYS = ["path", "loc", ...ATOM_VERB_KEYS] as const satisfies readonly AtomOptionalKey[];
+const ATOM_VERB_KEYS = ["splice", "pre", "post", "sed"] as const;
+type AtomOptionalKey = "loc" | (typeof ATOM_VERB_KEYS)[number];
+const ATOM_OPTIONAL_KEYS = ["loc", ...ATOM_VERB_KEYS] as const satisfies readonly AtomOptionalKey[];
 
 // Matches just the LINE+BIGRAM prefix of an anchor reference. Used to detect
 // optional `|content` suffixes (e.g. `82zu|  for (...)`) so the suffix can be
@@ -141,7 +142,7 @@ function stripNullAtomFields(edit: AtomToolEdit): AtomToolEdit {
 	return (next ?? fields) as AtomToolEdit;
 }
 
-type ParsedAtomLoc = { kind: "anchor"; pos: Anchor } | { kind: "bof" } | { kind: "eof" };
+type ParsedAtomLoc = { kind: "anchor"; pos: Anchor } | { kind: "file" };
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Resolution
@@ -203,10 +204,10 @@ function resolveAtomEntryPath(
 			loc = split[2]!;
 		}
 	}
-	const path = pathOverride || entry.path || topLevelPath;
+	const path = pathOverride || topLevelPath;
 	if (!path) {
 		throw new Error(
-			`Edit ${editIndex}: missing path. Provide a top-level path, per-entry path, or prefix loc with a file path (for example "a.ts:160sr").`,
+			`Edit ${editIndex}: missing path. Provide a top-level path or prefix loc with a file path (for example "a.ts:160sr").`,
 		);
 	}
 	return { ...entry, path, ...(loc !== entry.loc ? { loc } : {}) };
@@ -220,8 +221,7 @@ export function resolveAtomEntryPaths(
 }
 
 function parseLoc(raw: string, editIndex: number): ParsedAtomLoc {
-	if (raw === "^") return { kind: "bof" };
-	if (raw === "$") return { kind: "eof" };
+	if (raw === "$") return { kind: "file" };
 	// Detect range syntax explicitly: "<anchor>-<anchor>". A bare `-` inside the
 	// loc (e.g. line content like `i--`) should not trigger the range error.
 	const dash = raw.indexOf("-");
@@ -230,7 +230,7 @@ function parseLoc(raw: string, editIndex: number): ParsedAtomLoc {
 		const right = raw.slice(dash + 1);
 		if (tryParseAtomTag(left) !== undefined && tryParseAtomTag(right) !== undefined) {
 			throw new Error(
-				`Edit ${editIndex}: atom loc does not support line ranges. Use a single anchor like "160sr", "^", or "$".`,
+				`Edit ${editIndex}: atom loc does not support line ranges. Use a single anchor like "160sr" or "$".`,
 			);
 		}
 	}
@@ -387,57 +387,54 @@ function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0): AtomEdit[] {
 		);
 	}
 	if (typeof entry.loc !== "string") {
-		throw new Error(`Edit ${editIndex}: missing loc. Use a selector like "160sr", "^", or "$".`);
+		throw new Error(`Edit ${editIndex}: missing loc. Use a selector like "160sr" or "$".`);
 	}
 
 	const loc = parseLoc(entry.loc, editIndex);
 	const resolved: AtomEdit[] = [];
 
-	if (loc.kind === "bof") {
-		if (entry.set !== undefined || entry.post !== undefined || entry.sed !== undefined) {
-			throw new Error(`Edit ${editIndex}: loc "^" only supports pre.`);
+	if (loc.kind === "file") {
+		if (entry.splice !== undefined) {
+			throw new Error(`Edit ${editIndex}: loc "$" supports pre, post, and sed (not splice).`);
 		}
 		if (entry.pre !== undefined) {
 			resolved.push({ op: "prepend_file", lines: hashlineParseText(entry.pre) });
 		}
-		return resolved;
-	}
-
-	if (loc.kind === "eof") {
-		if (entry.set !== undefined || entry.pre !== undefined || entry.sed !== undefined) {
-			throw new Error(`Edit ${editIndex}: loc "$" only supports post.`);
-		}
 		if (entry.post !== undefined) {
 			resolved.push({ op: "append_file", lines: hashlineParseText(entry.post) });
 		}
+		if (entry.sed !== undefined) {
+			const spec = parseSedExpression(entry.sed, editIndex);
+			resolved.push({ op: "sed_file", spec, expression: entry.sed });
+		}
 		return resolved;
 	}
 
 	if (entry.pre !== undefined) {
 		resolved.push({ op: "pre", pos: loc.pos, lines: hashlineParseText(entry.pre) });
 	}
-	if (entry.set !== undefined) {
-		if (Array.isArray(entry.set) && entry.set.length === 0) {
-			// Models often default `set: []` alongside other verbs (notably `sed`).
+	if (entry.splice !== undefined) {
+		if (Array.isArray(entry.splice) && entry.splice.length === 0) {
+			// Models often default `splice: []` alongside other verbs (notably `sed`).
 			// Treating that combination as an explicit `del` produces a confusing
 			// `Conflicting ops` error. When another mutating verb is present, drop
-			// the empty `set` instead of treating it as a deletion.
+			// the empty `splice` instead of treating it as a deletion.
 			if (entry.sed === undefined) {
 				resolved.push({ op: "del", pos: loc.pos });
 			}
 		} else {
-			resolved.push({ op: "set", pos: loc.pos, lines: hashlineParseText(entry.set) });
+			resolved.push({ op: "splice", pos: loc.pos, lines: hashlineParseText(entry.splice) });
 		}
 	}
 	if (entry.post !== undefined) {
 		resolved.push({ op: "post", pos: loc.pos, lines: hashlineParseText(entry.post) });
 	}
 	if (entry.sed !== undefined) {
-		const setIsExplicitReplacement = Array.isArray(entry.set) && entry.set.length > 0;
-		// Models often duplicate intent by sending both an explicit `set` and a
+		const spliceIsExplicitReplacement = Array.isArray(entry.splice) && entry.splice.length > 0;
+		// Models often duplicate intent by sending both an explicit `splice` and a
 		// matching `sed`. The explicit replacement wins; the redundant `sed` would
 		// otherwise trigger a confusing `Conflicting ops` rejection.
-		if (!setIsExplicitReplacement) {
+		if (!spliceIsExplicitReplacement) {
 			const spec = parseSedExpression(entry.sed, editIndex);
 			resolved.push({ op: "sed", pos: loc.pos, spec, expression: entry.sed });
 		}
@@ -451,7 +448,7 @@ function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0): AtomEdit[] {
 
 function* getAtomAnchors(edit: AtomEdit): Iterable<Anchor> {
 	switch (edit.op) {
-		case "set":
+		case "splice":
 		case "pre":
 		case "post":
 		case "del":
@@ -527,16 +524,16 @@ function validateAtomAnchors(edits: AtomEdit[], fileLines: string[], warnings: s
 }
 
 function validateNoConflictingAnchorOps(edits: AtomEdit[]): void {
-	// For each anchor line, at most one mutating op (set/del).
+	// For each anchor line, at most one mutating op (splice/del).
 	// `pre`/`post` (insert ops) may coexist with them — they don't mutate the anchor line.
 	const mutatingPerLine = new Map<number, string>();
 	for (const edit of edits) {
-		if (edit.op !== "set" && edit.op !== "del" && edit.op !== "sed") continue;
+		if (edit.op !== "splice" && edit.op !== "del" && edit.op !== "sed") continue;
 		const existing = mutatingPerLine.get(edit.pos.line);
 		if (existing) {
 			throw new Error(
 				`Conflicting ops on anchor line ${edit.pos.line}: \`${existing}\` and \`${edit.op}\`. ` +
-					`At most one of set/del/sed is allowed per anchor.`,
+					`At most one of splice/del/sed is allowed per anchor.`,
 			);
 		}
 		mutatingPerLine.set(edit.pos.line, edit.op);
@@ -551,7 +548,7 @@ function maybeAutocorrectEscapedTabIndentation(edits: AtomEdit[], warnings: stri
 	const enabled = Bun.env.PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS !== "0";
 	if (!enabled) return;
 	for (const edit of edits) {
-		if (edit.op !== "set" && edit.op !== "pre" && edit.op !== "post") continue;
+		if (edit.op !== "splice" && edit.op !== "pre" && edit.op !== "post") continue;
 		if (edit.lines.length === 0) continue;
 		const hasEscapedTabs = edit.lines.some(line => line.includes("\\t"));
 		if (!hasEscapedTabs) continue;
@@ -614,13 +611,15 @@ export function applyAtomEdits(
 	// captured idx so multiple pre/post on the same target are emitted in the order
 	// the model produced them.
 	type Indexed<T> = { edit: T; idx: number };
-	type AnchorEdit = Exclude<AtomEdit, { op: "append_file" } | { op: "prepend_file" }>;
+	type AnchorEdit = Exclude<AtomEdit, { op: "append_file" } | { op: "prepend_file" } | { op: "sed_file" }>;
 	const anchorEdits: Indexed<AnchorEdit>[] = [];
 	const appendEdits: Indexed<Extract<AtomEdit, { op: "append_file" }>>[] = [];
+	const sedFileEdits: Indexed<Extract<AtomEdit, { op: "sed_file" }>>[] = [];
 	const prependEdits: Indexed<Extract<AtomEdit, { op: "prepend_file" }>>[] = [];
 	edits.forEach((edit, idx) => {
 		if (edit.op === "append_file") appendEdits.push({ edit, idx });
 		else if (edit.op === "prepend_file") prependEdits.push({ edit, idx });
+		else if (edit.op === "sed_file") sedFileEdits.push({ edit, idx });
 		else anchorEdits.push({ edit, idx });
 	});
 
@@ -667,7 +666,7 @@ export function applyAtomEdits(
 					replacementSet = true;
 					anchorDeleted = true;
 					break;
-				case "set":
+				case "splice":
 					replacement = edit.lines.length === 0 ? [""] : [...edit.lines];
 					replacementSet = true;
 					anchorMutated = true;
@@ -759,6 +758,42 @@ export function applyAtomEdits(
 		trackFirstChanged(insertIdx + 1);
 	}
 
+	// Apply sed_file ops last so they observe the post-anchor / post-prepend /
+	// post-append state of the file. Each op runs across every content line and
+	let warnedLiteralFallback = false;
+	sedFileEdits.sort((a, b) => a.idx - b.idx);
+	for (const { edit } of sedFileEdits) {
+		const hasTrailingNewline = fileLines.length > 1 && fileLines[fileLines.length - 1] === "";
+		const upper = hasTrailingNewline ? fileLines.length - 1 : fileLines.length;
+		let anyMatched = false;
+		let lastCompileError: string | undefined;
+		for (let i = 0; i < upper; i++) {
+			const line = fileLines[i] ?? "";
+			const r = applySedToLine(line, edit.spec);
+			if (r.error) lastCompileError = r.error;
+			if (!r.matched) continue;
+			anyMatched = true;
+			if (r.literalFallback && !warnedLiteralFallback) {
+				warnings.push(
+					`sed expression ${JSON.stringify(edit.expression)} did not match as a regex; applied literal substring substitution. Use the \`F\` flag (e.g. \`s/.../.../F\`) for literal patterns or escape regex metacharacters.`,
+				);
+				warnedLiteralFallback = true;
+			}
+			if (r.result !== line) {
+				fileLines[i] = r.result;
+				trackFirstChanged(i + 1);
+			}
+		}
+		if (!anyMatched) {
+			if (lastCompileError !== undefined) {
+				throw new Error(
+					`Edit sed expression ${JSON.stringify(edit.expression)} failed to compile: ${lastCompileError}`,
+				);
+			}
+			throw new Error(`Edit sed expression ${JSON.stringify(edit.expression)} did not match any line in the file.`);
+		}
+	}
+
 	return {
 		lines: fileLines.join("\n"),
 		firstChangedLine,

package/src/edit/modes/hashline.ts

@@ -59,7 +59,7 @@ const HASHLINE_PREFIX_PLUS_RE = new RegExp(
 	`^\\s*(?:>>>|>>)?\\s*\\+\\s*\\d+${HASHLINE_BIGRAM_RE_SRC}${HASHLINE_CONTENT_SEPARATOR_RE}`,
 );
 const DIFF_PLUS_RE = /^[+](?![+])/;
-const READ_TRUNCATION_NOTICE_RE = /^\[(?:Showing lines \d+-\d+ of \d+|\d+ more lines? in (?:file|\S+))\b.*\bsel=L\d+/;
+const READ_TRUNCATION_NOTICE_RE = /^\[(?:Showing lines \d+-\d+ of \d+|\d+ more lines? in (?:file|\S+))\b.*\bsel=L?\d+/;
 
 type LinePrefixStats = {
 	nonEmpty: number;
@@ -525,7 +525,7 @@ const MISMATCH_CONTEXT = 2;
 /**
  * Error thrown when one or more hashline references have stale hashes.
  *
- * Displays grep-style output with `>` separator on mismatched lines and `:` on
+ * Displays grep-style output with `*` marker on mismatched lines and a leading space on
  * surrounding context, showing the correct `LINE+ID` so the caller can fix all refs at once.
  */
 export class HashlineMismatchError extends Error {
@@ -604,7 +604,7 @@ export class HashlineMismatchError extends Error {
 
 		lines.push(
 			`Edit rejected: ${mismatches.length} line${mismatches.length > 1 ? "s have" : " has"} changed since the last read. The edit was NOT applied.`,
-			"Use the updated anchors shown below (`>` marks changed lines, `:` marks context) and retry the edit.",
+			"Use the updated anchors shown below (`*` marks changed lines, leading space marks context) and retry the edit.",
 		);
 		lines.push("");
 
@@ -621,9 +621,9 @@ export class HashlineMismatchError extends Error {
 			const prefix = `${lineNum}${hash}`;
 
 			if (mismatchSet.has(lineNum)) {
-				lines.push(`${prefix}>${text}`);
+				lines.push(`*${prefix}|${text}`);
 			} else {
-				lines.push(`${prefix}:${text}`);
+				lines.push(` ${prefix}|${text}`);
 			}
 		}
 		return lines.join("\n");
@@ -1060,7 +1060,6 @@ export interface CompactHashlineDiffPreview {
 
 export interface CompactHashlineDiffOptions {
 	maxUnchangedRun?: number;
-	maxAdditionRun?: number;
 	maxDeletionRun?: number;
 	maxOutputLines?: number;
 }
@@ -1216,7 +1215,6 @@ export function buildCompactHashlineDiffPreview(
 	options: CompactHashlineDiffOptions = {},
 ): CompactHashlineDiffPreview {
 	const maxUnchangedRun = options.maxUnchangedRun ?? 2;
-	const maxAdditionRun = options.maxAdditionRun ?? 2;
 	const maxDeletionRun = options.maxDeletionRun ?? 2;
 	const maxOutputLines = options.maxOutputLines ?? 16;
 
@@ -1235,7 +1233,7 @@ export function buildCompactHashlineDiffPreview(
 				break;
 			case "+":
 				addedLines += run.lines.length;
-				out.push(...collapseFromStart(run.lines, maxAdditionRun, "added"));
+				out.push(...run.lines);
 				break;
 			case "-":
 				removedLines += run.lines.length;

package/src/edit/renderer.ts

@@ -94,7 +94,7 @@ interface EditRenderArgs {
 	 */
 	previewDiff?: string;
 	__partialJson?: string;
-	// Hashline / chunk mode fields
+	// Hashline mode fields
 	edits?: EditRenderEntry[];
 }
 
@@ -141,7 +141,7 @@ export interface EditRenderContext {
 	editMode?: EditMode;
 	/** Pre-computed diff preview (computed before tool executes) */
 	editDiffPreview?: DiffResult | DiffError;
-	/** Multi-file streaming diff preview (chunk edits spanning several files) */
+	/** Multi-file streaming diff preview (edits spanning several files) */
 	perFileDiffPreview?: PerFileDiffPreview[];
 	/** Function to render diff text with syntax highlighting */
 	renderDiff?: (diffText: string, options?: { filePath?: string }) => string;
@@ -151,11 +151,9 @@ const EDIT_STREAMING_PREVIEW_LINES = 12;
 const CALL_TEXT_PREVIEW_LINES = 6;
 const CALL_TEXT_PREVIEW_WIDTH = 80;
 
-/** Extract file path from an edit entry's path (handles chunk's file:selector format). */
+/** Extract file path from an edit entry. */
 function filePathFromEditEntry(p: string | undefined): string | undefined {
-	if (!p) return undefined;
-	const ci = /^[a-zA-Z]:[/\\]/.test(p) ? p.indexOf(":", 2) : p.indexOf(":");
-	return ci === -1 ? p : p.slice(0, ci);
+	return p ?? undefined;
 }
 
 function decodePartialJsonStringFragment(fragment: string): string {
@@ -284,7 +282,7 @@ function formatMultiFileStreamingDiff(previews: PerFileDiffPreview[], uiTheme: T
 	const parts: string[] = [];
 	for (const preview of previews) {
 		if (!preview.diff && !preview.error) continue;
-		const header = uiTheme.fg("dim", `\n\n── ${shortenPath(preview.path)} ──`);
+		const header = uiTheme.fg("dim", `\n\n\u2500\u2500 ${shortenPath(preview.path)} \u2500\u2500`);
 		if (preview.error) {
 			parts.push(`${header}\n${uiTheme.fg("error", replaceTabs(preview.error))}`);
 			continue;
@@ -303,7 +301,7 @@ function getCallPreview(
 	renderContext: EditRenderContext | undefined,
 ): string {
 	const multi = renderContext?.perFileDiffPreview;
-	if (multi && multi.length > 0 && multi.some(p => p.diff || p.error)) {
+	if (multi && multi.length > 1 && multi.some(p => p.diff || p.error)) {
 		return formatMultiFileStreamingDiff(multi, uiTheme);
 	}
 	if (args.previewDiff) {

package/src/edit/streaming.ts

@@ -16,7 +16,6 @@ import type { Theme } from "../modes/theme/theme";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
 import { expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
-import { type ChunkToolEdit, computeChunkDiff, parseChunkEditPath } from "./modes/chunk";
 import { computeHashlineDiff, type HashlineToolEdit } from "./modes/hashline";
 import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
 import type { ReplaceEditEntry } from "./modes/replace";
@@ -126,6 +125,38 @@ export function dropIncompleteLastEdit<T>(edits: readonly T[], partialJson: stri
 	return [...edits];
 }
 
+// -----------------------------------------------------------------------------
+// Multi-file grouping
+// -----------------------------------------------------------------------------
+
+/** Cap on how many distinct files a streaming preview will render diffs for. */
+const MAX_PREVIEW_FILES = 5;
+
+/**
+ * Group a list of edits by their effective `path` (per-edit `path` falls back
+ * to the top-level `args.path`). Insertion order is preserved and the number of
+ * distinct buckets is capped at {@link MAX_PREVIEW_FILES}.
+ */
+function groupEditsByPath<T extends { path?: string }>(
+	edits: readonly T[],
+	fallbackPath: string | undefined,
+): Map<string, Array<T & { path: string }>> {
+	const groups = new Map<string, Array<T & { path: string }>>();
+	for (const edit of edits) {
+		if (!edit) continue;
+		const editPath = edit.path ?? fallbackPath;
+		if (!editPath) continue;
+		let bucket = groups.get(editPath);
+		if (!bucket) {
+			if (groups.size >= MAX_PREVIEW_FILES) continue;
+			bucket = [];
+			groups.set(editPath, bucket);
+		}
+		bucket.push({ ...edit, path: editPath });
+	}
+	return groups;
+}
+
 // -----------------------------------------------------------------------------
 // Strategies
 // -----------------------------------------------------------------------------
@@ -142,22 +173,26 @@ const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 		return { ...args, edits: dropIncompleteLastEdit(args.edits, partialJson, "edits") };
 	},
 	async computeDiffPreview(args, ctx) {
-		const first = args.edits?.[0];
-		if (!first) return null;
-		const path = first.path ?? args.path;
-		if (!path || first.old_text === undefined || first.new_text === undefined) return null;
-		ctx.signal.throwIfAborted();
-		const result = await computeEditDiff(
-			path,
-			first.old_text,
-			first.new_text,
-			ctx.cwd,
-			ctx.allowFuzzy ?? true,
-			first.all,
-			ctx.fuzzyThreshold,
-		);
-		ctx.signal.throwIfAborted();
-		return [toPerFilePreview(path, result)];
+		const groups = groupEditsByPath(args.edits ?? [], args.path);
+		if (groups.size === 0) return null;
+		const previews: PerFileDiffPreview[] = [];
+		for (const [path, fileEdits] of groups) {
+			const first = fileEdits[0];
+			if (!first || first.old_text === undefined || first.new_text === undefined) continue;
+			ctx.signal.throwIfAborted();
+			const result = await computeEditDiff(
+				path,
+				first.old_text,
+				first.new_text,
+				ctx.cwd,
+				ctx.allowFuzzy ?? true,
+				first.all,
+				ctx.fuzzyThreshold,
+			);
+			ctx.signal.throwIfAborted();
+			previews.push(toPerFilePreview(path, result));
+		}
+		return previews.length > 0 ? previews : null;
 	},
 	renderStreamingFallback() {
 		return "";
@@ -176,17 +211,22 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 		return { ...args, edits: dropIncompleteLastEdit(args.edits, partialJson, "edits") };
 	},
 	async computeDiffPreview(args, ctx) {
-		const first = args.edits?.[0];
-		const path = first?.path ?? args.path;
-		if (!path) return null;
-		ctx.signal.throwIfAborted();
-		const result = await computePatchDiff(
-			{ path, op: first?.op ?? "update", rename: first?.rename, diff: first?.diff },
-			ctx.cwd,
-			{ fuzzyThreshold: ctx.fuzzyThreshold, allowFuzzy: ctx.allowFuzzy },
-		);
-		ctx.signal.throwIfAborted();
-		return [toPerFilePreview(path, result)];
+		const groups = groupEditsByPath(args.edits ?? [], args.path);
+		if (groups.size === 0) return null;
+		const previews: PerFileDiffPreview[] = [];
+		for (const [path, fileEdits] of groups) {
+			const first = fileEdits[0];
+			if (!first) continue;
+			ctx.signal.throwIfAborted();
+			const result = await computePatchDiff(
+				{ path, op: first.op ?? "update", rename: first.rename, diff: first.diff },
+				ctx.cwd,
+				{ fuzzyThreshold: ctx.fuzzyThreshold, allowFuzzy: ctx.allowFuzzy },
+			);
+			ctx.signal.throwIfAborted();
+			previews.push(toPerFilePreview(path, result));
+		}
+		return previews.length > 0 ? previews : null;
 	},
 	renderStreamingFallback() {
 		return "";
@@ -205,83 +245,14 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		return { ...args, edits: dropIncompleteLastEdit(args.edits, partialJson, "edits") };
 	},
 	async computeDiffPreview(args, ctx) {
-		const first = args.edits?.[0] as (HashlineToolEdit & { path?: string }) | undefined;
-		const path = first?.path ?? args.path;
-		if (!path) return null;
-		const fileEdits = (args.edits ?? [])
-			.map(e => {
-				if (!e || typeof e !== "object") return undefined;
-				const entryPath = (e as { path?: string }).path ?? args.path;
-				if (!entryPath || entryPath !== path) return undefined;
-				return { ...(e as HashlineToolEdit), path } as HashlineToolEdit & { path: string };
-			})
-			.filter((e): e is HashlineToolEdit & { path: string } => e !== undefined);
-		ctx.signal.throwIfAborted();
-		const result = await computeHashlineDiff({ path, edits: fileEdits }, ctx.cwd);
-		ctx.signal.throwIfAborted();
-		return [toPerFilePreview(path, result)];
-	},
-	renderStreamingFallback() {
-		return "";
-	},
-};
-
-interface ChunkArgs {
-	path?: string;
-	edits?: ChunkToolEdit[];
-	__partialJson?: string;
-}
-
-const chunkStrategy: EditStreamingStrategy<ChunkArgs> = {
-	extractCompleteEdits(args, partialJson) {
-		if (!args?.edits) return args;
-		let edits = dropIncompleteLastEdit(args.edits, partialJson, "edits");
-		// Extra guard: if partial JSON still contains `":nu` / `":nul` (partial
-		// `null` literals), `partial-json` may have already surfaced the last
-		// entry with `write === null`. When that entry's `}` hasn't closed
-		// yet, it has already been dropped above. But if dropping was not
-		// triggered (e.g. list still open and no new `{` after), also drop the
-		// trailing null-write entry so the preview does not flicker with an
-		// error for an incomplete string/null literal.
-		if (partialJson && edits.length > 0) {
-			const last = edits[edits.length - 1] as Partial<ChunkToolEdit> | undefined;
-			const endsInPartialNull = /:\s*nu?l?\s*$/.test(partialJson.trimEnd());
-			if (last && endsInPartialNull && last.write === null) {
-				edits = edits.slice(0, -1);
-			}
-		}
-		return { ...args, edits };
-	},
-	async computeDiffPreview(args, ctx) {
-		const edits = args.edits ?? [];
-		if (edits.length === 0) return null;
-		// Group edits by file path
-		const groups = new Map<string, ChunkToolEdit[]>();
-		const fileOrder: string[] = [];
-		for (const edit of edits) {
-			if (!edit) continue;
-			const editPath = edit.path ?? args.path;
-			if (!editPath) continue;
-			const { filePath } = parseChunkEditPath(editPath);
-			if (!filePath) continue;
-			let bucket = groups.get(filePath);
-			if (!bucket) {
-				bucket = [];
-				groups.set(filePath, bucket);
-				fileOrder.push(filePath);
-			}
-			bucket.push({ ...edit, path: editPath });
-		}
-		if (fileOrder.length === 0) return null;
-
-		const MAX_FILES = 5;
-		const selected = fileOrder.slice(0, MAX_FILES);
+		const groups = groupEditsByPath(args.edits ?? [], args.path);
+		if (groups.size === 0) return null;
 		const previews: PerFileDiffPreview[] = [];
-		for (const filePath of selected) {
+		for (const [path, fileEdits] of groups) {
 			ctx.signal.throwIfAborted();
-			const fileEdits = groups.get(filePath) ?? [];
-			const result = await computeChunkDiff({ path: filePath, edits: fileEdits }, ctx.cwd, { signal: ctx.signal });
-			previews.push(toPerFilePreview(filePath, result));
+			const result = await computeHashlineDiff({ path, edits: fileEdits }, ctx.cwd);
+			ctx.signal.throwIfAborted();
+			previews.push(toPerFilePreview(path, result));
 		}
 		return previews;
 	},
@@ -311,16 +282,22 @@ const applyPatchStrategy: EditStreamingStrategy<ApplyPatchArgs> = {
 				return [{ path: "", error: err instanceof Error ? err.message : String(err) }];
 			}
 		}
-		const first = entries[0];
-		if (!first?.path) return null;
-		ctx.signal.throwIfAborted();
-		const result = await computePatchDiff(
-			{ path: first.path, op: first.op ?? "update", rename: first.rename, diff: first.diff },
-			ctx.cwd,
-			{ fuzzyThreshold: ctx.fuzzyThreshold, allowFuzzy: ctx.allowFuzzy },
-		);
-		ctx.signal.throwIfAborted();
-		return [toPerFilePreview(first.path, result)];
+		const groups = groupEditsByPath(entries, undefined);
+		if (groups.size === 0) return null;
+		const previews: PerFileDiffPreview[] = [];
+		for (const [path, fileEntries] of groups) {
+			const first = fileEntries[0];
+			if (!first) continue;
+			ctx.signal.throwIfAborted();
+			const result = await computePatchDiff(
+				{ path, op: first.op ?? "update", rename: first.rename, diff: first.diff },
+				ctx.cwd,
+				{ fuzzyThreshold: ctx.fuzzyThreshold, allowFuzzy: ctx.allowFuzzy },
+			);
+			ctx.signal.throwIfAborted();
+			previews.push(toPerFilePreview(path, result));
+		}
+		return previews.length > 0 ? previews : null;
 	},
 	renderStreamingFallback() {
 		return "";
@@ -365,7 +342,6 @@ export const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknow
 	replace: replaceStrategy as EditStreamingStrategy<unknown>,
 	patch: patchStrategy as EditStreamingStrategy<unknown>,
 	hashline: hashlineStrategy as EditStreamingStrategy<unknown>,
-	chunk: chunkStrategy as EditStreamingStrategy<unknown>,
 	apply_patch: applyPatchStrategy as EditStreamingStrategy<unknown>,
 	vim: vimStrategy,
 	atom: atomStrategy as EditStreamingStrategy<unknown>,