pi-hashline-edit-pro 4.0.0 → 4.1.0

package/README.md

@@ -40,7 +40,7 @@ Replace a line by its anchor:
 
 The result is the post-edit diff with fresh anchors, so you can keep editing without re-reading. Lines you did not touch keep their anchors. After a `write`, an auto-read block gives you the new anchors. The most recent `replace` or `insert` on a file can be reverted, even after a restart.
 
-The extension registers five tools: `read`, `replace`, `insert`, `anchor_grep`, and `undo_last_change`. The built-in `edit` tool is disabled. `replace` and `insert` take no `path` parameter: the file is resolved from the anchors' session ownership alone, so an edit can only land on the file the anchors were served for.
+The extension registers five tools: `read`, `replace`, `insert`, `anchor_grep`, and `undo_last_change`. The built-in `edit` tool is disabled. `replace` and `insert` take no `path` parameter by default: the file is resolved from the anchors' session ownership alone, so an edit can only land on the file the anchors were served for. Opt in with `/hashline-config` to require `path` in `replace` and `insert` for RPC visibility (for example pimacs.el); anchors still resolve the target and `path` must match.
 
 ### read
 
@@ -89,7 +89,7 @@ Single line: use the same anchor for `remove_from` and `remove_to`. `replace_fro
 
 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 as warnings: a leftover `anchor│` prefix in `replacement_lines` or the anchor fields (any prefix of 1 to 8 characters before `│`, for example `L3│` or `ab12│`), diff-preview rows pasted into the replacement, a reversed range, and a boundary line pasted twice. New lines that re-include a block adjacent to the range are stripped when that block is unique in the file. The whole run is stripped as one unit, so re-including an unchanged block next to the range never duplicates it.
+Common copy-paste slips are fixed automatically and reported as warnings: a leftover `anchor│` prefix in `replacement_lines` or the anchor fields (a prefix of 4 to 5 characters before `│`, for example `ab12│`), diff-preview rows pasted into the replacement, a reversed range, and a boundary line pasted twice. New lines that re-include a block adjacent to the range are stripped when that block is unique in the file. The whole run is stripped as one unit, so re-including an unchanged block next to the range never duplicates 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, `anchor_grep` output, the auto-read block after `write`, the `+anchor│` and ` anchor│` rows of post-edit diffs, the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale-anchor feedback) and verifies the whole range against that record before writing. A line that changed on disk since it was shown, or an anchor that is not owned in this session, refuses the edit with `[E_RANGE_STALE]` or `[E_STALE_ANCHOR]` and returns the current range with fresh anchors, so the retry needs no `read`. An owned anchor enters the served record when its row is shown (after a restart, restored ownership counts as shown), so a file with no owned anchors cannot be edited by anchor at all; call `read` first. An owned line that was never shown — for example beyond an auto-read preview's truncation cap — is refused with `[E_RANGE_STALE]` and returns the current range, so the retry still needs no `read`.
 
@@ -115,7 +115,7 @@ The same safety machinery as `replace` applies: undo is saved before the write (
 
 ### anchor_grep
 
-`anchor_grep` is an anchored search backed by ripgrep. It is disabled by default; enable it with `/toggle-anchor-grep` (or set `anchorGrepEnabled` to `true` in the config file). While it is enabled, the built-in grep is disabled. Disabling it removes the tool and restores the built-in grep only if that was active before the extension loaded.
+`anchor_grep` is an anchored search backed by ripgrep. It is enabled by default; disable it in `/hashline-config` (or set `anchorGrepEnabled` to `false` in the config file). While it is enabled, the built-in grep is disabled. Disabling it removes the tool and restores the built-in grep only if that was active before the extension loaded.
 
 Every matching line, and each requested context line, is returned as `lineNumber │ anchor│content`. The `anchor│content` part is served exactly like `read` output, so you can target it with `replace` or `insert` without a separate `read`; the line-number gutter and `=== path ===` header give filename and line for navigation.
 
@@ -153,7 +153,7 @@ Auto-read is enabled by default. After a successful `write`, the extension reads
 
 After `replace`, `insert`, and `undo_last_change`, the result shows the post-edit diff. The `+anchor│` and ` anchor│` rows carry the current anchors, so follow-up edits can anchor on the diff directly. The `-anchor│` rows show removed lines with their old anchors, which are stale after the edit. When the context line next to a change is blank or whitespace-only, one more context line is shown in that direction, so the change stays anchored to visible content. Call `read` when you want the full file's anchors.
 
-Auto-read keeps the same 50KB and 2000-line budget as `read`. Toggle it at runtime with `/toggle-auto-read`; both settings persist across sessions.
+Auto-read keeps the same 50KB and 2000-line budget as `read`. Change it in `/hashline-config`; both settings persist across sessions.
 
 ## Tool result details
 
@@ -170,16 +170,18 @@ All five tools return machine-readable metadata in `details` alongside the model
 
 | Command | Description |
 | --- | --- |
-| `/toggle-auto-read` | Toggle auto-read anchors after `write` and post-edit diffs after `replace`, `insert`, and `undo_last_change`. Persists across sessions. |
-| `/toggle-anchor-grep` | Enable or disable the `anchor_grep` tool. The built-in grep is disabled while `anchor_grep` is on. Persists across sessions. |
+| `/hashline-config` | Open the settings window: auto-read anchors, `anchor_grep` tool, required `path`, strict input, and boundary dedup. Persists across sessions. |
 | `/clear-anchors` | Clear the session's anchor claims. Anchors are re-claimed on the next `read`. |
 
-Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created when a setting is first toggled:
+Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created when a setting is first changed in `/hashline-config`:
 
 ```json
 {
   "autoRead": true,
-  "anchorGrepEnabled": false
+  "anchorGrepEnabled": true,
+  "requirePath": false,
+  "strictInput": false,
+  "boundaryDedupEnabled": true
 }
 ```
 

package/index.ts

@@ -7,17 +7,23 @@ import { regGrep } from "./src/grep";
 import { regUndo, clearUndo } from "./src/replace-undo";
 import { regRead, fmtReadPreview } from "./src/read";
 import type { RMetrics } from "./src/replace-response";
+import type { ReplaceDetails } from "./src/replace";
 import { extractWarnings } from "./src/replace-render";
 import { MAX_HASH_LINES } from "./src/hashline";
 import {
   readConfig,
   toggleAutoRead,
   toggleAnchorGrep,
+  toggleRequirePath,
+  toggleStrictInput,
+  toggleBoundaryDedup,
 } from "./src/config";
 import { loadHashStore, persistSnapshot, pruneMissing } from "./src/hash-store";
 import { initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, markServed as markServedScoped } from "./src/anchor-registry";
 import { buildServedMap } from "./src/served";
 import { clearBoundaryBypass } from "./src/boundary-bypass";
+import { currentEditFlags } from "./src/edit-common";
+import { HashlineConfigOverlay } from "./src/config-ui";
 import { registerWriteHook } from "./src/write-hook";
 import { readNormFile } from "./src/file-reader";
 import { loadFileKindAndText } from "./src/file-kind";
@@ -37,6 +43,17 @@ export default function (pi: ExtensionAPI): void {
   let autoRead = true;
   let grepWasActive = false;
 
+  async function refreshEditTools(): Promise<void> {
+    try {
+      const flags = await currentEditFlags();
+      regRead(pi, flags);
+      regReplace(pi, flags);
+      regInsert(pi, flags);
+    } catch (error) {
+      console.error("Failed to refresh edit tools:", error);
+    }
+  }
+
   pi.on("session_start", async (_event, ctx) => {
     const active = pi.getActiveTools();
     grepWasActive = active.includes("grep");
@@ -56,6 +73,7 @@ export default function (pi: ExtensionAPI): void {
     await gcRegistrySidecars();
     const config = await readConfig();
     autoRead = config.autoRead;
+    await refreshEditTools();
     pi.setActiveTools(
       pi.getActiveTools().filter((t) =>
         config.anchorGrepEnabled ? t !== "grep" : t !== "anchor_grep",
@@ -67,31 +85,40 @@ export default function (pi: ExtensionAPI): void {
     }
   });
 
-  pi.registerCommand("toggle-auto-read", {
-    description: "Toggle auto-read anchors after write and post-edit diffs after replace, insert, and undo_last_change",
+  pi.registerCommand("hashline-config", {
+    description: "Open the hashline settings window (auto-read, grep, path, strict input, dedup)",
     handler: async (_args, ctx) => {
-      autoRead = await toggleAutoRead();
-      const state = autoRead ? "enabled" : "disabled";
-      ctx.ui.notify(`Auto-read anchors after write and post-edit diffs after replace/undo: ${state}`, "info");
-    },
-  });
-
-  pi.registerCommand("toggle-anchor-grep", {
-    description: "Enable or disable the anchor_grep tool (the built-in grep is disabled while anchor_grep is on)",
-    handler: async (_args, ctx) => {
-      const enabled = await toggleAnchorGrep();
-      const active = pi.getActiveTools();
-      pi.setActiveTools(
-        enabled
-          ? [...new Set([...active.filter((t) => t !== "grep"), "anchor_grep"])]
-          : [...new Set([...active.filter((t) => t !== "anchor_grep"), ...(grepWasActive ? ["grep"] : [])])],
-      );
-      const state = enabled ? "enabled" : "disabled";
-      ctx.ui.notify(`anchor_grep tool ${state}`, "info");
+      if (!ctx.hasUI) {
+        ctx.ui.notify("/hashline-config requires interactive mode", "error");
+        return;
+      }
+      await ctx.ui.custom<void>(async (tui, theme, _keybindings, done) => {
+        const overlay = new HashlineConfigOverlay({
+          tui,
+          theme,
+          done,
+          onToggle: async (key) => {
+            if (key === "autoRead") autoRead = await toggleAutoRead();
+            else if (key === "anchorGrepEnabled") {
+              const enabled = await toggleAnchorGrep();
+              const active = pi.getActiveTools();
+              pi.setActiveTools(enabled ? [...new Set([...active.filter((t) => t !== "grep"), "anchor_grep"])] : [...new Set([...active.filter((t) => t !== "anchor_grep"), ...(grepWasActive ? ["grep"] : [])])]);
+            }
+            else if (key === "requirePath") await toggleRequirePath();
+            else if (key === "strictInput") await toggleStrictInput();
+            else await toggleBoundaryDedup();
+            await refreshEditTools();
+          },
+        });
+        await overlay.load();
+        return overlay;
+      }, {
+        overlay: true,
+        overlayOptions: { anchor: "center", width: "90%", minWidth: 60, maxHeight: "90%" },
+      });
     },
   });
 
-
   pi.registerCommand("clear-anchors", {
     description: "Clear the session's anchor claims (path-free resolution state); anchors are re-claimed on the next read",
     handler: async (_args, ctx) => {
@@ -164,7 +191,9 @@ export default function (pi: ExtensionAPI): void {
     const metrics = (event.details as { metrics?: RMetrics } | undefined)?.metrics;
     if (metrics?.classification === "noop") return;
 
-    const diff = (event.details as { diff?: string } | undefined)?.diff;
+    const toolDetails = event.details as ReplaceDetails | undefined;
+    const diff = toolDetails?.diff;
+    const detailWarnings = Array.isArray(toolDetails?.warnings) ? toolDetails.warnings.filter((w): w is string => typeof w === "string") : [];
     if (typeof diff !== "string") return;
     const hasDiff = diff.length > 0;
 
@@ -175,7 +204,7 @@ export default function (pi: ExtensionAPI): void {
       )
       .map((entry) => entry.text)
       .join("\n");
-    const warnings = extractWarnings(rendered);
+    const warnings = detailWarnings.length ? `Warnings:\n${detailWarnings.join("\n")}` : extractWarnings(rendered);
     const hint = hasDiff ? (warnings ? `${diff}\n\n${warnings}` : diff) : warnings ? `[post-edit] applied successfully; the diff is empty (whitespace-only change).\n\n${warnings}` : "[post-edit] applied successfully; the diff is empty (whitespace-only change).";
     return {
       content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "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 @@
-- `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.

package/prompts/read-guidelines.md

@@ -1,2 +1,3 @@
+- `read`: view files with `read`, not `bash` (`sed`/`grep`/`cat`) — only `read` rows carry usable anchors.
 - `read`: call before `replace` when you need fresh anchors.
 - `read`: call again after an edit when you need anchors you lack — post-edit diff `+anchor│`/` anchor│` rows and any served `anchor│content` rows already carry fresh anchors for the changed range.

package/prompts/read.md

@@ -1 +1 @@
-Read a text file and return it as `anchor│content` rows, one per line: a 4-character alphanumeric anchor, the `│` separator, then the line content. Target lines in replace and insert by anchor, never by content or line number. Page long files with `offset` and `limit`; when the output says truncated, continue with the hinted `offset/limit`. Images are returned as visual attachments. A binary file, a directory, or UTF-16/UTF-32 text is rejected; an empty file returns one empty row you can replace to seed content. BOMs are stripped for display and non-UTF-8 bytes are shown as U+FFFD.
+Read a text file and return it as `anchor│content` rows, one per line: a 4-character alphanumeric anchor, the `│` separator, then the line content. Target lines in replace and insert by anchor, never by content or line number. Page long files with `offset` and `limit`; when the output says truncated, continue with the hinted `offset/limit`. Images attach visually; binary, directory, and UTF-16/UTF-32 text are rejected; an empty file returns one empty row you can replace to seed content.

package/prompts/replace-guidelines.md

@@ -1,5 +1,4 @@
-- `replace`: use the same anchor for `remove_from` and `remove_to` to change one line.
-- `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`: edit with `replace`/`insert`, not `sed -i` or heredocs — anchor edits are verified against what was shown and undoable.
+- `replace`: `replacement_lines` takes bare lines without `│`; `[""]` is one blank line; pasted `anchor│` prefixes are stripped automatically (single line: same anchor for `remove_from` and `remove_to`).
 - `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).
+- `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/anchor-registry.ts

@@ -1,4 +1,5 @@
-import { appendFile, mkdir, readFile, readdir, rm, stat } from "fs/promises";
+import { chmod, mkdir, readFile, readdir, rm, stat } from "fs/promises";
+import { appendFileSync, chmodSync } from "fs";
 import { join } from "path";
 import { createHash } from "crypto";
 import { sessionClaimsDir } from "./paths";
@@ -129,8 +130,12 @@ export async function initRegistry(sessionFile: string | undefined): Promise<voi
   seedServedFromOwned(folded);
   registries.set(key, folded);
   try {
-    await mkdir(sessionClaimsDir(), { recursive: true });
-    await appendFile(currentSidecar, JSON.stringify({ kind: "session", sessionFile } satisfies RegistryEvent) + "\n", "utf-8");
+    await mkdir(sessionClaimsDir(), { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32") {
+      try { await chmod(sessionClaimsDir(), 0o700); } catch (error) { if (errCode(error) !== "ENOENT") console.error("Failed to secure anchor registry directory:", error); }
+      try { await chmod(currentSidecar, 0o600); } catch (error) { if (errCode(error) !== "ENOENT") console.error("Failed to secure anchor registry sidecar:", error); }
+    }
+    appendEvent({ kind: "session", sessionFile } satisfies RegistryEvent);
   } catch (error) {
     console.error("Failed to initialize anchor registry sidecar:", error);
   }
@@ -142,9 +147,15 @@ function current(): SessionState | undefined {
 }
 
 function appendEvent(event: RegistryEvent): void {
-  appendFile(currentSidecar!, JSON.stringify(event) + "\n", "utf-8").catch((error) => {
+  if (!currentSidecar) return;
+  try {
+    appendFileSync(currentSidecar, JSON.stringify(event) + "\n", "utf-8");
+    if (process.platform !== "win32") {
+      try { chmodSync(currentSidecar, 0o600); } catch (error) { if (errCode(error) !== "ENOENT") console.error("Failed to secure anchor registry sidecar:", error); }
+    }
+  } catch (error) {
     console.error("Failed to append registry event:", error);
-  });
+  }
 }
 
 function fingerprintIndex(state: SessionState, path: string): Map<string, string[]> {
@@ -188,9 +199,7 @@ export function allocateAnchor(path: string, checksum: string): string {
   const anchor = mintAnchor(state);
   state.everMinted.add(anchor);
   state.owned.set(anchor, { path, checksum });
-  if (currentSidecar) {
-    appendEvent({ kind: "allocate", path, rows: [[anchor, checksum]] });
-  }
+  appendEvent({ kind: "allocate", path, rows: [[anchor, checksum]] });
   return anchor;
 }
 
@@ -217,7 +226,7 @@ export function freeAnchors(path: string, anchors?: string[]): void {
 		}
 		state.served.delete(path);
 	}
-	if (freed.length > 0 && currentSidecar) {
+	if (freed.length > 0) {
 		appendEvent({ kind: "free", path, anchors: anchors ?? undefined });
 	}
 }
@@ -227,7 +236,6 @@ export function clearRegistry(): void {
 	if (!state) return;
 	state.owned.clear();
 	state.served.clear();
-	if (!currentSidecar) return;
 	appendEvent({ kind: "clear" });
 }
 
@@ -362,7 +370,7 @@ export function alignOwnershipWithSpans(
   const freed: { anchor: string; checksum: string }[] = [];
   const minted: MintedAt[] = [];
   const log = (event: RegistryEvent): void => {
-    if (!options?.shadow && currentSidecar) appendEvent(event);
+    if (!options?.shadow) appendEvent(event);
   };
 
   const sorted = [...spans].sort((a, b) => a.start - b.start);
@@ -432,7 +440,7 @@ export function alignOwnership(
   const freed: { anchor: string; checksum: string }[] = [];
   const minted: MintedAt[] = [];
   const log = (event: RegistryEvent): void => {
-    if (!options?.shadow && currentSidecar) appendEvent(event);
+    if (!options?.shadow) appendEvent(event);
   };
   if (prevAnchors) {
     for (const anchor of prevAnchors) state.everMinted.add(anchor);
@@ -544,7 +552,7 @@ export async function allocateFileAnchors(
           state.owned.set(anchor, { path, checksum });
           return anchor;
         });
-        if (!shadow && currentSidecar) {
+        if (!shadow) {
           appendEvent({ kind: "allocate", path, rows: anchors.map((a, i) => [a, checksums[i]!]) });
         }
         return { anchors, freed: [], minted: anchors };
@@ -567,7 +575,7 @@ export function adoptAnchors(path: string, entries: Map<string, string>): void {
 		state.owned.set(anchor, { path, checksum });
 		served.set(anchor, checksum);
 	}
-	if (currentSidecar && entries.size > 0) {
+	if (entries.size > 0) {
 		appendEvent({ kind: "allocate", path, rows: [...entries] });
 	}
 }

package/src/boundary-bypass.ts

@@ -13,6 +13,7 @@ function canonLines(lines: string[]): string[] {
 }
 
 const boundaryBypassTracker = new Map<string, string>();
+const BOUNDARY_BYPASS_LIMIT = 256;
 
 export function noopPayloadKey(
   absolutePath: string,
@@ -29,7 +30,12 @@ export function noopPayloadKey(
 }
 
 export function markBoundaryNoop(absolutePath: string, payload: string): void {
+  boundaryBypassTracker.delete(absolutePath);
   boundaryBypassTracker.set(absolutePath, payload);
+  if (boundaryBypassTracker.size > BOUNDARY_BYPASS_LIMIT) {
+    const oldest = boundaryBypassTracker.keys().next().value;
+    if (oldest !== undefined) boundaryBypassTracker.delete(oldest);
+  }
 }
 
 export function consumeBoundaryBypass(absolutePath: string, payload: string): boolean {

package/src/config-ui.ts

@@ -0,0 +1,93 @@
+import { Key, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { readConfig, type Config } from "./config";
+
+export type ConfigToggleKey = "autoRead" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupEnabled";
+
+export interface ConfigRow {
+  key: ConfigToggleKey;
+  label: string;
+  hint: string;
+  enabled: boolean;
+}
+
+export function configRows(config: Config): ConfigRow[] {
+  return [
+    { key: "autoRead", label: "Auto-read", hint: "Anchors after write + post-edit diffs", enabled: config.autoRead !== false },
+    { key: "anchorGrepEnabled", label: "Anchor grep", hint: "anchor_grep tool (builtin grep off while on)", enabled: config.anchorGrepEnabled === true },
+    { key: "requirePath", label: "Require path", hint: "replace + insert need path (RPC visibility)", enabled: config.requirePath === true },
+    { key: "strictInput", label: "Strict input", hint: "Reject auto-fixable slips instead of warnings", enabled: config.strictInput === true },
+    { key: "boundaryDedupEnabled", label: "Boundary dedup", hint: "Strip re-included edge lines (off = literal)", enabled: config.boundaryDedupEnabled !== false },
+  ];
+}
+
+function padRow(theme: Theme, innerWidth: number, content: string): string {
+  const padded = content + " ".repeat(Math.max(0, innerWidth - visibleWidth(content)));
+  return theme.fg("border", "│") + padded + theme.fg("border", "│");
+}
+
+export class HashlineConfigOverlay {
+  private rows: ConfigRow[];
+  private selected = 0;
+
+  constructor(private readonly opts: { tui: { requestRender(force?: boolean): void }; theme: Theme; done: () => void; onToggle: (key: ConfigToggleKey) => Promise<void> }) {
+    this.rows = [];
+  }
+
+  async load(): Promise<void> {
+    this.rows = configRows(await readConfig());
+  }
+
+  private toggleSelected(): void {
+    const row = this.rows[this.selected];
+    if (!row) return;
+    row.enabled = !row.enabled;
+    this.opts.tui.requestRender(true);
+    void this.opts.onToggle(row.key).then(async () => {
+      this.rows = configRows(await readConfig());
+      this.opts.tui.requestRender(true);
+    }).catch((error: unknown) => {
+      console.error("Failed to toggle hashline setting:", error);
+    });
+  }
+
+  handleInput(data: string): void {
+    if (matchesKey(data, Key.up) || data === "k") {
+      this.selected = (this.selected + this.rows.length - 1) % this.rows.length;
+      return;
+    }
+    if (matchesKey(data, Key.down) || data === "j") {
+      this.selected = (this.selected + 1) % this.rows.length;
+      return;
+    }
+    if (matchesKey(data, Key.space) || matchesKey(data, Key.enter) || data === " " || data === "\r" || data === "\n") {
+      this.toggleSelected();
+      return;
+    }
+    if (matchesKey(data, Key.escape) || data === "q") {
+      this.opts.done();
+    }
+  }
+
+  invalidate(): void {
+  }
+
+  render(width: number): string[] {
+    const theme = this.opts.theme;
+    const innerWidth = width - 2;
+    const lines: string[] = [];
+    lines.push(theme.fg("border", `╭${"─".repeat(innerWidth)}╮`));
+    lines.push(padRow(theme, innerWidth, ` ${theme.fg("accent", theme.bold("Hashline Config"))}`));
+    lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
+    this.rows.forEach((row, index) => {
+      const cursor = index === this.selected ? theme.fg("accent", "> ") : "  ";
+      const box = row.enabled ? theme.fg("success", "[x]") : theme.fg("dim", "[ ]");
+      const label = index === this.selected ? theme.fg("accent", theme.bold(row.label)) : row.label;
+      lines.push(padRow(theme, innerWidth, `${cursor}${box} ${label} ${theme.fg("dim", `— ${row.hint}`)}`));
+    });
+    lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
+    lines.push(padRow(theme, innerWidth, theme.fg("dim", " ↑↓ navigate · space toggle · q close")));
+    lines.push(theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
+    return lines;
+  }
+}

package/src/config.ts

@@ -6,11 +6,17 @@ import { writeAtomic } from "./fs-write";
 export interface Config {
   autoRead: boolean;
   anchorGrepEnabled: boolean;
+  requirePath?: boolean;
+  strictInput?: boolean;
+  boundaryDedupEnabled?: boolean;
 }
 
 const DEFAULT_CONFIG: Config = {
   autoRead: true,
-  anchorGrepEnabled: false
+  anchorGrepEnabled: true,
+  requirePath: false,
+  strictInput: false,
+  boundaryDedupEnabled: true
 };
 
 function parseConfig(content: string): Config {
@@ -20,9 +26,15 @@ function parseConfig(content: string): Config {
     throw new Error("config.json must be an object with a boolean autoRead field");
   }
   const anchorGrepEnabled = isRec(parsed) ? parsed.anchorGrepEnabled : undefined;
+  const requirePath = isRec(parsed) ? parsed.requirePath : undefined;
+  const strictInput = isRec(parsed) ? parsed.strictInput : undefined;
+  const boundaryDedupEnabled = isRec(parsed) ? parsed.boundaryDedupEnabled : undefined;
   return {
     autoRead,
     anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
+    requirePath: typeof requirePath === "boolean" ? requirePath : DEFAULT_CONFIG.requirePath,
+    strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,
+    boundaryDedupEnabled: typeof boundaryDedupEnabled === "boolean" ? boundaryDedupEnabled : DEFAULT_CONFIG.boundaryDedupEnabled,
   };
 }
 
@@ -56,3 +68,25 @@ export async function toggleAnchorGrep(): Promise<boolean> {
   await writeConfig(config);
   return config.anchorGrepEnabled;
 }
+
+export async function toggleRequirePath(): Promise<boolean> {
+  const config = await readConfig();
+  config.requirePath = !config.requirePath;
+  await writeConfig(config);
+  return config.requirePath;
+}
+
+export async function toggleStrictInput(): Promise<boolean> {
+  const config = await readConfig();
+  config.strictInput = !(config.strictInput === true);
+  await writeConfig(config);
+  return config.strictInput === true;
+}
+
+export async function toggleBoundaryDedup(): Promise<boolean> {
+  const config = await readConfig();
+  const enabled = config.boundaryDedupEnabled !== false;
+  config.boundaryDedupEnabled = !enabled;
+  await writeConfig(config);
+  return !enabled;
+}

package/src/edit-common.ts

@@ -3,11 +3,81 @@ import { resolveInCwd } from "./fs-write";
 import { abortIf, makePrepareArguments } from "./utils";
 import { ownerOf } from "./anchor-registry";
 import { parseHashRef, stripAnchorRow } from "./hashline";
+import { readConfig } from "./config";
 import { makeRenderCall, renderEditResult, type RPreview, type FgT } from "./replace-render";
 import type { ReplaceDetails } from "./replace";
-
 export const editPrepare = makePrepareArguments();
 
+export interface EditToolFlags {
+  requirePath: boolean;
+  strictInput: boolean;
+  boundaryDedupEnabled: boolean;
+  autoRead: boolean;
+}
+
+export const DEFAULT_EDIT_FLAGS: EditToolFlags = {
+  requirePath: false,
+  strictInput: false,
+  boundaryDedupEnabled: true,
+  autoRead: true
+};
+
+export async function currentEditFlags(): Promise<EditToolFlags> {
+  const config = await readConfig();
+  return {
+    requirePath: config.requirePath === true,
+    strictInput: config.strictInput === true,
+    boundaryDedupEnabled: config.boundaryDedupEnabled !== false,
+    autoRead: config.autoRead !== false
+  };
+}
+
+export function withReplacePrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
+  let description = base.description;
+  const snippetParts = [base.snippet];
+  let guidelines = [...base.guidelines];
+  if (!flags.autoRead) {
+    description = description.replace(" Anchor follow-up edits on the `+anchor│` and ` anchor│` rows of the post-edit diff instead of re-reading.", "");
+    guidelines = guidelines.map((guideline) => guideline.includes("post-edit diff") ? "`replace`: one edit per turn; verify each result before the next edit on that file." : guideline);
+  }
+  const descriptionParts = [description];
+  if (flags.requirePath) {
+    descriptionParts.push("Also give `path` matching the file the anchors were served for; it is required and must match anchor ownership.");
+    snippetParts.push("; include `path` (required)");
+    guidelines.push("`replace`: include `path` matching the file the anchors were served for; it is required.");
+  }
+  if (flags.strictInput) {
+    descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
+    guidelines.push("`replace`: strict-input is on: auto-fixable slips are rejected instead of fixed.");
+  }
+  if (!flags.boundaryDedupEnabled) {
+    descriptionParts.push("Boundary dedup is off: edits apply literally.");
+    guidelines.push("`replace`: boundary dedup is off: edits apply literally.");
+  }
+  return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
+}
+
+export function withReadPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
+  if (flags.autoRead) return { description: base.description, snippet: base.snippet, guidelines: [...base.guidelines] };
+  const guidelines = base.guidelines.map((guideline) => guideline.startsWith("`read`: call again after an edit") ? "`read`: call again after an edit when you need anchors you lack." : guideline);
+  return { description: base.description, snippet: base.snippet, guidelines };
+}
+
+export function withInsertPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
+  const descriptionParts = [base.description];
+  const snippetParts = [base.snippet];
+  const guidelines = [...base.guidelines];
+  if (flags.requirePath) {
+    descriptionParts.push("Also give `path` matching the file the anchor was served for; it is required and must match anchor ownership.");
+    snippetParts.push("; include `path` (required)");
+    guidelines.push("`insert`: include `path` matching the file the anchor was served for; it is required.");
+  }
+  if (flags.strictInput) {
+    descriptionParts.push("Strict-input mode is on: auto-fixable slips are rejected instead of fixed with warnings.");
+    guidelines.push("`insert`: strict-input is on: auto-fixable slips are rejected instead of fixed.");
+  }
+  return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
+}
 export function resolveEditTarget(removeFrom: string, removeTo?: string): string {
   const refs = [removeFrom, removeTo].filter((value): value is string => typeof value === "string");
   const owners = refs.map((ref) => ownerOf(parseHashRef(stripAnchorRow(ref.trim(), "anchor entry")).hash));
@@ -35,6 +105,48 @@ export function tryResolveEditTarget(removeFrom: string | undefined, removeTo?:
   }
 }
 
+export interface PathRequirementInput {
+  removeFrom?: string;
+  removeTo?: string;
+  anchor?: string;
+  providedPath?: unknown;
+  cwd: string;
+}
+
+export async function resolveEditTargetWithRequirement(input: PathRequirementInput): Promise<string> {
+  const { requirePath } = await readConfig();
+  if (!requirePath && input.providedPath !== undefined) {
+    throw new Error("[E_BAD_SHAPE] Edit request contains unknown or unsupported fields: path. Path resolution is anchor-only; enable require-path in /hashline-config to require it.");
+  }
+  if (requirePath && (typeof input.providedPath !== "string" || input.providedPath.length === 0)) {
+    throw new Error('[E_BAD_SHAPE] Edit request requires a non-empty "path" string when require-path mode is on (disable it in /hashline-config).');
+  }
+  const anchorTarget = typeof input.anchor === "string"
+    ? resolveEditTarget(input.anchor)
+    : resolveEditTarget(input.removeFrom as string, input.removeTo);
+  if (requirePath) {
+    const { resolved } = await resolveInCwd(input.providedPath as string, input.cwd);
+    if (resolved !== anchorTarget) {
+      throw new Error(`[E_BAD_SHAPE] Provided "path" "${input.providedPath}" does not match anchor ownership "${anchorTarget}".`);
+    }
+  }
+  return anchorTarget;
+}
+
+export async function throwIfStrictInput(warnings: string[]): Promise<void> {
+  const fixes = warnings.filter((warning) => warning.startsWith("[W_"));
+  if (fixes.length === 0) return;
+  const { strictInput } = await readConfig();
+  if (strictInput === true) {
+    throw new Error(`[E_BAD_SHAPE] Strict-input mode rejects auto-fixable input (disable it in /hashline-config):\n${fixes.join("\n")}`);
+  }
+}
+
+export async function isBoundaryDedupEnabled(): Promise<boolean> {
+  const { boundaryDedupEnabled } = await readConfig();
+  return boundaryDedupEnabled !== false;
+}
+
 export function editRenderCallWrapper(
   preview: (args: unknown, cwd: string, signal?: AbortSignal) => Promise<RPreview>,
   getInput?: (args: unknown) => { path?: string } | null,

package/src/fs-write.ts

@@ -101,12 +101,18 @@ const TEMP_PREFIX = ".tmp-";
 const TEMP_UUID_RE = /^\.tmp-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 const STALE_TEMP_MS = 60 * 60 * 1000;
 const sweptDirs = new Map<string, number>();
+const SWEPT_DIRS_LIMIT = 256;
 
 async function sweepStaleTemps(dir: string): Promise<void> {
   const sweepNow = Date.now();
   const lastSweep = sweptDirs.get(dir);
   if (lastSweep !== undefined && sweepNow - lastSweep < STALE_TEMP_MS) return;
+  sweptDirs.delete(dir);
   sweptDirs.set(dir, sweepNow);
+  if (sweptDirs.size > SWEPT_DIRS_LIMIT) {
+    const oldest = sweptDirs.keys().next().value;
+    if (oldest !== undefined) sweptDirs.delete(oldest);
+  }
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {

package/src/grep.ts

@@ -14,6 +14,8 @@ import { normReq } from "./payload-contract";
 import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
 import { markServed as markServedScoped } from "./anchor-registry";
 import { buildServedMap } from "./served";
+import { Text } from "@earendil-works/pi-tui";
+import { expandHint, getResultText, reuseText, type CallT, type FgT } from "./replace-render";
 const GREP_KS = new Set(["pattern", "path", "glob", "context", "ignoreCase", "literal", "limit"]);
 
 function cmp(a: string, b: string): number {
@@ -452,6 +454,79 @@ const grepToolSchema = Type.Object(
   { additionalProperties: false },
 );
 
+
+const GREP_PREVIEW_LINES = 16;
+const GREP_PREVIEW_LINES_EXPANDED = 40;
+
+export function fmtGrepCall(args: { pattern?: unknown; path?: unknown; glob?: unknown; literal?: unknown; ignoreCase?: unknown; context?: unknown; limit?: unknown } | undefined, theme: CallT): string {
+  const pattern = typeof args?.pattern === "string" && args.pattern.length > 0 ? theme.fg("accent", args.pattern) : theme.fg("toolOutput", "...");
+  const qualifiers: string[] = [];
+  if (typeof args?.path === "string" && args.path.length > 0) qualifiers.push(args.path);
+  if (typeof args?.glob === "string" && args.glob.length > 0) qualifiers.push(args.glob);
+  if (args?.literal === true) qualifiers.push("literal");
+  if (args?.ignoreCase === true) qualifiers.push("case-insensitive");
+  if (typeof args?.context === "number") qualifiers.push(`context ${args.context}`);
+  if (typeof args?.limit === "number") qualifiers.push(`limit ${args.limit}`);
+  let text = `${theme.fg("toolTitle", theme.bold("anchor_grep"))} ${pattern}`;
+  if (qualifiers.length > 0) text += ` ${theme.fg("dim", qualifiers.join(" "))}`;
+  return text;
+}
+
+function highlightRegex(args: unknown): RegExp | undefined {
+  if (!isRec(args) || typeof args.pattern !== "string" || args.pattern.length === 0) return undefined;
+  try {
+    const validated = buildRegex(args.pattern, args.literal === true, args.ignoreCase === true);
+    return new RegExp(validated.source, validated.flags.includes("i") ? "giu" : "gu");
+  } catch {
+    return undefined;
+  }
+}
+
+function highlightMatches(text: string, regex: RegExp, theme: FgT): string {
+  let out = "";
+  let last = 0;
+  regex.lastIndex = 0;
+  for (;;) {
+    const match = regex.exec(text);
+    if (!match || match[0].length === 0) break;
+    out += text.slice(last, match.index) + theme.fg("accent", match[0]);
+    last = match.index + match[0].length;
+  }
+  return out + text.slice(last);
+}
+
+const ANCHORED_ROW_RE = /^[A-Za-z0-9]{4}│/;
+
+function highlightHitRow(row: string, highlight: RegExp, theme: FgT): string {
+  const anchored = row.match(ANCHORED_ROW_RE);
+  if (!anchored) return highlightMatches(row, highlight, theme);
+  return anchored[0] + highlightMatches(row.slice(anchored[0].length), highlight, theme);
+}
+
+function styleGrepLine(line: string, highlight: RegExp | undefined, theme: FgT): string {
+  if (line.startsWith("=== ")) return theme.fg("accent", line);
+  if (line.startsWith("[grep:") || line.startsWith("... ")) return theme.fg("dim", line);
+  if (!highlight) return line;
+  const gutter = line.indexOf(" │ ");
+  if (gutter < 0) return highlightHitRow(line, highlight, theme);
+  const cut = gutter + " │ ".length;
+  return line.slice(0, cut) + highlightHitRow(line.slice(cut), highlight, theme);
+}
+
+export function renderGrepResult(result: { content?: Array<{ type: string; text?: string }> }, options: { isPartial: boolean; expanded?: boolean } | boolean, theme: FgT, context: any): Text {
+  const isPartial = typeof options === "boolean" ? options : options.isPartial;
+  const expanded = typeof options === "boolean" ? context.expanded === true : options.expanded === true || context.expanded === true;
+  if (isPartial) return reuseText(context, theme.fg("warning", "Searching..."));
+  const raw = getResultText(result);
+  if (context.isError) return raw ? reuseText(context, `\n${theme.fg("error", raw)}`) : new Text("", 0, 0);
+  if (!raw) return new Text("", 0, 0);
+  const maxLines = expanded ? GREP_PREVIEW_LINES_EXPANDED : GREP_PREVIEW_LINES;
+  const lines = raw.split("\n");
+  const highlight = highlightRegex((context as { args?: unknown }).args);
+  const shown = lines.slice(0, maxLines).map((line) => styleGrepLine(line, highlight, theme));
+  if (lines.length > maxLines) shown.push(theme.fg("muted", `... ${lines.length - maxLines} more grep lines (${expandHint()})`));
+  return reuseText(context, shown.join("\n"));
+}
 export function regGrep(pi: ExtensionAPI): void {
   pi.registerTool({
     name: "anchor_grep",
@@ -462,6 +537,14 @@ export function regGrep(pi: ExtensionAPI): void {
     prepareArguments: makePrepareArguments(),
     parameters: grepToolSchema,
     executionMode: "sequential",
+    renderCall(args: any, theme: CallT, context: any) {
+      const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+      text.setText(fmtGrepCall(args as { pattern?: unknown; path?: unknown } | undefined, theme));
+      return text;
+    },
+    renderResult(result, opts, theme, context) {
+      return renderGrepResult(result as never, opts as { isPartial: boolean; expanded?: boolean }, theme as never, context as never);
+    },
 
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);

package/src/hash-store.ts

@@ -535,7 +535,8 @@ async function statMissing(rows: { path: string }[]): Promise<string[]> {
           await stat(row.path);
           return undefined;
         } catch (error: unknown) {
-          if (errCode(error) !== "ENOENT") {
+          const code = errCode(error);
+          if (code !== "ENOENT" && code !== "ENOTDIR") {
             console.error("Failed to stat hash store path:", row.path, error);
             return undefined;
           }

package/src/hashline/alphabet.ts

@@ -12,7 +12,7 @@ export const ALPH_RE = new RegExp(`^[${ALNUM}]+$`);
 
 export const HASH_CLASS = `[${ALNUM}]{${HASH_LEN}}`;
 
-export const HASH_RUN = `[${ALNUM}]{1,${HASH_LEN * 2}}`;
+export const HASH_RUN = `[${ALNUM}]{${HASH_LEN},${HASH_LEN + 1}}`;
 
 export const HASH_RE = new RegExp(`^${HASH_CLASS}$`);
 

package/src/hashline/resolve.ts

@@ -1,6 +1,7 @@
 import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine, getCached } from "../utils";
-import { HASH_SEP, HASH_RUN, stripRowPrefix, canon } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
+import { HASH_SEP, stripRowPrefix, canon } from "./hash";
+import { HASH_RUN } from "./alphabet";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
 import { contentChecksum } from "./hasher";
 import { hashSource } from "./hash";
@@ -97,7 +98,7 @@ export function fmtMismatchWithHashes(
   if (notFound.length > 0) {
     const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
     out.push(
-      `[E_STALE_ANCHOR] ${notFound.length} stale anchor${notFound.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}: ${refList}. The file changed since read. Call read() for fresh anchors.`
+      `[E_STALE_ANCHOR] ${notFound.length} stale anchor${notFound.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}: ${refList}. The file changed since read. Call read()${filePath ? ` on ${filePath}` : ""} for fresh anchors.`
     );
     for (const m of notFound) {
       const ctx = m.context;
@@ -536,8 +537,8 @@ export function assertRangeServed(
       : `${mismatchLines.length} of ${rangeLength} line(s) in the replaced range (lines ${startLine}-${endLine})${location} do not match`;
   const capHint =
     rangeLength > shownLength
-      ? `\n\n[The range has ${rangeLength} lines; showing the first ${shownLength}. Call read() with offset=${startLine + shownLength} to see the rest.]`
-      : "";
+      ? `\n\n[The range has ${rangeLength} lines; showing the first ${shownLength}. Call read()${filePath ? ` on ${filePath}` : ""} with offset=${startLine + shownLength} to see the rest.]`
+      : "\n\nRetry with the fresh anchors above without a read.";
   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, shownHashes, shownMap);

package/src/insert.ts

@@ -10,13 +10,13 @@ import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
 import { decodeStringArray, isRec, rejectUnknownFields, splitLines } from "./utils";
 import { clearBoundaryBypass } from "./boundary-bypass";
-import { resolveEditTarget } from "./edit-common";
+import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, withInsertPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import type { RPreview, RRState } from "./replace-render";
-import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper } from "./edit-common";
 
-const INSERT_KS = new Set(["anchor", "direction", "lines"]);
+const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
 
 export interface InsertReq {
+  path?: string;
   anchor: string;
   direction: "before" | "after";
   lines: string[];
@@ -27,6 +27,9 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
     throw new Error("[E_BAD_SHAPE] Insert request must be an object.");
   }
   rejectUnknownFields(request, INSERT_KS, "Insert request");
+  if (request.path !== undefined && typeof request.path !== "string") {
+    throw new Error('[E_BAD_SHAPE] Insert request field "path" must be a string when provided.');
+  }
   if (typeof request.anchor !== "string" || request.anchor.length === 0) {
     throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (4-char anchor from read output).');
   }
@@ -38,33 +41,52 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
   }
 }
 
+const insertAnchorSchema = Type.String({
+  description:
+    'Bare 4-char anchor from a read row (the text before the `│` separator), never the row content. A pasted diff row or `anchor│` prefix is stripped with a warning. The anchor line is preserved; lines go after or before it.',
+});
+
+const insertDirectionSchema = Type.Union(
+  [Type.Literal("after"), Type.Literal("before")],
+  { description: '"after" or "before"' },
+);
+
+const insertLinesSchema = Type.Array(
+  Type.String({
+    description: "One line to insert; never embed \\n inside an element.",
+  }),
+  {
+    description: 'One string per line; [""] is a blank line; never include the anchor line.',
+  }
+);
+
+const insertPathRequiredSchema = Type.String({
+  description:
+    "Path to the file the anchor was served for; required and must match anchor ownership. The anchor still resolves the target.",
+});
+
 const insertToolSchema = Type.Object(
   {
-    anchor: Type.String({
-      description:
-        'Bare 4-char anchor from a read row (the text before the `│` separator), never the row content. A pasted diff row or `anchor│` prefix is stripped with a warning. The anchor line is preserved; lines go after or before it.',
-    }),
-    direction: Type.Union(
-      [
-        Type.Literal("after"),
-        Type.Literal("before"),
-      ],
-      { description: '"after" or "before"' },
-    ),
-    lines: Type.Array(
-      Type.String({
-        description:
-          "One line to insert; never embed \\n inside an element.",
-      }),
-      {
-        description:
-          'One string per line; [""] is a blank line; never include the anchor line.',
-      }
-    ),
+    anchor: insertAnchorSchema,
+    direction: insertDirectionSchema,
+    lines: insertLinesSchema,
   },
   { additionalProperties: false },
 );
 
+export function buildInsertToolSchema(requirePath: boolean): typeof insertToolSchema {
+  if (!requirePath) return insertToolSchema;
+  return Type.Object(
+    {
+      path: insertPathRequiredSchema,
+      anchor: insertAnchorSchema,
+      direction: insertDirectionSchema,
+      lines: insertLinesSchema,
+    },
+    { additionalProperties: false },
+  ) as typeof insertToolSchema;
+}
+
 function parseInsertAnchor(raw: string): { ref: Anchor; warnings: string[] } {
   const trimmedAnchor = raw.trim();
   const warnings: string[] = [];
@@ -97,17 +119,28 @@ function buildInsertEdit(
 export async function insertPreview(request: unknown, cwd: string, signal?: AbortSignal): Promise<RPreview> {
   try {
     const normalized = normReq(request);
+    const previewFixes: string[] = [];
     if (isRec(normalized)) {
       const expanded = decodeStringArray(normalized.lines);
-      if (expanded) normalized.lines = expanded;
+      if (expanded) {
+        previewFixes.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a lines element.');
+        normalized.lines = expanded;
+      }
     }
     assertInsertReq(normalized);
-    const { ref } = parseInsertAnchor(normalized.anchor);
-    const targetPath = resolveEditTarget(normalized.anchor);
+    const previewReq = normalized as InsertReq;
+    const { ref, warnings: previewAnchorWarnings } = parseInsertAnchor(previewReq.anchor);
+    await throwIfStrictInput([...previewFixes, ...previewAnchorWarnings]);
+    const targetPath = await resolveEditTargetWithRequirement({
+      anchor: previewReq.anchor,
+      providedPath: previewReq.path,
+      cwd,
+    });
     const preload = await readNormFile(targetPath, cwd, {
       accessMode: constants.R_OK,
       maxLines: MAX_HASH_LINES,
       noPersist: true,
+      allocation: "shadow",
       signal,
     });
     const { editParams } = buildInsertEdit(normalized, preload, ref, targetPath);
@@ -151,15 +184,20 @@ function getInsertInput(args: unknown): { path?: string; anchor?: string; direct
 
 type InsertToolDef = ToolDefinition<any, ReplaceDetails, RRState> & { renderShell?: "default" | "self" };
 
-export function buildInsertToolDef(): InsertToolDef {
+export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): InsertToolDef {
+  const prompted = withInsertPrompts({
+    description: loadP("../prompts/insert.md"),
+    snippet: loadP("../prompts/insert-snippet.md"),
+    guidelines: loadGuide("../prompts/insert-guidelines.md"),
+  }, flags);
   return {
     name: "insert",
     label: "Insert",
-    description: loadP("../prompts/insert.md"),
-    promptSnippet: loadP("../prompts/insert-snippet.md"),
-    promptGuidelines: loadGuide("../prompts/insert-guidelines.md"),
+    description: prompted.description,
+    promptSnippet: prompted.snippet,
+    promptGuidelines: prompted.guidelines,
     ...editToolBase,
-    parameters: insertToolSchema,
+    parameters: buildInsertToolSchema(flags.requirePath),
     renderCall: editRenderCallWrapper(insertPreview, getInsertInput, "insert"),
     renderResult: editRenderResultWrapper,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
@@ -174,8 +212,13 @@ export function buildInsertToolDef(): InsertToolDef {
       }
       assertInsertReq(canonical);
       const req = canonical;
-      const targetPath = resolveEditTarget(req.anchor);
+      const targetPath = await resolveEditTargetWithRequirement({
+        anchor: req.anchor,
+        providedPath: req.path,
+        cwd: ctx.cwd,
+      });
       const { ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor);
+      await throwIfStrictInput([...anchorWarnings, ...insertWarnings]);
       return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
         const preload = await readNormFile(targetPath, ctx.cwd, {
           signal,
@@ -205,6 +248,6 @@ export function buildInsertToolDef(): InsertToolDef {
   };
 }
 
-export function regInsert(pi: ExtensionAPI): void {
-  pi.registerTool(buildInsertToolDef());
+export function regInsert(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): void {
+  pi.registerTool(buildInsertToolDef(flags));
 }

package/src/payload-contract.ts

@@ -21,6 +21,10 @@ const removeToSchema = Type.String({
   description:
     "Bare 4-char anchor from a read row (the text before the `│` separator), never the row content. Marks the LAST line to remove (inclusive)",
 });
+const pathRequiredSchema = Type.String({
+  description:
+    "Path to the file the anchors were served for; required and must match anchor ownership. Anchors still resolve the target.",
+});
 
 export const editToolSchema = Type.Object(
   {
@@ -31,19 +35,35 @@ export const editToolSchema = Type.Object(
   { additionalProperties: false },
 );
 
+export function buildEditToolSchema(requirePath: boolean): typeof editToolSchema {
+  if (!requirePath) return editToolSchema;
+  return Type.Object(
+    {
+      path: pathRequiredSchema,
+      remove_from: removeFromSchema,
+      remove_to: removeToSchema,
+      replacement_lines: replacementLinesSchema,
+    },
+    { additionalProperties: false },
+  ) as typeof editToolSchema;
+}
+
 export type ReqParams = {
+  path?: string;
   remove_from: string;
   remove_to: string;
   replacement_lines: string[];
 };
 
-const ROOT_KS = new Set(["remove_from", "remove_to", "replacement_lines"]);
-
+const ROOT_KS = new Set(["path", "remove_from", "remove_to", "replacement_lines"]);
 export function assertReq(request: unknown): asserts request is ReqParams {
   if (!isRec(request)) {
     throw new Error("[E_BAD_SHAPE] Edit request must be an object.");
   }
   rejectUnknownFields(request, ROOT_KS, "Edit request");
+  if (request.path !== undefined && typeof request.path !== "string") {
+    throw new Error('[E_BAD_SHAPE] Edit request field "path" must be a string when provided.');
+  }
   if (
     typeof request.remove_from !== "string" ||
     typeof request.remove_to !== "string" ||

package/src/read.ts

@@ -15,18 +15,16 @@ import { lineHashes, fmtRegion, fmtRow, HASH_SEP, MAX_HASH_LINES } from "./hashl
 import { toCwd } from "./paths";
 import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
+import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import { valAccess } from "./validation";
 import { markServed as markServedScoped } from "./anchor-registry";
 import { buildServedMap } from "./served";
 import { Text } from "@earendil-works/pi-tui";
 const R_DESC = loadP("../prompts/read.md");
-
 const R_SNIPPET = loadP("../prompts/read-snippet.md");
-
 function readGuide(): string[] {
-	return loadGuide("../prompts/read-guidelines.md");
+  return loadGuide("../prompts/read-guidelines.md");
 }
-
 function normPosInt(
 	value: number | undefined,
 	name: "offset" | "limit",
@@ -166,13 +164,14 @@ export async function fmtReadPreview(
 	};
 }
 
-export function regRead(pi: ExtensionAPI): void {
-	pi.registerTool({
-		name: "read",
-		label: "Read",
-		description: R_DESC,
-		promptSnippet: R_SNIPPET,
-		promptGuidelines: readGuide(),
+export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): void {
+  const prompted = withReadPrompts({ description: R_DESC, snippet: R_SNIPPET, guidelines: readGuide() }, flags);
+  pi.registerTool({
+    name: "read",
+    label: "Read",
+    description: prompted.description,
+    promptSnippet: prompted.snippet,
+    promptGuidelines: prompted.guidelines,
 		prepareArguments: makePrepareArguments(),
 		parameters: Type.Object({
 			path: Type.String({

package/src/replace-render.ts

@@ -128,7 +128,7 @@ export function isApplied(
 
 const RESULT_PREVIEW_LINES = 16;
 
-function expandHint(): string {
+export function expandHint(): string {
 	try {
 		return keyHint("app.tools.expand", "to expand");
 	} catch {
@@ -165,7 +165,7 @@ export function buildAppliedText(
 				: "";
 		sections.push(`${diffSection}${hint}`);
 	}
-	const warnings = extractWarnings(text);
+	const warnings = details?.warnings?.length ? `Warnings:\n${details.warnings.join("\n")}` : extractWarnings(text);
 	if (warnings) sections.push(warnings);
 	return sections.length > 0 ? sections.join("\n\n") : undefined;
 }

package/src/replace-response.ts

@@ -125,7 +125,8 @@ export function buildNoop(input: NoopInput, noopNoun = "Replacement"): TResult {
 			firstChangedLine: undefined,
 			snapshotId,
 			classification: "noop" as const,
-			metrics,
+      metrics,
+      ...(warnings?.length ? { warnings: [...warnings] } : {}),
 		},
 	};
 }
@@ -210,6 +211,7 @@ export function buildChanged(input: SuccessInput, verb = "replaced"): TResult {
       snapshotId,
       metrics,
       diffLineNumbers: diffResult.lineNumbers,
+      ...(warnings?.length ? { warnings: [...warnings] } : {}),
     },
   };
 }

package/src/replace.ts

@@ -9,7 +9,7 @@ import {
   type LineEnding,
 } from "./replace-diff";
 import { readNormFile, type NormFile } from "./file-reader";
-import { editToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
+import { editToolSchema, buildEditToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
 import { decodeStringArray } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { type FileIdentity } from "./fs-write";
@@ -33,7 +33,7 @@ import { adoptAnchors, servedForPath } from "./anchor-registry";
 import { resolveTarget } from "./fs-write";
 import { toCwd } from "./paths";
 import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
-import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTarget } from "./edit-common";
+import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper, resolveEditTargetWithRequirement, throwIfStrictInput, isBoundaryDedupEnabled, withReplacePrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 
 export { editToolSchema, type ReqParams, assertReq };
 
@@ -46,6 +46,7 @@ export type ReplaceDetails = {
   classification?: "noop";
   metrics?: RMetrics;
   diffLineNumbers?: (number|undefined)[];
+  warnings?: string[];
 };
 
 export interface PipelineResult {
@@ -142,6 +143,8 @@ export async function execPipeline(
   );
   const displayPath = relative(cwd, absolutePath).replace(/\\/g, "/") || targetPath;
 
+  const dedupEnabled = await isBoundaryDedupEnabled();
+  const effectiveSkipBoundaryDedup = options?.skipBoundaryDedup === true || !dedupEnabled;
   let anchorResult: ReturnType<typeof applyEdit>;
   try {
     anchorResult = applyEdit(
@@ -151,7 +154,7 @@ export async function execPipeline(
       originalHashes,
       displayPath,
       served,
-      options?.skipBoundaryDedup,
+      effectiveSkipBoundaryDedup,
     );
   } catch (error) {
     await noteAnchorError(absolutePath, error, originalHashes, options?.noPersist);
@@ -168,6 +171,7 @@ export async function execPipeline(
         hashes: originalHashes,
       }, hashStore, false, true);
   const warnings = [...editWarnings, ...(anchorResult.warnings ?? [])];
+  await throwIfStrictInput(warnings);
   const { totalAddedLines, totalRemovedLines } = countLineChanges(
     edit, originalHashes, isNoop, anchorResult.autoFixes?.length ?? 0,
   );
@@ -220,7 +224,12 @@ export async function compPreview(
   try {
     const normalized = normReq(request);
     assertReq(normalized);
-    const targetPath = resolveEditTarget(normalized.remove_from, normalized.remove_to);
+    const targetPath = await resolveEditTargetWithRequirement({
+      removeFrom: (normalized as ReqParams).remove_from,
+      removeTo: (normalized as ReqParams).remove_to,
+      providedPath: (normalized as ReqParams).path,
+      cwd,
+    });
     const pipe = await execPipeline(
       targetPath,
       normalized,
@@ -240,18 +249,20 @@ type ToolDef = ToolDefinition<
   RRState
 > & { renderShell?: "default" | "self" };
 
-export function buildToolDef(): ToolDef {
-  const E_DESC = loadP("../prompts/replace.md");
-  const E_SNIPPET = loadP("../prompts/replace-snippet.md");
-  const E_GUIDE = loadGuide("../prompts/replace-guidelines.md");
-  const parameters = editToolSchema;
+export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef {
+  const prompted = withReplacePrompts({
+    description: loadP("../prompts/replace.md"),
+    snippet: loadP("../prompts/replace-snippet.md"),
+    guidelines: loadGuide("../prompts/replace-guidelines.md"),
+  }, flags);
+  const parameters = buildEditToolSchema(flags.requirePath);
   return {
     name: "replace",
     label: "Replace",
-    description: E_DESC,
+    description: prompted.description,
     parameters,
-    promptSnippet: E_SNIPPET,
-    promptGuidelines: E_GUIDE,
+    promptSnippet: prompted.snippet,
+    promptGuidelines: prompted.guidelines,
     ...editToolBase,
     renderCall: editRenderCallWrapper(compPreview),
     renderResult: editRenderResultWrapper,
@@ -259,10 +270,16 @@ export function buildToolDef(): ToolDef {
       const canonical = normReq(params);
       assertReq(canonical);
       const normalizedParams = canonical;
-      const targetPath = resolveEditTarget(normalizedParams.remove_from, normalizedParams.remove_to);
+      const targetPath = await resolveEditTargetWithRequirement({
+        removeFrom: normalizedParams.remove_from,
+        removeTo: normalizedParams.remove_to,
+        providedPath: normalizedParams.path,
+        cwd: ctx.cwd,
+      });
       return queuedEdit(targetPath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
+        const dedupOn = await isBoundaryDedupEnabled();
         const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
-        const boundaryBypass = consumeBoundaryBypass(mutationTargetPath, noopPayload);
+        const boundaryBypass = dedupOn ? consumeBoundaryBypass(mutationTargetPath, noopPayload) : false;
         const pipe = await execPipeline(
           targetPath,
           normalizedParams,
@@ -279,14 +296,14 @@ export function buildToolDef(): ToolDef {
           editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
           signal,
           appliedWarnings,
-          onApplied: () => clearBoundaryBypass(mutationTargetPath),
-          onNoopDedup: () => markBoundaryNoop(mutationTargetPath, noopPayload),
+          onApplied: () => { if (dedupOn) clearBoundaryBypass(mutationTargetPath); },
+          onNoopDedup: dedupOn ? () => markBoundaryNoop(mutationTargetPath, noopPayload) : undefined,
         });
       });
     },
   };
 }
 
-export function regReplace(pi: ExtensionAPI): void {
-  pi.registerTool(buildToolDef());
+export function regReplace(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FLAGS): void {
+  pi.registerTool(buildToolDef(flags));
 }