pi-hashline-edit-pro 6.4.3 → 6.4.5

package/README.md

@@ -159,7 +159,7 @@ The extension registers eight tools: `read`, `replace`, `replace_match`, `insert
 
 ### read
 
-`read` returns a text file with every line prefixed by `anchor│content`. The anchor is the line's address. `offset` accepts a 1-indexed line number or a served anchor; with an anchor, `limit` counts the lines to return after it. Anchor offsets are stable across edits and return the same editable rows.
+`read` returns a text file with every line prefixed by `anchor│content`. The anchor is the line's address. `offset` accepts a 1-indexed line number or a served anchor; with an anchor, `limit` counts the lines to return starting at that anchor row. Anchor offsets are stable across edits and return the same editable rows.
 
 | Parameter | Description |
 | --- | --- |
@@ -207,7 +207,7 @@ A deletion keeps blank lines at the edges of the removed range, so the separator
 
 The extension checks the request before any file I/O, so a bad request never touches the file.
 
-Auto-fixable slips fall into two groups. Fixed silently: a reversed range, embedded newlines, and a legacy array payload (a single-element array that holds stringified array text, even with a trailing JS method call, for example `[…].map(s => s)`, is unwrapped). Fixed with a warning: a leftover `anchor│` prefix in `text` or the anchor fields (a prefix of 4 to 5 letters before `│`, for example `abde│`), and diff-preview rows pasted into the replacement.
+Auto-fixable slips fall into two groups. Fixed silently: embedded newlines and a legacy array payload (a single-element array that holds stringified array text, even with a trailing JS method call, for example `[…].map(s => s)`, is unwrapped). Fixed with a warning or a hint: a reversed `remove_from`/`remove_to` range is applied in document order with an `[H_RANGE_REVERSED]` hint; a leftover `anchor│` prefix in `text` or the anchor fields (a prefix of 4 to 5 letters before `│`, for example `abde│`) and diff-preview rows pasted into the replacement are stripped with a warning.
 
 Content containing a NUL byte (`U+0000`) is rejected with `[E_BAD_SHAPE]` before any file I/O: writing it would make the file binary, so use an empty replacement to delete. This applies to the `text` field of both `replace` and `insert`.
 
@@ -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.
 
@@ -473,6 +473,7 @@ Full reference:
 | `[H_INDENT_MISMATCH]` | The new line has fewer leading whitespace characters than a structurally similar row (a reference row near the anchor line for an insert, or the replaced line). The edit applied as sent; the one-line hint names both counts and the reference anchor, for example `[H_INDENT_MISMATCH] new line has 0 leading whitespace characters; Kq3f│ has 2.` Copied or moved blocks are not checked, because their indentation comes from the source lines. |
 | `[H_SEPARATOR_MOVED]` | An insert landed its text directly against the anchor line, and the blank line that separated the anchor from its neighbor was displaced to the other side of the inserted text. The edit applied as sent; the one-line hint names the anchor and which side lost the blank line, for example `[H_SEPARATOR_MOVED] blank separator above Kq3f│ was displaced; add a blank line before Kq3f│ if unintended.` |
 | `[H_SEPARATOR_LOST]` | A pure deletion removed a run of blank lines that sat between two content lines. The edit applied as sent; the one-line hint names the two surviving anchors and the removed count, for example `[H_SEPARATOR_LOST] deletion removed 2 blank lines between Aaaa│ and Dddd│.` |
+| `[H_RANGE_REVERSED]` | The `remove_from` anchor resolved to a line after `remove_to`. The call applied the range in document order; the one-line hint names the line range used. |
 | `[E_NOT_FOUND]` | The path does not exist. |
 | `[E_ACCESS]` | The file is not readable or writable. |
 | `[E_NOT_TEXT]` | The path is a directory, binary file, image, or UTF-16/UTF-32 encoded text; hashline editing only supports text files. |

package/index.ts

@@ -33,7 +33,7 @@ import {
   setDisableOnModelsFromText,
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
-import { initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, freeAnchorsForPaths, sessionKeyFor, withAnchorSession, releaseRegistrySession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./src/anchor-registry";
+import { type AnchorSessionContext, initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, freeAnchorsForPaths, sessionKeyFor, 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,6 +77,7 @@ export default function (pi: ExtensionAPI): void {
   let grepFlavorCwd: string | undefined;
   const baseAnchorTools = new Set<string>();
   let gateApplied = false;
+  const pendingRegistrySessions: PendingRegistrySession[] = [];
 
   async function refreshEditTools(): Promise<void> {
     try {
@@ -144,7 +150,36 @@ export default function (pi: ExtensionAPI): void {
     pi.setActiveTools([...new Set([...base, ...enabled])]);
   }
 
-  pi.on("session_start", async (_event, ctx) => withAnchorSession(ctx, async () => {
+  function captureRegistrySession(ctx: AnchorSessionContext | undefined): void {
+    const key = sessionKeyFor(ctx);
+    const entry: PendingRegistrySession = {
+      key,
+      alive: () => {
+        try {
+          void ctx?.sessionManager;
+          return true;
+        } catch {
+          return false;
+        }
+      },
+    };
+    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> {
+    captureRegistrySession(ctx);
+    return withAnchorSession(ctx, fn);
+  }
+
+  pi.on("session_start", async (_event, ctx) => withRegistrySession(ctx, async () => {
     const active = pi.getActiveTools();
     baseAnchorTools.clear();
     for (const tool of ANCHOR_TOOL_NAMES) {
@@ -193,17 +228,36 @@ export default function (pi: ExtensionAPI): void {
 
   pi.on("session_shutdown", async (_event, ctx) => {
     try {
-      const key = sessionKeyFor(ctx);
-      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;
@@ -281,12 +335,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) {
@@ -301,7 +355,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.3",
+  "version": "6.4.5",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/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/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/hashline/apply.ts

@@ -166,7 +166,7 @@ export function planEdit(
   const fileHashes = precomputedHashes;
   const warnings: string[] = [];
 
-  const rangeFixed = swapReversedRanges(edit, fileHashes);
+  const rangeFixed = swapReversedRanges(edit, fileHashes, warnings);
   const prefixFixed = stripDiffPrefixes(
     stripBarePrefixes(rangeFixed, warnings, options?.stripWarning),
     warnings,

package/src/hashline/resolve.ts

@@ -265,6 +265,7 @@ export function stripDiffPrefixes(edit: HEdit, warnings: string[], location: Str
 export function swapReversedRanges(
 	edit: HEdit,
 	fileHashes: string[],
+	warnings?: string[],
 ): HEdit {
 	const lineByHash = new Map<string, number>();
 	for (let i = 0; i < fileHashes.length; i++) {
@@ -280,6 +281,7 @@ export function swapReversedRanges(
 	) {
 		return edit;
 	}
+	warnings?.push(`[H_RANGE_REVERSED] "remove_from" refers to line ${startLine} after "remove_to" (line ${endLine}); lines ${endLine}-${startLine} were replaced in document order.`);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }
 

package/src/replace-match.ts

@@ -4,7 +4,7 @@ import * as Diff from "diff";
 import { execPipeline, noteAnchorError, previewFromPipe, previewError, type ReplaceDetails } from "./replace";
 import { commitEdit } from "./commit";
 import { readNormFile, type NormFile } from "./file-reader";
-import { fmtRegion, MAX_HASH_LINES, parseHashRef, planEdit, preserveDeletionSeparators, resEdit, resolveAnchorLine, stripAnchorRow, type Anchor } from "./hashline";
+import { fmtRegion, MAX_HASH_LINES, parseHashRef, parsePayloadText, planEdit, preserveDeletionSeparators, resEdit, resolveAnchorLine, stripAnchorRow, type Anchor } from "./hashline";
 import { servedForPath, withAnchorSession } from "./anchor-registry";
 import { batchMemberFor, executeBatchMember, noteBatchFailure, registerBatchPlanner, type BatchMemberPlan, type BatchPlannerInput } from "./batch";
 import { loadP, loadGuidelines } from "./prompts";
@@ -16,9 +16,9 @@ import {
   type ReplaceMatchReq,
 } from "./payload-contract";
 import { literalEscapeHints, makePrepareArguments, splitLines } from "./utils";
-import { toLF } from "./normalize";
+import { toLF, type LineEnding } from "./normalize";
 import { isFidelitySensitiveChar } from "./edit-fidelity";
-import { countNewlines } from "./line-endings";
+import { countNewlines, splitWithEndings } from "./line-endings";
 import { MAX_RANGE_STALE_LINES } from "./constants";
 import {
   assertBoundaryLinesServed,
@@ -44,6 +44,7 @@ interface MatchRefs {
 export interface MatchPlan {
   editParams: { remove_from: string; remove_to: string; text: string };
   warnings: string[];
+  contentSeparators: (LineEnding | undefined)[];
   servedOverride?: ReadonlyMap<string, string>;
 }
 
@@ -51,18 +52,46 @@ function formatMatchRange(start: number, end: number): string {
   return start === end ? `line ${start}` : `lines ${start}-${end}`;
 }
 
-function replaceAllOccurrences(text: string, oldText: string, newText: string): { text: string; count: number } {
-  let out = "";
+function replaceAllOccurrences(
+  text: string,
+  oldText: string,
+  newText: string,
+): { text: string; separators: (LineEnding | undefined)[]; count: number } {
+  const parts: string[] = [];
+  const inserted: Array<{ start: number; end: number }> = [];
+  let length = 0;
+  const append = (chunk: string, fromNewText: boolean): void => {
+    if (fromNewText) inserted.push({ start: length, end: length + chunk.length });
+    parts.push(chunk);
+    length += chunk.length;
+  };
   let cursor = 0;
   let count = 0;
   for (;;) {
     const found = text.indexOf(oldText, cursor);
     if (found < 0) break;
-    out += text.slice(cursor, found) + newText;
+    append(text.slice(cursor, found), false);
+    append(newText, true);
     cursor = found + oldText.length;
     count += 1;
   }
-  return count === 0 ? { text, count: 0 } : { text: out + text.slice(cursor), count };
+  if (count === 0) return { text, separators: [], count: 0 };
+  append(text.slice(cursor), false);
+  const replacement = parts.join("");
+  const parsed = splitWithEndings(replacement);
+  const separators: (LineEnding | undefined)[] = [];
+  let offset = 0;
+  let insertedIndex = 0;
+  for (let index = 0; index < parsed.lines.length; index++) {
+    offset += parsed.lines[index]!.length;
+    const ending = parsed.endings[index];
+    if (ending === undefined) continue;
+    while (insertedIndex < inserted.length && inserted[insertedIndex]!.end <= offset) insertedIndex += 1;
+    const fromNewText = insertedIndex < inserted.length && offset >= inserted[insertedIndex]!.start && offset < inserted[insertedIndex]!.end;
+    separators.push(fromNewText ? ending : undefined);
+    offset += ending.length;
+  }
+  return { text: replacement, separators, count };
 }
 
 const RETYPE_DIFF_MAX_CHARS = 20_000;
@@ -206,10 +235,11 @@ export function buildReplaceMatchEdit(
   const rangeText = `${rangeLines.join("\n")}${rangeLines[rangeLines.length - 1] === "" ? "\n" : ""}`;
   const oldText = toLF(req.old_string);
   const newText = toLF(req.new_string);
-  const { text: replacement, count } = replaceAllOccurrences(rangeText, oldText, req.new_string);
+  const { text: replacement, separators: replacementSeparators, count } = replaceAllOccurrences(rangeText, oldText, req.new_string);
   if (count === 0) {
     throw new Error(notFoundMessage(displayPath, start, end, preload.fileHashes, fileLines, rangeText, oldText));
   }
+  const contentSeparators = parsePayloadText(replacement).lines.map((_, index) => replacementSeparators[index]);
   const startRef = fromLine <= toLine ? refs.from : refs.to;
   const endRef = fromLine <= toLine ? refs.to : refs.from;
   const servedOverride = trustRangeServed(fileLines, preload.fileHashes, served, start, end);
@@ -228,6 +258,7 @@ export function buildReplaceMatchEdit(
       text: replacement,
     },
     warnings,
+    contentSeparators,
     ...(servedOverride !== undefined ? { servedOverride } : {}),
   };
 }
@@ -251,6 +282,7 @@ function planReplaceMatchBatchMember(input: BatchPlannerInput): BatchMemberPlan
   return {
     hedit,
     warnings: [...warnings, ...hints, ...resWarnings, ...matchPlan.warnings],
+    contentSeparators: matchPlan.contentSeparators,
     planned,
     foldedLines: 0,
     ...(matchPlan.servedOverride !== undefined ? { servedOverride: matchPlan.servedOverride } : {}),
@@ -286,6 +318,7 @@ export async function replaceMatchPreview(request: unknown, cwd: string, signal?
       noPersist: true,
       preloadedNorm: preload,
       served: plan.servedOverride,
+      endingOverrides: plan.contentSeparators,
       signal,
     });
     return previewFromPipe(pipe);
@@ -367,6 +400,7 @@ export function buildReplaceMatchToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLA
             signal,
             preloadedNorm: preload,
             served: plan.servedOverride,
+            endingOverrides: plan.contentSeparators,
           });
           return commitEdit(pipe, {
             path: pipe.path,

package/src/replace.ts

@@ -158,9 +158,11 @@ function withEndingOverrides(edit: HEdit, overrides: (LineEnding | undefined)[]
   const length = Math.max(edit.content_separators?.length ?? 0, overrides.length);
   const separators: (LineEnding | undefined)[] = new Array(length);
   for (let index = 0; index < length; index++) {
-    separators[index] = overrides[index] ?? edit.content_separators?.[index];
+    separators[index] = index < overrides.length ? overrides[index] : edit.content_separators?.[index];
+  }
+  if (separators.every((ending) => ending === undefined)) {
+    return edit.content_separators === undefined ? edit : { ...edit, content_separators: undefined };
   }
-  if (separators.every((ending) => ending === undefined)) return edit;
   return { ...edit, content_separators: separators };
 }
 

package/tool-prompts/read.md

@@ -1 +1 @@
-Read a text file as `anchor│content` rows: a 4-character anchor (letters only, case-sensitive), `│`, then the line. Target edits by anchor, never by content or line number. `offset` takes a 1-indexed line number or a served anchor; with an anchor, `limit` counts lines after it — no line-number math. Page long files with `offset` and `limit`; when output says truncated, continue from the hinted `offset`. A stale anchor is refused with the current rows and fresh anchors. Images attach visually; binary, directory, and UTF-16/UTF-32 text are rejected; an empty file returns one empty row you can replace to seed content.
+Read a text file as `anchor│content` rows: a 4-character anchor (letters only, case-sensitive), `│`, then the line. Target edits by anchor, never by content or line number. `offset` takes a 1-indexed line number or a served anchor; with an anchor, `limit` counts lines from that anchor row onward — no line-number math. Page long files with `offset` and `limit`; when output says truncated, continue from the hinted `offset`. A stale anchor is refused with the current rows and fresh anchors. Images attach visually; binary, directory, and UTF-16/UTF-32 text are rejected; an empty file returns one empty row you can replace to seed content.