pi-hashline-edit-pro 6.4.4 → 6.4.6

package/README.md

@@ -341,7 +341,7 @@ 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; `outline` attaches an anchor-stamped structural outline per file; and `full` 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 attaches full contents. `Git repos only` is on by default and keeps the whole injection inside a git repository; turn it off to attach files in any directory. 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; `resources/views/vendor` is kept so Laravel view overrides stay attached), 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, _ide_helper.php, _ide_helper_models.php, .phpstorm.meta.php, .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; `full` also caps the budget at 2MB, while `outline` follows the context-derived budget because outlines stay compact. Skipped and not-attached files are named at the end of the message so the model can `read` them on demand. A model matched by `disableOnModels` skips the injection entirely.
+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; `resources/views/vendor` is kept so Laravel view overrides stay attached), 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, _ide_helper.php, _ide_helper_models.php, .phpstorm.meta.php, .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; `full` also caps the budget at 2MB, while `outline` follows the context-derived budget because outlines stay compact. Files are ranked before the budget applies: working-tree changes first, then manifest and entry files, then the dominant source tree, then everything else, and no single top-level directory may take more than 40% of the budget in the first pass, so one large subtree cannot crowd out the rest. Skipped and not-attached files are named at the end of the message so the model can `read` them on demand. A model matched by `disableOnModels` skips the injection entirely.
 
 Each attached file starts with a header (`=== path ===` in `full` mode, `=== path (language) — lines ===` in `outline` mode) followed by its anchor rows. Edit directly from the attachment with replace and insert, so no `read` is needed. `full` attaches files whole; `outline` attaches each file's structural outline within the budget. In outline mode, multi-line symbols appear as labels with `[limit N]` and single-line symbols appear as their content.
 
@@ -482,12 +482,12 @@ Full reference:
 | `[E_UNDO_NONE]` | `undo_last_change` found no recorded edit for the file. Nothing was changed; make an edit first. |
 | `[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; a pure deletion checks only its first and last line). The edit was refused; the current range is returned with fresh anchors. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 1,353,139-line hashline limit or the 100MB size limit. |
-| `[E_REGISTRY]` | The anchor registry was not initialized; a serve or edit ran outside an initialized session. |
+| `[E_REGISTRY]` | The anchor registry was not initialized, or the session's registry was released because the session was replaced or reloaded; a serve or edit ran without a usable session. Retry the operation in the current session. |
 | `[E_STORE_UNAVAILABLE]` | No SQLite runtime could be loaded: the host exposes neither `node:sqlite` (Node 22.19+) nor `bun:sqlite`. The pi release binary's bundled Bun lacks `node:sqlite`; run pi under Node or a Bun build that ships SQLite. |
 | `[E_WRITE_HASH_ECHO]` | A `write` `content` line reproduces a served row for this file (a bare `anchor│` read row, a `+anchor│`, ` anchor│`, or `-anchor│` diff row, or a `lineNumber:│ anchor│content` grep row). The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
 | `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |
 | `[E_BATCH_OVERLAP]` | Batched edit 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]` | A batch-level failure aborted the edit before writing (the base read failed, a cross-file member could not be prepared, the file changed or was deleted during the batch, or the composed result exceeded a limit). Nothing was written; a call whose own request is invalid is left out of the batch instead. Fix the cause and retry, otherwise call `read` for fresh anchors and retry. The abort names the failing call and its error code when one is known. |
+| `[E_OP_ABORTED]` | The edit was aborted before writing: the file changed or was deleted after it was read (a single edit or a cross-file move reports the file; a batch reports the batch and the failing call), the base read failed, a cross-file member could not be prepared, or the composed result exceeded a limit. Nothing was written; a call whose own request is invalid is left out of the batch instead. Fix the cause and retry, otherwise call `read` for fresh anchors and retry. The batch abort names the failing call and its error code when one is known. |
 | `[E_GREP_FAILED]` | `grep` could not start ripgrep or ripgrep exited with an error (for example a pattern with backreferences or look-around, which ripgrep's regex engine does not support); the message carries ripgrep's output. Retry with `literal: true` or simplify the pattern. |
 | `[E_GREP_TIMEOUT]` | `grep` timed out after 10 seconds; narrow `path` or simplify `pattern` and retry. |
 

package/index.ts

@@ -33,7 +33,7 @@ import {
   setDisableOnModelsFromText,
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
-import { type AnchorSessionContext, initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, freeAnchorsForPaths, sessionKeyFor, withAnchorSession, releaseRegistrySession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./src/anchor-registry";
+import { type AnchorSessionContext, initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, freeAnchorsForPaths, sessionKeyFor, sessionContextReadable, withAnchorSession, releaseRegistrySession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./src/anchor-registry";
 import { serveRows } from "./src/served";
 import { finalizeTurn, planAssistantMessage } from "./src/batch";
 import { currentEditFlags } from "./src/edit-common";
@@ -46,6 +46,11 @@ import { valAccess } from "./src/validation";
 import { splitLines } from "./src/utils";
 import { AUTO_READ_ALL_CUSTOM_TYPE } from "./src/constants";
 
+interface PendingRegistrySession {
+  key: string | undefined;
+  alive: () => boolean;
+}
+
 export default function (pi: ExtensionAPI): void {
   regRead(pi);
 
@@ -72,7 +77,7 @@ export default function (pi: ExtensionAPI): void {
   let grepFlavorCwd: string | undefined;
   const baseAnchorTools = new Set<string>();
   let gateApplied = false;
-  const pendingRegistrySessionKeys: Array<string | undefined> = [];
+  const pendingRegistrySessions: PendingRegistrySession[] = [];
 
   async function refreshEditTools(): Promise<void> {
     try {
@@ -145,8 +150,26 @@ export default function (pi: ExtensionAPI): void {
     pi.setActiveTools([...new Set([...base, ...enabled])]);
   }
 
-  async function withRegistrySession<T>(ctx: AnchorSessionContext | undefined, fn: () => Promise<T> | T): Promise<T> {
-    pendingRegistrySessionKeys.push(sessionKeyFor(ctx));
+  function captureRegistrySession(ctx: AnchorSessionContext | undefined): void {
+    const key = sessionKeyFor(ctx);
+    const entry: PendingRegistrySession = {
+      key,
+      alive: () => sessionContextReadable(ctx),
+    };
+    const index = key === undefined ? -1 : pendingRegistrySessions.findIndex((candidate) => candidate.key === key);
+    if (index >= 0) pendingRegistrySessions[index] = entry;
+    else pendingRegistrySessions.push(entry);
+  }
+
+  function releaseCapturedRegistrySession(key: string): void {
+    const index = pendingRegistrySessions.findIndex((entry) => entry.key === key);
+    if (index >= 0) pendingRegistrySessions.splice(index, 1);
+    releaseRegistrySession(key);
+  }
+
+  async function withRegistrySession<T>(ctx: AnchorSessionContext | undefined, fn: () => Promise<T> | T): Promise<T | undefined> {
+    if (!sessionContextReadable(ctx)) return undefined;
+    captureRegistrySession(ctx);
     return withAnchorSession(ctx, fn);
   }
 
@@ -197,19 +220,38 @@ export default function (pi: ExtensionAPI): void {
     }
   }));
 
-  pi.on("session_shutdown", async () => {
+  pi.on("session_shutdown", async (_event, ctx) => {
     try {
-      const key = pendingRegistrySessionKeys.shift();
-      if (key !== undefined) releaseRegistrySession(key);
+      let key: string | undefined;
+      let readable = true;
+      try {
+        key = sessionKeyFor(ctx);
+      } catch {
+        readable = false;
+      }
+      if (readable && key !== undefined) {
+        releaseCapturedRegistrySession(key);
+        return;
+      }
+      if (readable) {
+        const dead = pendingRegistrySessions.findIndex((entry) => entry.key === undefined && !entry.alive());
+        const fallback = pendingRegistrySessions.findIndex((entry) => entry.key === undefined);
+        const index = dead >= 0 ? dead : fallback;
+        if (index >= 0) pendingRegistrySessions.splice(index, 1);
+        return;
+      }
+      const dead = pendingRegistrySessions.findIndex((entry) => !entry.alive());
+      const entry = dead >= 0 ? pendingRegistrySessions.splice(dead, 1)[0] : pendingRegistrySessions.shift();
+      if (entry?.key !== undefined) releaseRegistrySession(entry.key);
     } catch (error) {
       console.error("Failed to release anchor registry session:", error);
     }
   });
-  pi.on("model_select", async (event, ctx) => withAnchorSession(ctx, async () => {
+  pi.on("model_select", async (event, ctx) => withRegistrySession(ctx, async () => {
     await syncModelGate(event.model, ctx.cwd);
   }));
 
-  pi.on("before_agent_start", async (_event, ctx) => withAnchorSession(ctx, async () => {
+  pi.on("before_agent_start", async (_event, ctx) => withRegistrySession(ctx, async () => {
     await syncModelGate(ctx.model, ctx.cwd);
     if (autoReadAll === "off" || autoReadAllInjected) return;
     if (modelDisabled(ctx.model, disableOnModels)) return;
@@ -287,12 +329,12 @@ export default function (pi: ExtensionAPI): void {
 
   pi.registerCommand("clear-anchors", {
     description: "Clear the session's anchor claims (path-free resolution state); anchors are re-claimed on the next read",
-    handler: async (_args, ctx) => withAnchorSession(ctx, async () => {
+    handler: async (_args, ctx) => withRegistrySession(ctx, async () => {
       clearRegistry();
       ctx.ui.notify(`Anchor claims cleared for this session`, "info");
     }),
   });
-  pi.on("message_end", async (event, ctx) => withAnchorSession(ctx, async () => {
+  pi.on("message_end", async (event, ctx) => withRegistrySession(ctx, async () => {
     try {
       await planAssistantMessage(event.message, ctx.cwd);
     } catch (error) {
@@ -307,7 +349,7 @@ export default function (pi: ExtensionAPI): void {
       console.error("Failed to finalize edit batch:", error);
     }
   });
-  pi.on("tool_result", async (event, ctx) => withAnchorSession(ctx, async () => {
+  pi.on("tool_result", async (event, ctx) => withRegistrySession(ctx, async () => {
     if (event.isError) return;
     const gated = modelDisabled(ctx.model, disableOnModels);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "6.4.4",
+  "version": "6.4.6",
   "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/src/anchor-registry.ts

@@ -406,7 +406,7 @@ async function ensureRegistryForKey(key: string, sessionFile: string | undefined
   try {
     await promise;
   } finally {
-    pendingInits.delete(key);
+    if (pendingInits.get(key) === promise) pendingInits.delete(key);
   }
 }
 
@@ -435,6 +435,15 @@ function sessionFileFor(ctx: AnchorSessionContext | undefined): string | undefin
   return typeof sessionFile === "string" && sessionFile.length > 0 ? sessionFile : undefined;
 }
 
+export function sessionContextReadable(ctx: AnchorSessionContext | undefined): boolean {
+  try {
+    void ctx?.sessionManager;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export async function withAnchorSession<T>(ctx: AnchorSessionContext | undefined, fn: () => Promise<T> | T): Promise<T> {
   const key = sessionKeyFor(ctx);
   if (key === undefined) return fn();
@@ -712,6 +721,9 @@ export function ownersForPath(path: string): Map<string, string> {
 export function ensureRegistry(): void {
   const key = activeKey();
   if (key && registries.has(key)) return;
+  if (sessionScope.getStore() !== undefined) {
+    throw new Error("[E_REGISTRY] The anchor registry for this session is no longer available; the session was replaced or reloaded. Retry the operation in the new session.");
+  }
   initRegistry(undefined).catch(() => undefined);
 }
 
@@ -973,8 +985,18 @@ export async function allocateFileAnchors(
     if (previousState && snapshotMatchesAllocation(registry, path, previousState.contentChecksum)) {
       prevAnchors = previousState.anchors;
       prevChecksums = previousState.checksums;
-      if (!prevChecksums && previousState.contentChecksum === contentChecksum(content)) {
-        prevChecksums = checksums;
+      if (!prevChecksums) {
+        if (previousState.contentChecksum === contentChecksum(content)) {
+          prevChecksums = checksums;
+        } else if (!shadow) {
+          const state = current();
+          const stale = state && prevAnchors ? prevAnchors.filter((anchor) => state.owned.get(anchor)?.path === path) : [];
+          if (state && stale.length > 0) {
+            const usedAt = state.lastUsedAt.get(path);
+            freeAnchors(path, stale);
+            if (usedAt !== undefined) state.lastUsedAt.set(path, usedAt);
+          }
+        }
       }
     }
   }

package/src/auto-read-all.ts

@@ -3,6 +3,7 @@ import { lstat, open, readdir } from "node:fs/promises";
 import { join, relative, resolve, sep } from "node:path";
 import { formatSize } from "@earendil-works/pi-coding-agent";
 import {
+  AUTO_READ_ALL_DIR_BUDGET_SHARE,
   AUTO_READ_ALL_MAX_BUDGET_BYTES,
   AUTO_READ_ALL_MAX_FILE_BYTES,
   AUTO_READ_ALL_MAX_FILES,
@@ -108,6 +109,137 @@ function isExcludedByPattern(baseLower: string): boolean {
     || baseLower.startsWith("coreui-icons.")
     || baseLower === "coreui.css";
 }
+
+const MANIFEST_BASE_NAMES = new Set([
+  "package.json",
+  "tsconfig.json",
+  "jsconfig.json",
+  "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "requirements.txt",
+  "pipfile",
+  "cargo.toml",
+  "go.mod",
+  "gemfile",
+  "rakefile",
+  "makefile",
+  "gnumakefile",
+  "cmakelists.txt",
+  "meson.build",
+  "build.gradle",
+  "build.gradle.kts",
+  "settings.gradle",
+  "settings.gradle.kts",
+  "pom.xml",
+  "mix.exs",
+  "composer.json",
+  "dockerfile",
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  "compose.yml",
+  "compose.yaml",
+  "readme.md",
+  "readme.rst",
+  "readme.txt",
+  "readme",
+]);
+
+const SOURCE_TOP_LEVEL_NAMES = new Set([
+  "src",
+  "source",
+  "lib",
+  "libs",
+  "app",
+  "apps",
+  "packages",
+  "server",
+  "client",
+  "web",
+  "api",
+  "cmd",
+  "internal",
+  "pkg",
+  "core",
+  "modules",
+  "components",
+  "services",
+  "plugins",
+  "include",
+]);
+
+const NON_SOURCE_TOP_LEVEL_NAMES = new Set([
+  "test",
+  "tests",
+  "spec",
+  "specs",
+  "__tests__",
+  "__mocks__",
+  "docs",
+  "doc",
+  "documentation",
+  "examples",
+  "example",
+  "samples",
+  "sample",
+  "fixtures",
+  "benchmark",
+  "benchmarks",
+  "bench",
+  "e2e",
+  "scripts",
+  "assets",
+  "static",
+  "public",
+  "coverage",
+  "migrations",
+  "locales",
+  "i18n",
+  "styles",
+]);
+
+function topSegmentOf(path: string): string | undefined {
+  const index = path.indexOf("/");
+  return index < 0 ? undefined : path.slice(0, index);
+}
+
+function detectSourceTopLevel(files: readonly string[]): Set<string> {
+  const counts = new Map<string, number>();
+  for (const file of files) {
+    const top = topSegmentOf(file)?.toLowerCase();
+    if (top === undefined || NON_SOURCE_TOP_LEVEL_NAMES.has(top)) continue;
+    counts.set(top, (counts.get(top) ?? 0) + 1);
+  }
+  let dominant: string | undefined;
+  let dominantCount = 0;
+  for (const [name, count] of counts) {
+    if (count > dominantCount) {
+      dominant = name;
+      dominantCount = count;
+    }
+  }
+  const source = new Set(SOURCE_TOP_LEVEL_NAMES);
+  if (dominant !== undefined) source.add(dominant);
+  return source;
+}
+
+function priorityOf(file: string, changed: ReadonlySet<string>, sourceTopLevel: ReadonlySet<string>): number {
+  if (changed.has(file)) return 0;
+  if (MANIFEST_BASE_NAMES.has(baseNameOf(file).toLowerCase())) return 1;
+  const top = topSegmentOf(file)?.toLowerCase();
+  if (top !== undefined && sourceTopLevel.has(top)) return 2;
+  return 3;
+}
+
+function rankFiles(files: readonly string[], changed: ReadonlySet<string>, sourceTopLevel: ReadonlySet<string>): string[] {
+  return [...files].sort((a, b) => {
+    const byPriority = priorityOf(a, changed, sourceTopLevel) - priorityOf(b, changed, sourceTopLevel);
+    if (byPriority !== 0) return byPriority;
+    if (a === b) return 0;
+    return a < b ? -1 : 1;
+  });
+}
+
 export function normalizeAutoReadAllIgnoreList(entries: readonly string[] | undefined): string[] {
   const seen = new Set<string>();
   const out: string[] = [];
@@ -228,6 +360,36 @@ async function listFromGit(cwd: string): Promise<string[] | undefined> {
   return result.stdout.split("\0").filter((entry) => entry.length > 0);
 }
 
+async function listChangedFiles(cwd: string): Promise<Set<string>> {
+  const changed = new Set<string>();
+  const prefixResult = await runCommand("git", ["rev-parse", "--show-prefix"], cwd);
+  const prefix = prefixResult.code === 0 ? toPosix(prefixResult.stdout.trim()) : "";
+  const result = await runCommand("git", ["status", "--porcelain", "-z", "-uall"], cwd);
+  if (result.code !== 0) return changed;
+  const fields = result.stdout.split("\0");
+  for (let index = 0; index < fields.length; index += 1) {
+    const field = fields[index];
+    if (field === undefined || field.length < 4) continue;
+    const status = field.slice(0, 2);
+    addChangedPath(changed, field.slice(3), prefix);
+    if (status.includes("R") || status.includes("C")) {
+      index += 1;
+      const source = fields[index];
+      if (source !== undefined && source.length > 0) addChangedPath(changed, source, prefix);
+    }
+  }
+  return changed;
+}
+
+function addChangedPath(changed: Set<string>, path: string, prefix: string): void {
+  const posix = toPosix(path);
+  if (prefix.length > 0 && posix.startsWith(prefix)) {
+    changed.add(posix.slice(prefix.length));
+    return;
+  }
+  changed.add(posix);
+}
+
 async function listFromRg(cwd: string): Promise<string[] | undefined> {
   let rgPath: string;
   try {
@@ -331,16 +493,19 @@ export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMod
   const unique = [...new Set(candidates.map(toPosix))].sort();
   const includable: string[] = [];
   let skippedByName = 0;
+  let skippedBinary = 0;
+  let skippedLarge = 0;
+  let skippedOther = 0;
   for (const file of unique) {
     const baseLower = baseNameOf(file).toLowerCase();
     if (EXCLUDED_NAME_SET.has(baseLower) || isExcludedBySegment(file) || isExcludedByPattern(baseLower) || isExcludedByCustomIgnore(file, customIgnore)) skippedByName += 1;
+    else if (IMAGE_EXTENSIONS.has(extensionOf(file))) skippedBinary += 1;
     else includable.push(file);
   }
-  const scanWindow = includable.slice(0, AUTO_READ_ALL_MAX_FILES * SCAN_LIMIT_MULTIPLIER);
+  const changed = source === "git" ? await listChangedFiles(cwd) : new Set<string>();
+  const sourceTopLevel = detectSourceTopLevel(includable);
+  const scanWindow = rankFiles(includable, changed, sourceTopLevel).slice(0, AUTO_READ_ALL_MAX_FILES * SCAN_LIMIT_MULTIPLIER);
   const sized: string[] = [];
-  let skippedBinary = 0;
-  let skippedLarge = 0;
-  let skippedOther = 0;
 
   await forEachLimit(scanWindow, SCAN_CONCURRENCY, async (file) => {
     let stats;
@@ -358,10 +523,6 @@ export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMod
       skippedLarge += 1;
       return;
     }
-    if (IMAGE_EXTENSIONS.has(extensionOf(file))) {
-      skippedBinary += 1;
-      return;
-    }
     sized.push(file);
   });
 
@@ -372,8 +533,7 @@ export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMod
     else if (nul) skippedBinary += 1;
     else textual.push(file);
   });
-  textual.sort();
-  const files = textual.slice(0, AUTO_READ_ALL_MAX_FILES);
+  const files = rankFiles(textual, changed, sourceTopLevel).slice(0, AUTO_READ_ALL_MAX_FILES);
 
   return { files, source, discovered: unique.length, skippedBinary, skippedLarge, skippedOther, skippedByName };
 }
@@ -430,34 +590,52 @@ export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number
   const outline = isOutlineAutoReadAll(mode);
   const sections: AutoReadAllSection[] = [];
   const omitted: string[] = [];
+  const backlog: string[] = [];
+  const usedByDir = new Map<string, number>();
+  const dirBudget = Math.max(1, Math.floor(budgetBytes * AUTO_READ_ALL_DIR_BUDGET_SHARE));
   let bytes = 0;
   let completeFiles = 0;
-  for (const file of discovery.files) {
+
+  const take = async (file: string, respectDirBudget: boolean): Promise<void> => {
     if (sections.length > 0 && bytes >= budgetBytes) {
       omitted.push(file);
-      continue;
+      return;
     }
-    if (!outline && sections.length > 0) {
+    const group = topSegmentOf(file) ?? ".";
+    const used = usedByDir.get(group) ?? 0;
+    if (sections.length > 0) {
       const size = await candidateFileBytes(cwd, file);
       if (size !== undefined && bytes + size > budgetBytes) {
         omitted.push(file);
-        continue;
+        return;
+      }
+      if (respectDirBudget && size !== undefined && used + size > dirBudget) {
+        backlog.push(file);
+        return;
       }
     }
     const section = await renderFile(file, cwd, outline);
     if (section === undefined) {
       omitted.push(file);
-      continue;
+      return;
     }
     const sectionBytes = Buffer.byteLength(section.text, "utf-8") + 1;
     if (sections.length > 0 && bytes + sectionBytes > budgetBytes) {
       omitted.push(file);
-      continue;
+      return;
+    }
+    if (sections.length > 0 && respectDirBudget && used + sectionBytes > dirBudget) {
+      backlog.push(file);
+      return;
     }
     sections.push(section);
     bytes += sectionBytes;
+    usedByDir.set(group, used + sectionBytes);
     if (section.complete) completeFiles += 1;
-  }
+  };
+
+  for (const file of discovery.files) await take(file, true);
+  for (const file of backlog) await take(file, false);
   if (sections.length === 0) return undefined;
   const sectionTexts = sections.map((section) => section.text);
   const coverage = `[coverage: ${completeFiles} complete]`;

package/src/batch.ts

@@ -505,7 +505,7 @@ function batchPlaceholder(member: PlannedMember, piece: BatchPiece, snapshotId:
     edits_noop: piece.noop ? 1 : 0,
     warnings: 0,
     classification: piece.noop ? "noop" : "applied",
-    ...(piece.noop ? {} : { added_lines: added, removed_lines: piece.end - piece.start + 1 }),
+    ...(piece.noop ? {} : { added_lines: added, removed_lines: Math.max(0, piece.end - piece.start + 1 - piece.foldedLines) }),
   };
   const structuredContent: EditStructured = {
     ok: true,
@@ -1102,7 +1102,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   let added = 0;
   let removed = 0;
   for (const piece of appliedPieces) {
-    removed += piece.end - piece.start + 1;
+    removed += Math.max(0, piece.end - piece.start + 1 - piece.foldedLines);
     added += Math.max(0, piece.newLines.length - piece.foldedLines);
   }
   const verb = batchVerb(runtime);

package/src/commit.ts

@@ -14,6 +14,28 @@ import { spanForEdit } from "./replace";
 import { restoreEndings, stripBOM, toLF, type LineEnding } from "./normalize";
 import { applyEndingOverrides, joinSeparators, separatorsForSpans } from "./line-endings";
 import { toEditVerb } from "./structured";
+export type FileStateSinceRead = "unchanged" | "deleted" | "changed";
+
+export async function fileStateSinceRead(
+  mutationTargetPath: string,
+  displayPath: string,
+  expectedNormalized: string,
+  signal?: AbortSignal,
+): Promise<FileStateSinceRead> {
+  abortIf(signal);
+  let raw: string | undefined;
+  try {
+    raw = await readFile(mutationTargetPath, "utf-8");
+  } catch (error) {
+    const code = errCode(error);
+    if (code === "ENOENT") raw = undefined;
+    else if (code === "EACCES" || code === "EPERM") throw new Error(`[E_ACCESS] File is not readable: ${displayPath}`);
+    else if (code === "ELOOP") throw new Error(`[E_ACCESS] Too many symbolic links while resolving: ${displayPath}`);
+    else throw mapIoError(error, "read", displayPath);
+  }
+  if (raw === undefined) return "deleted";
+  return toLF(stripBOM(raw).text) === expectedNormalized ? "unchanged" : "changed";
+}
 export interface CommitMeta {
   editAnchors?: [string, string];
   anchorCarry?: number;
@@ -91,21 +113,11 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     );
   }
 
-  abortIf(signal);
-  let currentRaw: string | undefined;
-  try {
-    currentRaw = await readFile(mutationTargetPath, "utf-8");
-  } catch (error) {
-    const code = errCode(error);
-    if (code === "ENOENT") currentRaw = undefined;
-    else if (code === "EACCES" || code === "EPERM") throw new Error(`[E_ACCESS] File is not readable: ${path}`);
-    else if (code === "ELOOP") throw new Error(`[E_ACCESS] Too many symbolic links while resolving: ${path}`);
-    else throw mapIoError(error, "read", path);
-  }
-  if (currentRaw === undefined) {
+  const state = await fileStateSinceRead(mutationTargetPath, path, pipe.originalNormalized, signal);
+  if (state === "deleted") {
     throw new Error(`[E_OP_ABORTED] Edit aborted: the file was deleted after the edit started.`);
   }
-  if (toLF(stripBOM(currentRaw).text) !== pipe.originalNormalized) {
+  if (state === "changed") {
     throw new Error(`[E_OP_ABORTED] Edit aborted: the file changed after the edit started. Call read for fresh anchors and retry.`);
   }
   const undo = await saveUndo(mutationTargetPath, {
@@ -141,7 +153,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     firstChangedLine: pipe.firstChangedLine,
     lastChangedLine: pipe.lastChangedLine,
     addedLines: Math.max(0, pipe.totalAddedLines - (meta.foldedAnchorLines ?? 0)),
-    removedLines: pipe.totalRemovedLines,
+    removedLines: Math.max(0, pipe.totalRemovedLines - (meta.foldedAnchorLines ?? 0)),
   };
 
   let resultHashes: string[];

package/src/constants.ts

@@ -36,3 +36,4 @@ export const AUTO_READ_ALL_MAX_FILES = 500;
 export const AUTO_READ_ALL_MAX_FILE_BYTES = 200_000;
 export const AUTO_READ_ALL_MIN_BUDGET_BYTES = 200_000;
 export const AUTO_READ_ALL_MAX_BUDGET_BYTES = 2_000_000;
+export const AUTO_READ_ALL_DIR_BUDGET_SHARE = 0.4;

package/src/copy-move.ts

@@ -3,7 +3,7 @@ import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, withFil
 import { Type } from "typebox";
 import { constants } from "node:fs";
 import { execPipeline, noteAnchorError, previewFromPipe, previewError, type PipelineResult, type ReplaceDetails } from "./replace";
-import { commitEdit } from "./commit";
+import { commitEdit, fileStateSinceRead } from "./commit";
 import { readNormFile, safeSnapId, type NormFile } from "./file-reader";
 import { preEditSnapshotFor } from "./pre-edit-snapshot";
 import {
@@ -377,6 +377,17 @@ async function commitMovePair(input: {
     warnings.push("Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8.");
   }
 
+  const destinationState = await fileStateSinceRead(input.destination.mutationTargetPath, input.destination.displayPath, input.destination.pipe.originalNormalized, input.signal);
+  if (destinationState !== "unchanged") {
+    const verb = destinationState === "deleted" ? "was deleted" : "changed";
+    throw new Error(`[E_OP_ABORTED] Edit aborted: ${input.destination.displayPath} ${verb} after the move started. Call read for fresh anchors and retry.`);
+  }
+  const sourceState = await fileStateSinceRead(input.source.mutationTargetPath, input.source.displayPath, input.source.pipe.originalNormalized, input.signal);
+  if (sourceState !== "unchanged") {
+    const verb = sourceState === "deleted" ? "was deleted" : "changed";
+    throw new Error(`[E_OP_ABORTED] Edit aborted: ${input.source.displayPath} ${verb} after the move started. Call read for fresh anchors and retry.`);
+  }
+
   const undoDestination = await saveUndo(input.destination.mutationTargetPath, pairEntry(input.destination.pipe, destinationSeparators));
   if (!undoDestination.persisted) {
     throw new Error(`[E_UNDO_UNAVAILABLE] Could not persist undo history for ${input.destination.displayPath}. Nothing was written.`);
@@ -451,7 +462,7 @@ async function commitMovePair(input: {
       firstChangedLine: input.destination.pipe.firstChangedLine,
       lastChangedLine: input.destination.pipe.lastChangedLine,
       addedLines: Math.max(0, input.destination.pipe.totalAddedLines - input.destination.foldedAnchorLines),
-      removedLines: input.destination.pipe.totalRemovedLines,
+      removedLines: Math.max(0, input.destination.pipe.totalRemovedLines - input.destination.foldedAnchorLines),
     },
     ...(destinationSpan !== undefined ? { spans: [destinationSpan] } : {}),
   }, "moved", contextLines);

package/src/write-hook.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { HASH_CLASS } from "./hashline/alphabet";
 import { HASH_SEP } from "./hashline/hash";
-import { servedForPath, withAnchorSession } from "./anchor-registry";
+import { sessionContextReadable, servedForPath, withAnchorSession, type AnchorSessionContext } from "./anchor-registry";
 import { resolveInCwd } from "./fs-write";
 import { abortIf, splitLines, isRec } from "./utils";
 import type { ModelLike } from "./model-gate";
@@ -31,8 +31,12 @@ export async function servedHashEchoDenial(rawPath: string, content: string, cwd
   return `[E_WRITE_HASH_ECHO] Refused write to ${rawPath}: line ${echo.line} contains the copied ${echo.hash}${HASH_SEP} anchor served for this file. Remove the copied anchors and retry.`;
 }
 
+function withReadableSession<T>(ctx: AnchorSessionContext | undefined, fn: () => Promise<T> | T): Promise<T | undefined> {
+  return sessionContextReadable(ctx) ? withAnchorSession(ctx, fn) : Promise.resolve(undefined);
+}
+
 export function registerWriteHook(pi: ExtensionAPI, isModelDisabled?: (model: ModelLike | undefined) => boolean): void {
-  pi.on("tool_call", async (event, ctx) => withAnchorSession(ctx, async () => {
+  pi.on("tool_call", async (event, ctx) => withReadableSession(ctx, async () => {
     if (event.toolName !== "write") return;
     if (isModelDisabled?.(ctx.model)) return;
     const input = event.input as Record<string, unknown> | undefined;