pi-hashline-edit-pro 2.8.0 → 2.8.1

package/README.md

@@ -148,6 +148,7 @@ Notes:
 Notes:
 - Results are grouped per file under a `=== path ===` header; every shown row carries the anchor it would have in `read` output.
 - Directory searches skip `node_modules`, `.git`, `.tmp`, and `coverage`. Binary, image, and oversized files are skipped silently.
+- Regex patterns with backreferences, nested quantifiers, quantified alternation, or multiple variable quantifiers are rejected with `[E_UNSAFE_REGEX]` before any files are scanned; use `literal: true` when regex behavior is unnecessary.
 - Output is capped at `limit` matched lines, 2000 rows, and 50KB of text (whichever comes first), with a hint naming the cap that cut results. A matched line longer than 500 bytes is shown as a fragment around the match with `...` marking the truncated sides, so the relevant part of the hit stays visible; a context line over 500 bytes is shown as its head with a trailing `...`. Fragments keep the line's anchor (long lines are hashed from their first 500 bytes) and are served like full rows, so a fragmented match is still editable with `replace` (which always replaces the whole line). Directory scans stop after 4000 files with a hint; results may be incomplete.
 - `file_path` works as an alias for `path`.
 - Line endings and BOMs survive every edit. The file's line ending is detected from its first newline and restored on write; a file that mixes LF and CRLF (for example a WSL-edited file) is normalized to the first-seen ending.
@@ -206,6 +207,8 @@ Anchors are unique by construction. If a line's base hash collides with an alrea
 
 Hashes live in a persistent per-file store (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) that keeps the hashes of unchanged lines across edits. When a range is replaced, the runtime maps the old content onto the new content and copies hashes for lines that survived; only genuinely new lines get fresh hashes.
 
+On POSIX systems, the state directory is restricted to mode `0700` and the SQLite database plus its WAL/SHM sidecars to `0600`. The undo table contains the complete pre-edit and post-edit text for the latest edit to each file, so the store should still be treated as sensitive data.
+
 The store also keeps a per-file record of the hashes the model was last served (`read` rows, auto-read blocks, post-edit diff rows), pruned to the file's current hashes on every update so removed lines' hashes do not accumulate. `replace` verifies every line of the resolved range against that record before writing; a line whose hash is missing from the record means it either changed on disk after it was shown or was never shown, and the edit is refused with `[E_RANGE_STALE]`. A `write` clears the record, so edits after a write are verified against whatever the next `read` or auto-read block serves.
 
 Two guarantees make this safe even with duplicated content:
@@ -236,6 +239,8 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 | `[E_BOUNDARY_BYPASS]` | The boundary anti-duplication was turned off for one replace call (an identical replacement had previously been cut to a noop); the duplicate lines were applied literally. The dedup is restored for the next call. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 238,328-line hashline limit or the 100MB size limit. |
 | `[E_WRITE_HASH_ECHO]` | A `write` `content` line begins with the exact `anchor│` served for this file at the same line. The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
+| `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |
+| `[E_UNSAFE_REGEX]` | A grep regex can trigger excessive backtracking; simplify it or search with `literal: true`. |
 
 ## Troubleshooting
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.8.0",
+  "version": "2.8.1",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 3-char hash (A-Za-z0-9) that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",
@@ -39,8 +39,8 @@
     ]
   },
   "dependencies": {
-    "diff": "^8.0.2",
-    "file-type": "^21.3.0",
+    "diff": "^9.0.0",
+    "file-type": "^22.0.2",
     "typebox": "^1.3.7",
     "xxhash-wasm": "^1.1.0"
   },
@@ -63,12 +63,12 @@
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",
     "@eslint/js": "^10.0.1",
-    "@types/node": "^24.0.0",
-    "@vitest/coverage-v8": "^4.1.10",
-    "eslint": "^10.7.0",
-    "typescript": "^5.8.0",
-    "typescript-eslint": "^8.65.0",
-    "vitest": "^4.1.8"
+    "@types/node": "^24",
+    "@vitest/coverage-v8": "^4.1.11",
+    "eslint": "^10.9.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.68.0",
+    "vitest": "^4.1.11"
   },
   "allowScripts": {
     "@google/genai@1.52.0": true,

package/src/commit.ts

@@ -5,7 +5,7 @@ import { saveUndo } from "./replace-undo";
 import { safeSnapId } from "./file-reader";
 import { writeAtomic } from "./fs-write";
 import { recordServedDiffSafe } from "./served";
-import { restoreEndings } from "./replace-diff";
+import { restoreEndings } from "./normalize";
 
 export interface CommitMeta {
   path: string;
@@ -72,6 +72,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     await writeAtomic(
       absolutePath,
       pipe.bom + restoreEndings(pipe.result, pipe.originalEnding),
+      pipe.identity,
     );
   } catch (error) {
     await undo.restore();

package/src/edit-common.ts

@@ -0,0 +1,45 @@
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { resolveInCwd } from "./fs-write";
+import { abortIf, makePrepareArguments } from "./utils";
+import { makeRenderCall, renderEditResult, type RPreview, type FgT } from "./replace-render";
+import type { ReplaceDetails } from "./replace";
+
+export const editPrepare = makePrepareArguments();
+
+export function editRenderResultWrapper(
+  result: { content?: Array<{ type: string; text?: string }>; details?: ReplaceDetails },
+  opts: { isPartial: boolean; expanded?: boolean } | boolean,
+  theme: FgT,
+  context: any,
+) {
+  return renderEditResult(result, opts, theme, context);
+}
+
+export function editRenderCallWrapper(
+  preview: (args: unknown, cwd: string) => Promise<RPreview>,
+  getInput?: (args: unknown) => { path?: string } | null,
+  toolName?: string,
+) {
+  return makeRenderCall(preview, { getInput, toolName });
+}
+
+export const editToolBase = {
+  prepareArguments: editPrepare,
+  executionMode: "sequential" as const,
+  renderShell: "default" as const,
+};
+
+export async function queuedEdit<T>(
+  path: string,
+  cwd: string,
+  signal: AbortSignal | undefined,
+  work: (absolute: string, resolved: string) => Promise<T>,
+): Promise<T> {
+  abortIf(signal);
+  const { absolute, resolved } = await resolveInCwd(path, cwd);
+  return withFileMutationQueue(resolved, async () => {
+    abortIf(signal);
+    return work(absolute, resolved);
+  });
+}
+

package/src/file-kind.ts

@@ -2,6 +2,7 @@ import { open as fsOpen, stat as fsStat } from "fs/promises";
 import { fileTypeFromBuffer } from "file-type";
 import { SNIFF_BYTES, MAX_BYTES } from "./constants";
 import { assertLineLimit, lineLimitMoreThanMessage } from "./utils";
+import type { FileIdentity } from "./fs-write";
 
 const IMG_TYPES = new Set<string>([
   "image/bmp",
@@ -54,7 +55,7 @@ function looksLikeText(sample: Uint8Array): boolean {
 export type LFile =
   | { kind: "directory" }
   | { kind: "image"; mimeType: string }
-  | { kind: "text"; text: string; hadUtf8DecodeErrors?: true }
+  | { kind: "text"; text: string; identity?: FileIdentity; hadUtf8DecodeErrors?: true }
   | { kind: "binary"; description: string }
   | { kind: "too_large"; description: string };
 
@@ -87,6 +88,8 @@ export async function loadFileKindAndText(
 
   const fileHandle = await fsOpen(filePath, "r");
   try {
+    const openedStats = await fileHandle.stat();
+    const identity = { dev: openedStats.dev, ino: openedStats.ino };
     const buffer = Buffer.alloc(SNIFF_BYTES);
     const { bytesRead } = await fileHandle.read(
       buffer,
@@ -95,7 +98,7 @@ export async function loadFileKindAndText(
       0,
     );
     if (bytesRead === 0) {
-      return { kind: "text", text: "" };
+      return { kind: "text", text: "", identity };
     }
 
     const sample = buffer.subarray(0, bytesRead);
@@ -179,6 +182,7 @@ export async function loadFileKindAndText(
     return {
       kind: "text",
       text,
+      identity,
       ...(hadUtf8DecodeErrors ? { hadUtf8DecodeErrors: true as const } : {}),
     };
   } finally {

package/src/file-reader.ts

@@ -3,9 +3,9 @@ import { stat } from "fs/promises";
 import { relative } from "path";
 import { lineHashes } from "./hashline";
 import { loadFileKindAndText, type LFile } from "./file-kind";
-import { resolveTarget } from "./fs-write";
+import { resolveTarget, type FileIdentity } from "./fs-write";
 import { toCwd } from "./paths";
-import { detectEnding, toLF, stripBOM, type LineEnding } from "./replace-diff";
+import { detectEnding, toLF, stripBOM, type LineEnding } from "./normalize";
 import { abortIf, errCode, assertLineLimit } from "./utils";
 import { valKind, valAccess } from "./validation";
 import type { HashStore } from "./hash-store";
@@ -16,6 +16,7 @@ export interface NormFile {
   originalEnding: LineEnding;
   fileHashes: string[];
   hadUtf8DecodeErrors: boolean;
+  identity: FileIdentity;
 }
 
 export type SnapInfo = {
@@ -94,12 +95,18 @@ export async function readNormFile(
   if (options?.maxLines !== undefined) assertLineLimit(normalized, path, options.maxLines);
 
   const fileHashes = await lineHashes(normalized, resolvedPath, undefined, options?.store, options?.noPersist !== true);
+  let identity = file.identity;
+  if (!identity) {
+    const { dev, ino } = await stat(resolvedPath);
+    identity = { dev, ino };
+  }
   return {
     absolutePath: resolvedPath,
     normalized,
     bom,
     originalEnding,
     fileHashes,
+    identity,
     hadUtf8DecodeErrors: file.hadUtf8DecodeErrors === true,
   };
 }

package/src/fs-write.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "crypto";
+import { constants } from "fs";
 import {
-	chmod,
 	lstat,
 	mkdir,
 	open,
@@ -15,6 +15,22 @@ import { dirname, join, parse, resolve, sep } from "path";
 import { toCwd } from "./paths";
 import { errCode } from "./utils";
 
+export interface FileIdentity {
+  dev: number;
+  ino: number;
+}
+
+function sameIdentity(
+  actual: Pick<Awaited<ReturnType<typeof stat>>, "dev" | "ino">,
+  expected: FileIdentity,
+): boolean {
+  return actual.dev === expected.dev && actual.ino === expected.ino;
+}
+
+function pathChanged(path: string): Error {
+  return new Error(`[E_PATH_CHANGED] Refusing to write ${path}: the target changed after it was read.`);
+}
+
 export async function resolveTarget(path: string): Promise<string> {
   const absolutePath = resolve(path);
   const { root } = parse(absolutePath);
@@ -128,6 +144,7 @@ export async function resolveInCwd(path: string, cwd: string): Promise<{ absolut
 export async function writeAtomic(
   path: string,
   content: string,
+  expectedIdentity?: FileIdentity,
 ): Promise<void> {
   const targetPath = await resolveTarget(path);
 
@@ -140,19 +157,25 @@ export async function writeAtomic(
     }
   }
 
+  if (expectedIdentity && (!existingStats || !sameIdentity(existingStats, expectedIdentity))) {
+    throw pathChanged(path);
+  }
+
   if (existingStats && existingStats.nlink > 1) {
-    await writeFile(targetPath, content, "utf-8");
-    try {
-      await chmod(targetPath, existingStats.mode & 0o7777);
-    } catch {}
+    const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
+    const handle = await open(targetPath, constants.O_WRONLY | noFollow);
     try {
-      const handle = await open(targetPath, "r");
+      const openedStats = await handle.stat();
+      if (!sameIdentity(openedStats, existingStats)) throw pathChanged(path);
+      await handle.writeFile(content, "utf-8");
+      await handle.truncate(Buffer.byteLength(content, "utf-8"));
       try {
-        await handle.sync();
-      } finally {
-        await handle.close();
-      }
-    } catch {}
+        await handle.chmod(existingStats.mode & 0o7777);
+      } catch {}
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
     return;
   }
 
@@ -174,6 +197,14 @@ export async function writeAtomic(
   }
   try {
     await tempHandle.close();
+    try {
+      const finalStats = await lstat(targetPath);
+      if (!existingStats || finalStats.isSymbolicLink() || !sameIdentity(finalStats, existingStats)) {
+        throw pathChanged(path);
+      }
+    } catch (error) {
+      if (errCode(error) !== "ENOENT" || existingStats) throw error;
+    }
     await rename(tempPath, targetPath);
     await syncDir(dir);
   } catch (error: unknown) {

package/src/grep.ts

@@ -47,6 +47,7 @@ export function assertGrepReq(request: unknown): asserts request is GrepReq {
 }
 
 function buildRegex(pattern: string, literal: boolean, ignoreCase: boolean): RegExp {
+  if (!literal) assertSafeRegex(pattern);
   const source = literal ? pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : pattern;
   try {
     return new RegExp(source, ignoreCase ? "ui" : "u");
@@ -55,6 +56,95 @@ function buildRegex(pattern: string, literal: boolean, ignoreCase: boolean): Reg
   }
 }
 
+interface RegexGroupRisk {
+  hasQuantifier: boolean;
+  hasAlternation: boolean;
+}
+
+function unsafeRegex(pattern: string): never {
+  throw new Error(
+    `[E_UNSAFE_REGEX] Refusing potentially exponential regex: ${pattern}. Use literal: true or simplify the expression.`,
+  );
+}
+
+function assertSafeRegex(pattern: string): void {
+  if (pattern.length > 4096) unsafeRegex(pattern);
+
+  const groups: RegexGroupRisk[] = [];
+  let inClass = false;
+  let escaped = false;
+  let variableQuantifiers = 0;
+  let lastAtom: { groupRisky: boolean; quantified: boolean } | undefined;
+
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i]!;
+    if (escaped) {
+      if (!inClass && (/[1-9]/.test(ch) || (ch === "k" && pattern[i + 1] === "<"))) {
+        unsafeRegex(pattern);
+      }
+      escaped = false;
+      lastAtom = { groupRisky: false, quantified: false };
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (inClass) {
+      if (ch === "]") {
+        inClass = false;
+        lastAtom = { groupRisky: false, quantified: false };
+      }
+      continue;
+    }
+    if (ch === "[") {
+      inClass = true;
+      continue;
+    }
+    if (ch === "(") {
+      groups.push({ hasQuantifier: false, hasAlternation: false });
+      lastAtom = undefined;
+      continue;
+    }
+    if (ch === ")") {
+      const group = groups.pop();
+      if (group) {
+        lastAtom = {
+          groupRisky: group.hasQuantifier || group.hasAlternation,
+          quantified: false,
+        };
+      }
+      continue;
+    }
+    if (ch === "|") {
+      const group = groups.at(-1);
+      if (group) group.hasAlternation = true;
+      lastAtom = undefined;
+      continue;
+    }
+
+    let quantifierLength = 0;
+    if (ch === "*" || ch === "+" || ch === "?") {
+      quantifierLength = 1;
+    } else if (ch === "{") {
+      quantifierLength = /^\{\d+(?:,\d*)?\}/.exec(pattern.slice(i))?.[0].length ?? 0;
+    }
+    if (quantifierLength > 0 && lastAtom) {
+      if (ch === "?" && lastAtom.quantified) continue;
+      const variable = ch !== "{" || pattern.slice(i, i + quantifierLength).includes(",");
+      if (variable && ++variableQuantifiers > 1) unsafeRegex(pattern);
+      if (lastAtom.groupRisky) unsafeRegex(pattern);
+      const group = groups.at(-1);
+      if (group) group.hasQuantifier = true;
+      lastAtom.quantified = true;
+      i += quantifierLength - 1;
+      continue;
+    }
+
+    lastAtom = { groupRisky: false, quantified: false };
+  }
+}
+
 function globToRegex(glob: string): RegExp {
   if (glob.startsWith("/")) glob = glob.slice(1);
   let source = "";
@@ -138,10 +228,12 @@ async function walkFiles(
   root: string,
   state: ScanState,
   onFile: (absPath: string) => Promise<void>,
+  signal?: AbortSignal,
 ): Promise<void> {
   const queue: string[] = [root];
   let head = 0;
   while (head < queue.length && !state.stopped) {
+    abortIf(signal);
     const dir = queue[head++]!;
     let entries;
     try {
@@ -150,8 +242,10 @@ async function walkFiles(
       continue;
     }
     entries.sort((a, b) => cmp(a.name, b.name));
-    for (const entry of entries) {
+    for (let ei = 0; ei < entries.length; ei++) {
+      if ((ei & 127) === 0) abortIf(signal);
       if (state.stopped) break;
+      const entry = entries[ei]!;
       const full = join(dir, entry.name);
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
@@ -176,17 +270,20 @@ async function searchFile(
   globRegex: RegExp | undefined,
   context: number,
   maxMatches: number,
+  signal?: AbortSignal,
 ): Promise<FileHit | undefined> {
   const displayPath = relative(cwd, absPath).replace(/\\/g, "/");
   if (globRegex) {
     const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
     if (!globRegex.test(globPath) && !globRegex.test(displayPath)) return undefined;
   }
-  const norm = await tryReadNormFile(absPath, cwd, { maxLines: MAX_HASH_LINES, noPersist: true });
+  const norm = await tryReadNormFile(absPath, cwd, { maxLines: MAX_HASH_LINES, noPersist: true, signal });
   if (!norm) return undefined;
   const lines = visLines(norm.normalized);
   const matchLines: number[] = [];
   for (let i = 0; i < lines.length; i++) {
+    if ((i & 1023) === 0) abortIf(signal);
+    if (i !== 0 && (i & 4095) === 0) await new Promise<void>((r) => setImmediate(r));
     if (regex.test(lines[i]!)) matchLines.push(i);
   }
   if (matchLines.length === 0) return undefined;
@@ -306,7 +403,7 @@ export function regGrep(pi: ExtensionAPI): void {
       } else {
         await walkFiles(base, state, async (absPath) => {
           files.push(absPath);
-        });
+        }, signal);
         files.sort(cmp);
       }
       const hits: FileHit[] = [];
@@ -324,7 +421,7 @@ export function regGrep(pi: ExtensionAPI): void {
         abortIf(signal);
         const absPath = files[f]!;
         if (countOnly) {
-          const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, Number.MAX_SAFE_INTEGER);
+          const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, Number.MAX_SAFE_INTEGER, signal);
           if (!hit) continue;
           totalRows += hit.rows.length;
           for (const row of hit.rows) totalBytes += Buffer.byteLength(row, "utf-8") + 1;
@@ -342,7 +439,7 @@ export function regGrep(pi: ExtensionAPI): void {
           limitTruncated = true;
           break;
         }
-        const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, remaining);
+        const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, remaining, signal);
         if (!hit) continue;
         const keptRows: string[] = [];
         const keptHashes: string[] = [];

package/src/hash-store/cache.ts

@@ -0,0 +1,18 @@
+export interface SnapshotCacheEntry {
+  checksum: string;
+  lineCount: number;
+  hashes: string[];
+}
+
+export const SNAPSHOT_CACHE_LIMIT = 256;
+
+export const snapshotCache = new Map<string, SnapshotCacheEntry>();
+
+export function cacheSnapshot(path: string, checksum: string, lineCount: number, hashes: string[]): void {
+  snapshotCache.delete(path);
+  snapshotCache.set(path, { checksum, lineCount, hashes: hashes.slice() });
+  if (snapshotCache.size > SNAPSHOT_CACHE_LIMIT) {
+    const oldest = snapshotCache.keys().next().value;
+    if (oldest !== undefined) snapshotCache.delete(oldest);
+  }
+}

package/src/hash-store/retry.ts

@@ -0,0 +1,48 @@
+import { isBusyError } from "./validation";
+
+const sleepSab = new Int32Array(new SharedArrayBuffer(4));
+
+function sleepSync(ms: number): void {
+  Atomics.wait(sleepSab, 0, 0, ms);
+}
+
+const BUSY_RETRIES = 3;
+const BUSY_RETRY_DELAY_MS = 50;
+
+export function withBusyRetry<T>(fn: () => T): T {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= BUSY_RETRIES; attempt++) {
+    try {
+      return fn();
+    } catch (error) {
+      lastError = error;
+      if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
+      sleepSync(BUSY_RETRY_DELAY_MS * (1 << attempt));
+    }
+  }
+  throw lastError;
+}
+
+export async function withBusyRetryAsync<T>(fn: () => T): Promise<T> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= BUSY_RETRIES; attempt++) {
+    try {
+      return fn();
+    } catch (error) {
+      lastError = error;
+      if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
+      await new Promise<void>((r) => setTimeout(r, BUSY_RETRY_DELAY_MS * (1 << attempt)));
+    }
+  }
+  throw lastError;
+}
+
+export function retriedWrite(stmt: { run(...params: (string | number)[]): unknown }): (...params: (string | number)[]) => void {
+  return (...params) => {
+    withBusyRetry(() => { stmt.run(...params); });
+  };
+}
+
+export async function openDbWithBusyRetryAsync<T>(fn: () => T): Promise<T> {
+  return withBusyRetryAsync(fn);
+}

package/src/hash-store/validation.ts

@@ -0,0 +1,62 @@
+import { HASH_RE } from "../hashline/alphabet";
+
+export function isValidHashList(value: unknown): value is string[] {
+  if (!Array.isArray(value)) return false;
+  for (const hash of value) {
+    if (typeof hash !== "string" || !HASH_RE.test(hash)) return false;
+  }
+  if (new Set(value).size !== value.length) return false;
+  return true;
+}
+
+export function parseHashList(raw: string, onInvalid: () => void, context?: string): string[] | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    console.error(`[parseHashList]${context ? ` ${context}:` : ""} failed to parse stored hashes JSON:`, error);
+    onInvalid();
+    return undefined;
+  }
+  if (!isValidHashList(parsed)) {
+    console.error(`[parseHashList]${context ? ` ${context}:` : ""} stored hashes did not pass validation:`, Array.isArray(parsed) ? `length=${parsed.length} sample=${JSON.stringify(parsed.slice(0, 3))}` : (() => { try { return JSON.stringify(parsed)?.slice(0, 500) ?? String(parsed).slice(0, 500); } catch { return String(parsed).slice(0, 500); } })());
+    onInvalid();
+    return undefined;
+  }
+  return parsed;
+}
+
+export function parseStoredHashes(row: Record<string, unknown> | undefined, onInvalid: () => void): string[] | undefined {
+  if (!row) return undefined;
+  return parseHashList(row.hashes as string, onInvalid);
+}
+
+export function isValidSnapshot(value: unknown): value is { content: string; hashes: string[] } {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value as Record<string, unknown>;
+  if (typeof v.content !== "string") return false;
+  return isValidHashList(v.hashes);
+}
+
+export function isCorruptionError(error: unknown): boolean {
+  if (error && typeof error === "object") {
+    const errcode = (error as { errcode?: unknown }).errcode;
+    if (typeof errcode === "number") {
+      return errcode === 11 || errcode === 24 || errcode === 26;
+    }
+    const code = (error as { code?: unknown }).code;
+    if (typeof code === "string" && /NOTADB|CORRUPT/.test(code)) return true;
+  }
+  return (
+    error instanceof Error &&
+    /corrupt|not a database|malformed|database disk image/i.test(error.message)
+  );
+}
+
+export function isBusyError(error: unknown): boolean {
+  if (error && typeof error === "object") {
+    const errcode = (error as { errcode?: unknown }).errcode;
+    if (typeof errcode === "number") return errcode === 5 || errcode === 6;
+  }
+  return error instanceof Error && /busy|locked/i.test(error.message);
+}

package/src/hash-store.ts

@@ -1,11 +1,29 @@
 import { existsSync } from "fs";
-import { readFile, rename, mkdir, stat } from "fs/promises";
+import { chmod, readFile, rename, mkdir, stat } from "fs/promises";
 import { hashStorePath, hashStoreDir, legacyHashStorePath } from "./paths";
 import { errCode, isRec, splitLines } from "./utils";
 import { initHasher, contentChecksum } from "./hashline/hasher";
-import { HASH_RE } from "./hashline/alphabet";
 import { HASH_STORE_VERSION, HASH_STORE_BUSY_TIMEOUT } from "./constants";
-
+import {
+  isValidHashList,
+  parseStoredHashes,
+  isValidSnapshot,
+  isCorruptionError,
+  parseHashList,
+} from "./hash-store/validation";
+import {
+  withBusyRetry,
+  retriedWrite,
+  openDbWithBusyRetryAsync,
+} from "./hash-store/retry";
+import {
+  snapshotCache,
+  cacheSnapshot,
+  SNAPSHOT_CACHE_LIMIT,
+} from "./hash-store/cache";
+
+export { isValidHashList, parseHashList, parseStoredHashes, isCorruptionError };
+export { SNAPSHOT_CACHE_LIMIT };
 export const STORE_NOT_OPEN_MESSAGE = "Hash store is not open; transactional update aborted";
 
 type SqlParams = (string | number)[];
@@ -92,133 +110,10 @@ export interface UndoRecord {
   resultContent: string;
 }
 
-interface LegacySnapshot {
-  content: string;
-  hashes: string[];
-}
-
-export function isValidHashList(value: unknown): value is string[] {
-  if (!Array.isArray(value)) return false;
-  for (const hash of value) {
-    if (typeof hash !== "string" || !HASH_RE.test(hash)) return false;
-  }
-  if (new Set(value).size !== value.length) return false;
-  return true;
-}
-
-export function parseHashList(raw: string, onInvalid: () => void, context?: string): string[] | undefined {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    console.error(`[parseHashList]${context ? ` ${context}:` : ""} failed to parse stored hashes JSON:`, error);
-    onInvalid();
-    return undefined;
-  }
-  if (!isValidHashList(parsed)) {
-    console.error(`[parseHashList]${context ? ` ${context}:` : ""} stored hashes did not pass validation:`, Array.isArray(parsed) ? `length=${parsed.length} sample=${JSON.stringify(parsed.slice(0, 3))}` : (() => { try { return JSON.stringify(parsed)?.slice(0, 500) ?? String(parsed).slice(0, 500); } catch { return String(parsed).slice(0, 500); } })());
-    onInvalid();
-    return undefined;
-  }
-  return parsed;
-}
-export function parseStoredHashes(
-  row: Record<string, unknown> | undefined,
-  onInvalid: () => void,
-): string[] | undefined {
-  if (!row) return undefined;
-  return parseHashList(row.hashes as string, onInvalid);
-}
-
-function isValidSnapshot(value: unknown): value is LegacySnapshot {
-  if (typeof value !== "object" || value === null) return false;
-  const v = value as Record<string, unknown>;
-  if (typeof v.content !== "string") return false;
-  return isValidHashList(v.hashes);
-}
-
-export function isCorruptionError(error: unknown): boolean {
-  if (error && typeof error === "object") {
-    const errcode = (error as { errcode?: unknown }).errcode;
-    if (typeof errcode === "number") {
-      return errcode === 11 || errcode === 24 || errcode === 26;
-    }
-    const code = (error as { code?: unknown }).code;
-    if (typeof code === "string" && /NOTADB|CORRUPT/.test(code)) return true;
-  }
-  return (
-    error instanceof Error &&
-    /corrupt|not a database|malformed|database disk image/i.test(error.message)
-  );
-}
-
-function isBusyError(error: unknown): boolean {
-  if (error && typeof error === "object") {
-    const errcode = (error as { errcode?: unknown }).errcode;
-    if (typeof errcode === "number") return errcode === 5 || errcode === 6;
-  }
-  return error instanceof Error && /busy|locked/i.test(error.message);
-}
-
-const sleepSab = new Int32Array(new SharedArrayBuffer(4));
-
-function sleepSync(ms: number): void {
-  Atomics.wait(sleepSab, 0, 0, ms);
-}
-
-const BUSY_RETRIES = 3;
-const BUSY_RETRY_DELAY_MS = 50;
-
-function withBusyRetry<T>(fn: () => T): T {
-  let lastError: unknown;
-  for (let attempt = 0; attempt <= BUSY_RETRIES; attempt++) {
-    try {
-      return fn();
-    } catch (error) {
-      lastError = error;
-      if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
-      sleepSync(BUSY_RETRY_DELAY_MS * (1 << attempt));
-    }
-  }
-  throw lastError;
-}
-
-async function withBusyRetryAsync<T>(fn: () => T): Promise<T> {
-  let lastError: unknown;
-  for (let attempt = 0; attempt <= BUSY_RETRIES; attempt++) {
-    try {
-      return fn();
-    } catch (error) {
-      lastError = error;
-      if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
-      await new Promise<void>((r) => setTimeout(r, BUSY_RETRY_DELAY_MS * (1 << attempt)));
-    }
-  }
-  throw lastError;
-}
-
-async function openDbWithBusyRetryAsync(storePath: string): Promise<{ db: RawDb; stmts: Prepared }> {
-  return withBusyRetryAsync(() => openDb(storePath));
-}
-
-function retriedWrite(
-  stmt: { run(...params: SqlParams): unknown },
-): (...params: SqlParams) => void {
-  return (...params) => {
-    withBusyRetry(() => { stmt.run(...params); });
-  };
-}
-
 let cachedDb: { path: string; db: RawDb; stmts: Prepared } | null = null;
 let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
-interface SnapshotCacheEntry {
-  checksum: string;
-  lineCount: number;
-  hashes: string[];
-}
-const snapshotCache = new Map<string, SnapshotCacheEntry>();
-export const SNAPSHOT_CACHE_LIMIT = 256;
+
 function openDb(storePath: string): { db: RawDb; stmts: Prepared } {
   const db = openDbFn(storePath);
   try {
@@ -231,9 +126,7 @@ function openDb(storePath: string): { db: RawDb; stmts: Prepared } {
   }
 }
 
-function buildStore(
-  db: RawDb,
-): { db: RawDb; stmts: Prepared } {
+function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA synchronous = NORMAL");
   db.exec(
@@ -351,30 +244,45 @@ function shutdownDb(db: RawDb): void {
 }
 
 async function openStore(storePath: string): Promise<HashStore> {
-  shutdownHashStore();
-
+  if (cachedDb && cachedDb.path === storePath && cachedDb.db.isOpen) {
+    return { stmts: cachedDb.stmts, engine: sqliteEngine };
+  }
+  if (cachedDb) shutdownHashStore();
   await initHasher();
-  await mkdir(hashStoreDir(), { recursive: true });
+  await mkdir(hashStoreDir(), { recursive: true, mode: 0o700 });
+  if (process.platform !== "win32") {
+    await chmod(hashStoreDir(), 0o700);
+  }
 
   let existed = existsSync(storePath);
   let opened: { db: RawDb; stmts: Prepared };
   try {
-    opened = await openDbWithBusyRetryAsync(storePath);
+    opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
   } catch (error) {
     if (!isCorruptionError(error)) throw error;
     console.error("Hash store failed to open, rebuilding:", error);
     await quarantineStore(storePath);
     existed = false;
-    opened = await openDbWithBusyRetryAsync(storePath);
+    opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
   }
   if (!isHealthy(opened.db)) {
     shutdownDb(opened.db);
     await quarantineStore(storePath);
     existed = false;
-    opened = await openDbWithBusyRetryAsync(storePath);
+    opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
   }
   const { db, stmts } = opened;
 
+  if (process.platform !== "win32") {
+    for (const candidate of [storePath, `${storePath}-wal`, `${storePath}-shm`]) {
+      try {
+        await chmod(candidate, 0o600);
+      } catch (error) {
+        if (errCode(error) !== "ENOENT") throw error;
+      }
+    }
+  }
+
   if (!existed) {
     try {
       await migrateLegacy(db);
@@ -422,7 +330,7 @@ export function shutdownHashStore(): void {
 }
 
 export function withStore(fn: () => void): void {
-  if (!cachedDb) {
+  if (!cachedDb || !cachedDb.db.isOpen) {
     throw new Error(STORE_NOT_OPEN_MESSAGE);
   }
   withBusyRetry(() => {
@@ -503,15 +411,6 @@ async function migrateLegacy(db: RawDb): Promise<void> {
   }
 }
 
-function cacheSnapshot(path: string, checksum: string, lineCount: number, hashes: string[]): void {
-  snapshotCache.delete(path);
-  snapshotCache.set(path, { checksum, lineCount, hashes: hashes.slice() });
-  if (snapshotCache.size > SNAPSHOT_CACHE_LIMIT) {
-    const oldest = snapshotCache.keys().next().value;
-    if (oldest !== undefined) snapshotCache.delete(oldest);
-  }
-}
-
 export function getSnapshot(
   store: HashStore,
   path: string,

package/src/insert.ts

@@ -1,18 +1,17 @@
 import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { constants } from "fs";
 import { execPipeline, type ReqParams, type ReplaceDetails, previewFromPipe, previewError } from "./replace";
 import { commitEdit } from "./commit";
 import { readNormFile, type NormFile } from "./file-reader";
-import { resolveInCwd } from "./fs-write";
 import { MAX_HASH_LINES, parseHashRef, resolveAnchorLine, type Anchor } from "./hashline";
 import { stripAnchorRow } from "./hashline/resolve";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
-import { makeRenderCall, renderEditResult, type RPreview, type RRState } from "./replace-render";
-import { abortIf, isRec, makePrepareArguments, rejectUnknownFields, splitLines } from "./utils";
+import { isRec, rejectUnknownFields, splitLines } from "./utils";
 import { clearBoundaryBypass } from "./boundary-bypass";
+import type { RPreview, RRState } from "./replace-render";
+import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper } from "./edit-common";
 
 const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
 
@@ -158,32 +157,17 @@ export function buildInsertToolDef(): InsertToolDef {
     description: loadP("../prompts/insert.md"),
     promptSnippet: loadP("../prompts/insert-snippet.md"),
     promptGuidelines: loadGuide("../prompts/insert-guidelines.md"),
-    prepareArguments: makePrepareArguments(),
-    executionMode: "sequential",
+    ...editToolBase,
     parameters: insertToolSchema,
-    renderShell: "default",
-    renderCall: makeRenderCall(insertPreview, { getInput: getInsertInput, toolName: "insert" }),
-    renderResult(result, { isPartial, expanded }, theme, context) {
-      return renderEditResult(
-        result as {
-          content?: Array<{ type: string; text?: string }>;
-          details?: ReplaceDetails;
-        },
-        { isPartial, expanded },
-        theme,
-        context,
-      );
-    },
-
+    renderCall: editRenderCallWrapper(insertPreview, getInsertInput, "insert"),
+    renderResult: editRenderResultWrapper,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
       assertInsertReq(canonical);
       const req = canonical;
       const path = req.path;
       const { ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor);
-      const { absolute: absolutePath, resolved: mutationTargetPath } = await resolveInCwd(path, ctx.cwd);
-      return withFileMutationQueue(mutationTargetPath, async () => {
-        abortIf(signal);
+      return queuedEdit(path, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
         const preload = await readNormFile(path, ctx.cwd, {
           signal,
           accessMode: constants.R_OK | constants.W_OK,

package/src/normalize.ts

@@ -0,0 +1,27 @@
+export type LineEnding = "\r\n" | "\n" | "\r";
+
+export function detectEnding(content: string): LineEnding {
+  const crIdx = content.indexOf("\r");
+  const lfIdx = content.indexOf("\n");
+  if (crIdx === -1 && lfIdx === -1) return "\n";
+  if (crIdx === -1) return "\n";
+  if (lfIdx === -1) return "\r";
+  if (crIdx < lfIdx) return content[crIdx + 1] === "\n" ? "\r\n" : "\r";
+  return "\n";
+}
+
+export function toLF(text: string): string {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+export function restoreEndings(text: string, ending: LineEnding): string {
+  if (ending === "\r\n") return text.replace(/\n/g, "\r\n");
+  if (ending === "\r") return text.replace(/\n/g, "\r");
+  return text;
+}
+
+export function stripBOM(content: string): { bom: string; text: string } {
+  return content.startsWith("\uFEFF")
+    ? { bom: "\uFEFF", text: content.slice(1) }
+    : { bom: "", text: content };
+}

package/src/replace-diff.ts

@@ -5,37 +5,15 @@ import {
   ANCHOR_LEN,
   HASH_SEP,
 } from "./hashline";
+import {
+  detectEnding,
+  toLF,
+  restoreEndings,
+  stripBOM,
+  type LineEnding,
+} from "./normalize";
 
-export type LineEnding = "\r\n" | "\n" | "\r";
-
-export function detectEnding(content: string): LineEnding {
-  const crIdx = content.indexOf("\r");
-  const lfIdx = content.indexOf("\n");
-  if (crIdx === -1 && lfIdx === -1) return "\n";
-  if (crIdx === -1) return "\n";
-  if (lfIdx === -1) return "\r";
-  if (crIdx < lfIdx) return content[crIdx + 1] === "\n" ? "\r\n" : "\r";
-  return "\n";
-}
-
-export function toLF(text: string): string {
-  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-
-export function restoreEndings(
-  text: string,
-  ending: LineEnding,
-): string {
-  if (ending === "\r\n") return text.replace(/\n/g, "\r\n");
-  if (ending === "\r") return text.replace(/\n/g, "\r");
-  return text;
-}
-
-export function stripBOM(content: string): { bom: string; text: string } {
-  return content.startsWith("\uFEFF")
-    ? { bom: "\uFEFF", text: content.slice(1) }
-    : { bom: "", text: content };
-}
+export { detectEnding, toLF, restoreEndings, stripBOM, type LineEnding };
 
 function fmtDiffLine(
   prefix: " " | "+" | "-",

package/src/replace-undo.ts

@@ -1,11 +1,13 @@
-import { readFile } from "fs/promises";
+import { constants } from "fs";
+import { open } from "fs/promises";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { loadHashStore, persistSnapshot, upsertUndo, getUndoEntry, deleteUndo, type UndoRecord } from "./hash-store";
 import { recordServedDiff } from "./served";
-import { resolveInCwd, writeAtomic } from "./fs-write";
-import { toLF, stripBOM, genDiff, genPatch, restoreEndings, type LineEnding } from "./replace-diff";
+import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
+import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
+import { genDiff, genPatch } from "./replace-diff";
 import { cntDiff, errCode, makePrepareArguments } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
@@ -121,8 +123,17 @@ export function regUndo(pi: ExtensionAPI): void {
 
       return withFileMutationQueue(mutationTargetPath, async () => {
         let currentRaw: string | undefined;
+        let currentIdentity: FileIdentity | undefined;
         try {
-          currentRaw = await readFile(mutationTargetPath, "utf-8");
+          const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
+          const handle = await open(mutationTargetPath, constants.O_RDONLY | noFollow);
+          try {
+            const { dev, ino } = await handle.stat();
+            currentIdentity = { dev, ino };
+            currentRaw = await handle.readFile("utf-8");
+          } finally {
+            await handle.close();
+          }
         } catch (error) {
           if (errCode(error) !== "ENOENT") throw error;
         }
@@ -146,6 +157,7 @@ export function regUndo(pi: ExtensionAPI): void {
         await writeAtomic(
           mutationTargetPath,
           undo.bom + restoreEndings(undo.content, undo.originalEnding),
+          currentIdentity,
         );
 
         const currentNormalized = currentRaw === undefined ? "" : toLF(stripBOM(currentRaw).text);

package/src/replace.ts

@@ -2,7 +2,6 @@ import type {
   ExtensionAPI,
   ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { constants } from "fs";
 import {
   genDiff,
@@ -10,9 +9,9 @@ import {
 } from "./replace-diff";
 import { readNormFile, type NormFile } from "./file-reader";
 import { editToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
-import { isRec, abortIf, makePrepareArguments } from "./utils";
+import { isRec } from "./utils";
 import { loadP, loadGuide } from "./prompts";
-import { resolveInCwd } from "./fs-write";
+import { type FileIdentity } from "./fs-write";
 import { applyEdit,
   lineHashes,
   resEdit,
@@ -26,14 +25,13 @@ import { applyEdit,
 import { commitEdit } from "./commit";
 import type { RMetrics } from "./replace-response";
 import {
-  makeRenderCall,
-  renderEditResult,
   type RPreview,
   type RRState,
 } from "./replace-render";
 import { loadHashStore, findSnapshotPaths, findServedPaths, type HashStore } from "./hash-store";
 import { getServed, recordServedSafe } from "./served";
 import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
+import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper } from "./edit-common";
 
 export { editToolSchema, type ReqParams, assertReq };
 
@@ -65,6 +63,7 @@ export interface PipelineResult {
   totalRemovedLines: number;
   hadBoundaryDedup: boolean;
   boundaryRemovedLines: number;
+  identity: FileIdentity;
 }
 
 async function resolveMissingPath(
@@ -170,7 +169,7 @@ export async function execPipeline(
   );
 
   const hashStore = options?.store ?? await loadHashStore();
-  const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath } = await readNormFile(
+  const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath, identity } = await readNormFile(
     path, cwd, { signal: options?.signal, accessMode: options?.accessMode, maxLines: MAX_HASH_LINES, store: hashStore, noPersist: options?.noPersist, preloadedNorm: options?.preloadedNorm },
   );
 
@@ -227,6 +226,7 @@ export async function execPipeline(
     totalRemovedLines,
     hadBoundaryDedup: (anchorResult.autoFixes?.length ?? 0) > 0,
     boundaryRemovedLines: anchorResult.autoFixes?.length ?? 0,
+    identity,
   };
 }
 
@@ -277,22 +277,9 @@ export function buildToolDef(): ToolDef {
     parameters,
     promptSnippet: E_SNIPPET,
     promptGuidelines: E_GUIDE,
-    prepareArguments: makePrepareArguments(),
-    executionMode: "sequential",
-    renderShell: "default",
-    renderCall: makeRenderCall(compPreview),
-    renderResult(result, { isPartial, expanded }, theme, context) {
-      return renderEditResult(
-        result as {
-          content?: Array<{ type: string; text?: string }>;
-          details?: ReplaceDetails;
-        },
-        { isPartial, expanded },
-        theme,
-        context,
-      );
-    },
-
+    ...editToolBase,
+    renderCall: editRenderCallWrapper(compPreview),
+    renderResult: editRenderResultWrapper,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
       const resolution = isRec(canonical) ? await resolveMissingPath(canonical) : undefined;
@@ -300,14 +287,11 @@ export function buildToolDef(): ToolDef {
         canonical.path = resolution.path;
       }
       assertReq(canonical);
-
       const normalizedParams = canonical;
       const path = normalizedParams.path;
-      const { absolute: absolutePath, resolved: mutationTargetPath } = await resolveInCwd(path, ctx.cwd);
-      const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
-      const boundaryBypass = consumeBoundaryBypass(mutationTargetPath, noopPayload);
-      return withFileMutationQueue(mutationTargetPath, async () => {
-        abortIf(signal);
+      return queuedEdit(path, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
+        const noopPayload = noopPayloadKey(mutationTargetPath, normalizedParams.remove_from, normalizedParams.remove_to, normalizedParams.replacement_lines);
+        const boundaryBypass = consumeBoundaryBypass(mutationTargetPath, noopPayload);
         const pipe = await execPipeline(
           normalizedParams,
           ctx.cwd,

package/src/validation.ts

@@ -1,6 +1,7 @@
 import { constants } from "fs";
 import { access as fsAccess } from "fs/promises";
 import type { LFile } from "./file-kind";
+import type { FileIdentity } from "./fs-write";
 import { errCode } from "./utils";
 
 export async function valAccess(
@@ -26,7 +27,7 @@ export async function valAccess(
 	}
 }
 
-export function valKind(file: LFile, path: string): asserts file is { kind: "text"; text: string; hadUtf8DecodeErrors?: true } {
+export function valKind(file: LFile, path: string): asserts file is { kind: "text"; text: string; identity?: FileIdentity; hadUtf8DecodeErrors?: true } {
 	if (file.kind === "directory") {
 		throw new Error(`[E_NOT_TEXT] Path is a directory: ${path}. Use ls to inspect directories.`);
 	}
@@ -42,4 +43,3 @@ export function valKind(file: LFile, path: string): asserts file is { kind: "tex
 		);
 	}
 }
-