pi-hashline-edit-pro 1.0.4 → 1.0.6

package/README.md

@@ -62,10 +62,13 @@ Optional parameters:
 
 Paged output ends with a continuation hint, e.g. `[Showing lines 1-50 of 120. Use offset=51 to continue.]`.
 
+Lines up to 200KB are displayed in full; larger lines are replaced by a marker with a bash inspection hint (`sed -n 'Np' <path> | head -c 204800`) since hash anchors require full lines.
+
 Edge cases:
 
 - **Images** (JPEG, PNG, GIF, WebP) are passed through as visual attachments and don't participate in the hashline protocol.
 - **Binary and directory paths** are rejected with a descriptive error.
+- **UTF-16/UTF-32 encoded text** (detected via BOM) is rejected with `[E_NOT_TEXT]` — editing such a file would decode it as `U+FFFD` garbage and rewrite it as corrupted UTF-8.
 - **Empty files** are returned as a single empty-line hash (`HASH│`); use `replace` on that hash to insert content.
 - **BOMs** are stripped for display; **non-UTF-8 bytes** are shown as `U+FFFD` (editing such a file rewrites it as UTF-8, with a warning).
 - **Files over 238,328 lines** are rejected with `[E_FILE_TOO_LARGE]` (see [Hashing](#hashing)).
@@ -92,7 +95,7 @@ Exactly one edit per call, with `hash_range_inclusive` and `content_lines` at th
 Behavior:
 
 - **Validation before any file I/O.** Unknown fields, missing fields, wrong types, and malformed anchors are rejected with `[E_BAD_SHAPE]` / `[E_BAD_REF]`. The edit applies against the pre-edit snapshot, so all hashes in the request come from one consistent file state.
-- **Rejected dialects.** The `changes` array dialect and the legacy `oldText`/`newText` dialect are rejected with `[E_BAD_SHAPE]` / `[E_LEGACY_SHAPE]`; the error tells you to send `{hash_range_inclusive: ["<START>", "<END>"], content_lines: [...]}`.
+- **Rejected dialects.** The `changes` array dialect and the legacy `oldText`/`newText` dialect are rejected with `[E_LEGACY_SHAPE]`; the error tells you to send `{hash_range_inclusive: ["<START>", "<END>"], content_lines: [...]}`.
 - **Autocorrections** (all accompanied by a warning unless noted):
   - A `HASH│` prefix accidentally left on a `content_lines` entry is stripped.
   - Diff-preview rows (`+HASH│…`, `-HASH│…`, `-   │…`) pasted into `content_lines` have their markers stripped. Numbered deletion rows (`-1    foo`) and unified-diff lines are written literally — never silently altered.
@@ -119,14 +122,16 @@ Enabled by default. After a successful `write`, `replace`, or `undo_last_replace
 
 - 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.
 - 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.
 
 ## Undo
 
 `undo_last_replace` reverts the most recent successful `replace` on a file, restoring the exact previous content — BOM and line endings included — and the previous anchors.
 
 - History is per-file and single-level: only the most recent replace can be reverted.
-- History is in-memory and is lost when the session ends or the extension reloads.
+- 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.
 - A successful `write` clears the history for that file.
 - Call `read` after an undo 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.
@@ -155,12 +160,12 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created automatic
 | `[E_AMBIGUOUS_ANCHOR]` | An anchor matches multiple lines; call `read` for fresh anchors. |
 | `[E_INVALID_PATCH]` | A `content_lines` entry is a diff-preview row (`+HASH│`, `-HASH│`, `-   │`) — the marker is stripped automatically with a warning. |
 | `[E_BARE_HASH_PREFIX]` | A `content_lines` entry starts with a hash-like `HASH│` prefix — the prefix is stripped automatically with a warning. |
-| `[E_LEGACY_SHAPE]` | The request uses the unsupported `oldText`/`newText` dialect. |
+| `[E_LEGACY_SHAPE]` | The request uses an unsupported dialect: `oldText`/`newText` fields or a `changes` array. |
 | `[E_BAD_OP]` | Range start line is after range end line — the pair is swapped automatically with a warning. |
 | `[E_WOULD_EMPTY]` | An edit would empty a non-empty file; use `write` instead. |
 | `[E_NOT_FOUND]` | The path does not exist. |
 | `[E_ACCESS]` | The file is not readable or writable. |
-| `[E_NOT_TEXT]` | The path is a directory, binary file, or image; hashline editing only supports text files. |
+| `[E_NOT_TEXT]` | The path is a directory, binary file, image, or UTF-16/UTF-32 encoded text; hashline editing only supports text files. |
 | `[E_UNDO_STALE]` | `undo_last_replace` refused: the file was modified or deleted after the last replace. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 238,328-line hashline limit. |
 
@@ -176,7 +181,7 @@ The alphabet is sized for an LLM consumer: the model tokenizes rather than squin
 
 - **Stale anchors fail, per line.** A hash mismatch means that line's content changed since the last `read`. The error says so and, when only one anchor of a pair is stale, shows the current lines around the still-valid anchor so the range can be re-located without a full re-read. Mismatched anchors are never silently relocated to a "close enough" line — correctness over convenience.
 - **Autocorrection only when the intent is unambiguous**, and always visible: hash-prefix and diff-row stripping produce a warning; the boundary-duplication fix is silent because the duplicate never reaches the file. Literal content is never silently altered when the intent is ambiguous (numbered deletion rows and unified-diff lines are written verbatim).
-- **Byte-exact preservation.** UTF-8 BOMs, CRLF vs LF endings, file permissions, and trailing newlines survive edits and undo.
+- **Byte-exact preservation.** UTF-8 BOMs, CRLF, LF, and CR-only line endings, file permissions, and trailing newlines survive edits and undo.
 - **Atomic and ordered writes.** Files are written via temp-file-then-rename; symlink chains are resolved so the target is updated without replacing the symlink; hard-linked files are updated in place; concurrent edits to the same underlying file serialize through a per-target mutation queue.
 - **One edit per call.** The request shape stays `{path, hash_range_inclusive, content_lines}` from schema through validation to application; there is no batching dialect.
 

package/index.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
 import { initHasher } from "./src/hashline";
 import { regReplace } from "./src/replace";
 import { regReplaceUndo, clearUndo } from "./src/replace-undo";
@@ -59,7 +60,7 @@ export default function (pi: ExtensionAPI): void {
       const writtenPath = (event.input as Record<string, unknown>)?.path;
       if (typeof writtenPath === "string") {
         try {
-          clearUndo(await resolveTarget(toCwd(writtenPath, ctx.cwd)));
+          await clearUndo(await resolveTarget(toCwd(writtenPath, ctx.cwd)));
         } catch (error) {
           console.error("Failed to clear undo after write:", error);
         }
@@ -98,6 +99,7 @@ export default function (pi: ExtensionAPI): void {
         { offset, limit },
         fileHashes,
         absolutePath,
+        DEFAULT_MAX_BYTES,
       );
 
       return {
@@ -108,6 +110,13 @@ export default function (pi: ExtensionAPI): void {
       };
     } 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} ---` },
+        ],
+      };
     }
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "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",
@@ -47,7 +47,7 @@
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
+    "test:coverage": "vitest run --coverage --coverage.thresholds.lines=90 --coverage.thresholds.statements=90 --coverage.thresholds.functions=85 --coverage.thresholds.branches=80",
     "lint": "eslint \"src/**/*.ts\" \"index.ts\" \"test/**/*.ts\"",
     "typecheck": "tsc --noEmit"
   },

package/prompts/read.md

@@ -1 +1 @@
-Read a text file; each line returned as HASH│content with a 3-char alphanumeric hash. No line numbers — use the HASH as the anchor in replace calls. Images → visual attachments; Binary/directory → rejected; empty → HASH│ (replace to insert); pageable with offset/limit; BOM stripped; non-UTF-8 shown as U+FFFD.
+Read a text file; each line returned as HASH│content with a 3-char alphanumeric hash. No line numbers — use the HASH as the anchor in replace calls. Images → visual attachments; Binary/directory → rejected; UTF-16/UTF-32 (BOM) → rejected; empty → HASH│ (replace to insert); pageable with offset/limit; BOM stripped; non-UTF-8 shown as U+FFFD.

package/src/constants.ts

@@ -1,6 +1,7 @@
 export const AUTO_READ_MAX = 2000;
 export const SNIFF_BYTES = 8192;
 export const MAX_BYTES = 100 * 1024 * 1024;
+export const MAX_READ_LINE_BYTES = 200 * 1024;
 
 export const HASH_STORE_BUSY_TIMEOUT = 1000;
 export const HASH_STORE_VERSION = 4;

package/src/file-kind.ts

@@ -15,6 +15,26 @@ const TEXT_TYPES = new Set<string>([
   "application/x-ms-regedit",
 ]);
 
+function detectTextBom(sample: Uint8Array): string | undefined {
+  if (
+    sample.length >= 4 &&
+    sample[0] === 0xff &&
+    sample[1] === 0xfe &&
+    sample[2] === 0x00 &&
+    sample[3] === 0x00
+  ) return "UTF-32LE";
+  if (
+    sample.length >= 4 &&
+    sample[0] === 0x00 &&
+    sample[1] === 0x00 &&
+    sample[2] === 0xfe &&
+    sample[3] === 0xff
+  ) return "UTF-32BE";
+  if (sample.length >= 2 && sample[0] === 0xff && sample[1] === 0xfe) return "UTF-16LE";
+  if (sample.length >= 2 && sample[0] === 0xfe && sample[1] === 0xff) return "UTF-16BE";
+  return undefined;
+}
+
 function isTextType(mimeType: string): boolean {
   return mimeType.startsWith("text/") || TEXT_TYPES.has(mimeType);
 }
@@ -66,6 +86,13 @@ export async function loadFileKindAndText(
     }
 
     const sample = buffer.subarray(0, bytesRead);
+    const textBom = detectTextBom(sample);
+    if (textBom) {
+      return {
+        kind: "binary",
+        description: `${textBom} encoded text`
+      };
+    }
     const detectedMimeType = (await fileTypeFromBuffer(sample))?.mime;
     if (
       detectedMimeType !== undefined &&

package/src/file-reader.ts

@@ -4,7 +4,7 @@ import { lineHashes } from "./hashline";
 import { loadFileKindAndText, type LFile } from "./file-kind";
 import { resolveTarget } from "./fs-write";
 import { toCwd } from "./paths";
-import { detectEnding, toLF, stripBOM } from "./replace-diff";
+import { detectEnding, toLF, stripBOM, type LineEnding } from "./replace-diff";
 import { abortIf } from "./utils";
 import { valKind, valAccess } from "./validation";
 import { visLines } from "./utils";
@@ -13,7 +13,7 @@ export interface NormFile {
   absolutePath: string;
   normalized: string;
   bom: string;
-  originalEnding: "\r\n" | "\n";
+  originalEnding: LineEnding;
   fileHashes: string[];
   hadUtf8DecodeErrors: boolean;
 }

package/src/hash-store.ts

@@ -12,6 +12,9 @@ interface Prepared {
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
+  undoUpsert: (...params: SqlParams) => void;
+  undoGet: (...params: SqlParams) => Record<string, unknown> | undefined;
+  undoDelete: (...params: SqlParams) => void;
 }
 
 export interface HashStore {
@@ -19,6 +22,14 @@ export interface HashStore {
   readonly engine: "node:sqlite";
 }
 
+export interface UndoRecord {
+  content: string;
+  bom: string;
+  ending: string;
+  hashes: string[];
+  resultContent: string;
+}
+
 interface LegacySnapshot {
   content: string;
   hashes: string[];
@@ -72,27 +83,49 @@ function buildStore(
       "value TEXT NOT NULL" +
     ")"
   );
+  db.exec(
+    "CREATE TABLE IF NOT EXISTS undo (" +
+      "path TEXT PRIMARY KEY, " +
+      "content TEXT NOT NULL, " +
+      "bom TEXT NOT NULL, " +
+      "ending TEXT NOT NULL, " +
+      "hashes TEXT NOT NULL, " +
+      "result_content TEXT NOT NULL, " +
+      "updated_at INTEGER NOT NULL" +
+    ")"
+  );
   const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'version'").get() as { value?: string } | undefined;
   if (versionRow && versionRow.value !== String(HASH_STORE_VERSION)) {
     db.exec("DELETE FROM snapshots");
+    db.exec("DELETE FROM undo");
   }
   db.prepare(
     "INSERT INTO meta (key, value) VALUES ('version', ?) " +
     "ON CONFLICT(key) DO UPDATE SET value = excluded.value"
   ).run(String(HASH_STORE_VERSION));
   const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
-  const allStmt = db.prepare("SELECT path FROM snapshots");
+  const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
   const upsertStmt = db.prepare(
     "INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) " +
     "ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, updated_at = excluded.updated_at"
   );
-
+  const undoUpsertStmt = db.prepare(
+    "INSERT INTO undo (path, content, bom, ending, hashes, result_content, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?) " +
+    "ON CONFLICT(path) DO UPDATE SET content = excluded.content, bom = excluded.bom, ending = excluded.ending, hashes = excluded.hashes, result_content = excluded.result_content, updated_at = excluded.updated_at"
+  );
+  const undoGetStmt = db.prepare(
+    "SELECT content, bom, ending, hashes, result_content FROM undo WHERE path = ?"
+  );
+  const undoDelStmt = db.prepare("DELETE FROM undo WHERE path = ?");
   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); },
+    undoGet: (...params) => undoGetStmt.get(...params) as Record<string, unknown> | undefined,
+    undoDelete: (...params) => { undoDelStmt.run(...params); },
   };
 
   return { db, stmts };
@@ -295,6 +328,44 @@ export function deleteSnapshot(store: HashStore, path: string): void {
   store.stmts.deleteOne(path);
 }
 
+export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): void {
+  store.stmts.undoUpsert(
+    path,
+    entry.content,
+    entry.bom,
+    entry.ending,
+    JSON.stringify(entry.hashes),
+    entry.resultContent,
+    Date.now(),
+  );
+}
+
+export function getUndoEntry(store: HashStore, path: string): UndoRecord | undefined {
+  const row = store.stmts.undoGet(path);
+  if (!row) return undefined;
+  try {
+    const parsed = JSON.parse(row.hashes as string);
+    if (!Array.isArray(parsed) || !parsed.every((h) => typeof h === "string")) {
+      store.stmts.undoDelete(path);
+      return undefined;
+    }
+    return {
+      content: row.content as string,
+      bom: row.bom as string,
+      ending: row.ending as string,
+      hashes: parsed as string[],
+      resultContent: row.result_content as string,
+    };
+  } catch {
+    store.stmts.undoDelete(path);
+    return undefined;
+  }
+}
+
+export function deleteUndo(store: HashStore, path: string): void {
+  store.stmts.undoDelete(path);
+}
+
 export async function pruneMissing(store: HashStore): Promise<void> {
   const rows = store.stmts.allPaths() as { path: string }[];
   const missing: string[] = [];
@@ -307,6 +378,9 @@ export async function pruneMissing(store: HashStore): Promise<void> {
   }
   if (missing.length === 0) return;
   withStore(() => {
-    for (const path of missing) store.stmts.deleteOne(path);
+    for (const path of missing) {
+      store.stmts.deleteOne(path);
+      store.stmts.undoDelete(path);
+    }
   });
 }

package/src/hashline/hash.ts

@@ -143,6 +143,7 @@ export async function lineHashes(
   store?: HashStore,
   persist?: boolean,
 ): Promise<string[]> {
+  await initHasher();
   if (!path) {
     return _lineHashesPure(content);
   }

package/src/hashline/hasher.ts

@@ -9,7 +9,7 @@ let hasher: Hasher | null = null;
 
 export function getH(): Hasher {
 	if (hasher) return hasher;
-	throw new Error("xxhash-wasm not initialized yet. This should not happen.");
+	throw new Error("xxhash-wasm hasher not initialized; await initHasher() before calling hashline APIs.");
 }
 
 const hasherP: Promise<Hasher> = xxhash().then((h) => {

package/src/read.ts

@@ -6,6 +6,7 @@ import {
 	type TruncationResult,
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { MAX_READ_LINE_BYTES } from "./constants";
 import { loadFileKindAndText } from "./file-kind";
 import { readNormFile } from "./file-reader";
 import { lineHashes, fmtRegion, HASH_SEP, MAX_HASH_LINES } from "./hashline";
@@ -58,6 +59,7 @@ export async function fmtReadPreview(
 	options: { offset?: number; limit?: number },
 	precomputedHashes?: string[],
 	path?: string,
+	maxLineBytes = MAX_READ_LINE_BYTES,
 ): Promise<{ text: string; truncation?: TruncationResult; nextOffset?: number }> {
 	const allLines = visLines(text);
 	const totalLines = allLines.length;
@@ -88,15 +90,42 @@ export async function fmtReadPreview(
 	const allHashes = precomputedHashes ?? await (path ? lineHashes(text, path) : lineHashes(text));
 	const selectedHashes = allHashes.slice(startLine - 1, endIdx);
 	const formatted = fmtRegion(selectedHashes, selected);
-
-	const truncation = truncateHead(formatted);
-	if (truncation.firstLineExceedsLimit) {
+	const maxBytes = maxLineBytes;
+	const rowSizes = selected.map((line, index) => ({
+		lineNumber: startLine + index,
+		bytes: Buffer.byteLength(`${selectedHashes[index]}${HASH_SEP}${line}`, "utf-8"),
+	}));
+	if (rowSizes.some((row) => row.bytes > maxBytes)) {
+		const oversized = rowSizes.filter((row) => row.bytes > maxBytes);
+		const rows = rowSizes.map((row, index) =>
+			row.bytes > maxBytes
+				? `[Line ${row.lineNumber} is ${formatSize(row.bytes)}, exceeds ${formatSize(maxBytes)}; content not shown. Use bash: sed -n '${row.lineNumber}p' <path> | head -c ${maxBytes}]`
+				: 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 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)) {
+			nextOffset = lastShownLine + 1;
+			preview += `\n\n${warning}\n${formatPaginationHint(startLine, lastShownLine, totalLines, nextOffset, skippedTruncation.truncated ? skippedTruncation.maxBytes : undefined)}`;
+		} else {
+			preview += `\n\n${warning}`;
+		}
 		return {
-			text: `[Line ${startLine} exceeds ${formatSize(truncation.maxBytes)}. Hashline output requires full lines; cannot compute hashes for a truncated preview.]`,
-			truncation,
+			text: preview,
+			truncation: skippedTruncation.truncated ? skippedTruncation : undefined,
+			...(nextOffset !== undefined ? { nextOffset } : {}),
 		};
 	}
 
+	const truncation = truncateHead(formatted, { maxBytes });
+
 	let preview = truncation.content;
 	let nextOffset: number | undefined;
 	if (truncation.truncated) {

package/src/replace-diff.ts

@@ -5,10 +5,15 @@ import {
   HASH_SEP,
 } from "./hashline";
 
-export function detectEnding(content: string): "\r\n" | "\n" {
-  const crlfIdx = content.indexOf("\r\n");
+export type LineEnding = "\r\n" | "\n" | "\r";
+
+export function detectEnding(content: string): LineEnding {
   const lfIdx = content.indexOf("\n");
-  if (lfIdx === -1 || crlfIdx === -1) return "\n";
+  if (lfIdx === -1) {
+    return content.indexOf("\r") >= 0 ? "\r" : "\n";
+  }
+  const crlfIdx = content.indexOf("\r\n");
+  if (crlfIdx === -1) return "\n";
   return crlfIdx < lfIdx ? "\r\n" : "\n";
 }
 
@@ -18,9 +23,11 @@ export function toLF(text: string): string {
 
 export function restoreEndings(
   text: string,
-  ending: "\r\n" | "\n",
+  ending: LineEnding,
 ): string {
-  return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+  if (ending === "\r\n") return text.replace(/\n/g, "\r\n");
+  if (ending === "\r") return text.replace(/\n/g, "\r");
+  return text;
 }
 
 export function stripBOM(content: string): { bom: string; text: string } {

package/src/replace-undo.ts

@@ -2,11 +2,11 @@ import { readFile } from "fs/promises";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { loadHashStore, upsertSnapshot } from "./hash-store";
+import { loadHashStore, upsertSnapshot, upsertUndo, getUndoEntry, deleteUndo } from "./hash-store";
 import { contentChecksum } from "./hashline/hasher";
 import { resolveTarget, writeAtomic } from "./fs-write";
 import { toCwd } from "./paths";
-import { toLF, stripBOM, genDiff, restoreEndings } from "./replace-diff";
+import { toLF, stripBOM, genDiff, restoreEndings, type LineEnding } from "./replace-diff";
 import { cntDiff, splitLines, errCode } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
@@ -14,26 +14,60 @@ import { changedRange } from "./hashline";
 export interface UndoEntry {
   content: string;
   bom: string;
-  originalEnding: "\r\n" | "\n";
+  originalEnding: LineEnding;
   hashes: string[];
   resultContent: string;
 }
 
-const undoMap = new Map<string, UndoEntry>();
-
-export function saveUndo(path: string, entry: UndoEntry): void {
-  undoMap.set(path, entry);
+export async function saveUndo(path: string, entry: UndoEntry): Promise<boolean> {
+  try {
+    const store = await loadHashStore();
+    upsertUndo(store, path, {
+      content: entry.content,
+      bom: entry.bom,
+      ending: entry.originalEnding,
+      hashes: entry.hashes,
+      resultContent: entry.resultContent,
+    });
+    return true;
+  } catch (error) {
+    console.error("Failed to persist undo entry:", error);
+    return false;
+  }
 }
 
-export function getUndo(path: string): UndoEntry | undefined {
-  return undoMap.get(path);
+export async function getUndo(path: string): Promise<UndoEntry | undefined> {
+  try {
+    const store = await loadHashStore();
+    const record = getUndoEntry(store, path);
+    if (!record) return undefined;
+    const originalEnding = record.ending;
+    if (originalEnding !== "\r\n" && originalEnding !== "\n" && originalEnding !== "\r") {
+      await deleteUndo(store, path);
+      return undefined;
+    }
+    return {
+      content: record.content,
+      bom: record.bom,
+      originalEnding,
+      hashes: record.hashes,
+      resultContent: record.resultContent,
+    };
+  } catch (error) {
+    console.error("Failed to load undo entry:", error);
+    return undefined;
+  }
 }
 
-export function clearUndo(path: string): void {
-  undoMap.delete(path);
+export async function clearUndo(path: string): Promise<void> {
+  try {
+    const store = await loadHashStore();
+    deleteUndo(store, path);
+  } catch (error) {
+    console.error("Failed to clear undo entry:", error);
+  }
 }
 
-
 export function regReplaceUndo(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "undo_last_replace",
@@ -52,7 +86,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
       const absolutePath = toCwd(path, ctx.cwd);
       const mutationTargetPath = await resolveTarget(absolutePath);
 
-      const undo = getUndo(mutationTargetPath);
+      const undo = await getUndo(mutationTargetPath);
       if (!undo) {
         return {
           content: [
@@ -67,16 +101,14 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
       }
 
       return withFileMutationQueue(mutationTargetPath, async () => {
-        let currentNormalized: string | undefined;
+        let currentRaw: string | undefined;
         try {
-          const currentRaw = await readFile(mutationTargetPath, "utf-8");
-          const { text: currentStripped } = stripBOM(currentRaw);
-          currentNormalized = toLF(currentStripped);
+          currentRaw = await readFile(mutationTargetPath, "utf-8");
         } catch (error) {
           if (errCode(error) !== "ENOENT") throw error;
         }
 
-        if (currentNormalized === undefined) {
+        if (currentRaw === undefined) {
           return {
             content: [
               {
@@ -88,7 +120,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
             details: {},
           };
         }
-        if (currentNormalized !== undo.resultContent) {
+        if (currentRaw !== undo.bom + restoreEndings(undo.resultContent, undo.originalEnding)) {
           return {
             content: [
               {
@@ -101,6 +133,8 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
           };
         }
 
+        const { text: currentStripped } = stripBOM(currentRaw);
+        const currentNormalized = toLF(currentStripped);
         const diffResult = genDiff(undo.content, currentNormalized, 0);
         const linesAddedByReplace = cntDiff(diffResult.diff, "+");
         const linesRemovedByReplace = cntDiff(diffResult.diff, "-");
@@ -118,7 +152,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
           console.error("Failed to restore hash store snapshot after undo:", error);
         }
 
-        clearUndo(mutationTargetPath);
+        await clearUndo(mutationTargetPath);
 
         const parts: string[] = [
           `Undone last replace on ${path}.`,

package/src/replace.ts

@@ -9,6 +9,7 @@ import { constants } from "fs";
 import {
   genDiff,
   restoreEndings,
+  type LineEnding,
 } from "./replace-diff";
 import { readNormFile } from "./file-reader";
 import { normReq, normalizeFilePath, tryParseContentLines } from "./replace-normalize";
@@ -86,7 +87,7 @@ interface PipelineResult {
   originalNormalized: string;
   result: string;
   bom: string;
-  originalEnding: "\r\n" | "\n";
+  originalEnding: LineEnding;
   hadUtf8DecodeErrors: boolean;
   warnings: string[];
   noopEdit?: NEdit;
@@ -100,7 +101,7 @@ interface PipelineResult {
 
 const ROOT_KS = new Set(["path", "content_lines", "hash_range_inclusive"]);
 
-const LEGACY_KS = ["oldText", "newText", "old_text", "new_text", "old_range", "start", "end", "lines"];
+const LEGACY_KS = ["oldText", "newText", "old_text", "new_text", "old_range", "start", "end", "lines", "changes"];
 
 export function assertNoLegacyKeys(request: unknown): void {
   if (!isRec(request)) return;
@@ -250,11 +251,6 @@ export async function compPreview(
 ): Promise<RPreview> {
   try {
     const normalized = normReq(request);
-    if (isRec(request) && Array.isArray(request.changes)) {
-      return {
-        error: `[E_BAD_SHAPE] The replace tool does not accept a "changes" array. Send hash_range_inclusive and content_lines at the top level (one edit per call).`
-      };
-    }
     assertReq(normalized);
     const { path, originalNormalized, result, resultHashes } = await execPipeline(
       normalized,
@@ -409,8 +405,9 @@ export function buildToolDef(): ToolDef {
 
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
+      assertReq(canonical);
 
-      const normalizedParams = canonical as ReqParams;
+      const normalizedParams = canonical;
       const path = normalizedParams.path;
       const absolutePath = toCwd(path, ctx.cwd);
       const mutationTargetPath = await resolveTarget(absolutePath);
@@ -465,13 +462,18 @@ export function buildToolDef(): ToolDef {
           absolutePath,
           bom + restoreEndings(result, originalEnding),
         );
-        saveUndo(mutationTargetPath, {
+        const undoPersisted = await saveUndo(mutationTargetPath, {
           content: originalNormalized,
           bom,
           originalEnding,
           hashes: originalHashes,
           resultContent: result,
         });
+        if (!undoPersisted) {
+          warnings.push(
+            "Undo history could not be persisted; undo_last_replace will not be available for this edit.",
+          );
+        }
         const updatedSnapshotId = (await fileSnap(absolutePath))
           .snapshotId;