@d3ara1n/pi-hashline-edit 0.1.1 → 0.2.0

package/src/core/types.ts

@@ -12,8 +12,8 @@ export interface Anchor {
 
 /**
  * Edit operation. Every line-numbered op references a line via {@link Anchor} —
- * the line number is for humans, the hash for machine verification; both must
- * match the snapshot at once.
+ * the line number is the address, the hash a checksum that the line at that
+ * address is still what was read; both must match at apply time.
  */
 export type Edit =
 	| { readonly op: "replace"; readonly start: Anchor; readonly end?: Anchor; readonly body: string[] }
@@ -25,47 +25,63 @@ export type Edit =
 
 export type LineEnding = "lf" | "crlf";
 
-/** File snapshot: original text recorded at read time + per-line context-aware hash. */
-export interface FileSnapshot {
-	readonly path: string;
-	/** `lineHashes[i]` = hash of line (i+1); length always equals the file's line count. */
-	readonly lineHashes: readonly string[];
-	readonly text: string;
-	/** Hash length used when generating lineHashes; apply must reuse it for the new snapshot to avoid length drift on the next verification. */
-	readonly hashLen: number;
-	/** Original file line ending (lf/crlf); apply restores it so a CRLF file keeps its line endings after edit. */
-	readonly lineEnding: LineEnding;
-}
+/**
+ * Outcome of shifted-anchor recovery. When a cited anchor's hash no longer
+ * matches the live content, the applicator rescans ±radius lines for the
+ * original content — holding the ORIGINAL line number fixed and re-hashing each
+ * candidate's content (`computeLineHash(citedLine, candidateContent) === citedHash`
+ * iff the candidate is the original content). A ready-to-resend anchor (with the
+ * freshly computed hash) is returned so the model can retry without a re-read.
+ *
+ * - `found` — exactly one nearby line holds the original content; resend the op
+ *   with the provided anchor.
+ * - `ambiguous` — several nearby lines match (e.g. duplicate content); the model
+ *   picks the right one from the candidates (each carries its own new hash).
+ * - `none` — the content genuinely changed; re-read.
+ */
+export type AnchorRecovery =
+	| { readonly kind: "found"; readonly newLine: number; readonly newHash: string }
+	| {
+			readonly kind: "ambiguous";
+			readonly candidates: ReadonlyArray<{ readonly line: number; readonly hash: string }>;
+	  }
+	| { readonly kind: "none" };
 
-/** A single parsed file patch. */
-export interface ParsedPatch {
-	readonly path: string;
-	readonly edits: Edit[];
+/**
+ * A single anchor that failed verification, with its recovery attempt.
+ *
+ * `opIndex` is the 0-based position in the input `edits[]`; `which` names the
+ * op's anchor (`"anchor"` = start, `"end"` = range end); `op` is the op kind.
+ * `current` is the cited line's live content + hash (null if the line number is
+ * out of range) — surfaced when recovery is `none` so the model can self-diagnose.
+ */
+export interface AnchorFailure {
+	readonly opIndex: number;
+	readonly which: "anchor" | "end";
+	readonly op: Edit["op"];
+	readonly cited: Anchor;
+	readonly recovery: AnchorRecovery;
+	readonly current: { readonly hash: string; readonly content: string } | null;
 }
 
-/** Error kinds. */
-export type PatchErrorKind =
-	| "parse" // malformed input
-	| "stale" // file changed (current text !== snapshot.text)
-	| "anchor" // anchor hash does not match the snapshot (model misremembered) or line out of range
-	| "collision" // hash appears at multiple lines, cannot locate uniquely
-	| "range" // illegal operation range (overlap, reverse order, spanning a gap, etc.)
-	| "noop"; // edit produced no change (body byte-identical to the target)
-
-export interface PatchError {
-	readonly kind: PatchErrorKind;
-	readonly message: string;
-	/** Line number (1-based) in the input patch, for error localization. */
-	readonly line?: number;
-}
+/** Batch-level failure. `anchor` carries every per-anchor failure collected across the batch. */
+export type ApplyFailure =
+	| { readonly kind: "anchor"; readonly failures: readonly AnchorFailure[] }
+	| { readonly kind: "range"; readonly message: string }
+	| { readonly kind: "noop"; readonly message: string };
 
-/** Apply result. */
+/**
+ * Apply result. On success, `touchedLines` lists the 0-based line indices in
+ * the NEW file that this edit produced (inserted or replaced) — callers use it
+ * to surface fresh `LINE#HASH` anchors so the model can chain edits without a
+ * re-read. On failure, `failure` is either the collected set of anchor failures
+ * (each with recovery) or a single range/noop error; nothing is written.
+ */
 export type ApplyResult =
 	| {
 			readonly ok: true;
 			readonly text: string;
-			readonly newSnapshot: FileSnapshot;
 			readonly changed: boolean;
-			readonly diff: string;
+			readonly touchedLines: readonly number[];
 	  }
-	| { readonly ok: false; readonly error: PatchError };
+	| { readonly ok: false; readonly failure: ApplyFailure };

package/src/index.ts

@@ -1,32 +1,31 @@
 /**
  * pi-hashline-edit extension entry.
  *
- * Overrides the built-in read/edit: read outputs "lineNo#hash│content" and
- * records a snapshot; edit accepts only a hashline patch (LINE#HASH anchors),
- * and legacy oldText/newText is rejected explicitly (no silent degradation).
- * The renderer is inherited from the built-in automatically.
+ * Overrides the built-in read/edit: read outputs "lineNo#hash│content";
+ * edit accepts structured hashline ops (edits[] with LINE#HASH anchors), and
+ * legacy oldText/newText is rejected explicitly (no silent degradation). Each
+ * tool carries its own renderer.
  *
  * @module pi-hashline-edit
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadConfig } from "./pi/config.ts";
-import { clearSnapshots, getState } from "./pi/state.ts";
+import { getState } from "./pi/state.ts";
 import { makeEditOverride } from "./pi/edit-tool.ts";
 import { makeReadOverride } from "./pi/read-tool.ts";
+import { makeGrepOverride } from "./pi/grep-tool.ts";
 
 export default function (pi: ExtensionAPI) {
 	const cwd = process.cwd();
 
-	// refresh config and snapshots on session start / reload
+	// refresh config on session start / reload
 	pi.on("session_start", async () => {
-		const config = loadConfig(cwd);
 		const state = getState();
-		state.config = config;
-		state.hashLen = config.hashLen;
-		clearSnapshots();
+		state.config = loadConfig(cwd);
 	});
 
 	pi.registerTool(makeReadOverride(cwd));
 	pi.registerTool(makeEditOverride(cwd));
+	pi.registerTool(makeGrepOverride(cwd));
 }

package/src/pi/config.ts

@@ -15,9 +15,11 @@ export interface HashlineEditConfig {
 	enabled: boolean;
 	/** Line hash length (default 4). */
 	hashLen: number;
+	/** ±line radius for shifted-anchor recovery (default 15; 0 disables rescue). */
+	shiftRadius: number;
 }
 
-const DEFAULT_CONFIG: HashlineEditConfig = { enabled: true, hashLen: 4 };
+const DEFAULT_CONFIG: HashlineEditConfig = { enabled: true, hashLen: 4, shiftRadius: 15 };
 
 function getAgentDir(): string {
 	const envDir = process.env.PI_AGENT_DIR;
@@ -49,5 +51,9 @@ export function loadConfig(cwd?: string): HashlineEditConfig {
 			typeof raw.hashLen === "number" && raw.hashLen >= 2 && raw.hashLen <= 8
 				? raw.hashLen
 				: DEFAULT_CONFIG.hashLen,
+		shiftRadius:
+			typeof raw.shiftRadius === "number" && raw.shiftRadius >= 0 && raw.shiftRadius <= 100
+				? raw.shiftRadius
+				: DEFAULT_CONFIG.shiftRadius,
 	};
 }

package/src/pi/edit-tool.ts

@@ -1,101 +1,176 @@
 /**
- * Override edit: accepts only a hashline patch (`input`).
+ * Override edit: hashline ops via structured `edits` (LINE#HASH anchors).
  *
- * Not backward-compatible with legacy oldText/newText — when legacy input is
- * detected it errors explicitly so the developer knows the model didn't use the
- * new approach, rather than silently degrading. Tolerance is limited to
- * format-only normalizations that don't affect the result (optional colon, CRLF
- * at the parse layer); paradigm-level compatibility is refused outright.
+ * Each op in `edits` references line anchors copied from read output (or from a
+ * prior edit's "Updated anchors"). The core verifies each anchor live against
+ * the current file content — no snapshot, no global stale check: a cited line
+ * that changed (or was misremembered) fails its own anchor; unchanged lines
+ * elsewhere never block the edit. Legacy oldText/newText is not accepted — the
+ * schema requires an `op` discriminator, so legacy payloads are rejected at the
+ * schema layer (a visible failure, never a silent degradation).
  *
- * Concurrency safety: the read-modify-write is wrapped in
- * withFileMutationQueue, serializing multiple edits to the same file to prevent
- * data loss under pi's default parallel execution. AbortSignal is honored —
- * checked after read / before write, so a user cancel never touches the disk.
+ * On success the result carries fresh `LINE#HASH` anchors for the lines this
+ * edit produced (and the line that shifted into a deletion gap), so the model
+ * can chain edits without a re-read.
+ *
+ * Concurrency safety: read-modify-write is wrapped in withFileMutationQueue.
+ * AbortSignal is honored — checked after read / before write.
  *
  * @module pi-hashline-edit/pi
  */
 
-import { createEditTool, generateDiffString, generateUnifiedPatch, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { createEditTool, generateDiffString, generateUnifiedPatch, withFileMutationQueue, type EditToolDetails } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
+import { Text } from "@earendil-works/pi-tui";
 import { readFile, writeFile } from "node:fs/promises";
-import { applyEdits, parsePatch } from "../core/index.ts";
-import type { Edit, FileSnapshot, PatchError } from "../core/types.ts";
+import { applyEdits, hashFileLines } from "../core/index.ts";
+import { splitLines } from "../core/lines.ts";
+import type { ApplyFailure, Edit } from "../core/types.ts";
 import { canonicalPath } from "./read-tool.ts";
-import { getState, getSnapshot, putSnapshot, recordSnapshot } from "./state.ts";
-import { Text } from "@earendil-works/pi-tui";
+import { getState } from "./state.ts";
+
+/** Cap on the number of updated anchors returned inline (bounds token cost for large inserts). */
+const MAX_ANCHOR_LINES = 40;
 
-// The schema deliberately omits additionalProperties:false: when the model
-// mistakenly sends legacy edits/oldText/newText, those extra fields reach
-// execute as-is and are caught and rejected explicitly by missingInputError.
-// This relies on typebox allowing extra properties by default + pi validation
-// not stripping them — do not change either of these.
+const anchorSchema = Type.Object({
+	line: Type.Number({ description: "1-based line number" }),
+	hash: Type.String({ description: "Line content hash copied from read output (the #HASH after the line number)" }),
+});
+
+const editOpSchema = Type.Object({
+	op: Type.Union(
+		[
+			Type.Literal("replace"),
+			Type.Literal("delete"),
+			Type.Literal("insert_after"),
+			Type.Literal("insert_before"),
+			Type.Literal("append"),
+			Type.Literal("prepend"),
+		],
+		{ description: "Operation kind" },
+	),
+	anchor: Type.Optional(anchorSchema),
+	end: Type.Optional(anchorSchema),
+	body: Type.Optional(Type.Array(Type.String(), { description: "New content lines (required for replace/insert/append/prepend; omit for delete)" })),
+});
 
 const editSchema = Type.Object({
 	path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
-	input: Type.Optional(
-		Type.String({
-			description:
-				"Hashline patch referencing LINE#HASH anchors from your latest read. Ops: replace / delete / insert_after / insert_before / append / prepend. Body rows start with `+`. This tool does NOT accept legacy oldText/newText.",
-		}),
-	),
+	edits: Type.Array(editOpSchema, { description: "Hashline ops, each referencing LINE#HASH anchors from your latest read or edit result" }),
 });
 
-/** Turn a PatchError into helpful hint text for the model. */
-function errorText(e: PatchError, path: string): string {
-	switch (e.kind) {
-		case "stale":
-			return `File ${path} changed since your last read. Re-read it before editing.`;
-		case "anchor":
-			return `Anchor mismatch: ${e.message}. Re-read ${path} to get current line hashes (LINE#HASH).`;
-		case "collision":
-			return `Hash collision: ${e.message}. Re-read ${path}.`;
-		case "range":
-			return `Bad range: ${e.message}`;
-		case "noop":
-			return `Edit produced no change: ${e.message}`;
-		case "parse":
-			return `Parse error${e.line ? ` at line ${e.line}` : ""}: ${e.message}`;
+type EditOpInput = Static<typeof editOpSchema>;
+
+/**
+ * Turn an ApplyFailure into LLM-facing text. The FIRST line is a terse summary
+ * (the TUI's renderResult shows only the first line of an error result); the
+ * remaining lines carry the structured detail the model needs to retry without a
+ * re-read — rescued anchors / ambiguous candidates / the cited line's live
+ * content. range/noop are already terse single-line messages.
+ */
+function formatFailure(failure: ApplyFailure, path: string): string {
+	if (failure.kind === "range") return failure.message;
+	if (failure.kind === "noop") return failure.message;
+
+	const lines: string[] = [];
+	let found = 0;
+	let ambiguous = 0;
+	let none = 0;
+	for (const f of failure.failures) {
+		const where = `op #${f.opIndex} ${f.op} ${f.which} (line ${f.cited.line})`;
+		switch (f.recovery.kind) {
+			case "found": {
+				found++;
+				lines.push(
+					`• ${where}: content shifted to line ${f.recovery.newLine}. Resend this op with ${f.which} { "line": ${f.recovery.newLine}, "hash": "${f.recovery.newHash}" }.`,
+				);
+				break;
+			}
+			case "ambiguous": {
+				ambiguous++;
+				const nums = f.recovery.candidates.map((c) => c.line).join(", ");
+				const list = f.recovery.candidates
+					.map((c) => `{ "line": ${c.line}, "hash": "${c.hash}" }`)
+					.join(" / ");
+				lines.push(
+					`• ${where}: ambiguous — same content at lines ${nums}. Pick the right one and resend ${f.which} ${list}.`,
+				);
+				break;
+			}
+			case "none": {
+				none++;
+				const cur =
+					f.current != null
+						? `current line ${f.cited.line}: ${f.cited.line}#${f.current.hash}│${f.current.content}`
+						: `line ${f.cited.line} is out of range`;
+				lines.push(`• ${where}: not found nearby — content changed. ${cur}. Re-read ${path} for fresh anchors.`);
+				break;
+			}
+		}
 	}
+	const parts: string[] = [];
+	if (found) parts.push(`${found} rescued`);
+	if (ambiguous) parts.push(`${ambiguous} ambiguous`);
+	if (none) parts.push(`${none} need re-read`);
+	const brief = `Anchor mismatch: ${parts.join(", ")}.`;
+	return `${brief}\n${lines.join("\n")}`;
 }
 
-/** Get the first changed line after applying (for firstChangedLine / TUI jump). insert_after uses anchor + 1. */
-function minAnchorLine(edits: readonly Edit[]): number | undefined {
-	let min: number | undefined;
-	for (const e of edits) {
-		let line: number | undefined;
-		if (e.op === "replace" || e.op === "delete") line = e.start.line;
-		else if (e.op === "insert_after") line = e.anchor.line + 1;
-		else if (e.op === "insert_before") line = e.anchor.line;
-		else if (e.op === "prepend") line = 1;
-		// append has no anchor, skip (trailing append)
-		if (line !== undefined && (min === undefined || line < min)) min = line;
+/** Translate JSON edit ops into core Edit[]. Validates conditional required fields (anchor/body per op). */
+function toCoreEdits(ops: readonly EditOpInput[]): { ok: true; edits: Edit[] } | { ok: false; error: string } {
+	const edits: Edit[] = [];
+	for (const o of ops) {
+		switch (o.op) {
+			case "replace":
+				if (!o.anchor) return { ok: false, error: "replace needs `anchor` {line, hash}" };
+				if (!o.body) return { ok: false, error: "replace needs `body`" };
+				edits.push({ op: "replace", start: o.anchor, end: o.end, body: o.body });
+				break;
+			case "delete":
+				if (!o.anchor) return { ok: false, error: "delete needs `anchor` {line, hash}" };
+				edits.push({ op: "delete", start: o.anchor, end: o.end });
+				break;
+			case "insert_after":
+			case "insert_before":
+				if (!o.anchor) return { ok: false, error: `${o.op} needs \`anchor\` {line, hash}` };
+				if (!o.body) return { ok: false, error: `${o.op} needs \`body\`` };
+				edits.push({ op: o.op, anchor: o.anchor, body: o.body });
+				break;
+			case "append":
+			case "prepend":
+				if (!o.body) return { ok: false, error: `${o.op} needs \`body\`` };
+				edits.push({ op: o.op, body: o.body });
+				break;
+		}
 	}
-	return min;
+	return { ok: true, edits };
 }
 
 /**
- * The model didn't use hashline (sent legacy oldText/newText or is missing
- * input) → tell it explicitly, don't silently degrade. Exported for testing.
- * params is `any` so it can detect legacy fields outside the schema.
+ * Fail the edit by throwing. pi's contract: a tool failure is signaled by throwing,
+ * not by returning `{ isError: true }` — the framework derives `context.isError` from
+ * whether execute threw, and overwrites `result.isError` with it
+ * (`updateResult({ ...result, isError: event.isError })`). Returning an isError object
+ * left the TUI rendering failures as success (green). The thrown message reaches the
+ * LLM verbatim; renderResult shows its first line in red.
  */
-export function missingInputError(path: string, params: any): string {
-	const legacy =
-		Array.isArray(params?.edits) ||
-		typeof params?.oldText === "string" ||
-		typeof params?.newText === "string";
-	if (legacy) {
-		return `⚠ ${path}: you sent the legacy oldText/newText format, but this edit tool ONLY accepts hashline \`input\`. The legacy path was intentionally removed so this is surfaced, not silently degraded. Re-read ${path} to get LINE#HASH anchors, then send \`input\` (e.g. \`replace 4#aF3:\` followed by \`+\` body rows).`;
-	}
-	return `Edit ${path}: missing \`input\` (hashline patch). Read ${path} first, then send \`input\` referencing LINE#HASH anchors.`;
+function errResult(text: string): never {
+	throw new Error(text);
 }
 
-/** Build an error result (with isError: true so the TUI/agent loop treats it as a failure, not a success). */
-function errResult(text: string) {
-	return {
-		isError: true as const,
-		content: [{ type: "text" as const, text }],
-		details: undefined,
-	};
+/**
+ * Format the updated anchors (fresh LINE#HASH│content) for the touched new-file
+ * lines, so the model can chain edits without a re-read. Capped to bound tokens.
+ */
+function formatUpdatedAnchors(newText: string, touched: readonly number[], hashLen: number): string {
+	const newLines = splitLines(newText);
+	const newHashes = hashFileLines(newLines, hashLen);
+	const idxs = [...new Set(touched)].sort((a, b) => a - b);
+	if (idxs.length === 0) return "";
+	const rows = idxs.map((i) => `${i + 1}#${newHashes[i]}│${newLines[i]}`);
+	const shown = rows.length > MAX_ANCHOR_LINES ? rows.slice(0, MAX_ANCHOR_LINES) : rows;
+	const more = rows.length > MAX_ANCHOR_LINES ? `\n… (${rows.length - MAX_ANCHOR_LINES} more; re-read for full anchors)` : "";
+	return `\nUpdated anchors (use these for the next edit):\n${shown.join("\n")}${more}`;
 }
 
 export function makeEditOverride(cwd: string) {
@@ -105,32 +180,30 @@ export function makeEditOverride(cwd: string) {
 		name: "edit" as const,
 		label: "edit",
 		description:
-			"Edit a file via hashline patch (LINE#HASH anchors, content-verified). Does NOT accept legacy oldText/newText.",
-		promptSnippet: "Edit files via hashline LINE#HASH anchors (input patch); legacy oldText/newText not accepted",
+			"Edit a file via hashline ops (LINE#HASH anchors, content-verified). Each op in `edits` references line anchors from your latest read or edit result.",
+		promptSnippet: "Edit files via hashline ops (edits[] with LINE#HASH anchors from read)",
 		promptGuidelines: [
-			"Pass `input`: a hashline patch referencing `LINE#HASH` anchors copied from your latest read output (e.g. `replace 12#aF3:`).",
-			"Ops: `replace LINE#HASH[..LINE#HASH]:` · `delete LINE#HASH` · `insert_after LINE#HASH:` · `insert_before LINE#HASH:` · `append:` · `prepend:`.",
-			"Body rows start with `+` followed by the literal line. `+` alone = blank line. Literal `+`/`-` lines become `++`/`+-`.",
-			"After each successful edit, re-ground: line numbers shift, so take the next edit's anchors from a fresh read.",
-			"This tool does NOT accept legacy oldText/newText — sending those returns an error (intentional, so it's visible).",
+			"Pass `edits`: an array of ops. Each op = {op, anchor?, end?, body?}.",
+			"op ∈ replace | delete | insert_after | insert_before | append | prepend.",
+			"anchor & end = {line, hash} copied from your latest read or edit result (the `#HASH` after each line number). replace/delete take anchor (+ optional end for a range); insert_after/insert_before take anchor; append/prepend take neither.",
+			"body = string[] of new content lines (required for replace/insert/append/prepend; omit for delete).",
+			"A successful edit returns `Updated anchors` for the changed lines — use those (not stale line numbers) for the next edit to the same file; re-read only if you need lines outside that set.",
 		],
 		parameters: editSchema,
-		renderShell: "self" as const,
+		renderShell: "default" as const,
 
 		renderCall(args: Static<typeof editSchema>, theme: any) {
 			let text = theme.fg("toolTitle", theme.bold("edit "));
 			text += theme.fg("accent", args.path);
-			if (args.input) {
-				const firstOp = args.input.split("\n").find((l) => l.trim() && !l.startsWith("+"));
-				if (firstOp) text += theme.fg("dim", ` — ${firstOp.trim()}`);
-			}
+			const n = args.edits?.length ?? 0;
+			if (n) text += theme.fg("dim", ` — ${n} op${n > 1 ? "s" : ""}: ${args.edits[0].op}`);
 			return new Text(text, 0, 0);
 		},
 
-		renderResult(result: any, { isPartial, expanded }: any, theme: any) {
+		renderResult(result: any, { isPartial, expanded }: any, theme: any, context: any) {
 			if (isPartial) return new Text(theme.fg("warning", "Editing…"), 0, 0);
 			const content = result.content?.[0];
-			if (result.isError) {
+			if (context.isError) {
 				const t = content?.type === "text" ? content.text.split("\n")[0] : "Error";
 				return new Text(theme.fg("error", t), 0, 0);
 			}
@@ -160,19 +233,19 @@ export function makeEditOverride(cwd: string) {
 
 			const path = params.path;
 			const absPath = canonicalPath(cwd, path);
-			const input = params.input;
 
-			// No input → tell explicitly (distinguish legacy vs missing), don't silently degrade
-			if (typeof input !== "string" || input.trim() === "") {
-				return errResult(missingInputError(path, params as any));
+			if (!params.edits?.length) {
+				return errResult(`Edit ${path}: \`edits\` is empty or missing.`);
 			}
 			// withFileMutationQueue serializes read-modify-write for the same file, preventing parallel-edit data loss
-			return await withFileMutationQueue(absPath, () => runHashline(absPath, path, input, signal));
+			return await withFileMutationQueue(absPath, () => runHashline(absPath, path, params.edits, signal));
 		},
 	};
 }
 
-async function runHashline(absPath: string, displayPath: string, input: string, signal: AbortSignal | undefined) {
+async function runHashline(absPath: string, displayPath: string, editOps: readonly EditOpInput[], signal: AbortSignal | undefined) {
+	const { hashLen, shiftRadius } = getState().config;
+
 	let currentText: string;
 	try {
 		currentText = (await readFile(absPath)).toString("utf-8");
@@ -183,20 +256,17 @@ async function runHashline(absPath: string, displayPath: string, input: string,
 	// Check for cancel after read: if the user aborted, don't proceed to parse/apply; the file stays untouched
 	if (signal?.aborted) return errResult(`Edit ${displayPath} aborted before apply.`);
 
-	// Use the recorded snapshot, or if there is none (the model didn't read) build one from the
-	// current file — anchor verification still forces the model to use a real hash (it can't guess
-	// correctly without reading), naturally steering it to read first.
-	const snap: FileSnapshot = getSnapshot(absPath) ?? recordSnapshot(absPath, currentText);
-
-	// input has no file header; prepend one so parsePatch passes (path is just a label)
-	const parsed = parsePatch(`file: ${absPath}\n\n${input}`);
-	if (!parsed.ok) {
-		return errResult(errorText(parsed.error, displayPath));
-	}
+	const translated = toCoreEdits(editOps);
+	if (!translated.ok) return errResult(translated.error);
 
-	const result = applyEdits(currentText, parsed.patch.edits, snap);
+	// Anchors are verified against the current content. A line that changed (or a
+	// hash the model didn't actually read) fails its own anchor — but first we try
+	// shifted recovery: if the content merely moved within ±shiftRadius, a fresh
+	// anchor is returned so the model can retry without a re-read. All failures in
+	// the batch are collected (nothing written on any failure).
+	const result = applyEdits(currentText, translated.edits, hashLen, shiftRadius);
 	if (!result.ok) {
-		return errResult(errorText(result.error, displayPath));
+		return errResult(formatFailure(result.failure, displayPath));
 	}
 
 	// Check for cancel before write: if aborted, don't touch the disk; the file stays untouched
@@ -209,20 +279,16 @@ async function runHashline(absPath: string, displayPath: string, input: string,
 		return errResult(`Error writing ${displayPath}: ${msg}`);
 	}
 
-	// Update the snapshot: consecutive edits need no re-read (result.newSnapshot is based on the new text), via LRU
-	putSnapshot(absPath, result.newSnapshot);
-
+	// pi's generateDiffString returns the display diff (colored by the renderer) and the first changed line
+	const { diff, firstChangedLine } = generateDiffString(currentText, result.text);
+	const details: EditToolDetails = {
+		diff,
+		patch: generateUnifiedPatch(displayPath, currentText, result.text),
+		firstChangedLine,
+	};
+	const anchors = formatUpdatedAnchors(result.text, result.touchedLines, hashLen);
 	return {
-		content: [
-			{ type: "text" as const, text: `Edited ${displayPath} (${parsed.patch.edits.length} op(s)).` },
-		],
-		details: {
-			// details.diff must use pi's generateDiffString (+N content format); the built-in
-			// renderer's parseDiffLine only recognizes this format — core's standard unified diff
-			// would be grayed out as plain text
-			diff: generateDiffString(currentText, result.text),
-			patch: generateUnifiedPatch(displayPath, currentText, result.text),
-			firstChangedLine: minAnchorLine(parsed.patch.edits),
-		},
+		content: [{ type: "text" as const, text: `Edited ${displayPath} (${translated.edits.length} op(s)).${anchors}` }],
+		details,
 	};
 }