@oh-my-pi/pi-coding-agent 14.5.3 → 14.5.6

package/CHANGELOG.md

@@ -2,6 +2,55 @@
 
 ## [Unreleased]
 
+## [14.5.6] - 2026-04-29
+### Changed
+
+- Removed the atom edit mode's multi-anchor auto-rebase rejection so stale-but-uniquely-rebasable block edits apply with warnings instead of failing.
+
+## [14.5.5] - 2026-04-29
+### Breaking Changes
+
+- Rejected atom diffs with unrecognized operations (including lone '-' lines) by throwing parse errors instead of treating them as inserts
+
+### Added
+
+- Added duplicate-line post-edit detection that warns on newly introduced adjacent identical lines and auto-removes one duplicate when bracket-balance is restored
+- Added a warning when suspicious adjacent duplicates are introduced after edits so users can review potential stale-line issues
+
+### Changed
+
+- Changed anchor rebase handling to fail when multiple mutating anchors would need auto-rebase, preventing silent misapplied contiguous block rewrites
+
+### Fixed
+
+- Fixed bracket-corruption caused by botched block rewrites by automatically removing a newly introduced duplicate adjacent line when removing it restores the original `{}`, `()`, and `[]` balance and by warning when automatic removal is unsafe
+
+## [14.5.4] - 2026-04-28
+### Breaking Changes
+
+- Changed the `atom` edit mode from JSON `{ path, edits }` calls to the compact file-oriented `input` patch language that was previously exposed as `atomd`; `atomd` is no longer a separate edit variant
+- Renamed MCP tool identifiers from the `mcp_<server>_<tool>` format to `mcp__<server>_<tool>` so custom tool names, active tool lists, and persisted MCP selections must be updated to the new prefix
+- Renamed the built-in content-search tool from `grep` to `search`, including SDK/tool event names and settings keys (`search.enabled`, `search.contextBefore`, `search.contextAfter`), so integrations using `grep` and `grep.*` references must be updated
+
+### Added
+
+- Added internal URL support to the `search` tool, allowing `artifact://`-style paths that resolve to local files to be searched directly
+- Added IRC relay observation in the main agent UI so every IRC exchange between agents is rendered in the main transcript, even when the main agent is not a direct participant
+- Added stateful `href`/`hrefr` prompt helpers that can reuse anchors remembered from prior `hline` helper calls
+
+### Changed
+
+- Changed file-path rendering across search, find, AST, LSP, and related edit outputs to display targets as cwd-relative paths when they resolve inside the working directory and keep absolute paths for files outside the cwd
+- Changed system prompt guidance so in-cwd tool paths must be passed as cwd-relative paths and absolute paths only for out-of-cwd targets or `~` expansion
+- Updated `edit` streaming diff previews for `patch`, `replace`, and `hashline` to produce a single request-level preview for the new single-file `path` mode
+- Bumped default `read.defaultLimit` from 300 to 500 lines, and scaled the read tool's byte budget with the line limit (`max(50KB, lines * 512)`) so the configured line count is no longer truncated by the shared 50KB cap
+
+### Fixed
+
+- Fixed atom edit streaming previews to use atom headers for file names instead of apply_patch parsing errors.
+- Fixed collapsed search result rendering so summary and truncation rows stay within the collapsed output budget
+- Updated search path handling to support path lists and internal file paths while preserving previous search behavior
+
 ## [14.5.3] - 2026-04-27
 
 ### Added

package/examples/extensions/plan-mode.ts

@@ -22,7 +22,7 @@ import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
 import { Key } from "@oh-my-pi/pi-tui";
 
 // Read-only tools for plan mode
-const PLAN_MODE_TOOLS = ["read", "bash", "grep", "find", "ls"];
+const PLAN_MODE_TOOLS = ["read", "bash", "search", "find"];
 
 // Full set of tools for normal mode
 const NORMAL_MODE_TOOLS = ["read", "bash", "edit", "write"];

package/examples/sdk/README.md

@@ -69,7 +69,7 @@ const { session } = await createAgentSession({
 });
 
 // Read-only tools
-const { session } = await createAgentSession({ toolNames: ["read", "grep", "find", "ls"], authStorage, modelRegistry });
+const { session } = await createAgentSession({ toolNames: ["read", "search", "find"], authStorage, modelRegistry });
 
 // In-memory
 const { session } = await createAgentSession({

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.5.3",
+	"version": "14.5.6",
 	"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.20.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.5.3",
-		"@oh-my-pi/pi-agent-core": "14.5.3",
-		"@oh-my-pi/pi-ai": "14.5.3",
-		"@oh-my-pi/pi-natives": "14.5.3",
-		"@oh-my-pi/pi-tui": "14.5.3",
-		"@oh-my-pi/pi-utils": "14.5.3",
+		"@oh-my-pi/omp-stats": "14.5.6",
+		"@oh-my-pi/pi-agent-core": "14.5.6",
+		"@oh-my-pi/pi-ai": "14.5.6",
+		"@oh-my-pi/pi-natives": "14.5.6",
+		"@oh-my-pi/pi-tui": "14.5.6",
+		"@oh-my-pi/pi-utils": "14.5.6",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@xterm/headless": "^6.0.0",

package/src/config/prompt-templates.ts

@@ -43,24 +43,119 @@ function formatHashlineRef(lineNum: unknown, content: unknown): { num: number; t
 	return { num, text, ref };
 }
 
+interface HashlineHelperRef {
+	line: number;
+	ref: string;
+}
+
+interface HashlineHelperState {
+	last?: HashlineHelperRef;
+	byLine: Map<number, HashlineHelperRef>;
+}
+
+const HASHLINE_HELPER_STATE = Symbol("hashlineHelperState");
+
+interface HashlineHelperStateHolder {
+	[HASHLINE_HELPER_STATE]?: HashlineHelperState;
+}
+
+function isHelperOptions(value: unknown): value is prompt.HelperOptions {
+	return typeof value === "object" && value !== null && "hash" in value;
+}
+
+function splitHelperArgs(args: unknown[]): { positional: unknown[]; options?: prompt.HelperOptions } {
+	const maybeOptions = args.at(-1);
+	if (!isHelperOptions(maybeOptions)) return { positional: args };
+	return { positional: args.slice(0, -1), options: maybeOptions };
+}
+
+function getHashlineHelperState(context: unknown, options: prompt.HelperOptions | undefined): HashlineHelperState {
+	const data = options?.data;
+	const root = data?.root;
+	const holderTarget = data && typeof data === "object" ? data : root && typeof root === "object" ? root : context;
+	if (!holderTarget || typeof holderTarget !== "object") {
+		throw new Error("hashline prompt helpers require an object render context");
+	}
+
+	const holder = holderTarget as HashlineHelperStateHolder;
+	if (!holder[HASHLINE_HELPER_STATE]) {
+		holder[HASHLINE_HELPER_STATE] = { byLine: new Map() };
+	}
+	return holder[HASHLINE_HELPER_STATE];
+}
+
+function isLineNumberArg(value: unknown): boolean {
+	const num = typeof value === "number" ? value : Number.parseInt(String(value), 10);
+	return Number.isFinite(num);
+}
+
+function rememberHashlineRef(state: HashlineHelperState, line: number, ref: string): void {
+	const entry = { line, ref };
+	state.last = entry;
+	state.byLine.set(line, entry);
+}
+
+function requireStoredHashlineRef(state: HashlineHelperState, lineArg?: unknown): string {
+	if (lineArg === undefined) {
+		if (!state.last) {
+			throw new Error("{{href}} requires a previous {{hline}} call in the same prompt render");
+		}
+		return state.last.ref;
+	}
+
+	const line = typeof lineArg === "number" ? lineArg : Number.parseInt(String(lineArg), 10);
+	const entry = state.byLine.get(line);
+	if (!entry) {
+		throw new Error(`{{href ${line}}} requires a previous {{hline ${line} ...}} call in the same prompt render`);
+	}
+	return entry.ref;
+}
+
+function wrapHashlineRef(ref: string, args: unknown[]): string {
+	const preStr = typeof args[0] === "string" ? args[0] : "";
+	const postStr = typeof args[1] === "string" ? args[1] : "";
+	return `${preStr}${ref}${postStr}`;
+}
+
+function resolveHashlineRef(state: HashlineHelperState, args: unknown[]): string {
+	if (args.length === 0) return requireStoredHashlineRef(state);
+	const [first, second, ...rest] = args;
+	if (isLineNumberArg(first)) {
+		if (second === undefined) return requireStoredHashlineRef(state, first);
+		const { ref } = formatHashlineRef(first, second);
+		return wrapHashlineRef(ref, rest);
+	}
+	return wrapHashlineRef(requireStoredHashlineRef(state), args);
+}
+
 /**
  * {{href lineNum "content"}} — compute a real hashline ref for prompt examples.
- * {{href lineNum "content" "[" "]"}} — wrap the ref with pre/post chars (still quoted).
+ * {{href lineNum}} — quote the ref remembered by the earlier {{hline lineNum "..."}}
+ * {{href}} — quote the ref from the previous {{hline}} call.
+ * {{href "[" "]"}} — wrap the previous {{hline}} ref with pre/post chars.
  * Returns `"lineNumBIGRAM"` (e.g., `"42nd"`), or `"[42nd]"` when pre/post are supplied.
  */
-prompt.registerHelper("href", (lineNum: unknown, content: unknown, pre?: unknown, post?: unknown): string => {
-	const { ref } = formatHashlineRef(lineNum, content);
-	const preStr = typeof pre === "string" ? pre : "";
-	const postStr = typeof post === "string" ? post : "";
-	return JSON.stringify(`${preStr}${ref}${postStr}`);
+prompt.registerHelper("href", function (this: unknown, ...args: unknown[]): string {
+	const { positional, options } = splitHelperArgs(args);
+	const state = getHashlineHelperState(this, options);
+	return JSON.stringify(resolveHashlineRef(state, positional));
+});
+prompt.registerHelper("hrefr", function (this: unknown, ...args: unknown[]): string {
+	const { positional, options } = splitHelperArgs(args);
+	const state = getHashlineHelperState(this, options);
+	return resolveHashlineRef(state, positional);
 });
 
 /**
  * {{hline lineNum "content"}} — format a full read-style line with prefix.
  * Returns `"lineNumBIGRAM|content"` (pipe between anchor and content).
  */
-prompt.registerHelper("hline", (lineNum: unknown, content: unknown): string => {
-	const { ref, text } = formatHashlineRef(lineNum, content);
+prompt.registerHelper("hline", function (this: unknown, ...args: unknown[]): string {
+	const { positional, options } = splitHelperArgs(args);
+	const [lineNum, content] = positional;
+	const { num, ref, text } = formatHashlineRef(lineNum, content);
+	const state = getHashlineHelperState(this, options);
+	rememberHashlineRef(state, num, ref);
 	return `${ref}${HASHLINE_CONTENT_SEPARATOR}${text}`;
 });
 

package/src/config/settings-schema.ts

@@ -1,5 +1,6 @@
 import { THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 import { TASK_SIMPLE_MODES } from "../task/simple-mode";
+import { EDIT_MODES } from "../utils/edit-mode";
 
 /** Unified settings schema - single source of truth for all settings.
  * Unified settings schema - single source of truth for all settings.
@@ -160,8 +161,8 @@ export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
 	},
 	{
 		pattern: "^\\s*(grep|rg|ripgrep|ag|ack)\\s+",
-		tool: "grep",
-		message: "Use the `grep` tool instead of grep/rg. It respects .gitignore and provides structured output.",
+		tool: "search",
+		message: "Use the `search` tool instead of grep/rg. It respects .gitignore and provides structured output.",
 	},
 	{
 		pattern: "^\\s*(find|fd|locate)\\s+.*(-name|-iname|-type|--type|-glob)",
@@ -955,12 +956,12 @@ export const SETTINGS_SCHEMA = {
 	// Edit tool
 	"edit.mode": {
 		type: "enum",
-		values: ["replace", "patch", "hashline", "vim", "apply_patch", "atom"] as const,
+		values: EDIT_MODES,
 		default: "hashline",
 		ui: {
 			tab: "editing",
 			label: "Edit Mode",
-			description: "Select the edit tool variant (replace, patch, hashline, vim, or apply_patch)",
+			description: "Select the edit tool variant (replace, patch, hashline, atom, vim, or apply_patch)",
 		},
 	},
 
@@ -1027,7 +1028,7 @@ export const SETTINGS_SCHEMA = {
 
 	"read.defaultLimit": {
 		type: "number",
-		default: 300,
+		default: 500,
 		ui: {
 			tab: "editing",
 			label: "Default Read Limit",
@@ -1198,30 +1199,30 @@ export const SETTINGS_SCHEMA = {
 		ui: { tab: "tools", label: "Find", description: "Enable the find tool for file searching" },
 	},
 
-	"grep.enabled": {
+	"search.enabled": {
 		type: "boolean",
 		default: true,
-		ui: { tab: "tools", label: "Grep", description: "Enable the grep tool for content searching" },
+		ui: { tab: "tools", label: "Search", description: "Enable the search tool for content searching" },
 	},
 
-	"grep.contextBefore": {
+	"search.contextBefore": {
 		type: "number",
 		default: 1,
 		ui: {
 			tab: "tools",
-			label: "Grep Context Before",
-			description: "Lines of context before each grep match",
+			label: "Search Context Before",
+			description: "Lines of context before each search match",
 			submenu: true,
 		},
 	},
 
-	"grep.contextAfter": {
+	"search.contextAfter": {
 		type: "number",
 		default: 3,
 		ui: {
 			tab: "tools",
-			label: "Grep Context After",
-			description: "Lines of context after each grep match",
+			label: "Search Context After",
+			description: "Lines of context after each search match",
 			submenu: true,
 		},
 	},

package/src/config/settings.ts

@@ -326,7 +326,7 @@ export class Settings {
 
 	/**
 	 * Get the edit variant for a specific model.
-	 * Returns "patch", "replace", "hashline", "vim", "apply_patch", or null (use global default).
+	 * Returns "patch", "replace", "hashline", "atom", "vim", "apply_patch", or null (use global default).
 	 */
 	getEditVariantForModel(model: string | undefined): EditMode | null {
 		if (!model) return null;

package/src/cursor.ts

@@ -177,10 +177,10 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 
 	async grep(args: Parameters<NonNullable<ICursorExecHandlers["grep"]>>[0]) {
 		const toolCallId = decodeToolCallId(args.toolCallId);
-		const grepPath = args.glob ? `${args.path || "."}/${args.glob}` : args.path || ".";
-		const toolResultMessage = await executeTool(this.options, "grep", toolCallId, {
+		const searchPath = args.glob ? `${args.path || "."}/${args.glob}` : args.path || ".";
+		const toolResultMessage = await executeTool(this.options, "search", toolCallId, {
 			pattern: args.pattern,
-			path: grepPath,
+			path: searchPath,
 			i: args.caseInsensitive || undefined,
 		});
 		return toolResultMessage;
@@ -327,7 +327,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		const toolCallId = decodeToolCallId(call.toolCallId);
 		const tool = this.options.tools.get(toolName);
 		if (!tool) {
-			const availableTools = Array.from(this.options.tools.keys()).filter(name => name.startsWith("mcp_"));
+			const availableTools = Array.from(this.options.tools.keys()).filter(name => name.startsWith("mcp__"));
 			const message = formatMcpToolErrorMessage(toolName, availableTools);
 			const result = buildToolErrorResult(message);
 			return createToolResultMessage(toolCallId, toolName, result, true);

package/src/edit/index.ts

@@ -19,13 +19,8 @@ import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit
 import type { VimToolDetails } from "../vim/types";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
-import {
-	type AtomParams,
-	type AtomToolEdit,
-	atomEditParamsSchema,
-	executeAtomSingle,
-	resolveAtomEntryPaths,
-} from "./modes/atom";
+import { type AtomParams, atomEditParamsSchema, executeAtomSingle } from "./modes/atom";
+import atomGrammar from "./modes/atom.lark" with { type: "text" };
 import {
 	executeHashlineSingle,
 	HashlineMismatchError,
@@ -122,45 +117,11 @@ function createEditWritethrough(session: ToolSession): WritethroughCallback {
 	return enableLsp ? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics }) : writethroughNoop;
 }
 
-/**
- * Resolve per-entry `path` against an optional top-level `path` default.
- * If both are absent on an entry, throws a descriptive error.
- */
-function resolveEntryPaths<T extends { path?: string }>(
-	edits: readonly T[],
-	topLevelPath: string | undefined,
-): (T & { path: string })[] {
-	return edits.map((edit, i) => {
-		const path = (edit && typeof edit.path === "string" && edit.path) || topLevelPath;
-		if (!path) {
-			throw new Error(
-				`Edit ${i}: missing \`path\`. Provide \`path\` on this edit or supply a top-level \`path\` for the request.`,
-			);
-		}
-		return { ...edit, path };
-	});
-}
-
-/** Group items by a key, preserving insertion order. */
-function groupBy<T, K>(items: T[], key: (item: T) => K): Map<K, T[]> {
-	const map = new Map<K, T[]>();
-	for (const item of items) {
-		const k = key(item);
-		let arr = map.get(k);
-		if (!arr) {
-			arr = [];
-			map.set(k, arr);
-		}
-		arr.push(item);
-	}
-	return map;
-}
-
-/** Run single-file executors for each file group and aggregate results. */
-async function executePerFile(
+/** Run apply_patch file operations and aggregate their multi-file result. */
+async function executeApplyPatchPerFile(
 	fileEntries: {
 		path: string;
-		run: (batchRequest: LspBatchRequest | undefined) => Promise<AgentToolResult<EditToolDetails, any>>;
+		run: (batchRequest: LspBatchRequest | undefined) => Promise<AgentToolResult<EditToolDetails>>;
 	}[],
 	outerBatchRequest: LspBatchRequest | undefined,
 	onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
@@ -230,6 +191,58 @@ async function executePerFile(
 	};
 }
 
+async function executeSinglePathEntries(
+	path: string,
+	runs: ((batchRequest: LspBatchRequest | undefined) => Promise<AgentToolResult<EditToolDetails>>)[],
+	outerBatchRequest: LspBatchRequest | undefined,
+	onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+): Promise<AgentToolResult<EditToolDetails, TInput>> {
+	if (runs.length === 1) {
+		return runs[0](outerBatchRequest);
+	}
+
+	const contentTexts: string[] = [];
+	const diffTexts: string[] = [];
+	let firstChangedLine: number | undefined;
+
+	for (let i = 0; i < runs.length; i++) {
+		const isLast = i === runs.length - 1;
+		const batchRequest: LspBatchRequest | undefined = outerBatchRequest
+			? { id: outerBatchRequest.id, flush: isLast && outerBatchRequest.flush }
+			: undefined;
+
+		try {
+			const result = await runs[i](batchRequest);
+			const details = result.details;
+			if (details?.diff) diffTexts.push(details.diff);
+			firstChangedLine ??= details?.firstChangedLine;
+			const text = result.content?.find(c => c.type === "text")?.text ?? "";
+			if (text) contentTexts.push(text);
+		} catch (err) {
+			const errorText = err instanceof Error ? err.message : String(err);
+			contentTexts.push(`Error editing ${path}: ${errorText}`);
+		}
+
+		if (!isLast && onUpdate) {
+			onUpdate({
+				content: [{ type: "text", text: contentTexts.join("\n") }],
+				details: {
+					diff: diffTexts.join("\n"),
+					firstChangedLine,
+				},
+			});
+		}
+	}
+
+	return {
+		content: [{ type: "text", text: contentTexts.join("\n") }],
+		details: {
+			diff: diffTexts.join("\n"),
+			firstChangedLine,
+		},
+	};
+}
+
 export class EditTool implements AgentTool<TInput> {
 	readonly name = "edit";
 	readonly label = "Edit";
@@ -278,8 +291,9 @@ export class EditTool implements AgentTool<TInput> {
 	 * and fall back to emitting a JSON function tool from `parameters`.
 	 */
 	get customFormat(): { syntax: "lark"; definition: string } | undefined {
-		if (this.mode !== "apply_patch") return undefined;
-		return { syntax: "lark", definition: applyPatchGrammar };
+		if (this.mode === "apply_patch") return { syntax: "lark", definition: applyPatchGrammar };
+		if (this.mode === "atom") return { syntax: "lark", definition: atomGrammar };
+		return undefined;
 	}
 
 	/**
@@ -316,13 +330,12 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits, path: topPath } = params as PatchParams & { path?: string };
-					const resolved = resolveEntryPaths(edits as PatchEditEntry[], topPath);
-					const entries = resolved.map(entry => ({
-						path: entry.path,
-						run: (br: LspBatchRequest | undefined) =>
+					const { edits, path } = params as PatchParams;
+					const runs = (edits as PatchEditEntry[]).map(
+						entry => (br: LspBatchRequest | undefined) =>
 							executePatchSingle({
 								session: tool.session,
+								path,
 								params: entry,
 								signal,
 								batchRequest: br,
@@ -331,8 +344,8 @@ export class EditTool implements AgentTool<TInput> {
 								writethrough: tool.#writethrough,
 								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
 							}),
-					}));
-					return executePerFile(entries, batchRequest, onUpdate);
+					);
+					return executeSinglePathEntries(path, runs, batchRequest, onUpdate);
 				},
 			},
 			apply_patch: {
@@ -346,21 +359,25 @@ export class EditTool implements AgentTool<TInput> {
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
 					const entries = expandApplyPatchToEntries(params as ApplyPatchParams);
-					const perFile = entries.map(entry => ({
-						path: entry.path!,
-						run: (br: LspBatchRequest | undefined) =>
-							executePatchSingle({
-								session: tool.session,
-								params: entry,
-								signal,
-								batchRequest: br,
-								allowFuzzy: tool.#allowFuzzy,
-								fuzzyThreshold: tool.#fuzzyThreshold,
-								writethrough: tool.#writethrough,
-								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
-							}),
-					}));
-					return executePerFile(perFile, batchRequest, onUpdate);
+					const perFile = entries.map(entry => {
+						const { path, ...patchParams } = entry;
+						return {
+							path,
+							run: (br: LspBatchRequest | undefined) =>
+								executePatchSingle({
+									session: tool.session,
+									path,
+									params: patchParams,
+									signal,
+									batchRequest: br,
+									allowFuzzy: tool.#allowFuzzy,
+									fuzzyThreshold: tool.#fuzzyThreshold,
+									writethrough: tool.#writethrough,
+									beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+								}),
+						};
+					});
+					return executeApplyPatchPerFile(perFile, batchRequest, onUpdate);
 				},
 			},
 			hashline: {
@@ -371,25 +388,18 @@ export class EditTool implements AgentTool<TInput> {
 					params: EditParams,
 					signal: AbortSignal | undefined,
 					batchRequest: LspBatchRequest | undefined,
-					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+					_onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits, path: topPath } = params as HashlineParams & { path?: string };
-					const resolved = resolveEntryPaths(edits as HashlineToolEdit[], topPath);
-					const byFile = groupBy(resolved, e => e.path);
-					const entries = [...byFile.entries()].map(([path, fileEdits]) => ({
+					const { edits, path } = params as HashlineParams;
+					return executeHashlineSingle({
+						session: tool.session,
 						path,
-						run: (br: LspBatchRequest | undefined) =>
-							executeHashlineSingle({
-								session: tool.session,
-								path,
-								edits: fileEdits,
-								signal,
-								batchRequest: br,
-								writethrough: tool.#writethrough,
-								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
-							}),
-					}));
-					return executePerFile(entries, batchRequest, onUpdate);
+						edits: edits as HashlineToolEdit[],
+						signal,
+						batchRequest,
+						writethrough: tool.#writethrough,
+						beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+					});
 				},
 			},
 			atom: {
@@ -400,25 +410,18 @@ export class EditTool implements AgentTool<TInput> {
 					params: EditParams,
 					signal: AbortSignal | undefined,
 					batchRequest: LspBatchRequest | undefined,
-					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+					_onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits, path: topPath } = params as AtomParams & { path?: string };
-					const resolved = resolveAtomEntryPaths(edits as AtomToolEdit[], topPath);
-					const byFile = groupBy(resolved, e => e.path);
-					const entries = [...byFile.entries()].map(([path, fileEdits]) => ({
+					const { input, path } = params as AtomParams & { path?: string };
+					return executeAtomSingle({
+						session: tool.session,
+						input,
 						path,
-						run: (br: LspBatchRequest | undefined) =>
-							executeAtomSingle({
-								session: tool.session,
-								path,
-								edits: fileEdits,
-								signal,
-								batchRequest: br,
-								writethrough: tool.#writethrough,
-								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
-							}),
-					}));
-					return executePerFile(entries, batchRequest, onUpdate);
+						signal,
+						batchRequest,
+						writethrough: tool.#writethrough,
+						beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+					});
 				},
 			},
 			replace: {
@@ -431,13 +434,12 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits, path: topPath } = params as ReplaceParams & { path?: string };
-					const resolved = resolveEntryPaths(edits as ReplaceEditEntry[], topPath);
-					const entries = resolved.map(entry => ({
-						path: entry.path,
-						run: (br: LspBatchRequest | undefined) =>
+					const { edits, path } = params as ReplaceParams;
+					const runs = (edits as ReplaceEditEntry[]).map(
+						entry => (br: LspBatchRequest | undefined) =>
 							executeReplaceSingle({
 								session: tool.session,
+								path,
 								params: entry,
 								signal,
 								batchRequest: br,
@@ -446,8 +448,8 @@ export class EditTool implements AgentTool<TInput> {
 								writethrough: tool.#writethrough,
 								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
 							}),
-					}));
-					return executePerFile(entries, batchRequest, onUpdate);
+					);
+					return executeSinglePathEntries(path, runs, batchRequest, onUpdate);
 				},
 			},
 			vim: {