pi-hashline-edit-pro 2.7.2 → 2.8.1

package/README.md

@@ -139,7 +139,7 @@ Notes:
 | --- | --- |
 | `pattern` | Search pattern (regex, or literal text when `literal` is true). |
 | `path` | File or directory to search (default: the current working directory). |
-| `glob` | Filter files by glob pattern; `*` matches across directories, e.g. `*.ts` or `**/*.spec.ts`. |
+| `glob` | Filter files by glob pattern; `*` matches across directories, e.g. `*.ts` or `**/*.spec.ts`. A leading `/` is ignored, and the pattern may be relative to the search root or to the current directory. |
 | `ignoreCase` | Case-insensitive search (default: false). |
 | `literal` | Treat the pattern as literal text instead of a regex (default: false). |
 | `context` | Lines of context before and after each match; context rows carry anchors too (default: 0). |
@@ -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:
@@ -235,6 +238,9 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 | `[E_RANGE_STALE]` | A line in the replaced range no longer matches what was last shown (the file changed on disk, or the line was never shown). The edit was refused; the current range is returned with fresh anchors. |
 | `[E_BOUNDARY_BYPASS]` | The boundary anti-duplication was turned off for one replace call (an identical replacement had previously been cut to a noop); the duplicate lines were applied literally. The dedup is restored for the next call. |
 | `[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/index.ts

@@ -16,10 +16,10 @@ import {
 import { loadHashStore, pruneMissing } from "./src/hash-store";
 import { recordServedSafe, clearServed } from "./src/served";
 import { clearBoundaryBypass } from "./src/boundary-bypass";
+import { registerWriteHook } from "./src/write-hook";
 import { readNormFile } from "./src/file-reader";
 import { loadFileKindAndText } from "./src/file-kind";
-import { toCwd } from "./src/paths";
-import { resolveTarget } from "./src/fs-write";
+import { resolveInCwd } from "./src/fs-write";
 import { valAccess } from "./src/validation";
 
 export default function (pi: ExtensionAPI): void {
@@ -29,6 +29,7 @@ export default function (pi: ExtensionAPI): void {
   regInsert(pi);
   regGrep(pi);
   regUndo(pi);
+  registerWriteHook(pi);
 
   let autoRead = true;
 
@@ -67,7 +68,7 @@ export default function (pi: ExtensionAPI): void {
       let resolvedPath: string | undefined;
       if (typeof writtenPath === "string") {
         try {
-          resolvedPath = await resolveTarget(toCwd(writtenPath, ctx.cwd));
+          resolvedPath = (await resolveInCwd(writtenPath, ctx.cwd)).resolved;
           await clearUndo(resolvedPath);
           clearBoundaryBypass(resolvedPath);
           const store = await loadHashStore();
@@ -79,7 +80,7 @@ export default function (pi: ExtensionAPI): void {
       if (!autoRead) return;
       if (typeof writtenPath !== "string") return;
       try {
-        resolvedPath ??= await resolveTarget(toCwd(writtenPath, ctx.cwd));
+        resolvedPath ??= (await resolveInCwd(writtenPath, ctx.cwd)).resolved;
         await valAccess(resolvedPath, writtenPath);
         const file = await loadFileKindAndText(resolvedPath, { maxLines: MAX_HASH_LINES, displayPath: writtenPath });
         if (file.kind !== "text") return;
@@ -124,7 +125,8 @@ export default function (pi: ExtensionAPI): void {
     if (metrics?.classification === "noop") return;
 
     const diff = (event.details as { diff?: string } | undefined)?.diff;
-    if (!diff) return;
+    if (typeof diff !== "string") return;
+    const hasDiff = diff.length > 0;
 
     const rendered = (event.content ?? [])
       .filter(
@@ -134,11 +136,12 @@ export default function (pi: ExtensionAPI): void {
       .map((entry) => entry.text)
       .join("\n");
     const warnings = 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: [
         {
           type: "text",
-          text: warnings ? `${diff}\n\n${warnings}` : diff,
+          text: hint,
         },
       ],
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.7.2",
+  "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,13 +39,13 @@
     ]
   },
   "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"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.75.0",
+    "@earendil-works/pi-coding-agent": ">=0.84.0",
     "@earendil-works/pi-tui": "*"
   },
   "engines": {
@@ -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/prompts/grep-guidelines.md

@@ -1,7 +1,3 @@
-- `grep`: results carry anchors recorded like read output, so you can target them with replace or insert immediately.
-- `grep`: pass `path` for a single file or directory; the default is the current working directory. Directory searches skip node_modules, .git, .tmp, and coverage.
-- `grep`: use `literal: true` when the pattern contains regex metacharacters you want matched literally.
-- `grep`: use `context` to see surrounding lines; context rows carry anchors too.
-- `grep`: use `glob` to filter files; `*` matches across directories, e.g. `*.ts` or `**/*.spec.ts`.
-- `grep`: results are capped at `limit` matches (default 100), 2000 rows, and 50KB; refine the pattern or raise limit to see more.
-- `grep`: a matched line longer than 500 bytes is shown as a fragment around the match with `...` marking the truncated sides; the row keeps its anchor and is editable with replace (which replaces the whole line). Use read to see the full line.
+- `grep`: every hit and `context` line comes back as `anchor│content` — use that anchor directly for `replace`/`insert` without a new `read`.
+- `grep`: use `path` for file or folder (default cwd), `glob` like `*.ts` to filter, `literal:true` for literal text, `context:N` for surrounding lines.
+- `grep`: search skips `node_modules/.git/.tmp/coverage` and skips binary/image files.

package/prompts/grep-snippet.md

@@ -1 +1 @@
-Search file contents; matching lines carry anchors usable in replace/insert without a re-read
+Search with `anchor│content` hits usable directly for `replace`/`insert`; use `literal`/`glob`/`context`

package/prompts/grep.md

@@ -1 +1 @@
-Search text files for a pattern. Returns every matching line (and the requested context lines) as `anchor│content` rows, so the results can be used directly as replace and insert anchors without a separate read. Directory searches skip node_modules, .git, .tmp, and coverage. Binary, image, and oversized files are skipped silently. Output is capped at `limit` matches (default 100), 2000 rows, and 50KB; a matched line longer than 500 bytes is shown as a fragment around the match with `...` marking the truncated sides, and the row keeps its anchor (long lines are hashed from their first 500 bytes), so the match is still editable.
+Search text files for a pattern. Every hit and each `context` line is returned as `anchor│content` so you can use that anchor directly for `replace`/`insert` without a new `read`. Directory search skips `node_modules/.git/.tmp/coverage` and skips binary/image files. Matching lines longer than 500 bytes are shown as a fragment around the match with `...`, but the anchor is still valid for the whole line. If output says truncated, refine `pattern` or raise `limit` as hinted.

package/prompts/insert-guidelines.md

@@ -1,7 +1,3 @@
-- `insert`: anchor takes ONLY the bare 3-char anchor of the line next to which the new lines go: read row `ve7│function hello() {` means `"anchor": "ve7"`. Never paste the line content or the whole `anchor│content` row.
-- `insert`: the anchor line is preserved. Include only the new lines in `lines`, never the anchor line itself.
-- `insert`: use `direction: "after"` to add lines after the anchor line, `"before"` to add them before it.
-- `insert`: read the file first, so the anchor line was shown to you. Use a post-edit diff row or grep output for follow-up inserts.
-- `insert`: to seed an empty file, read it and insert after the `anchor│` empty-line row.
-- `insert`: lines are applied literally — never deduplicated — so restating a neighbor is safe and has no effect on the result.
-- `insert`: the post-edit diff is capped at 50KB; a row longer than 50KB is shown as a marker that keeps the row's anchor, and the diff ends with a truncation note when the cap is hit, so call read for content the diff did not show.
+- `insert`: `anchor` is bare `aB3` from `aB3│content` (never the content), direction `after` adds below, `before` adds above. Do not put the anchor line in `lines`; `[""]` is a blank line.
+- `insert`: `lines` is bare content, one element per line, kept literally even if it duplicates neighbors — nothing is removed.
+- `insert`: the anchor must have been shown by `read`, a post-edit diff (`+anchor│`/` anchor│`), or `grep`. For an empty file, `read` shows one `anchor│` empty row — insert `after` it.

package/prompts/insert-snippet.md

@@ -1 +1 @@
-Insert lines after or before a line in a text file via bare 3-char anchor from read: the anchor line stays, new lines go after/before it, applied literally
+Insert `lines` after/before bare anchor `aB3` from `aB3│content`: anchor stays, lines are bare without `│`, one per element

package/prompts/insert.md

@@ -1 +1 @@
-Insert lines after or before an existing line in a text file, targeted by 3-character anchors from read output. The anchor line is preserved; the new lines are added after it (direction "after") or before it (direction "before"). Each element of lines is exactly one line; do not embed \n inside an element: use separate elements. Use [""] for a blank line. The lines you send are added literally: nothing is removed, and lines that duplicate their neighbors are kept. The post-edit diff is capped at 50KB: rows longer than 50KB are shown as markers that keep the row's anchor, and the diff ends with a truncation note when the cap is hit; call read for anything not shown.
+Insert lines after or before one existing line in a text file, using a bare anchor like `aB3` from `aB3│content`. The anchor line stays; your `lines` are added after (`"after"`) or before (`"before"`) it, one string per line. Use `[""]` for a blank line, never put `\n` inside an element and never include the anchor line in `lines`. Lines are added literally, even if they duplicate neighbors.

package/prompts/read-guidelines.md

@@ -1,2 +1,2 @@
 - `read`: call before `replace` when you need fresh anchors for a file.
-- `read`: call again after an edit when you need anchors you do not have. The post-edit diff after replace/insert and the anchored rows after grep already carry fresh anchors for the changed range.
+- `read`: call again after an edit when you need anchors you do not have — post-edit diff `+anchor│`/` anchor│` rows and `grep` hits are already fresh anchors for the changed range, so no new `read` needed for those lines.

package/prompts/read.md

@@ -1 +1 @@
-Read a text file; each line returned as `anchor│content` with a 3-character alphanumeric anchor. No line numbers: use the anchor in replace and insert calls. Images → visual attachments; Binary/directory → rejected; UTF-16/UTF-32 (BOM) → rejected; empty → anchor│ (replace to insert); pageable with offset/limit; BOM stripped; non-UTF-8 shown as U+FFFD.
+Read a text file; each line returned as `anchor│content` with a 3-character alphanumeric anchor (e.g. `aB3│hello` is anchor `aB3` plus content `hello`). No line numbers: use the anchor in replace and insert calls. Images → visual attachments; Binary/directory → rejected; UTF-16/UTF-32 (BOM) → rejected; empty → anchor│ (replace to insert); pageable with offset/limit; BOM stripped; non-UTF-8 shown as U+FFFD. If output says truncated, use `offset`/`limit` as hinted.

package/prompts/replace-guidelines.md

@@ -1,9 +1,5 @@
-- `replace`: remove_from and remove_to take ONLY the bare 3-char anchor: read row `ve7│function hello() {` means `"remove_from": "ve7"`. Never paste the line content, a code line, a paragraph, or the whole `anchor│content` row into these fields.
-- `replace`: remove_from and remove_to mark the exact lines that are REMOVED, and replacement_lines is their complete replacement applied in order; nothing outside the range changes. Every line inside the range that is not reproduced byte-exact in replacement_lines is deleted from the file.
-- `replace`: keep the range as tight as the change: anchor only the first and last line that actually change, never a whole function, class, or import block when only part of it changes.
-- `replace`: to replace a single line, use the same anchor for both remove_from and remove_to (e.g. remove_from: "<ANCHOR>", remove_to: "<ANCHOR>").
-- `replace`: when copying a line from read output, remove its `anchor│` prefix and keep the leading whitespace exactly as shown.
-- `replace`: replacement_lines is an array of strings, one element per line. Mirror the removed lines exactly, blank lines included: use `[]` to delete the range, `[""]` for a single blank line, `["a", ""]` for a line followed by a blank line, and `["", ""]` for two blank lines. Do not embed `\n` inside an element: each element is exactly one line.
-- `replace`: when auto-read shows the post-edit diff, its rows are the fresh anchors for the new file: `+anchor│` and ` anchor│` rows carry current anchors and unchanged lines keep their previous anchors, so you can anchor follow-up edits on the diff without re-reading.
-- `replace`: do not issue multiple replace calls on the same file in one message. Issue the next edit only after verifying the previous diff.
-- `replace`: the post-edit diff is capped at 50KB; a row longer than 50KB is shown as a marker that keeps the row's anchor, and the diff ends with a truncation note when the cap is hit, so call read for content the diff did not show.
+- `replace`: `remove_from` and `remove_to` are bare anchors like `aB3` (the 3 chars before `│` in `aB3│content`), never the full row or file content. Use the same anchor for both to change one line.
+- `replace`: `replacement_lines` is bare content without `│`, one element per line. Use `[]` to delete, `[""]` for one blank line, never put `\n` inside an element and never include the `anchor│` prefix.
+- `replace`: the range from `remove_from` to `remove_to` is exactly deleted and replaced in order — make it tight, only the lines that actually change, and copy leading spaces exactly.
+- `replace`: diff markers like `+aB3│` or `-aB3│` are stripped automatically if pasted, but always try to send bare content.
+- `replace`: `+anchor│` and ` anchor│` rows in a post-edit diff are fresh anchors — you can use them for the next edit without a new `read`. Do one `replace`/`insert` per turn and check the diff before the next edit.

package/prompts/replace-snippet.md

@@ -1 +1 @@
-Replace lines in a text file via bare 3-char anchors from read: anchor only, never line content; anchor exactly the lines that change; one edit per tool call
+Replace lines via bare 3-char anchor `aB3` from `aB3│content`: `remove_from`/`remove_to` are `aB3` only, `replacement_lines` is bare lines without `│`; one edit per call

package/prompts/replace.md

@@ -1 +1 @@
-Replace a range of lines (or a single line) in a text file, targeted by 3-character anchors from read output. remove_from and remove_to must each be a BARE anchor: copy only the anchor from the leftmost column of a read row (row `ve7│function hello() {` means `"remove_from": "ve7"`). Never pass the line content, a code line, or a paragraph into these fields. The post-edit diff is capped at 50KB: rows longer than 50KB are shown as markers that keep the row's anchor, and the diff ends with a truncation note when the cap is hit; call read for anything not shown.
+Replace a range of lines (or a single line) in a text file, targeted by 3-character anchors from read output. Saw `aB3│content` in read/diff/grep: `aB3` is the bare HASH before `│`, `aB3│content` is the full row. `remove_from` and `remove_to` are bare HASH only (e.g. `"aB3"`), never the full row or file content. `replacement_lines` is bare content without `│`, one string per line — use `[]` to delete. Example: read showed `aB3│old` and `kQm│old2`, to replace both use `{"remove_from":"aB3","remove_to":"kQm","replacement_lines":["new line 1","new line 2"]}`. Single line → same anchor for both.

package/prompts/undo-last-change-guidelines.md

@@ -1,4 +1,2 @@
-- `undo_last_change`: reverts only the most recent replace or insert on the file: any write to the file clears the undo history, so call it immediately after a bad edit. An edit is bad when its post-edit diff shows `-anchor│` rows for lines you meant to keep (a closing brace, import, or declaration).
-- `undo_last_change`: when auto-read shows the post-edit diff, its `+anchor│` and ` anchor│` rows are the fresh anchors for the restored file, so follow-up edits can anchor on the diff without re-reading.
-- `undo_last_change`: if the file was deleted since the edit, the undo restores it from the recorded pre-edit content; if the file was modified since the edit, the undo is refused with `[E_UNDO_STALE]` and the record is kept, so reverting the external change makes the undo succeed.
-- `undo_last_change`: the undo diff is capped at 50KB; a row longer than 50KB is shown as a marker that keeps the row's anchor, and the diff ends with a truncation note when the cap is hit, so call read for content the diff did not show.
+- `undo_last_change`: only the last `replace`/`insert` per file can be undone; a successful `write` clears it, so call immediately after a bad diff (look for `-anchor│` lines you wanted to keep).
+- `undo_last_change`: if the file changed after the edit you get `[E_UNDO_STALE]` — the record is kept, so undo again after the file matches the edited state; if the file was deleted it is restored.

package/prompts/undo-last-change-snippet.md

@@ -1 +1 @@
-Undo the last change (replace or insert) on a file
+Undo last `replace`/`insert` on a file; restores deleted file, keeps record on `[E_UNDO_STALE]`

package/prompts/undo-last-change.md

@@ -1 +1 @@
-Undo the last change (replace or insert) on a file, reverting it to its previous state. Use when an edit produced incorrect results (e.g., wrong content, duplicated lines, broken syntax). If the file was deleted since the edit, the undo restores it from the recorded content. If the file was modified since the edit, the undo is refused and the record is kept until the file matches the edited state again. The undo diff is capped at 50KB: rows longer than 50KB are shown as markers that keep the row's anchor, and the diff ends with a truncation note when the cap is hit; call read for anything not shown.
+Undo the last `replace` or `insert` on a file, restoring previous content, BOM and line endings. Use after a bad edit when the diff showed wrong lines removed. If the file was deleted, it is restored; if changed elsewhere, you get `[E_UNDO_STALE]` and the record is kept so you can retry after restoring the edited state. If output says truncated, use `read` to see full file.

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

@@ -1,6 +1,8 @@
 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",
@@ -53,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 };
 
@@ -86,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,
@@ -94,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);
@@ -141,11 +145,7 @@ export async function loadFileKindAndText(
         for (let i = 0; i < decoded.length; i++) {
           if (decoded.charCodeAt(i) === 10) newlineCount++;
         }
-        if (newlineCount > options.maxLines) {
-          throw new Error(
-            `[E_FILE_TOO_LARGE] ${options.displayPath ?? filePath} has more than ${options.maxLines} lines, exceeding the ${options.maxLines}-line hashline limit. For very large files, use write.`,
-          );
-        }
+        if (newlineCount > options.maxLines) throw new Error(lineLimitMoreThanMessage(options.displayPath ?? filePath, options.maxLines));
       }
       return decoded;
     }
@@ -169,6 +169,11 @@ export async function loadFileKindAndText(
       position += chunkBytesRead;
     }
     parts.push(decodeChunk(new Uint8Array(0), false));
+    const text = parts.join("");
+    if (options?.maxLines !== undefined && text.length > 0) {
+      const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      assertLineLimit(normalized, options.displayPath ?? filePath, options.maxLines);
+    }
 
     if (containsNul) {
       return { kind: "binary", description: "contains NUL bytes" };
@@ -176,7 +181,8 @@ export async function loadFileKindAndText(
 
     return {
       kind: "text",
-      text: parts.join(""),
+      text,
+      identity,
       ...(hadUtf8DecodeErrors ? { hadUtf8DecodeErrors: true as const } : {}),
     };
   } finally {

package/src/file-reader.ts

@@ -1,13 +1,13 @@
 import { constants } from "fs";
 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 { abortIf } from "./utils";
+import { detectEnding, toLF, stripBOM, type LineEnding } from "./normalize";
+import { abortIf, errCode, assertLineLimit } from "./utils";
 import { valKind, valAccess } from "./validation";
-import { visLines } from "./utils";
 import type { HashStore } from "./hash-store";
 export interface NormFile {
   absolutePath: string;
@@ -16,6 +16,7 @@ export interface NormFile {
   originalEnding: LineEnding;
   fileHashes: string[];
   hadUtf8DecodeErrors: boolean;
+  identity: FileIdentity;
 }
 
 export type SnapInfo = {
@@ -52,7 +53,7 @@ export async function safeSnapId(
   try {
     return (await fileSnap(absolutePath)).snapshotId;
   } catch (error) {
-    console.error(`Failed to compute snapshot (${context}):`, error);
+    console.error(`[safeSnapId] ${context}: failed to stat "${absolutePath}" (code=${errCode(error) ?? "?"}):`, error);
     return undefined;
   }
 }
@@ -91,22 +92,42 @@ export async function readNormFile(
   const originalEnding = detectEnding(rawContent);
   const normalized = toLF(rawContent);
 
-  if (options?.maxLines !== undefined) {
-    const lineCount = visLines(normalized).length;
-    if (lineCount > options.maxLines) {
-      throw new Error(
-        `[E_FILE_TOO_LARGE] ${path} has ${lineCount} lines, exceeding the ${options.maxLines}-line hashline limit. For very large files, use write.`,
-      );
-    }
-  }
+  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,
   };
 }
+
+export async function tryReadNormFile(
+  absPath: string,
+  cwd: string,
+  options?: ReadNormOptions,
+): Promise<NormFile | undefined> {
+  try {
+    const displayPath = relative(cwd, absPath).replace(/\\/g, "/") || absPath;
+    const file = await loadFileKindAndText(absPath, { maxLines: options?.maxLines, displayPath });
+    if (file.kind !== "text") return undefined;
+    return await readNormFile(absPath, cwd, { ...options, preloadedFile: file });
+  } catch (error) {
+    const code = errCode(error);
+    if (code === "EACCES" || code === "EPERM" || code === "ENOENT" || code === "ELOOP") return undefined;
+    if (error instanceof Error) {
+      const msg = error.message;
+      if (msg.startsWith("[E_FILE_TOO_LARGE]") || msg.startsWith("[E_NOT_FOUND]") || msg.startsWith("[E_ACCESS]") || msg.startsWith("[E_NOT_TEXT]")) return undefined;
+    }
+    throw error;
+  }
+}

package/src/fs-write.ts

@@ -1,4 +1,5 @@
 import { randomUUID } from "crypto";
+import { constants } from "fs";
 import {
 	lstat,
 	mkdir,
@@ -11,8 +12,25 @@ import {
 	writeFile,
 } from "fs/promises";
 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);
@@ -25,7 +43,15 @@ export async function resolveTarget(path: string): Promise<string> {
   async function resParts(
     currentPath: string,
     remainingParts: string[],
+    symlinkDepth = 0,
   ): Promise<string> {
+    if (symlinkDepth > 40) {
+      const error = new Error(
+        `Too many symbolic links while resolving ${path}`,
+      ) as NodeJS.ErrnoException;
+      error.code = "ELOOP";
+      throw error;
+    }
     if (remainingParts.length === 0) {
       return currentPath;
     }
@@ -36,7 +62,7 @@ export async function resolveTarget(path: string): Promise<string> {
     try {
       const candidateStats = await lstat(candidatePath);
       if (!candidateStats.isSymbolicLink()) {
-        return resParts(candidatePath, tail);
+        return resParts(candidatePath, tail, symlinkDepth);
       }
 
       if (visitedSymlinks.has(candidatePath)) {
@@ -59,7 +85,7 @@ export async function resolveTarget(path: string): Promise<string> {
       return resParts(parse(linkTargetPath).root, [
         ...targetParts,
         ...tail,
-      ]);
+      ], symlinkDepth + 1);
     } catch (error: unknown) {
       if (errCode(error) === "ENOENT") {
         return join(candidatePath, ...tail);
@@ -110,9 +136,15 @@ async function syncDir(dir: string): Promise<void> {
   }
 }
 
+export async function resolveInCwd(path: string, cwd: string): Promise<{ absolute: string; resolved: string }> {
+  const absolute = toCwd(path, cwd);
+  const resolved = await resolveTarget(absolute);
+  return { absolute, resolved };
+}
 export async function writeAtomic(
   path: string,
   content: string,
+  expectedIdentity?: FileIdentity,
 ): Promise<void> {
   const targetPath = await resolveTarget(path);
 
@@ -125,8 +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");
+    const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
+    const handle = await open(targetPath, constants.O_WRONLY | noFollow);
+    try {
+      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.chmod(existingStats.mode & 0o7777);
+      } catch {}
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
     return;
   }
 
@@ -148,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) {