@gajae-code/coding-agent 0.18.11 → 0.19.0

package/src/discovery/helpers.ts

@@ -202,14 +202,24 @@ export function getProjectPath(ctx: LoadContext, source: SourceId, subpath: stri
 }
 
 /** Build the filesystem authority for a provider read. */
-export function getReadOptions(
-	ctx: Pick<
-		LoadContext,
-		"home" | "isolatedHome" | "userAgentDir" | "homeIdentity" | "userAgentIdentity" | "bypassCache"
-	>,
-	scope: ReadScope,
-): ReadFileOptions | undefined {
-	if (!ctx.isolatedHome) return ctx.bypassCache ? { bypassCache: true } : undefined;
+type DiscoveryReadContext = Pick<
+	LoadContext,
+	"home" | "isolatedHome" | "userAgentDir" | "homeIdentity" | "userAgentIdentity" | "bypassCache"
+> & {
+	repoRoot?: string | null;
+	cwd?: string;
+};
+
+export function getReadOptions(ctx: DiscoveryReadContext, scope: ReadScope): ReadFileOptions | undefined {
+	if (!ctx.isolatedHome) {
+		const boundary = scope === "project" ? (ctx.repoRoot ?? ctx.cwd) : undefined;
+		if (!boundary) return ctx.bypassCache ? { bypassCache: true } : undefined;
+		return {
+			...(ctx.bypassCache ? { bypassCache: true as const } : {}),
+			containmentRoot: boundary,
+			scope,
+		};
+	}
 	return {
 		isolatedHome: true,
 		home: ctx.home,
@@ -222,15 +232,14 @@ export function getReadOptions(
 }
 
 export async function getReadOptionsForContainment(
-	ctx: Pick<
-		LoadContext,
-		"home" | "isolatedHome" | "userAgentDir" | "homeIdentity" | "userAgentIdentity" | "bypassCache"
-	>,
+	ctx: DiscoveryReadContext,
 	scope: ReadScope,
 	containmentRoot?: string,
 ): Promise<ReadFileOptions | undefined> {
 	const options = getReadOptions(ctx, scope);
-	if (!options || !containmentRoot) return options;
+	// Ordinary reads keep the repository boundary from getReadOptions. The extra
+	// root is an isolated-home constraint and was not applied on this path before.
+	if (!ctx.isolatedHome || !options || !containmentRoot) return options;
 	const containmentRootIdentity = await capturePathIdentity(containmentRoot);
 	if (!containmentRootIdentity) return undefined;
 	return { ...options, containmentRoot, containmentRootIdentity };
@@ -298,7 +307,7 @@ export function buildRuleFromMarkdown(
 	},
 ): Rule {
 	const { frontmatter, body } = parseFrontmatter(content, { source: filePath });
-	const { condition, scope } = parseRuleConditionAndScope(frontmatter as RuleFrontmatter);
+	const { condition, astCondition, scope } = parseRuleConditionAndScope(frontmatter as RuleFrontmatter);
 
 	let globs: string[] | undefined;
 	if (Array.isArray(frontmatter.globs)) {
@@ -329,6 +338,7 @@ export function buildRuleFromMarkdown(
 		alwaysApply: frontmatter.alwaysApply === true,
 		description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
 		condition,
+		astCondition,
 		scope,
 		interruptMode,
 		repeatMode,
@@ -1005,8 +1015,7 @@ export async function readContainedFile(
 		rootIdentity = capturedRoot;
 		if (
 			expectedRootIdentity !== undefined &&
-			(rootIdentity.dev !== BigInt(expectedRootIdentity.dev) ||
-				rootIdentity.ino !== BigInt(expectedRootIdentity.ino))
+			(rootIdentity.dev !== expectedRootIdentity.dev || rootIdentity.ino !== expectedRootIdentity.ino)
 		)
 			return null;
 		await SkillDiscoveryTestHooks.afterContainedRootValidated?.(root);

package/src/discovery/mcp-compat.ts

@@ -110,23 +110,63 @@ interface CodexMcpServerConfig {
 	command?: string;
 	args?: string[];
 	env?: Record<string, string>;
-	env_vars?: string[];
+	/** List of env-var names, or `{ name }` entries. Not a value table. */
+	env_vars?: unknown;
 	url?: string;
 	http_headers?: Record<string, string>;
-	env_http_headers?: Record<string, string>;
-	bearer_token_env_var?: string;
+	/** Header name to env-var name. Not a header value. */
+	env_http_headers?: unknown;
+	/** Env-var name whose value is the bearer token. Not the token. */
+	bearer_token_env_var?: unknown;
 	cwd?: string;
 	startup_timeout_sec?: number;
 	tool_timeout_sec?: number;
 }
 
+/** POSIX env-var name. Rejects values that are not names so they are not stored. */
+function isEnvVarName(value: string): boolean {
+	return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+
+/** `${NAME}` keeps the indirection. Callers must not read the process environment. */
+function envVarReference(name: string): string {
+	return `\${${name}}`;
+}
+
+function codexEnvVarEntry(entry: unknown): { name: string; source: string | undefined } | undefined {
+	if (typeof entry === "string") return isEnvVarName(entry) ? { name: entry, source: undefined } : undefined;
+	if (isRecord(entry) && typeof entry.name === "string" && isEnvVarName(entry.name)) {
+		return { name: entry.name, source: typeof entry.source === "string" ? entry.source : undefined };
+	}
+	return undefined;
+}
+
+/** Codex remote-executor sources have no local GJC equivalent. */
+function isUnsupportedEnvSource(source: string | undefined): boolean {
+	return source !== undefined && source !== "local";
+}
+
 /**
  * Extract normalized MCP servers from a Codex `config.toml` `[mcp_servers.*]`
  * section. Codex's config does not carry an `enabled` concept; imported servers
  * default to autoload (startup) behavior after import. Bounded to the supplied
  * content: no filesystem scanning, no user-home reads.
+ *
+ * `env_vars`, `env_http_headers`, and `bearer_token_env_var` name variables.
+ * The process environment is not read. A local name is stored as `${NAME}`
+ * only when the destination keeps operator config. A project destination omits
+ * the reference: project mcp.json is expanded on a later run, and a name such
+ * as `CI_JOB_JWT_V2` is not treated as sensitive, so persisting it would
+ * forward a host value. The source level is metadata and does not decide this.
+ * A static `env` or `http_headers` value is copied. An entry whose source is
+ * not `local` is skipped.
  */
-function extractCodexMcpServers(toml: Record<string, unknown>): Record<string, Partial<MCPServer>> {
+function extractCodexMcpServers(
+	toml: Record<string, unknown>,
+	warnings: string[],
+	sourcePath: string,
+	omitEnvReferences: boolean,
+): Record<string, Partial<MCPServer>> {
 	if (!toml.mcp_servers || !isRecord(toml.mcp_servers)) return {};
 
 	const codexServers = toml.mcp_servers as Record<string, CodexMcpServerConfig>;
@@ -146,11 +186,38 @@ function extractCodexMcpServers(toml: Record<string, unknown>): Record<string, P
 		};
 
 		const env: Record<string, string> = { ...(isStringRecord(serverConfig.env) ? serverConfig.env : {}) };
-		if (Array.isArray(serverConfig.env_vars)) {
-			for (const varName of serverConfig.env_vars) {
-				if (typeof varName !== "string") continue;
-				const value = Bun.env[varName];
-				if (value !== undefined) env[varName] = value;
+		if (serverConfig.env_vars !== undefined && !Array.isArray(serverConfig.env_vars)) {
+			warnings.push(
+				`skipped env_vars for "${name}" in ${sourcePath} because it is not a list of environment variable names`,
+			);
+		} else if (Array.isArray(serverConfig.env_vars)) {
+			for (const entry of serverConfig.env_vars) {
+				const parsed = codexEnvVarEntry(entry);
+				if (!parsed) {
+					warnings.push(
+						`skipped env_vars entry for "${name}" in ${sourcePath} because it is not an environment variable name`,
+					);
+					continue;
+				}
+				if (isUnsupportedEnvSource(parsed.source)) {
+					warnings.push(
+						`skipped env_vars entry ${parsed.name} for "${name}" in ${sourcePath} because source "${parsed.source}" is not executed locally`,
+					);
+					continue;
+				}
+				if (Object.hasOwn(env, parsed.name)) {
+					warnings.push(
+						`kept static env ${parsed.name} for "${name}" in ${sourcePath} and did not read the environment`,
+					);
+					continue;
+				}
+				if (omitEnvReferences) {
+					warnings.push(
+						`skipped project-scope environment reference ${parsed.name} for "${name}" in ${sourcePath} so a later load cannot expand a host value`,
+					);
+					continue;
+				}
+				env[parsed.name] = envVarReference(parsed.name);
 			}
 		}
 		if (Object.keys(env).length > 0) server.env = env;
@@ -158,16 +225,50 @@ function extractCodexMcpServers(toml: Record<string, unknown>): Record<string, P
 		const headers: Record<string, string> = {
 			...(isStringRecord(serverConfig.http_headers) ? serverConfig.http_headers : {}),
 		};
-		if (isRecord(serverConfig.env_http_headers)) {
+		if (serverConfig.env_http_headers !== undefined && !isRecord(serverConfig.env_http_headers)) {
+			warnings.push(
+				`skipped env_http_headers for "${name}" in ${sourcePath} because it is not a table of environment variable names`,
+			);
+		} else if (isRecord(serverConfig.env_http_headers)) {
 			for (const [headerName, envVarName] of Object.entries(serverConfig.env_http_headers)) {
-				if (typeof envVarName !== "string") continue;
-				const value = Bun.env[envVarName];
-				if (value !== undefined) headers[headerName] = value;
+				if (typeof envVarName !== "string" || !isEnvVarName(envVarName)) {
+					warnings.push(
+						`skipped env_http_headers entry for "${name}" in ${sourcePath} because its value is not an environment variable name`,
+					);
+					continue;
+				}
+				if (Object.hasOwn(headers, headerName)) {
+					warnings.push(
+						`kept static header ${headerName} for "${name}" in ${sourcePath} and did not read ${envVarName}`,
+					);
+					continue;
+				}
+				if (omitEnvReferences) {
+					warnings.push(
+						`skipped project-scope environment reference ${envVarName} for "${name}" in ${sourcePath} so a later load cannot expand a host value`,
+					);
+					continue;
+				}
+				headers[headerName] = envVarReference(envVarName);
 			}
 		}
-		if (typeof serverConfig.bearer_token_env_var === "string") {
-			const token = Bun.env[serverConfig.bearer_token_env_var];
-			if (token) headers.Authorization = `Bearer ${token}`;
+		if (serverConfig.bearer_token_env_var !== undefined) {
+			const bearerName = serverConfig.bearer_token_env_var;
+			if (typeof bearerName !== "string" || !isEnvVarName(bearerName)) {
+				warnings.push(
+					`skipped bearer_token_env_var for "${name}" in ${sourcePath} because it is not an environment variable name`,
+				);
+			} else if (Object.hasOwn(headers, "Authorization")) {
+				warnings.push(
+					`kept static Authorization for "${name}" in ${sourcePath} and did not read bearer_token_env_var ${bearerName}`,
+				);
+			} else if (omitEnvReferences) {
+				warnings.push(
+					`skipped project-scope environment reference ${bearerName} for "${name}" in ${sourcePath} so a later load cannot expand a host value`,
+				);
+			} else {
+				headers.Authorization = `Bearer ${envVarReference(bearerName)}`;
+			}
 		}
 		if (Object.keys(headers).length > 0) server.headers = headers;
 
@@ -192,6 +293,7 @@ export function normalizeCodexMcpToml(
 	content: string,
 	sourcePath: string,
 	level: "project" | "user" = "project",
+	options?: { omitEnvReferences?: boolean },
 ): MCPCompatNormalizeResult {
 	const items: MCPServer[] = [];
 	const warnings: string[] = [];
@@ -212,7 +314,8 @@ export function normalizeCodexMcpToml(
 			}
 		}
 	}
-	const servers = extractCodexMcpServers(parsed);
+	const omitEnvReferences = options?.omitEnvReferences ?? level === "project";
+	const servers = extractCodexMcpServers(parsed, warnings, sourcePath, omitEnvReferences);
 	for (const [name, config] of Object.entries(servers)) {
 		items.push({
 			name,

package/src/edit/apply-patch/index.ts

@@ -12,7 +12,13 @@
  */
 
 import { ApplyPatchError } from "../diff";
-import { type ApplyPatchOptions, type ApplyPatchResult, applyPatch, type PatchInput } from "../modes/patch";
+import {
+	type ApplyPatchOptions,
+	type ApplyPatchResult,
+	applyPatch,
+	type PatchInput,
+	preflightPatchMkdir,
+} from "../modes/patch";
 import { parseApplyPatch } from "./parser";
 
 export * from "./parser";
@@ -48,6 +54,11 @@ export async function applyCodexPatch(patchText: string, options: ApplyPatchOpti
 		deleted: [] as string[],
 	};
 
+	// Containment is checked for every hunk before the first write. A later
+	// I/O failure still leaves earlier hunks applied, per spec §6.1.
+	for (const hunk of hunks) {
+		await preflightPatchMkdir(hunk, options);
+	}
 	for (const hunk of hunks) {
 		const result = await applyPatch(hunk, options);
 		results.push(result);

package/src/edit/index.ts

@@ -3,9 +3,12 @@ import { prompt } from "@gajae-code/utils";
 import type * as z from "zod/v4";
 import {
 	executeHashlineSingle,
+	type HashlineEdit,
 	HashlineMismatchError,
 	type HashlineParams,
 	hashlineEditParamsSchema,
+	parseHashline,
+	splitHashlineInputs,
 } from "../hashline";
 import hashlineGrammarTemplate from "../hashline/grammar.lark" with { type: "text" };
 import { resolveHashlineGrammarPlaceholders } from "../hashline/hash";
@@ -21,13 +24,28 @@ import hashlineDescription from "../prompts/tools/hashline.md" with { type: "tex
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
 import type { ToolSession } from "../tools";
+import { assertEditableFile } from "../tools/auto-generated-guard";
+import { resolvePlanPath } from "../tools/plan-mode-guard";
 import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, resolveEditMode, resolveForcedEnvEditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
-import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
+import { normalizeCreateContent } from "./diff";
+import {
+	type ApplyPatchEntry,
+	type ApplyPatchParams,
+	applyPatchSchema,
+	expandApplyPatchToEntries,
+	expandApplyPatchToPreviewEntries,
+} from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
-import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
-import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
+import {
+	executePatchSingle,
+	type PatchEditEntry,
+	type PatchParams,
+	patchEditEntrySchema,
+	patchEditSchema,
+} from "./modes/patch";
+import { executeReplaceEntries, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
 
 export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
@@ -57,6 +75,12 @@ type VimParams = z.infer<typeof vimSchema>;
 type EditParams = ReplaceParams | PatchParams | HashlineParams | VimParams | ApplyPatchParams;
 type EditToolResultDetails = EditToolDetails | VimToolDetails;
 
+/** Diff bodies introduce only `+` rows, not unified-diff file headers. */
+function addedPatchDigest(diff: string): string | undefined {
+	const added = diff.split("\n").filter(line => line.startsWith("+") && !line.startsWith("+++ "));
+	return added.length > 0 ? added.map(line => line.slice(1)).join("\n") : undefined;
+}
+
 const UNSAFE_EDIT_SUMMARY_PATH =
 	/(?:\b(?:https?|wss?):\/\/|\b(?:api[-_ ]?key|access[-_ ]?token|bearer|secret|password)\b|\b(?:sk|pk|rk)-[A-Za-z0-9_-]{12,})/i;
 
@@ -167,6 +191,56 @@ function createEditWritethrough(session: ToolSession): WritethroughCallback {
 	return enableLsp ? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics }) : writethroughNoop;
 }
 
+type PatchGuardFailure = { path: string; errorText: string };
+
+/**
+ * Refuse a generated source or rename destination before any entry writes.
+ * A single entry still throws. Several entries return the per-entry errors
+ * the patch aggregators already use, and the caller writes nothing.
+ */
+async function collectPatchGuardFailures(
+	session: ToolSession,
+	entries: { path: string; rename?: string }[],
+	signal?: AbortSignal,
+): Promise<PatchGuardFailure[] | undefined> {
+	const failures: PatchGuardFailure[] = [];
+	const aggregate = entries.length > 1;
+	for (const entry of entries) {
+		signal?.throwIfAborted();
+		try {
+			const resolvedPath = resolvePlanPath(session, entry.path);
+			await assertEditableFile(resolvedPath, entry.path, session.settings);
+			signal?.throwIfAborted();
+			if (!entry.rename) continue;
+			const resolvedRename = resolvePlanPath(session, entry.rename);
+			if (resolvedRename === resolvedPath) continue;
+			await assertEditableFile(resolvedRename, entry.rename, session.settings);
+			signal?.throwIfAborted();
+		} catch (err) {
+			signal?.throwIfAborted();
+			if (!aggregate || (err instanceof Error && err.name === "AbortError")) throw err;
+			failures.push({ path: entry.path, errorText: err instanceof Error ? err.message : String(err) });
+		}
+	}
+	return failures.length > 0 ? failures : undefined;
+}
+
+function refusedPatchEntriesResult(
+	failures: PatchGuardFailure[],
+	details: { path?: string; perFileResults?: EditToolPerFileResult[] },
+): AgentToolResult<EditToolDetails, TInput> {
+	return {
+		content: [
+			{
+				type: "text",
+				text: failures.map(failure => `Error editing ${failure.path}: ${failure.errorText}`).join("\n"),
+			},
+		],
+		details: { diff: "", ...details },
+		isError: true,
+	};
+}
+
 /** Run apply_patch file operations and aggregate their multi-file result. */
 async function executeApplyPatchPerFile(
 	fileEntries: {
@@ -364,6 +438,96 @@ export class EditTool implements AgentTool<TInput> {
 		return this.#getModeDefinition().parameters;
 	}
 
+	matcherDigest(args: unknown): string | undefined {
+		const digest = this.matcherEntries(args)
+			?.map(entry => entry.digest)
+			.filter(Boolean)
+			.join("\n");
+		return digest || undefined;
+	}
+
+	matcherEntries(args: unknown): readonly { path: string; digest: string }[] | undefined {
+		try {
+			if (!args || typeof args !== "object" || Array.isArray(args)) return undefined;
+			const record = args as Record<string, unknown>;
+			const digests = new Map<string, string>();
+			const add = (path: string, digest: string | undefined) => {
+				if (!path || digest === undefined) return;
+				const current = digests.get(path);
+				digests.set(path, current === undefined ? digest : `${current}\n${digest}`);
+			};
+
+			switch (this.mode) {
+				case "replace": {
+					if (typeof record.path !== "string" || !Array.isArray(record.edits)) return undefined;
+					for (const entry of record.edits) {
+						if (!entry || typeof entry !== "object" || Array.isArray(entry)) return undefined;
+						const text = (entry as Record<string, unknown>).new_text;
+						if (text !== undefined && typeof text !== "string") return undefined;
+						add(record.path, text);
+					}
+					break;
+				}
+				case "patch": {
+					if (typeof record.path !== "string" || !Array.isArray(record.edits)) return undefined;
+					for (const entry of record.edits) {
+						const parsed = patchEditEntrySchema.safeParse(entry);
+						if (!parsed.success) return undefined;
+						const { diff, op, rename } = parsed.data;
+						if (op === "delete" || diff === undefined) continue;
+						// A create body is digested exactly as the writer will persist it.
+						add(rename ?? record.path, op === "create" ? normalizeCreateContent(diff) : addedPatchDigest(diff));
+					}
+					break;
+				}
+				case "hashline": {
+					const parsed = hashlineEditParamsSchema.safeParse(args);
+					if (!parsed.success) return undefined;
+					for (const section of splitHashlineInputs(parsed.data.input, {
+						path: parsed.data.path,
+						cwd: this.session.cwd,
+					})) {
+						// A section still streaming (e.g. a trailing op with no anchor yet)
+						// does not parse; it contributes nothing, but earlier complete
+						// sections keep their entries (as pi-edit's hashline inspect does).
+						let edits: HashlineEdit[];
+						try {
+							edits = parseHashline(section.diff);
+						} catch {
+							continue;
+						}
+						const inserted = edits.filter(edit => edit.kind === "insert");
+						if (inserted.length > 0) add(section.path, inserted.map(edit => edit.text).join("\n"));
+					}
+					break;
+				}
+				case "apply_patch": {
+					const parsed = applyPatchSchema.safeParse(args);
+					if (!parsed.success) return undefined;
+					let entries: ApplyPatchEntry[];
+					try {
+						entries = expandApplyPatchToEntries(parsed.data);
+					} catch {
+						entries = expandApplyPatchToPreviewEntries(parsed.data);
+					}
+					for (const entry of entries) {
+						if (entry.op === "delete" || entry.diff === undefined) continue;
+						// The envelope parser already strips Add File prefixes.
+						add(entry.rename ?? entry.path, entry.op === "create" ? entry.diff : addedPatchDigest(entry.diff));
+					}
+					break;
+				}
+				case "vim":
+					return undefined;
+			}
+
+			return digests.size > 0 ? Array.from(digests, ([path, digest]) => ({ path, digest })) : undefined;
+		} catch {
+			// Streamed arguments can be incomplete or malformed in any mode.
+			return undefined;
+		}
+	}
+
 	/**
 	 * When in `apply_patch` mode, expose the OpenAI code backend Lark grammar so providers
 	 * that support OpenAI-style custom tools can emit a grammar-constrained
@@ -403,7 +567,7 @@ export class EditTool implements AgentTool<TInput> {
 			patch: {
 				description: () => prompt.render(patchDescription),
 				parameters: patchEditSchema,
-				execute: (
+				execute: async (
 					tool: EditTool,
 					params: EditParams,
 					signal: AbortSignal | undefined,
@@ -411,7 +575,14 @@ export class EditTool implements AgentTool<TInput> {
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
 					const { edits, path } = params as PatchParams;
-					const runs = (edits as PatchEditEntry[]).map(
+					const patchEdits = edits as PatchEditEntry[];
+					const guardFailures = await collectPatchGuardFailures(
+						tool.session,
+						patchEdits.map(entry => ({ path, rename: entry.rename })),
+						signal,
+					);
+					if (guardFailures) return refusedPatchEntriesResult(guardFailures, { path });
+					const runs = patchEdits.map(
 						entry => (br: LspBatchRequest | undefined) =>
 							executePatchSingle({
 								session: tool.session,
@@ -431,7 +602,7 @@ export class EditTool implements AgentTool<TInput> {
 			apply_patch: {
 				description: () => prompt.render(applyPatchDescription),
 				parameters: applyPatchSchema,
-				execute: (
+				execute: async (
 					tool: EditTool,
 					params: EditParams,
 					signal: AbortSignal | undefined,
@@ -439,6 +610,21 @@ export class EditTool implements AgentTool<TInput> {
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
 					const entries = expandApplyPatchToEntries(params as ApplyPatchParams);
+					const guardFailures = await collectPatchGuardFailures(
+						tool.session,
+						entries.map(entry => ({ path: entry.path, rename: entry.rename })),
+						signal,
+					);
+					if (guardFailures) {
+						return refusedPatchEntriesResult(guardFailures, {
+							perFileResults: guardFailures.map(failure => ({
+								path: failure.path,
+								diff: "",
+								isError: true,
+								errorText: failure.errorText,
+							})),
+						});
+					}
 					const perFile = entries.map(entry => {
 						const { path, ...patchParams } = entry;
 						return {
@@ -490,24 +676,20 @@ 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 } = params as ReplaceParams;
-					const runs = (edits as ReplaceEditEntry[]).map(
-						entry => (br: LspBatchRequest | undefined) =>
-							executeReplaceSingle({
-								session: tool.session,
-								path,
-								params: entry,
-								signal,
-								batchRequest: br,
-								allowFuzzy: tool.#allowFuzzy,
-								fuzzyThreshold: tool.#fuzzyThreshold,
-								writethrough: tool.#writethrough,
-								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
-							}),
-					);
-					return executeSinglePathEntries(path, runs, batchRequest, onUpdate);
+					return executeReplaceEntries({
+						session: tool.session,
+						path,
+						edits: edits as ReplaceEditEntry[],
+						signal,
+						batchRequest,
+						allowFuzzy: tool.#allowFuzzy,
+						fuzzyThreshold: tool.#fuzzyThreshold,
+						writethrough: tool.#writethrough,
+						beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+					});
 				},
 			},
 			vim: {