pi-hashline-edit-pro 1.0.8 → 1.1.1

package/README.md

@@ -11,7 +11,7 @@ Fork of [pi-hashline-edit](https://github.com/RimuruW/pi-hashline-edit) by Rimur
 - **Stable anchors.** Editing one part of a file leaves the hashes of untouched lines unchanged, so anchors from earlier reads stay valid.
 - **Autocorrection with warnings.** Unambiguous copy-paste mistakes — hash prefixes, diff-preview rows, reversed ranges — are fixed automatically and reported.
 - **Safe writes.** Atomic temp-file-then-rename writes preserve permissions, BOMs, line endings, symlinks, and hard links.
-- **Auto-read.** Fresh anchors are appended to the result of every `write`, `replace`, and `undo_last_replace`.
+- **Auto-read.** Fresh anchors are appended to the result of every `write` that changes the file; after `replace` and `undo_last_replace`, the post-edit diff is shown instead.
 
 ## Installation
 
@@ -47,7 +47,7 @@ kQm│}
 }
 ```
 
-3. Keep editing. Anchors for untouched lines remain valid across edits, so hashes from earlier reads keep working; changed lines get fresh anchors, which auto-read appends to each result.
+3. Keep editing. Anchors for untouched lines remain valid across edits, so hashes from earlier reads keep working; changed lines get fresh anchors, which auto-read appends after each `write`.
 
 ## The `read` tool
 
@@ -102,7 +102,7 @@ Behavior:
   - A reversed range (start hash after end hash) is swapped and applied.
   - A duplicated boundary line — the classic `}`, `});`, or `} else {` pasted twice — is silently removed; the duplicate never reaches the file.
   - `file_path` is accepted as an alias for `path`; a JSON-string `content_lines` is parsed into an array.
-- **Response.** A successful edit reports `Successfully replaced in {path}. Added X line(s), removed Y line(s).` plus any warnings. An edit that produces identical content reports `No changes made` and never rotates anchors. The post-edit diff is exposed to the host UI via `details.diff` only — it is intentionally not part of the model-visible text.
+- **Response.** With auto-read enabled (the default), a successful edit returns the post-edit diff — the same `+HASH│` / `-   │` / ` HASH│` rows the user sees — instead of the summary. With auto-read disabled, the edit reports `Successfully replaced in {path}. Added X line(s), removed Y line(s).` plus any warnings, and no diff is shown to the model. Warnings are appended in both modes. An edit that produces identical content reports `No changes made` and never rotates anchors. The post-edit diff is exposed to the host UI via `details.diff` — the TUI always shows it — and reaches the model-visible text only while auto-read is on.
 - **Undo.** Every successful replace is undoable once via `undo_last_replace` — see [Undo](#undo).
 
 ## Anchor stability
@@ -118,13 +118,15 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 
 ## Auto-read
 
-Enabled by default. After a successful `write`, `replace`, or `undo_last_replace`, the extension reads the file and appends an `--- Auto-read (hashline anchors) ---` block to the result, so the model gets immediate `HASH│content` anchors without a separate `read` call.
+Enabled by default. After a successful `write` that changes the file, the extension reads the file and appends an `--- Auto-read (hashline anchors) ---` block to the result, so the model gets immediate `HASH│content` anchors without a separate `read` call.
 
-- After `replace` / `undo_last_replace`, the block covers the changed span plus 2 lines of context above and below — the rest of the file keeps its anchors from the persistent store.
+- A no-op `replace` produces no diff — the file is unchanged, so existing anchors remain valid.
+- After `replace` / `undo_last_replace`, the success summary is replaced by the post-edit diff (the same `+HASH│` / `-   │` / ` HASH│` rows used for replace) plus any warnings, so the model sees the change like a git diff instead of line counts; no anchor block is appended — call `read` for fresh anchors.
+- With auto-read disabled, `replace` / `undo_last_replace` results keep the plain summary in the model-visible text — no diff and no anchor block reach the model (the post-edit diff is still shown to the user).
 - After `write`, the block dumps from the top of the file. For files over 2000 lines, the dump is truncated with a pagination hint — use `read` with `offset` to continue.
 - Auto-read keeps a 50KB display budget: lines over 50KB are skipped with a marker instead of their content (use `read` for lines up to 200KB).
 - Toggle at runtime with `/toggle-auto-read`; the setting persists across sessions.
-- If the auto-read itself fails (e.g. the file was deleted between the operation and the read), a short `--- Auto-read failed: ... ---` notice is appended instead of the anchor block, so the model knows the anchors are missing.
+- If the auto-read itself fails (e.g. the file was deleted between the write and the read), a short `--- Auto-read failed: ... ---` notice is appended instead of the anchor block, so the model knows the anchors are missing.
 
 ## Undo
 
@@ -134,14 +136,14 @@ Enabled by default. After a successful `write`, `replace`, or `undo_last_replace
 - History is persisted in the hash store (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) and survives session restarts; a failed `write` does not clear it.
 - **Undo is a precondition, not a convenience.** The undo record is persisted *before* the edit is written; if it cannot be persisted, the `replace` is refused with `[E_UNDO_UNAVAILABLE]` and the file is not touched, so every applied edit is undoable. If the file write itself then fails, the previous undo record is restored, so a refused edit never destroys earlier undo history.
 - A successful `write` clears the history for that file.
-- Call `read` after an undo to get fresh anchors for follow-up edits.
+- With auto-read enabled, the model sees the post-edit diff after an undo, just like a replace; with auto-read disabled it sees the plain summary. No anchors are appended after an undo — call `read` to get fresh anchors for follow-up edits.
 - **Safety guard.** If the file was modified or deleted since the last replace, `undo_last_replace` refuses with `[E_UNDO_STALE]` rather than overwriting those changes.
 
 ## Commands and configuration
 
 | Command | Description |
 | --- | --- |
-| `/toggle-auto-read` | Toggle automatic hashline anchors after write and replace operations. Persists across sessions. |
+| `/toggle-auto-read` | Toggle automatic hashline anchors after write and post-edit diffs after replace and undo_last_replace operations. Persists across sessions. |
 
 Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created automatically when a setting is toggled:
 

package/index.ts

@@ -5,7 +5,7 @@ import { regReplace } from "./src/replace";
 import { regReplaceUndo, clearUndo } from "./src/replace-undo";
 import { regRead, fmtReadPreview } from "./src/read";
 import type { RMetrics } from "./src/replace-response";
-import { AUTO_READ_MAX } from "./src/constants";
+import { extractWarnings } from "./src/replace-render";
 import { MAX_HASH_LINES } from "./src/hashline";
 import {
   readConfig,
@@ -13,16 +13,17 @@ import {
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
 import { readNormFile } from "./src/file-reader";
+import { loadFileKindAndText } from "./src/file-kind";
 import { toCwd } from "./src/paths";
 import { resolveTarget } from "./src/fs-write";
+import { valAccess } from "./src/validation";
 
 export default function (pi: ExtensionAPI): void {
-  regRead(pi, { autoRead: true });
+  regRead(pi);
 
   regReplace(pi);
   regReplaceUndo(pi);
 
-  const debugValue = process.env.PI_HASHLINE_DEBUG;
   let autoRead = true;
 
   pi.on("session_start", async (_event, ctx) => {
@@ -37,25 +38,24 @@ export default function (pi: ExtensionAPI): void {
     }
     const config = await readConfig();
     autoRead = config.autoRead;
-    regRead(pi, { autoRead });
-
+    const debugValue = process.env.PI_HASHLINE_DEBUG;
     if (debugValue === "1" || debugValue === "true") {
       ctx.ui.notify(`Hashline Edit mode active`, "info");
     }
   });
 
   pi.registerCommand("toggle-auto-read", {
-    description: "Toggle automatic hashline anchors after write and replace operations",
+    description: "Toggle automatic hashline anchors after write and post-edit diffs after replace and undo_last_replace operations",
     handler: async (_args, ctx) => {
       autoRead = await toggleAutoRead();
-      regRead(pi, { autoRead });
       const state = autoRead ? "enabled" : "disabled";
-      ctx.ui.notify(`Auto-read after write/replace: ${state}`, "info");
+      ctx.ui.notify(`Auto-read anchors (write) and post-edit diffs (replace/undo): ${state}`, "info");
     },
   });
 
   pi.on("tool_result", async (event, ctx) => {
     if (event.isError) return;
+
     if (event.toolName === "write") {
       const writtenPath = (event.input as Record<string, unknown>)?.path;
       if (typeof writtenPath === "string") {
@@ -65,58 +65,68 @@ export default function (pi: ExtensionAPI): void {
           console.error("Failed to clear undo after write:", error);
         }
       }
+      if (!autoRead) return;
+      if (typeof writtenPath !== "string") return;
+      try {
+        const resolvedPath = await resolveTarget(toCwd(writtenPath, ctx.cwd));
+        await valAccess(resolvedPath, writtenPath);
+        const file = await loadFileKindAndText(resolvedPath, { maxLines: MAX_HASH_LINES, displayPath: writtenPath });
+        if (file.kind !== "text") return;
+        const { normalized, fileHashes, absolutePath } = await readNormFile(
+          writtenPath, ctx.cwd, { maxLines: MAX_HASH_LINES, preloadedFile: file },
+        );
+        const preview = await fmtReadPreview(
+          normalized,
+          {},
+          fileHashes,
+          absolutePath,
+          DEFAULT_MAX_BYTES,
+        );
+        return {
+          content: [
+            ...(event.content ?? []),
+            { type: "text", text: `\n\n--- Auto-read (hashline anchors) ---\n${preview.text}` },
+          ],
+        };
+      } catch (error) {
+        console.error("Auto-read after write failed:", error);
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            ...(event.content ?? []),
+            { type: "text", text: `\n\n--- Auto-read failed: ${message} ---` },
+          ],
+        };
+      }
     }
-    if (!autoRead) return;
+
     if (
-      event.toolName !== "write" &&
       event.toolName !== "replace" &&
       event.toolName !== "undo_last_replace"
     ) return;
-    const filePath = (event.input as Record<string, unknown>)?.path;
-    if (typeof filePath !== "string") return;
+    if (!autoRead) return;
 
     const metrics = (event.details as { metrics?: RMetrics } | undefined)?.metrics;
-    if (event.toolName !== "write" && metrics?.classification === "noop") return;
+    if (metrics?.classification === "noop") return;
 
-    try {
-      const { normalized, fileHashes, absolutePath } = await readNormFile(
-        filePath, ctx.cwd, { maxLines: MAX_HASH_LINES },
-      );
-
-      const changedLines =
-        event.toolName === "replace" || event.toolName === "undo_last_replace"
-          ? metrics?.changed_lines
-          : undefined;
-      let offset: number | undefined;
-      let limit = AUTO_READ_MAX;
-      if (changedLines) {
-        offset = Math.max(1, changedLines.first - 2);
-        limit = Math.min(changedLines.last + 2 - offset + 1, AUTO_READ_MAX);
-      }
+    const diff = (event.details as { diff?: string } | undefined)?.diff;
+    if (!diff) return;
 
-      const preview = await fmtReadPreview(
-        normalized,
-        { offset, limit },
-        fileHashes,
-        absolutePath,
-        DEFAULT_MAX_BYTES,
-      );
-
-      return {
-        content: [
-          ...(event.content ?? []),
-          { type: "text", text: `\n\n--- Auto-read (hashline anchors) ---\n${preview.text}` },
-        ],
-      };
-    } catch (error) {
-      console.error("Auto-read after write/replace failed:", error);
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        content: [
-          ...(event.content ?? []),
-          { type: "text", text: `\n\n--- Auto-read failed: ${message} ---` },
-        ],
-      };
-    }
+    const rendered = (event.content ?? [])
+      .filter(
+        (entry): entry is { type: "text"; text: string } =>
+          entry.type === "text" && typeof entry.text === "string",
+      )
+      .map((entry) => entry.text)
+      .join("\n");
+    const warnings = extractWarnings(rendered);
+    return {
+      content: [
+        {
+          type: "text",
+          text: warnings ? `${diff}\n\n${warnings}` : diff,
+        },
+      ],
+    };
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "1.0.8",
+  "version": "1.1.1",
   "type": "module",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 62-symbol, perfect hashing)",
   "main": "index.ts",

package/prompts/read-guidelines.md

@@ -1,2 +1,2 @@
 - `read`: call before `replace` when you need fresh HASH anchors for a file.
-{{AUTO_READ_NOTE}}
+- `read`: call again after any edit to that file — changed lines get new anchors.

package/prompts/replace-guidelines.md

@@ -1,4 +1,6 @@
 - `replace`: hash_range_inclusive must use only anchors from the most recent read of the same file.
+- `replace`: hash_range_inclusive marks the exact lines that are REMOVED, and content_lines is their complete replacement applied in order; nothing outside the range changes. Every line inside the range that is not reproduced byte-exact in content_lines is deleted from the file — including closing braces and other structural lines.
+- `replace`: minimize the replaced range — anchor only the lines that actually change, so few unchanged lines must be reproduced byte-exact.
+- `replace`: to replace a single line, repeat its hash in both positions of hash_range_inclusive: ["<HASH>", "<HASH>"] — never extend the range to neighboring lines for a one-line edit.
 - `replace`: content_lines is a native JSON array of strings — never a serialized JSON string. When copying a line from read output, remove its HASH│ prefix and keep the leading whitespace exactly as shown.
-- `replace`: minimize the replaced range — anchor only the lines that actually change; for insertions use a single-line range (e.g. the line after the insertion point) instead of a whole block, so fewer unchanged lines must be reproduced byte-exact.
-- `replace`: content_lines entries are single lines — never embed a line break inside an entry; pass each line as its own array entry.
+- `replace`: content_lines entries are single lines — never embed a line break inside an entry; pass each line as its own array entry.

package/src/file-kind.ts

@@ -46,8 +46,14 @@ export type LFile =
   | { kind: "binary"; description: string };
 
 
+export interface LoadFileOptions {
+  maxLines?: number;
+  displayPath?: string;
+}
+
 export async function loadFileKindAndText(
   filePath: string,
+  options?: LoadFileOptions,
 ): Promise<LFile> {
   const pathStat = await fsStat(filePath);
   if (pathStat.isDirectory()) {
@@ -104,6 +110,7 @@ export async function loadFileKindAndText(
 
     const decoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
     let hadUtf8DecodeErrors = false;
+    let newlineCount = 0;
     const parts: string[] = [];
 
     function decodeChunk(chunk: Uint8Array, stream: boolean): string {
@@ -111,6 +118,16 @@ export async function loadFileKindAndText(
       if (!hadUtf8DecodeErrors && decoded.includes("\uFFFD")) {
         hadUtf8DecodeErrors = true;
       }
+      if (options?.maxLines !== undefined) {
+        for (let i = 0; i < decoded.length; i++) {
+          if (decoded.charCodeAt(i) === 10) newlineCount++;
+        }
+        if (newlineCount > options.maxLines) {
+          throw new Error(
+            `[E_FILE_TOO_LARGE] ${options.displayPath ?? filePath} has more than ${options.maxLines} lines, exceeding the ${options.maxLines}-line edit limit. Hashline editing targets source-sized files; for very large files use write or a non-line-based approach.`,
+          );
+        }
+      }
       return decoded;
     }
 

package/src/file-reader.ts

@@ -20,12 +20,17 @@ export interface NormFile {
 
 export type SnapInfo = {
   snapshotId: string;
+  ino: number;
   mtimeMs: number;
+  ctimeMs: number;
   size: number;
 };
 
-function fmtSnapId(canonicalPath: string, info: { mtimeMs: number; size: number }): string {
-  return `v1|${canonicalPath}|${info.mtimeMs}|${info.size}`;
+function fmtSnapId(
+  canonicalPath: string,
+  info: { ino: number; mtimeMs: number; ctimeMs: number; size: number },
+): string {
+  return `v2|${canonicalPath}|${info.ino}|${info.mtimeMs}|${info.ctimeMs}|${info.size}`;
 }
 
 export async function fileSnap(absolutePath: string): Promise<SnapInfo> {
@@ -33,7 +38,9 @@ export async function fileSnap(absolutePath: string): Promise<SnapInfo> {
   const stats = await stat(canonicalPath);
   return {
     snapshotId: fmtSnapId(canonicalPath, stats),
+    ino: stats.ino,
     mtimeMs: stats.mtimeMs,
+    ctimeMs: stats.ctimeMs,
     size: stats.size,
   };
 }
@@ -60,9 +67,8 @@ export async function readNormFile(
   await valAccess(resolvedPath, path, accessMode);
 
   abortIf(signal);
-  const file = options?.preloadedFile ?? (await loadFileKindAndText(resolvedPath));
+  const file = options?.preloadedFile ?? (await loadFileKindAndText(resolvedPath, { maxLines: options?.maxLines, displayPath: path }));
   valKind(file, path);
-
   abortIf(signal);
   const { bom, text: rawContent } = stripBOM(file.text);
   const originalEnding = detectEnding(rawContent);

package/src/hash-store.ts

@@ -46,6 +46,55 @@ function isValidSnapshot(value: unknown): value is LegacySnapshot {
   return true;
 }
 
+export function isCorruptionError(error: unknown): boolean {
+  if (error && typeof error === "object") {
+    const errcode = (error as { errcode?: unknown }).errcode;
+    if (typeof errcode === "number") {
+      return errcode === 11 || errcode === 24 || errcode === 26;
+    }
+    const code = (error as { code?: unknown }).code;
+    if (typeof code === "string" && /NOTADB|CORRUPT/.test(code)) return true;
+  }
+  return (
+    error instanceof Error &&
+    /corrupt|not a database|malformed|database disk image/i.test(error.message)
+  );
+}
+
+function isBusyError(error: unknown): boolean {
+  if (error && typeof error === "object") {
+    const errcode = (error as { errcode?: unknown }).errcode;
+    if (typeof errcode === "number") return errcode === 5 || errcode === 6;
+  }
+  return error instanceof Error && /busy|locked/i.test(error.message);
+}
+
+function sleepSync(ms: number): void {
+  const sab = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(sab, 0, 0, ms);
+}
+
+const BUSY_RETRIES = 3;
+const BUSY_RETRY_DELAY_MS = 100;
+
+function withBusyRetry<T>(fn: () => T): T {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= BUSY_RETRIES; attempt++) {
+    try {
+      return fn();
+    } catch (error) {
+      lastError = error;
+      if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
+      sleepSync(BUSY_RETRY_DELAY_MS);
+    }
+  }
+  throw lastError;
+}
+
+function openDbWithBusyRetry(storePath: string): { db: DatabaseSync; stmts: Prepared } {
+  return withBusyRetry(() => openDb(storePath));
+}
+
 let cachedDb: { path: string; db: DatabaseSync; stmts: Prepared } | null = null;
 let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
@@ -121,13 +170,12 @@ function buildStore(
   const stmts: Prepared = {
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     allPaths: (...params) => allStmt.all(...params) as Record<string, unknown>[],
-    deleteOne: (...params) => { delStmt.run(...params); },
-    upsert: (...params) => { upsertStmt.run(...params); },
-    undoUpsert: (...params) => { undoUpsertStmt.run(...params); },
+    deleteOne: (...params) => { withBusyRetry(() => { delStmt.run(...params); }); },
+    upsert: (...params) => { withBusyRetry(() => { upsertStmt.run(...params); }); },
+    undoUpsert: (...params) => { withBusyRetry(() => { undoUpsertStmt.run(...params); }); },
     undoGet: (...params) => undoGetStmt.get(...params) as Record<string, unknown> | undefined,
-    undoDelete: (...params) => { undoDelStmt.run(...params); },
+    undoDelete: (...params) => { withBusyRetry(() => { undoDelStmt.run(...params); }); },
   };
-
   return { db, stmts };
 }
 
@@ -135,8 +183,9 @@ function isHealthy(db: DatabaseSync): boolean {
   try {
     const row = db.prepare("PRAGMA quick_check").get() as { quick_check?: string } | undefined;
     return row?.quick_check === "ok";
-  } catch {
-    return false;
+  } catch (error) {
+    if (isCorruptionError(error)) return false;
+    return true;
   }
 }
 
@@ -170,18 +219,19 @@ async function openStore(storePath: string): Promise<HashStore> {
   let existed = existsSync(storePath);
   let opened: { db: DatabaseSync; stmts: Prepared };
   try {
-    opened = openDb(storePath);
+    opened = openDbWithBusyRetry(storePath);
   } catch (error) {
+    if (!isCorruptionError(error)) throw error;
     console.error("Hash store failed to open, rebuilding:", error);
     await quarantineStore(storePath);
     existed = false;
-    opened = openDb(storePath);
+    opened = openDbWithBusyRetry(storePath);
   }
   if (!isHealthy(opened.db)) {
     shutdownDb(opened.db);
     await quarantineStore(storePath);
     existed = false;
-    opened = openDb(storePath);
+    opened = openDbWithBusyRetry(storePath);
   }
   const { db, stmts } = opened;
 
@@ -228,14 +278,16 @@ export function shutdownHashStore(): void {
 
 function withStore(fn: () => void): void {
   if (cachedDb) {
-    cachedDb.db.exec("BEGIN IMMEDIATE");
-    try {
-      fn();
-      cachedDb.db.exec("COMMIT");
-    } catch (e) {
-      cachedDb.db.exec("ROLLBACK");
-      throw e;
-    }
+    withBusyRetry(() => {
+      cachedDb!.db.exec("BEGIN IMMEDIATE");
+      try {
+        fn();
+        cachedDb!.db.exec("COMMIT");
+      } catch (e) {
+        try { cachedDb!.db.exec("ROLLBACK"); } catch {}
+        throw e;
+      }
+    });
   } else {
     fn();
   }

package/src/hashline/hash.ts

@@ -43,10 +43,10 @@ function hashAt(idx: number): string {
 }
 
 export const HL_PREFIX_PLUS_RE = new RegExp(
-	`^\\+\\s*${HASH_CLASS}│`,
+	`^\\+${HASH_CLASS}│`,
 );
 export const HL_PREFIX_MINUS_RE = new RegExp(
-	`^-(?:\\s*${HASH_CLASS}│| {${ANCHOR_LEN}}│)`,
+	`^-(?:${HASH_CLASS}│| {${ANCHOR_LEN}}│)`,
 );
 
 export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CLASS})│`);
@@ -157,19 +157,32 @@ export async function lineHashes(
       previous.removedHashes,
     );
     if (persist !== false) {
-      upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+      try {
+        upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+      } catch (error) {
+        console.error("Failed to persist hash snapshot:", error);
+      }
     }
     return newHashes;
   }
 
-  const cached = getSnapshot(hashStore, path, content);
+  let cached: string[] | undefined;
+  try {
+    cached = getSnapshot(hashStore, path, content);
+  } catch (error) {
+    console.error("Failed to read hash store snapshot:", error);
+  }
   if (cached) {
     return cached;
   }
 
   const newHashes = _lineHashesPure(content);
   if (persist !== false) {
-    upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+    try {
+      upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+    } catch (error) {
+      console.error("Failed to persist hash snapshot:", error);
+    }
   }
   return newHashes;
 }

package/src/read.ts

@@ -21,11 +21,8 @@ const R_DESC = loadP("../prompts/read.md");
 
 const R_SNIPPET = loadP("../prompts/read-snippet.md");
 
-function readGuide(autoRead: boolean): string[] {
-	const note = "- `read`: call again after any edit to that file — changed lines get new anchors.";
-	return loadGuide("../prompts/read-guidelines.md", {
-		AUTO_READ_NOTE: autoRead ? "" : note,
-	});
+function readGuide(): string[] {
+	return loadGuide("../prompts/read-guidelines.md");
 }
 
 function normPosInt(
@@ -103,15 +100,15 @@ export async function fmtReadPreview(
 				: fmtRegion([selectedHashes[index]!], [selected[index]!]),
 		);
 		const skippedTruncation = truncateHead(rows.join("\n"), { maxBytes });
-		const shownRows = rowSizes.filter((row) => row.bytes <= maxBytes);
-		const lastShownLine = shownRows.at(-1)?.lineNumber ?? startLine - 1;
+		const shownRowCount = skippedTruncation.content === "" ? 0 : skippedTruncation.content.split("\n").length;
+		const lastShownLine = shownRowCount > 0 ? startLine + shownRowCount - 1 : startLine - 1;
 		const lineLabel = oversized.length === 1 ? `Line ${oversized[0]!.lineNumber}` : `Lines ${oversized.map((row) => row.lineNumber).join(", ")}`;
 		const verb = oversized.length === 1 ? "exceeds" : "exceed";
 		const addresses = oversized.map((row) => `${row.lineNumber}p`).join(";");
 		const warning = `[${lineLabel} ${verb} ${formatSize(maxBytes)}; content not shown because hashline anchors require full lines. Inspect with bash: sed -n '${addresses}' <path> | head -c ${maxBytes}]`;
 		let preview = skippedTruncation.content;
 		let nextOffset: number | undefined;
-		if (shownRows.length > 0 && (skippedTruncation.truncated || lastShownLine < totalLines)) {
+		if (shownRowCount > 0 && (skippedTruncation.truncated || lastShownLine < totalLines)) {
 			nextOffset = lastShownLine + 1;
 			preview += `\n\n${warning}\n${formatPaginationHint(startLine, lastShownLine, totalLines, nextOffset, skippedTruncation.truncated ? skippedTruncation.maxBytes : undefined)}`;
 		} else {
@@ -148,13 +145,13 @@ export async function fmtReadPreview(
 	};
 }
 
-export function regRead(pi: ExtensionAPI, opts?: { autoRead?: boolean }): void {
+export function regRead(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "read",
 		label: "Read",
 		description: R_DESC,
 		promptSnippet: R_SNIPPET,
-		promptGuidelines: readGuide(opts?.autoRead ?? true),
+		promptGuidelines: readGuide(),
 		parameters: Type.Object({
 			path: Type.String({
 				description: "Path to the file to read (relative or absolute)",
@@ -181,7 +178,7 @@ export function regRead(pi: ExtensionAPI, opts?: { autoRead?: boolean }): void {
 			await valAccess(absolutePath, rawPath);
 
 			abortIf(signal);
-			const file = await loadFileKindAndText(absolutePath);
+			const file = await loadFileKindAndText(absolutePath, { maxLines: MAX_HASH_LINES, displayPath: rawPath });
 			if (file.kind === "image") {
 				const builtinRead = createReadTool(ctx.cwd);
 				const executeBuiltinRead = builtinRead.execute as unknown as (

package/src/replace-response.ts

@@ -35,7 +35,7 @@ type NEditEntry = {
 export interface NoopInput {
 	path: string;
 	noopEdit: NEditEntry | undefined;
-	snapshotId: string;
+	snapshotId?: string;
 	editMeta: RMeta;
 	warnings: string[] | undefined;
 }
@@ -47,7 +47,7 @@ export interface SuccessInput {
   result: string;
   resultHashes: string[];
   warnings: string[] | undefined;
-  snapshotId: string;
+  snapshotId?: string;
   editMeta: RMeta;
 }
 
@@ -126,7 +126,7 @@ export function buildChanged(input: SuccessInput): TResult {
   const { path, result, warnings, snapshotId, originalNormalized, editMeta, resultHashes } = input;
 
   const resultLines = visLines(result);
-  const diffResult = genDiff(originalNormalized, result, 2, resultHashes);
+  const diffResult = genDiff(originalNormalized, result, 1, resultHashes);
   const addedLines = editMeta.addedLines;
   const removedLines = editMeta.removedLines;
   const warningsBlock = warnBlock(warnings);

package/src/replace-undo.ts

@@ -157,6 +157,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
         const linesAddedByReplace = cntDiff(diffResult.diff, "+");
         const linesRemovedByReplace = cntDiff(diffResult.diff, "-");
         const restoredRange = changedRange(currentNormalized, undo.content);
+        const undoDiff = genDiff(currentNormalized, undo.content, 1, undo.hashes).diff;
 
         await writeAtomic(
           mutationTargetPath,
@@ -192,6 +193,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
             },
           ],
           details: {
+            diff: undoDiff,
             metrics: buildMetrics({
               classification: "applied",
               editsAttempted: 1,

package/src/replace.ts

@@ -453,7 +453,12 @@ export function buildToolDef(): ToolDef {
 
         const editsAttempted = 1;
         if (originalNormalized === result) {
-          const noopSnapshotId = (await fileSnap(absolutePath)).snapshotId;
+          let noopSnapshotId: string | undefined;
+          try {
+            noopSnapshotId = (await fileSnap(absolutePath)).snapshotId;
+          } catch (error) {
+            console.error("Failed to compute snapshot for noop edit:", error);
+          }
           return buildNoop({
             path,
             noopEdit,
@@ -497,8 +502,12 @@ export function buildToolDef(): ToolDef {
           await undo.restore();
           throw error;
         }
-        const updatedSnapshotId = (await fileSnap(absolutePath))
-          .snapshotId;
+        let updatedSnapshotId: string | undefined;
+        try {
+          updatedSnapshotId = (await fileSnap(absolutePath)).snapshotId;
+        } catch (error) {
+          console.error("Failed to compute post-edit snapshot:", error);
+        }
 
         const editMeta: RMeta = {
           editsAttempted,

package/src/validation.ts

@@ -19,6 +19,9 @@ export async function valAccess(
 			const accessLabel = accessMode & constants.W_OK ? "not writable" : "not readable";
 			throw new Error(`[E_ACCESS] File is ${accessLabel}: ${path}`);
 		}
+		if (code === "ELOOP") {
+			throw new Error(`[E_ACCESS] Too many symbolic links while resolving: ${path}`);
+		}
 		throw new Error(`[E_ACCESS] Cannot access file: ${path}`);
 	}
 }