@jerryan/pi-hashline-edit 0.7.0 → 0.7.2

package/README.md

@@ -1,114 +1,127 @@
-![pi-hashline-edit](assets/banner.jpeg)
-
-# pi-hashline-edit
-
-A [pi-coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent) extension that replaces the built-in `read` and `edit` tools with a hash-anchored line-editing workflow.
-
-Every line returned by `read` carries a short content hash. Edits reference these hashes instead of raw text, so the tool can detect stale context and reject outdated changes before they reach the file.
-
-Inspired by [oh-my-pi](https://github.com/can1357/oh-my-pi).
-
-## Differences from upstream
-
-This is a fork of the original [pi-hashline-edit](https://github.com/earendil-works/pi-hashline-edit). The core protocol (hash-anchored reads, stale-anchor rejection, atomic writes) is unchanged from upstream. Key differences:
-
-- **Single edit shape.** One entry type: `{ range: [start, end], lines: [...] }`. No `op` field, no `append`/`prepend`/`replace_text` ops, no `after`/`before`. The tuple enforces explicit endpoint anchors, eliminating the common "forgot `end`" failure mode.
-- **Standard hex hash alphabet.** `0-9 A-F` instead of `ZPMQVRWSNKTXJBYH`. Hex pairs are more likely to be single tokens.
-- **Symmetric boundary-duplication detection.** Runtime warnings catch duplicated boundary lines on both sides of a replacement, not just trailing.
-- **`read` raw mode.** `raw: true` returns plain text without `LINE#HASH:` anchors, for reads that don't plan to edit.
-- **Inline FNV-1a hashing.** Replaces `xxhashjs` dependency. Always incorporates line index.
-- **Minimal prompt surface.** Prompt text describes what the model needs to use the tool; return-format documentation and error catalogues are omitted.
-- **No legacy compatibility.** The `{ oldText, newText }` substring-replace format is not accepted. The schema is hashline-only.
-
-## Installation
-
-```bash
-# From npm
-pi install npm:pi-hashline-edit
-
-# From a local checkout
-pi install /path/to/pi-hashline-edit
-```
-
-## How It Works
-
-### `read` — tagged line output
-
-Text files are returned with a `LINE#HASH:` prefix on every line. Line numbers may be left-padded within each returned block so the `#HASH:` columns align:
-
-```text
- 8#A4:function hello() {
- 9#3F:  console.log("world");
-10#B2:}
-```
-
-- `LINE` — 1-indexed line number.
-- `HASH` — 2-character content hash (hex digits `0-9 A-F`).
-
-Optional parameters:
-- `offset` — start reading from this line number (1-indexed).
-- `limit` — maximum number of lines to return.
-- `raw` — when `true`, returns plain text without LINE#HASH anchors. Saves tokens when you don't plan to edit this file.
-
-Images (JPEG, PNG, GIF, WebP) are passed through as attachments and do not participate in the hashline protocol. Binary and directory paths are rejected with a descriptive error.
-
-### `edit` — hash-anchored modifications
-
-Each edit entry replaces an inclusive anchor range:
-
-```json
-{
-  "path": "src/main.ts",
-  "edits": [
-    { "range": ["11#3F", "11#3F"], "lines": ["  console.log('hashline');"] },
-    { "range": ["42#B2", "45#C7"], "lines": ["function foo() {", "  return 42;", "}"] }
-  ]
-}
-```
-
-- `range` — `[start, end]` pair of LINE#HASH anchors. Use the same anchor twice for single-line.
-- `lines` — new content replacing the range (string array). Use `[]` to delete.
-
-All edits in a single call validate against the same pre-edit snapshot and apply bottom-up, so line numbers stay consistent across operations.
-
-### Chained edits
-
-After a successful edit, the result includes an `--- Updated anchors ---` block with fresh `LINE#HASH` references for the changed region. These can be used directly in the next `edit` call on the same file without a full re-read, provided the next edit targets the same or nearby lines. For distant changes, use `read` first.
-
-### Diff preview
-
-Each edit result includes a compact `Diff preview:` block showing the changed lines with `+`/`-` markers and their new `LINE#HASH` anchors, making quick follow-up edits possible without a full re-read.
-
-## Design Decisions
-
-- **Stale anchors fail.** A hash mismatch means the file has changed since the last `read`. The error includes a snippet with fresh `LINE#HASH` references for the affected lines for immediate retry.
-- **No fallback relocation.** Mismatched anchors are never silently relocated to a "close enough" line. This trades convenience for correctness.
-- **Strict patch content.** If `lines` contains `LINE#HASH:` display prefixes or diff `+`/`-` markers, the edit is rejected with `[E_INVALID_PATCH]`. The model must send literal file content; the runtime does not silently strip accidental prefixes.
-- **Atomic writes.** Files are written via temp-file-then-rename to avoid corruption from interrupted writes. Symlink chains are resolved so the target file is updated without replacing the symlink. Hard-linked files are updated in place to preserve the shared inode. File permissions are preserved across atomic renames.
-- **Per-file mutation queue.** Edits queue by the canonical write target, so concurrent edits through different symlink paths still serialize onto the same underlying file.
-- **Schema-delegated validation.** Field-type and schema validation are the responsibility of pi's AJV layer. The extension's runtime guard only prevents crashes from missing required top-level fields.
-
-## Hashing
-
-Hashes are computed with inline FNV-1a (32-bit, mask-reduced to 8 bits), then mapped to a 2-character hex string from `0-9 A-F`.
-
-The line index is always incorporated into the hash, so identical content on different lines produces different hashes.
-
-## Development
-
-Requires [Node.js](https://nodejs.org) and npm.
-
-```bash
-npm install
-npm test
-```
-
-Set `PI_HASHLINE_DEBUG=1` to show an "active" notification at session start.
-
-## Credits
-
-Thanks to [can1357](https://github.com/can1357) for the original [oh-my-pi](https://github.com/can1357/oh-my-pi) implementation and the hashline concept.
-
-## License
-
-[MIT](LICENSE)
+![pi-hashline-edit](assets/banner.jpeg)
+
+# pi-hashline-edit
+
+A [pi-coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent) extension that replaces the built-in `read` and `edit` tools with a hash-anchored line-editing workflow.
+
+Every line returned by `read` carries a short content hash. Edits reference these hashes instead of raw text, so the tool can detect stale context and reject outdated changes before they reach the file.
+
+Inspired by [oh-my-pi](https://github.com/can1357/oh-my-pi).
+
+## Differences from upstream
+
+This is a fork of the original [pi-hashline-edit](https://github.com/earendil-works/pi-hashline-edit). The core protocol (hash-anchored reads, stale-anchor rejection, atomic writes) is unchanged from upstream. Key differences:
+
+- **Single edit shape.** One entry type: `{ range: [start, end], lines: [...] }`. No `op` field, no `append`/`prepend`/`replace_text` ops, no `after`/`before`. The tuple enforces explicit endpoint anchors, eliminating the common "forgot `end`" failure mode.
+- **Standard hex hash alphabet.** `0-9 A-F` instead of `ZPMQVRWSNKTXJBYH`. Hex pairs are more likely to be single tokens.
+- **Symmetric boundary-duplication detection.** Runtime warnings catch duplicated boundary lines on both sides of a replacement, not just trailing.
+- **`read` raw mode.** `raw: true` returns plain text without `LINE#HASH:` anchors, for reads that don't plan to edit.
+- **Inline FNV-1a hashing.** Replaces `xxhashjs` dependency. Always incorporates line index.
+- **Minimal prompt surface.** Prompt text describes what the model needs to use the tool; return-format documentation and error catalogues are omitted.
+- **No legacy compatibility.** The `{ oldText, newText }` substring-replace format is not accepted. The schema is hashline-only.
+
+## Installation
+
+```bash
+# From npm
+pi install npm:@jerryan/pi-hashline-edit
+
+# From a local checkout
+pi install /path/to/pi-hashline-edit
+```
+
+## How It Works
+
+### `read` — tagged line output
+
+Text files are returned with a `LINE#HASH:` prefix on every line. Line numbers may be left-padded within each returned block so the `#HASH:` columns align:
+
+```text
+ 8#A4:function hello() {
+ 9#3F:  console.log("world");
+10#B2:}
+```
+
+- `LINE` — 1-indexed line number.
+- `HASH` — 2-character content hash (hex digits `0-9 A-F`).
+
+Optional parameters:
+- `offset` — start reading from this line number (1-indexed).
+- `limit` — maximum number of lines to return.
+- `raw` — when `true`, returns plain text without LINE#HASH anchors. Saves tokens when you don't plan to edit this file.
+
+Images (JPEG, PNG, GIF, WebP) are passed through as attachments and do not participate in the hashline protocol. Binary and directory paths are rejected with a descriptive error.
+
+### `edit` — hash-anchored modifications
+
+Each edit entry replaces an inclusive anchor range:
+
+```json
+{
+  "path": "src/main.ts",
+  "edits": [
+    { "range": ["11#3F", "11#3F"], "lines": ["  console.log('hashline');"] },
+    { "range": ["42#B2", "45#C7"], "lines": ["function foo() {", "  return 42;", "}"] }
+  ]
+}
+```
+
+- `range` — `[start, end]` pair of LINE#HASH anchors. Use the same anchor twice for single-line.
+- `lines` — new content replacing the range (string array). Use `[]` to delete.
+
+All edits in a single call validate against the same pre-edit snapshot and apply bottom-up, so line numbers stay consistent across operations.
+
+### Chained edits
+
+After a successful edit, the response contains a unified diff where context and added lines carry fresh `LINE#HASH` anchors. These can be used directly in the next `edit` call on the same file without a full re-read, provided the next edit targets the same or nearby lines. For distant changes, use `read` first.
+
+### Diff output
+
+Each edit result shows a unified diff with hashline-formatted lines:
+
+```text
+ 8#A4:function hello() {
+-9   :  console.log("world");
++9#B1:  console.log("hashline");
+10#B2:}
+```
+
+- Context lines: ` NN#HH:content` (space prefix)
+- Removed lines: `-NN   :content` (no hash, aligned colon)
+- Added lines: `+NN#HH:content` (hash for new anchors)
+- Multiple hunks are shown when edits are far apart.
+
+## Design Decisions
+
+- **Stale anchors fail.** A hash mismatch means the file has changed since the last `read`. The error includes a snippet with fresh `LINE#HASH` references for the affected lines for immediate retry.
+- **No fallback relocation.** Mismatched anchors are never silently relocated to a "close enough" line. This trades convenience for correctness.
+- **Strict patch content.** If `lines` contains `LINE#HASH:` display prefixes or diff `+`/`-` markers, the edit is rejected with `[E_INVALID_PATCH]`. The model must send literal file content; the runtime does not silently strip accidental prefixes.
+- **Full-file deletion guardrail.** Edits that would empty a file with more than 50 lines are rejected with `[E_WOULD_EMPTY]`. Small files show the full diff normally; large deletions are almost always mistakes.
+- **Atomic writes.** Files are written via temp-file-then-rename to avoid corruption from interrupted writes. Symlink chains are resolved so the target file is updated without replacing the symlink. Hard-linked files are updated in place to preserve the shared inode. File permissions are preserved across atomic renames.
+- **Per-file mutation queue.** Edits queue by the canonical write target, so concurrent edits through different symlink paths still serialize onto the same underlying file.
+- **Schema-delegated validation.** Field-type and schema validation are the responsibility of pi's AJV layer. The extension's runtime guard only prevents crashes from missing required top-level fields.
+
+## Hashing
+
+Hashes are computed with inline FNV-1a (32-bit, mask-reduced to 8 bits), then mapped to a 2-character hex string from `0-9 A-F`.
+
+The line index is always incorporated into the hash, so identical content on different lines produces different hashes.
+
+## Development
+
+Requires [Node.js](https://nodejs.org) and npm.
+
+```bash
+npm install
+npm test
+```
+
+Set `PI_HASHLINE_DEBUG=1` to show an "active" notification at session start.
+
+## Credits
+
+Thanks to [can1357](https://github.com/can1357) for the original [oh-my-pi](https://github.com/can1357/oh-my-pi) implementation and the hashline concept.
+
+## License
+
+[MIT](LICENSE)

package/package.json

@@ -1,53 +1,53 @@
-{
-  "name": "@jerryan/pi-hashline-edit",
-  "version": "0.7.0",
-  "description": "Hashline read/edit tool override for pi-coding-agent",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/JerryAZR/pi-hashline-edit.git"
-  },
-  "author": "JerryAZR",
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/"
-  },
-  "keywords": [
-    "pi-package",
-    "pi",
-    "coding-agent",
-    "extension",
-    "hashline"
-  ],
-  "license": "MIT",
-  "files": [
-    "index.ts",
-    "src",
-    "prompts",
-    "README.md",
-    "LICENSE"
-  ],
-  "pi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  },
-  "dependencies": {
-    "diff": "^8.0.2",
-    "file-type": "^21.3.0"
-  },
-  "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.74.0",
-    "@earendil-works/pi-coding-agent": ">=0.74.0",
-    "@earendil-works/pi-tui": "*",
-    "@sinclair/typebox": "*"
-  },
-  "scripts": {
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
-  "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.74.0",
-    "@types/node": "^22.0.0",
-    "ajv": "^8.20.0",
-    "vitest": "^3.0.0"
-  }
-}
+{
+  "name": "@jerryan/pi-hashline-edit",
+  "version": "0.7.2",
+  "description": "Hashline read/edit tool override for pi-coding-agent",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JerryAZR/pi-hashline-edit.git"
+  },
+  "author": "JerryAZR",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "coding-agent",
+    "extension",
+    "hashline"
+  ],
+  "license": "MIT",
+  "files": [
+    "index.ts",
+    "src",
+    "prompts",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "dependencies": {
+    "diff": "^8.0.2",
+    "file-type": "^21.3.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": ">=0.74.0",
+    "@earendil-works/pi-coding-agent": ">=0.74.0",
+    "@earendil-works/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@types/node": "^22.0.0",
+    "ajv": "^8.20.0",
+    "vitest": "^3.0.0"
+  }
+}

package/prompts/edit.md

@@ -1,12 +1,12 @@
 Patch a UTF-8 text file using `LINE#HASH` anchors copied verbatim from `read`.
 
-Submit one `edit` call per file. All operations go in a single `edits` array; anchors must all come from the same pre-edit read.
+Submit one `edit` call per file. All operations go in a single `edits` array; anchors must come from the same fresh source — the most recent `read` or diff output of a successful `edit` on this file.
 
 Each edit entry replaces an inclusive anchor range:
 ```json
 { "range": [startAnchor, endAnchor], "lines": [...] }
 ```
-- `range` — `[start, end]` pair of LINE#HASH anchors from the most recent `read`.
+- `range` — `[start, end]` pair of LINE#HASH anchors from the most recent `read` or diff output.
   Use the same anchor twice for single-line: `["42#A4", "42#A4"]`.
 - `lines` — new content replacing the range (string array). Use `[]` to delete.
   Must be literal file content, not LINE#HASH-prefixed output. Match indentation exactly.
@@ -19,5 +19,5 @@ Example:
 ] }
 
 Rules:
-- Do not guess, shift, or construct anchors. Copy them from the most recent `read` of this file.
+- Do not guess, shift, or construct anchors. Copy them from the most recent `read` or diff output of this file.
 - Do not emit overlapping or adjacent edits — merge them into one.

package/src/edit-diff.ts

@@ -223,102 +223,63 @@ export function replaceText(
 
 // ─── Diff generation ────────────────────────────────────────────────────
 
-function formatDiffPreviewLine(
-  prefix: " " | "+" | "-",
-  lineNum: number,
-  lineNumWidth: number,
-  line: string,
-  includeHash: boolean,
-): string {
-  const paddedLineNum = String(lineNum).padStart(lineNumWidth, " ");
-  if (!includeHash) {
-    return `${prefix}${paddedLineNum}    ${line}`;
-  }
-  return `${prefix}${paddedLineNum}#${computeLineHash(lineNum, line)}:${line}`;
-}
-
 export function generateDiffString(
   oldContent: string,
   newContent: string,
   contextLines = 4,
-): { diff: string; firstChangedLine: number | undefined } {
-  const parts = Diff.diffLines(oldContent, newContent);
-  const output: string[] = [];
+): { diff: string } {
+  const patch = Diff.structuredPatch("a", "b", oldContent, newContent, undefined, undefined, {
+    context: contextLines,
+  });
+
+  if (!patch.hunks.length) {
+    return { diff: "" };
+  }
+
   const maxLineNum = Math.max(
     oldContent.split("\n").length,
     newContent.split("\n").length,
   );
   const lineNumWidth = String(maxLineNum).length;
-  let oldLineNum = 1;
-  let newLineNum = 1;
-  let lastWasChange = false;
-  let firstChangedLine: number | undefined;
-
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i]!;
-    const raw = part.value.split("\n");
-    if (raw[raw.length - 1] === "") raw.pop();
-
-    if (part.added || part.removed) {
-      if (firstChangedLine === undefined) firstChangedLine = newLineNum;
-      for (const line of raw) {
-        if (part.added) {
-          output.push(
-            formatDiffPreviewLine("+", newLineNum, lineNumWidth, line, true),
-          );
-          newLineNum++;
-        } else {
-          output.push(
-            formatDiffPreviewLine("-", oldLineNum, lineNumWidth, line, false),
-          );
-          oldLineNum++;
-        }
-      }
-      lastWasChange = true;
-      continue;
+  const hashPad = " ".repeat(3); // align with `#HH:`
+
+  const output: string[] = [];
+
+  for (let h = 0; h < patch.hunks.length; h++) {
+    const hunk = patch.hunks[h]!;
+    if (h > 0) {
+      output.push("    ...");
     }
 
-    const nextPartIsChange =
-      i < parts.length - 1 && (parts[i + 1]!.added || parts[i + 1]!.removed);
-    if (lastWasChange || nextPartIsChange) {
-      let linesToShow = raw;
-      let skipStart = 0;
-      let skipEnd = 0;
+    let oldLineNum = hunk.oldStart;
+    let newLineNum = hunk.newStart;
 
-      if (!lastWasChange) {
-        skipStart = Math.max(0, raw.length - contextLines);
-        linesToShow = raw.slice(skipStart);
-      }
-      if (!nextPartIsChange && linesToShow.length > contextLines) {
-        skipEnd = linesToShow.length - contextLines;
-        linesToShow = linesToShow.slice(0, contextLines);
-      }
+    for (const line of hunk.lines) {
+      if (line === "\") continue;
 
-      if (skipStart > 0) {
-        output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
-        oldLineNum += skipStart;
-        newLineNum += skipStart;
-      }
-      for (const line of linesToShow) {
-        output.push(
-          formatDiffPreviewLine(" ", newLineNum, lineNumWidth, line, true),
-        );
+      const prefix = line[0] as " " | "+" | "-";
+      const text = line.slice(1);
+
+      if (prefix === "-") {
+        const padded = String(oldLineNum).padStart(lineNumWidth, " ");
+        output.push(`-${padded}${hashPad}:${text}`);
+        oldLineNum++;
+      } else if (prefix === "+") {
+        const padded = String(newLineNum).padStart(lineNumWidth, " ");
+        const hash = computeLineHash(newLineNum, text);
+        output.push(`+${padded}#${hash}:${text}`);
+        newLineNum++;
+      } else {
+        const padded = String(newLineNum).padStart(lineNumWidth, " ");
+        const hash = computeLineHash(newLineNum, text);
+        output.push(` ${padded}#${hash}:${text}`);
         oldLineNum++;
         newLineNum++;
       }
-      if (skipEnd > 0) {
-        output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
-        oldLineNum += skipEnd;
-        newLineNum += skipEnd;
-      }
-    } else {
-      oldLineNum += raw.length;
-      newLineNum += raw.length;
     }
-    lastWasChange = false;
   }
 
-  return { diff: output.join("\n"), firstChangedLine };
+  return { diff: output.join("\n") };
 }
 
 export interface CompactHashlineDiffPreview {

package/src/edit-response.ts

@@ -1,21 +1,11 @@
 /**
  * Edit response builders.
  *
- * Pulled out of `src/edit.ts` execute() so the noop and changed branches
- * are independently testable and the top-level execute path stays narrative.
- *
- * No behaviour change: outputs are byte-identical to the previous inline
- * implementation. The only additive surface is `details.metrics` (Phase 2 C
- * — observability for hosts; the LLM-visible text is unchanged).
+ * Unified diff output: agent and user see the same content. The diff is
+ * generated from structuredPatch hunks with hashline-formatted lines.
  */
 
 import { generateDiffString } from "./edit-diff";
-import {
-  computeAffectedLineRange,
-  formatHashlineRegion,
-} from "./hashline";
-
-const CHANGED_ANCHOR_TEXT_BUDGET_BYTES = 50 * 1024;
 
 // ─── Public types ───────────────────────────────────────────────────────
 
@@ -24,7 +14,6 @@ export type EditMetrics = {
   edits_noop: number;
   warnings: number;
   classification: "applied" | "noop";
-  changed_lines?: { first: number; last: number };
   added_lines?: number;
   removed_lines?: number;
 };
@@ -51,8 +40,6 @@ export interface SuccessResponseInput {
   originalNormalized: string;
   result: string;
   warnings: string[] | undefined;
-  firstChangedLine: number | undefined;
-  lastChangedLine: number | undefined;
   snapshotId: string;
   editsAttempted: number;
   noopEditsCount: number;
@@ -60,12 +47,6 @@ export interface SuccessResponseInput {
 
 // ─── Helpers ────────────────────────────────────────────────────────────
 
-function getVisibleLines(text: string): string[] {
-  if (text.length === 0) return [];
-  const lines = text.split("\n");
-  return text.endsWith("\n") ? lines.slice(0, -1) : lines;
-}
-
 function countDiffLines(diff: string, marker: "+" | "-"): number {
   if (!diff) return 0;
   let count = 0;
@@ -82,8 +63,6 @@ function buildMetrics(args: {
   editsAttempted: number;
   noopEditsCount: number;
   warningsCount: number;
-  firstChangedLine?: number;
-  lastChangedLine?: number;
   addedLines?: number;
   removedLines?: number;
 }): EditMetrics {
@@ -93,16 +72,6 @@ function buildMetrics(args: {
     warnings: args.warningsCount,
     classification: args.classification,
   };
-  if (
-    args.classification === "applied" &&
-    args.firstChangedLine !== undefined &&
-    args.lastChangedLine !== undefined
-  ) {
-    metrics.changed_lines = {
-      first: args.firstChangedLine,
-      last: args.lastChangedLine,
-    };
-  }
   if (args.addedLines !== undefined) metrics.added_lines = args.addedLines;
   if (args.removedLines !== undefined) metrics.removed_lines = args.removedLines;
   return metrics;
@@ -145,7 +114,6 @@ export function buildNoopResponse(input: NoopResponseInput): ToolResult {
     content: [{ type: "text", text }],
     details: {
       diff: "",
-      firstChangedLine: undefined,
       snapshotId,
       classification: "noop" as const,
       metrics,
@@ -154,42 +122,15 @@ export function buildNoopResponse(input: NoopResponseInput): ToolResult {
 }
 
 export function buildChangedResponse(input: SuccessResponseInput): ToolResult {
-  const {
-    result,
-    warnings,
-    firstChangedLine,
-    lastChangedLine,
-    snapshotId,
-    originalNormalized,
-    editsAttempted,
-    noopEditsCount,
-  } = input;
+  const { result, warnings, snapshotId, originalNormalized, editsAttempted, noopEditsCount } =
+    input;
 
   const diffResult = generateDiffString(originalNormalized, result);
   const addedLines = countDiffLines(diffResult.diff, "+");
   const removedLines = countDiffLines(diffResult.diff, "-");
   const warningsBlock = warningsBlockOf(warnings);
 
-  const resultLines = getVisibleLines(result);
-  const anchorRange = computeAffectedLineRange({
-    firstChangedLine,
-    lastChangedLine,
-    resultLineCount: resultLines.length,
-  });
-  const anchorsBlock = anchorRange
-    ? (() => {
-        const region = resultLines.slice(anchorRange.start - 1, anchorRange.end);
-        const formatted = formatHashlineRegion(region, anchorRange.start);
-        const block = `--- Anchors ${anchorRange.start}-${anchorRange.end} ---\n${formatted}`;
-        return Buffer.byteLength(block, "utf8") <= CHANGED_ANCHOR_TEXT_BUDGET_BYTES
-          ? block
-          : "Anchors omitted; use read for subsequent edits.";
-      })()
-    : resultLines.length === 0
-      ? "File is empty. Use edit with prepend or append and omit pos to insert content."
-      : "Anchors omitted; use read for subsequent edits.";
-
-  const text = [anchorsBlock, warningsBlock.trimStart()]
+  const text = [diffResult.diff, warningsBlock.trimStart()]
     .filter((section) => section.length > 0)
     .join("\n\n");
 
@@ -198,8 +139,6 @@ export function buildChangedResponse(input: SuccessResponseInput): ToolResult {
     editsAttempted,
     noopEditsCount,
     warningsCount: warnings?.length ?? 0,
-    firstChangedLine,
-    lastChangedLine,
     addedLines,
     removedLines,
   });
@@ -208,7 +147,6 @@ export function buildChangedResponse(input: SuccessResponseInput): ToolResult {
     content: [{ type: "text", text }],
     details: {
       diff: diffResult.diff,
-      firstChangedLine: firstChangedLine ?? diffResult.firstChangedLine,
       snapshotId,
       metrics,
     },