pi-hashline-edit-pro 4.3.4 → 4.3.6

package/README.md

@@ -89,7 +89,7 @@ Single line: use the same anchor for `remove_from` and `remove_to`. `replace_fro
 
 The request is checked before any file I/O, so a bad request never touches the file.
 
-Common copy-paste slips are fixed automatically: a leftover `anchor│` prefix in `replacement_lines` or the anchor fields (a prefix of 4 to 5 characters before `│`, for example `ab12│`), diff-preview rows pasted into the replacement, and a boundary line pasted twice are reported as warnings, while a reversed range, a JSON-array wrapper, and embedded newlines are corrected silently. New lines that re-include a block adjacent to the range are stripped when that block is unique in the file. The whole run is stripped as one unit, so re-including an unchanged block next to the range never duplicates it. Boundary dedup has three modes in `/hashline-config`: `on` strips with a warning, `off` applies edits literally, and `strict` rejects the edit with `[E_BOUNDARY_STRICT]` when any replacement line would be stripped.
+Common copy-paste slips are fixed automatically: a leftover `anchor│` prefix in `replacement_lines` or the anchor fields (a prefix of 4 to 5 letters before `│`, for example `abde│`), diff-preview rows pasted into the replacement, and a boundary line pasted twice are reported as warnings, while a reversed range, a JSON-array wrapper, and embedded newlines are corrected silently. New lines that re-include a block adjacent to the range are stripped when that block is unique in the file. The whole run is stripped as one unit, so re-including an unchanged block next to the range never duplicates it. Boundary dedup has three modes in `/hashline-config`: `on` strips with a warning, `off` applies edits literally, and `strict` rejects the edit with `[E_BOUNDARY_STRICT]` when any replacement line would be stripped.
 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 `replace`'s `replacement_lines` and `insert`'s `lines`.
 
 Every line in the removed range must match what was last shown to you. The extension records the `anchor│content` rows it serves (`read` output, `anchor_grep` output, the auto-read block after `write`, the `+anchor│` and ` anchor│` rows of post-edit diffs, the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale-anchor feedback) and verifies the whole range against that record before writing. A line that changed on disk since it was shown, or an anchor that is not owned in this session, refuses the edit with `[E_RANGE_STALE]` or `[E_STALE_ANCHOR]` and returns the current range with fresh anchors, so the retry needs no `read`. An owned anchor enters the served record when its row is shown (after a restart, restored ownership counts as shown), so a file with no owned anchors cannot be edited by anchor at all; call `read` first. An owned line that was never shown — for example beyond an auto-read preview's truncation cap — is refused with `[E_RANGE_STALE]` and returns the current range, so the retry still needs no `read`.
@@ -176,7 +176,7 @@ All five tools return machine-readable metadata in `details` alongside the model
 | Tool | `details` |
 | --- | --- |
 | `read` | `truncation` (set when output was truncated), `snapshotId` (a `v2\|path\|ino\|mtime\|ctime\|size` fingerprint), `nextOffset` (use as the next `offset`), and `metrics` with `truncated` and `next_offset`. |
-| `replace`, `insert` | `diff` (post-edit diff, capped, with current anchors on `+HASH│` and ` HASH│` rows; a same-message batch reports the combined diff on its last call and an empty diff on earlier calls), `patch` (a standard unified patch for external tools, capped like the diff), `patchTruncated` (true when the patch was cut or skipped for a pair over 1MB and can no longer be applied as-is), `firstChangedLine`, `snapshotId`, `classification` (`"noop"` when nothing changed), `batch` (`{ id, size, last, total }` marking same-message batch membership), and `metrics`: `edits_attempted`, `edits_noop`, `warnings`, `classification` (`"applied"` or `"noop"`), `changed_lines` (`{ first, last }`), `added_lines`, `removed_lines`. |
+| `replace`, `insert` | `diff` (post-edit diff, capped, with current anchors on `+HASH│` and ` HASH│` rows; a same-message batch reports the combined diff on its last call and an empty diff on earlier calls), `patch` (a standard unified patch for external tools, capped like the diff), `patchTruncated` (true when the patch was cut or skipped for a pair over 1MB and can no longer be applied as-is), `firstChangedLine`, `snapshotId`, `classification` (`"noop"` when nothing changed), `batch` (`{ id, size, last, total }` marking same-message batch membership; earlier members also carry `aborted: true` and `abortMessage` after a batch abort), and `metrics`: `edits_attempted`, `edits_noop`, `warnings`, `classification` (`"applied"` or `"noop"`), `changed_lines` (`{ first, last }`), `added_lines`, `removed_lines`. |
 | `undo_last_change` | `diff` (the undo diff with restored anchors), `patch`, `patchTruncated`, and `metrics` in the same shape as `replace`. |
 | `anchor_grep` | `metrics` with `matches` (capped at `limit`), `files`, and `truncated`; `truncation` (the standard pi truncation report) when output was cut; and `linesTruncated` (true when long lines were shown as fragments). |
 
@@ -233,7 +233,7 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 | --- | --- |
 | `[E_BAD_SHAPE]` | Request envelope or edit item has unknown, missing, or wrongly-typed fields (for example `replacement_lines` must be an array of strings, one element per line), or content contains a NUL byte (`U+0000`), which would make the file binary. |
 | `[W_BAD_SHAPE]` | Auto-corrected request slip reported as a warning (for example stringified array text that could not be parsed and was kept as one literal line). |
-| `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` is not a bare 4-char anchor. |
+| `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` is not a bare 4-character anchor (the anchor table is letters only). |
 | `[W_BAD_REF]` | A pasted `anchor│` or diff-preview marker was stripped from an anchor field with a warning. |
 | `[E_STALE_ANCHOR]` | An anchor is not owned in this session (it was never shown to you, or its line was edited or the file was rewritten); call `read` for fresh anchors. |
 | `[W_INVALID_PATCH]` | A `replacement_lines` element is a diff-preview row (`+anchor│`, `-anchor│`, `-    │`). The marker is stripped automatically with a warning. |
@@ -249,7 +249,7 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 | `[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_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 begins with an `anchor│` that was served for this file (any line position). The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
+| `[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 `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. |
@@ -261,6 +261,7 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 - Stale anchors. `[E_STALE_ANCHOR]` means an anchor is not owned in this session: it was never shown to you, or its line was edited or the file was rewritten since. Call `read` for fresh anchors and retry.
 - Range changed on disk. `[E_RANGE_STALE]` means a line inside the replaced range changed after it was last shown to you (or was never shown). Nothing was modified; the error carries the current range with fresh anchors, so retry with those without a `read`.
 - Multi-conversation hosts. Anchors, served records, and ownership logs are resolved per calling session, so a tool call in one conversation is never answered by another conversation's registry; a foreign anchor fails with `[E_STALE_ANCHOR]`. Interactive previews are the one exception: pi does not pass the session into render callbacks, so when one process serves several conversations at once a preview can fall back to the most recently active session and show a stale or wrong-file diff. Previews never write files or claim anchors; run the call for the authoritative result.
+- Undo scope. `undo_last_change` records are keyed by file path, not by session, so in a multi-conversation host any conversation that names the file can revert its most recent `replace` or `insert`, even one made by another conversation. Anchor ownership remains session-scoped; only undo is shared.
 - Reset the anchor state. Anchors live in `~/.config/pi-hashline-edit-pro/hash-store.sqlite` (with `-wal`/`-shm` sidecars) and in per-session ownership logs under `~/.config/pi-hashline-edit-pro/sessions/`. Quit pi, delete those files, and everything is rebuilt on the next session. Anchor history is lost, but no project files are touched.
 - Corrupt store. If the store fails its health check it is renamed to `hash-store.sqlite.corrupt-<timestamp>` and rebuilt automatically.
 - Config directory moved. If `XDG_CONFIG_HOME` is set on a non-Windows platform, the config directory (and the anchor state inside it) lives at `$XDG_CONFIG_HOME/pi-hashline-edit-pro` instead of `~/.config/pi-hashline-edit-pro`. An existing store is not migrated automatically. To keep anchor and undo history, move the old `hash-store.sqlite` files (plus `-wal`/`-shm` sidecars) into the new directory before the first run.

package/index.ts

@@ -7,6 +7,7 @@ import { regGrep } from "./src/grep";
 import { regUndo, clearUndo } from "./src/replace-undo";
 import { regRead, fmtReadPreview } from "./src/read";
 import { buildAutoReadAllInjection, autoReadAllBudget } from "./src/auto-read-all";
+import { clearAutoReadAllComplete } from "./src/auto-read-all-state";
 import type { RMetrics } from "./src/replace-response";
 import type { ReplaceDetails } from "./src/replace";
 import { extractWarnings } from "./src/replace-render";
@@ -103,6 +104,7 @@ export default function (pi: ExtensionAPI): void {
   pi.on("session_shutdown", async (_event, ctx) => {
     try {
       const key = sessionKeyFor(ctx);
+      clearAutoReadAllComplete(key);
       if (key !== undefined) releaseRegistrySession(key);
     } catch (error) {
       console.error("Failed to release anchor registry session:", error);
@@ -113,7 +115,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, autoReadAllIgnore);
+      const injection = await buildAutoReadAllInjection(ctx.cwd, autoReadAllBudget(ctx.model), autoReadAll, autoReadAllIgnore, sessionKeyFor(ctx));
       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 } };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.3.4",
+  "version": "4.3.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",
@@ -58,10 +58,10 @@
     "test:coverage": "vitest run --coverage --coverage.thresholds.lines=90 --coverage.thresholds.statements=90 --coverage.thresholds.functions=85 --coverage.thresholds.branches=80",
     "lint": "eslint \"src/**/*.ts\" \"index.ts\" \"test/**/*.ts\"",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run typecheck && npm run lint && npm test"
+    "prepublishOnly": "npm run typecheck && npm run lint"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.84.0",
+    "@earendil-works/pi-coding-agent": "^0.86.1",
     "@eslint/js": "^10.0.1",
     "@types/node": "^24",
     "@vitest/coverage-v8": "^4.1.11",

package/prompts/read.md

@@ -1 +1 @@
-Read a text file and return it as `anchor│content` rows, one per line: a 4-character alphanumeric anchor, the `│` separator, then the line content. Target lines in replace and insert by anchor, never by content or line number. Page long files with `offset` and `limit`; when the output says truncated, continue with the hinted `offset/limit`. 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 and return it as `anchor│content` rows, one per line: a 4-character anchor (letters only), the `│` separator, then the line content. Target lines in replace and insert by anchor, never by content or line number. Page long files with `offset` and `limit`; when the output says truncated, continue with the hinted `offset/limit`. 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.

package/src/anchor-registry.ts

@@ -659,6 +659,7 @@ export function alignOwnershipWithSpans(
   const state = options?.shadow ? shadowStateFrom(current()!) : current()!;
   const freed: { anchor: string; checksum: string }[] = [];
   const minted: MintedAt[] = [];
+  const reused = new Set<string>();
   const log = (event: RegistryEvent): void => {
     if (!options?.shadow) appendEvent(event);
   };
@@ -671,14 +672,12 @@ export function alignOwnershipWithSpans(
     const start = span.start + offset;
     const end = span.end + offset;
     const spanLength = end - start + 1;
-    const spanFreed: { anchor: string; checksum: string }[] = [];
     for (let i = start; i <= end; i++) {
       const anchor = anchors[i]!;
       if (state.owned.has(anchor)) {
         state.owned.delete(anchor);
         const checksum = prevChecksums[i - offset] ?? "";
-        spanFreed.push({ anchor, checksum });
-        freed.push(spanFreed[spanFreed.length - 1]!);
+        freed.push({ anchor, checksum });
       }
     }
     const replacement: (string | undefined)[] = new Array(span.replacementCount);
@@ -690,10 +689,7 @@ export function alignOwnershipWithSpans(
         (!state.owned.has(positional) || state.owned.get(positional)!.path === path)
       ) {
         replacement[k] = positional;
-        const freedAt = freed.findIndex((candidate) => candidate.anchor === positional);
-        if (freedAt >= 0) freed.splice(freedAt, 1);
-        const pooledAt = spanFreed.findIndex((candidate) => candidate.anchor === positional);
-        if (pooledAt >= 0) spanFreed.splice(pooledAt, 1);
+        reused.add(positional);
       }
     }
     for (let k = 0; k < span.replacementCount; k++) {
@@ -714,8 +710,9 @@ export function alignOwnershipWithSpans(
   }
   const rows: [string, string][] = minted.map((m) => [m.anchor, m.checksum]);
   if (rows.length > 0) log({ kind: "allocate", path, rows });
-  if (freed.length > 0) log({ kind: "free", path, anchors: freed.map((f) => f.anchor) });
-  return { anchors, freed: freed.map((f) => f.anchor), minted: minted.map((m) => m.anchor) };
+  const retained = freed.filter((candidate) => !reused.has(candidate.anchor));
+  if (retained.length > 0) log({ kind: "free", path, anchors: retained.map((f) => f.anchor) });
+  return { anchors, freed: retained.map((f) => f.anchor), minted: minted.map((m) => m.anchor) };
 }
 
 export function alignOwnership(

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

@@ -1,13 +1,27 @@
-const completeSnapshots = new Map<string, string>();
-export function recordAutoReadAllComplete(absolutePath: string, snapshotId: string): void {
-  completeSnapshots.set(absolutePath, snapshotId);
+const completeSnapshots = new Map<string, Map<string, string>>();
+
+function scopeFor(sessionKey: string | undefined): string {
+  return sessionKey ?? "";
 }
-export function getAutoReadAllSnapshot(absolutePath: string): string | undefined {
-  return completeSnapshots.get(absolutePath);
+
+export function recordAutoReadAllComplete(sessionKey: string | undefined, absolutePath: string, snapshotId: string): void {
+  const scope = scopeFor(sessionKey);
+  let snapshots = completeSnapshots.get(scope);
+  if (!snapshots) {
+    snapshots = new Map();
+    completeSnapshots.set(scope, snapshots);
+  }
+  snapshots.set(absolutePath, snapshotId);
 }
-export function invalidateAutoReadAllComplete(absolutePath: string): void {
-  completeSnapshots.delete(absolutePath);
+
+export function getAutoReadAllSnapshot(sessionKey: string | undefined, absolutePath: string): string | undefined {
+  return completeSnapshots.get(scopeFor(sessionKey))?.get(absolutePath);
 }
-export function clearAutoReadAllComplete(): void {
+
+export function clearAutoReadAllComplete(sessionKey: string | undefined): void {
+  completeSnapshots.delete(scopeFor(sessionKey));
+}
+
+export function clearAllAutoReadAllComplete(): void {
   completeSnapshots.clear();
 }

package/src/auto-read-all.ts

@@ -388,6 +388,16 @@ export function chunkAutoReadAllSections(sections: string[], maxBytes: number =
   if (current.length > 0) chunks.push(current.join("\n\n"));
   return chunks;
 }
+
+async function candidateFileBytes(cwd: string, file: string): Promise<number | undefined> {
+  try {
+    const stats = await lstat(resolve(cwd, file));
+    return stats.isFile() ? stats.size : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 async function renderFile(file: string, cwd: string): Promise<AutoReadAllSection | undefined> {
   try {
     const { normalized, fileHashes, absolutePath } = await readNormFile(file, cwd, { maxLines: MAX_HASH_LINES });
@@ -419,7 +429,7 @@ 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", ignoreDirs: readonly string[] = []): Promise<AutoReadAllInjection | undefined> {
+export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number, mode: AutoReadAllMode = "on", ignoreDirs: readonly string[] = [], sessionKey?: string): Promise<AutoReadAllInjection | undefined> {
   const discovery = await discoverAutoReadAllFiles(cwd, mode, ignoreDirs);
   if (discovery.files.length === 0) return undefined;
   const sections: AutoReadAllSection[] = [];
@@ -427,6 +437,13 @@ export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number
   let bytes = 0;
   let completeFiles = 0;
   for (const file of discovery.files) {
+    if (sections.length > 0) {
+      const size = await candidateFileBytes(cwd, file);
+      if (size !== undefined && bytes + size > budgetBytes) {
+        omitted.push(file);
+        continue;
+      }
+    }
     const section = await renderFile(file, cwd);
     if (section === undefined) {
       omitted.push(file);
@@ -439,7 +456,7 @@ export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number
     }
     sections.push(section);
     const snapshotId = await safeSnapId(section.absolutePath, "auto-read-all");
-    if (snapshotId !== undefined) recordAutoReadAllComplete(section.absolutePath, snapshotId);
+    if (snapshotId !== undefined) recordAutoReadAllComplete(sessionKey, section.absolutePath, snapshotId);
     bytes += sectionBytes;
     completeFiles += 1;
   }

package/src/batch.ts

@@ -23,11 +23,11 @@ import { assertInsertReq, assertReq, normReq } from "./payload-contract";
 import { saveUndo } from "./replace-undo";
 import { buildChanged, buildNoop, type RMetrics, type TResult } from "./replace-response";
 import { serveRows, servedHashesFromDiff } from "./served";
-import { abortIf, assertLineLimit, errCode, isRec, splitLines } from "./utils";
-import { MAX_BYTES } from "./constants";
+import { abortIf, assertByteLimit, assertLineLimit, errCode, isRec, splitLines } from "./utils";
 
 export interface PlannedMember {
   batchKey: number;
+  id: string;
   display: number;
   total: number;
   target: string;
@@ -126,12 +126,18 @@ const batches = new Map<number, BatchState>();
 let nextBatchKey = 1;
 const abortedMembers = new Map<string, { display: number; message: string }>();
 const ABORTED_MEMBERS_LIMIT = 1024;
+const placeholderResults = new Map<string, TResult>();
 
 function markBatchMembersAborted(runtime: BatchState): void {
   const message = abortedBatchMessage(runtime);
   for (const id of runtime.memberIds) {
     abortedMembers.delete(id);
     abortedMembers.set(id, { display: runtime.display, message });
+    const result = placeholderResults.get(id);
+    if (result?.details.batch) {
+      result.details.batch.aborted = true;
+      result.details.batch.abortMessage = message;
+    }
   }
   while (abortedMembers.size > ABORTED_MEMBERS_LIMIT) {
     const oldest = abortedMembers.keys().next().value;
@@ -157,6 +163,7 @@ export function resetBatchStateForTests(): void {
   plan.clear();
   batches.clear();
   abortedMembers.clear();
+  placeholderResults.clear();
   nextBatchKey = 1;
 }
 
@@ -203,7 +210,12 @@ function enforceCap(): void {
     if (oldest === undefined) return;
     const state = batches.get(oldest);
     batches.delete(oldest);
-    if (state) for (const id of state.memberIds) plan.delete(id);
+    if (state) {
+      for (const id of state.memberIds) {
+        plan.delete(id);
+        placeholderResults.delete(id);
+      }
+    }
   }
 }
 
@@ -274,6 +286,7 @@ export async function planAssistantMessage(message: unknown, cwd: string): Promi
     group.forEach((item, index) => {
       plan.set(item.id, {
         batchKey: key,
+        id: item.id,
         display,
         total: finalGroups.length,
         target: item.target,
@@ -521,7 +534,11 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
   if (noop) runtime.noops += 1;
   else runtime.applied += 1;
   runtime.warnings.push(...piece.warnings);
-  if (!input.member.last) return batchPlaceholder(input.member, piece, base.snapshotId);
+  if (!input.member.last) {
+    const placeholder = batchPlaceholder(input.member, piece, base.snapshotId);
+    placeholderResults.set(input.member.id, placeholder);
+    return placeholder;
+  }
   return finishBatch(input.member, input.signal);
 }
 
@@ -633,9 +650,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     assertNotEmpty(base.content, composed);
     assertLineLimit(composed, paths.displayPath, MAX_HASH_LINES);
     const finalBytes = base.bom + restoreEndings(composed, base.ending);
-    if (Buffer.byteLength(finalBytes, "utf-8") > MAX_BYTES) {
-      throw new Error(`[E_FILE_TOO_LARGE] File is too large: ${paths.displayPath} (exceeds the ${MAX_BYTES / (1024 * 1024)}MB size limit). For very large files, use write.`);
-    }
+    assertByteLimit(finalBytes, paths.displayPath);
   } catch (error) {
     discardBatchState(runtime);
     if (error instanceof Error) error.message = withAbortSuffix(error.message, runtime.display);
@@ -739,7 +754,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     await getDiffContextLines(),
   );
   changed.details.diff = `${header}\n${changed.details.diff}`;
-  changed.details.diffLineNumbers?.unshift(undefined);
+  changed.details.diffLineNumbers?.unshift(null);
   try {
     serveRows(runtime.target, resultHashes, splitLines(composed), servedHashesFromDiff(changed.details.diff));
   } catch (error) {
@@ -786,7 +801,10 @@ export async function finalizeTurn(toolCallIds: string[]): Promise<void> {
   for (const key of keys) {
     const runtime = batches.get(key);
     if (!runtime) continue;
-    for (const id of runtime.memberIds) plan.delete(id);
+    for (const id of runtime.memberIds) {
+      plan.delete(id);
+      placeholderResults.delete(id);
+    }
     batches.delete(key);
   }
 }

package/src/commit.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import type { PipelineResult } from "./replace";
-import { abortIf, errCode, splitLines } from "./utils";
+import { abortIf, assertByteLimit, errCode, splitLines } from "./utils";
 import { DEDUP_ANCHOR } from "./constants";
 import { HASH_SEP } from "./hashline";
 import { buildChanged, buildNoop, type RMeta, type TResult } from "./replace-response";
@@ -70,6 +70,9 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     );
   }
 
+  const finalFileBytes = pipe.bom + restoreEndings(pipe.result, pipe.originalEnding);
+  assertByteLimit(finalFileBytes, path);
+
   if (pipe.hadUtf8DecodeErrors) {
     warnings.push(
       "Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8.",
@@ -112,7 +115,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     abortIf(signal);
     await writeAtomic(
       absolutePath,
-      pipe.bom + restoreEndings(pipe.result, pipe.originalEnding),
+      finalFileBytes,
       pipe.identity,
     );
   } catch (error) {

package/src/grep.ts

@@ -3,11 +3,12 @@ import { formatSize, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type TruncationResult
 import { Type } from "typebox";
 import { stat } from "node:fs/promises";
 import { dirname, isAbsolute, join, win32 } from "node:path";
+import { pathToFileURL } from "node:url";
 import { spawn, spawnSync } from "node:child_process";
 import { createInterface } from "node:readline";
 import { tryReadNormFile } from "./file-reader";
 import { globToRegex } from "./glob";
-import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP } from "./hashline";
+import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP, HASH_CLASS } from "./hashline";
 import { ANCHOR_POOL_EXHAUSTED_PREFIX, MAX_GREP_LINE_BYTES } from "./constants";
 import { toCwd, toDisplayPath } from "./paths";
 import { loadP, loadGuide } from "./prompts";
@@ -276,10 +277,9 @@ export async function resolveRgPath(): Promise<string> {
     const { createRequire } = await import("node:module");
     const require = createRequire(import.meta.url);
     const pkgPath = require.resolve("@earendil-works/pi-coding-agent/package.json");
-    const { dirname } = await import("node:path");
     const piDir = dirname(pkgPath);
     const toolsManagerPath = join(piDir, "dist/utils/tools-manager.js");
-    const mod = await import("file://" + toolsManagerPath);
+    const mod = await import(pathToFileURL(toolsManagerPath).href);
     if (mod.ensureTool) {
       const p = await mod.ensureTool("rg", true);
       if (p) { cachedRgPath = p; return p; }
@@ -468,7 +468,7 @@ function highlightMatches(text: string, regex: RegExp, theme: FgT): string {
   return out + text.slice(last);
 }
 
-const ANCHORED_ROW_RE = /^[A-Za-z0-9]{4}│/;
+const ANCHORED_ROW_RE = new RegExp(`^${HASH_CLASS}${HASH_SEP}`);
 
 function highlightHitRow(row: string, highlight: RegExp, theme: FgT): string {
   const anchored = row.match(ANCHORED_ROW_RE);

package/src/hash-store.ts

@@ -117,7 +117,6 @@ interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
   getState: (...params: SqlParams) => Record<string, unknown> | undefined;
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
-  allHashes: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
   undoUpsert: (...params: SqlParams) => void;
@@ -205,7 +204,6 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
   const getStateStmt = db.prepare("SELECT checksum, hashes, line_checksums FROM snapshots WHERE path = ?");
   const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo");
-  const allHashesStmt = db.prepare("SELECT path, hashes FROM snapshots");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
   const upsertStmt = db.prepare(
     "INSERT INTO snapshots (path, checksum, line_count, hashes, line_checksums, updated_at) VALUES (?, ?, ?, ?, ?, ?) " +
@@ -224,8 +222,7 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   const stmts: Prepared = {
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     getState: (...params) => getStateStmt.get(...params) as Record<string, unknown> | undefined,
-    allPaths: (...params) => allStmt.all(...params) as Record<string, unknown>[],
-    allHashes: (...params) => allHashesStmt.all(...params) as Record<string, unknown>[],
+    allPaths: (...params) => withBusyRetry(() => allStmt.all(...params) as Record<string, unknown>[]),
     deleteOne: retriedWrite(delStmt),
     upsert: retriedWrite(upsertStmt),
     undoUpsert: retriedWrite(undoUpsertStmt),

package/src/hashline/alphabet.ts

@@ -6,32 +6,16 @@ if (typeof rawAnchors !== "string" || rawAnchors.length === 0 || rawAnchors.leng
 const TABLE: string = rawAnchors;
 export const HASH_LEN = 4;
 export const ANCHOR_COUNT = TABLE.length / HASH_LEN;
-const ALNUM = "A-Za-z0-9";
+const LETTERS = "A-Za-z";
 
-export const ALPH_RE = new RegExp(`^[${ALNUM}]+$`);
+export const ALPH_RE = new RegExp(`^[${LETTERS}]+$`);
 
-export const HASH_CLASS = `[${ALNUM}]{${HASH_LEN}}`;
+export const HASH_CLASS = `[${LETTERS}]{${HASH_LEN}}`;
 
-export const HASH_RUN = `[${ALNUM}]{${HASH_LEN},${HASH_LEN + 1}}`;
+export const HASH_RUN = `[${LETTERS}]{${HASH_LEN},${HASH_LEN + 1}}`;
 
 export const HASH_RE = new RegExp(`^${HASH_CLASS}$`);
 
-let indexByAnchor: Map<string, number> | undefined;
-
-function reverseIndex(): Map<string, number> {
-  if (!indexByAnchor) {
-    indexByAnchor = new Map();
-    for (let i = 0; i < ANCHOR_COUNT; i++) {
-      indexByAnchor.set(TABLE.slice(i * HASH_LEN, i * HASH_LEN + HASH_LEN), i);
-    }
-  }
-  return indexByAnchor;
-}
-
 export function anchorAt(idx: number): string {
   return TABLE.slice(idx * HASH_LEN, idx * HASH_LEN + HASH_LEN);
 }
-
-export function anchorIndex(hash: string): number {
-  return reverseIndex().get(hash) ?? -1;
-}

package/src/hashline/apply.ts

@@ -1,5 +1,4 @@
 import { abortIf, clipLine, splitLines } from "../utils";
-import { _lineHashesPure } from "./hash";
 import {
 	valEdit,
 	stripBarePrefixes,

package/src/hashline/parse.ts

@@ -13,7 +13,7 @@ function diagRef(ref: string): string {
 	const trimmed = ref.trim();
 
 	if (!trimmed.length) {
-		return `[E_BAD_REF] Invalid anchor. Expected a 4-char alphanumeric anchor (e.g. "Hasu").`;
+		return `[E_BAD_REF] Invalid anchor. Expected a 4-character anchor (letters only, e.g. "Hasu").`;
 	}
 
 	if (/^\d+/.test(trimmed)) {
@@ -29,13 +29,13 @@ function diagRef(ref: string): string {
 		const firstHash = firstMatch?.[0] ?? "Hasu";
 		const lastHash = lastMatch?.[0] ?? "Hasu";
 		const preview = first.slice(0, 60);
-		return `[E_BAD_REF] Invalid anchor — remove_from and remove_to must each be a single bare 4-char hash (e.g. "Hasu"), not a block with HASH│content. Received ${lines.length} lines starting "${preview}…" — use only the first hash "${firstHash}" as remove_from and "${lastHash}" as remove_to, and put the new content (without HASH│) in replacement_lines.`;
+		return `[E_BAD_REF] Invalid anchor — remove_from and remove_to must each be a single bare 4-character anchor (letters only, e.g. "Hasu"), not a block with HASH│content. Received ${lines.length} lines starting "${preview}…" — use only the first hash "${firstHash}" as remove_from and "${lastHash}" as remove_to, and put the new content (without HASH│) in replacement_lines.`;
 	}
 	if (trimmed.includes("│")) {
-		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 4-char anchor, drop everything from "│" onward.`;
+		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 4-character anchor, drop everything from "│" onward.`;
 	}
 
-	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 4-char alphanumeric anchor (e.g. "Hasu").`;
+	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 4-character anchor (letters only, e.g. "Hasu").`;
 }
 
 function parseRef(ref: string): Anchor {

package/src/read.ts

@@ -19,7 +19,7 @@ import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-
 import { valAccess } from "./validation";
 import { readConfig } from "./config";
 import { resolveTarget } from "./fs-write";
-import { withAnchorSession, servedForPath } from "./anchor-registry";
+import { withAnchorSession, servedForPath, sessionKeyFor } from "./anchor-registry";
 import { serveRows } from "./served";
 import { getAutoReadAllSnapshot } from "./auto-read-all-state";
 import { Text } from "@earendil-works/pi-tui";
@@ -217,7 +217,7 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
                 if (autoReadAllMode !== "off") {
                   const canonical = await resolveTarget(absolutePath).catch(() => undefined);
                   if (canonical !== undefined) {
-                    const stored = getAutoReadAllSnapshot(canonical);
+                    const stored = getAutoReadAllSnapshot(sessionKeyFor(ctx), canonical);
                     if (stored !== undefined) {
                       const current = await safeSnapId(canonical, "auto-read-all guard");
                       if (current !== undefined && current === stored) {

package/src/replace-diff.ts

@@ -4,6 +4,7 @@ import {
   _lineHashesPure,
   ANCHOR_LEN,
   HASH_SEP,
+  HASH_CLASS,
   changedRange,
 } from "./hashline";
 import { MAX_DIFF_INPUT_BYTES, DEDUP_ANCHOR } from "./constants";
@@ -111,7 +112,7 @@ export function spansFromHashes(oldHashes: string[], newHashes: string[]): DiffS
   return spans;
 }
 
-const ANCHORED_DIFF_ROW_RE = /^([+ -])([A-Za-z0-9]{4})│/;
+const ANCHORED_DIFF_ROW_RE = new RegExp(`^([+ -])(${HASH_CLASS})│`);
 
 export function disambiguateDuplicateAnchors(diff: string): string {
   if (!diff.includes("│")) return diff;

package/src/replace-render.ts

@@ -42,7 +42,7 @@ export function colorLines(lines: string[], theme: FgT): string[] {
 		return theme.fg("dim", line);
 	});
 }
-export function toNumberedDiff(diff: string, lineNumbers: (number|undefined)[]): string {
+export function toNumberedDiff(diff: string, lineNumbers: (number | null | undefined)[]): string {
 	return withLineNumbers(diff, lineNumbers);
 }
 
@@ -162,7 +162,7 @@ function extractSummary(text: string | undefined): string | undefined {
 
 const BATCH_HEADER_RE = /^batch \d+:\n/;
 
-function splitBatchHeader(diff: string, lineNumbers: (number | undefined)[] | undefined): { header: string | undefined; body: string; lineNumbers: (number | undefined)[] | undefined } {
+function splitBatchHeader(diff: string, lineNumbers: (number | null | undefined)[] | undefined): { header: string | undefined; body: string; lineNumbers: (number | null | undefined)[] | undefined } {
 	const match = diff.match(BATCH_HEADER_RE);
 	if (!match) return { header: undefined, body: diff, lineNumbers };
 	return { header: match[0]!.slice(0, -1), body: diff.slice(match[0].length), lineNumbers: lineNumbers?.slice(1) };

package/src/replace-response.ts

@@ -240,7 +240,7 @@ export function buildChanged(input: SuccessInput, verb = "replaced", diffContext
         editMeta.firstChangedLine ?? baseDiff.firstChangedLine,
       snapshotId,
       metrics,
-      diffLineNumbers: diffResult.lineNumbers,
+      diffLineNumbers: diffResult.lineNumbers.map((line) => line ?? null),
       ...(warnings?.length ? { warnings: [...warnings] } : {}),
     },
   };

package/src/replace-undo.ts

@@ -248,7 +248,7 @@ export function regUndo(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
             ],
             details: {
               diff: undoDiff,
-              diffLineNumbers: undoDiffResult.lineNumbers,
+              diffLineNumbers: undoDiffResult.lineNumbers.map((line) => line ?? null),
               patch: patchResult.patch,
               ...(patchResult.truncated ? { patchTruncated: true as const } : {}),
               metrics: buildMetrics({

package/src/replace.ts

@@ -45,9 +45,9 @@ export type ReplaceDetails = {
   snapshotId?: string;
   classification?: "noop";
   metrics?: RMetrics;
-  diffLineNumbers?: (number|undefined)[];
+  diffLineNumbers?: (number | null)[];
   warnings?: string[];
-  batch?: { id: number; size: number; last: boolean; total: number };
+  batch?: { id: number; size: number; last: boolean; total: number; aborted?: boolean; abortMessage?: string };
 };
 
 export interface PipelineResult {

package/src/utils.ts

@@ -1,4 +1,5 @@
-import { NUL_CONTENT_MSG } from "./constants";
+import { NUL_CONTENT_MSG, MAX_BYTES } from "./constants";
+import { HASH_CLASS } from "./hashline/alphabet";
 
 export function isRec(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -141,8 +142,10 @@ export function getCached<K, V>(map: Map<K, V>, key: K, compute: (key: K) => V):
 	return v;
 }
 
+const HASH_ROW_RE = new RegExp(`^${HASH_CLASS}│`);
+
 export function isHashRow(line: string): boolean {
-	return /^[A-Za-z0-9]{4}│/.test(line);
+	return HASH_ROW_RE.test(line);
 }
 
 export function gutterWidth(max: number, fallback: number): number {
@@ -170,14 +173,14 @@ export function numberedRead(text: string, offset: number): string {
 	}).join("\n");
 }
 
-export function withLineNumbers(text: string, numbers: (number|undefined)[]): string {
+export function withLineNumbers(text: string, numbers: (number | null | undefined)[]): string {
 	const lines = text.split("\n");
 	const nums = numbers ?? [];
-	const max = nums.reduce<number>((m, n) => n !== undefined && n > m ? n : m, 0);
+	const max = nums.reduce<number>((m, n) => n !== undefined && n !== null && n > m ? n : m, 0);
 	const width = gutterWidth(max, lines.length);
 	return lines.map((line, i) => {
 		const n = nums[i];
-		const prefix = n !== undefined ? formatGutter(n, width) : blankGutter(width);
+		const prefix = n !== undefined && n !== null ? formatGutter(n, width) : blankGutter(width);
 		return prefix + line;
 	}).join("\n");
 }
@@ -189,6 +192,11 @@ export function assertLineLimit(content: string, displayPath: string, limit: num
 	const count = splitLines(content).length;
 	if (count > limit) throw new Error(formatLineLimit(displayPath, limit, count));
 }
+export function assertByteLimit(content: string, displayPath: string, limit = MAX_BYTES): void {
+	if (Buffer.byteLength(content, "utf-8") > limit) {
+		throw new Error(`[E_FILE_TOO_LARGE] File is too large: ${displayPath} (exceeds the ${limit / (1024 * 1024)}MB size limit). For very large files, use write.`);
+	}
+}
 export function lineLimitMoreThanMessage(displayPath: string, limit: number): string {
 	return formatLineLimit(displayPath, limit, undefined);
 }

package/src/write-hook.ts

@@ -5,7 +5,7 @@ import { servedForPath, withAnchorSession } from "./anchor-registry";
 import { resolveInCwd } from "./fs-write";
 import { abortIf, splitLines, isRec, normalizeFilePath } from "./utils";
 
-const HASH_ECHO_RE = new RegExp(`^(${HASH_CLASS})${HASH_SEP}`);
+const HASH_ECHO_RE = new RegExp(`^(?: *[0-9]+ ${HASH_SEP} )?[+ -]?(${HASH_CLASS})${HASH_SEP}`);
 
 function searchEcho(lines: string[], served: ReadonlyMap<string, string> | ReadonlySet<string>): { line: number; hash: string } | undefined {
   for (let i = 0; i < lines.length; i++) {
@@ -27,7 +27,7 @@ export async function servedHashEchoDenial(rawPath: string, content: string, cwd
   if (!served || served.size === 0) return undefined;
   const echo = findServedHashEcho(content, served);
   if (!echo) return undefined;
-  return `[E_WRITE_HASH_ECHO] Refused write to ${rawPath}: line ${echo.line} begins with the exact ${echo.hash}${HASH_SEP} anchor served for this file. Remove the copied anchors and retry.`;
+  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.`;
 }
 
 export function registerWriteHook(pi: ExtensionAPI): void {