@d3ara1n/pi-hashline-edit 0.1.1 → 0.1.2

package/src/core/hash.ts

@@ -1,11 +1,26 @@
 /**
- * Per-line context-aware hash.
+ * Per-line content hash.
  *
- * Each line's hash is computed by concatenating "previous line + this line +
- * next line", so identical content lines (blank lines, `}`, `return`) get
- * different hashes due to different neighbors, making in-file collisions
- * effectively zero. Residual collisions are resolved by {@link hashFileLines}
- * via automatic length extension (per-file zero-collision guarantee).
+ * The hash mixes the 1-based line number into the line content, so every line
+ * gets a unique hash by construction — line numbers are unique, therefore no
+ * in-file collision is possible, and no length extension / fallback is ever
+ * needed.
+ *
+ * Why line + content (not content alone, not content + neighbors):
+ *
+ * - The line number is the address; the hash is a checksum that the line at
+ *   that address is still what was read. Mixing the number in makes the hash a
+ *   pure fingerprint of (position, content): it changes only when the line's
+ *   own content changes, never when a neighbor changes. (A neighbor-aware hash
+ *   would change an unchanged line's hash when an adjacent line is edited — a
+ *   spurious dependency with no benefit under this design's position-fixed
+ *   apply.)
+ * - Content alone would leave identical lines (blank lines, `}`) sharing a
+ *   hash; mixing the line number disambiguates them for free.
+ *
+ * Drift (file changed since read) is caught up-front by the global stale check
+ * (`text !== snapshot.text`). This hash's job is to verify the model actually
+ * read the line — it cannot forge a `(line, content)` hash without reading.
  *
  * @module pi-hashline-edit/core
  */
@@ -38,62 +53,20 @@ function toBase32(n: number, len: number): string {
 }
 
 /**
- * Compute the context-aware hash of a single line.
+ * Compute the hash of a single line from its 1-based line number and content.
  *
- * @param prev previous line content (`""` for the first line)
- * @param cur  this line's content
- * @param next next line content (`""` for the last line)
- * @param len  hash length (default 4, 20 bits ≈ 1M values)
+ * @param line    1-based line number
+ * @param content the line's content (no line terminator)
+ * @param len     hash length (default 4, 20 bits ≈ 1M values)
  */
-export function computeLineHash(prev: string, cur: string, next: string, len = 4): string {
-	const h = fnv1a32(`${prev}\n${cur}\n${next}`);
-	return toBase32(h, len);
-}
-
-/** Compute raw per-line hashes (no collision handling). */
-function rawHashes(lines: readonly string[], len: number): string[] {
-	return lines.map((line, i) =>
-		computeLineHash(lines[i - 1] ?? "", line, lines[i + 1] ?? "", len),
-	);
-}
-
-/** Find hash values that appear more than once. */
-function duplicatedHashes(hashes: readonly string[]): Set<string> {
-	const counts = new Map<string, number>();
-	for (const h of hashes) counts.set(h, (counts.get(h) ?? 0) + 1);
-	return new Set([...counts.entries()].filter(([, c]) => c > 1).map(([h]) => h));
-}
-
-/** Fallback: force uniqueness with an index suffix (theoretically unreachable under context-aware hashing). */
-function forceUnique(hashes: string[]): string[] {
-	const seen = new Map<string, number>();
-	return hashes.map((h) => {
-		const c = seen.get(h) ?? 0;
-		seen.set(h, c + 1);
-		return c === 0 ? h : `${h}${c}`;
-	});
+export function computeLineHash(line: number, content: string, len = 4): string {
+	return toBase32(fnv1a32(`${line}\n${content}`), len);
 }
 
 /**
- * Compute per-line hashes for the whole file and resolve in-file collisions:
- * colliding lines are recomputed with a longer len until unique within the file
- * (per-file zero-collision guarantee).
- *
- * Design rationale: context-aware hashing already drives the collision
- * probability near zero; this extension is a defensive fallback guaranteeing
- * apply never mislocates due to hash ambiguity.
+ * Compute per-line hashes for a file. Unique by construction — the 1-based line
+ * number is part of each hash, so two identical content lines always differ.
  */
 export function hashFileLines(lines: readonly string[], len = 4): string[] {
-	if (lines.length === 0) return [];
-	let hashes = rawHashes(lines, len);
-	for (let curLen = len; curLen <= len + 4; curLen++) {
-		const dups = duplicatedHashes(hashes);
-		if (dups.size === 0) return hashes;
-		hashes = hashes.map((h, i) =>
-			dups.has(h)
-				? computeLineHash(lines[i - 1] ?? "", lines[i] ?? "", lines[i + 1] ?? "", curLen + 1)
-				: h,
-		);
-	}
-	return forceUnique(hashes);
+	return lines.map((content, i) => computeLineHash(i + 1, content, len));
 }

package/src/core/index.ts

@@ -9,9 +9,5 @@
 
 export * from "./types.ts";
 export { computeLineHash, hashFileLines } from "./hash.ts";
-export { splitLines, joinLines, createSnapshot, verifyAnchor } from "./snapshot.ts";
-export type { AnchorVerifyResult } from "./snapshot.ts";
-export { parsePatch } from "./parse.ts";
-export type { ParseResult } from "./parse.ts";
+export { splitLines, joinLines, detectLineEnding } from "./lines.ts";
 export { applyEdits } from "./apply.ts";
-export { buildDiff } from "./diff.ts";

package/src/core/lines.test.ts

@@ -0,0 +1,30 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { splitLines, joinLines, detectLineEnding } from "./lines.ts";
+
+test("splitLines edge cases", () => {
+	assert.deepEqual(splitLines(""), []);
+	assert.deepEqual(splitLines("a"), ["a"]);
+	assert.deepEqual(splitLines("a\nb"), ["a", "b"]);
+	assert.deepEqual(splitLines("a\nb\n"), ["a", "b"]);
+	assert.deepEqual(splitLines("a\n\n"), ["a", ""]);
+	assert.deepEqual(splitLines("\n"), [""]);
+});
+
+test("splitLines strips CRLF \\r", () => {
+	assert.deepEqual(splitLines("a\r\nb\r\n"), ["a", "b"]);
+	assert.deepEqual(splitLines("a\r\nb"), ["a", "b"]);
+});
+
+test("joinLines restores line endings", () => {
+	assert.equal(joinLines(["a", "b"]), "a\nb\n");
+	assert.equal(joinLines([]), "");
+	assert.equal(joinLines(["a", "b"], "crlf"), "a\r\nb\r\n");
+	assert.equal(joinLines(["a", "b"], "lf"), "a\nb\n");
+});
+
+test("detectLineEnding", () => {
+	assert.equal(detectLineEnding("a\nb\n"), "lf");
+	assert.equal(detectLineEnding("a\r\nb\r\n"), "crlf");
+	assert.equal(detectLineEnding("a\nb\r\nc\n"), "crlf");
+});

package/src/core/lines.ts

@@ -0,0 +1,42 @@
+/**
+ * Line text helpers: split/join with CRLF normalization and line-ending
+ * detection.
+ *
+ * CRLF: splitLines strips the trailing `\r` from each line (hashes are based on
+ * clean lines, matching the `\r`-free content the model copies from the
+ * display); detectLineEnding records the original ending so joinLines can
+ * restore it — guaranteeing a CRLF file keeps its endings after edit.
+ *
+ * @module pi-hashline-edit/core
+ */
+
+import type { LineEnding } from "./types.ts";
+
+/**
+ * Split text into lines, stripping the trailing `\r` of each line (CRLF
+ * normalization, so hashes are based on clean lines).
+ *
+ * Convention: a trailing newline is treated as the terminator of the last line,
+ * not as producing an extra empty trailing line.
+ * - `"a\nb\n"` → `["a", "b"]`
+ * - `"a\r\nb\r\n"` → `["a", "b"]` (`\r` stripped)
+ * - `"a\n\n"` → `["a", ""]`
+ * - `""` → `[]`
+ */
+export function splitLines(text: string): string[] {
+	if (text === "") return [];
+	const normalized = text.endsWith("\n") ? text.slice(0, -1) : text;
+	return normalized.split("\n").map((l) => (l.endsWith("\r") ? l.slice(0, -1) : l));
+}
+
+/** Detect the dominant line ending of the text (any `\r\n` counts as CRLF). */
+export function detectLineEnding(text: string): LineEnding {
+	return text.includes("\r\n") ? "crlf" : "lf";
+}
+
+/** Join a line array back into text, restoring the given line ending (default LF). Non-empty files end with a newline. */
+export function joinLines(lines: readonly string[], ending: LineEnding = "lf"): string {
+	if (lines.length === 0) return "";
+	const sep = ending === "crlf" ? "\r\n" : "\n";
+	return lines.join(sep) + sep;
+}

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,28 @@ 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;
-}
-
-/** A single parsed file patch. */
-export interface ParsedPatch {
-	readonly path: string;
-	readonly edits: Edit[];
-}
-
 /** 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.)
+	| "anchor" // anchor hash does not match the current line content (line changed, or model misremembered) or line out of range
+	| "range" // illegal operation range (overlap, reverse order, 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;
 }
 
-/** 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.
+ */
 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 };

package/src/index.ts

@@ -1,30 +1,27 @@
 /**
  * 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";
 
 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));

package/src/pi/edit-tool.ts

@@ -1,95 +1,109 @@
 /**
- * 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 { Edit, PatchError } 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" }),
 });
 
+type EditOpInput = Static<typeof editOpSchema>;
+
 /** 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}`;
-	}
-}
-
-/** 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;
 	}
-	return min;
 }
 
-/**
- * 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.
- */
-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).`;
+/** 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 `Edit ${path}: missing \`input\` (hashline patch). Read ${path} first, then send \`input\` referencing LINE#HASH anchors.`;
+	return { ok: true, edits };
 }
 
-/** Build an error result (with isError: true so the TUI/agent loop treats it as a failure, not a success). */
+/** Build an error result (isError: true so the TUI/agent loop treats it as a failure). */
 function errResult(text: string) {
 	return {
 		isError: true as const,
@@ -98,6 +112,21 @@ function errResult(text: string) {
 	};
 }
 
+/**
+ * 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) {
 	const builtin = createEditTool(cwd);
 
@@ -105,32 +134,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 +187,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 = getState().config.hashLen;
+
 	let currentText: string;
 	try {
 		currentText = (await readFile(absPath)).toString("utf-8");
@@ -183,18 +210,13 @@ 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 — steering it to
+	// read first. Unrelated changes elsewhere never block the edit.
+	const result = applyEdits(currentText, translated.edits, hashLen);
 	if (!result.ok) {
 		return errResult(errorText(result.error, displayPath));
 	}
@@ -209,20 +231,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,
 	};
 }