@d3ara1n/pi-hashline-edit 0.1.0 → 0.1.2

package/README.md

@@ -2,41 +2,40 @@
 
 > Hashline-style file editing for [pi](https://github.com/earendil-works/pi-coding-agent) — line-anchored edits verified by content hash, replacing `oldText`/`newText` matching.
 
-用「行级内容 hash + 行号」双重锚替代 pi 内置的 `oldText`/`newText` 精确匹配编辑。模型指出要改的行（带 hash 校验），而不是重打要改的代码——从根上消除 string-not-found 死循环与空白战争。
+Edits reference lines by `LINE#HASH` anchors (copied from `read` output) instead of retyping the code to be changed — eliminating string-not-found loops and whitespace battles at the root.
 
-## 设计要点
+## Design
 
-- **行级 hash + 行号双重锚**：`read` 每行带短 hash（`3#aF3│code`），`edit` 引用 `行号#hash`。行号给人读，hash 给机器校验——天然抗行号漂移。
-- **context-aware hash**：每行 hash 把上下两行一起算，使内容相同的行（空行、`}`）因邻居不同而 hash 不同，文件内碰撞接近 0。
-- **严格核心 + 可插拔容错**：核心 `parse → apply` 零猜测、失败快；容错（旧格式归一化、漂移重定位、块解析）做成独立开关的中间件。
-- **不兼容旧格式**：override 内置 `edit`/`read`。edit 只接受 hashline `input`；模型误发 `oldText`/`newText` 会收到明确错误（而非静默降级到旧方案）——让开发者知道 hashline 是否真在用。容错仅限不影响结果的格式归一化。
+- **Per-line hash + line number, dual anchor**: `read` shows each line with a short hash (`3#aF3│code`); `edit` references `LINE#HASH`. The line number is the address; the hash is a checksum that the line at that address is still what was read.
+- **Line + content hash**: each line's hash mixes its 1-based line number into its content, so every line gets a unique hash by construction — no in-file collisions, no length extension. The hash changes only when the line's own content changes, never when a neighbor changes.
+- **Live, surgical verification**: at apply time each cited anchor's hash is recomputed from the CURRENT line content and compared — no stored snapshot, no whole-file stale check. A line that changed (or was misremembered) fails its own anchor; an unrelated change elsewhere never blocks the edit. No fuzzy matching, no boundary repair, no drift relocation.
+- **Chain edits without re-reading**: a successful `edit` returns `Updated anchors` (`LINE#HASH│`) for the lines it produced (and the line that shifted into a deletion gap), so the next edit to the same file can cite them directly.
+- **No legacy compatibility**: overrides the built-in `edit`/`read`. `edit` accepts only structured hashline ops; sending legacy `oldText`/`newText` is rejected at the schema layer (never silently degrades) — so you always know whether hashline is actually in use.
 
-> **状态**：Phase 1 纯核心库（`src/core/`）已完成，可独立测试。pi 接入层（`src/pi/`）开发中。
+## Protocol
 
-## 协议速览
-
-`read` 输出（每行带锚）：
+`read` output (each line anchored):
 
 ```
 src/foo.ts · 6 lines
    1#aF3│import { compute } from "./util"
    2#7Qk│
    3#mP0│export function foo(x: number) {
-   4#kLp│  if (x < 0) return 0
-   5#xY9│  return compute(x)
-   6#b2H│}
 ```
 
-`edit` 的 `input`：path 在工具参数里，input 只含 ops（无需 `file:` 头，工具自动注入）
+`edit` takes `path` + `edits` (an array of ops, each with `op`, `anchor`/`end` `{line, hash}` from read, and `body` string[]):
 
+```jsonc
+{
+  "path": "src/foo.ts",
+  "edits": [
+    { "op": "replace", "anchor": { "line": 4, "hash": "kLp" }, "body": ["  return x + 1"] },
+    { "op": "insert_after", "anchor": { "line": 6, "hash": "b2H" }, "body": ["", "export const bar = foo"] }
+  ]
+}
 ```
-replace 4#kLp:
-+  if (x < 0) throw new Error("neg")
 
-insert_after 6#b2H:
-+
-+export const bar = foo
-```
+Ops: `replace` · `delete` · `insert_after` · `insert_before` · `append` · `prepend`. `anchor`/`end` = `{line, hash}` from read; `body` = new content lines (string[], omit for `delete`).
 
 ## Installation
 
@@ -56,4 +55,4 @@ Or add to `~/.pi/agent/settings.json`:
 
 ## Dependencies
 
-- 无额外 `@d3ara1n/pi-*` 依赖；peer `@earendil-works/pi-coding-agent` 随 pi 附带（框架级，按惯例不列）。
+- No additional `@d3ara1n/pi-*` dependencies; peer `@earendil-works/pi-coding-agent` ships with pi (framework-level, not listed by convention).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-hashline-edit",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "Hashline-style file editing for pi — line-anchored edits verified by content hash, replacing oldText/newText matching",
   "keywords": [

package/src/core/apply.test.ts

@@ -1,185 +1,173 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { createSnapshot } from "./snapshot.ts";
+import { computeLineHash } from "./hash.ts";
+import { splitLines } from "./lines.ts";
 import { applyEdits } from "./apply.ts";
-import type { Edit, FileSnapshot } from "./types.ts";
+import type { Anchor } from "./types.ts";
 
-const snap = (text: string): FileSnapshot => createSnapshot("f.ts", text);
-const ln = (s: FileSnapshot, line: number) => ({ line, hash: s.lineHashes[line - 1] });
+/** Live anchor: hash the current content at the given line (1-based). */
+function at(text: string, line: number): Anchor {
+	return { line, hash: computeLineHash(line, splitLines(text)[line - 1]) };
+}
 
-// —— 正常路径 ——
+// --- happy paths ---
 
-test("replace 单行", () => {
+test("replace single line", () => {
 	const text = "a\nb\nc\n";
-	const s = snap(text);
-	const r = applyEdits(text, [{ op: "replace", start: ln(s, 2), body: ["B"] }], s);
+	const r = applyEdits(text, [{ op: "replace", start: at(text, 2), body: ["B"] }]);
 	assert.equal(r.ok, true);
 	if (r.ok) assert.equal(r.text, "a\nB\nc\n");
 });
 
 test("replace range", () => {
 	const text = "a\nb\nc\nd\ne\n";
-	const s = snap(text);
-	const r = applyEdits(
-		text,
-		[{ op: "replace", start: ln(s, 2), end: ln(s, 4), body: ["X", "Y"] }],
-		s,
-	);
+	const r = applyEdits(text, [{ op: "replace", start: at(text, 2), end: at(text, 4), body: ["X", "Y"] }]);
 	assert.equal(r.ok, true);
 	if (r.ok) assert.equal(r.text, "a\nX\nY\ne\n");
 });
 
-test("delete 单行 / range", () => {
+test("delete single line / range", () => {
 	const text = "a\nb\nc\nd\n";
-	const s = snap(text);
-	const r = applyEdits(text, [{ op: "delete", start: ln(s, 2), end: ln(s, 3) }], s);
+	const r = applyEdits(text, [{ op: "delete", start: at(text, 2), end: at(text, 3) }]);
 	assert.equal(r.ok, true);
 	if (r.ok) assert.equal(r.text, "a\nd\n");
 });
 
 test("insert_after", () => {
 	const text = "a\nb\n";
-	const s = snap(text);
-	const r = applyEdits(text, [{ op: "insert_after", anchor: ln(s, 1), body: ["x"] }], s);
+	const r = applyEdits(text, [{ op: "insert_after", anchor: at(text, 1), body: ["x"] }]);
 	assert.equal(r.ok, true);
 	if (r.ok) assert.equal(r.text, "a\nx\nb\n");
 });
 
 test("insert_before", () => {
 	const text = "a\nb\n";
-	const s = snap(text);
-	const r = applyEdits(text, [{ op: "insert_before", anchor: ln(s, 2), body: ["x"] }], s);
+	const r = applyEdits(text, [{ op: "insert_before", anchor: at(text, 2), body: ["x"] }]);
 	assert.equal(r.ok, true);
 	if (r.ok) assert.equal(r.text, "a\nx\nb\n");
 });
 
 test("append / prepend", () => {
 	const text = "a\nb\n";
-	const s = snap(text);
-	const r = applyEdits(
-		text,
-		[
-			{ op: "prepend", body: ["head"] },
-			{ op: "append", body: ["tail"] },
-		],
-		s,
-	);
+	const r = applyEdits(text, [
+		{ op: "prepend", body: ["head"] },
+		{ op: "append", body: ["tail"] },
+	]);
 	assert.equal(r.ok, true);
 	if (r.ok) assert.equal(r.text, "head\na\nb\ntail\n");
 });
 
-test("多操作乱序 → 按位置正确应用", () => {
+test("multiple out-of-order ops → applied at the right positions", () => {
 	const text = "a\nb\nc\n";
-	const s = snap(text);
-	const r = applyEdits(
-		text,
-		[
-			{ op: "insert_after", anchor: ln(s, 3), body: ["z"] },
-			{ op: "replace", start: ln(s, 1), body: ["A"] },
-		],
-		s,
-	);
+	const r = applyEdits(text, [
+		{ op: "insert_after", anchor: at(text, 3), body: ["z"] },
+		{ op: "replace", start: at(text, 1), body: ["A"] },
+	]);
 	assert.equal(r.ok, true);
 	if (r.ok) assert.equal(r.text, "A\nb\nc\nz\n");
 });
 
-test("结果带 diff 与 newSnapshot", () => {
-	const text = "a\nb\n";
-	const s = snap(text);
-	const r = applyEdits(text, [{ op: "replace", start: ln(s, 1), body: ["A"] }], s);
+test("touchedLines covers exactly the lines this edit produced (new-file indices)", () => {
+	const text = "a\nb\nc\n";
+	const r = applyEdits(text, [
+		{ op: "insert_after", anchor: at(text, 3), body: ["z"] },
+		{ op: "replace", start: at(text, 1), body: ["A"] },
+	]);
 	assert.equal(r.ok, true);
 	if (r.ok) {
-		assert.ok(r.diff.includes("@@"));
-		assert.equal(r.newSnapshot.text, "A\nb\n");
-		assert.equal(r.newSnapshot.lineHashes.length, 2);
+		// new file: [A, b, c, z]; this edit produced line index 0 (A) and 3 (z)
+		assert.deepEqual([...r.touchedLines], [0, 3]);
 	}
 });
 
-test("闭环：newSnapshot 可用于下一次 edit", () => {
-	let s = snap("a\nb\n");
-	let cur = s.text;
-	const r1 = applyEdits(cur, [{ op: "replace", start: ln(s, 1), body: ["A"] }], s);
-	assert.equal(r1.ok, true);
-	if (r1.ok) {
-		cur = r1.text;
-		s = r1.newSnapshot;
-		const r2 = applyEdits(cur, [{ op: "replace", start: ln(s, 2), body: ["B"] }], s);
-		assert.equal(r2.ok, true);
-		if (r2.ok) assert.equal(r2.text, "A\nB\n");
+test("touchedLines for append", () => {
+	const text = "a\n";
+	const r = applyEdits(text, [{ op: "append", body: ["b", "c"] }]);
+	assert.equal(r.ok, true);
+	if (r.ok) assert.deepEqual([...r.touchedLines], [1, 2]);
+});
+
+test("touchedLines for delete re-anchors the line that shifted into the gap", () => {
+	const text = "a\nb\nc\nd\n";
+	const r = applyEdits(text, [{ op: "delete", start: at(text, 2) }]);
+	assert.equal(r.ok, true);
+	if (r.ok) {
+		// new file: [a, c, d]; deleting line 2 (b) shifts c into index 1
+		assert.deepEqual([...r.touchedLines], [1]);
 	}
 });
 
-// —— 错误路径 ——
+// --- error paths ---
 
-test("stale（文件已变）拒绝", () => {
-	const s = snap("a\nb\n");
-	const r = applyEdits("a\nCHANGED\n", [{ op: "replace", start: ln(s, 1), body: ["x"] }], s);
+test("anchor hash mismatch rejected (line changed)", () => {
+	const text = "a\nb\n";
+	const r = applyEdits(text, [{ op: "replace", start: { line: 1, hash: "WRONG" }, body: ["x"] }]);
 	assert.equal(r.ok, false);
-	if (!r.ok) assert.equal(r.error.kind, "stale");
+	if (!r.ok) assert.equal(r.error.kind, "anchor");
 });
 
-test("anchor hash 不匹配拒绝（防记错）", () => {
-	const text = "a\nb\n";
-	const s = snap(text);
-	const r = applyEdits(text, [{ op: "replace", start: { line: 1, hash: "WRONG" }, body: ["x"] }], s);
+test("line out of range rejected", () => {
+	const text = "a\n";
+	const r = applyEdits(text, [{ op: "replace", start: { line: 5, hash: computeLineHash(1, "a") }, body: ["x"] }]);
 	assert.equal(r.ok, false);
 	if (!r.ok) assert.equal(r.error.kind, "anchor");
 });
 
-test("行号越界拒绝", () => {
-	const text = "a\n";
-	const s = snap(text);
-	const r = applyEdits(text, [{ op: "replace", start: { line: 5, hash: s.lineHashes[0] }, body: ["x"] }], s);
+test("anchor mismatch when the cited line's content differs (live verification)", () => {
+	// hash for line 2's content, but cited as line 1 → must fail because line 1's live content differs
+	const text = "a\nb\n";
+	const r = applyEdits(text, [{ op: "replace", start: { line: 1, hash: computeLineHash(2, "b") }, body: ["x"] }]);
 	assert.equal(r.ok, false);
 	if (!r.ok) assert.equal(r.error.kind, "anchor");
 });
 
-test("range 逆序拒绝", () => {
+test("reverse-order range rejected", () => {
 	const text = "a\nb\nc\n";
-	const s = snap(text);
-	const r = applyEdits(
-		text,
-		[{ op: "replace", start: ln(s, 3), end: ln(s, 1), body: ["x"] }],
-		s,
-	);
+	const r = applyEdits(text, [{ op: "replace", start: at(text, 3), end: at(text, 1), body: ["x"] }]);
 	assert.equal(r.ok, false);
 	if (!r.ok) assert.equal(r.error.kind, "range");
 });
 
-test("重叠编辑拒绝", () => {
+test("overlapping edits rejected", () => {
 	const text = "a\nb\nc\nd\n";
-	const s = snap(text);
-	const r = applyEdits(
-		text,
-		[
-			{ op: "replace", start: ln(s, 2), end: ln(s, 3), body: ["x"] },
-			{ op: "replace", start: ln(s, 3), body: ["y"] },
-		],
-		s,
-	);
+	const r = applyEdits(text, [
+		{ op: "replace", start: at(text, 2), end: at(text, 3), body: ["x"] },
+		{ op: "replace", start: at(text, 3), body: ["y"] },
+	]);
 	assert.equal(r.ok, false);
 	if (!r.ok) assert.equal(r.error.kind, "range");
 });
 
-test("同插入点冲突拒绝", () => {
+test("conflict at the same insertion point rejected", () => {
 	const text = "a\nb\n";
-	const s = snap(text);
-	const r = applyEdits(
-		text,
-		[
-			{ op: "insert_after", anchor: ln(s, 1), body: ["x"] },
-			{ op: "insert_after", anchor: ln(s, 1), body: ["y"] },
-		],
-		s,
-	);
+	const r = applyEdits(text, [
+		{ op: "insert_after", anchor: at(text, 1), body: ["x"] },
+		{ op: "insert_after", anchor: at(text, 1), body: ["y"] },
+	]);
 	assert.equal(r.ok, false);
 	if (!r.ok) assert.equal(r.error.kind, "range");
 });
 
-test("noop（body 字节相同）拒绝", () => {
+test("noop (byte-identical body) rejected", () => {
 	const text = "a\nb\n";
-	const s = snap(text);
-	const r = applyEdits(text, [{ op: "replace", start: ln(s, 1), body: ["a"] }], s);
+	const r = applyEdits(text, [{ op: "replace", start: at(text, 1), body: ["a"] }]);
 	assert.equal(r.ok, false);
 	if (!r.ok) assert.equal(r.error.kind, "noop");
 });
+
+test("unrelated change elsewhere does NOT block the edit (no global stale check)", () => {
+	// read-time text and current text differ at line 3, but we only touch line 1 — must succeed
+	const readText = "a\nb\nc\n";
+	const currentText = "a\nb\nCHANGED\n";
+	const r = applyEdits(currentText, [{ op: "replace", start: at(readText, 1), body: ["A"] }]);
+	assert.equal(r.ok, true);
+	if (r.ok) assert.equal(r.text, "A\nb\nCHANGED\n");
+});
+
+test("CRLF line endings preserved", () => {
+	const text = "a\r\nb\r\n";
+	const r = applyEdits(text, [{ op: "replace", start: at(text, 1), body: ["A"] }]);
+	assert.equal(r.ok, true);
+	if (r.ok) assert.equal(r.text, "A\r\nb\r\n");
+});
+

package/src/core/apply.ts

@@ -1,54 +1,58 @@
 /**
- * 纯函数应用器：在快照对应的文件上应用编辑。
+ * Pure-function applicator: applies edits to a file's current text.
  *
- * 严格语义：
- * - 要求当前 `text === snapshot.text`（stale 检查）；漂移由 `transforms/relocate`
- *   中间件在调用 apply 前处理，纯 apply 不猜。
- * - 每个锚的 hash 必须匹配快照中对应行（防模型记错行号/hash）。
- * - 操作范围不得重叠（含同插入点）。
- * - body 与目标字节相同 → `noop` 错误（引导模型查 bug 而非盲目重试）。
+ * Verification is live and surgical: each anchor's hash is recomputed from the
+ * CURRENT line content at the cited line number and compared to the cited hash.
+ * No snapshot, no global stale check — a line that changed (or was
+ * misremembered) fails its own anchor; unchanged lines elsewhere never block
+ * the edit.
+ *
+ * Other strict semantics:
+ * - Operation ranges must not overlap (including the same insertion point).
+ * - body byte-identical to the whole-file result → `noop` error (guides the
+ *   model to investigate rather than blindly retry).
  *
  * @module pi-hashline-edit/core
  */
 
-import { buildDiff } from "./diff.ts";
-import { createSnapshot, joinLines, splitLines } from "./snapshot.ts";
-import type { ApplyResult, Edit, FileSnapshot, PatchError } from "./types.ts";
+import { computeLineHash } from "./hash.ts";
+import { detectLineEnding, joinLines, splitLines } from "./lines.ts";
+import type { Anchor, ApplyResult, Edit, PatchError } from "./types.ts";
 
-/** 行级操作：把 `[lo, hi)`（0-based，hi exclusive）区间的原始行替换为 newLines。 */
+/** Line-level operation: replace the raw lines in the `[lo, hi)` range (0-based, hi exclusive) with newLines. */
 interface SpanOp {
 	lo: number;
 	hi: number;
 	newLines: string[];
 }
 
-/** 校验锚匹配快照（纯 apply：text 已等于 snapshot.text，故只防记错）。 */
-function checkAnchor(snapshot: FileSnapshot, line: number, hash: string): PatchError | null {
-	if (line < 1 || line > snapshot.lineHashes.length) {
+/** Verify an anchor against the current file: line in range and hash matches the live content. */
+function checkAnchor(lines: readonly string[], line: number, hash: string, hashLen: number): PatchError | null {
+	if (line < 1 || line > lines.length) {
 		return {
 			kind: "anchor",
-			message: `line ${line} does not exist (file has ${snapshot.lineHashes.length} lines)`,
+			message: `line ${line} does not exist (file has ${lines.length} lines)`,
 		};
 	}
-	if (snapshot.lineHashes[line - 1] !== hash) {
+	if (computeLineHash(line, lines[line - 1], hashLen) !== hash) {
 		return {
 			kind: "anchor",
-			message: `hash mismatch at line ${line}: file has #${snapshot.lineHashes[line - 1]}, edit says #${hash}`,
+			message: `line ${line} changed or hash is wrong: re-read to get the current #HASH`,
 		};
 	}
 	return null;
 }
 
-/** 把 Edit 翻译成 SpanOp，同时校验锚与范围。 */
-function translateEdit(edit: Edit, snapshot: FileSnapshot): { op: SpanOp } | { error: PatchError } {
+/** Translate an Edit into a SpanOp, verifying anchors and ranges against the current lines. */
+function translateEdit(edit: Edit, lines: readonly string[], hashLen: number): { op: SpanOp } | { error: PatchError } {
 	switch (edit.op) {
 		case "replace":
 		case "delete": {
-			const startErr = checkAnchor(snapshot, edit.start.line, edit.start.hash);
+			const startErr = checkAnchor(lines, edit.start.line, edit.start.hash, hashLen);
 			if (startErr) return { error: startErr };
 			let endLine = edit.start.line;
 			if (edit.end) {
-				const endErr = checkAnchor(snapshot, edit.end.line, edit.end.hash);
+				const endErr = checkAnchor(lines, edit.end.line, edit.end.hash, hashLen);
 				if (endErr) return { error: endErr };
 				endLine = edit.end.line;
 			}
@@ -64,17 +68,17 @@ function translateEdit(edit: Edit, snapshot: FileSnapshot): { op: SpanOp } | { e
 			};
 		}
 		case "insert_after": {
-			const err = checkAnchor(snapshot, edit.anchor.line, edit.anchor.hash);
+			const err = checkAnchor(lines, edit.anchor.line, edit.anchor.hash, hashLen);
 			if (err) return { error: err };
 			return { op: { lo: edit.anchor.line, hi: edit.anchor.line, newLines: edit.body } };
 		}
 		case "insert_before": {
-			const err = checkAnchor(snapshot, edit.anchor.line, edit.anchor.hash);
+			const err = checkAnchor(lines, edit.anchor.line, edit.anchor.hash, hashLen);
 			if (err) return { error: err };
 			return { op: { lo: edit.anchor.line - 1, hi: edit.anchor.line - 1, newLines: edit.body } };
 		}
 		case "append": {
-			return { op: { lo: snapshot.lineHashes.length, hi: snapshot.lineHashes.length, newLines: edit.body } };
+			return { op: { lo: lines.length, hi: lines.length, newLines: edit.body } };
 		}
 		case "prepend": {
 			return { op: { lo: 0, hi: 0, newLines: edit.body } };
@@ -82,37 +86,32 @@ function translateEdit(edit: Edit, snapshot: FileSnapshot): { op: SpanOp } | { e
 	}
 }
 
-/** 零宽区间（插入点）的"最后影响位"是 lo；非零宽是 hi-1。 */
+/** The "last affected position" of a zero-width range (insertion point) is lo; otherwise hi-1. */
 function maxAffected(op: SpanOp): number {
 	return op.lo === op.hi ? op.lo : op.hi - 1;
 }
 
 /**
- * 在快照对应的文件上应用编辑。
+ * Apply edits to `text`. Anchors are verified against the current content; on
+ * success `touchedLines` gives the 0-based indices of the new-file lines this
+ * edit produced.
  *
- * @param text     当前文件全文
- * @param edits    解析出的编辑操作
- * @param snapshot read 时记录的快照（text 必须等于当前 text）
- * @returns 应用结果；失败返回结构化错误
+ * @param text    current full file text
+ * @param edits   parsed edit operations
+ * @param hashLen hash length used to verify anchors (default 4)
  */
-export function applyEdits(text: string, edits: Edit[], snapshot: FileSnapshot): ApplyResult {
-	if (text !== snapshot.text) {
-		return {
-			ok: false,
-			error: { kind: "stale", message: "file changed since last read; re-read before editing" },
-		};
-	}
-
+export function applyEdits(text: string, edits: Edit[], hashLen = 4): ApplyResult {
 	const lines = splitLines(text);
+	const ending = detectLineEnding(text);
 
 	const ops: SpanOp[] = [];
 	for (const edit of edits) {
-		const t = translateEdit(edit, snapshot);
+		const t = translateEdit(edit, lines, hashLen);
 		if ("error" in t) return { ok: false, error: t.error };
 		ops.push(t.op);
 	}
 
-	// 重叠检查：按 lo 升序，相邻 op 的起点不得落在前一个的影响区内
+	// Overlap check: sort ascending by lo; the next op's start must not fall inside the previous op's affected range
 	const sorted = [...ops].sort((a, b) => a.lo - b.lo || a.hi - b.hi);
 	for (let k = 1; k < sorted.length; k++) {
 		if (sorted[k].lo <= maxAffected(sorted[k - 1])) {
@@ -126,25 +125,37 @@ export function applyEdits(text: string, edits: Edit[], snapshot: FileSnapshot):
 		}
 	}
 
-	// 从后往前应用（lo 降序），避免行号偏移
+	// Apply back-to-front (lo descending) so original lo/hi stay valid
 	let result = [...lines];
 	for (const op of [...sorted].sort((a, b) => b.lo - a.lo)) {
 		result = [...result.slice(0, op.lo), ...op.newLines, ...result.slice(op.hi)];
 	}
 
-	const newText = joinLines(result, snapshot.lineEnding);
+	const newText = joinLines(result, ending);
 	if (newText === text) {
 		return {
 			ok: false,
 			error: {
 				kind: "noop",
-				message:
-					"edit parsed and applied cleanly but produced no change; body is byte-identical to the target — the bug is elsewhere, re-read first",
+				message: "edit parsed and applied cleanly but produced no change; body is byte-identical — the bug is elsewhere, re-read first",
 			},
 		};
 	}
 
-	const newSnapshot = createSnapshot(snapshot.path, newText, snapshot.hashLen);
-	const diff = buildDiff(snapshot.path, lines, sorted);
-	return { ok: true, text: newText, newSnapshot, changed: true, diff };
+	// touchedLines: new-file indices worth re-anchoring — each produced line,
+	// and for a pure delete the line that shifted into the gap (so the model
+	// gets a fresh anchor for the shifted region).
+	const touched: number[] = [];
+	let delta = 0;
+	for (const op of sorted) {
+		const newLo = op.lo + delta;
+		if (op.newLines.length > 0) {
+			for (let i = 0; i < op.newLines.length; i++) touched.push(newLo + i);
+		} else if (newLo < result.length) {
+			touched.push(newLo);
+		}
+		delta += op.newLines.length - (op.hi - op.lo);
+	}
+
+	return { ok: true, text: newText, changed: true, touchedLines: touched };
 }

package/src/core/hash.test.ts

@@ -4,46 +4,51 @@ import { computeLineHash, hashFileLines } from "./hash.ts";
 
 const ALLOWED = new Set("0123456789ABCDEFGHJKMNPQRSTVWXYZ");
 
-test("computeLineHash 稳定且为 base32", () => {
-	const a = computeLineHash("p", "c", "n", 4);
-	const b = computeLineHash("p", "c", "n", 4);
+test("computeLineHash is stable and base32", () => {
+	const a = computeLineHash(3, "code", 4);
+	const b = computeLineHash(3, "code", 4);
 	assert.equal(a, b);
 	assert.equal(a.length, 4);
 	for (const ch of a) assert.ok(ALLOWED.has(ch), `bad char ${ch}`);
 });
 
-test("context-aware：相同行不同邻居 → 不同 hash", () => {
-	const h1 = computeLineHash("a", "x", "b");
-	const h2 = computeLineHash("c", "x", "d");
-	assert.notEqual(h1, h2);
+test("different line number → different hash (even for identical content)", () => {
+	assert.notEqual(computeLineHash(2, ""), computeLineHash(5, ""));
+	assert.notEqual(computeLineHash(1, "}"), computeLineHash(2, "}"));
 });
 
-test("context-aware：相同三元组 → 相同 hash", () => {
-	assert.equal(computeLineHash("a", "x", "b"), computeLineHash("a", "x", "b"));
+test("different content → different hash", () => {
+	assert.notEqual(computeLineHash(1, "a"), computeLineHash(1, "b"));
 });
 
-test("base32 字符集（去 I/L/O/U）批量", () => {
+test("same (line, content) → same hash", () => {
+	assert.equal(computeLineHash(7, "x"), computeLineHash(7, "x"));
+});
+
+test("base32 alphabet (without I/L/O/U) in bulk", () => {
 	for (let i = 0; i < 2000; i++) {
-		const h = computeLineHash("", `line ${i}`, "", 4);
+		const h = computeLineHash(i + 1, `line ${i}`, 4);
 		for (const ch of h) assert.ok(ALLOWED.has(ch), `bad char ${ch} in ${h}`);
 	}
 });
 
-test("hashFileLines 长度等于行数", () => {
+test("hashFileLines length equals line count", () => {
 	assert.equal(hashFileLines(["a", "b", "c"]).length, 3);
 });
 
-test("hashFileLines 空文件", () => {
+test("hashFileLines empty file", () => {
 	assert.deepEqual(hashFileLines([]), []);
 });
 
-test("hashFileLines 文件内无碰撞（大量重复行）", () => {
+test("hashFileLines: identical content lines get distinct hashes (no collision, no length bloat)", () => {
+	// runs of identical lines — the case neighbor-aware hashing explodes on
 	const lines = ["", "", "", "", "", "}", "}", "}", "return", "return", ",", ","];
 	const hashes = hashFileLines(lines);
-	assert.equal(new Set(hashes).size, hashes.length, "collision not resolved");
+	assert.equal(new Set(hashes).size, hashes.length, "duplicate hashes");
+	for (const h of hashes) assert.equal(h.length, 4, `hash ${h} is not 4 chars`);
 });
 
-test("hashFileLines 长度参数生效", () => {
+test("hashFileLines respects the length parameter", () => {
 	assert.equal(hashFileLines(["a", "b"], 6)[0].length, 6);
 	assert.equal(hashFileLines(["a", "b"], 4)[0].length, 4);
 });