pi-hashline-edit-pro 4.3.2 → 4.3.4

package/README.md

@@ -85,7 +85,7 @@ 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.
 
@@ -162,11 +162,12 @@ Auto-read keeps the same 50KB and 2000-line budget as `read`. Auto-read and Diff
 
 Auto-read all is off by default and has three modes, selected in `/hashline-config`: `off` injects nothing, `on` discovers every file in the working directory that is not git-ignored (`git ls-files`, falling back to `ripgrep`, then to a directory walk), and `git` uses `git ls-files` only, injecting nothing when the working directory is not a git repository. On the first turn of a session, the extension discovers the files, reads each one, and attaches the resulting `anchor│content` rows to the conversation as one extension message before the model answers. Those anchors are served exactly like `read` output, so the model can `replace` and `insert` immediately without calling `read` first. The message is injected once per session; resumed, forked, and cloned sessions that already contain it skip the injection.
 
-Files are filtered before injection: symlinks, directories, image extensions (including SVG), binary files (a NUL byte in the first 8KB), files over 200KB, any path with a vendored segment (vendor, node_modules, bower_components, third_party, thirdparty, jspm_packages, .venv, venv, site-packages, __pycache__, .tox, .gradle, .terraform, Pods, Carthage, DerivedData, coreui, coreui-icons, case-insensitive), and vendored or generated names and patterns (*.min.js, *.min.css, *.min.mjs, *-min.js, *-min.css, *.bundle.*, *.chunk.*, *.umd.js, *.map, *.lock, package-lock.json, yarn.lock, composer.lock, Gemfile.lock, Cargo.lock, poetry.lock, Pipfile.lock, go.sum, flake.lock, *.generated.*, *.gen.*, *_pb2.py, *.pb.go, *.g.dart, *.freezed.dart, *.designer.cs, *.g.cs, *.snap, .eslintcache, coreui-icons.*, coreui.css) are skipped. The attachment stops at 500 files or at a byte budget derived from the model context window (200KB floor, 2MB ceiling), and it never drops below one file. Skipped and not-attached files are named at the end of the message so the model can `read` them on demand. A file whose `read` output is truncated keeps its truncation hint, so the rest can be paged in with `read`.
+Files are filtered before injection: symlinks, directories, image extensions (including SVG), binary files (a NUL byte in the first 8KB), files over 200KB, any path with a vendored segment (vendor, node_modules, bower_components, third_party, thirdparty, jspm_packages, .venv, venv, site-packages, __pycache__, .tox, .gradle, .terraform, Pods, Carthage, DerivedData, coreui, coreui-icons, case-insensitive), and vendored or generated names and patterns (*.min.js, *.min.css, *.min.mjs, *-min.js, *-min.css, *.bundle.*, *.chunk.*, *.umd.js, *.map, *.lock, package-lock.json, yarn.lock, composer.lock, Gemfile.lock, Cargo.lock, poetry.lock, Pipfile.lock, go.sum, flake.lock, *.generated.*, *.gen.*, *_pb2.py, *.pb.go, *.g.dart, *.freezed.dart, *.designer.cs, *.g.cs, *.snap, .eslintcache, coreui-icons.*, coreui.css) are skipped. The attachment stops at 500 files or at a byte budget derived from the model context window (200KB floor, 2MB ceiling), and it never drops below one file. Skipped and not-attached files are named at the end of the message so the model can `read` them on demand.
 
-Each attached file carries a status line: `[complete, N lines; do NOT re-read]` means the section is fully attached and must be edited directly without calling `read`, while `[truncated, showing M of N lines; use read with offset=X to continue]` means only the first bytes are attached. A coverage line after the header reports complete versus truncated counts and the number of 48KB file-boundary chunks the payload splits into, so a host-side cut never tears a file in the middle.
+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"`).
+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
 
@@ -183,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, 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`:
@@ -192,6 +193,7 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created when a se
 {
   "autoRead": true,
   "autoReadAll": "off",
+  "autoReadAllIgnore": [],
   "anchorGrepEnabled": true,
   "requirePath": false,
   "strictInput": false,
@@ -252,6 +254,7 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 | `[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. |
 | `[E_UNSAFE_REGEX]` | A grep regex can trigger excessive backtracking; simplify it or search with `literal: true`. |
+| `[E_AUTO_READ_ALL]` | File already attached and unchanged since this session's start; the attached content is still exact. |
 
 ## Troubleshooting
 

package/index.ts

@@ -21,6 +21,7 @@ import {
   toggleStrictInput,
   cycleBoundaryDedupMode,
   adjustDiffContextLines,
+  setAutoReadAllIgnoreFromText,
 } from "./src/config";
 import { loadHashStore, persistSnapshot, pruneMissing } from "./src/hash-store";
 import { initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, sessionKeyFor, withAnchorSession, releaseRegistrySession } from "./src/anchor-registry";
@@ -47,6 +48,7 @@ export default function (pi: ExtensionAPI): void {
 
   let autoRead = true;
   let autoReadAll: AutoReadAllMode = "off";
+  let autoReadAllIgnore: string[] = [];
   let autoReadAllInjected = false;
   let grepWasActive = false;
 
@@ -56,6 +58,7 @@ export default function (pi: ExtensionAPI): void {
       regRead(pi, flags);
       regReplace(pi, flags);
       regInsert(pi, flags);
+      regUndo(pi, flags);
     } catch (error) {
       console.error("Failed to refresh edit tools:", error);
     }
@@ -82,6 +85,7 @@ export default function (pi: ExtensionAPI): void {
     if (corrupted && (ctx as { hasUI?: boolean }).hasUI) ctx.ui.notify("Hashline config was corrupt and was reset to defaults", "warning");
     autoRead = config.autoRead;
     autoReadAll = config.autoReadAll ?? "off";
+    autoReadAllIgnore = config.autoReadAllIgnore ?? [];
     const sessionBranch = (ctx as { sessionManager?: { getBranch?: () => Array<{ type?: string; customType?: string }> } }).sessionManager?.getBranch?.() ?? [];
     autoReadAllInjected = sessionBranch.some((entry) => entry.type === "custom_message" && entry.customType === AUTO_READ_ALL_CUSTOM_TYPE);
     await refreshEditTools();
@@ -109,7 +113,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);
+      const injection = await buildAutoReadAllInjection(ctx.cwd, autoReadAllBudget(ctx.model), autoReadAll, autoReadAllIgnore);
       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 } };
@@ -120,7 +124,7 @@ export default function (pi: ExtensionAPI): void {
   }));
 
   pi.registerCommand("hashline-config", {
-    description: "Open the hashline settings window (auto-read, auto-read all, 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");
@@ -131,9 +135,10 @@ export default function (pi: ExtensionAPI): void {
           tui,
           theme,
           done,
-          onToggle: async (key, delta) => {
+          onToggle: async (key, delta, value) => {
             if (key === "autoRead") autoRead = await toggleAutoRead();
             else if (key === "autoReadAll") { autoReadAll = await cycleAutoReadAllMode(); autoReadAllInjected = false; }
+            else if (key === "autoReadAllIgnore") autoReadAllIgnore = await setAutoReadAllIgnoreFromText(value ?? "");
             else if (key === "diffContextLines") await adjustDiffContextLines(delta ?? 1);
             else if (key === "anchorGrepEnabled") {
               const enabled = await toggleAnchorGrep();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.3.2",
+  "version": "4.3.4",
   "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/grep-guidelines.md

@@ -1,3 +1,2 @@
 - `anchor_grep`: hits and `context` rows come back as `lineNumber │ anchor│content` — target them with `replace`/`insert` directly; `lineNumber` enables jump-to-line.
-- `anchor_grep`: `path` takes a file or folder (default cwd), `glob` like `*.ts` filters, `literal:true` for literal text, `context:N` for surrounding lines.
 - `anchor_grep`: binary/image files are skipped silently.

package/prompts/grep.md

@@ -1 +1 @@
-Search text files with ripgrep. Hits and context lines come back as `lineNumber │ anchor│content` rows, editable with replace or insert without a new read; the `=== path ===` header and line numbers locate the match. Searches respect `.gitignore`, always skip `.git`, and skip binary and image files silently. A match over 500 bytes is shown as a `...` fragment around the hit, but its anchor still covers the whole line. When the output says truncated, refine `pattern` or raise `limit` (default 100).
+Search text files with ripgrep. Hits and context lines come back as `lineNumber │ anchor│content` rows, editable with replace or insert without a new read; the `=== path ===` header and line numbers locate the match. Searches respect `.gitignore`, always skip `.git`, and skip binary and image files silently. A match over 500 bytes is shown as a `...` fragment around the hit, but its anchor still covers the whole line. When cut by match limit, raise `limit` (default 100); when cut by rows/bytes, refine `pattern` / narrow path.

package/prompts/insert-guidelines.md

@@ -1,2 +1 @@
-- `insert`: the anchor must have been shown by `read`, a post-edit diff (`+anchor│`/` anchor│`), or any served `anchor│content` row. Empty file: `read` shows one `anchor│` row — insert `after` it.
-- `insert`: a batch may pair one `before` and one `after` on the same anchor line; the pair composes into a single insertion. Any other same-line pair is an overlap.
+

package/prompts/insert.md

@@ -1 +1 @@
-Insert lines after or before one existing line in a text file, addressed by a bare anchor from read output or a diff row. The anchor line is preserved: `lines` go after it with `direction: "after"` or before it with `direction: "before"`, one string per line, no anchor prefixes, no embedded newlines. Lines are added literally, even when they duplicate neighbors. Multiple `replace`/`insert` calls on the same file in one message form one batch per file: earlier calls reply `In batch N` and the last call shows the combined diff, with one undo for the whole batch.
+Insert lines after or before one existing line in a text file, addressed by a bare anchor from any served anchor│content row. The anchor line is preserved: `lines` go after it with `direction: "after"` or before it with `direction: "before"`, one string per line, no anchor prefixes, no embedded newlines. Lines are added literally, even when they duplicate neighbors. Multiple `replace`/`insert` calls on the same file in one message form one batch per file: earlier calls reply `In batch N` and the last call shows the combined diff, with one undo for the whole batch.

package/prompts/read-guidelines.md

@@ -1,3 +1,2 @@
-- `read`: view files with `read`, not `bash` (`sed`/`grep`/`cat`) — only `read` rows carry usable anchors.
-- `read`: call before `replace` when you need fresh anchors.
-- `read`: call again after an edit when you need anchors you lack — post-edit diff `+anchor│`/` anchor│` rows and any served `anchor│content` rows already carry fresh anchors for the changed range.
+- `read`: call again after an edit when you need anchors you lack — post-edit diff `+anchor│`/` anchor│` rows and any served `anchor│content` rows already carry fresh anchors for the changed range.
+- `read`: `E_AUTO_READ_ALL` on an attached file means its content is still exactly as it was when attached at the start of this session.

package/prompts/replace-guidelines.md

@@ -1,5 +1,5 @@
 - `replace`: edit with `replace`/`insert`, not `sed -i` or heredocs — anchor edits are verified against what was shown and undoable.
-- `replace`: `replacement_lines` takes bare lines without `│`; `[""]` is one blank line; pasted `anchor│` prefixes are stripped automatically (single line: same anchor for `remove_from` and `remove_to`).
-- `replace`: post-edit diff `+anchor│`/` anchor│` rows are fresh anchors for the next edit — no new `read` needed; never anchor on `-anchor│` rows, those anchors were freed by the edit. Check each batch diff before the next turn's edits on that file.
-- `replace`: batched calls must target disjoint ranges and all be valid; an overlap or any failure aborts the whole batch with nothing applied.
-- `replace`: if `replacement_lines` re-include the boundary line adjacent to the range, it is deduplicated automatically, shown as `dedup│content` rows in the diff (not editable, never use `dedup` as an anchor).
+- `replace`: `replacement_lines` `[""]` is one blank line; pasted `anchor│` prefixes are stripped automatically (single line: same anchor for `remove_from` and `remove_to`).
+- `replace`: never anchor on `-anchor│` rows of the post-edit diff, those anchors were freed by the edit. Check each batch diff before the next turn's edits on that file.
+- `replace`: same-file same-message batches must target disjoint ranges; an overlap or member failure aborts only that file's batch unwritten. Unresolvable calls stay solo and don't abort.
+- `replace`: if `replacement_lines` re-include the boundary line adjacent to the range, it is deduplicated automatically (not editable, never use `dedup` as an anchor).

package/prompts/replace.md

@@ -1 +1 @@
-Replace a range of lines (or a single line) in a text file, targeted by 4-character anchors from read output. Give `remove_from` and `remove_to` as bare anchors marking the first and last line to remove, and `replacement_lines` as one string per new line with no anchor prefixes and no embedded newlines; `[]` deletes the range. Every line in the range must match what was last shown; if the file drifted, the edit is refused and the current range is returned with fresh anchors, so retry without re-reading. Anchor follow-up edits on the `+anchor│` and ` anchor│` rows of the post-edit diff instead of re-reading. Multiple `replace`/`insert` calls on the same file in one message form one batch per file: earlier calls reply `In batch N` and the last call shows the combined diff, with one undo for the whole batch.
+Replace a range of lines (or a single line) in a text file, targeted by 4-character anchors from any served anchor│content row. Give `remove_from` and `remove_to` as bare anchors marking the first and last line to remove, and `replacement_lines` as one string per new line with no anchor prefixes and no embedded newlines; `[]` deletes the range. Anchor follow-up edits on the `+anchor│` and ` anchor│` rows of the post-edit diff instead of re-reading. Multiple `replace`/`insert` calls on the same file in one message form one batch per file: earlier calls reply `In batch N` and the last call shows the combined diff, with one undo for the whole batch.

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

@@ -0,0 +1,13 @@
+const completeSnapshots = new Map<string, string>();
+export function recordAutoReadAllComplete(absolutePath: string, snapshotId: string): void {
+  completeSnapshots.set(absolutePath, snapshotId);
+}
+export function getAutoReadAllSnapshot(absolutePath: string): string | undefined {
+  return completeSnapshots.get(absolutePath);
+}
+export function invalidateAutoReadAllComplete(absolutePath: string): void {
+  completeSnapshots.delete(absolutePath);
+}
+export function clearAutoReadAllComplete(): void {
+  completeSnapshots.clear();
+}

package/src/auto-read-all.ts

@@ -1,7 +1,7 @@
 import { execFile } from "node:child_process";
 import { lstat, open, readdir } from "node:fs/promises";
 import { join, relative, resolve, sep } from "node:path";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "@earendil-works/pi-coding-agent";
+import { formatSize } from "@earendil-works/pi-coding-agent";
 import {
   AUTO_READ_ALL_MAX_BUDGET_BYTES,
   AUTO_READ_ALL_MAX_FILE_BYTES,
@@ -9,13 +9,15 @@ import {
   AUTO_READ_ALL_MIN_BUDGET_BYTES,
   SNIFF_BYTES,
 } from "./constants";
-import type { AutoReadAllMode } from "./config";
+import { normalizeAutoReadAllIgnoreEntry, type AutoReadAllMode } from "./config";
 import { serveRows } from "./served";
-import { readNormFile } from "./file-reader";
+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";
+import { recordAutoReadAllComplete } from "./auto-read-all-state";
 
 const EXEC_TIMEOUT_MS = 20_000;
 const EXEC_MAX_BYTES = 64 * 1024 * 1024;
@@ -25,7 +27,7 @@ const MAX_REPORTED_OMISSIONS = 50;
 export const AUTO_READ_ALL_CHUNK_BYTES = 48 * 1024;
 
 const HEADER =
-  "[hashline auto-read-all] The content of every non-ignored project file is attached below with live hashline anchors. Each anchor│content row is already owned and served for this session, so replace and insert can target those anchors directly without calling read first. Sections marked [complete] are fully attached; do NOT call read for them. Only sections marked [truncated] need read. Rows with a truncation hint are only partially shown; call read with the hinted offset to see the rest.";
+  "[hashline auto-read-all] Every non-ignored project file is attached below with live hashline anchors. Do not call read for files in [files complete: ...]. Edit directly from the attachment with replace and insert.";
 
 const IMAGE_EXTENSIONS = new Set([
   ".avif",
@@ -104,6 +106,59 @@ function isExcludedByPattern(baseLower: string): boolean {
   if (baseLower === "coreui.css") return true;
   return false;
 }
+export function normalizeAutoReadAllIgnoreList(entries: readonly string[] | undefined): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const entry of entries ?? []) {
+    if (typeof entry !== "string") continue;
+    const cleaned = normalizeAutoReadAllIgnoreEntry(entry).toLowerCase();
+    if (cleaned.length === 0 || seen.has(cleaned)) continue;
+    seen.add(cleaned);
+    out.push(cleaned);
+  }
+  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;
+  }
+  return false;
+}
 
 const WALK_IGNORED_DIRS = new Set([
   ".git",
@@ -140,10 +195,8 @@ export interface AutoReadAllDiscovery {
 export interface AutoReadAllSection {
   file: string;
   text: string;
-  complete: boolean;
   totalLines: number;
-  shownLines: number;
-  nextOffset?: number;
+  absolutePath: string;
 }
 export interface AutoReadAllInjection {
   text: string;
@@ -152,7 +205,6 @@ export interface AutoReadAllInjection {
   omitted: string[];
   chunks: string[];
   completeFiles: number;
-  truncatedFiles: number;
 }
 
 function runCommand(command: string, args: string[], cwd: string): Promise<{ stdout: string; code: number }> {
@@ -187,7 +239,7 @@ async function listFromRg(cwd: string): Promise<string[] | undefined> {
   return result.stdout.split("\0").filter((entry) => entry.length > 0);
 }
 
-async function walkDir(dir: string, base: string, out: string[]): Promise<void> {
+async function walkDir(dir: string, base: string, out: string[], customIgnore: readonly string[] = []): Promise<void> {
   let entries;
   try {
     entries = await readdir(dir, { withFileTypes: true });
@@ -199,7 +251,8 @@ async function walkDir(dir: string, base: string, out: string[]): Promise<void>
     const full = join(dir, entry.name);
     if (entry.isDirectory()) {
       if (WALK_IGNORED_DIRS.has(entry.name) || EXCLUDED_SEGMENT_SET.has(entry.name.toLowerCase())) continue;
-      await walkDir(full, base, out);
+      if (customIgnore.length > 0 && isExcludedByCustomIgnore(toPosix(relative(base, full)), customIgnore)) continue;
+      await walkDir(full, base, out, customIgnore);
     } else if (entry.isFile()) {
       out.push(toPosix(relative(base, full)));
     }
@@ -250,7 +303,8 @@ async function forEachLimit<T>(items: T[], limit: number, work: (item: T) => Pro
   await Promise.all(workers);
 }
 
-export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMode = "on"): Promise<AutoReadAllDiscovery> {
+export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMode = "on", ignoreDirs: readonly string[] = []): Promise<AutoReadAllDiscovery> {
+  const customIgnore = normalizeAutoReadAllIgnoreList(ignoreDirs);
   let source: AutoReadAllSource = "git";
   let candidates = await listFromGit(cwd);
   if (candidates === undefined) {
@@ -263,7 +317,7 @@ export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMod
   if (candidates === undefined) {
     source = "walk";
     const walked: string[] = [];
-    await walkDir(cwd, cwd, walked);
+    await walkDir(cwd, cwd, walked, customIgnore);
     candidates = walked;
   }
 
@@ -272,7 +326,7 @@ export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMod
   let skippedByName = 0;
   for (const file of unique) {
     const baseLower = baseNameOf(file).toLowerCase();
-    if (EXCLUDED_NAME_SET.has(baseLower) || isExcludedBySegment(file) || isExcludedByPattern(baseLower)) skippedByName += 1;
+    if (EXCLUDED_NAME_SET.has(baseLower) || isExcludedBySegment(file) || isExcludedByPattern(baseLower) || isExcludedByCustomIgnore(file, customIgnore)) skippedByName += 1;
     else includable.push(file);
   }
   const scanWindow = includable.slice(0, AUTO_READ_ALL_MAX_FILES * SCAN_LIMIT_MULTIPLIER);
@@ -337,14 +391,10 @@ export function chunkAutoReadAllSections(sections: string[], maxBytes: number =
 async function renderFile(file: string, cwd: string): Promise<AutoReadAllSection | undefined> {
   try {
     const { normalized, fileHashes, absolutePath } = await readNormFile(file, cwd, { maxLines: MAX_HASH_LINES });
-    const preview = await fmtReadPreview(normalized, {}, fileHashes, absolutePath, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES);
+    const preview = await fmtReadPreview(normalized, {}, fileHashes, absolutePath, AUTO_READ_ALL_MAX_BUDGET_BYTES, MAX_HASH_LINES);
     serveRows(absolutePath, fileHashes, splitLines(normalized), preview.servedHashes);
     const totalLines = fileHashes.length;
-    const shownLines = preview.servedHashes.length;
-    const complete = preview.truncation === undefined && preview.nextOffset === undefined && shownLines >= totalLines;
-    const status = complete ? `[complete, ${totalLines} lines; do NOT re-read]` : `[truncated, showing ${shownLines} of ${totalLines} lines; use read with offset=${preview.nextOffset ?? shownLines + 1} to continue]`;
-    const nextOffset = preview.nextOffset;
-    return { file, text: `=== ${file} ===\n${status}\n${preview.text}`, complete, totalLines, shownLines, ...(nextOffset !== undefined ? { nextOffset } : {}) };
+    return { file, text: `=== ${file} ===\n${preview.text}`, totalLines, absolutePath };
   } catch (error) {
     console.error(`Auto-read all: skipped ${file}:`, error);
     return undefined;
@@ -369,14 +419,13 @@ 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"): Promise<AutoReadAllInjection | undefined> {
-  const discovery = await discoverAutoReadAllFiles(cwd, mode);
+export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number, mode: AutoReadAllMode = "on", ignoreDirs: readonly string[] = []): Promise<AutoReadAllInjection | undefined> {
+  const discovery = await discoverAutoReadAllFiles(cwd, mode, ignoreDirs);
   if (discovery.files.length === 0) return undefined;
   const sections: AutoReadAllSection[] = [];
   const omitted: string[] = [];
   let bytes = 0;
   let completeFiles = 0;
-  let truncatedFiles = 0;
   for (const file of discovery.files) {
     const section = await renderFile(file, cwd);
     if (section === undefined) {
@@ -389,16 +438,19 @@ export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number
       continue;
     }
     sections.push(section);
+    const snapshotId = await safeSnapId(section.absolutePath, "auto-read-all");
+    if (snapshotId !== undefined) recordAutoReadAllComplete(section.absolutePath, snapshotId);
     bytes += sectionBytes;
-    if (section.complete) completeFiles += 1;
-    else truncatedFiles += 1;
+    completeFiles += 1;
   }
   if (sections.length === 0) return undefined;
   const sectionTexts = sections.map((section) => section.text);
   const chunks = chunkAutoReadAllSections(sectionTexts);
-  const coverage = `[coverage: ${completeFiles} complete, ${truncatedFiles} truncated, ${chunks.length} chunk(s) x 48KB with file boundaries preserved; do NOT re-read complete files]`;
-  const text = `${HEADER}\n\n${coverage}\n\n${sectionTexts.join("\n\n")}\n\n${buildFooter(sections.length, discovery, omitted)}`;
-  return { text, files: sections.length, bytes, omitted, chunks, completeFiles, truncatedFiles };
+  const coverage = `[coverage: ${completeFiles} complete]`;
+  const completeNames = sections.map((section) => section.file);
+  const machineList = `[files complete: ${JSON.stringify(completeNames)} omitted: ${JSON.stringify(omitted)}]`;
+  const text = `${HEADER}\n\n${coverage}\n${machineList}\n\n${sectionTexts.join("\n\n")}\n\n${buildFooter(sections.length, discovery, omitted)}`;
+  return { text, files: sections.length, bytes, omitted, chunks, completeFiles };
 }
 
 export function autoReadAllBudget(model: { contextWindow?: number } | undefined): number {

package/src/batch.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { constants } from "node:fs";
-import { relative } from "node:path";
+import { toDisplayPath } from "./paths";
 import { readConfig, getDiffContextLines } from "./config";
 import { throwIfStrictInput, tryResolveEditTarget } from "./edit-common";
 import { readNormFile, safeSnapId } from "./file-reader";
@@ -178,39 +178,17 @@ function normalizeEditArgs(args: unknown): NormalizedEditArgs | undefined {
   }
   return undefined;
 }
-function anchorTargetFor(args: unknown): string | undefined {
-  const normalized = normalizeEditArgs(args);
-  if (!normalized) return undefined;
-  if (normalized.kind === "replace") return tryResolveEditTarget(normalized.removeFrom, normalized.removeTo);
-  return tryResolveEditTarget(normalized.anchor);
-}
-async function inferredTargetFor(args: unknown, cwd: string, requirePath: boolean): Promise<string | undefined> {
-  const normalized = normalizeEditArgs(args);
-  if (!normalized) return undefined;
-  if (requirePath && normalized.path) {
-    try {
-      return (await resolveInCwd(normalized.path, cwd)).resolved;
-    } catch {
-      return undefined;
-    }
-  }
-  if (normalized.kind === "replace") {
-    return tryResolveEditTarget(normalized.removeFrom) ?? (normalized.removeTo ? tryResolveEditTarget(normalized.removeTo) : undefined);
-  }
-  return undefined;
-}
 
 async function verifyPaths(
-  group: Array<{ id: string; target: string; kind: BatchKind; args: unknown }>,
+  group: Array<{ id: string; target: string; kind: BatchKind; args: unknown; path?: string }>,
   cwd: string,
-): Promise<Array<{ id: string; target: string; kind: BatchKind; args: unknown }>> {
-  const verified: Array<{ id: string; target: string; kind: BatchKind; args: unknown }> = [];
+): Promise<Array<{ id: string; target: string; kind: BatchKind; args: unknown; path?: string }>> {
+  const verified: Array<{ id: string; target: string; kind: BatchKind; args: unknown; path?: string }> = [];
   for (const item of group) {
-    const normalized = normalizeEditArgs(item.args);
-    if (!normalized || !normalized.path) continue;
+    if (!item.path) continue;
     let resolved: string | undefined;
     try {
-      resolved = (await resolveInCwd(normalized.path, cwd)).resolved;
+      resolved = (await resolveInCwd(item.path, cwd)).resolved;
     } catch {
       resolved = undefined;
     }
@@ -241,11 +219,24 @@ export async function planAssistantMessage(message: unknown, cwd: string): Promi
   if (calls.length < 2) return;
   const earlyConfig = await readConfig();
   const requirePath = earlyConfig.requirePath === true;
-  interface ResolvedCall { id: string; target: string; kind: BatchKind; args: unknown }
+  interface ResolvedCall { id: string; target: string; kind: BatchKind; args: unknown; path?: string }
   const resolved: ResolvedCall[] = [];
   for (const call of calls) {
-    const target = anchorTargetFor(call.args) ?? await inferredTargetFor(call.args, cwd, requirePath);
-    if (target) resolved.push({ id: call.id, target, kind: call.name as BatchKind, args: call.args });
+    const normalized = normalizeEditArgs(call.args);
+    if (!normalized) continue;
+    let target = normalized.kind === "replace" ? tryResolveEditTarget(normalized.removeFrom, normalized.removeTo) : tryResolveEditTarget(normalized.anchor);
+    if (!target) {
+      if (requirePath && normalized.path) {
+        try {
+          target = (await resolveInCwd(normalized.path, cwd)).resolved;
+        } catch {
+          target = undefined;
+        }
+      } else if (normalized.kind === "replace") {
+        target = tryResolveEditTarget(normalized.removeFrom) ?? (normalized.removeTo ? tryResolveEditTarget(normalized.removeTo) : undefined);
+      }
+    }
+    if (target) resolved.push({ id: call.id, target, kind: call.name as BatchKind, args: call.args, ...(normalized.path ? { path: normalized.path } : {}) });
   }
   const groups = new Map<string, ResolvedCall[]>();
   for (const item of resolved) {
@@ -447,7 +438,7 @@ export async function ensureBatchBase(input: {
   runtime.paths = {
     absolutePath: file.absolutePath,
     mutationTargetPath: input.mutationTargetPath,
-    displayPath: relative(input.cwd, file.absolutePath).replace(/\\/g, "/") || input.targetPath,
+    displayPath: toDisplayPath(input.cwd, file.absolutePath, input.targetPath),
   };
   return base;
 }