pi-hashline-edit-pro 3.0.1 → 3.0.3

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,7 +99,7 @@ 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.
+- 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 the candidates 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.
 - 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).
@@ -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 the candidates 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "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,6 @@
 - `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.
+- `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.
+- `replace`: if `replacement_lines` re-include the boundary line adjacent to the range, it is deduplicated automatically, shown as `dedup│content` rows in the diff (not editable, never use `dedup` as an anchor).

package/src/commit.ts

@@ -1,5 +1,7 @@
 import type { PipelineResult } from "./replace";
-import { abortIf, clipLine } from "./utils";
+import { abortIf } from "./utils";
+import { DEDUP_ANCHOR } from "./constants";
+import { HASH_SEP } from "./hashline";
 import { buildChanged, buildNoop, type RMeta, type TResult } from "./replace-response";
 import { saveUndo } from "./replace-undo";
 import { safeSnapId } from "./file-reader";
@@ -22,10 +24,10 @@ export interface CommitMeta {
   onNoopDedup?: () => void;
 }
 
-function boundaryDedupWarning(lineTexts: string[]): string {
-  const quoted = lineTexts.map((line) => `"${clipLine(line, 80)}"`).join(", ");
-  const plural = lineTexts.length > 1;
-  return `Boundary dedup: ${quoted} already ${plural ? "exist" : "exists"} next to the edited range, so ${plural ? "they were" : "it was"} not added again.`;
+function boundaryDedupWarning(count: number): string {
+  const noun = count === 1 ? "1 line" : `${count} lines`;
+  const row = count === 1 ? "row" : "rows";
+  return `Boundary dedup: ${noun} not added again (see ${DEDUP_ANCHOR}${HASH_SEP} ${row}).`;
 }
 
 export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promise<TResult> {
@@ -61,7 +63,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     );
   }
   if (pipe.boundaryRemovedLineTexts.length > 0) {
-    warnings.push(boundaryDedupWarning(pipe.boundaryRemovedLineTexts));
+    warnings.push(boundaryDedupWarning(pipe.boundaryRemovedLineTexts.length));
   }
 
   abortIf(signal);
@@ -109,6 +111,8 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     warnings,
     snapshotId: updatedSnapshotId,
     editMeta,
+    boundaryDedupAbove: pipe.boundaryDedupAbove,
+    boundaryDedupBelow: pipe.boundaryDedupBelow,
   };
   const changed = buildChanged(successInput, meta.verb);
   if (changed.details.diff) {

package/src/constants.ts

@@ -12,3 +12,5 @@ export const HASH_STORE_BUSY_TIMEOUT = 1000;
 export const HASH_STORE_VERSION = 7;
 export const NEW_CONTENT_NOT_ARRAY_MSG =
   `[E_BAD_SHAPE] "replacement_lines" must be an array of strings, one per line (use [] to delete).`;
+
+export const DEDUP_ANCHOR = "dedup";

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,45 @@ 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 pickRecentPath(store: HashStore, candidates: string[]): string {
+  let best = candidates[0]!;
+  let bestSession = -1;
+  let bestActivity = -1;
+  for (const candidate of candidates) {
+    const rank = sessionRank(candidate) ?? -1;
+    let activity = -1;
+    if (rank < 0) {
+      activity = pathActivity(store, candidate);
+    }
+    if (rank > bestSession || (rank === bestSession && activity > bestActivity)) {
+      best = candidate;
+      bestSession = rank;
+      bestActivity = activity;
+    }
+  }
+  return best;
+}

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[],
   };
 }
 
@@ -178,6 +185,8 @@ export function buildInsertToolDef(): InsertToolDef {
           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,51 @@
+import { loadHashStore, findSnapshotPaths, findServedPaths, pickRecentPath } 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: `[E_BAD_SHAPE] Missing "path" resolved to ${single}.` };
+  }
+  const sorted = [...matches].sort();
+  const picked = pickRecentPath(store, sorted);
+  return { path: picked, warning: `[E_BAD_SHAPE] Missing "path" resolved to ${picked} (picked most recent of ${sorted.length}: ${sorted.join(", ")}).` };
+}
+
+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

@@ -75,16 +75,14 @@ export function normReq(input: unknown): unknown {
   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 +92,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

@@ -12,8 +12,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;
@@ -65,17 +64,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 +237,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

@@ -1,7 +1,10 @@
+import { formatSize, DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
 import type { NEdit } from "./hashline";
+import { HASH_SEP } from "./hashline";
 import type { ReplaceDetails } from "./replace";
 import { genDiff, genPatch } from "./replace-diff";
 import { visLines, clipLine } from "./utils";
+import { DEDUP_ANCHOR } from "./constants";
 
 export type TResult = {
 	content: Array<{ type: "text"; text: string }>;
@@ -46,6 +49,8 @@ export interface SuccessInput {
   warnings: string[] | undefined;
   snapshotId?: string;
   editMeta: RMeta;
+  boundaryDedupAbove?: string[];
+  boundaryDedupBelow?: string[];
 }
 
 
@@ -124,11 +129,47 @@ export function buildNoop(input: NoopInput, noopNoun = "Replacement"): TResult {
 		},
 	};
 }
+export function fmtDedupRow(line: string): string {
+  const row = `${DEDUP_ANCHOR}${HASH_SEP}${line}`;
+  if (Buffer.byteLength(row, "utf-8") <= DEFAULT_MAX_BYTES) return row;
+  const size = formatSize(Buffer.byteLength(row, "utf-8"));
+  const limit = formatSize(DEFAULT_MAX_BYTES);
+  return `${DEDUP_ANCHOR}${HASH_SEP}[Row is ${size}, exceeds ${limit}; content not shown. Use read to see the full line.]`;
+}
+
+export function isChangeRow(line: string): boolean {
+  return line.startsWith("+") || line.startsWith("-");
+}
+
+export function withDedupRows(diff: string, lineNumbers: (number | undefined)[], above: string[] | undefined, below: string[] | undefined): { diff: string; lineNumbers: (number | undefined)[] } {
+  const top = (above ?? []).map(fmtDedupRow);
+  const bottom = (below ?? []).map(fmtDedupRow);
+  if (top.length === 0 && bottom.length === 0) return { diff, lineNumbers };
+  if (diff.length === 0) return { diff: [...top, ...bottom].join("\n"), lineNumbers: [...lineNumbers, ...[...top, ...bottom].map(() => undefined)] };
+  const lines = diff.split("\n");
+  let first = -1;
+  let last = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (isChangeRow(lines[i]!)) {
+      if (first < 0) first = i;
+      last = i;
+    }
+  }
+  if (first < 0) return { diff: `${diff}\n${[...top, ...bottom].join("\n")}`, lineNumbers: [...lineNumbers, ...[...top, ...bottom].map(() => undefined)] };
+  const out = [...lines];
+  const nums = [...lineNumbers];
+  out.splice(last + 1, 0, ...bottom);
+  nums.splice(last + 1, 0, ...bottom.map(() => undefined));
+  out.splice(first, 0, ...top);
+  nums.splice(first, 0, ...top.map(() => undefined));
+  return { diff: out.join("\n"), lineNumbers: nums };
+}
 
 export function buildChanged(input: SuccessInput, verb = "replaced"): TResult {
-  const { path, result, warnings, snapshotId, originalNormalized, originalHashes, editMeta, resultHashes } = input;
+  const { path, result, warnings, snapshotId, originalNormalized, originalHashes, editMeta, resultHashes, boundaryDedupAbove, boundaryDedupBelow } = input;
   const resultLines = visLines(result);
-  const diffResult = genDiff(originalNormalized, result, 1, resultHashes, originalHashes);
+  const baseDiff = genDiff(originalNormalized, result, 1, resultHashes, originalHashes);
+  const diffResult = withDedupRows(baseDiff.diff, baseDiff.lineNumbers, boundaryDedupAbove, boundaryDedupBelow);
   const addedLines = editMeta.addedLines;
   const removedLines = editMeta.removedLines;
   const warningsBlock = warnBlock(warnings);
@@ -161,7 +202,7 @@ export function buildChanged(input: SuccessInput, verb = "replaced"): TResult {
       patch: patchResult.patch,
       ...(patchResult.truncated ? { patchTruncated: true as const } : {}),
       firstChangedLine:
-        editMeta.firstChangedLine ?? diffResult.firstChangedLine,
+        editMeta.firstChangedLine ?? baseDiff.firstChangedLine,
       snapshotId,
       metrics,
       diffLineNumbers: diffResult.lineNumbers,

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,
@@ -23,12 +22,13 @@ import { applyEdit,
   type NEdit,
 } from "./hashline";
 import { commitEdit } from "./commit";
-import type { RMetrics } from "./replace-response";
+import { withDedupRows, type RMetrics } from "./replace-response";
 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";
@@ -64,44 +64,11 @@ export interface PipelineResult {
   hadBoundaryDedup: boolean;
   boundaryRemovedLines: number;
   boundaryRemovedLineTexts: string[];
+  boundaryDedupAbove: string[];
+  boundaryDedupBelow: string[];
   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;
@@ -216,6 +183,9 @@ export async function execPipeline(
     edit, originalHashes, isNoop, anchorResult.autoFixes?.length ?? 0,
   );
 
+  const sortedFixes = [...(anchorResult.autoFixes ?? [])].sort((a, b) => a.removedLineIndex - b.removedLineIndex);
+  const aboveFixes = sortedFixes.filter((fix) => fix.kind === "leading" || fix.kind === "last-new-before");
+  const belowFixes = sortedFixes.filter((fix) => fix.kind === "trailing" || fix.kind === "first-new-after");
   return {
     path,
     originalNormalized,
@@ -233,7 +203,9 @@ export async function execPipeline(
     totalRemovedLines,
     hadBoundaryDedup: (anchorResult.autoFixes?.length ?? 0) > 0,
     boundaryRemovedLines: anchorResult.autoFixes?.length ?? 0,
-    boundaryRemovedLineTexts: anchorResult.autoFixes?.map((fix) => fix.removedLine) ?? [],
+    boundaryRemovedLineTexts: sortedFixes.map((fix) => fix.removedLine),
+    boundaryDedupAbove: aboveFixes.map((fix) => fix.removedLine),
+    boundaryDedupBelow: belowFixes.map((fix) => fix.removedLine),
     identity,
   };
 }
@@ -242,9 +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,
     };
   }
-  return { diff: genDiff(pipe.originalNormalized, pipe.result, 4, pipe.resultHashes, pipe.originalHashes).diff };
+  const base = genDiff(pipe.originalNormalized, pipe.result, 4, pipe.resultHashes, pipe.originalHashes);
+  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) };
@@ -256,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,
@@ -292,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;
       }

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);