pi-hashline-edit-pro 4.2.1 → 4.2.3

package/README.md

@@ -93,11 +93,11 @@ Common copy-paste slips are fixed automatically and reported as warnings: a left
 
 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`.
 
-An edit that produces identical content reports `No changes made` and leaves the anchors alone. When a noop happened because the boundary anti-duplication cut a line from the replacement, sending the same replacement once more runs with that dedup turned off for the single call and applies the lines literally; the result carries a `[W_BOUNDARY_BYPASS]` notice. The pending bypass is per file and keyed to the payload; copied prefixes, diff markers, and stray whitespace are normalized before matching. Any applied edit or successful `write` clears it.
+An edit that produces identical content reports `No changes made` and leaves the anchors alone. When a noop happened because the boundary anti-duplication cut a line from the replacement, sending the same replacement once more runs with that dedup turned off for the single call and applies the lines literally; the result carries a `[W_BOUNDARY_BYPASS]` notice. The pending bypass is per file and keyed to the payload; copied prefixes, diff markers, and stray whitespace are normalized before matching. Any applied edit or successful `write` clears it. A pending bypass overrides `strict` mode for its one resend; an aborted batch preserves a consumed bypass for retry.
 
 After a successful edit, the diff is capped at 50KB. A row over 50KB is shown as a marker that keeps the row's anchor, and only the rows shown in the capped diff are recorded as served. The same caps apply to the `insert` and `undo_last_change` diffs, to the interactive previews, and to `details.patch`.
 
-Multiple `replace` and `insert` calls on the same file in one message are grouped per file into one batch that validates every call against the pre-batch state and then applies them together on the batch's last call: earlier calls reply `In batch` (`In batch N` when several files batch) and the batch's last call shows the combined diff, with one undo reverting the whole batch. Batched calls must target disjoint ranges; overlapping ranges, or any failing call, aborts the whole batch with nothing written. Verify each batch diff before the next turn's edits on that file.
+Multiple `replace` and `insert` calls on the same file in one message are grouped per file into one batch that validates every call against the pre-batch state and then applies them together on the batch's last call: earlier calls reply `In batch` (`In batch N` when several files batch) and the batch's last call shows the combined diff, with one undo reverting the whole batch. Batched calls must target disjoint ranges; overlapping ranges, or any failing call, aborts the whole batch. Calls with stale anchors join their file's batch through a `requirePath` path hint or a valid co-anchor and abort it instead of applying partially; a same-turn sibling whose anchors resolve nowhere still aborts the batch when no other file is being edited. An error that aborts a batch ends with `Aborts batch N.`, while the abort itself reads `[E_OP_ABORTED] Batch N aborted.` Anchor capacity is preflighted before writing; if anchor finalization fails after the write, the error states the file was written with one undo available. Verify each batch diff before the next turn's edits on that file.
 
 ### insert
 
@@ -236,8 +236,8 @@ Codes starting with `E_` are errors (the operation failed); codes starting with
 | `[E_REGISTRY]` | The anchor registry was not initialized; a serve or edit ran outside an initialized session. |
 | `[E_WRITE_HASH_ECHO]` | A `write` `content` line begins with the exact `anchor│` served for this file at the same line. The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
 | `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |
-| `[E_BATCH_OVERLAP]` | Batched `replace`/`insert` calls target overlapping ranges; the whole batch was refused with nothing written. Retry with disjoint ranges. |
-| `[E_BATCH_ABORTED]` | A same-turn edit batch aborted (a member failed, or the file changed mid-turn); nothing was written. The first failure is quoted; fix it and retry the batch. |
+| `[E_BATCH_OVERLAP]` | Batched `replace`/`insert` calls target overlapping ranges; the whole batch was refused. Retry with disjoint ranges. |
+| `[E_OP_ABORTED]` | An edit aborted (a same-turn batch member failed, or the file changed or was deleted after the edit started). Fix the sibling failure and retry the batch, otherwise call `read` for fresh anchors and retry. |
 | `[E_UNSAFE_REGEX]` | A grep regex can trigger excessive backtracking; simplify it or search with `literal: true`. |
 
 ## Troubleshooting

package/index.ts

@@ -11,7 +11,7 @@ import type { ReplaceDetails } from "./src/replace";
 import { extractWarnings } from "./src/replace-render";
 import { MAX_HASH_LINES } from "./src/hashline";
 import {
-  readConfig,
+  readConfigWithStatus,
   toggleAutoRead,
   toggleAnchorGrep,
   toggleRequirePath,
@@ -75,7 +75,8 @@ export default function (pi: ExtensionAPI): void {
     const sessionFile = sessionManager?.getSessionFile?.();
     await initRegistry(sessionFile);
     await gcRegistrySidecars();
-    const config = await readConfig();
+    const { config, corrupted } = await readConfigWithStatus();
+    if (corrupted && (ctx as { hasUI?: boolean }).hasUI) ctx.ui.notify("Hashline config was corrupt and was reset to defaults", "warning");
     autoRead = config.autoRead;
     await refreshEditTools();
     pi.setActiveTools(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.2.1",
+  "version": "4.2.3",
   "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

@@ -1,4 +1,4 @@
-import { chmod, mkdir, readFile, readdir, rm, stat } from "fs/promises";
+import { chmod, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "fs/promises";
 import { appendFileSync, chmodSync } from "fs";
 import { join } from "path";
 import { createHash } from "crypto";
@@ -16,6 +16,7 @@ export type RegistryEvent =
   | { kind: "session"; sessionFile: string }
   | { kind: "allocate"; path: string; rows: [string, string][] }
   | { kind: "free"; path: string; anchors?: string[] }
+  | { kind: "minted"; anchors: string[] }
   | { kind: "clear" };
 
 export interface OwnedAnchor {
@@ -31,7 +32,9 @@ interface SessionState {
 }
 
 const SIDECAR_SUFFIX = ".registry.jsonl";
-
+const SIDECAR_COMPACT_LINES = 5000;
+const SIDECAR_COMPACT_BYTES = 1024 * 1024;
+const SIDECAR_COMPACT_CHUNK = 5000;
 let currentKey: string | undefined;
 let currentSidecar: string | undefined;
 const registries = new Map<string, SessionState>();
@@ -62,6 +65,8 @@ export function foldRegistryEvents(events: RegistryEvent[]): SessionState {
   for (const event of events) {
     if (event.kind === "clear") {
       state.owned.clear();
+    } else if (event.kind === "minted") {
+      for (const anchor of event.anchors) state.everMinted.add(anchor);
     } else if (event.kind === "allocate") {
       for (const [anchor, checksum] of event.rows) {
         state.owned.set(anchor, { path: event.path, checksum });
@@ -90,7 +95,7 @@ export function parseRegistryLog(raw: string): RegistryEvent[] {
     if (!line.trim()) continue;
     try {
       const parsed = JSON.parse(line) as RegistryEvent;
-      if (parsed && (parsed.kind === "allocate" || parsed.kind === "free" || parsed.kind === "clear" || parsed.kind === "session")) {
+      if (parsed && (parsed.kind === "allocate" || parsed.kind === "free" || parsed.kind === "clear" || parsed.kind === "session" || parsed.kind === "minted")) {
         events.push(parsed);
       }
     } catch {
@@ -107,6 +112,46 @@ function sidecarPath(key: string): string {
 function sidecarKeyFor(sessionFile: string): string {
   return createHash("sha256").update(sessionFile).digest("hex").slice(0, 24);
 }
+export function shouldCompactSidecar(raw: string): boolean {
+  if (raw.length >= SIDECAR_COMPACT_BYTES) return true;
+  let lines = 0;
+  for (let i = 0; i < raw.length; i++) if (raw.charCodeAt(i) === 10) lines += 1;
+  return lines >= SIDECAR_COMPACT_LINES;
+}
+export function buildCompactedLog(sessionFile: string, state: SessionState): string {
+  const byPath = new Map<string, Array<[string, string]>>();
+  for (const [anchor, entry] of state.owned) {
+    const rows = byPath.get(entry.path) ?? [];
+    rows.push([anchor, entry.checksum]);
+    byPath.set(entry.path, rows);
+  }
+  const out: string[] = [JSON.stringify({ kind: "session", sessionFile })];
+  for (const [path, rows] of byPath) {
+    for (let i = 0; i < rows.length; i += SIDECAR_COMPACT_CHUNK) {
+      out.push(JSON.stringify({ kind: "allocate", path, rows: rows.slice(i, i + SIDECAR_COMPACT_CHUNK) }));
+    }
+  }
+  const freedHistory = [...state.everMinted].filter((anchor) => !state.owned.has(anchor));
+  for (let i = 0; i < freedHistory.length; i += SIDECAR_COMPACT_CHUNK) {
+    out.push(JSON.stringify({ kind: "minted", anchors: freedHistory.slice(i, i + SIDECAR_COMPACT_CHUNK) }));
+  }
+  return out.join("\n") + "\n";
+}
+async function compactSidecarIfNeeded(sidecar: string, raw: string, sessionFile: string, state: SessionState): Promise<void> {
+  if (!shouldCompactSidecar(raw)) return;
+  const tmp = `${sidecar}.compact-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  try {
+    const compacted = buildCompactedLog(sessionFile, state);
+    await writeFile(tmp, compacted, { mode: 0o600 });
+    if (process.platform !== "win32") {
+      try { await chmod(tmp, 0o600); } catch { }
+    }
+    await rename(tmp, sidecar);
+  } catch (error) {
+    console.error("Failed to compact anchor registry sidecar:", error);
+    try { await rm(tmp, { force: true }); } catch { }
+  }
+}
 
 export async function initRegistry(sessionFile: string | undefined): Promise<void> {
   if (!sessionFile) {
@@ -119,9 +164,10 @@ export async function initRegistry(sessionFile: string | undefined): Promise<voi
   currentKey = key;
   currentSidecar = sidecarPath(key);
   let events: RegistryEvent[] = [];
+  let rawLog = "";
   try {
-    const raw = await readFile(currentSidecar, "utf-8");
-    events = parseRegistryLog(raw);
+    rawLog = await readFile(currentSidecar, "utf-8");
+    events = parseRegistryLog(rawLog);
   } catch (error) {
     if (errCode(error) !== "ENOENT") {
       console.error("Failed to read anchor registry sidecar:", error);
@@ -130,6 +176,9 @@ export async function initRegistry(sessionFile: string | undefined): Promise<voi
   const folded = foldRegistryEvents(events);
   seedServedFromOwned(folded);
   registries.set(key, folded);
+  if (rawLog.length > 0) {
+    await compactSidecarIfNeeded(currentSidecar, rawLog, sessionFile, folded);
+  }
   try {
     await mkdir(sessionClaimsDir(), { recursive: true, mode: 0o700 });
     if (process.platform !== "win32") {
@@ -170,7 +219,7 @@ function fingerprintIndex(state: SessionState, path: string): Map<string, string
   return index;
 }
 
-const MINT_PROBE_LIMIT = 8192;
+export const MINT_PROBE_LIMIT = 8192;
 
 export function mintAnchor(state: SessionState): string {
   for (let probe = 0; probe < MINT_PROBE_LIMIT; probe++) {
@@ -595,6 +644,16 @@ export async function gcRegistrySidecars(): Promise<void> {
     return;
   }
   for (const name of names) {
+    if (name.includes(`${SIDECAR_SUFFIX}.compact-`)) {
+      const tmpPath = join(sessionClaimsDir(), name);
+      try {
+        const tmpStat = await stat(tmpPath);
+        if (Date.now() - tmpStat.mtimeMs > 60 * 60 * 1000) await rm(tmpPath, { force: true });
+      } catch (error) {
+        if (errCode(error) !== "ENOENT") console.error("Failed to inspect registry sidecar:", error);
+      }
+      continue;
+    }
     if (!name.endsWith(SIDECAR_SUFFIX)) continue;
     const sidecar = join(sessionClaimsDir(), name);
     try {

package/src/batch.ts

@@ -2,7 +2,7 @@ import { readFile } from "fs/promises";
 import { constants } from "fs";
 import { relative } from "path";
 import { readConfig, getDiffContextLines } from "./config";
-import { throwIfStrictInput, tryResolveEditTarget } from "./edit-common";
+import { resolveEditTarget, throwIfStrictInput, tryResolveEditTarget } from "./edit-common";
 import { readNormFile, safeSnapId } from "./file-reader";
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import {
@@ -50,6 +50,7 @@ interface BatchBase {
   hadUtf8DecodeErrors: boolean;
   absolutePath: string;
   snapshotId?: string;
+  baseLines: string[];
 }
 
 export interface BatchPiece {
@@ -65,6 +66,7 @@ export interface BatchPiece {
   noop: boolean;
   noopPayload?: string;
   foldedLines: number;
+  bypassConsumed?: boolean;
 }
 
 export interface BatchMemberInput {
@@ -80,6 +82,7 @@ export interface BatchMemberInput {
   strictBoundaryDedup: boolean;
   noopPayload?: string;
   foldedLines?: number;
+  bypassConsumed?: boolean;
 }
 
 interface BatchState {
@@ -97,6 +100,7 @@ interface BatchState {
   failures: number;
   failed: boolean;
   firstError?: unknown;
+  poisonedBy?: string;
   warnings: string[];
 }
 
@@ -144,13 +148,39 @@ function normalizeEditArgs(args: unknown): NormalizedEditArgs | undefined {
   }
   return undefined;
 }
-
 function anchorTargetFor(args: unknown): string | undefined {
   const normalized = normalizeEditArgs(args);
   if (!normalized) return undefined;
   if (normalized.kind === "replace") return tryResolveEditTarget(normalized.removeFrom, normalized.removeTo);
   return tryResolveEditTarget(normalized.anchor);
 }
+function unresolvedErrorFor(call: EditCall): Error {
+  const normalized = normalizeEditArgs(call.args);
+  if (!normalized) return new Error(`sibling invalid`);
+  const refs = normalized.kind === "replace" ? [normalized.removeFrom, normalized.removeTo].filter((ref): ref is string => typeof ref === "string").join("→") : normalized.anchor;
+  try {
+    if (normalized.kind === "replace") resolveEditTarget(normalized.removeFrom, normalized.removeTo);
+    else resolveEditTarget(normalized.anchor);
+  } catch {
+    return new Error(`sibling stale (${refs})`);
+  }
+  return new Error(`sibling stale (${refs})`);
+}
+async function inferredTargetFor(args: unknown, cwd: string, requirePath: boolean): Promise<string | undefined> {
+  const normalized = normalizeEditArgs(args);
+  if (!normalized) return undefined;
+  if (requirePath && normalized.path) {
+    try {
+      return (await resolveInCwd(normalized.path, cwd)).resolved;
+    } catch {
+      return undefined;
+    }
+  }
+  if (normalized.kind === "replace") {
+    return tryResolveEditTarget(normalized.removeFrom) ?? (normalized.removeTo ? tryResolveEditTarget(normalized.removeTo) : undefined);
+  }
+  return undefined;
+}
 
 async function verifyPaths(
   group: Array<{ id: string; target: string; kind: BatchKind; args: unknown }>,
@@ -191,10 +221,12 @@ export async function planAssistantMessage(message: unknown, cwd: string): Promi
     calls.push({ id: block.id, name: block.name, args: block.arguments });
   }
   if (calls.length < 2) return;
+  const earlyConfig = await readConfig();
+  const requirePath = earlyConfig.requirePath === true;
   interface ResolvedCall { id: string; target: string; kind: BatchKind; args: unknown }
   const resolved: ResolvedCall[] = [];
   for (const call of calls) {
-    const target = anchorTargetFor(call.args);
+    const target = anchorTargetFor(call.args) ?? await inferredTargetFor(call.args, cwd, requirePath);
     if (target) resolved.push({ id: call.id, target, kind: call.name as BatchKind, args: call.args });
   }
   const groups = new Map<string, ResolvedCall[]>();
@@ -204,10 +236,8 @@ export async function planAssistantMessage(message: unknown, cwd: string): Promi
     groups.set(item.target, group);
   }
   const multi = [...groups.values()].filter((group) => group.length >= 2);
-  if (multi.length === 0) return;
-  const config = await readConfig();
   const finalGroups: ResolvedCall[][] = [];
-  if (config.requirePath === true) {
+  if (requirePath) {
     for (const group of multi) {
       const verified = await verifyPaths(group, cwd);
       if (verified.length >= 2) finalGroups.push(verified);
@@ -215,11 +245,22 @@ export async function planAssistantMessage(message: unknown, cwd: string): Promi
   } else {
     finalGroups.push(...multi);
   }
-  if (finalGroups.length === 0) return;
+  const resolvedIds = new Set(resolved.map((item) => item.id));
+  const unplanned = calls.filter((call) => !resolvedIds.has(call.id));
+  let poison: { target: string; error: unknown; callId: string } | undefined;
+  if (unplanned.length > 0 && groups.size === 1) {
+    const sole = [...groups.values()][0]!;
+    const poisonTarget = sole[0]!.target;
+    const poisonCall = unplanned[0]!;
+    poison = { target: poisonTarget, error: unresolvedErrorFor(poisonCall), callId: poisonCall.id };
+    if (!finalGroups.some((group) => group[0]!.target === poisonTarget)) finalGroups.push(sole);
+  }
   let display = 0;
   for (const group of finalGroups) {
     display += 1;
     const key = nextBatchKey++;
+    const matchingPoison = poison !== undefined && group[0]!.target === poison.target ? poison : undefined;
+    const poisoned = matchingPoison !== undefined;
     batches.set(key, {
       display,
       target: group[0]!.target,
@@ -229,8 +270,9 @@ export async function planAssistantMessage(message: unknown, cwd: string): Promi
       pieces: [],
       applied: 0,
       noops: 0,
-      failures: 0,
-      failed: false,
+      failures: poisoned ? 1 : 0,
+      failed: poisoned,
+      ...(matchingPoison ? { firstError: matchingPoison.error, poisonedBy: matchingPoison.callId } : {}),
       warnings: [],
     });
     group.forEach((item, index) => {
@@ -310,9 +352,21 @@ function batchPlaceholder(member: PlannedMember, piece: BatchPiece, snapshotId:
   };
 }
 
+export function withAbortSuffix(message: string, display: number): string {
+  const suffix = `Aborts batch ${display}.`;
+  if (message.includes(suffix)) return message;
+  return message.endsWith(".") ? `${message} ${suffix}` : `${message}. ${suffix}`;
+}
+export function suffixPoisonCause(toolCallId: string, error: unknown): void {
+  if (!(error instanceof Error)) return;
+  for (const runtime of batches.values()) {
+    if (runtime.poisonedBy === toolCallId) error.message = withAbortSuffix(error.message, runtime.display);
+  }
+}
 export function noteBatchFailure(member: PlannedMember, error: unknown): void {
   const runtime = batches.get(member.batchKey);
   if (!runtime) return;
+  if (error instanceof Error && !error.message.startsWith("[E_OP_ABORTED]")) error.message = withAbortSuffix(error.message, member.display);
   runtime.failures += 1;
   if (!runtime.failed) {
     runtime.failed = true;
@@ -320,9 +374,15 @@ export function noteBatchFailure(member: PlannedMember, error: unknown): void {
   }
 }
 
-function batchAbortedError(runtime: BatchState): Error {
-  const first = runtime.firstError instanceof Error ? runtime.firstError.message : String(runtime.firstError);
-  return new Error(`[E_BATCH_ABORTED] Batch ${runtime.display} aborted; nothing was written. First failure: ${first}`);
+function batchAbortedError(runtime: BatchState, input?: BatchMemberInput): Error {
+  restoreBatchBypasses(runtime, input);
+  return new Error(`[E_OP_ABORTED] Batch ${runtime.display} aborted.`);
+}
+function restoreBatchBypasses(runtime: BatchState, input?: BatchMemberInput): void {
+  for (const piece of runtime.pieces) {
+    if (piece.bypassConsumed && piece.noopPayload) markBoundaryNoop(runtime.target, piece.noopPayload);
+  }
+  if (input?.bypassConsumed && input.noopPayload) markBoundaryNoop(input.mutationTargetPath, input.noopPayload);
 }
 
 export async function ensureBatchBase(input: {
@@ -351,6 +411,7 @@ export async function ensureBatchBase(input: {
     hadUtf8DecodeErrors: file.hadUtf8DecodeErrors,
     absolutePath: file.absolutePath,
     ...(snapshotId !== undefined ? { snapshotId } : {}),
+    baseLines: splitLines(file.normalized),
   };
   runtime.base = base;
   runtime.served = servedForPath(file.absolutePath);
@@ -365,7 +426,7 @@ export async function ensureBatchBase(input: {
 export async function executeBatchMember(input: BatchMemberInput): Promise<TResult> {
   const runtime = batches.get(input.member.batchKey);
   if (!runtime) throw new Error(`[E_STALE_ANCHOR] Batch ${input.member.display} is no longer tracked. Call read for fresh anchors.`);
-  if (runtime.failed) throw batchAbortedError(runtime);
+  if (runtime.failed) throw batchAbortedError(runtime, input);
   let base: BatchBase;
   try {
     base = await ensureBatchBase({
@@ -377,11 +438,13 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
     });
   } catch (error) {
     noteBatchFailure(input.member, error);
+    restoreBatchBypasses(runtime, input);
     throw error;
   }
   if (input.mutationTargetPath !== input.member.target) {
     const error = new Error(`[E_STALE_ANCHOR] "${input.hedit.hash_bounds[0].hash}" is no longer owned by ${input.member.target}. Call read for fresh anchors.`);
     noteBatchFailure(input.member, error);
+    restoreBatchBypasses(runtime, input);
     throw error;
   }
   const displayPath = runtime.paths?.displayPath ?? input.targetPath;
@@ -393,6 +456,7 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
       skipBoundaryDedup: input.skipBoundaryDedup,
       strictBoundaryDedup: input.strictBoundaryDedup,
       signal: input.signal,
+      baseFileLines: base.baseLines,
     });
   } catch (error) {
     if (error instanceof RangeStaleError) adoptAnchors(base.absolutePath, error.rangeServedMap);
@@ -400,15 +464,17 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
     else if (error instanceof Error && error.message.startsWith("[E_BOUNDARY_STRICT]")) {
       const indexed = new Error(`edit #${input.member.order} strict boundary-dedup rejection: ${error.message}`);
       noteBatchFailure(input.member, indexed);
+      restoreBatchBypasses(runtime, input);
       throw indexed;
     }
     noteBatchFailure(input.member, error);
+    restoreBatchBypasses(runtime, input);
     throw error;
   }
   const start = planned.resolved.hash_bounds[0].line;
   const end = planned.resolved.hash_bounds[1].line;
   const newLines = planned.resolved.content_lines;
-  const baseLines = splitLines(base.content);
+  const baseLines = base.baseLines;
   const originalSlice = baseLines.slice(start - 1, end);
   const noop = originalSlice.length === newLines.length && originalSlice.every((line, index) => line === newLines[index]);
   const autoFixes = planned.autoFixes?.length ?? 0;
@@ -425,6 +491,7 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
     noop,
     ...(input.noopPayload !== undefined ? { noopPayload: input.noopPayload } : {}),
     foldedLines: input.foldedLines ?? 0,
+    ...(input.bypassConsumed ? { bypassConsumed: true as const } : {}),
   };
   runtime.pieces.push(piece);
   if (input.kind === "replace") runtime.replaceCount += 1;
@@ -476,20 +543,27 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     const prev = ordered[i - 1]!;
     const current = ordered[i]!;
     if (current.start <= prev.end) {
+      restoreBatchBypasses(runtime);
       throw new Error(`[E_BATCH_OVERLAP] Batch ${runtime.display} has overlapping ranges: ${formatBatchPiece(prev)} overlaps ${formatBatchPiece(current)}`);
     }
   }
+  const composed = composeBatchLines(base.content, appliedPieces);
   const warnings = [...runtime.warnings];
   if (base.hadUtf8DecodeErrors) warnings.push("Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8.");
   const dedupTotal = runtime.pieces.reduce((sum, piece) => sum + piece.autoFixes, 0);
   if (dedupTotal > 0) warnings.push(boundaryDedupWarning(dedupTotal));
-  await throwIfStrictInput(dedupeWarnings(warnings));
-  const composed = composeBatchLines(base.content, appliedPieces);
-  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.`);
+  try {
+    await throwIfStrictInput(dedupeWarnings(warnings));
+    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.`);
+    }
+  } catch (error) {
+    restoreBatchBypasses(runtime);
+    if (error instanceof Error) error.message = withAbortSuffix(error.message, runtime.display);
+    throw error;
   }
   if (composed === base.content) {
     const snapshotId = await safeSnapId(paths.absolutePath, "noop edit");
@@ -501,10 +575,24 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     currentRaw = await readFile(runtime.target, "utf-8");
   } catch (error) {
     if (errCode(error) !== "ENOENT") throw error;
-    throw new Error(`[E_BATCH_ABORTED] Batch ${runtime.display} aborted: the file was deleted after the batch started; nothing was written.`);
+    restoreBatchBypasses(runtime);
+    throw new Error(`[E_OP_ABORTED] Batch ${runtime.display} aborted: the file was deleted after the batch started.`);
   }
   if (toLF(stripBOM(currentRaw).text) !== base.content) {
-    throw new Error(`[E_BATCH_ABORTED] Batch ${runtime.display} aborted: the file changed after the batch started; nothing was written. Call read for fresh anchors and retry.`);
+    restoreBatchBypasses(runtime);
+    throw new Error(`[E_OP_ABORTED] Batch ${runtime.display} aborted: the file changed after the batch started. Call read for fresh anchors and retry.`);
+  }
+  const preflightSpans = appliedPieces.map((piece) => ({ start: piece.start - 1, end: piece.end - 1, replacementCount: piece.newLines.length }));
+  try {
+    await lineHashes(composed, runtime.target, {
+      content: base.content,
+      hashes: base.hashes,
+      spans: preflightSpans,
+    }, undefined, false, true);
+  } catch (error) {
+    restoreBatchBypasses(runtime);
+    if (error instanceof Error) error.message = withAbortSuffix(error.message, runtime.display);
+    throw error;
   }
   const undo = await saveUndo(runtime.target, {
     content: base.content,
@@ -514,23 +602,32 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     resultContent: composed,
   });
   if (!undo.persisted) {
-    throw new Error(`[E_UNDO_UNAVAILABLE] Could not persist undo history; the edit was not applied and ${paths.displayPath} is unchanged.`);
+    restoreBatchBypasses(runtime);
+    throw new Error(`[E_UNDO_UNAVAILABLE] Could not persist undo history for ${paths.displayPath}. Aborts batch ${runtime.display}.`);
   }
   try {
     abortIf(signal);
     await writeAtomic(paths.absolutePath, base.bom + restoreEndings(composed, base.ending), base.identity);
   } catch (error) {
     await undo.restore();
+    restoreBatchBypasses(runtime);
+    if (error instanceof Error) error.message = withAbortSuffix(error.message, runtime.display);
     throw error;
   }
   clearBoundaryBypass(runtime.target);
   const updatedSnapshotId = await safeSnapId(paths.absolutePath, "post-edit");
   const spans = appliedPieces.map((piece) => ({ start: piece.start - 1, end: piece.end - 1, replacementCount: piece.newLines.length }));
-  const resultHashes = await lineHashes(composed, runtime.target, {
-    content: base.content,
-    hashes: base.hashes,
-    spans,
-  });
+  let resultHashes: string[];
+  try {
+    resultHashes = await lineHashes(composed, runtime.target, {
+      content: base.content,
+      hashes: base.hashes,
+      spans,
+    });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`${detail} File was written; anchor finalization failed. One undo reverts. Call read for fresh anchors.`);
+  }
   const range = changedRange(base.content, composed);
   let added = 0;
   let removed = 0;

package/src/commit.ts

@@ -1,5 +1,6 @@
+import { readFile } from "fs/promises";
 import type { PipelineResult } from "./replace";
-import { abortIf } from "./utils";
+import { abortIf, errCode, splitLines } from "./utils";
 import { DEDUP_ANCHOR } from "./constants";
 import { HASH_SEP } from "./hashline";
 import { buildChanged, buildNoop, type RMeta, type TResult } from "./replace-response";
@@ -10,8 +11,7 @@ import { writeAtomic } from "./fs-write";
 import { servedHashesFromDiff, buildServedMap } from "./served";
 import { lineHashes } from "./hashline";
 import { hashSpan } from "./replace";
-import { restoreEndings } from "./normalize";
-import { splitLines } from "./utils";
+import { restoreEndings, stripBOM, toLF } from "./normalize";
 import { markServed as markServedScoped } from "./anchor-registry";
 export interface CommitMeta {
   editAnchors?: [string, string];
@@ -71,6 +71,22 @@ 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 error;
+  }
+  if (currentRaw === undefined) {
+    throw new Error(`[E_OP_ABORTED] Edit aborted: the file was deleted after the edit started.`);
+  }
+  if (toLF(stripBOM(currentRaw).text) !== pipe.originalNormalized) {
+    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, {
     content: pipe.originalNormalized,
     bom: pipe.bom,
@@ -80,7 +96,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   });
   if (!undo.persisted) {
     throw new Error(
-      `[E_UNDO_UNAVAILABLE] Could not persist undo history; the edit was not applied and ${path} is unchanged.`
+      `[E_UNDO_UNAVAILABLE] Could not persist undo history for ${path}.`
     );
   }
   try {
@@ -109,13 +125,19 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   const span = meta.editAnchors ? hashSpan(pipe.originalHashes, meta.editAnchors[0], meta.editAnchors[1]) : undefined;
   const resultCount = splitLines(pipe.result).length;
   const replacementCount = span ? resultCount - (pipe.originalHashes.length - (span[1] - span[0] + 1)) : 0;
-  const resultHashes = pipe.result === pipe.originalNormalized
-    ? pipe.originalHashes
-    : await lineHashes(pipe.result, mutationTargetPath, {
+  let resultHashes: string[];
+  try {
+    resultHashes = pipe.result === pipe.originalNormalized
+      ? pipe.originalHashes
+      : await lineHashes(pipe.result, mutationTargetPath, {
         content: pipe.originalNormalized,
         hashes: pipe.originalHashes,
         spans: span ? [{ start: span[0], end: span[1], replacementCount }] : undefined,
       });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`${detail} File was written; anchor finalization failed. One undo reverts. Call read for fresh anchors.`);
+  }
   const successInput = {
     path,
     originalNormalized: pipe.originalNormalized,