pi-hashline-edit-pro 4.3.3 → 4.3.5

package/README.md

@@ -85,11 +85,11 @@ Example: read showed `Hasu│old` and `arvm│old2`; to replace both:
 }
 ```
 
-Single line: use the same anchor for `remove_from` and `remove_to`. `replace_from`/`replace_to` work as aliases.
+Single line: use the same anchor for `remove_from` and `remove_to`. `replace_from`/`replace_to` and `from`/`to` work as aliases.
 
 The request is checked before any file I/O, so a bad request never touches the file.
 
-Common copy-paste slips are fixed automatically: 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, and a boundary line pasted twice are reported as warnings, while a reversed range, a JSON-array wrapper, and embedded newlines are corrected silently. 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. Boundary dedup has three modes in `/hashline-config`: `on` strips with a warning, `off` applies edits literally, and `strict` rejects the edit with `[E_BOUNDARY_STRICT]` when any replacement line would be stripped.
+Common copy-paste slips are fixed automatically: a leftover `anchor│` prefix in `replacement_lines` or the anchor fields (a prefix of 4 to 5 letters before `│`, for example `abde│`), diff-preview rows pasted into the replacement, and a boundary line pasted twice are reported as warnings, while a reversed range, a JSON-array wrapper, and embedded newlines are corrected silently. 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. Boundary dedup has three modes in `/hashline-config`: `on` strips with a warning, `off` applies edits literally, and `strict` rejects the edit with `[E_BOUNDARY_STRICT]` when any replacement line would be stripped.
 Content containing a NUL byte (`U+0000`) is rejected with `[E_BAD_SHAPE]` before any file I/O: writing it would make the file binary, so use an empty replacement to delete. This applies to `replace`'s `replacement_lines` and `insert`'s `lines`.
 
 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`.
@@ -167,7 +167,7 @@ Files are filtered before injection: symlinks, directories, image extensions (in
 Each attached file is shown as `=== path ===` followed by its `anchor│content` rows — edit directly from the attachment with replace and insert, no read needed. Files attach whole.
 A coverage line after the header reports the complete count. A `[files complete: [...] omitted: [...]]` line right after it lists every attached complete file and omitted file in one place — check that line instead of scanning sections.
 
-The setting lives in `/hashline-config` as Auto-read all and in `config.json` as `autoReadAll` (`"off"`, `"on"`, or `"git"`; older configs with `true` or `false` are read as `"on"` or `"off"`). Extra folders are ignored via `/hashline-config` as Ignore folders and via `config.json` as `autoReadAllIgnore` (array of folder names, for example `["docs", "tmp"]`); a single-segment entry skips any path containing that folder (case-insensitive), while an entry with a slash (for example `"src/tmp"`) skips that folder path. Custom ignores are counted with the vendor/name/pattern skips in the footer.
+The setting lives in `/hashline-config` as Auto-read all and in `config.json` as `autoReadAll` (`"off"`, `"on"`, or `"git"`; older configs with `true` or `false` are read as `"on"` or `"off"`). Extra folders and files are ignored via `/hashline-config` as Ignore folders/files and via `config.json` as `autoReadAllIgnore` (array of folder names, file names, or globs, for example `["docs", "scratch.md", "*.test.ts"]`). A single-segment entry skips any folder or file with that exact name (case-insensitive); an entry containing glob characters (`*`, `?`, `[`, `]`, `{`, `}`) is matched as a glob against the file name, or against the whole relative path when it also contains a slash, with the same syntax as `anchor_grep`'s `glob`; any other entry with a slash (for example `"src/tmp"`) skips that path. Custom ignores are counted with the vendor/name/pattern skips in the footer.
 
 ## Tool result details
 
@@ -184,7 +184,7 @@ All five tools return machine-readable metadata in `details` alongside the model
 
 | Command | Description |
 | --- | --- |
-| `/hashline-config` | Open the settings window: auto-read anchors, auto-read all mode, ignore folders, diff context lines, `anchor_grep` tool, required `path`, strict input, and boundary dedup. Persists across sessions. |
+| `/hashline-config` | Open the settings window: auto-read anchors, auto-read all mode, ignore folders/files, diff context lines, `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 changed in `/hashline-config`:
@@ -233,7 +233,7 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 | --- | --- |
 | `[E_BAD_SHAPE]` | Request envelope or edit item has unknown, missing, or wrongly-typed fields (for example `replacement_lines` must be an array of strings, one element per line), or content contains a NUL byte (`U+0000`), which would make the file binary. |
 | `[W_BAD_SHAPE]` | Auto-corrected request slip reported as a warning (for example stringified array text that could not be parsed and was kept as one literal line). |
-| `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` is not a bare 4-char anchor. |
+| `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` is not a bare 4-character anchor (the anchor table is letters only). |
 | `[W_BAD_REF]` | A pasted `anchor│` or diff-preview marker was stripped from an anchor field with a warning. |
 | `[E_STALE_ANCHOR]` | An anchor is not owned in this session (it was never shown to you, or its line was edited or the file was rewritten); call `read` for fresh anchors. |
 | `[W_INVALID_PATCH]` | A `replacement_lines` element is a diff-preview row (`+anchor│`, `-anchor│`, `-    │`). The marker is stripped automatically with a warning. |
@@ -249,7 +249,7 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 1,353,139-line hashline limit or the 100MB size limit. |
 | `[E_REGISTRY]` | The anchor registry was not initialized; a serve or edit ran outside an initialized session. |
 | `[E_STORE_UNAVAILABLE]` | No SQLite runtime could be loaded: the host exposes neither `node:sqlite` (Node 22.19+) nor `bun:sqlite`. The pi release binary's bundled Bun lacks `node:sqlite`; run pi under Node or a Bun build that ships SQLite. |
-| `[E_WRITE_HASH_ECHO]` | A `write` `content` line begins with an `anchor│` that was served for this file (any line position). The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
+| `[E_WRITE_HASH_ECHO]` | A `write` `content` line reproduces a served row for this file (a bare `anchor│` read row, a `+anchor│`, ` anchor│`, or `-anchor│` diff row, or a `lineNumber │ anchor│content` grep row). The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
 | `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |
 | `[E_BATCH_OVERLAP]` | Batched `replace`/`insert` calls target overlapping ranges; the whole batch was refused. One `before` plus one `after` insert on the same anchor line is not an overlap. Retry with disjoint ranges. |
 | `[E_OP_ABORTED]` | An edit aborted (a same-message batch member failed, or the file changed or was deleted after the edit started). Nothing was written. Fix the sibling failure and retry the batch, otherwise call `read` for fresh anchors and retry. The abort names the failing call and its error code when one is known. |

package/index.ts

@@ -7,6 +7,7 @@ import { regGrep } from "./src/grep";
 import { regUndo, clearUndo } from "./src/replace-undo";
 import { regRead, fmtReadPreview } from "./src/read";
 import { buildAutoReadAllInjection, autoReadAllBudget } from "./src/auto-read-all";
+import { clearAutoReadAllComplete } from "./src/auto-read-all-state";
 import type { RMetrics } from "./src/replace-response";
 import type { ReplaceDetails } from "./src/replace";
 import { extractWarnings } from "./src/replace-render";
@@ -103,6 +104,7 @@ export default function (pi: ExtensionAPI): void {
   pi.on("session_shutdown", async (_event, ctx) => {
     try {
       const key = sessionKeyFor(ctx);
+      clearAutoReadAllComplete(key);
       if (key !== undefined) releaseRegistrySession(key);
     } catch (error) {
       console.error("Failed to release anchor registry session:", error);
@@ -113,7 +115,7 @@ export default function (pi: ExtensionAPI): void {
     if (autoReadAll === "off" || autoReadAllInjected) return;
     autoReadAllInjected = true;
     try {
-      const injection = await buildAutoReadAllInjection(ctx.cwd, autoReadAllBudget(ctx.model), autoReadAll, autoReadAllIgnore);
+      const injection = await buildAutoReadAllInjection(ctx.cwd, autoReadAllBudget(ctx.model), autoReadAll, autoReadAllIgnore, sessionKeyFor(ctx));
       if (!injection) return;
       if (ctx.hasUI) ctx.ui.notify(`Auto-read all: attached ${injection.files} file(s) with anchors`, "info");
       return { message: { customType: AUTO_READ_ALL_CUSTOM_TYPE, content: injection.text, display: false } };
@@ -124,7 +126,7 @@ export default function (pi: ExtensionAPI): void {
   }));
 
   pi.registerCommand("hashline-config", {
-    description: "Open the hashline settings window (auto-read, auto-read all, ignore folders, diff context, grep, path, strict input, dedup)",
+    description: "Open the hashline settings window (auto-read, auto-read all, ignore folders/files, diff context, grep, path, strict input, dedup)",
     handler: async (_args, ctx) => {
       if (!ctx.hasUI) {
         ctx.ui.notify("/hashline-config requires interactive mode", "error");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.3.3",
+  "version": "4.3.5",
   "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/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 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.
+Read a text file and return it as `anchor│content` rows, one per line: a 4-character anchor (letters only), 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/src/anchor-registry.ts

@@ -659,6 +659,7 @@ export function alignOwnershipWithSpans(
   const state = options?.shadow ? shadowStateFrom(current()!) : current()!;
   const freed: { anchor: string; checksum: string }[] = [];
   const minted: MintedAt[] = [];
+  const reused = new Set<string>();
   const log = (event: RegistryEvent): void => {
     if (!options?.shadow) appendEvent(event);
   };
@@ -671,14 +672,12 @@ export function alignOwnershipWithSpans(
     const start = span.start + offset;
     const end = span.end + offset;
     const spanLength = end - start + 1;
-    const spanFreed: { anchor: string; checksum: string }[] = [];
     for (let i = start; i <= end; i++) {
       const anchor = anchors[i]!;
       if (state.owned.has(anchor)) {
         state.owned.delete(anchor);
         const checksum = prevChecksums[i - offset] ?? "";
-        spanFreed.push({ anchor, checksum });
-        freed.push(spanFreed[spanFreed.length - 1]!);
+        freed.push({ anchor, checksum });
       }
     }
     const replacement: (string | undefined)[] = new Array(span.replacementCount);
@@ -690,10 +689,7 @@ export function alignOwnershipWithSpans(
         (!state.owned.has(positional) || state.owned.get(positional)!.path === path)
       ) {
         replacement[k] = positional;
-        const freedAt = freed.findIndex((candidate) => candidate.anchor === positional);
-        if (freedAt >= 0) freed.splice(freedAt, 1);
-        const pooledAt = spanFreed.findIndex((candidate) => candidate.anchor === positional);
-        if (pooledAt >= 0) spanFreed.splice(pooledAt, 1);
+        reused.add(positional);
       }
     }
     for (let k = 0; k < span.replacementCount; k++) {
@@ -714,8 +710,9 @@ export function alignOwnershipWithSpans(
   }
   const rows: [string, string][] = minted.map((m) => [m.anchor, m.checksum]);
   if (rows.length > 0) log({ kind: "allocate", path, rows });
-  if (freed.length > 0) log({ kind: "free", path, anchors: freed.map((f) => f.anchor) });
-  return { anchors, freed: freed.map((f) => f.anchor), minted: minted.map((m) => m.anchor) };
+  const retained = freed.filter((candidate) => !reused.has(candidate.anchor));
+  if (retained.length > 0) log({ kind: "free", path, anchors: retained.map((f) => f.anchor) });
+  return { anchors, freed: retained.map((f) => f.anchor), minted: minted.map((m) => m.anchor) };
 }
 
 export function alignOwnership(

package/src/auto-read-all-state.ts

@@ -1,13 +1,27 @@
-const completeSnapshots = new Map<string, string>();
-export function recordAutoReadAllComplete(absolutePath: string, snapshotId: string): void {
-  completeSnapshots.set(absolutePath, snapshotId);
+const completeSnapshots = new Map<string, Map<string, string>>();
+
+function scopeFor(sessionKey: string | undefined): string {
+  return sessionKey ?? "";
 }
-export function getAutoReadAllSnapshot(absolutePath: string): string | undefined {
-  return completeSnapshots.get(absolutePath);
+
+export function recordAutoReadAllComplete(sessionKey: string | undefined, absolutePath: string, snapshotId: string): void {
+  const scope = scopeFor(sessionKey);
+  let snapshots = completeSnapshots.get(scope);
+  if (!snapshots) {
+    snapshots = new Map();
+    completeSnapshots.set(scope, snapshots);
+  }
+  snapshots.set(absolutePath, snapshotId);
 }
-export function invalidateAutoReadAllComplete(absolutePath: string): void {
-  completeSnapshots.delete(absolutePath);
+
+export function getAutoReadAllSnapshot(sessionKey: string | undefined, absolutePath: string): string | undefined {
+  return completeSnapshots.get(scopeFor(sessionKey))?.get(absolutePath);
 }
-export function clearAutoReadAllComplete(): void {
+
+export function clearAutoReadAllComplete(sessionKey: string | undefined): void {
+  completeSnapshots.delete(scopeFor(sessionKey));
+}
+
+export function clearAllAutoReadAllComplete(): void {
   completeSnapshots.clear();
 }

package/src/auto-read-all.ts

@@ -13,6 +13,7 @@ import { normalizeAutoReadAllIgnoreEntry, type AutoReadAllMode } from "./config"
 import { serveRows } from "./served";
 import { readNormFile, safeSnapId } from "./file-reader";
 import { resolveRgPath } from "./grep";
+import { globToRegex } from "./glob";
 import { MAX_HASH_LINES } from "./hashline";
 import { fmtReadPreview } from "./read";
 import { splitLines } from "./utils";
@@ -117,12 +118,41 @@ export function normalizeAutoReadAllIgnoreList(entries: readonly string[] | unde
   }
   return out;
 }
+const GLOB_CHARS_RE = /[*?[\]{}]/;
+const GLOB_CACHE_LIMIT = 256;
+const globRegexCache = new Map<string, RegExp | null>();
+
+function globRegexFor(entry: string): RegExp | null {
+  const cached = globRegexCache.get(entry);
+  if (cached !== undefined) return cached;
+  let compiled: RegExp | null;
+  try {
+    compiled = globToRegex(entry);
+  } catch {
+    compiled = null;
+  }
+  if (globRegexCache.size >= GLOB_CACHE_LIMIT) {
+    const oldest = globRegexCache.keys().next().value;
+    if (oldest !== undefined) globRegexCache.delete(oldest);
+  }
+  globRegexCache.set(entry, compiled);
+  return compiled;
+}
+
 export function isExcludedByCustomIgnore(path: string, customIgnore: readonly string[]): boolean {
   if (customIgnore.length === 0) return false;
   const lower = path.toLowerCase();
   const segments = lower.split("/");
+  const base = segments[segments.length - 1] ?? "";
   for (const entry of customIgnore) {
     if (entry.length === 0) continue;
+    if (GLOB_CHARS_RE.test(entry)) {
+      const regex = globRegexFor(entry);
+      if (regex !== null) {
+        if (entry.includes("/") ? regex.test(lower) : regex.test(base)) return true;
+        continue;
+      }
+    }
     if (!entry.includes("/")) {
       if (segments.includes(entry)) return true;
     } else if (lower === entry || lower.startsWith(entry + "/") || lower.includes("/" + entry + "/") || lower.endsWith("/" + entry)) return true;
@@ -389,7 +419,7 @@ function buildFooter(attached: number, discovery: AutoReadAllDiscovery, omitted:
   return `[hashline auto-read-all: ${attached} file(s) attached from ${discovery.source}; ${summary}${omissionNote}]`;
 }
 
-export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number, mode: AutoReadAllMode = "on", ignoreDirs: readonly string[] = []): Promise<AutoReadAllInjection | undefined> {
+export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number, mode: AutoReadAllMode = "on", ignoreDirs: readonly string[] = [], sessionKey?: string): Promise<AutoReadAllInjection | undefined> {
   const discovery = await discoverAutoReadAllFiles(cwd, mode, ignoreDirs);
   if (discovery.files.length === 0) return undefined;
   const sections: AutoReadAllSection[] = [];
@@ -409,7 +439,7 @@ export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number
     }
     sections.push(section);
     const snapshotId = await safeSnapId(section.absolutePath, "auto-read-all");
-    if (snapshotId !== undefined) recordAutoReadAllComplete(section.absolutePath, snapshotId);
+    if (snapshotId !== undefined) recordAutoReadAllComplete(sessionKey, section.absolutePath, snapshotId);
     bytes += sectionBytes;
     completeFiles += 1;
   }

package/src/config-ui.ts

@@ -20,7 +20,7 @@ export function configRows(config: Config): ConfigRow[] {
   return [
     { key: "autoRead", label: "Auto-read", hint: "Anchors after write + post-edit diffs", enabled: config.autoRead !== false },
     { key: "autoReadAll", label: "Auto-read all", hint: "Attach files on the first turn: off, on, git (git repos only)", enabled: (config.autoReadAll ?? "off") !== "off", mode: config.autoReadAll ?? "off", cycle: ["off", "on", "git"] },
-    { key: "autoReadAllIgnore", label: "Ignore folders", hint: "Extra folders skipped by auto-read all (comma-separated)", enabled: (config.autoReadAllIgnore ?? []).length > 0, folders: config.autoReadAllIgnore ?? [] },
+    { key: "autoReadAllIgnore", label: "Ignore folders/files", hint: "Extra folders, files, or globs skipped by auto-read all (comma-separated)", enabled: (config.autoReadAllIgnore ?? []).length > 0, folders: config.autoReadAllIgnore ?? [] },
     { key: "diffContextLines", label: "Diff context", hint: "Surrounding lines in post-edit diffs (needs Auto-read)", enabled: config.autoRead !== false, value: config.diffContextLines ?? 1, disabled: 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 },
@@ -205,7 +205,7 @@ export class HashlineConfigOverlay {
       }
     });
     lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
-    const footer = this.editingIgnore ? " type to edit · Enter save · Esc cancel" : " ↑↓ navigate · space toggle · ←/→ or -/+ adjust · e edit folders · q close";
+    const footer = this.editingIgnore ? " type to edit · Enter save · Esc cancel" : " ↑↓ navigate · space toggle · ←/→ or -/+ adjust · e edit list · q close";
     lines.push(padRow(theme, innerWidth, theme.fg("dim", footer)));
     lines.push(theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
     return lines;

package/src/glob.ts

@@ -0,0 +1,186 @@
+function bracketEnd(source: string, start: number): number {
+  let j = start + 1;
+  if (j < source.length && (source[j] === "!" || source[j] === "^")) j++;
+  if (j < source.length && source[j] === "]") j++;
+  let esc = false;
+  while (j < source.length) {
+    const c = source[j]!;
+    if (esc) {
+      esc = false;
+      j++;
+      continue;
+    }
+    if (c === "\\") {
+      esc = true;
+      j++;
+      continue;
+    }
+    if (c === "]") return j;
+    j++;
+  }
+  return -1;
+}
+function globPartToSource(glob: string): string {
+  let source = "";
+  let i = 0;
+  while (i < glob.length) {
+    const ch = glob[i]!;
+    if (ch === "\\" && i + 1 < glob.length) {
+      const next = glob[i + 1]!;
+      source += next.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      i += 2;
+      continue;
+    }
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        i += 2;
+        if (glob[i] === "/") {
+          i += 1;
+          source += "(?:.*\\/)?";
+        } else {
+          source += ".*";
+        }
+        continue;
+      }
+      source += ".*";
+      i += 1;
+      continue;
+    }
+    if (ch === "?") {
+      source += "[^/]";
+      i += 1;
+      continue;
+    }
+    if (ch === "{") {
+      let depth = 1;
+      let j = i + 1;
+      let esc = false;
+      while (j < glob.length && depth > 0) {
+        const c = glob[j]!;
+        if (esc) {
+          esc = false;
+          j++;
+          continue;
+        }
+        if (c === "\\") {
+          esc = true;
+          j++;
+          continue;
+        }
+        if (c === "[") {
+          const e = bracketEnd(glob, j);
+          if (e >= 0) {
+            j = e + 1;
+            continue;
+          }
+          j++;
+          continue;
+        }
+        if (c === "{") depth++;
+        else if (c === "}") depth--;
+        if (depth === 0) break;
+        j++;
+      }
+      if (depth !== 0) {
+        source += "\\{";
+        i++;
+        continue;
+      }
+      const inner = glob.slice(i + 1, j);
+      const parts: string[] = [];
+      let cur = "";
+      let d2 = 0;
+      let esc2 = false;
+      for (let k = 0; k < inner.length; k++) {
+        const c = inner[k]!;
+        if (esc2) {
+          cur += c;
+          esc2 = false;
+          continue;
+        }
+        if (c === "\\") {
+          esc2 = true;
+          cur += c;
+          continue;
+        }
+        if (c === "[") {
+          const e = bracketEnd(inner, k);
+          if (e >= 0) {
+            cur += inner.slice(k, e + 1);
+            k = e;
+            continue;
+          }
+          cur += c;
+          continue;
+        }
+        if (c === "{") {
+          d2++;
+          cur += c;
+          continue;
+        }
+        if (c === "}") {
+          d2--;
+          cur += c;
+          continue;
+        }
+        if (c === "," && d2 === 0) {
+          parts.push(cur);
+          cur = "";
+          continue;
+        }
+        cur += c;
+      }
+      parts.push(cur);
+      if (parts.length <= 1) {
+        source += "\\{" + globPartToSource(inner) + "\\}";
+      } else {
+        source += "(?:" + parts.map((p) => globPartToSource(p)).join("|") + ")";
+      }
+      i = j + 1;
+      continue;
+    }
+    if (ch === "[") {
+      let j = i + 1;
+      if (j < glob.length && (glob[j] === "!" || glob[j] === "^")) j++;
+      if (j < glob.length && glob[j] === "]") j++;
+      let esc3 = false;
+      while (j < glob.length) {
+        const c = glob[j]!;
+        if (esc3) {
+          esc3 = false;
+          j++;
+          continue;
+        }
+        if (c === "\\") {
+          esc3 = true;
+          j++;
+          continue;
+        }
+        if (c === "]") break;
+        j++;
+      }
+      if (j >= glob.length) {
+        source += "\\[";
+        i++;
+        continue;
+      }
+      let content = glob.slice(i + 1, j);
+      if (content.startsWith("!")) content = "^" + content.slice(1);
+      if (content.startsWith("]") || content.startsWith("^]")) {
+        if (content.startsWith("^]")) content = "^\\]" + content.slice(2);
+        else content = "\\]" + content.slice(1);
+      }
+      if (content.startsWith("^") && !content.includes("/")) content = "^/" + content.slice(1);
+      source += "[" + content + "]";
+      i = j + 1;
+      continue;
+    }
+    source += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    i++;
+  }
+  return source;
+}
+export function globToRegex(glob: string): RegExp {
+  if (glob.startsWith("/")) glob = glob.slice(1);
+  return new RegExp(`^${globPartToSource(glob)}$`);
+}

package/src/grep.ts

@@ -3,10 +3,12 @@ import { formatSize, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type TruncationResult
 import { Type } from "typebox";
 import { stat } from "node:fs/promises";
 import { dirname, isAbsolute, join, win32 } from "node:path";
+import { pathToFileURL } from "node:url";
 import { spawn, spawnSync } from "node:child_process";
 import { createInterface } from "node:readline";
 import { tryReadNormFile } from "./file-reader";
-import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP } from "./hashline";
+import { globToRegex } from "./glob";
+import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP, HASH_CLASS } from "./hashline";
 import { ANCHOR_POOL_EXHAUSTED_PREFIX, MAX_GREP_LINE_BYTES } from "./constants";
 import { toCwd, toDisplayPath } from "./paths";
 import { loadP, loadGuide } from "./prompts";
@@ -152,193 +154,6 @@ function assertSafeRegex(pattern: string): void {
   }
 }
 
-function bracketEnd(source: string, start: number): number {
-  let j = start + 1;
-  if (j < source.length && (source[j] === "!" || source[j] === "^")) j++;
-  if (j < source.length && source[j] === "]") j++;
-  let esc = false;
-  while (j < source.length) {
-    const c = source[j]!;
-    if (esc) {
-      esc = false;
-      j++;
-      continue;
-    }
-    if (c === "\\") {
-      esc = true;
-      j++;
-      continue;
-    }
-    if (c === "]") return j;
-    j++;
-  }
-  return -1;
-}
-function globPartToSource(glob: string): string {
-  let source = "";
-  let i = 0;
-  while (i < glob.length) {
-    const ch = glob[i]!;
-    if (ch === "\\" && i + 1 < glob.length) {
-      const next = glob[i + 1]!;
-      source += next.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      i += 2;
-      continue;
-    }
-    if (ch === "*") {
-      if (glob[i + 1] === "*") {
-        i += 2;
-        if (glob[i] === "/") {
-          i += 1;
-          source += "(?:.*\\/)?";
-        } else {
-          source += ".*";
-        }
-        continue;
-      }
-      source += ".*";
-      i += 1;
-      continue;
-    }
-    if (ch === "?") {
-      source += "[^/]";
-      i += 1;
-      continue;
-    }
-    if (ch === "{") {
-      let depth = 1;
-      let j = i + 1;
-      let esc = false;
-      while (j < glob.length && depth > 0) {
-        const c = glob[j]!;
-        if (esc) {
-          esc = false;
-          j++;
-          continue;
-        }
-        if (c === "\\") {
-          esc = true;
-          j++;
-          continue;
-        }
-        if (c === "[") {
-          const e = bracketEnd(glob, j);
-          if (e >= 0) {
-            j = e + 1;
-            continue;
-          }
-          j++;
-          continue;
-        }
-        if (c === "{") depth++;
-        else if (c === "}") depth--;
-        if (depth === 0) break;
-        j++;
-      }
-      if (depth !== 0) {
-        source += "\\{";
-        i++;
-        continue;
-      }
-      const inner = glob.slice(i + 1, j);
-      const parts: string[] = [];
-      let cur = "";
-      let d2 = 0;
-      let esc2 = false;
-      for (let k = 0; k < inner.length; k++) {
-        const c = inner[k]!;
-        if (esc2) {
-          cur += c;
-          esc2 = false;
-          continue;
-        }
-        if (c === "\\") {
-          esc2 = true;
-          cur += c;
-          continue;
-        }
-        if (c === "[") {
-          const e = bracketEnd(inner, k);
-          if (e >= 0) {
-            cur += inner.slice(k, e + 1);
-            k = e;
-            continue;
-          }
-          cur += c;
-          continue;
-        }
-        if (c === "{") {
-          d2++;
-          cur += c;
-          continue;
-        }
-        if (c === "}") {
-          d2--;
-          cur += c;
-          continue;
-        }
-        if (c === "," && d2 === 0) {
-          parts.push(cur);
-          cur = "";
-          continue;
-        }
-        cur += c;
-      }
-      parts.push(cur);
-      if (parts.length <= 1) {
-        source += "\\{" + globPartToSource(inner) + "\\}";
-      } else {
-        source += "(?:" + parts.map((p) => globPartToSource(p)).join("|") + ")";
-      }
-      i = j + 1;
-      continue;
-    }
-    if (ch === "[") {
-      let j = i + 1;
-      if (j < glob.length && (glob[j] === "!" || glob[j] === "^")) j++;
-      if (j < glob.length && glob[j] === "]") j++;
-      let esc3 = false;
-      while (j < glob.length) {
-        const c = glob[j]!;
-        if (esc3) {
-          esc3 = false;
-          j++;
-          continue;
-        }
-        if (c === "\\") {
-          esc3 = true;
-          j++;
-          continue;
-        }
-        if (c === "]") break;
-        j++;
-      }
-      if (j >= glob.length) {
-        source += "\\[";
-        i++;
-        continue;
-      }
-      let content = glob.slice(i + 1, j);
-      if (content.startsWith("!")) content = "^" + content.slice(1);
-      if (content.startsWith("]") || content.startsWith("^]")) {
-        if (content.startsWith("^]")) content = "^\\]" + content.slice(2);
-        else content = "\\]" + content.slice(1);
-      }
-      if (content.startsWith("^") && !content.includes("/")) content = "^/" + content.slice(1);
-      source += "[" + content + "]";
-      i = j + 1;
-      continue;
-    }
-    source += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-    i++;
-  }
-  return source;
-}
-function globToRegex(glob: string): RegExp {
-  if (glob.startsWith("/")) glob = glob.slice(1);
-  return new RegExp(`^${globPartToSource(glob)}$`);
-}
-
 interface FileHit {
   path: string;
   displayPath: string;
@@ -462,10 +277,9 @@ export async function resolveRgPath(): Promise<string> {
     const { createRequire } = await import("node:module");
     const require = createRequire(import.meta.url);
     const pkgPath = require.resolve("@earendil-works/pi-coding-agent/package.json");
-    const { dirname } = await import("node:path");
     const piDir = dirname(pkgPath);
     const toolsManagerPath = join(piDir, "dist/utils/tools-manager.js");
-    const mod = await import("file://" + toolsManagerPath);
+    const mod = await import(pathToFileURL(toolsManagerPath).href);
     if (mod.ensureTool) {
       const p = await mod.ensureTool("rg", true);
       if (p) { cachedRgPath = p; return p; }
@@ -654,7 +468,7 @@ function highlightMatches(text: string, regex: RegExp, theme: FgT): string {
   return out + text.slice(last);
 }
 
-const ANCHORED_ROW_RE = /^[A-Za-z0-9]{4}│/;
+const ANCHORED_ROW_RE = new RegExp(`^${HASH_CLASS}${HASH_SEP}`);
 
 function highlightHitRow(row: string, highlight: RegExp, theme: FgT): string {
   const anchored = row.match(ANCHORED_ROW_RE);

package/src/hash-store.ts

@@ -117,7 +117,6 @@ interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
   getState: (...params: SqlParams) => Record<string, unknown> | undefined;
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
-  allHashes: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
   undoUpsert: (...params: SqlParams) => void;
@@ -205,7 +204,6 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
   const getStateStmt = db.prepare("SELECT checksum, hashes, line_checksums FROM snapshots WHERE path = ?");
   const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo");
-  const allHashesStmt = db.prepare("SELECT path, hashes FROM snapshots");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
   const upsertStmt = db.prepare(
     "INSERT INTO snapshots (path, checksum, line_count, hashes, line_checksums, updated_at) VALUES (?, ?, ?, ?, ?, ?) " +
@@ -224,8 +222,7 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   const stmts: Prepared = {
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     getState: (...params) => getStateStmt.get(...params) as Record<string, unknown> | undefined,
-    allPaths: (...params) => allStmt.all(...params) as Record<string, unknown>[],
-    allHashes: (...params) => allHashesStmt.all(...params) as Record<string, unknown>[],
+    allPaths: (...params) => withBusyRetry(() => allStmt.all(...params) as Record<string, unknown>[]),
     deleteOne: retriedWrite(delStmt),
     upsert: retriedWrite(upsertStmt),
     undoUpsert: retriedWrite(undoUpsertStmt),

package/src/hashline/alphabet.ts

@@ -6,13 +6,13 @@ if (typeof rawAnchors !== "string" || rawAnchors.length === 0 || rawAnchors.leng
 const TABLE: string = rawAnchors;
 export const HASH_LEN = 4;
 export const ANCHOR_COUNT = TABLE.length / HASH_LEN;
-const ALNUM = "A-Za-z0-9";
+const LETTERS = "A-Za-z";
 
-export const ALPH_RE = new RegExp(`^[${ALNUM}]+$`);
+export const ALPH_RE = new RegExp(`^[${LETTERS}]+$`);
 
-export const HASH_CLASS = `[${ALNUM}]{${HASH_LEN}}`;
+export const HASH_CLASS = `[${LETTERS}]{${HASH_LEN}}`;
 
-export const HASH_RUN = `[${ALNUM}]{${HASH_LEN},${HASH_LEN + 1}}`;
+export const HASH_RUN = `[${LETTERS}]{${HASH_LEN},${HASH_LEN + 1}}`;
 
 export const HASH_RE = new RegExp(`^${HASH_CLASS}$`);
 

package/src/hashline/parse.ts

@@ -13,7 +13,7 @@ function diagRef(ref: string): string {
 	const trimmed = ref.trim();
 
 	if (!trimmed.length) {
-		return `[E_BAD_REF] Invalid anchor. Expected a 4-char alphanumeric anchor (e.g. "Hasu").`;
+		return `[E_BAD_REF] Invalid anchor. Expected a 4-character anchor (letters only, e.g. "Hasu").`;
 	}
 
 	if (/^\d+/.test(trimmed)) {
@@ -29,13 +29,13 @@ function diagRef(ref: string): string {
 		const firstHash = firstMatch?.[0] ?? "Hasu";
 		const lastHash = lastMatch?.[0] ?? "Hasu";
 		const preview = first.slice(0, 60);
-		return `[E_BAD_REF] Invalid anchor — remove_from and remove_to must each be a single bare 4-char hash (e.g. "Hasu"), not a block with HASH│content. Received ${lines.length} lines starting "${preview}…" — use only the first hash "${firstHash}" as remove_from and "${lastHash}" as remove_to, and put the new content (without HASH│) in replacement_lines.`;
+		return `[E_BAD_REF] Invalid anchor — remove_from and remove_to must each be a single bare 4-character anchor (letters only, e.g. "Hasu"), not a block with HASH│content. Received ${lines.length} lines starting "${preview}…" — use only the first hash "${firstHash}" as remove_from and "${lastHash}" as remove_to, and put the new content (without HASH│) in replacement_lines.`;
 	}
 	if (trimmed.includes("│")) {
-		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 4-char anchor, drop everything from "│" onward.`;
+		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 4-character anchor, drop everything from "│" onward.`;
 	}
 
-	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 4-char alphanumeric anchor (e.g. "Hasu").`;
+	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 4-character anchor (letters only, e.g. "Hasu").`;
 }
 
 function parseRef(ref: string): Anchor {

package/src/read.ts

@@ -19,7 +19,7 @@ import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-
 import { valAccess } from "./validation";
 import { readConfig } from "./config";
 import { resolveTarget } from "./fs-write";
-import { withAnchorSession, servedForPath } from "./anchor-registry";
+import { withAnchorSession, servedForPath, sessionKeyFor } from "./anchor-registry";
 import { serveRows } from "./served";
 import { getAutoReadAllSnapshot } from "./auto-read-all-state";
 import { Text } from "@earendil-works/pi-tui";
@@ -217,7 +217,7 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
                 if (autoReadAllMode !== "off") {
                   const canonical = await resolveTarget(absolutePath).catch(() => undefined);
                   if (canonical !== undefined) {
-                    const stored = getAutoReadAllSnapshot(canonical);
+                    const stored = getAutoReadAllSnapshot(sessionKeyFor(ctx), canonical);
                     if (stored !== undefined) {
                       const current = await safeSnapId(canonical, "auto-read-all guard");
                       if (current !== undefined && current === stored) {

package/src/replace-diff.ts

@@ -4,6 +4,7 @@ import {
   _lineHashesPure,
   ANCHOR_LEN,
   HASH_SEP,
+  HASH_CLASS,
   changedRange,
 } from "./hashline";
 import { MAX_DIFF_INPUT_BYTES, DEDUP_ANCHOR } from "./constants";
@@ -111,7 +112,7 @@ export function spansFromHashes(oldHashes: string[], newHashes: string[]): DiffS
   return spans;
 }
 
-const ANCHORED_DIFF_ROW_RE = /^([+ -])([A-Za-z0-9]{4})│/;
+const ANCHORED_DIFF_ROW_RE = new RegExp(`^([+ -])(${HASH_CLASS})│`);
 
 export function disambiguateDuplicateAnchors(diff: string): string {
   if (!diff.includes("│")) return diff;

package/src/utils.ts

@@ -1,4 +1,5 @@
 import { NUL_CONTENT_MSG } from "./constants";
+import { HASH_CLASS } from "./hashline/alphabet";
 
 export function isRec(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -20,6 +21,14 @@ export function normalizeAnchors(record: Record<string, unknown>): void {
     record.remove_to = record.replace_to;
     delete record.replace_to;
   }
+  if (typeof record.remove_from !== "string" && typeof record.from === "string") {
+    record.remove_from = record.from;
+    delete record.from;
+  }
+  if (typeof record.remove_to !== "string" && typeof record.to === "string") {
+    record.remove_to = record.to;
+    delete record.to;
+  }
 }
 
 export function normalizeRequest(input: unknown): unknown {
@@ -133,8 +142,10 @@ export function getCached<K, V>(map: Map<K, V>, key: K, compute: (key: K) => V):
 	return v;
 }
 
+const HASH_ROW_RE = new RegExp(`^${HASH_CLASS}│`);
+
 export function isHashRow(line: string): boolean {
-	return /^[A-Za-z0-9]{4}│/.test(line);
+	return HASH_ROW_RE.test(line);
 }
 
 export function gutterWidth(max: number, fallback: number): number {

package/src/write-hook.ts

@@ -5,7 +5,7 @@ import { servedForPath, withAnchorSession } from "./anchor-registry";
 import { resolveInCwd } from "./fs-write";
 import { abortIf, splitLines, isRec, normalizeFilePath } from "./utils";
 
-const HASH_ECHO_RE = new RegExp(`^(${HASH_CLASS})${HASH_SEP}`);
+const HASH_ECHO_RE = new RegExp(`^(?: *[0-9]+ ${HASH_SEP} )?[+ -]?(${HASH_CLASS})${HASH_SEP}`);
 
 function searchEcho(lines: string[], served: ReadonlyMap<string, string> | ReadonlySet<string>): { line: number; hash: string } | undefined {
   for (let i = 0; i < lines.length; i++) {
@@ -27,7 +27,7 @@ export async function servedHashEchoDenial(rawPath: string, content: string, cwd
   if (!served || served.size === 0) return undefined;
   const echo = findServedHashEcho(content, served);
   if (!echo) return undefined;
-  return `[E_WRITE_HASH_ECHO] Refused write to ${rawPath}: line ${echo.line} begins with the exact ${echo.hash}${HASH_SEP} anchor served for this file. Remove the copied anchors and retry.`;
+  return `[E_WRITE_HASH_ECHO] Refused write to ${rawPath}: line ${echo.line} contains the copied ${echo.hash}${HASH_SEP} anchor served for this file. Remove the copied anchors and retry.`;
 }
 
 export function registerWriteHook(pi: ExtensionAPI): void {