pi-hashline-edit-pro 2.7.0 → 2.7.1

package/README.md

@@ -161,7 +161,9 @@ Notes:
 - History is persisted and survives session restarts. A failed `write` does not clear it.
 - Every applied replace or insert is undoable: the undo record is saved before the edit is written.
 - A successful `write` clears the history for that file.
-- If the file was modified or deleted since the last replace or insert, the undo is refused rather than overwriting those changes.
+- If the file was modified since the last replace or insert, the undo is refused rather than overwriting those changes. The undo record is kept: once the file matches the edited state again (for example you revert the external change), `undo_last_change` succeeds.
+- If the file was deleted since the last replace or insert, `undo_last_change` restores it from the recorded pre-edit content. Nothing is overwritten, since the file no longer exists.
+- Missing-file cleanup never touches the undo record: the per-session prune of the hash store removes the snapshots and served records of files that no longer exist (both are recomputed on the next read), but the undo history survives — even when the file is temporarily absent, for example during a branch switch.
 
 ## Auto-read
 
@@ -228,7 +230,7 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 | `[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, image, or UTF-16/UTF-32 encoded text; hashline editing only supports text files. |
-| `[E_UNDO_STALE]` | `undo_last_change` refused: the file was modified or deleted after the last edit. |
+| `[E_UNDO_STALE]` | `undo_last_change` refused: the file was modified after the last edit. The undo record is kept until the file matches the edited state again or a new edit replaces it. |
 | `[E_UNDO_UNAVAILABLE]` | Undo history could not be persisted to the hash store; the edit was refused and the file was left unchanged. |
 | `[E_RANGE_STALE]` | A line in the replaced range no longer matches what was last shown (the file changed on disk, or the line was never shown). The edit was refused; the current range is returned with fresh anchors. |
 | `[E_BOUNDARY_BYPASS]` | The boundary anti-duplication was turned off for one replace call (an identical replacement had previously been cut to a noop); the duplicate lines were applied literally. The dedup is restored for the next call. |

package/index.ts

@@ -65,13 +65,14 @@ export default function (pi: ExtensionAPI): void {
 
     if (event.toolName === "write") {
       const writtenPath = (event.input as Record<string, unknown>)?.path;
+      let resolvedPath: string | undefined;
       if (typeof writtenPath === "string") {
         try {
-          const target = await resolveTarget(toCwd(writtenPath, ctx.cwd));
-          await clearUndo(target);
-          clearBoundaryBypass(target);
+          resolvedPath = await resolveTarget(toCwd(writtenPath, ctx.cwd));
+          await clearUndo(resolvedPath);
+          clearBoundaryBypass(resolvedPath);
           const store = await loadHashStore();
-          clearServed(store, target);
+          clearServed(store, resolvedPath);
         } catch (error) {
           console.error("Failed to clear undo after write:", error);
         }
@@ -79,7 +80,7 @@ export default function (pi: ExtensionAPI): void {
       if (!autoRead) return;
       if (typeof writtenPath !== "string") return;
       try {
-        const resolvedPath = await resolveTarget(toCwd(writtenPath, ctx.cwd));
+        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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 3-char hash (A-Za-z0-9) that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/prompts/undo-last-change-guidelines.md

@@ -1,2 +1,3 @@
 - `undo_last_change`: reverts only the most recent replace or insert on the file: any write to the file clears the undo history, so call it immediately after a bad edit. An edit is bad when its post-edit diff shows `-HASH│` rows for lines you meant to keep (a closing brace, import, or declaration).
 - `undo_last_change`: when auto-read shows the post-edit diff, its `+HASH│` and ` HASH│` rows are the fresh anchors for the restored file, so follow-up edits can anchor on the diff without re-reading.
+- `undo_last_change`: if the file was deleted since the edit, the undo restores it from the recorded pre-edit content; if the file was modified since the edit, the undo is refused with `[E_UNDO_STALE]` and the record is kept, so reverting the external change makes the undo succeed.

package/prompts/undo-last-change.md

@@ -1 +1 @@
-Undo the last change (replace or insert) on a file, reverting it to its previous state. Use when an edit produced incorrect results (e.g., wrong content, duplicated lines, broken syntax).
+Undo the last change (replace or insert) on a file, reverting it to its previous state. Use when an edit produced incorrect results (e.g., wrong content, duplicated lines, broken syntax). If the file was deleted since the edit, the undo restores it from the recorded content. If the file was modified since the edit, the undo is refused and the record is kept until the file matches the edited state again.

package/src/boundary-bypass.ts

@@ -1,6 +1,6 @@
 import { parseText } from "./hashline/parse";
 import { ANCHOR_ROW_RE } from "./hashline/resolve";
-import { HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE } from "./hashline/hash";
+import { stripRowPrefix } from "./hashline/hash";
 
 function canonRef(ref: string): string {
   const trimmed = ref.trim();
@@ -9,15 +9,7 @@ function canonRef(ref: string): string {
 }
 
 function canonLines(lines: string[]): string[] {
-  return parseText(lines).map((line) => {
-    const bare = line.match(HL_BARE_PREFIX_RE);
-    if (bare) return line.slice(bare[0].length);
-    const plus = line.match(HL_PREFIX_PLUS_RE);
-    if (plus) return line.slice(plus[0].length);
-    const minus = line.match(HL_PREFIX_MINUS_RE);
-    if (minus) return line.slice(minus[0].length);
-    return line;
-  });
+  return parseText(lines).map((line) => stripRowPrefix(line).text);
 }
 
 const boundaryBypassTracker = new Map<string, string>();

package/src/grep.ts

@@ -4,7 +4,7 @@ import { readdir, stat } from "fs/promises";
 import { dirname, join, relative } from "path";
 import { loadFileKindAndText } from "./file-kind";
 import { readNormFile } from "./file-reader";
-import { MAX_HASH_LINES, HASH_SEP } from "./hashline";
+import { MAX_HASH_LINES, fmtRow } from "./hashline";
 import { toCwd } from "./paths";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./replace-normalize";
@@ -155,7 +155,7 @@ async function searchFile(
   if (file.kind !== "text") return undefined;
   let norm;
   try {
-    norm = await readNormFile(absPath, cwd, { maxLines: MAX_HASH_LINES, preloadedFile: file });
+    norm = await readNormFile(absPath, cwd, { maxLines: MAX_HASH_LINES, preloadedFile: file, noPersist: true });
   } catch (error) {
     if (isSkipableLoadError(error)) return undefined;
     throw error;
@@ -175,7 +175,7 @@ async function searchFile(
   const rows: string[] = [];
   const hashes: string[] = [];
   for (const idx of sorted) {
-    rows.push(`${norm.fileHashes[idx]}${HASH_SEP}${lines[idx]}`);
+    rows.push(fmtRow(norm.fileHashes[idx]!, lines[idx]!));
     hashes.push(norm.fileHashes[idx]!);
   }
   return {

package/src/hash-store.ts

@@ -66,6 +66,7 @@ interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
   allHashes: (...params: SqlParams) => Record<string, unknown>[];
+  allServed: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
   undoUpsert: (...params: SqlParams) => void;
@@ -118,6 +119,14 @@ export function parseHashList(raw: string, onInvalid: () => void): string[] | un
   return parsed;
 }
 
+export function parseStoredHashes(
+  row: Record<string, unknown> | undefined,
+  onInvalid: () => void,
+): string[] | undefined {
+  if (!row) return undefined;
+  return parseHashList(row.hashes as string, onInvalid);
+}
+
 function isValidSnapshot(value: unknown): value is LegacySnapshot {
   if (typeof value !== "object" || value === null) return false;
   const v = value as Record<string, unknown>;
@@ -174,6 +183,14 @@ function openDbWithBusyRetry(storePath: string): { db: RawDb; stmts: Prepared }
   return withBusyRetry(() => openDb(storePath));
 }
 
+function retriedWrite(
+  stmt: { run(...params: SqlParams): unknown },
+): (...params: SqlParams) => void {
+  return (...params) => {
+    withBusyRetry(() => { stmt.run(...params); });
+  };
+}
+
 let cachedDb: { path: string; db: RawDb; stmts: Prepared } | null = null;
 let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
@@ -238,6 +255,7 @@ function buildStore(
   if (versionRow && versionRow.value !== String(HASH_STORE_VERSION)) {
     db.exec("DELETE FROM snapshots");
     db.exec("DELETE FROM undo");
+    db.exec("DELETE FROM served");
   }
   db.prepare(
     "INSERT INTO meta (key, value) VALUES ('version', ?) " +
@@ -246,6 +264,7 @@ function buildStore(
   const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
   const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo UNION SELECT path FROM served");
   const allHashesStmt = db.prepare("SELECT path, hashes FROM snapshots");
+  const allServedStmt = db.prepare("SELECT path, hashes FROM served");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
   const upsertStmt = db.prepare(
     "INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) " +
@@ -269,14 +288,15 @@ function buildStore(
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     allPaths: (...params) => allStmt.all(...params) as Record<string, unknown>[],
     allHashes: (...params) => allHashesStmt.all(...params) as Record<string, unknown>[],
-    deleteOne: (...params) => { withBusyRetry(() => { delStmt.run(...params); }); },
-    upsert: (...params) => { withBusyRetry(() => { upsertStmt.run(...params); }); },
-    undoUpsert: (...params) => { withBusyRetry(() => { undoUpsertStmt.run(...params); }); },
+    allServed: (...params) => allServedStmt.all(...params) as Record<string, unknown>[],
+    deleteOne: retriedWrite(delStmt),
+    upsert: retriedWrite(upsertStmt),
+    undoUpsert: retriedWrite(undoUpsertStmt),
     undoGet: (...params) => undoGetStmt.get(...params) as Record<string, unknown> | undefined,
-    undoDelete: (...params) => { withBusyRetry(() => { undoDelStmt.run(...params); }); },
+    undoDelete: retriedWrite(undoDelStmt),
     servedGet: (...params) => servedGetStmt.get(...params) as Record<string, unknown> | undefined,
-    servedUpsert: (...params) => { withBusyRetry(() => { servedUpsertStmt.run(...params); }); },
-    servedDelete: (...params) => { withBusyRetry(() => { servedDelStmt.run(...params); }); },
+    servedUpsert: retriedWrite(servedUpsertStmt),
+    servedDelete: retriedWrite(servedDelStmt),
   };
   return { db, stmts };
 }
@@ -489,8 +509,7 @@ export function getSnapshot(
     return cached.hashes.slice();
   }
   const row = store.stmts.get(path, checksum, lineCount);
-  if (!row) return undefined;
-  const parsed = parseHashList(row.hashes as string, () => {
+  const parsed = parseStoredHashes(row, () => {
     if (deleteCorrupt) store.stmts.deleteOne(path);
     snapshotCache.delete(path);
   });
@@ -525,7 +544,7 @@ export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): v
 export function getUndoEntry(store: HashStore, path: string): UndoRecord | undefined {
   const row = store.stmts.undoGet(path);
   if (!row) return undefined;
-  const parsed = parseHashList(row.hashes as string, () => store.stmts.undoDelete(path));
+  const parsed = parseStoredHashes(row, () => store.stmts.undoDelete(path));
   if (!parsed) return undefined;
   return {
     content: row.content as string,
@@ -571,14 +590,15 @@ export async function pruneMissing(store: HashStore): Promise<void> {
     for (const path of missing) {
       store.stmts.deleteOne(path);
       snapshotCache.delete(path);
-      store.stmts.undoDelete(path);
       store.stmts.servedDelete(path);
     }
   });
 }
 
-export function findSnapshotPaths(store: HashStore, hashes: string[]): string[] {
-  const rows = store.stmts.allHashes() as { path: string; hashes: string }[];
+function matchPathsByHashes(
+  rows: { path: string; hashes: string }[],
+  hashes: string[],
+): string[] {
   const matches: string[] = [];
   for (const row of rows) {
     try {
@@ -591,3 +611,11 @@ export function findSnapshotPaths(store: HashStore, hashes: string[]): string[]
   }
   return matches;
 }
+
+export function findSnapshotPaths(store: HashStore, hashes: string[]): string[] {
+  return matchPathsByHashes(store.stmts.allHashes() as { path: string; hashes: string }[], hashes);
+}
+
+export function findServedPaths(store: HashStore, hashes: string[]): string[] {
+  return matchPathsByHashes(store.stmts.allServed() as { path: string; hashes: string }[], hashes);
+}

package/src/hashline/apply.ts

@@ -1,5 +1,5 @@
 import { abortIf, splitLines } from "../utils";
-import { _lineHashesPure, HASH_SEP } from "./hash";
+import { _lineHashesPure } from "./hash";
 import {
 	valEdit,
 	stripBarePrefixes,
@@ -268,20 +268,7 @@ export function applyEdit(
 	};
 }
 
-export function fmtRegion(
-	hashes: string[],
-	lines: string[],
-): string {
-	if (hashes.length !== lines.length) {
-		throw new Error(
-			`fmtRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`,
-		);
-	}
-	return lines
-		.map((line, index) => `${hashes[index]}${HASH_SEP}${line}`)
-		.join("\n");
-}
-
+export { fmtRegion, fmtRow } from "./resolve";
 export function changedRange(
 	original: string,
 	result: string,

package/src/hashline/hash.ts

@@ -47,6 +47,30 @@ export const HL_PREFIX_MINUS_RE = new RegExp(
 
 export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_RUN})│`);
 
+export type RowPrefixKind = "bare" | "plus" | "minus";
+
+export type StrippedRow = {
+	text: string;
+	kind: RowPrefixKind | null;
+	hash: string | undefined;
+};
+
+export function stripRowPrefix(line: string): StrippedRow {
+	const bare = line.match(HL_BARE_PREFIX_RE);
+	if (bare) {
+		return { text: line.slice(bare[0].length), kind: "bare", hash: bare[1] };
+	}
+	const plus = line.match(HL_PREFIX_PLUS_RE);
+	if (plus) {
+		return { text: line.slice(plus[0].length), kind: "plus", hash: plus[1] };
+	}
+	const minus = line.match(HL_PREFIX_MINUS_RE);
+	if (minus) {
+		return { text: line.slice(minus[0].length), kind: "minus", hash: minus[1] };
+	}
+	return { text: line, kind: null, hash: undefined };
+}
+
 export function canon(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();
 }

package/src/hashline/index.ts

@@ -43,5 +43,6 @@ export {
 	buildIdx,
 	applyEdit,
 	fmtRegion,
+	fmtRow,
 	changedRange,
 } from "./apply";

package/src/hashline/resolve.ts

@@ -1,12 +1,11 @@
 import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine } from "../utils";
-import { HASH_SEP, HASH_RUN, HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE, canon } from "./hash";
+import { HASH_SEP, HASH_RUN, stripRowPrefix, canon } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
 
 export type RAnchor = {
 	line: number;
 	hash: string;
-	hashMatched: boolean;
 };
 
 export type HEdit = { content_lines: string[]; hash_bounds: [Anchor, Anchor] };
@@ -56,7 +55,6 @@ function resAnchorFromMap(
 		return {
 			line: hashMatches[0]!,
 			hash: ref.hash,
-			hashMatched: true,
 		};
 	}
 	return { ref, kind: "ambiguous", candidates: hashMatches };
@@ -74,6 +72,19 @@ function assertAligned(
 	}
 }
 
+export function fmtRow(hash: string, line: string): string {
+	return `${hash}${HASH_SEP}${line}`;
+}
+
+export function fmtRegion(hashes: string[], lines: string[]): string {
+	if (hashes.length !== lines.length) {
+		throw new Error(
+			`fmtRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`,
+		);
+	}
+	return lines.map((line, index) => fmtRow(hashes[index]!, line)).join("\n");
+}
+
 export function fmtMismatchWithHashes(
   mismatches: HMismatch[],
   fileLines: string[],
@@ -213,10 +224,10 @@ export function stripBarePrefixes(
 	const fileHashSet = new Set(fileHashes);
 	const stripped: { lineIndex: number; matched: boolean }[] = [];
 	const contentLines = edit.content_lines.map((line, lineIndex) => {
-		const match = line.match(HL_BARE_PREFIX_RE);
-		if (!match) return line;
-		stripped.push({ lineIndex, matched: fileHashSet.has(match[1]!) });
-		return line.slice(match[0].length);
+		const result = stripRowPrefix(line);
+		if (result.kind !== "bare") return line;
+		stripped.push({ lineIndex, matched: fileHashSet.has(result.hash ?? "") });
+		return result.text;
 	});
 	if (stripped.length === 0) return edit;
 	const locations = stripped
@@ -239,17 +250,10 @@ export function stripDiffPrefixes(
 ): HEdit {
 	const stripped: number[] = [];
 	const contentLines = edit.content_lines.map((line, lineIndex) => {
-		const plus = line.match(HL_PREFIX_PLUS_RE);
-		if (plus) {
-			stripped.push(lineIndex);
-			return line.slice(plus[0].length);
-		}
-		const minus = line.match(HL_PREFIX_MINUS_RE);
-		if (minus) {
-			stripped.push(lineIndex);
-			return line.slice(minus[0].length);
-		}
-		return line;
+		const result = stripRowPrefix(line);
+		if (result.kind !== "plus" && result.kind !== "minus") return line;
+		stripped.push(lineIndex);
+		return result.text;
 	});
 	if (stripped.length === 0) return edit;
 	const locations = stripped.map((i) => `replacement_lines line ${i + 1}`).join(", ");
@@ -502,12 +506,10 @@ export function resolveAnchorLine(
 }
 
 export class RangeStaleError extends Error {
-  readonly firstMismatchLine: number;
   readonly rangeHashes: string[];
-  constructor(message: string, firstMismatchLine: number, rangeHashes: string[]) {
+  constructor(message: string, rangeHashes: string[]) {
     super(message);
     this.name = "RangeStaleError";
-    this.firstMismatchLine = firstMismatchLine;
     this.rangeHashes = rangeHashes;
   }
 }
@@ -544,7 +546,7 @@ export function assertRangeServed(
   for (let line = startLine; line < startLine + shownLength; line++) {
     const hash = fileHashes[line - 1]!;
     shownHashes.push(hash);
-    rows.push(`${hash}${HASH_SEP}${fileLines[line - 1]}`);
+    rows.push(fmtRow(hash, fileLines[line - 1]));
   }
   const location = filePath ? ` in ${filePath}` : "";
   const first = mismatchLines[0]!;
@@ -558,7 +560,7 @@ export function assertRangeServed(
       : "";
   const message =
     `[E_RANGE_STALE] ${mismatchText} what was shown. Nothing was modified. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
-  throw new RangeStaleError(message, first, shownHashes);
+  throw new RangeStaleError(message, shownHashes);
 }
 
 export { warnUnicodeEsc };

package/src/replace-response.ts

@@ -1,3 +1,4 @@
+import type { NEdit } from "./hashline";
 import type { ReplaceDetails } from "./replace";
 import { genDiff, genPatch } from "./replace-diff";
 import { visLines, clipLine } from "./utils";
@@ -27,14 +28,9 @@ export type RMeta = {
   removedLines: number;
 };
 
-type NEditEntry = {
-	loc: string;
-	currentContent: string;
-};
-
 export interface NoopInput {
 	path: string;
-	noopEdit: NEditEntry | undefined;
+	noopEdit: NEdit | undefined;
 	snapshotId?: string;
 	editMeta: RMeta;
 	warnings: string[] | undefined;

package/src/replace-undo.ts

@@ -126,26 +126,15 @@ export function regUndo(pi: ExtensionAPI): void {
           if (errCode(error) !== "ENOENT") throw error;
         }
 
-        if (currentRaw === undefined) {
-          await clearUndo(mutationTargetPath);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file no longer exists.`
-              },
-            ],
-            isError: true,
-            details: {},
-          };
-        }
-        if (currentRaw !== undo.bom + restoreEndings(undo.resultContent, undo.originalEnding)) {
-          await clearUndo(mutationTargetPath);
+        if (
+          currentRaw !== undefined &&
+          currentRaw !== undo.bom + restoreEndings(undo.resultContent, undo.originalEnding)
+        ) {
           return {
             content: [
               {
                 type: "text",
-                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file changed after the edit. Call read() to inspect the current state.`
+                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file changed after the edit. The undo record is kept; once the file matches the edited state again, undo_last_change will succeed. Call read() to inspect the current state.`
               },
             ],
             isError: true,
@@ -153,20 +142,19 @@ export function regUndo(pi: ExtensionAPI): void {
           };
         }
 
-        const { text: currentStripped } = stripBOM(currentRaw);
-        const currentNormalized = toLF(currentStripped);
+        await writeAtomic(
+          mutationTargetPath,
+          undo.bom + restoreEndings(undo.content, undo.originalEnding),
+        );
+
+        const currentNormalized = currentRaw === undefined ? "" : toLF(stripBOM(currentRaw).text);
         const currentHashes = await lineHashes(currentNormalized, mutationTargetPath);
-        const diffResult = genDiff(undo.content, currentNormalized, 0, undefined, undo.hashes);
+        const diffResult = genDiff(undo.content, undo.resultContent, 0, undefined, undo.hashes);
         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, currentHashes).diff;
 
-        await writeAtomic(
-          mutationTargetPath,
-          undo.bom + restoreEndings(undo.content, undo.originalEnding),
-        );
-
         try {
           const store = await loadHashStore();
           upsertSnapshot(store, mutationTargetPath, contentChecksum(undo.content), splitLines(undo.content).length, undo.hashes);
@@ -180,6 +168,9 @@ export function regUndo(pi: ExtensionAPI): void {
         const parts: string[] = [
           `Undone last change on ${path}.`,
         ];
+        if (currentRaw === undefined) {
+          parts.push("The file was deleted; restored it from undo history.");
+        }
         if (linesAddedByReplace > 0 || linesRemovedByReplace > 0) {
           parts.push(
             `Removed ${linesAddedByReplace} line(s), restored ${linesRemovedByReplace} line(s).`,

package/src/replace.ts

@@ -31,9 +31,8 @@ import {
   type RPreview,
   type RRState,
 } from "./replace-render";
-export { reuseText, reuseMarkdown } from "./replace-render";
 import { loadP, loadGuide } from "./prompts";
-import { loadHashStore, findSnapshotPaths, type HashStore } from "./hash-store";
+import { loadHashStore, findSnapshotPaths, findServedPaths, type HashStore } from "./hash-store";
 import { getServed, recordServedSafe } from "./served";
 import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
 import { commitEdit } from "./commit";
@@ -149,7 +148,7 @@ async function resolveMissingPath(
   } catch {
     return undefined;
   }
-  const matches = findSnapshotPaths(store, hashes);
+  const matches = [...new Set([...findSnapshotPaths(store, hashes), ...findServedPaths(store, hashes)])];
   if (matches.length === 1) {
     return {
       path: matches[0]!,

package/src/served.ts

@@ -1,4 +1,4 @@
-import { loadHashStore, parseHashList, type HashStore } from "./hash-store";
+import { loadHashStore, parseStoredHashes, type HashStore } from "./hash-store";
 import { HASH_CLASS } from "./hashline/alphabet";
 
 const SERVED_DIFF_ROW_RE = new RegExp(`^[+ ](${HASH_CLASS})│`);
@@ -14,8 +14,7 @@ export function servedHashesFromDiff(diff: string): string[] {
 
 export function getServed(store: HashStore, path: string): Set<string> | undefined {
   const row = store.stmts.servedGet(path);
-  if (!row) return undefined;
-  const parsed = parseHashList(row.hashes as string, () => store.stmts.servedDelete(path));
+  const parsed = parseStoredHashes(row, () => store.stmts.servedDelete(path));
   if (!parsed) return undefined;
   return new Set(parsed);
 }