pi-readseek 0.3.19 → 0.3.21

package/src/edit.ts

@@ -7,6 +7,7 @@ import { createPatch } from "diff";
 import { detectLineEnding, generateCompactOrFullDiff, normalizeToLF, replaceText, restoreLineEndings, stripBom } from "./edit-diff.js";
 import { HashlineMismatchError, applyHashlineEdits, computeLineHash, ensureHashInit, parseLineRef, type HashlineEditItem, escapeControlCharsForDisplay } from "./hashline.js";
 import { resolveToCwd } from "./path-utils.js";
+import { looksLikeBinary } from "./binary-detect.js";
 import { throwIfAborted } from "./runtime.js";
 import { buildEditOutput } from "./edit-output.js";
 import { classifyEdit, isDifftAvailable, runDifftastic } from "./edit-classify.js";
@@ -21,6 +22,7 @@ import { buildEditPreviewKey, buildPendingEditPreviewData, resolvePendingDiffPre
 import { buildDiffData, type DiffBlockRange } from "./diff-data.js";
 import { clampLineToWidth, clampLinesToWidth, linkToolPath, resolveRenderResultContext, summaryLine } from "./tui-render-utils.js";
 import { DiffPreviewComponent } from "./tui-diff-component.js";
+import type { FreshAnchorsPredicate } from "./tool-types.js";
 
 import { resolveEditDiffDisplay } from "./readseek-settings.js";
 
@@ -41,10 +43,6 @@ export function wrapWriteError(err: any, path: string): Error {
 	return new Error(`Failed to write file: ${path}`);
 }
 
-export function isBinaryBuffer(buf: Buffer): boolean {
-	return buf.includes(0);
-}
-
 
 const hashlineEditItemSchema = Type.Union([
 	Type.Object({ set_line: Type.Object({ anchor: Type.String(), new_text: Type.String() }) }, { additionalProperties: true }),
@@ -137,443 +135,462 @@ function mapEditFileError(err: any, filePath: string, displayPath: string, phase
 }
 
 export interface EditToolOptions {
-	wasReadInSession?: (absolutePath: string) => boolean;
+	wasReadInSession?: FreshAnchorsPredicate;
 	syntaxValidate?: SyntaxValidateOptions["syntaxValidate"];
 }
 
+export interface ExecuteEditOptions {
+	params: unknown;
+	signal: AbortSignal | undefined;
+	cwd: string;
+	wasReadInSession?: FreshAnchorsPredicate;
+	syntaxValidate?: SyntaxValidateOptions["syntaxValidate"];
+}
 
-export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}) {
-	const toolConfig = {
-		callable: true,
-		enabled: true,
-		policy: "mutating" as const,
-		readOnly: false,
-		pythonName: "edit",
-		defaultExposure: "not-safe-by-default" as const,
-	};
-	const tool = {
-		name: "edit",
-		label: "Edit",
-		description: EDIT_PROMPT_METADATA.description,
-		promptSnippet: EDIT_PROMPT_METADATA.promptSnippet,
-		promptGuidelines: EDIT_PROMPT_METADATA.promptGuidelines,
-		parameters: hashlineEditSchema,
-		ptc: toolConfig,
-		renderShell: "default" as const,
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			await ensureHashInit();
-			const parsed = params as HashlineParams;
-			const input = params as Record<string, unknown>;
-			const rawPath = parsed.path;
-			const path = rawPath.replace(/^@/, "");
-			const absolutePath = resolveToCwd(path, ctx.cwd);
-			throwIfAborted(signal);
-			try {
-				return await withFileMutationQueue(absolutePath, async () => {
-				throwIfAborted(signal);
-			if (options.wasReadInSession && !options.wasReadInSession(absolutePath)) {
-				const message = [
-					`You must get fresh anchors for ${absolutePath} before editing it.`,
-					`Call read(${JSON.stringify(rawPath)}) first, or use grep, search, or write to produce fresh anchors for this file.`,
-					"edit requires fresh LINE:HASH anchors from read, grep, search, or write so the hashes match the current file contents.",
-				].join(" ");
-				return buildEditError(
-					absolutePath,
-					"file-not-read",
-					message,
-					`Call read(${JSON.stringify(rawPath)}) first, or use grep, search, or write to produce fresh anchors for this file.`,
-				);
-			}
-			const hasTopLevelReplaceInput =
-				typeof input.oldText === "string" ||
-				typeof input.newText === "string" ||
-				typeof input.old_text === "string" ||
-				typeof input.new_text === "string";
-			if (hasTopLevelReplaceInput) {
-				return buildEditError(
-					absolutePath,
-					"invalid-edit-variant",
-					"Top-level oldText/newText and old_text/new_text are no longer supported. Use edits[0].replace instead.",
-					"Use edits: [{ replace: { old_text, new_text } }].",
-				);
-			}
+export async function executeEdit(opts: ExecuteEditOptions): Promise<any> {
+	const { params, signal, cwd, wasReadInSession, syntaxValidate } = opts;
+	await ensureHashInit();
+	const parsed = params as HashlineParams;
+	const input = params as Record<string, unknown>;
+	const rawPath = parsed.path;
+	const path = rawPath.replace(/^@/, "");
+	const absolutePath = resolveToCwd(path, cwd);
+	throwIfAborted(signal);
+	try {
+		return await withFileMutationQueue(absolutePath, async () => {
+		throwIfAborted(signal);
+	if (wasReadInSession && !wasReadInSession(absolutePath)) {
+		const message = [
+			`You must get fresh anchors for ${absolutePath} before editing it.`,
+			`Call read(${JSON.stringify(rawPath)}) first, or use grep, search, or write to produce fresh anchors for this file.`,
+			"edit requires fresh LINE:HASH anchors from read, grep, search, or write so the hashes match the current file contents.",
+		].join(" ");
+		return buildEditError(
+			absolutePath,
+			"file-not-read",
+			message,
+			`Call read(${JSON.stringify(rawPath)}) first, or use grep, search, or write to produce fresh anchors for this file.`,
+		);
+	}
+	const hasTopLevelReplaceInput =
+		typeof input.oldText === "string" ||
+		typeof input.newText === "string" ||
+		typeof input.old_text === "string" ||
+		typeof input.new_text === "string";
+	if (hasTopLevelReplaceInput) {
+		return buildEditError(
+			absolutePath,
+			"invalid-edit-variant",
+			"Top-level oldText/newText and old_text/new_text are no longer supported. Use edits[0].replace instead.",
+			"Use edits: [{ replace: { old_text, new_text } }].",
+		);
+	}
 
-			const edits = parsed.edits ?? [];
+	const edits = parsed.edits ?? [];
 
-			if (!edits.length) {
-				return buildEditError(absolutePath, "invalid-edit-variant", "No edits provided.");
-			}
+	if (!edits.length) {
+		return buildEditError(absolutePath, "invalid-edit-variant", "No edits provided.");
+	}
 
-			// Validate edit variant keys
-			for (let i = 0; i < edits.length; i++) {
-				throwIfAborted(signal);
-				const e = edits[i] as Record<string, unknown>;
-				if (("old_text" in e || "new_text" in e) && !("replace" in e)) {
-					const message = `edits[${i}] has top-level 'old_text'/'new_text'. Use {replace: {old_text, new_text}} or {set_line}, {replace_lines}, {insert_after}.`;
-					return buildEditError(absolutePath, "invalid-edit-variant", message);
-				}
-				if ("diff" in e) {
-					const message = `edits[${i}] contains 'diff' from patch mode. Hashline edit expects one of: {set_line}, {replace_lines}, {insert_after}, {replace}.`;
-					return buildEditError(absolutePath, "invalid-edit-variant", message);
-				}
-				const variantCount =
-					Number("set_line" in e) +
-					Number("replace_lines" in e) +
-					Number("insert_after" in e) +
-					Number("replace" in e) +
-					Number("replace_symbol" in e);
-				if (variantCount !== 1) {
-					const message = `edits[${i}] must contain exactly one of: 'set_line', 'replace_lines', 'insert_after', 'replace', 'replace_symbol'. Got: [${Object.keys(e).join(", ")}].`;
-					return buildEditError(absolutePath, "invalid-edit-variant", message);
-				}
-			}
+	// Validate edit variant keys
+	for (let i = 0; i < edits.length; i++) {
+		throwIfAborted(signal);
+		const e = edits[i] as Record<string, unknown>;
+		if (("old_text" in e || "new_text" in e) && !("replace" in e)) {
+			const message = `edits[${i}] has top-level 'old_text'/'new_text'. Use {replace: {old_text, new_text}} or {set_line}, {replace_lines}, {insert_after}.`;
+			return buildEditError(absolutePath, "invalid-edit-variant", message);
+		}
+		if ("diff" in e) {
+			const message = `edits[${i}] contains 'diff' from patch mode. Hashline edit expects one of: {set_line}, {replace_lines}, {insert_after}, {replace}.`;
+			return buildEditError(absolutePath, "invalid-edit-variant", message);
+		}
+		const variantCount =
+			Number("set_line" in e) +
+			Number("replace_lines" in e) +
+			Number("insert_after" in e) +
+			Number("replace" in e) +
+			Number("replace_symbol" in e);
+		if (variantCount !== 1) {
+			const message = `edits[${i}] must contain exactly one of: 'set_line', 'replace_lines', 'insert_after', 'replace', 'replace_symbol'. Got: [${Object.keys(e).join(", ")}].`;
+			return buildEditError(absolutePath, "invalid-edit-variant", message);
+		}
+	}
 
-			const anchorEdits = edits.filter(
-				(e): e is HashlineEditItem => "set_line" in e || "replace_lines" in e || "insert_after" in e,
-			);
-			const replaceEdits = edits.filter(
-				(e): e is { replace: { old_text: string; new_text: string; all?: boolean; fuzzy?: boolean } } => "replace" in e,
-			);
-			const replaceSymbolEdits = edits.filter(
-				(e): e is { replace_symbol: { symbol: string; new_body: string } } => "replace_symbol" in e,
-			);
-			for (const rs of replaceSymbolEdits) {
-				if (!rs.replace_symbol.new_body.trim()) {
-					return buildEditError(absolutePath, "invalid-edit-variant", "replace_symbol.new_body must not be empty or whitespace-only.");
-				}
-			}
+	const anchorEdits = edits.filter(
+		(e): e is HashlineEditItem => "set_line" in e || "replace_lines" in e || "insert_after" in e,
+	);
+	const replaceEdits = edits.filter(
+		(e): e is { replace: { old_text: string; new_text: string; all?: boolean; fuzzy?: boolean } } => "replace" in e,
+	);
+	const replaceSymbolEdits = edits.filter(
+		(e): e is { replace_symbol: { symbol: string; new_body: string } } => "replace_symbol" in e,
+	);
+	for (const rs of replaceSymbolEdits) {
+		if (!rs.replace_symbol.new_body.trim()) {
+			return buildEditError(absolutePath, "invalid-edit-variant", "replace_symbol.new_body must not be empty or whitespace-only.");
+		}
+	}
 
-			let rawBuffer: Buffer;
+	let rawBuffer: Buffer;
+	try {
+		rawBuffer = await fsReadFile(absolutePath);
+	} catch (err: any) {
+		return mapEditFileError(err, absolutePath, path, "read");
+	}
+	if (looksLikeBinary(rawBuffer)) {
+		const message = `Cannot edit binary file: ${path}`;
+		return buildEditError(absolutePath, "binary-file", message);
+	}
+	throwIfAborted(signal);
+	const raw = rawBuffer.toString("utf-8");
+	const { bom, text: content } = stripBom(raw);
+	const originalEnding = detectLineEnding(content);
+	const originalNormalized = normalizeToLF(content);
+	const origLines = originalNormalized.split("\n");
+	const anchorSnapshots = new Map<string, string>();
+	for (const edit of anchorEdits) {
+		const refs: string[] = [];
+		if ("set_line" in edit) refs.push(edit.set_line.anchor);
+		else if ("replace_lines" in edit) {
+			refs.push(edit.replace_lines.start_anchor, edit.replace_lines.end_anchor);
+		} else if ("insert_after" in edit) refs.push(edit.insert_after.anchor);
+		for (const ref of refs) {
 			try {
-				rawBuffer = await fsReadFile(absolutePath);
-			} catch (err: any) {
-				return mapEditFileError(err, absolutePath, path, "read");
-			}
-			if (isBinaryBuffer(rawBuffer)) {
-				const message = `Cannot edit binary file: ${path}`;
-				return buildEditError(absolutePath, "binary-file", message);
-			}
-			throwIfAborted(signal);
-			const raw = rawBuffer.toString("utf-8");
-			const { bom, text: content } = stripBom(raw);
-			const originalEnding = detectLineEnding(content);
-			const originalNormalized = normalizeToLF(content);
-			const origLines = originalNormalized.split("\n");
-			const anchorSnapshots = new Map<string, string>();
-			for (const edit of anchorEdits) {
-				const refs: string[] = [];
-				if ("set_line" in edit) refs.push(edit.set_line.anchor);
-				else if ("replace_lines" in edit) {
-					refs.push(edit.replace_lines.start_anchor, edit.replace_lines.end_anchor);
-				} else if ("insert_after" in edit) refs.push(edit.insert_after.anchor);
-				for (const ref of refs) {
-					try {
-						const parsed = parseLineRef(ref);
-						if (parsed.line >= 1 && parsed.line <= origLines.length) {
-							const lineContent = origLines[parsed.line - 1];
-							const hash = computeLineHash(parsed.line, lineContent);
-							anchorSnapshots.set(ref, `${parsed.line}:${hash}|${escapeControlCharsForDisplay(lineContent)}`);
-						}
-					} catch {
-						/* skip malformed refs */
-					}
-				}
-			}
-			let preAnchorContent = originalNormalized;
-			// AC 26: reject anchored edits that target a line inside any replace_symbol
-			// pre-replace range. Resolve each target against the ORIGINAL content so the
-			// user-provided anchor line numbers (which reference the file as read) are
-			// compared against the pre-replace coordinates.
-			//
-			// F2: surface replace_symbol symbol-resolution errors (not-found, ambiguous)
-			// BEFORE the AC 26 overlap check and before any write (C1 preserved).
-			// Error-precedence order: replace_symbol resolution > anchor-overlap > anchored-edit.
-			//
-			// AC 4: store successful probe results and reuse them in the apply loop so
-			// readseekMapContent is invoked at most once per replace_symbol edit.
-			const replaceSymbolRanges: { start: number; end: number }[] = [];
-			const rsProbeResults: { type: "ok"; content: string; replacement: string; warnings: string[]; range: { start: number; end: number } }[] = [];
-			for (const rs of replaceSymbolEdits) {
-				const probe = await replaceSymbol({
-					filePath: absolutePath,
-					content: originalNormalized,
-					symbol: rs.replace_symbol.symbol,
-					newBody: rs.replace_symbol.new_body,
-				});
-				if (probe.type !== "ok") {
-					// F2: symbol-resolution errors surface before AC 26 overlap check.
-					return buildEditError(absolutePath, "invalid-edit-variant", probe.message);
+				const parsed = parseLineRef(ref);
+				if (parsed.line >= 1 && parsed.line <= origLines.length) {
+					const lineContent = origLines[parsed.line - 1];
+					const hash = computeLineHash(parsed.line, lineContent);
+					anchorSnapshots.set(ref, `${parsed.line}:${hash}|${escapeControlCharsForDisplay(lineContent)}`);
 				}
-				rsProbeResults.push(probe);
-				replaceSymbolRanges.push(probe.range);
+			} catch {
+				/* skip malformed refs */
 			}
+		}
+	}
+	let preAnchorContent = originalNormalized;
+	// AC 26: reject anchored edits that target a line inside any replace_symbol
+	// pre-replace range. Resolve each target against the ORIGINAL content so the
+	// user-provided anchor line numbers (which reference the file as read) are
+	// compared against the pre-replace coordinates.
+	//
+	// F2: surface replace_symbol symbol-resolution errors (not-found, ambiguous)
+	// BEFORE the AC 26 overlap check and before any write (C1 preserved).
+	// Error-precedence order: replace_symbol resolution > anchor-overlap > anchored-edit.
+	//
+	// AC 4: store successful probe results and reuse them in the apply loop so
+	// readseekMapContent is invoked at most once per replace_symbol edit.
+	const replaceSymbolRanges: { start: number; end: number }[] = [];
+	const rsProbeResults: { type: "ok"; content: string; replacement: string; warnings: string[]; range: { start: number; end: number } }[] = [];
+	for (const rs of replaceSymbolEdits) {
+		const probe = await replaceSymbol({
+			filePath: absolutePath,
+			content: originalNormalized,
+			symbol: rs.replace_symbol.symbol,
+			newBody: rs.replace_symbol.new_body,
+		});
+		if (probe.type !== "ok") {
+			// F2: symbol-resolution errors surface before AC 26 overlap check.
+			return buildEditError(absolutePath, "invalid-edit-variant", probe.message);
+		}
+		rsProbeResults.push(probe);
+		replaceSymbolRanges.push(probe.range);
+	}
 
-			const sortedReplaceSymbolRanges = [...replaceSymbolRanges].sort((a, b) => a.start - b.start || a.end - b.end);
-			for (let i = 1; i < sortedReplaceSymbolRanges.length; i++) {
-				const prev = sortedReplaceSymbolRanges[i - 1];
-				const current = sortedReplaceSymbolRanges[i];
-				if (current.start <= prev.end) {
-					const message = `replace_symbol ranges overlap or duplicate (lines ${prev.start}-${prev.end} and ${current.start}-${current.end}).`;
-					return buildEditError(absolutePath, "invalid-edit-variant", message);
+	const sortedReplaceSymbolRanges = [...replaceSymbolRanges].sort((a, b) => a.start - b.start || a.end - b.end);
+	for (let i = 1; i < sortedReplaceSymbolRanges.length; i++) {
+		const prev = sortedReplaceSymbolRanges[i - 1];
+		const current = sortedReplaceSymbolRanges[i];
+		if (current.start <= prev.end) {
+			const message = `replace_symbol ranges overlap or duplicate (lines ${prev.start}-${prev.end} and ${current.start}-${current.end}).`;
+			return buildEditError(absolutePath, "invalid-edit-variant", message);
+		}
+	}
+	if (replaceSymbolRanges.length > 0) {
+		for (const edit of anchorEdits) {
+			if ("replace_lines" in edit) {
+				let startLine: number | undefined;
+				let endLine: number | undefined;
+				try {
+					startLine = parseLineRef(edit.replace_lines.start_anchor).line;
+					endLine = parseLineRef(edit.replace_lines.end_anchor).line;
+				} catch {
+					// Let the normal anchored edit validation report malformed anchors later.
 				}
-			}
-			if (replaceSymbolRanges.length > 0) {
-				for (const edit of anchorEdits) {
-					if ("replace_lines" in edit) {
-						let startLine: number | undefined;
-						let endLine: number | undefined;
-						try {
-							startLine = parseLineRef(edit.replace_lines.start_anchor).line;
-							endLine = parseLineRef(edit.replace_lines.end_anchor).line;
-						} catch {
-							// Let the normal anchored edit validation report malformed anchors later.
-						}
-						if (startLine !== undefined && endLine !== undefined) {
-							const lo = Math.min(startLine, endLine);
-							const hi = Math.max(startLine, endLine);
-							for (const range of replaceSymbolRanges) {
-								if (lo <= range.end && hi >= range.start) {
-									const message = `replace_lines range ${lo}-${hi} overlaps a replace_symbol range (lines ${range.start}-${range.end}).`;
-						return buildEditError(absolutePath, "invalid-edit-variant", message);
-								}
-							}
-						}
-					}
-					const refs: string[] = [];
-					if ("set_line" in edit) refs.push(edit.set_line.anchor);
-					else if ("replace_lines" in edit) {
-						refs.push(edit.replace_lines.start_anchor, edit.replace_lines.end_anchor);
-					} else if ("insert_after" in edit) refs.push(edit.insert_after.anchor);
-					for (const ref of refs) {
-						let parsedLine: number | undefined;
-						try {
-							parsedLine = parseLineRef(ref).line;
-						} catch {
-							continue;
-						}
-						for (const range of replaceSymbolRanges) {
-							if (parsedLine >= range.start && parsedLine <= range.end) {
-								const message = `Anchor at line ${parsedLine} falls inside a replace_symbol range (lines ${range.start}-${range.end}).`;
-						return buildEditError(absolutePath, "invalid-edit-variant", message);
-							}
+				if (startLine !== undefined && endLine !== undefined) {
+					const lo = Math.min(startLine, endLine);
+					const hi = Math.max(startLine, endLine);
+					for (const range of replaceSymbolRanges) {
+						if (lo <= range.end && hi >= range.start) {
+							const message = `replace_lines range ${lo}-${hi} overlaps a replace_symbol range (lines ${range.start}-${range.end}).`;
+				return buildEditError(absolutePath, "invalid-edit-variant", message);
 						}
 					}
 				}
 			}
-			// Apply pass: reuse all probe results (AC 4). The probe pass resolved every
-			// replace_symbol against originalNormalized; apply those replacements in
-			// reverse source order so original line ranges stay valid and no second
-			// replaceSymbol/readseekMapContent call is needed.
-			const replaceSymbolWarnings: string[] = [];
-			if (rsProbeResults.length > 0) {
-				const lines = originalNormalized.split("\n");
-				for (const probe of rsProbeResults) {
-					replaceSymbolWarnings.push(...probe.warnings);
+			const refs: string[] = [];
+			if ("set_line" in edit) refs.push(edit.set_line.anchor);
+			else if ("replace_lines" in edit) {
+				refs.push(edit.replace_lines.start_anchor, edit.replace_lines.end_anchor);
+			} else if ("insert_after" in edit) refs.push(edit.insert_after.anchor);
+			for (const ref of refs) {
+				let parsedLine: number | undefined;
+				try {
+					parsedLine = parseLineRef(ref).line;
+				} catch {
+					continue;
 				}
-				for (const probe of [...rsProbeResults].sort((a, b) => b.range.start - a.range.start)) {
-					lines.splice(
-						probe.range.start - 1,
-						probe.range.end - probe.range.start + 1,
-						...probe.replacement.split("\n"),
-					);
+				for (const range of replaceSymbolRanges) {
+					if (parsedLine >= range.start && parsedLine <= range.end) {
+						const message = `Anchor at line ${parsedLine} falls inside a replace_symbol range (lines ${range.start}-${range.end}).`;
+				return buildEditError(absolutePath, "invalid-edit-variant", message);
+					}
 				}
-				preAnchorContent = lines.join("\n");
 			}
-			let result = preAnchorContent;
+		}
+	}
+	// Apply pass: reuse all probe results (AC 4). The probe pass resolved every
+	// replace_symbol against originalNormalized; apply those replacements in
+	// reverse source order so original line ranges stay valid and no second
+	// replaceSymbol/readseekMapContent call is needed.
+	const replaceSymbolWarnings: string[] = [];
+	if (rsProbeResults.length > 0) {
+		const lines = originalNormalized.split("\n");
+		for (const probe of rsProbeResults) {
+			replaceSymbolWarnings.push(...probe.warnings);
+		}
+		for (const probe of [...rsProbeResults].sort((a, b) => b.range.start - a.range.start)) {
+			lines.splice(
+				probe.range.start - 1,
+				probe.range.end - probe.range.start + 1,
+				...probe.replacement.split("\n"),
+			);
+		}
+		preAnchorContent = lines.join("\n");
+	}
+	let result = preAnchorContent;
+
+	let anchorResult;
+	try {
+		anchorResult = applyHashlineEdits(result, anchorEdits, signal);
+	} catch (err) {
+		if (err instanceof HashlineMismatchError) {
+			return buildEditError(absolutePath, "hash-mismatch", err.message, undefined, {
+				updatedAnchors: err.updatedAnchors,
+			});
+		}
+		throw err;
+	}
+	result = anchorResult.content;
+
+	const replaceWarnings: string[] = [];
+	for (const r of replaceEdits) {
+		throwIfAborted(signal);
+		if (!r.replace.old_text.length) {
+			const message = "replace.old_text must not be empty.";
+			return buildEditError(absolutePath, "invalid-edit-variant", message);
+		}
+		const rep = replaceText(result, r.replace.old_text, r.replace.new_text, {
+			all: r.replace.all ?? false,
+			fuzzy: r.replace.fuzzy ?? false,
+		});
+		if (!rep.count) {
+			const message = `Could not find exact text to replace in ${path}.`;
+			const hint =
+				"Re-read the file and prefer set_line/replace_lines/insert_after for hash-verified edits. " +
+				"The replace variant is exact-only by default because fuzzy fallback is unverified.";
+			return buildEditError(absolutePath, "text-not-found", message, hint);
+		}
+		if (rep.usedFuzzyMatch) {
+			replaceWarnings.push(
+				"replace used fuzzy matching because exact old_text was not found; re-read the file and prefer set_line/replace_lines/insert_after for hash-verified edits.",
+			);
+		}
+		result = rep.content;
+	}
 
-			let anchorResult;
-			try {
-				anchorResult = applyHashlineEdits(result, anchorEdits, signal);
-			} catch (err) {
-				if (err instanceof HashlineMismatchError) {
-					return buildEditError(absolutePath, "hash-mismatch", err.message, undefined, {
-						updatedAnchors: err.updatedAnchors,
-					});
-				}
-				throw err;
-			}
-			result = anchorResult.content;
-
-			const replaceWarnings: string[] = [];
-			for (const r of replaceEdits) {
-				throwIfAborted(signal);
-				if (!r.replace.old_text.length) {
-					const message = "replace.old_text must not be empty.";
-					return buildEditError(absolutePath, "invalid-edit-variant", message);
-				}
-				const rep = replaceText(result, r.replace.old_text, r.replace.new_text, {
-					all: r.replace.all ?? false,
-					fuzzy: r.replace.fuzzy ?? false,
-				});
-				if (!rep.count) {
-					const message = `Could not find exact text to replace in ${path}.`;
-					const hint =
-						"Re-read the file and prefer set_line/replace_lines/insert_after for hash-verified edits. " +
-						"The replace variant is exact-only by default because fuzzy fallback is unverified.";
-					return buildEditError(absolutePath, "text-not-found", message, hint);
-				}
-				if (rep.usedFuzzyMatch) {
-					replaceWarnings.push(
-						"replace used fuzzy matching because exact old_text was not found; re-read the file and prefer set_line/replace_lines/insert_after for hash-verified edits.",
-					);
-				}
-				result = rep.content;
+	if (originalNormalized === result) {
+		let diagnostic = `No changes made to ${path}. The edits produced identical content.`;
+		if (anchorResult.noopEdits?.length) {
+			diagnostic +=
+				"\n" +
+				anchorResult.noopEdits
+					.map(
+						(e) =>
+							`Edit ${e.editIndex}: replacement for ${e.loc} is identical to current content:\n  ${e.loc}| ${escapeControlCharsForDisplay(e.currentContent)}`,
+					)
+					.join("\n");
+			diagnostic += "\nRe-read the file to see the current state.";
+		} else {
+			const targetLines = [...new Set(anchorSnapshots.values())];
+			if (targetLines.length > 0) {
+				const preview = targetLines.slice(0, 5).join("\n");
+				diagnostic += `\nThe file currently contains:\n${preview}\nYour edits were normalized back to the original content. Ensure your replacement changes actual code, not just formatting.`;
 			}
+		}
+		return buildEditError(absolutePath, "no-op", diagnostic);
+	}
 
-			if (originalNormalized === result) {
-				let diagnostic = `No changes made to ${path}. The edits produced identical content.`;
-				if (anchorResult.noopEdits?.length) {
-					diagnostic +=
-						"\n" +
-						anchorResult.noopEdits
-							.map(
-								(e) =>
-									`Edit ${e.editIndex}: replacement for ${e.loc} is identical to current content:\n  ${e.loc}| ${escapeControlCharsForDisplay(e.currentContent)}`,
-							)
-							.join("\n");
-					diagnostic += "\nRe-read the file to see the current state.";
-				} else {
-					const targetLines = [...new Set(anchorSnapshots.values())];
-					if (targetLines.length > 0) {
-						const preview = targetLines.slice(0, 5).join("\n");
-						diagnostic += `\nThe file currently contains:\n${preview}\nYour edits were normalized back to the original content. Ensure your replacement changes actual code, not just formatting.`;
-					}
-				}
-				return buildEditError(absolutePath, "no-op", diagnostic);
+	throwIfAborted(signal);
+
+	// Syntax-regression validator (warn/block/off)
+	const syntaxMode = resolveSyntaxValidateMode({ syntaxValidate: syntaxValidate });
+	let syntaxWarning: string | undefined;
+	if (syntaxMode !== "off") {
+		const regression = await validateSyntaxRegression({
+			filePath: absolutePath,
+			before: originalNormalized,
+			after: result,
+		});
+		if (regression) {
+			const lines = regression.errorLines.join(", ");
+			const message = `syntax-regression: lines ${lines}`;
+			// Task 7 (AC 12): block mode aborts with syntax-regression code; file is left untouched.
+			if (syntaxMode === "block") {
+				return buildEditError(absolutePath, "syntax-regression", message);
 			}
+			syntaxWarning = message;
+		}
+	}
+	const writeContent = bom + restoreLineEndings(result, originalEnding);
+	try {
+		await fsWriteFile(absolutePath, writeContent, "utf-8");
+	} catch (err: any) {
+		return mapEditFileError(err, absolutePath, path, "write");
+	}
 
-			throwIfAborted(signal);
-
-			// Syntax-regression validator (warn/block/off)
-			const syntaxMode = resolveSyntaxValidateMode({ syntaxValidate: options.syntaxValidate });
-			let syntaxWarning: string | undefined;
-			if (syntaxMode !== "off") {
-				const regression = await validateSyntaxRegression({
-					filePath: absolutePath,
-					before: originalNormalized,
-					after: result,
-				});
-				if (regression) {
-					const lines = regression.errorLines.join(", ");
-					const message = `syntax-regression: lines ${lines}`;
-					// Task 7 (AC 12): block mode aborts with syntax-regression code; file is left untouched.
-					if (syntaxMode === "block") {
-						return buildEditError(absolutePath, "syntax-regression", message);
-					}
-					syntaxWarning = message;
-				}
-			}
-			const writeContent = bom + restoreLineEndings(result, originalEnding);
-			try {
-				await fsWriteFile(absolutePath, writeContent, "utf-8");
-			} catch (err: any) {
-				return mapEditFileError(err, absolutePath, path, "write");
-			}
+	if (input.postEditVerify === true) {
+		let verifiedContent: string;
+		try {
+			const verified = await fsReadFile(absolutePath, "utf-8");
+			verifiedContent = verified;
+		} catch (err: any) {
+			const message = `Edit write completed but post-edit verification failed: could not read ${path} after writing.`;
+			return buildEditError(absolutePath, "post-edit-verification-read-failed", message, undefined, {
+					fsCode: err?.code,
+					fsMessage: err?.message,
+				},
+			);
+		}
+		if (verifiedContent !== writeContent) {
+			const message = `Edit write completed but post-edit verification did not confirm the intended content for ${path}. Re-read the file before making follow-up edits.`;
+			return buildEditError(absolutePath, "post-edit-verification-mismatch", message, undefined, {
+					expectedLength: writeContent.length,
+					actualLength: verifiedContent.length,
+				},
+			);
+		}
+	}
 
-			if (input.postEditVerify === true) {
-				let verifiedContent: string;
-				try {
-					const verified = await fsReadFile(absolutePath, "utf-8");
-					verifiedContent = verified;
-				} catch (err: any) {
-					const message = `Edit write completed but post-edit verification failed: could not read ${path} after writing.`;
-					return buildEditError(absolutePath, "post-edit-verification-read-failed", message, undefined, {
-							fsCode: err?.code,
-							fsMessage: err?.message,
-						},
-					);
-				}
-				if (verifiedContent !== writeContent) {
-					const message = `Edit write completed but post-edit verification did not confirm the intended content for ${path}. Re-read the file before making follow-up edits.`;
-					return buildEditError(absolutePath, "post-edit-verification-mismatch", message, undefined, {
-							expectedLength: writeContent.length,
-							actualLength: verifiedContent.length,
-						},
-					);
-				}
-			}
+	const diffResult = generateCompactOrFullDiff(originalNormalized, result);
+	const patch = createPatch(path, originalNormalized, result);
+	const blockRanges: DiffBlockRange[] = rsProbeResults.map((probe) => ({
+		kind: "remove" as const,
+		startLine: probe.range.start,
+		endLine: probe.range.end,
+	}));
+	const diffData = buildDiffData({
+		path: absolutePath,
+		oldContent: originalNormalized,
+		newContent: result,
+		diff: diffResult.diff,
+		...(blockRanges.length ? { blockRanges } : {}),
+	});
+	const warnings: string[] = [];
+	if (anchorResult.warnings?.length) warnings.push(...anchorResult.warnings);
+	if (replaceWarnings.length) warnings.push(...replaceWarnings);
+	if (replaceSymbolWarnings.length) warnings.push(...replaceSymbolWarnings);
+	if (syntaxWarning) warnings.push(syntaxWarning);
+	// Semantic classification
+	const internalClassification = classifyEdit(originalNormalized, result);
+	const difftAvailable = await isDifftAvailable();
+	let semanticSummary: SemanticSummary = {
+		classification: internalClassification.classification,
+		difftasticAvailable: difftAvailable,
+	};
 
-			const diffResult = generateCompactOrFullDiff(originalNormalized, result);
-			const patch = createPatch(path, originalNormalized, result);
-			const blockRanges: DiffBlockRange[] = rsProbeResults.map((probe) => ({
-				kind: "remove" as const,
-				startLine: probe.range.start,
-				endLine: probe.range.end,
-			}));
-			const diffData = buildDiffData({
-				path: absolutePath,
-				oldContent: originalNormalized,
-				newContent: result,
-				diff: diffResult.diff,
-				...(blockRanges.length ? { blockRanges } : {}),
-			});
-			const warnings: string[] = [];
-			if (anchorResult.warnings?.length) warnings.push(...anchorResult.warnings);
-			if (replaceWarnings.length) warnings.push(...replaceWarnings);
-			if (replaceSymbolWarnings.length) warnings.push(...replaceSymbolWarnings);
-			if (syntaxWarning) warnings.push(syntaxWarning);
-			// Semantic classification
-			const internalClassification = classifyEdit(originalNormalized, result);
-			const difftAvailable = await isDifftAvailable();
-			let semanticSummary: SemanticSummary = {
-				classification: internalClassification.classification,
-				difftasticAvailable: difftAvailable,
+	if (difftAvailable) {
+		const ext = path.split(".").pop() ?? "txt";
+		const difftResult = await runDifftastic(originalNormalized, result, ext);
+		if (difftResult) {
+			semanticSummary = {
+				classification: difftResult.classification,
+				difftasticAvailable: true,
+				...(difftResult.movedBlocks > 0 ? { movedBlocks: difftResult.movedBlocks } : {}),
 			};
+		}
+	}
+	const builtOutput = buildEditOutput({
+		path: absolutePath,
+		displayPath: path,
+		diff: diffResult.diff,
+		patch,
+		diffData,
+		firstChangedLine: anchorResult.firstChangedLine ?? diffResult.firstChangedLine,
+		warnings,
+		noopEdits: anchorResult.noopEdits ?? [],
+		edits,
+		semanticSummary,
+	});
 
-			if (difftAvailable) {
-				const ext = path.split(".").pop() ?? "txt";
-				const difftResult = await runDifftastic(originalNormalized, result, ext);
-				if (difftResult) {
-					semanticSummary = {
-						classification: difftResult.classification,
-						difftasticAvailable: true,
-						...(difftResult.movedBlocks > 0 ? { movedBlocks: difftResult.movedBlocks } : {}),
-					};
-				}
-			}
-			const builtOutput = buildEditOutput({
-				path: absolutePath,
-				displayPath: path,
-				diff: diffResult.diff,
-				patch,
-				diffData,
-				firstChangedLine: anchorResult.firstChangedLine ?? diffResult.firstChangedLine,
-				warnings,
-				noopEdits: anchorResult.noopEdits ?? [],
-				edits,
-				semanticSummary,
-			});
-
-			return {
-				content: [{ type: "text", text: builtOutput.text }],
-				details: {
-					diff: diffResult.diff,
-					patch: builtOutput.patch,
-					diffData,
-					firstChangedLine: anchorResult.firstChangedLine ?? diffResult.firstChangedLine,
-					readseekValue: builtOutput.readseekValue,
-				} as EditToolDetails & {
-					diffData: typeof diffData;
-					readseekValue: {
-						tool: string;
-						ok: boolean;
-						path: string;
-						summary: string;
-						diff: string;
-						diffData: typeof diffData;
-						firstChangedLine: number | undefined;
-						warnings: string[];
-						noopEdits: unknown[];
-					};
-				},
+	return {
+		content: [{ type: "text", text: builtOutput.text }],
+		details: {
+			diff: diffResult.diff,
+			patch: builtOutput.patch,
+			diffData,
+			firstChangedLine: anchorResult.firstChangedLine ?? diffResult.firstChangedLine,
+			readseekValue: builtOutput.readseekValue,
+		} as EditToolDetails & {
+			diffData: typeof diffData;
+			readseekValue: {
+				tool: string;
+				ok: boolean;
+				path: string;
+				summary: string;
+				diff: string;
+				diffData: typeof diffData;
+				firstChangedLine: number | undefined;
+				warnings: string[];
+				noopEdits: unknown[];
 			};
-				});
-			} catch (err: any) {
-				if (typeof err?.code === "string") {
-					return mapEditFileError(err, absolutePath, path, "read");
-				}
-				throw err;
-			}
+		},
+	};
+		});
+	} catch (err: any) {
+		if (typeof err?.code === "string") {
+			return mapEditFileError(err, absolutePath, path, "read");
+		}
+		throw err;
+	}
+}
+
+
+export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}) {
+	const toolConfig = {
+		callable: true,
+		enabled: true,
+		policy: "mutating" as const,
+		readOnly: false,
+		pythonName: "edit",
+		defaultExposure: "not-safe-by-default" as const,
+	};
+	const tool = {
+		name: "edit",
+		label: "Edit",
+		description: EDIT_PROMPT_METADATA.description,
+		promptSnippet: EDIT_PROMPT_METADATA.promptSnippet,
+		promptGuidelines: EDIT_PROMPT_METADATA.promptGuidelines,
+		parameters: hashlineEditSchema,
+		ptc: toolConfig,
+		renderShell: "default" as const,
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+			return executeEdit({
+				params,
+				signal,
+				cwd: ctx.cwd,
+				wasReadInSession: options.wasReadInSession,
+				syntaxValidate: options.syntaxValidate,
+			});
 		},
 		renderCall(args: any, theme: any, ...rest: any[]) {
 			const context: { argsComplete?: boolean; executionStarted?: boolean; lastComponent?: any; cwd?: string; state?: Record<string, any>; invalidate?: () => void; width?: number; expanded?: boolean } = rest[0] ?? {};