pi-hashline-edit-pro 3.0.2 → 3.0.4

package/README.md

@@ -91,6 +91,7 @@ One edit per call, with `remove_from`, `remove_to`, and `replacement_lines` at t
 
 | Field | Description |
 | --- | --- |
+| `path` | Path to edit; always provide it explicitly — it is only auto-resolved from the anchors as a fallback. |
 | `remove_from` | 4-char anchor from `read` output marking the FIRST line to remove (inclusive). |
 | `remove_to` | 4-char anchor from `read` output marking the LAST line to remove (inclusive). |
 | `replacement_lines` | Replacement lines as an array of strings, one element per line. Mirror the removed lines exactly, blank lines included: use `[]` to delete the range, `[""]` for a single blank line, `["a", ""]` for a line followed by a blank line, and `["", ""]` for two blank lines. Do not embed `\n` inside an element: each element is exactly one line. |
@@ -98,8 +99,8 @@ One edit per call, with `remove_from`, `remove_to`, and `replacement_lines` at t
 Notes:
 
 - The request is checked before any file I/O, so a bad request never touches the file.
-- Common copy-paste slips are fixed automatically and reported: a leftover `anchor│` prefix (including a truncated or expanded prefix of up to 6 characters, e.g. `L3│` or `ab12│`) in `replacement_lines` or `remove_from`/`remove_to`, diff-preview rows pasted into the replacement, a reversed range, or a boundary line pasted twice. New lines that re-include a block adjacent to the range are stripped automatically when that block is unique in the file. The whole run is stripped as one unit (including repeated structural lines like `}`), so re-including an unchanged block next to the range never duplicates it. A missing `path` is resolved from the anchors when they uniquely identify a file in the hash store (reported as a warning); when the anchors match multiple known files the request is rejected with the candidate paths named. `file_path` works as an alias for `path` in all five tools.
-- An edit that produces identical content reports `No changes made` and leaves the anchors alone. When such a noop happened because a boundary anti-duplication cut removed lines from the replacement (the cut blocked a line that duplicates the block next to the range from being added), the same replacement sent once more runs with the edge anti-duplication turned off for that single call and is applied literally. The duplicated lines are kept, and the result carries a `[E_BOUNDARY_BYPASS]` notice. The pending bypass is per file and keyed to that payload; copied `anchor│` prefixes, diff markers, and stray whitespace in the resend are normalized before matching, so a copy-paste resend still hits it. Any applied edit clears it, and a successful `write` also clears it.
+- Common copy-paste slips are fixed automatically and reported: a leftover `anchor│` prefix (including a truncated or expanded prefix of up to 6 characters, e.g. `L3│` or `ab12│`) in `replacement_lines` or `remove_from`/`remove_to`, diff-preview rows pasted into the replacement, a reversed range, or a boundary line pasted twice. New lines that re-include a block adjacent to the range are stripped automatically when that block is unique in the file. The whole run is stripped as one unit (including repeated structural lines like `}`), so re-including an unchanged block next to the range never duplicates it. A missing `path` is resolved from the anchors when they identify known files in the hash store (reported as a warning); when the anchors match multiple known files the most recently touched file is picked, with up to 3 candidate paths named. `file_path` works as an alias for `path` in all five tools, and `replace_from`/`replace_to` work as aliases for `remove_from`/`remove_to` in `replace`.
+- An edit that produces identical content reports `No changes made` and leaves the anchors alone. When such a noop happened because a boundary anti-duplication cut removed lines from the replacement (the cut blocked a line that duplicates the block next to the range from being added), the same replacement sent once more runs with the edge anti-duplication turned off for that single call and is applied literally. The duplicated lines are kept, and the result carries a `[W_BOUNDARY_BYPASS]` notice. The pending bypass is per file and keyed to that payload; copied `anchor│` prefixes, diff markers, and stray whitespace in the resend are normalized before matching, so a copy-paste resend still hits it. Any applied edit clears it, and a successful `write` also clears it.
 - Every line in the removed range must match what was last shown to you. The extension records the `anchor│content` rows it serves (`read` output, the auto-read block after `write`, the `+anchor│`/` anchor│` rows of post-edit diffs (replace, insert, and undo), the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale/ambiguous-anchor feedback) and verifies the whole range against that record before writing. If an interior line changed on disk since it was shown (external editor, formatter-on-save, code generation) or was never shown, the edit is refused with `[E_RANGE_STALE]` and the current range is returned with fresh anchors, so the retry needs no `read`. Edits outside the served record are only possible for files that were never read (for example right after a `write` with auto-read disabled); once the file has been served, every replaced line must have been shown.
 - After a successful edit you get the post-edit diff with fresh anchors, so you can keep editing without re-reading. The diff is capped at 50KB: a row longer than 50KB is shown as a marker that keeps the row's anchor (so the line stays editable via the diff), and when the total cap is hit the diff ends with a truncation note. Only the rows shown in the capped diff are recorded as served. The same caps apply to the `insert` and `undo_last_change` diffs, to the interactive previews, and to `details.patch` (which is flagged with `details.patchTruncated` when it was cut and can no longer be applied as-is).
 - Do not issue multiple replace or insert calls on the same file in one message; parallel edits split attention across the post-edit diffs and removed lines are easy to miss. Verify each diff before the next edit on that file.
@@ -119,12 +120,14 @@ Notes:
 
 | Field | Description |
 | --- | --- |
+| `path` | Path to edit; always provide it explicitly — it is only auto-resolved from the anchors as a fallback. |
 | `anchor` | 4-char anchor from `read` output marking the line next to which the lines go (inclusive; the line is preserved). A pasted diff row like `+Hasu│x` or an `anchor│` prefix is stripped automatically with a warning. |
 | `direction` | `"after"` to insert below the anchor line, `"before"` to insert above it. |
 | `lines` | Lines to insert as an array of strings, one element per line. Mirror `replacement_lines` semantics: use `[""]` for a blank line and do not embed `\n` inside an element. The anchor line is never part of `lines`. |
 
 Notes:
 
+- A missing `path` is resolved from the anchor the same way as `replace` (reported as a warning); when the anchor matches multiple known files the most recently touched file is picked, with up to 3 candidate paths named.
 - The anchor line must have been shown to you (read output, a post-edit diff row, anchor_grep output, or stale-range feedback). The same verification as `replace` applies: a stale or unshown anchor is rejected with `[E_STALE_ANCHOR]`, `[E_AMBIGUOUS_ANCHOR]`, or `[E_RANGE_STALE]` and the retry needs no `read`.
 - Lines are applied literally: nothing is removed, and a line that duplicates its neighbor is kept. `replace`'s boundary anti-duplication never runs for `insert`.
 - To seed an empty file, read it and insert after the `anchor│` empty-line row.
@@ -221,17 +224,21 @@ Two guarantees make this safe even with duplicated content:
 
 A no-op replace never changes the file, so anchors remain valid. On first run after upgrading from an older version, the previous `hash-store.json` is imported once and renamed to `hash-store.json.bak`.
 
-## Error codes
+## Error and warning codes
+
+Codes starting with `E_` are errors (the operation failed); codes starting with `W_` are warnings (the operation succeeded with a notice).
 
 | Code | Meaning |
 | --- | --- |
 | `[E_BAD_SHAPE]` | Request envelope or edit item has unknown, missing, or wrongly-typed fields (for example `replacement_lines` must be an array of strings, one element per line). |
+| `[W_BAD_SHAPE]` | Auto-corrected request slip reported as a warning (for example unwrapped JSON array syntax, embedded newlines split into lines, or a missing `path` resolved from anchors). |
 | `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` is not a bare 4-char anchor. |
+| `[W_BAD_REF]` | A pasted `anchor│` or diff-preview marker was stripped from an anchor field with a warning. |
 | `[E_STALE_ANCHOR]` | An anchor does not match any line in the current file; call `read` for fresh anchors. |
 | `[E_AMBIGUOUS_ANCHOR]` | An anchor matches multiple lines; call `read` for fresh anchors. |
-| `[E_INVALID_PATCH]` | A `replacement_lines` element is a diff-preview row (`+anchor│`, `-anchor│`, `-    │`). The marker is stripped automatically with a warning. |
-| `[E_BARE_HASH_PREFIX]` | A `replacement_lines` element starts with an `anchor│` prefix (the anchor plus the separator). The prefix is stripped automatically with a warning. |
-| `[E_BAD_OP]` | Range start line is after range end line. The pair is swapped automatically with a warning. |
+| `[W_INVALID_PATCH]` | A `replacement_lines` element is a diff-preview row (`+anchor│`, `-anchor│`, `-    │`). The marker is stripped automatically with a warning. |
+| `[W_BARE_HASH_PREFIX]` | A `replacement_lines` element starts with an `anchor│` prefix (the anchor plus the separator). The prefix is stripped automatically with a warning. |
+| `[W_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. |
@@ -239,7 +246,7 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 | `[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. |
+| `[W_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. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 257,795-line hashline limit or the 100MB size limit. |
 | `[E_WRITE_HASH_ECHO]` | A `write` `content` line begins with the exact `anchor│` served for this file at the same line. The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
 | `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/prompts/insert-guidelines.md

@@ -1 +1,2 @@
-- `insert`: the anchor must have been shown by `read`, a post-edit diff (`+anchor│`/` anchor│`), or any served `anchor│content` row. Empty file: `read` shows one `anchor│` row — insert `after` it.
+- `insert`: the anchor must have been shown by `read`, a post-edit diff (`+anchor│`/` anchor│`), or any served `anchor│content` row. Empty file: `read` shows one `anchor│` row — insert `after` it.
+- `insert`: always include explicit `path`/`file_path`, even when the file can be inferred from anchors. Do not rely on anchor-based path inference.

package/prompts/replace-guidelines.md

@@ -1,4 +1,5 @@
 - `replace`: use the same anchor for `remove_from` and `remove_to` to change one line.
+- `replace`: always include explicit `path`/`file_path`, even when the file can be inferred from anchors. Do not rely on anchor-based path inference.
 - `replace`: `replacement_lines` takes bare lines without `│`; `[""]` is one blank line; pasted `anchor│` prefixes are stripped automatically.
 - `replace`: keep the range tight — only lines that actually change — and copy leading spaces exactly.
 - `replace`: post-edit diff `+anchor│`/` anchor│` rows are fresh anchors for the next edit — no new `read` needed. One edit per turn; check the diff before the next edit on that file.

package/src/hash-store/cache.ts

@@ -16,3 +16,25 @@ export function cacheSnapshot(path: string, checksum: string, lineCount: number,
     if (oldest !== undefined) snapshotCache.delete(oldest);
   }
 }
+
+let sessionSeq = 0;
+export const sessionTouched = new Map<string, number>();
+
+export function touchSession(path: string): void {
+  sessionSeq += 1;
+  sessionTouched.delete(path);
+  sessionTouched.set(path, sessionSeq);
+}
+
+export function sessionRank(path: string): number | undefined {
+  return sessionTouched.get(path);
+}
+
+export function clearSession(): void {
+  sessionTouched.clear();
+  sessionSeq = 0;
+}
+
+export function forgetSession(path: string): void {
+  sessionTouched.delete(path);
+}

package/src/hash-store.ts

@@ -20,11 +20,7 @@ import {
   retriedWrite,
   openDbWithBusyRetryAsync,
 } from "./hash-store/retry";
-import {
-  snapshotCache,
-  cacheSnapshot,
-  SNAPSHOT_CACHE_LIMIT,
-} from "./hash-store/cache";
+import { snapshotCache, cacheSnapshot, SNAPSHOT_CACHE_LIMIT, touchSession, sessionRank, clearSession, forgetSession } from "./hash-store/cache";
 
 export { isValidHashList, isValidServedMap, parseHashList, parseServedMap, parseStoredHashes, parseStoredServed, isCorruptionError };
 export { SNAPSHOT_CACHE_LIMIT };
@@ -99,6 +95,9 @@ interface Prepared {
   servedGet: (...params: SqlParams) => Record<string, unknown> | undefined;
   servedUpsert: (...params: SqlParams) => void;
   servedDelete: (...params: SqlParams) => void;
+  snapshotTime: (...params: SqlParams) => Record<string, unknown> | undefined;
+  undoTime: (...params: SqlParams) => Record<string, unknown> | undefined;
+  servedTime: (...params: SqlParams) => Record<string, unknown> | undefined;
 }
 
 export interface HashStore {
@@ -199,6 +198,9 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
     "ON CONFLICT(path) DO UPDATE SET hashes = excluded.hashes, updated_at = excluded.updated_at"
   );
   const servedDelStmt = db.prepare("DELETE FROM served WHERE path = ?");
+  const snapshotTimeStmt = db.prepare("SELECT updated_at FROM snapshots WHERE path = ?");
+  const undoTimeStmt = db.prepare("SELECT updated_at FROM undo WHERE path = ?");
+  const servedTimeStmt = db.prepare("SELECT updated_at FROM served WHERE path = ?");
   const stmts: Prepared = {
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     allPaths: (...params) => allStmt.all(...params) as Record<string, unknown>[],
@@ -212,6 +214,9 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
     servedGet: (...params) => servedGetStmt.get(...params) as Record<string, unknown> | undefined,
     servedUpsert: retriedWrite(servedUpsertStmt),
     servedDelete: retriedWrite(servedDelStmt),
+    snapshotTime: (...params) => snapshotTimeStmt.get(...params) as Record<string, unknown> | undefined,
+    undoTime: (...params) => undoTimeStmt.get(...params) as Record<string, unknown> | undefined,
+    servedTime: (...params) => servedTimeStmt.get(...params) as Record<string, unknown> | undefined,
   };
   return { db, stmts };
 }
@@ -345,6 +350,7 @@ export function shutdownHashStore(): void {
     cachedDb = null;
   }
   snapshotCache.clear();
+  clearSession();
 }
 
 export function withStore(fn: () => void): void {
@@ -462,6 +468,7 @@ export function upsertSnapshot(
 ): void {
   store.stmts.upsert(path, checksum, lineCount, JSON.stringify(hashes), Date.now());
   cacheSnapshot(path, checksum, lineCount, hashes);
+  touchSession(path);
 }
 export function persistSnapshot(
   store: HashStore,
@@ -482,6 +489,7 @@ export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): v
     entry.resultContent,
     Date.now(),
   );
+  touchSession(path);
 }
 
 export function getUndoEntry(store: HashStore, path: string): UndoRecord | undefined {
@@ -540,6 +548,7 @@ export async function pruneMissing(store: HashStore): Promise<void> {
     }
   });
   for (const path of missing) snapshotCache.delete(path);
+  for (const path of missing) forgetSession(path);
 }
 
 function matchPathsByHashes(
@@ -603,3 +612,44 @@ export function findSnapshotPaths(store: HashStore, hashes: string[]): string[]
 export function findServedPaths(store: HashStore, hashes: string[]): string[] {
   return matchPathsByServed(store.stmts.allServed() as { path: string; hashes: string }[], hashes);
 }
+
+export function pathActivity(store: HashStore, path: string): number {
+  let activity = 0;
+  try {
+    const snap = withBusyRetry(() => store.stmts.snapshotTime(path)) as { updated_at?: unknown } | undefined;
+    const snapTime = typeof snap?.updated_at === "number" ? snap.updated_at : 0;
+    if (snapTime > activity) activity = snapTime;
+  } catch {
+  }
+  try {
+    const undo = withBusyRetry(() => store.stmts.undoTime(path)) as { updated_at?: unknown } | undefined;
+    const undoTime = typeof undo?.updated_at === "number" ? undo.updated_at : 0;
+    if (undoTime > activity) activity = undoTime;
+  } catch {
+  }
+  try {
+    const served = withBusyRetry(() => store.stmts.servedTime(path)) as { updated_at?: unknown } | undefined;
+    const servedTime = typeof served?.updated_at === "number" ? served.updated_at : 0;
+    if (servedTime > activity) activity = servedTime;
+  } catch {
+  }
+  return activity;
+}
+
+export function rankRecentPaths(store: HashStore, candidates: string[]): string[] {
+  const scored = candidates.map((candidate) => {
+    const rank = sessionRank(candidate) ?? -1;
+    const activity = rank < 0 ? pathActivity(store, candidate) : -1;
+    return { candidate, rank, activity };
+  });
+  scored.sort((a, b) => {
+    if (a.rank !== b.rank) return b.rank - a.rank;
+    if (a.activity !== b.activity) return b.activity - a.activity;
+    return a.candidate < b.candidate ? -1 : a.candidate > b.candidate ? 1 : 0;
+  });
+  return scored.map((entry) => entry.candidate);
+}
+
+export function pickRecentPath(store: HashStore, candidates: string[]): string {
+  return rankRecentPaths(store, candidates)[0]!;
+}

package/src/hashline/parse.ts

@@ -63,14 +63,14 @@ function unwrapJsonEnvelope(line: string, warnings?: string[]): string {
     const parsed: unknown = JSON.parse(withoutDot);
     if (Array.isArray(parsed) && parsed.length === 1 && typeof parsed[0] === "string") {
       warnings?.push(
-        '[E_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
+        '[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
       );
       return parsed[0];
     }
     return line;
   } catch {
     warnings?.push(
-      '[E_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
+      '[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
     );
     return match[1]!;
   }
@@ -90,7 +90,7 @@ export function parseText(edit: string[], warnings?: string[]): string[] {
   }
   if (split) {
     warnings?.push(
-      "[E_BAD_SHAPE] replacement_lines contained embedded newlines; split into one line each.",
+      "[W_BAD_SHAPE] replacement_lines contained embedded newlines; split into one line each.",
     );
   }
   return out;

package/src/hashline/resolve.ts

@@ -195,7 +195,7 @@ export function stripAnchorRow(
 			: match[1] === "-"
 				? 'leading "-" marker'
 				: '"anchor│" prefix';
-	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${clipLine(trimmed, 48)}".`);
+  warnings?.push(`[W_BAD_REF] Stripped ${marker} from ${entryLabel} "${clipLine(trimmed, 48)}".`);
 	return match[2]!;
 }
 
@@ -241,7 +241,7 @@ export function stripBarePrefixes(
 		.map((s) => `replacement_lines line ${s.lineIndex + 1}`)
 		.join(", ");
 	warnings.push(
-		`[E_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.`
+    `[W_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -260,7 +260,7 @@ export function stripDiffPrefixes(
 	if (stripped.length === 0) return edit;
 	const locations = stripped.map((i) => `replacement_lines line ${i + 1}`).join(", ");
 	warnings.push(
-		`[E_INVALID_PATCH] Stripped diff-preview marker from ${locations}.`
+    `[W_INVALID_PATCH] Stripped diff-preview marker from ${locations}.`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -285,7 +285,7 @@ export function swapReversedRanges(
 		return edit;
 	}
 	warnings.push(
-		`[E_BAD_OP] Swapped reversed remove_from/remove_to.`
+    `[W_BAD_OP] Swapped reversed remove_from/remove_to.`
 	);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }

package/src/insert.ts

@@ -10,6 +10,7 @@ import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
 import { decodeStringArray, isRec, rejectUnknownFields, splitLines } from "./utils";
 import { clearBoundaryBypass } from "./boundary-bypass";
+import { resolveInsertPath } from "./missing-path";
 import type { RPreview, RRState } from "./replace-render";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper } from "./edit-common";
 
@@ -43,10 +44,12 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
 
 const insertToolSchema = Type.Object(
   {
-    path: Type.String({
-      description:
-        "Path to the file to edit",
-    }),
+    path: Type.Optional(
+      Type.String({
+        description:
+          "Path to edit; always provide it explicitly — it is only auto-resolved from the anchors as a fallback.",
+      }),
+    ),
     anchor: Type.String({
       description:
         'Bare 4-char anchor from a read row like `Hasu│content`, never the content. A pasted `+Hasu│x` diff row or `anchor│` prefix is stripped with a warning. The anchor line is preserved; lines go after or before it.',
@@ -108,6 +111,10 @@ export async function insertPreview(request: unknown, cwd: string, signal?: Abor
       const expanded = decodeStringArray(normalized.lines);
       if (expanded) normalized.lines = expanded;
     }
+    if (isRec(normalized)) {
+      const resolution = await resolveInsertPath(normalized);
+      if (resolution) normalized.path = resolution.path;
+    }
     assertInsertReq(normalized);
     const { ref } = parseInsertAnchor(normalized.anchor);
     const preload = await readNormFile(normalized.path, cwd, {
@@ -138,7 +145,7 @@ function getInsertInput(args: unknown): { path?: string; anchor?: string; direct
   } catch {
     return null;
   }
-  if (!isRec(normalized) || typeof normalized.path !== "string") return null;
+  if (!isRec(normalized)) return null;
   if (
     typeof normalized.anchor !== "string" ||
     (normalized.direction !== "before" && normalized.direction !== "after") ||
@@ -148,10 +155,10 @@ function getInsertInput(args: unknown): { path?: string; anchor?: string; direct
     return null;
   }
   return {
-    path: normalized.path,
-    anchor: normalized.anchor,
-    direction: normalized.direction,
-    lines: normalized.lines,
+    ...(typeof normalized.path === "string" ? { path: normalized.path } : {}),
+    anchor: normalized.anchor as string,
+    direction: normalized.direction as "before" | "after",
+    lines: normalized.lines as string[],
   };
 }
 
@@ -174,10 +181,12 @@ export function buildInsertToolDef(): InsertToolDef {
       if (isRec(canonical)) {
         const expanded = decodeStringArray(canonical.lines);
         if (expanded) {
-          insertWarnings.push('[E_BAD_SHAPE] Unwrapped JSON array syntax from a lines element.');
+          insertWarnings.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a lines element.');
           canonical.lines = expanded;
         }
       }
+      const resolution = isRec(canonical) ? await resolveInsertPath(canonical) : undefined;
+      if (resolution && isRec(canonical)) canonical.path = resolution.path;
       assertInsertReq(canonical);
       const req = canonical;
       const path = req.path;
@@ -203,7 +212,7 @@ export function buildInsertToolDef(): InsertToolDef {
           verb: "inserted",
           noopNoun: "Insertion",
           foldedAnchorLines: anchorLine === undefined ? 0 : 1,
-          prefixWarnings: [...anchorWarnings, ...insertWarnings],
+          prefixWarnings: [...(resolution ? [resolution.warning] : []), ...anchorWarnings, ...insertWarnings],
           onApplied: () => clearBoundaryBypass(mutationTargetPath),
         });
       });

package/src/missing-path.ts

@@ -0,0 +1,54 @@
+import { loadHashStore, findSnapshotPaths, findServedPaths, rankRecentPaths } from "./hash-store";
+import { parseHashRef } from "./hashline/parse";
+import { stripAnchorRow } from "./hashline/resolve";
+
+export async function resolvePathFromHashes(hashes: string[]): Promise<{ path: string; warning: string } | undefined> {
+  let store;
+  try {
+    store = await loadHashStore();
+  } catch {
+    return undefined;
+  }
+  const matches = [...new Set([...findSnapshotPaths(store, hashes), ...findServedPaths(store, hashes)])];
+  if (matches.length === 0) return undefined;
+  if (matches.length === 1) {
+    const single = matches[0]!;
+    return { path: single, warning: `[W_BAD_SHAPE] Missing "path" resolved to ${single}.` };
+  }
+  const ranked = rankRecentPaths(store, [...matches]);
+  const picked = ranked[0]!;
+  const shown = ranked.slice(0, 3);
+  const hidden = ranked.length - shown.length;
+  const listed = hidden > 0 ? `${shown.join(", ")}, ... (+${hidden} more)` : shown.join(", ");
+  return { path: picked, warning: `[W_BAD_SHAPE] Missing "path" resolved to ${picked} (picked most recent of ${ranked.length}: ${listed}).` };
+}
+
+export async function resolveReplacePath(request: Record<string, unknown>): Promise<{ path: string; warning: string } | undefined> {
+  if (typeof request.path === "string") return undefined;
+  const from = request.remove_from;
+  const to = request.remove_to;
+  if (typeof from !== "string" || typeof to !== "string") return undefined;
+  const hashes: string[] = [];
+  for (const ref of [from, to]) {
+    try {
+      hashes.push(parseHashRef(ref).hash);
+    } catch {
+      return undefined;
+    }
+  }
+  return resolvePathFromHashes(hashes);
+}
+
+export async function resolveInsertPath(request: Record<string, unknown>): Promise<{ path: string; warning: string } | undefined> {
+  if (typeof request.path === "string") return undefined;
+  const anchor = request.anchor;
+  if (typeof anchor !== "string") return undefined;
+  let hash: string;
+  try {
+    const stripped = stripAnchorRow(anchor.trim(), "anchor entry");
+    hash = parseHashRef(stripped).hash;
+  } catch {
+    return undefined;
+  }
+  return resolvePathFromHashes([hash]);
+}

package/src/payload-contract.ts

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { isRec, normalizeFilePath, rejectUnknownFields } from "./utils";
+import { isRec, normalizeAnchors, normalizeFilePath, rejectUnknownFields } from "./utils";
 
 const replacementLinesSchema = Type.Array(
   Type.String({
@@ -72,19 +72,18 @@ export function normReq(input: unknown): unknown {
   }
   const record: Record<string, unknown> = { ...input };
   normalizeFilePath(record);
+  normalizeAnchors(record);
   return record;
 }
 
-export function getPreviewInput(args: unknown): ReqParams | null {
+export function getPreviewInput(args: unknown): { path?: string; remove_from: string; remove_to: string; replacement_lines: string[] } | null {
   let normalized: unknown;
   try {
     normalized = normReq(args);
   } catch {
     return null;
   }
-  if (!isRec(normalized) || typeof normalized.path !== "string") {
-    return null;
-  }
+  if (!isRec(normalized)) return null;
   if (
     typeof normalized.remove_from !== "string" ||
     typeof normalized.remove_to !== "string" ||
@@ -94,9 +93,9 @@ export function getPreviewInput(args: unknown): ReqParams | null {
     return null;
   }
   return {
-    path: normalized.path,
-    remove_from: normalized.remove_from,
-    remove_to: normalized.remove_to,
-    replacement_lines: normalized.replacement_lines,
+    ...(typeof normalized.path === "string" ? { path: normalized.path } : {}),
+    remove_from: normalized.remove_from as string,
+    remove_to: normalized.remove_to as string,
+    replacement_lines: normalized.replacement_lines as string[],
   };
 }

package/src/replace-render.ts

@@ -2,6 +2,7 @@ import { Markdown, Text } from "@earendil-works/pi-tui";
 import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
 import type { ReplaceDetails } from "./replace";
 import { withLineNumbers } from "./utils";
+import { isDedupRow } from "./replace-response";
 import { getPreviewInput } from "./payload-contract";
 export { getPreviewInput };
 
@@ -12,8 +13,7 @@ export type MdTheme = Pick<
 	"fg" | "bold" | "italic" | "underline" | "strikethrough"
 >;
 
-export type RPreview = { diff: string } | { error: string };
-
+export type RPreview = { diff: string; path?: string } | { error: string; path?: string };
 export type RRState = {
 	argsKey?: string;
 	preview?: RPreview;
@@ -25,9 +25,10 @@ export type RRState = {
 type DiffRowKind = "added" | "removed" | "context";
 
 function diffRowKind(line: string): DiffRowKind {
-	const stripped = line.replace(/^\s*\d+\s+│\s*/, "");
-	if (stripped.startsWith("+") && !stripped.startsWith("+++")) return "added";
-	if (stripped.startsWith("-") && !stripped.startsWith("---")) return "removed";
+	const withoutGutter = line.replace(/^\s*\d+\s+│\s*/, "");
+	if (isDedupRow(withoutGutter) || isDedupRow(withoutGutter.replace(/^\s*│\s*/, ""))) return "removed";
+	if (withoutGutter.startsWith("+") && !withoutGutter.startsWith("+++")) return "added";
+	if (withoutGutter.startsWith("-") && !withoutGutter.startsWith("---")) return "removed";
 	return "context";
 }
 
@@ -65,17 +66,21 @@ export function fmtResult(diff: string, theme: FgT): string {
 }
 
 export function fmtCall(
-	args: { path?: string } | undefined,
-	state: RRState,
-	expanded: boolean,
-	theme: CallT,
-	toolName = "replace",
+  args: { path?: string; remove_from?: string; remove_to?: string; anchor?: string } | undefined,
+  state: RRState,
+  expanded: boolean,
+  theme: CallT,
+  toolName = "replace",
 ): string {
-	const path = args?.path;
-	const pathDisplay =
-		typeof path === "string" && path.length > 0
-			? theme.fg("accent", path)
-			: theme.fg("toolOutput", "...");
+  const previewPath = state.preview && "path" in state.preview ? state.preview.path : undefined;
+  const path = args?.path ?? previewPath;
+  const anchorFallback = typeof args?.remove_from === "string" && typeof args?.remove_to === "string" ? `${args.remove_from}→${args.remove_to}` : typeof args?.anchor === "string" ? args.anchor : undefined;
+  const pathDisplay =
+    typeof path === "string" && path.length > 0
+      ? theme.fg("accent", path)
+      : typeof anchorFallback === "string" && anchorFallback.length > 0
+        ? theme.fg("accent", anchorFallback)
+        : theme.fg("toolOutput", "...");
 	let text = `${theme.fg("toolTitle", theme.bold(toolName))} ${pathDisplay}`;
 
 	if (!state.preview) {
@@ -234,7 +239,7 @@ export function reuseMarkdown(context: any, content: string, theme: any): Markdo
 
 export function makeRenderCall(
 	preview: (args: unknown, cwd: string, signal?: AbortSignal) => Promise<RPreview>,
-	options: { getInput?: (args: unknown) => { path?: string } | null; toolName?: string } = {},
+  options: { getInput?: (args: unknown) => { path?: string; remove_from?: string; remove_to?: string; anchor?: string } | null; toolName?: string } = {},
 ) {
 	const getInput = options.getInput ?? getPreviewInput;
 	const toolName = options.toolName ?? "replace";

package/src/replace-response.ts

@@ -137,6 +137,10 @@ export function fmtDedupRow(line: string): string {
   return `${DEDUP_ANCHOR}${HASH_SEP}[Row is ${size}, exceeds ${limit}; content not shown. Use read to see the full line.]`;
 }
 
+export function isDedupRow(line: string): boolean {
+  return line.startsWith(`${DEDUP_ANCHOR}${HASH_SEP}`);
+}
+
 export function isChangeRow(line: string): boolean {
   return line.startsWith("+") || line.startsWith("-");
 }

package/src/replace-undo.ts

@@ -11,7 +11,8 @@ import { genDiff, genPatch } from "./replace-diff";
 import { cntDiff, errCode, makePrepareArguments, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
-import { renderEditResult } from "./replace-render";
+import { renderEditResult, fmtCall } from "./replace-render";
+import { Text } from "@earendil-works/pi-tui";
 import { changedRange, lineHashes } from "./hashline";
 export interface UndoEntry {
   content: string;
@@ -100,6 +101,11 @@ export function regUndo(pi: ExtensionAPI): void {
       }),
     }),
     executionMode: "sequential",
+    renderCall(args: any, theme: any, context: any) {
+      const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+      text.setText(fmtCall(args as { path?: string } | undefined, { preview: undefined } as never, context.expanded === true, theme, "undo_last_change"));
+      return text;
+    },
     renderResult(result, opts, theme, context) {
       return renderEditResult(result as never, opts as { isPartial: boolean; expanded?: boolean }, theme as never, context as never);
     },

package/src/replace.ts

@@ -15,7 +15,6 @@ import { type FileIdentity } from "./fs-write";
 import { applyEdit,
   lineHashes,
   resEdit,
-  parseHashRef,
   MAX_HASH_LINES,
   RangeStaleError,
   AnchorMismatchError,
@@ -28,7 +27,8 @@ import {
   type RPreview,
   type RRState,
 } from "./replace-render";
-import { loadHashStore, findSnapshotPaths, findServedPaths, type HashStore } from "./hash-store";
+import { loadHashStore, type HashStore } from "./hash-store";
+import { resolveReplacePath } from "./missing-path";
 import { getServed, recordServedSafe } from "./served";
 import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
 import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper } from "./edit-common";
@@ -69,41 +69,6 @@ export interface PipelineResult {
   identity: FileIdentity;
 }
 
-async function resolveMissingPath(
-  request: Record<string, unknown>,
-): Promise<{ path: string; warning: string } | undefined> {
-  if (typeof request.path === "string") return undefined;
-  const from = request.remove_from;
-  const to = request.remove_to;
-  if (typeof from !== "string" || typeof to !== "string") return undefined;
-  const hashes: string[] = [];
-  for (const ref of [from, to]) {
-    try {
-      hashes.push(parseHashRef(ref).hash);
-    } catch {
-      return undefined;
-    }
-  }
-  let store: HashStore;
-  try {
-    store = await loadHashStore();
-  } catch {
-    return undefined;
-  }
-  const matches = [...new Set([...findSnapshotPaths(store, hashes), ...findServedPaths(store, hashes)])];
-  if (matches.length === 1) {
-    return {
-      path: matches[0]!,
-      warning: `[E_BAD_SHAPE] Missing "path" resolved to ${matches[0]}.`,
-    };
-  }
-  if (matches.length > 1) {
-    throw new Error(
-      `[E_BAD_SHAPE] Edit request requires a non-empty "path" string; the anchors match multiple known files: ${matches.join(", ")}.`,
-    );
-  }
-  return undefined;
-}
 
 export interface ExecPipelineOptions {
   accessMode?: number;
@@ -165,7 +130,7 @@ export async function execPipeline(
   let replacementLines = params.replacement_lines;
   const expandedReplacement = decodeStringArray(replacementLines);
   if (expandedReplacement) {
-    editWarnings.push('[E_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.');
+    editWarnings.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.');
     replacementLines = expandedReplacement;
   }
   const edit = resEdit(
@@ -249,10 +214,11 @@ export function previewFromPipe(pipe: PipelineResult): RPreview {
   if (pipe.originalNormalized === pipe.result) {
     return {
       error: `No changes made to ${pipe.path}. The edit produced identical content.`,
+      path: pipe.path,
     };
   }
   const base = genDiff(pipe.originalNormalized, pipe.result, 4, pipe.resultHashes, pipe.originalHashes);
-  return { diff: withDedupRows(base.diff, base.lineNumbers, pipe.boundaryDedupAbove, pipe.boundaryDedupBelow).diff };
+  return { diff: withDedupRows(base.diff, base.lineNumbers, pipe.boundaryDedupAbove, pipe.boundaryDedupBelow).diff, path: pipe.path };
 }
 export function previewError(error: unknown): RPreview {
   return { error: error instanceof Error ? error.message : String(error) };
@@ -264,6 +230,10 @@ export async function compPreview(
 ): Promise<RPreview> {
   try {
     const normalized = normReq(request);
+    if (isRec(normalized)) {
+      const resolution = await resolveReplacePath(normalized);
+      if (resolution) normalized.path = resolution.path;
+    }
     assertReq(normalized);
     const pipe = await execPipeline(
       normalized,
@@ -300,7 +270,7 @@ export function buildToolDef(): ToolDef {
     renderResult: editRenderResultWrapper,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
-      const resolution = isRec(canonical) ? await resolveMissingPath(canonical) : undefined;
+      const resolution = isRec(canonical) ? await resolveReplacePath(canonical) : undefined;
       if (resolution && isRec(canonical)) {
         canonical.path = resolution.path;
       }
@@ -316,7 +286,7 @@ export function buildToolDef(): ToolDef {
           { accessMode: constants.R_OK | constants.W_OK, signal, skipBoundaryDedup: boundaryBypass },
         );
         const appliedWarnings = boundaryBypass
-          ? ["[E_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
+          ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
           : [];
         return commitEdit(pipe, {
           path,

package/src/served.ts

@@ -1,4 +1,5 @@
 import { loadHashStore, parseStoredServed, STORE_NOT_OPEN_MESSAGE, withStore, type HashStore } from "./hash-store";
+import { touchSession } from "./hash-store/cache";
 import { withBusyRetry } from "./hash-store/retry";
 import { HASH_CLASS } from "./hashline/alphabet";
 import { contentChecksum } from "./hashline/hasher";
@@ -81,6 +82,7 @@ export function recordServed(
   entries: Map<string, string>,
   scope?: ReadonlySet<string>,
 ): void {
+  touchSession(path);
   try {
     withStore(() => {
       const map = computeUpdate(store, path, entries, scope);

package/src/utils.ts

@@ -9,11 +9,23 @@ export function normalizeFilePath(record: Record<string, unknown>): void {
   }
 }
 
+export function normalizeAnchors(record: Record<string, unknown>): void {
+  if (typeof record.remove_from !== "string" && typeof record.replace_from === "string") {
+    record.remove_from = record.replace_from;
+    delete record.replace_from;
+  }
+  if (typeof record.remove_to !== "string" && typeof record.replace_to === "string") {
+    record.remove_to = record.replace_to;
+    delete record.replace_to;
+  }
+}
+
 export function makePrepareArguments(): (args: unknown) => any {
   return (args) => {
     if (!isRec(args)) return args;
     const record = { ...args };
     normalizeFilePath(record);
+    normalizeAnchors(record);
     return record;
   };
 }