@oh-my-pi/pi-coding-agent 17.2.3 → 17.2.5

package/src/discovery/builtin.ts

@@ -31,6 +31,7 @@ import {
 	expandEnvVarsDeep,
 	getExtensionNameFromPath,
 	loadFilesFromDir,
+	parseRequestIdFormat,
 	SOURCE_PATHS,
 	scanSkillsFromDir,
 } from "./helpers";
@@ -154,10 +155,19 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 				timeout = undefined;
 			}
 
+			// Validate requestIdFormat: only the two documented encodings
+			const requestIdFormat = parseRequestIdFormat(serverConfig.requestIdFormat);
+			if (requestIdFormat === undefined && serverConfig.requestIdFormat != null) {
+				logger.warn(
+					`MCP server "${serverName}": invalid requestIdFormat ${JSON.stringify(serverConfig.requestIdFormat)}, ignoring`,
+				);
+			}
+
 			result.push({
 				name: serverName,
 				enabled,
 				timeout,
+				requestIdFormat,
 				command: serverConfig.command as string | undefined,
 				args: serverConfig.args as string[] | undefined,
 				env: serverConfig.env as Record<string, string> | undefined,

package/src/discovery/helpers.ts

@@ -16,6 +16,7 @@ import { invalidate as invalidateFsCache, readDirEntries, readFile } from "../ca
 import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../capability/rule";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import type { MCPRequestIdFormat } from "../mcp/types";
 import { type ConfiguredThinkingLevel, parseConfiguredThinkingLevel } from "../thinking";
 import { normalizeToolNames } from "../tools/builtin-names";
 
@@ -140,6 +141,15 @@ export function parseBoolean(value: unknown): boolean | undefined {
 	return undefined;
 }
 
+/**
+ * Parse an MCP `requestIdFormat` value. Unrecognized values are dropped so a typo
+ * degrades to the default integer ids rather than reaching a transport.
+ */
+export function parseRequestIdFormat(value: unknown): MCPRequestIdFormat | undefined {
+	if (value === "string" || value === "number") return value;
+	return undefined;
+}
+
 /**
  * Parse a comma-separated string into an array of trimmed, non-empty strings.
  */

package/src/discovery/mcp-json.ts

@@ -12,7 +12,7 @@ import { registerProvider } from "../capability";
 import { readFile } from "../capability/fs";
 import { type MCPServer, mcpCapability } from "../capability/mcp";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
-import { createSourceMeta, expandEnvVarsDeep } from "./helpers";
+import { createSourceMeta, expandEnvVarsDeep, parseRequestIdFormat } from "./helpers";
 
 const PROVIDER_ID = "mcp-json";
 const DISPLAY_NAME = "MCP Config";
@@ -26,6 +26,7 @@ interface MCPConfigFile {
 		{
 			enabled?: boolean;
 			timeout?: number;
+			requestIdFormat?: "string" | "number";
 			command?: string;
 			args?: string[];
 			env?: Record<string, string>;
@@ -83,10 +84,19 @@ function transformMCPConfig(config: MCPConfigFile, source: SourceMeta): MCPServe
 				}
 			}
 
+			const requestIdFormat = parseRequestIdFormat(serverConfig.requestIdFormat);
+			if (requestIdFormat === undefined && serverConfig.requestIdFormat !== undefined) {
+				logger.warn("MCP server has invalid 'requestIdFormat' value, ignoring", {
+					name,
+					value: serverConfig.requestIdFormat,
+				});
+			}
+
 			const server: MCPServer = {
 				name,
 				enabled,
 				timeout,
+				requestIdFormat,
 				command: serverConfig.command,
 				args: serverConfig.args,
 				env: serverConfig.env,

package/src/discovery/omp-extension-roots.ts

@@ -15,6 +15,7 @@
  * @see ./omp-plugins.ts
  * @see ./builtin.ts `loadExtensionModules`
  */
+import { AsyncLocalStorage } from "node:async_hooks";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getAgentDir, isEnoent, logger, tryParseJson } from "@oh-my-pi/pi-utils";
@@ -36,10 +37,48 @@ export interface OmpExtensionRoot {
 
 interface InjectedRoot {
 	path: string;
+	/** Relative CLI spelling, rebound against the active project on discovery. */
+	relativePath?: string;
 	level: "user" | "project";
 }
 
+export type OmpExtensionRootMode = "merge" | "explicit-only";
+
+interface InvocationRootScope {
+	/** Raw SDK spellings, resolved against the LoadContext that performs discovery. */
+	paths: readonly string[];
+	mode: OmpExtensionRootMode;
+}
+
+const invocationRootScope = new AsyncLocalStorage<InvocationRootScope>();
+
 let injectedCliRoots: InjectedRoot[] = [];
+let injectedCliRootMode: OmpExtensionRootMode = "merge";
+
+export interface InjectOmpExtensionCliRootOptions {
+	/**
+	 * `explicit-only` exposes only roots named by this CLI invocation. Use it
+	 * with `--no-extensions` so configured and installed packages cannot
+	 * contribute sibling capabilities through the `omp-plugins` provider.
+	 */
+	mode?: OmpExtensionRootMode;
+	/** Replace roots from an earlier invocation instead of extending them. */
+	replace?: boolean;
+}
+
+/**
+ * Run one SDK invocation with its own extension-package roots. Async resources
+ * started inside `callback` retain this scope, including discovery deliberately
+ * deferred until the end of session startup. Raw relative paths are resolved by
+ * {@link listOmpExtensionRoots} against that invocation's active cwd.
+ */
+export function withOmpExtensionRootScope<T>(
+	paths: readonly string[],
+	mode: OmpExtensionRootMode,
+	callback: () => T,
+): T {
+	return invocationRootScope.run({ paths: [...paths], mode }, callback);
+}
 
 /**
  * Register CLI-provided extension package paths (e.g. from `--extension`/`-e`)
@@ -50,17 +89,27 @@ let injectedCliRoots: InjectedRoot[] = [];
  * Call once during startup before any capability load. Repeated calls extend
  * the registered set; {@link clearOmpExtensionCliRoots} resets for tests.
  */
-export function injectOmpExtensionCliRoots(paths: readonly string[], home: string, cwd: string): void {
+export function injectOmpExtensionCliRoots(
+	paths: readonly string[],
+	home: string,
+	cwd: string,
+	options: InjectOmpExtensionCliRootOptions = {},
+): void {
+	if (options.mode) injectedCliRootMode = options.mode;
+	if (options.replace) injectedCliRoots = [];
 	if (paths.length === 0) return;
 	const expanded = paths.map(raw => {
 		const tilde = expandTilde(raw, home);
-		return path.isAbsolute(tilde) ? tilde : path.resolve(cwd, tilde);
+		return {
+			path: path.isAbsolute(tilde) ? tilde : path.resolve(cwd, tilde),
+			relativePath: path.isAbsolute(tilde) ? undefined : tilde,
+		};
 	});
 	const merged = new Map<string, InjectedRoot>();
 	for (const root of injectedCliRoots) merged.set(root.path, root);
-	for (const resolved of expanded) {
+	for (const { path: resolved, relativePath } of expanded) {
 		// CLI scope mirrors how `--extension` is treated elsewhere — user-level overrides win.
-		if (!merged.has(resolved)) merged.set(resolved, { path: resolved, level: "user" });
+		if (!merged.has(resolved)) merged.set(resolved, { path: resolved, relativePath, level: "user" });
 	}
 	injectedCliRoots = [...merged.values()];
 }
@@ -68,6 +117,7 @@ export function injectOmpExtensionCliRoots(paths: readonly string[], home: strin
 /** Drop every CLI-injected root. Tests use this between cases. */
 export function clearOmpExtensionCliRoots(): void {
 	injectedCliRoots = [];
+	injectedCliRootMode = "merge";
 }
 
 /** Inspect currently-injected CLI roots (read-only). Exposed for diagnostics + tests. */
@@ -121,7 +171,8 @@ async function isDirectory(p: string): Promise<boolean> {
  * Sources, in order of precedence (later entries with the same absolute path
  * are dropped):
  *
- * 1. CLI roots injected via {@link injectOmpExtensionCliRoots}
+ * 1. Invocation-scoped SDK roots, when present; otherwise CLI roots injected
+ *    via {@link injectOmpExtensionCliRoots}
  * 2. Project `<cwd>/.omp/settings.json#extensions`
  * 3. User `~/.omp/agent/settings.json#extensions`
  * 4. Enabled npm/link plugins installed under `<plugins>/node_modules/` (for
@@ -134,21 +185,29 @@ async function isDirectory(p: string): Promise<boolean> {
  * other sources still surface.
  */
 export async function listOmpExtensionRoots(ctx: LoadContext): Promise<OmpExtensionRoot[]> {
-	const { project, user } = scopeDirs(ctx);
-	const [projectExtensions, userExtensions, installedPlugins] = await Promise.all([
-		readSettingsExtensions(path.join(project, "settings.json")),
-		readSettingsExtensions(path.join(user, "settings.json")),
-		listInstalledPluginRoots(ctx),
-	]);
-
-	const candidates: InjectedRoot[] = [
-		...injectedCliRoots,
-		...projectExtensions.map((raw): InjectedRoot => ({ path: resolveAgainst(raw, ctx), level: "project" })),
-		...userExtensions.map((raw): InjectedRoot => ({ path: resolveAgainst(raw, ctx), level: "user" })),
-		...installedPlugins,
-	];
-
-	// First-seen-wins dedup preserves CLI > project-settings > user-settings > installed precedence.
+	const scopedRoots = invocationRootScope.getStore();
+	const rootMode = scopedRoots?.mode ?? injectedCliRootMode;
+	let candidates: InjectedRoot[] = scopedRoots
+		? scopedRoots.paths.map(raw => ({ path: resolveAgainst(raw, ctx), level: "user" }))
+		: injectedCliRoots.map(root =>
+				root.relativePath ? { ...root, path: path.resolve(ctx.cwd, root.relativePath) } : root,
+			);
+	if (rootMode === "merge") {
+		const { project, user } = scopeDirs(ctx);
+		const [projectExtensions, userExtensions, installedPlugins] = await Promise.all([
+			readSettingsExtensions(path.join(project, "settings.json")),
+			readSettingsExtensions(path.join(user, "settings.json")),
+			listInstalledPluginRoots(ctx),
+		]);
+		candidates = [
+			...candidates,
+			...projectExtensions.map((raw): InjectedRoot => ({ path: resolveAgainst(raw, ctx), level: "project" })),
+			...userExtensions.map((raw): InjectedRoot => ({ path: resolveAgainst(raw, ctx), level: "user" })),
+			...installedPlugins,
+		];
+	}
+
+	// First-seen-wins dedup preserves invocation/CLI > project-settings > user-settings > installed precedence.
 	const seen = new Set<string>();
 	const unique: InjectedRoot[] = [];
 	for (const candidate of candidates) {

package/src/discovery/omp-plugins.ts

@@ -28,7 +28,13 @@ import { type Skill, skillCapability } from "../capability/skill";
 import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
 import { type CustomTool, toolCapability } from "../capability/tool";
 import type { LoadContext, LoadResult } from "../capability/types";
-import { buildRuleFromMarkdown, createSourceMeta, loadFilesFromDir, scanSkillsFromDir } from "./helpers";
+import {
+	buildRuleFromMarkdown,
+	createSourceMeta,
+	loadFilesFromDir,
+	parseRequestIdFormat,
+	scanSkillsFromDir,
+} from "./helpers";
 import { listOmpExtensionRoots, type OmpExtensionRoot } from "./omp-extension-roots";
 import { resolvePluginStdioPaths } from "./substitute-plugin-root";
 
@@ -257,6 +263,7 @@ const MCP_FILENAMES = [".mcp.json", "mcp.json"] as const;
 interface RawMcpServer {
 	enabled?: boolean;
 	timeout?: number;
+	requestIdFormat?: unknown;
 	command?: string;
 	args?: string[];
 	env?: Record<string, string>;
@@ -305,10 +312,12 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 			// Root relative command/cwd at the plugin's config directory, not the
 			// session cwd (MCP stdio spawning resolves relative values there).
 			const rooted = resolvePluginStdioPaths({ command: cfg.command, cwd: cfg.cwd }, root.path);
+			const requestIdFormat = parseRequestIdFormat(cfg.requestIdFormat);
 			items.push({
 				name: serverName,
 				...(cfg.enabled !== undefined && { enabled: cfg.enabled }),
 				...(cfg.timeout !== undefined && { timeout: cfg.timeout }),
+				...(requestIdFormat !== undefined && { requestIdFormat }),
 				...(rooted.command !== undefined && { command: rooted.command }),
 				...(cfg.args !== undefined && { args: cfg.args }),
 				...(cfg.env !== undefined && { env: cfg.env }),

package/src/edit/diff.ts

@@ -855,7 +855,6 @@ export function replaceText(content: string, oldText: string, newText: string, o
 	let normalizedContent = normalizeToLF(content);
 	const normalizedOldText = normalizeToLF(oldText);
 	const normalizedNewText = normalizeToLF(newText);
-	let count = 0;
 
 	if (options.all) {
 		// Check for exact matches first
@@ -867,11 +866,13 @@ export function replaceText(content: string, oldText: string, newText: string, o
 			};
 		}
 
-		// No exact matches - try fuzzy matching iteratively
+		// Match against the immutable source so inserted replacement text cannot become a later candidate.
+		const replacements: Array<{ startIndex: number; endIndex: number; text: string }> = [];
 		while (true) {
 			const matchOutcome = findMatch(normalizedContent, normalizedOldText, {
 				allowFuzzy: options.fuzzy,
 				threshold,
+				excludedRanges: replacements,
 			});
 
 			const shouldUseClosest =
@@ -888,14 +889,22 @@ export function replaceText(content: string, oldText: string, newText: string, o
 			if (adjustedNewText === match.actualText) {
 				break;
 			}
-			normalizedContent =
-				normalizedContent.substring(0, match.startIndex) +
-				adjustedNewText +
-				normalizedContent.substring(match.startIndex + match.actualText.length);
-			count++;
+			replacements.push({
+				startIndex: match.startIndex,
+				endIndex: match.startIndex + Math.max(match.actualText.length, 1),
+				text: adjustedNewText,
+			});
 		}
 
-		return { content: normalizedContent, count };
+		replacements.sort((a, b) => a.startIndex - b.startIndex);
+		const parts: string[] = [];
+		let sourceIndex = 0;
+		for (const replacement of replacements) {
+			parts.push(normalizedContent.substring(sourceIndex, replacement.startIndex), replacement.text);
+			sourceIndex = replacement.endIndex;
+		}
+		parts.push(normalizedContent.substring(sourceIndex));
+		return { content: parts.join(""), count: replacements.length };
 	}
 
 	// Single replacement mode

package/src/edit/index.ts

@@ -19,7 +19,7 @@ import { executeHashlineSingle, hashlineEditParamsSchema } from "./hashline";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } 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 { executeReplace, type ReplaceBatchParams, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
 import { pruneOversizedEditSnapshots } from "./snapshot-details";
 import { EDIT_MODE_STRATEGIES } from "./streaming";
@@ -46,7 +46,7 @@ type TInput =
 
 type HashlineParams = typeof hashlineEditParamsSchema.infer;
 
-type EditParams = ReplaceParams | PatchParams | HashlineParams | ApplyPatchParams;
+type EditParams = ReplaceParams | ReplaceBatchParams | PatchParams | HashlineParams | ApplyPatchParams;
 
 type EditModeDefinition = {
 	description: (session: ToolSession) => string;
@@ -402,7 +402,7 @@ export class EditTool implements AgentTool<TInput> {
 	/**
 	 * `mode` pins the edit variant for this instance, for callers whose protocol
 	 * fixes the shape of an edit. The Cursor `pi_edit` frame carries
-	 * `old_text`/`new_text` pairs, which only `replace` accepts — under the
+	 * `old_string`/`new_string` args, which only `replace` accepts — under the
 	 * default `hashline` mode those args do not match the schema at all. Left
 	 * unset, the env/settings resolution applies as before.
 	 */
@@ -662,11 +662,24 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits, path } = params as ReplaceParams;
-					const targetPath = await resolveEditPath(tool.session, path, { mustExist: true, signal });
-					const runs = (edits as ReplaceEditEntry[]).map(
+					// `edits` is the internal `ReplaceBatchParams` form only the Cursor
+					// exec bridge produces (multi-replacement `pi_edit` frames run as one
+					// lifecycle); model calls always arrive in the single-edit schema shape.
+					const replaceParams = params as ReplaceParams | ReplaceBatchParams;
+					const entries =
+						"edits" in replaceParams
+							? replaceParams.edits
+							: [
+									{
+										old_string: replaceParams.old_string,
+										new_string: replaceParams.new_string,
+										replace_all: replaceParams.replace_all,
+									},
+								];
+					const targetPath = await resolveEditPath(tool.session, replaceParams.path, { mustExist: true, signal });
+					const runs = entries.map(
 						entry => (br: LspBatchRequest | undefined) =>
-							executeReplaceSingle({
+							executeReplace({
 								session: tool.session,
 								path: targetPath,
 								params: entry,

package/src/edit/modes/replace.ts

@@ -258,23 +258,41 @@ function formatPreviewWindow(lines: string[], centerIndex: number, options: Prev
 		.join("\n");
 }
 
-function findExactMatchOutcome(content: string, target: string): MatchOutcome | undefined {
-	const exactIndex = content.indexOf(target);
-	if (exactIndex === -1) {
+function findExactMatchOutcome(
+	content: string,
+	target: string,
+	excludedRanges: readonly { startIndex: number; endIndex: number }[],
+): MatchOutcome | undefined {
+	let firstIndex: number | undefined;
+	let occurrences = 0;
+	const recordedIndices: number[] = [];
+	let searchStart = 0;
+
+	while (searchStart <= content.length - target.length) {
+		const index = content.indexOf(target, searchStart);
+		if (index === -1) break;
+
+		const endIndex = index + target.length;
+		if (!excludedRanges.some(range => index < range.endIndex && endIndex > range.startIndex)) {
+			firstIndex ??= index;
+			occurrences++;
+			if (recordedIndices.length < MAX_RECORDED_MATCHES) {
+				recordedIndices.push(index);
+			}
+		}
+		searchStart = endIndex;
+	}
+
+	if (firstIndex === undefined) {
 		return undefined;
 	}
 
-	const occurrences = content.split(target).length - 1;
 	if (occurrences > 1) {
 		const contentLines = content.split("\n");
 		const occurrenceLines: number[] = [];
 		const occurrencePreviews: string[] = [];
-		let searchStart = 0;
-
-		for (let i = 0; i < MAX_RECORDED_MATCHES; i++) {
-			const idx = content.indexOf(target, searchStart);
-			if (idx === -1) break;
-			const lineNumber = content.slice(0, idx).split("\n").length;
+		for (const index of recordedIndices) {
+			const lineNumber = content.slice(0, index).split("\n").length;
 			occurrenceLines.push(lineNumber);
 			occurrencePreviews.push(
 				formatPreviewWindow(contentLines, lineNumber - 1, {
@@ -282,17 +300,16 @@ function findExactMatchOutcome(content: string, target: string): MatchOutcome |
 					maxLen: OCCURRENCE_PREVIEW_MAX_LEN,
 				}),
 			);
-			searchStart = idx + 1;
 		}
 
 		return { occurrences, occurrenceLines, occurrencePreviews };
 	}
 
-	const startLine = content.slice(0, exactIndex).split("\n").length;
+	const startLine = content.slice(0, firstIndex).split("\n").length;
 	return {
 		match: {
 			actualText: target,
-			startIndex: exactIndex,
+			startIndex: firstIndex,
 			startLine,
 			confidence: 1,
 		},
@@ -408,6 +425,7 @@ function findBestFuzzyMatchCore(
 	offsets: number[],
 	threshold: number,
 	includeDepth: boolean,
+	excludedRanges: readonly { startIndex: number; endIndex: number }[],
 ): BestFuzzyMatchResult {
 	const targetNormalized = normalizeLines(targetLines, includeDepth);
 
@@ -417,6 +435,12 @@ function findBestFuzzyMatchCore(
 	let aboveThresholdCount = 0;
 
 	for (let start = 0; start <= contentLines.length - targetLines.length; start++) {
+		const startIndex = offsets[start];
+		const endLine = start + targetLines.length - 1;
+		const endIndex = Math.max(startIndex + 1, offsets[endLine] + contentLines[endLine].length);
+		if (excludedRanges.some(range => startIndex < range.endIndex && endIndex > range.startIndex)) {
+			continue;
+		}
 		const windowLines = contentLines.slice(start, start + targetLines.length);
 		const windowNormalized = normalizeLines(windowLines, includeDepth);
 		let score = 0;
@@ -434,7 +458,7 @@ function findBestFuzzyMatchCore(
 			bestScore = score;
 			best = {
 				actualText: windowLines.join("\n"),
-				startIndex: offsets[start],
+				startIndex,
 				startLine: start + 1,
 				confidence: score,
 			};
@@ -446,7 +470,12 @@ function findBestFuzzyMatchCore(
 	return { best, aboveThresholdCount, secondBestScore };
 }
 
-function findBestFuzzyMatch(content: string, target: string, threshold: number): BestFuzzyMatchResult {
+function findBestFuzzyMatch(
+	content: string,
+	target: string,
+	threshold: number,
+	excludedRanges: readonly { startIndex: number; endIndex: number }[],
+): BestFuzzyMatchResult {
 	const contentLines = content.split("\n");
 	const targetLines = target.split("\n");
 
@@ -458,11 +487,18 @@ function findBestFuzzyMatch(content: string, target: string, threshold: number):
 	}
 
 	const offsets = computeLineOffsets(contentLines);
-	let result = findBestFuzzyMatchCore(contentLines, targetLines, offsets, threshold, true);
+	let result = findBestFuzzyMatchCore(contentLines, targetLines, offsets, threshold, true, excludedRanges);
 
 	// Retry without indent depth if match is close but below threshold
 	if (result.best && result.best.confidence < threshold && result.best.confidence >= FALLBACK_THRESHOLD) {
-		const noDepthResult = findBestFuzzyMatchCore(contentLines, targetLines, offsets, threshold, false);
+		const noDepthResult = findBestFuzzyMatchCore(
+			contentLines,
+			targetLines,
+			offsets,
+			threshold,
+			false,
+			excludedRanges,
+		);
 		if (noDepthResult.best && noDepthResult.best.confidence > result.best.confidence) {
 			result = noDepthResult;
 		}
@@ -473,25 +509,35 @@ function findBestFuzzyMatch(content: string, target: string, threshold: number):
 
 /**
  * Find a match for target text within content.
- * Used primarily for replace-mode edits.
+ * Used primarily for replace-mode edits; excluded ranges remain invisible to exact and fuzzy matching.
  */
 export function findMatch(
 	content: string,
 	target: string,
-	options: { allowFuzzy: boolean; threshold?: number },
+	options: {
+		allowFuzzy: boolean;
+		threshold?: number;
+		excludedRanges?: readonly { startIndex: number; endIndex: number }[];
+	},
 ): MatchOutcome {
 	if (target.length === 0) {
 		return {};
 	}
+	const excludedRanges = options.excludedRanges ?? [];
 
-	const exactMatch = findExactMatchOutcome(content, target);
+	const exactMatch = findExactMatchOutcome(content, target, excludedRanges);
 	if (exactMatch) {
 		return exactMatch;
 	}
 
 	// Try fuzzy match
 	const threshold = options.threshold ?? DEFAULT_FUZZY_THRESHOLD;
-	const { best, aboveThresholdCount, secondBestScore } = findBestFuzzyMatch(content, target, threshold);
+	const { best, aboveThresholdCount, secondBestScore } = findBestFuzzyMatch(
+		content,
+		target,
+		threshold,
+		excludedRanges,
+	);
 
 	if (!best) {
 		return {};
@@ -1012,24 +1058,31 @@ export function findContextLine(
 	return { index: undefined, confidence: bestScore };
 }
 
-export const replaceEditEntrySchema = type({
-	old_text: "string",
-	new_text: "string",
-	"all?": "boolean",
-});
-
 export const replaceEditSchema = type({
 	path: "string",
-	edits: replaceEditEntrySchema.array(),
+	old_string: "string",
+	new_string: "string",
+	"replace_all?": "boolean",
 });
 
-export type ReplaceEditEntry = typeof replaceEditEntrySchema.infer;
 export type ReplaceParams = typeof replaceEditSchema.infer;
 
-export interface ExecuteReplaceSingleOptions {
+/**
+ * Internal batch form of {@link ReplaceParams}, produced only by the Cursor
+ * exec bridge: a `pi_edit` frame carries several replacements against one
+ * path but must run as a single tool lifecycle with one aggregate result.
+ * Never advertised to the model — the agent loop validates model calls
+ * against {@link replaceEditSchema}, which has no `edits` field.
+ */
+export interface ReplaceBatchParams {
+	path: string;
+	edits: Omit<ReplaceParams, "path">[];
+}
+
+export interface ExecuteReplaceOptions {
 	session: ToolSession;
 	path: string;
-	params: ReplaceEditEntry;
+	params: Omit<ReplaceParams, "path">;
 	signal?: AbortSignal;
 	batchRequest?: LspBatchRequest;
 	allowFuzzy: boolean;
@@ -1038,9 +1091,9 @@ export interface ExecuteReplaceSingleOptions {
 	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
 }
 
-export async function executeReplaceSingle(
-	options: ExecuteReplaceSingleOptions,
-): Promise<AgentToolResult<EditToolDetails, ReplaceEditEntry>> {
+export async function executeReplace(
+	options: ExecuteReplaceOptions,
+): Promise<AgentToolResult<EditToolDetails, ReplaceParams>> {
 	const {
 		session,
 		path,
@@ -1052,12 +1105,12 @@ export async function executeReplaceSingle(
 		writethrough,
 		beginDeferredDiagnosticsForPath,
 	} = options;
-	const { old_text, new_text, all } = params;
+	const { old_string, new_string, replace_all } = params;
 
 	enforcePlanModeWrite(session, path);
 
-	if (old_text.length === 0) {
-		throw new Error("old_text must not be empty.");
+	if (old_string.length === 0) {
+		throw new Error("old_string must not be empty.");
 	}
 
 	const absolutePath = resolvePlanPath(session, path);
@@ -1065,12 +1118,12 @@ export async function executeReplaceSingle(
 	const { bom, text: content } = stripBom(rawContent);
 	const originalEnding = detectLineEnding(content);
 	const normalizedContent = normalizeToLF(content);
-	const normalizedOldText = normalizeToLF(old_text);
-	const normalizedNewText = normalizeToLF(new_text);
+	const normalizedOldText = normalizeToLF(old_string);
+	const normalizedNewText = normalizeToLF(new_string);
 
 	const result = replaceText(normalizedContent, normalizedOldText, normalizedNewText, {
 		fuzzy: allowFuzzy,
-		all: all ?? false,
+		all: replace_all ?? false,
 		threshold: fuzzyThreshold,
 	});
 

package/src/edit/renderer.ts

@@ -115,7 +115,7 @@ interface EditRenderArgs {
 	patch?: string;
 	input?: string;
 	_input?: string;
-	all?: boolean;
+	replace_all?: boolean;
 	// Patch mode fields
 	op?: Operation;
 	rename?: unknown;